diff --git a/mailcow/src/mailcow-dockerized/data/web/lang/lang.cs.json b/mailcow/src/mailcow-dockerized/data/web/lang/lang.cs.json
index dccdc22..5299f10 100644
--- a/mailcow/src/mailcow-dockerized/data/web/lang/lang.cs.json
+++ b/mailcow/src/mailcow-dockerized/data/web/lang/lang.cs.json
@@ -4,17 +4,23 @@
         "app_passwds": "Hesla aplikací",
         "bcc_maps": "BCC mapy",
         "delimiter_action": "Zacházení s označkovanou poštou",
+        "domain_desc": "Změnit popis domény",
+        "domain_relayhost": "Změnit předávající server pro doménu",
         "eas_reset": "Resetování EAS zařízení",
         "extend_sender_acl": "Rozšiřování ACL odesílatele o externí adresy",
         "filters": "Filtry",
         "login_as": "Přihlásit se jako uživatel",
+        "mailbox_relayhost": "Změnit předávající server pro schránku",
         "prohibited": "Zakázáno z důvodu ACL",
+        "protocol_access": "Upravit povolené protokoly",
         "pushover": "Pushover",
         "quarantine": "Karanténa",
         "quarantine_attachments": "Přílohy v karanténě",
+        "quarantine_category": "Změnit kategorii oznámení karantény",
         "quarantine_notification": "Upozornění z karantény",
         "ratelimit": "Omezení provozu",
         "recipient_maps": "Mapy příjemců",
+        "smtp_ip_access": "Spravovat povolené hostitele pro SMTP",
         "sogo_access": "Správa přístupu do SOGo",
         "sogo_profile_reset": "Resetování profilu SOGo",
         "spam_alias": "Dočasné aliasy",
@@ -38,12 +44,13 @@
         "app_password": "Přidat heslo aplikace",
         "automap": "Pokusit se automaticky mapovat složky (\"Sent items\", \"Sent\" => \"Sent\" atd.)",
         "backup_mx_options": "Možnosti záložního MX",
+        "bcc_dest_format": "Cíl kopie musí být jedna platná email adresa. Pokud potřebujete posílat kopie na více adres, vytvořte Alias a použijte jej zde.",
         "comment_info": "Soukromý komentář se nezobrazí uživateli; veřejný komentář se zobrazí jako nápověda při zastavení se kurzorem v přehledu uživatelů",
         "custom_params": "Vlastní parametry",
         "custom_params_hint": "Správně: --param=xy, špatně: --param xy",
-        "delete1": "Odstranit ze zdroje po dokončení",
-        "delete2": "Smazat zprávy v cíli, které nejsou ve zdroji",
-        "delete2duplicates": "Odstranit duplicity v cílovém místě",
+        "delete1": "Odstranit ze zdrojové schránky, po dokončení přenosu",
+        "delete2": "Odstranit zprávy v cílové schránce, pokud nejsou ve zdrojové",
+        "delete2duplicates": "Odstranit duplicity v cílové schránce",
         "description": "Popis",
         "destination": "Cíl",
         "disable_login": "Zakázat přihlášení (ale stále přijímat poštu)",
@@ -88,14 +95,14 @@
         "sieve_desc": "Krátký popis",
         "sieve_type": "Typ filtru",
         "skipcrossduplicates": "Přeskočit duplicitní zprávy (\"první přijde, první mele\")",
-        "subscribeall": "Odebírat všechny složky",
+        "subscribeall": "Synchronizovat všechny složky",
         "syncjob": "Přidat synchronizační úlohu",
         "syncjob_hint": "Upozornění: Heslo bude uloženo jako prostý text!",
         "target_address": "Cílové adresy",
         "target_address_info": "<small>Kompletní email adresa/y (oddělené čárkami).</small>",
         "target_domain": "Cílová doména",
-        "timeout1": "Časový limit pro připojení ke vzdálenému hostiteli",
-        "timeout2": "Časový limit pro připojení k lokálnímu hostiteli",
+        "timeout1": "Časový limit pro připojení ke vzdálenému serveru",
+        "timeout2": "Časový limit pro připojení k lokálnímu serveru",
         "username": "Uživatelské jméno",
         "validate": "Ověřit",
         "validation_success": "Úspěšně ověřeno"
@@ -110,7 +117,7 @@
         "add": "Přidat",
         "add_admin": "Přidat správce",
         "add_domain_admin": "Přidat správce domény",
-        "add_forwarding_host": "Přidat předávajícího hostitele",
+        "add_forwarding_host": "Přidat předávající server",
         "add_relayhost": "Přidat transport podle odesílatele",
         "add_relayhost_hint": "Pozor: přihlašovací údaje se ukládají jako prostý text.",
         "add_row": "Přidat řádek",
@@ -121,20 +128,25 @@
         "admin": "Správce",
         "admin_details": "Upravit správce",
         "admin_domains": "Přidělené domény",
+        "admins": "Administrátoři",
+        "admins_ldap": "LDAP Administrátoři",
         "advanced_settings": "Pokročilá nastavení",
         "api_allow_from": "Povolit přístup k API z těchto IP adres (oddělte čárkou nebo řádkem)",
-        "api_info": "API je stále ve vývoji.",
+        "api_info": "Dokumentaci naleznete na <a href=\"/api\">/api</a>",
         "api_key": "API klíč",
+        "api_read_only": "Přístup pouze pro čtení",
+        "api_read_write": "Přístup i se zápisem",
         "api_skip_ip_check": "Vynechat ověření IP adresy pro API",
         "app_links": "Odkazy na aplikace",
         "app_name": "Název aplikace",
-        "apps_name": "Hlavička aplikací (\"mailcow Apps\")",
+        "apps_name": "\"mailcow Apps\" název",
         "arrival_time": "Čas zařazení do fronty (čas na serveru)",
         "authed_user": "Přihlášený uživatel",
         "ays": "Opravdu chcete pokračovat?",
         "ban_list_info": "Seznam blokovaných IP adres je zobrazen níže: <b>síť (zbývající čas blokování) - [akce]</b>.<br />IP adresy zařazené pro odblokování budou z aktivního seznamu odebrány během několika sekund.<br />Červeně označené položky jsou pernamentní bloky z blacklistu.",
         "change_logo": "Změnit logo",
         "configuration": "Nastavení",
+        "convert_html_to_text": "Převést HTML do prostého textu",
         "credentials_transport_warning": "<b>Upozornění</b>: Přidání položky do transportní mapy aktualizuje také přihlašovací údaje všech záznamů s odpovídajícím skokem.",
         "customer_id": "ID zákazníka",
         "customize": "Přizpůsobení",
@@ -150,10 +162,12 @@
         "dkim_key_unused": "Klíč nepoužitý",
         "dkim_key_valid": "Klíč je platný",
         "dkim_keys": "ARC/DKIM klíče",
+        "dkim_overwrite_key": "Přepsat existující DKIM klíč",
         "dkim_private_key": "Soukromý klíč",
-        "dkim_to": "Komu",
-        "dkim_to_title": "Cílová doména/y - bude přepsáno",
+        "dkim_to": "Do",
+        "dkim_to_title": "Cílová doména/y - údaje budou přepsány",
         "domain": "Doména",
+        "domain_admin": "Administrátor domény",
         "domain_admins": "Správci domén",
         "domain_s": "Doména/y",
         "duplicate": "Duplikovat",
@@ -163,18 +177,20 @@
         "excludes": "Vyloučit tyto příjemce",
         "f2b_ban_time": "Doba blokování (s)",
         "f2b_blacklist": "Sítě/hostitelé na blacklistu",
+        "f2b_filter": "Regex filtre",
         "f2b_list_info": "Síť nebo hostitelé na blacklistu mají vždy větší váhu než položky na whitelistu. Blacklist se sestavuje vždy při startu kontejneru.",
         "f2b_max_attempts": "Max. pokusů",
         "f2b_netban_ipv4": "Rozsah IPv4 podsítě k zablokování (8-32)",
         "f2b_netban_ipv6": "Rozsah IPv6 podsítě k zablokování (8-128)",
-        "f2b_parameters": "Nastavení Fail2ban",
+        "f2b_parameters": "Parametry automatického firewallu",
+        "f2b_regex_info": "Záznamy které se berou v úvahu: SOGo, Postfix, Dovecot, PHP-FPM.",
         "f2b_retry_window": "Časový horizont pro maximum pokusů (s)",
         "f2b_whitelist": "Sítě/hostitelé na whitelistu",
         "filter_table": "Tabulka filtrů",
         "flush_queue": "Vyprázdnit frontu (opětovně doručit)",
-        "forwarding_hosts": "Předávající hostitelé",
-        "forwarding_hosts_add_hint": "Lze zadat IPv4/IPv6 adresy, sítě ve formátu CIDR, názvy hostitelů (budou převedeny na IP adresy) nebo názvy domén (budou převedeny na IP pomocí SPF záznamů, příp. MX záznamů).",
-        "forwarding_hosts_hint": "Příchozí zprávy od zde uvedených hostitelů jsou bezpodmínečně přijaty. U těchto hostitelů se nekontroluje DNSBL a nepoužije greylisting. Spam od těchto hostitelů se nikdy neodmítá, ale občas může skončit ve složce se spamem. Nejčastěji se zde uvádějí poštovní servery, jež předávají příchozí e-maily na tento poštovní server.",
+        "forwarding_hosts": "Předávající servery",
+        "forwarding_hosts_add_hint": "Lze zadat IPv4/IPv6 adresy, sítě ve formátu CIDR, názvy serverů (budou převedeny na IP adresy) nebo názvy domén (budou převedeny na IP pomocí SPF záznamů, příp. MX záznamů).",
+        "forwarding_hosts_hint": "Příchozí zprávy od zde uvedených serverů jsou bezpodmínečně přijaty. U těchto serverů se nekontroluje DNSBL a nepoužije greylisting. Spam od těchto serverů se nikdy neodmítá, ale občas může skončit ve složce se spamem. Nejčastěji se zde uvádějí poštovní servery, jež předávají příchozí e-maily na tento poštovní server.",
         "from": "Od",
         "generate": "generovat",
         "guid": "GUID - unikátní ID licence",
@@ -182,6 +198,7 @@
         "hash_remove_info": "Odebrání hashe omezení provozu (pokud stále existuje) zcela vyresetuje jeho počítadlo.<br>\r\n  Každý hash je označen jinou barvou.",
         "help_text": "Přepsat text nápovědy pod přihlašovacím formulářem (HTML povoleno)",
         "host": "Hostitel",
+        "html": "HTML",
         "import": "Importovat",
         "import_private_key": "Importovat soukromý klíč",
         "in_use_by": "Používáno",
@@ -189,10 +206,12 @@
         "include_exclude": "Zahrnout/Vyloučit",
         "include_exclude_info": "Ve výchozím nastavení (bez výběru), jsou adresovány <b>všechny poštovní schránky</b>",
         "includes": "Zahrnout tyto přijemce",
+        "is_mx_based": "Na základě MX",
         "last_applied": "Naposledy použité",
         "license_info": "Licence není povinná, pomůžete však dalšímu vývoji.<br><a href=\"https://www.servercow.de/mailcow?lang=en#sal\" target=\"_blank\" alt=\"SAL order\">Registrujte si své GUID</a>, nebo si <a href=\"https://www.servercow.de/mailcow?lang=en#support\" target=\"_blank\" alt=\"Support order\">zaplaťte podporu pro svou instalaci mailcow.</a>",
         "link": "Odkaz",
         "loading": "Prosím čekejte...",
+        "login_time": "Čas přihlášení",
         "logo_info": "Obrázek bude zmenšen na výšku 40 pixelů pro horní navigační lištu a na max. šířku 250 pixelů pro úvodní stránku.",
         "lookup_mx": "Ověřit cíl proti MX záznamu (.outlook.com bude směrovat všechnu poštu pro MX *.outlook.com přes tento uzel)",
         "main_name": "Název webu (\"mailcow UI\")",
@@ -204,13 +223,23 @@
         "no_active_bans": "Žádná aktivní blokování",
         "no_new_rows": "Žádné další řádky nejsou k dispozici",
         "no_record": "Žádný záznam",
+        "oauth2_add_client": "Přidat OAuth2 klienta",
+        "oauth2_apps": "OAuth2 Aplikace",
         "oauth2_client_id": "ID klienta",
         "oauth2_client_secret": "Tajný klíč klienta",
         "oauth2_info": "Implementace OAuth2 podporuje přidělení typu \"Authorization Code\" a vydává tokeny k obnovení.<br>\r\nServer vydává tokeny k obnovení automaticky, jakmile byl předchozí token použit.<br><br>\r\n→ Výchozím rozsahem je <i>profil</i>. Ověření přes OAuth2 mohou využít jen uživatelé poštovních schránek. Je-li rozsah vynechán, použije se <i>profil</i>.<br>\r\n→ Klient je povinen uvést parametr <i>state</i> spolu s požadavkem na ověření.<br><br>\r\nCesty API pro požadavky na ověření OAuth2: <br>\r\n<ul>\r\n  <li>Koncový bod pro ověření: <code>/oauth/authorize</code></li>\r\n  <li>Koncový bod pro token: <code>/oauth/token</code></li>\r\n  <li>Stránka zdroje:  <code>/oauth/profile</code></li>\r\n</ul>\r\nDojde-li ke znovuvytvoření tajného klíče klienta, nedojde ke zneplatnění stávajícíh ověřovacích kódů, nebude však už možné obnovit jejich token.<br><br>\r\nOdvoláním klientského tokenů okamžitě ukončíte všechny aktivní relace a klienti se budou muset znovu přihlásit.",
         "oauth2_redirect_uri": "URI přesměrování",
         "oauth2_renew_secret": "Vytvořit nový tajný klíč",
         "oauth2_revoke_tokens": "Odvolat všechny klientské tokeny",
+        "optional": "volitelné",
         "password": "Heslo",
+        "password_length": "Délka hesla",
+        "password_policy": "Politika hesel",
+        "password_policy_chars": "Musí obsahovat nejméně jedno písmeno",
+        "password_policy_length": "Minimální délka hesla je %d",
+        "password_policy_lowerupper": "Musí obsahovat malé a velké písmeno",
+        "password_policy_numbers": "Musí obsahovat nejméně jedno číslo",
+        "password_policy_special_chars": "Musí obsahovat speciální znak",
         "password_repeat": "Potvrzení nového hesla (opakujte)",
         "priority": "Priorita",
         "private_key": "Soukromý klíč",
@@ -218,6 +247,7 @@
         "quarantine_bcc": "Odeslat kopii (BCC) všech upozornění tomuto adresátu:<br><small>Jinak nechtte nevyplněno. <b>Nepodepsáno, nekontrolováno - volte raději jen místní adresáty.</b></small>",
         "quarantine_exclude_domains": "Vyloučené domény a doménové aliasy",
         "quarantine_max_age": "Maximální stáří ve dnech<br><small>Hodnota musí být rovna nebo větší než 1 den.</small>",
+        "quarantine_max_score": "Neposílat notifikace pokud je spam skóre větší než hodnota:<br><small>Výchozí je 9999.0</small>",
         "quarantine_max_size": "Maximální velikost v MiB (větší prvky budou smazány)<br />0 <b>neznamená</b> neomezeno.",
         "quarantine_notification_html": "Šablona upozornění:<br><small>Ponechte prázdné, aby se obnovila výchozí šablona.</small>",
         "quarantine_notification_sender": "Odesílatel upozornění",
@@ -231,9 +261,9 @@
         "queue_deliver_mail": "Doručit",
         "queue_hold_mail": "Zadržet",
         "queue_manager": "Správce fronty",
+        "queue_show_message": "Zobrazit zprávu",
         "queue_unban": "odblokovat",
         "queue_unhold_mail": "Propustit",
-        "queue_show_message": "Zobrazit zprávu",
         "quota_notification_html": "Šablona upozornění:<br><small>Ponechte prázdné, aby se obnovila výchozí šablona.</small>",
         "quota_notification_sender": "Odesílatel upozornění",
         "quota_notification_subject": "Předmět upozornění",
@@ -249,6 +279,7 @@
         "regen_api_key": "Generovat API klíč",
         "regex_maps": "Mapy regulárních výrazů",
         "relay_from": "Adresa \"Od:\"",
+        "relay_rcpt": "\"Komu:\" adresa",
         "relay_run": "Provést test",
         "relayhosts": "Transporty podle odesílatele",
         "relayhosts_hint": "Zde definujte transporty podle odesílatele, jež pak můžete použít v nastavení domény.<br>\r\nProtokol transportu je vždy \"smtp:\". Bere se v potaz uživatelské nastavení odchozího TLS.",
@@ -266,6 +297,7 @@
         "rsettings_preset_1": "Pro přihlášené uživatele vypnout vše kromě DKIM a omezení provozu",
         "rsettings_preset_2": "Postmasteři chtějí dostávat spam",
         "rsettings_preset_3": "Povolit jen určité odesílatele pro schránku (např. jen interní schránka)",
+        "rsettings_preset_4": "Deaktivujte Rspamd pro doménu",
         "rspamd-com_settings": "<a href=\"https://rspamd.com/doc/configuration/settings.html#settings-structure\" target=\"_blank\">Rspamd dokumentace</a>\r\n  - Název nastavení bude automaticky vygenerován, viz níže uvedené předvolby.",
         "rspamd_global_filters": "Mapa globálních filtrů",
         "rspamd_global_filters_agree": "Budu opatrný!",
@@ -277,10 +309,12 @@
         "search_domain_da": "Hledat domény",
         "send": "Odeslat",
         "sender": "Odesílatel",
+        "service": "Služba",
         "service_id": "ID podpory",
         "source": "Zdroj",
         "spamfilter": "Filtr spamu",
         "subject": "Předmět",
+        "success": "Úspěch",
         "sys_mails": "Systémové zprávy",
         "text": "Text",
         "time": "Čas",
@@ -289,6 +323,7 @@
         "to_top": "Zpět na začátek",
         "transport_dest_format": "Formát: example.org, .example.org, *, box@example.org (vícero položek lze oddělit čárkou)",
         "transport_maps": "Transportní mapy",
+        "transport_test_rcpt_info": "&#8226; Na otestování odchozí pošty je možné použít null@hosted.mailcow.de jako adresáta",
         "transports_hint": "→ Položka transportní mapy <b>přebíjí</b> transportní mapu podle odesílatele</b>.<br>\r\n→ Uživatelské nastavení odchozího TLS se ignoruje a lze je výhradně vynutit mapováním TLS pravidel.<br>\r\n→ Protokol transportu je vždy \"smtp:\".<br>\r\n→ Adresy, jež odpovídají výrazu \"/localhost$/\", se vždy předají přes \"local:\", takže nejsou zahrnuty do definice cíle \"*\".<br>\r\n→ Pro stanovení přihlašovacích údajů dalšího skoku, např. \"[host]:25\", bude Postfix <b>vždy</b> hledat nejdříve \"host\" a teprve pak \"[host]:25\". Kvůli tomu nelze použít současně \"host\" a \"[host]:25\"",
         "ui_footer": "Pata stránka (HTML povoleno)",
         "ui_header_announcement": "Oznámení",
@@ -297,9 +332,9 @@
         "ui_header_announcement_help": "Oznámení se zobrazuje všem přihlášeným uživatelům a také na přihlašovací obrazovce.",
         "ui_header_announcement_select": "Druh oznámení",
         "ui_header_announcement_type": "Druh",
+        "ui_header_announcement_type_danger": "Velmi důležité",
         "ui_header_announcement_type_info": "Informace",
         "ui_header_announcement_type_warning": "Důležité",
-        "ui_header_announcement_type_danger": "Velmi důležité",
         "ui_texts": "Hlavička a texty UI",
         "unban_pending": "čeká na odblokování",
         "unchanged_if_empty": "Pokud se nemění, ponechte prázdné",
@@ -319,12 +354,13 @@
         "aliases_in_use": "Max. počet aliasů musí být větší nebo roven %d",
         "app_name_empty": "Název aplikace nemůže být prázdný",
         "app_passwd_id_invalid": "Neplatné heslo aplikace ID %s",
-        "bcc_empty": "BCC cíl nesmí být prázdný",
-        "bcc_exists": "BCC mapování %s již existuje pro typ %s",
-        "bcc_must_be_email": "BCC mapování %s není správná email adresa",
+        "bcc_empty": "Cíl kopie nesmí být prázdný",
+        "bcc_exists": "Skrytá kopie %s již existuje pro typ %s",
+        "bcc_must_be_email": "Cíl kopie %s není správná email adresa",
         "comment_too_long": "Moc dlouhý komentář, max. 160 znaků",
         "defquota_empty": "Výchozí kvóta schránky nesmí být 0.",
         "description_invalid": "Popis zdroje %s je neplatný",
+        "dkim_domain_or_sel_exists": "DKIM klíč pro \"%s\" existuje a nebude přepsán",
         "dkim_domain_or_sel_invalid": "DKIM nebo selektor doménu je neplatný: %s",
         "domain_cannot_match_hostname": "Doména a hostname nesmí být stejné",
         "domain_exists": "Doména %s již existuje",
@@ -334,6 +370,7 @@
         "domain_quota_m_in_use": "Kvóta domény musí být větší nebo rovna %s MiB",
         "extra_acl_invalid": "Externí adresa odesílatele \"%s\" je neplatná",
         "extra_acl_invalid_domain": "Externí adresa odesílatele \"%s\" má neplatnou doménu",
+        "fido2_verification_failed": "FIDO2 ověření selhalo: %s",
         "file_open_error": "Soubor nelze otevřít k zápisu",
         "filter_type": "Špatný typ filtru",
         "from_invalid": "Odesílatel nesmí být prázdný",
@@ -377,6 +414,7 @@
         "network_host_invalid": "Neplatná síť nebo hostitel: %s",
         "next_hop_interferes": "%s koliduje se skokem %s",
         "next_hop_interferes_any": "Existující skok koliduje s %s",
+        "nginx_reload_failed": "Nginx reload selhal: %s",
         "no_user_defined": "Žádný uživatel není definován",
         "object_exists": "Objekt %s již existuje",
         "object_is_not_numeric": "Hodnota %s není číslo",
@@ -394,6 +432,7 @@
         "redis_error": "Chyba Redis: %s",
         "relayhost_invalid": "Položky %s je neplatná",
         "release_send_failed": "Zprávu nelze propustit: %s",
+        "reset_f2b_regex": "Regex filtr se nepodařilo resetovat, zkuste to znovu nebo počkejte pár sekund a obnovte stránku.",
         "resource_invalid": "Název zdroje %s je neplatný",
         "rl_timeframe": "Nesprávný časový rámec omezení provozu",
         "rspamd_ui_pw_length": "Heslo pro Rspamd UI musí mít alespoň 6 znaků",
@@ -409,6 +448,7 @@
         "targetd_relay_domain": "Cílová doména %s je předávaná",
         "temp_error": "Dočasná chyba",
         "text_empty": "Text nesmí být prázdný",
+        "tfa_token_invalid": "Neplatný TFA token",
         "tls_policy_map_dest_invalid": "Cíl mapy pravidel je neplatný",
         "tls_policy_map_entry_exists": "Položka mapy TLS pravidel \"%s\" již existuje",
         "tls_policy_map_parameter_invalid": "Parametr pravidel TLS je neplatný",
@@ -427,29 +467,35 @@
         "chart_this_server": "Graf (tento server)",
         "containers_info": "Informace o kontejnerech",
         "disk_usage": "Využití disku",
+        "docs": "Dokumentace",
         "external_logs": "Externí logy",
         "history_all_servers": "Záznam (všechny servery)",
         "in_memory_logs": "Logy v paměti",
         "jvm_memory_solr": "Spotřeba paměti JVM",
+        "last_modified": "Naposledy změněn",
         "log_info": "<p><b>Logy v paměti</b> jsou shromažďovány v Redis seznamech a jsou oříznuty na LOG_LINES (%d) každou minutu, aby se nepřetěžoval server.\r\n  <br>Logy v paměti nemají být trvalé. Všechny aplikace, které logují do paměti, zároveň logují i do Docker služby podle nastavení logging driveru.\r\n  <br>Logy v paměti lze použít pro ladění drobných problémů s kontejnery.</p>\r\n  <p><b>Externí logy</b> jsou shromažďovány pomocí API dané aplikace.</p>\r\n  <p><b>Statické logy</b> jsou většinou logy činností, které nejsou zaznamenávány do Docker služby, ale přesto je dobré je schraňovat (výjimkou jsou logy API).</p>",
+        "login_time": "Čas",
         "logs": "Logy",
+        "online_users": "Uživatelů online",
         "restart_container": "Restartovat",
+        "service": "Služba",
+        "size": "Velikost",
         "solr_dead": "Solr se spouští, je vypnutý nebo spadl.",
-        "solr_docs": "Dokumentace",
-        "solr_last_modified": "Naposledy změněn",
-        "solr_size": "Velikost",
-        "solr_started_at": "Spuštěn",
         "solr_status": "Stav Solr",
-        "solr_uptime": "Doba běhu",
+        "started_at": "Spuštěn",
         "started_on": "Spuštěno",
         "static_logs": "Statické logy",
-        "system_containers": "Systém a kontejnery"
+        "success": "Úspěch",
+        "system_containers": "Systém a kontejnery",
+        "uptime": "Doba běhu",
+        "username": "Uživatelské meno"
     },
     "diagnostics": {
         "cname_from_a": "Hodnota odvozena z A/AAAA záznamu. Lze použít, pokud záznam ukazuje na správný zdroj.",
         "dns_records": "DNS záznamy",
         "dns_records_24hours": "Upozornění: Změnám v systému DNS může trvat až 24 hodin, než se zde správně zobrazí jejich aktuální stav. Můžete zde snadno zjistit, jak nastavit DNS záznamy a zda jsou všechny záznamy správně uloženy.",
         "dns_records_data": "Správný záznam",
+        "dns_records_docs": "Přečtěte si prosím <a target=\"_blank\" href=\"https://mailcow.github.io/mailcow-dockerized-docs/prerequisite-dns/\">dokumentaci</a>.",
         "dns_records_name": "Název",
         "dns_records_status": "Současný stav",
         "dns_records_type": "Typ",
@@ -457,19 +503,23 @@
     },
     "edit": {
         "active": "Aktivní",
+        "admin": "Upravit administrátora",
         "advanced_settings": "Pokročilá nastavení",
         "alias": "Upravit alias",
+        "allow_from_smtp": "Umožnit pouze těmto IP adresám používat <b>SMTP</b>",
+        "allow_from_smtp_info": "Nechte prázdné pro povolení všech odesílatelů.<br>IPv4/IPv6 adresy a sítě.",
+        "allowed_protocols": "Povolené protokoly",
         "app_name": "Název aplikace",
         "app_passwd": "Heslo aplikace",
         "automap": "Pokusit se automaticky mapovat složky (\"Sent items\", \"Sent\" => \"Sent\" atd.)",
         "backup_mx_options": "Možnosti záložního MX",
-        "bcc_dest_format": "BCC cíl musí být jedna platná email adresa.",
+        "bcc_dest_format": "Cíl kopie musí být jedna platná email adresa. Pokud potřebujete posílat kopie na více adres, vytvořte Alias a použijte jej zde.",
         "client_id": "ID klienta",
         "client_secret": "Tajný klíč klienta",
         "comment_info": "Soukromý komentář se nezobrazí uživateli; veřejný komentář se zobrazí jako nápověda při zastavení se kurzorem v přehledu uživatelů",
-        "delete1": "Odstranit ze zdroje po dokončení",
-        "delete2": "Smazat zprávy v cíli, které nejsou ve zdroji",
-        "delete2duplicates": "Odstranit duplicity v cílovém místě",
+        "delete1": "Odstranit ze zdrojové schránky, po dokončení přenosu",
+        "delete2": "Odstranit zprávy v cílové schránce, pokud nejsou ve zdrojové",
+        "delete2duplicates": "Odstranit duplicity v cílové schránce",
         "delete_ays": "Potvrďte odstranění.",
         "description": "Popis",
         "disable_login": "Zakázat přihlášení (ale stále přijímat poštu)",
@@ -493,8 +543,10 @@
         "hostname": "Jméno hostitele",
         "inactive": "Neaktivní",
         "kind": "Druh",
+        "lookup_mx": "Cíl je regulární výraz který se shoduje s MX záznamem (<code>.*google\\.com</code> směřuje veškerou poštu na MX které jsou cílem pro google.com přes tento skok)",
         "mailbox": "Úprava poštovní schránky",
         "mailbox_quota_def": "Výchozí kvóta schránky",
+        "mailbox_relayhost_info": "Aplikované jen na uživatelskou schránku a přímé aliasy, přepisuje předávající server domény.",
         "max_aliases": "Max. počet aliasů",
         "max_mailboxes": "Max. počet poštovních schránek",
         "max_quota": "Max. kvóta poštovní schránky (MiB)",
@@ -504,6 +556,7 @@
         "mins_interval": "Interval (min)",
         "multiple_bookings": "Vícenásobné rezervace",
         "nexthop": "Další skok",
+        "none_inherit": "Žádné / Podědit",
         "password": "Heslo",
         "password_repeat": "Potvrzení nového hesla (opakujte)",
         "previous": "Předchozí stránka",
@@ -519,6 +572,9 @@
         "pushover_vars": "Bez filtru odesílatelů se zpracují všechny příchozí zprávy.<br>Regulární výrazy i výslovné adresy lze zadat současně a budou zpracovány postupně, nezávisí na sobě.<br>Lze použít proměnné pro text a předmět upozornění (pozor na ochranu osobních údajů apod.)",
         "pushover_verify": "Ověřit přihlašovací údaje",
         "quota_mb": "Kvóta (MiB)",
+        "quota_warning_bcc": "Upozornění na kvótu BCC",
+        "quota_warning_bcc_info": "Upozornění budou poslány jako samostatné kopie následujícím příjemcům. Předmět bude doplněn o uživatelské jméno v závorkách, příklad: <code>Upozornění na kvótu (user@example.com)</code>.",
+        "ratelimit": "Omezení přenosu",
         "redirect_uri": "URL přesměrování/odvolání",
         "relay_all": "Předávání všech příjemců",
         "relay_all_info": "<small>Pokud se rozhodnete <b>nepředávat</b> všechny příjemce, musíte přidat prázdnou poštovní schránku pro každého příjemce, který se má předávat.</small>",
@@ -531,7 +587,7 @@
         "save": "Uložit změny",
         "scope": "Rozsah",
         "sender_acl": "Povolit odesílání jako",
-        "sender_acl_disabled": "↳ <span class=\"label label-danger\">Kontrola odesílatele vypnuta</span>",
+        "sender_acl_disabled": "<span class=\"label label-danger\">Kontrola odesílatele vypnuta</span>",
         "sender_acl_info": "Má-li uživatel schránky A dovoleno odesílat jako uživatel schránky B, nezobrazuje se adresa odesílatele B v seznamu \"Od\" v SOGo automaticky.<br>\r\n  Uživatel schránky A musí nejdříve v SOGo vytvořit pověření, jež umožní uživateli B vybrat svou adresu jako odesílatele. Tento mechanismus neplatí pro aliasy.",
         "sieve_desc": "Krátký popis",
         "sieve_type": "Typ filtru",
@@ -541,27 +597,44 @@
         "sogo_visible": "Alias dostupný v SOGo",
         "sogo_visible_info": "Tato volba určuje objekty, jež lze zobrazit v SOGo (sdílené nebo nesdílené aliasy, jež ukazuje alespoň na jednu schránku).",
         "spam_alias": "Vytvořit nebo změnit dočasné aliasy",
+        "spam_filter": "Spam filtr",
         "spam_policy": "Přidat nebo odebrat položky whitelistu/blacklistu",
         "spam_score": "Nastavte vlastní skóre spamu",
         "subfolder2": "Synchronizace do podsložky v cílovém umístění<br><small>(prázdné = nepoužívat podsložku)</small>",
         "syncjob": "Upravit synchronizační úlohu",
         "target_address": "Cílová adresa/y<br /> <small>(oddělte čárkou)</small>",
         "target_domain": "Cílová doména",
-        "timeout1": "Časový limit pro připojení ke vzdálenému hostiteli",
-        "timeout2": "Časový limit pro připojení k lokálnímu hostiteli",
+        "timeout1": "Časový limit pro připojení ke vzdálenému serveru",
+        "timeout2": "Časový limit pro připojení k lokálnímu serveru",
         "title": "Úprava objektu",
         "unchanged_if_empty": "Pokud se nemění, ponechte prázdné",
         "username": "Uživatelské jméno",
         "validate_save": "Ověřit a uložit"
     },
+    "fido2": {
+        "confirm": "Potvrdit",
+        "fido2_auth": "Přihlásit se přes FIDO2",
+        "fido2_success": "Zařízení úspěšně zaregistrované",
+        "fido2_validation_failed": "Ověření selhalo",
+        "fn": "Uživatelsky přívětivý název",
+        "known_ids": "Známe ID",
+        "none": "Vypnuto",
+        "register_status": "Stav registrace",
+        "rename": "Přejmenovat",
+        "set_fido2": "Registrovat FIDO2 zařízení",
+        "set_fn": "Nastavi uživatelsky přívětivý název",
+        "start_fido2_validation": "Spustit FIDO2 ověření"
+    },
     "footer": {
         "cancel": "Zrušit",
         "confirm_delete": "Potvdit smazání",
         "delete_now": "Smazat",
         "delete_these_items": "Prosím potvrďte změny objektu id:",
+        "hibp_check": "Ověřit heslo v databázi hacknutých hesel haveibeenpwned.com",
         "hibp_nok": "Nalezeno! Toto je potenciálně nebezpečné heslo!",
         "hibp_ok": "Nebyla nalezena žádná shoda.",
         "loading": "Prosím čekejte...",
+        "nothing_selected": "Není nic vybráno",
         "restart_container": "Restartovat kontejner",
         "restart_container_info": "<b>Důležité:</b> Šetrný restart může chvíli trvat, prosím čekejte...",
         "restart_now": "Restartovat nyní",
@@ -585,8 +658,10 @@
     },
     "login": {
         "delayed": "Přihlášení zpožděno o %s sekund.",
+        "fido2_webauthn": "FIDO2/WebAuthn",
         "login": "Přihlásit",
         "mobileconfig_info": "Ke stažení profilového souboru se přihlaste jako uživatel schránky.",
+        "other_logins": "Přihlášení klíčem",
         "password": "Heslo",
         "username": "Uživatelské jméno"
     },
@@ -596,7 +671,8 @@
         "active": "Aktivní",
         "add": "Přidat",
         "add_alias": "Přidat alias",
-        "add_bcc_entry": "Přidat BCC mapu",
+        "add_alias_expand": "Rozšířit alias o alias domény",
+        "add_bcc_entry": "Přidat skrytou kopii",
         "add_domain": "Přidat doménu",
         "add_domain_alias": "Přidat doménový alias",
         "add_domain_record_first": "Prosím nejdříve vytvořte doménu",
@@ -610,26 +686,31 @@
         "alias_domain_alias_hint": "Aliasy <b>neplatí</b> automaticky pro doménové aliasy. Alias <code>muj-alias@domena</code> <b>neplatí</b> pro <code>muj-alias@domena2</code> (kde \"domena2\" je imaginární doménový alias pro \"domena\").<br>K přesměrování pošty na externí schránku použijte SIEVE filtr (viz záložka \"Filtry\" nebo SOGo -> Forwarder).",
         "alias_domain_backupmx": "Doménový alias není aktivní pro předávanou doménu",
         "aliases": "Aliasy",
+        "all_domains": "Všechny domény",
+        "allow_from_smtp": "Umožnit pouze těmto IP adresám používat <b>SMTP</b>",
+        "allow_from_smtp_info": "Nechte prázdné pro povolení všech odesílatelů.<br>IPv4/IPv6 adresy a sítě.",
+        "allowed_protocols": "Povolené protokoly",
         "backup_mx": "Záložní MX",
         "bcc": "BCC",
-        "bcc_destination": "BCC cíl",
-        "bcc_destinations": "BCC cíl",
-        "bcc_info": "Mapa BCC se používá pro tiché předávání kopií všech zpráv na jinou adresu. Mapa příjemců se použije, pokud je místní cíl příjemcem zprávy.<br/>\r\n  Mapa odesílatelů podléhá obdobnému principu. Místní cíl nebude informován o neúspěšném doručení.",
-        "bcc_local_dest": "Místní cíl",
-        "bcc_map": "BCC mapování",
-        "bcc_map_type": "Typ BCC",
-        "bcc_maps": "BCC mapy",
-        "bcc_rcpt_map": "Mapa příjemců",
-        "bcc_sender_map": "Mapa odesílatelů",
-        "bcc_to_rcpt": "Přepnout na mapu příjemců",
-        "bcc_to_sender": "Přepnout na mapu odesílatelů",
-        "bcc_type": "Typ BCC",
+        "bcc_destination": "Cíl kopie",
+        "bcc_destinations": "Cíl kopií",
+        "bcc_info": "Skryté kopie (Mapa BCC) se používá pro tiché předávání kopií všech zpráv na jinou adresu. Při použití skryté kopie typu <i>Přijatý e-mail</i> budou přeposlány všechny maily směřující na dotyčnou adresu nebo doménu.\nU typu <i>Odeslaný e-mail</i> budou přeposlány všechny maily odeslané z dotyčné adresy nebo domény.\nPokud selže přeposlání na cílovou adresu, tak odesílatel o tom nebude informován.",
+        "bcc_local_dest": "Týká se",
+        "bcc_map": "Skrytá kopie",
+        "bcc_map_type": "Typ skryté kopie",
+        "bcc_maps": "Skryté kopie",
+        "bcc_rcpt_map": "Přijatý e-mail",
+        "bcc_sender_map": "Odeslaný e-mail",
+        "bcc_to_rcpt": "Přepnout typ na Přijatý e-mail",
+        "bcc_to_sender": "Přepnout typ na Odeslaný e-mail",
+        "bcc_type": "Typ skryté kopie",
         "booking_0": "Vždy volno",
         "booking_0_short": "Vždy volno",
         "booking_custom": "Omezeno na pevný počet rezervací",
         "booking_custom_short": "Pevný limit",
         "booking_lt0": "Neomezeno, ale po rezervaci se ukazuje jako obsazené",
         "booking_lt0_short": "Volný limit",
+        "catch_all": "Doménový koš",
         "daily": "Každý den",
         "deactivate": "Vypnout",
         "description": "Popis",
@@ -644,18 +725,23 @@
         "empty": "Žádné výsledky",
         "enable_x": "Zapnout",
         "excludes": "Vyloučené",
-        "filter_table": "Tabulka filtrů",
+        "filter_table": "Filtrovat tabulku",
         "filters": "Filtry",
         "fname": "Celé jméno",
+        "goto_ham": "Učit se jako <b>ham</b>",
+        "goto_spam": "Učit se jako <b>spam</b>",
         "hourly": "Každou hodinu",
         "in_use": "Obsazeno (%)",
         "inactive": "Neaktivní",
         "insert_preset": "Vložit ukázkovou položku \"%s\"",
         "kind": "Druh",
         "last_mail_login": "Poslední přihlášení",
+        "last_pw_change": "Naposledy změněno heslo",
         "last_run": "Naposledy spuštěno",
-        "last_run_reset": "Plánovat další",
+        "last_run_reset": "Znovu naplánovat",
         "mailbox": "Poštovní schránka",
+        "mailbox_defaults": "Výchozí nastavení",
+        "mailbox_defaults_info": "Definuje výchozí nastavení pro nové schránky",
         "mailbox_defquota": "Výchozí velikost schránky",
         "mailbox_quota": "Max. velikost schránky",
         "mailboxes": "Poštovní schránky",
@@ -666,11 +752,17 @@
         "no": "&#10005;",
         "no_record": "Žádný záznam pro objekt %s",
         "no_record_single": "Žádný záznam",
+        "open_logs": "Otevřít záznam",
         "owner": "Vlastník",
         "private_comment": "Soukromý komentář",
         "public_comment": "Veřejný komentář",
+        "q_add_header": "Složka nevyžádaná pošta",
+        "q_all": "Všechny kategorie",
+        "q_reject": "Odmítnuta",
+        "quarantine_category": "Kategorie oznámení karantény",
         "quarantine_notification": "Upozornění z karantény",
         "quick_actions": "Akce",
+        "recipient": "Přijatý e-mail",
         "recipient_map": "Mapa příjemce",
         "recipient_map_info": "Mapy příjemců slouží k nahrazení cílové adresy zprávy před doručením.",
         "recipient_map_new": "Nový přijemce",
@@ -681,6 +773,7 @@
         "remove": "Smazat",
         "resources": "Zdroje",
         "running": "Běží",
+        "sender": "Odeslaný e-mail",
         "set_postfilter": "Označit jako post-filtr)",
         "set_prefilter": "Označit jako pre-filtr",
         "sieve_info": "Můžete uložit více filtrů pro každého uživatele, ale současně může být aktivní pouze jeden prefilter a jeden postfilter.<br>\r\nKaždý filtr bude proveden v daném pořadí. Ani chyba při vykonávání skriptu nebo snaha o pozdržení nezastaví vykonání dalších skriptů.<br><br>Global sieve prefilter → Prefilter → Uživatelské skripty → Postfilter → Global sieve postfilter",
@@ -693,7 +786,6 @@
         "sieve_preset_7": "Přesměrovat a ponechat/zahodit",
         "sieve_preset_8": "Zahodit zprávu poslanou na alias, do něhož patří i odesílatel",
         "sieve_preset_header": "Vizte následující ukázková pravidla. Více informací na <a href=\"https://en.wikipedia.org/wiki/Sieve_(mail_filtering_language)\" target=\"_blank\">Wikipedii</a>.",
-        "sogo_allow_admin_hint": "Přihlásit se do SOGo jako správce může jen uživatel s existujícím profilem SOGo. Uživatel se musí do SOGo alespoň jednou přihlásit.",
         "sogo_visible": "Alias dostupný v SOGo",
         "sogo_visible_n": "Skrýt alias v SOGo",
         "sogo_visible_y": "Zobrazit alias v SOGo",
@@ -713,8 +805,8 @@
         "tls_map_parameters_info": "Prázdné nebo parametry, například: protocols=!SSLv2 ciphers=medium exclude=3DES",
         "tls_map_policy": "Pravidlo",
         "tls_policy_maps": "Mapy TLS pravidel",
-        "tls_policy_maps_info": "Tato mapa přepisuje pravidla odchozích TLS nezávisle na TLS nastavení uživatele.<br>\r\n  Pro více informací prosím prostudujte <a href=\"http://www.postfix.org/postconf.5.html#smtp_tls_policy_maps\" target=\"_blank\">dokumentaci k \"smtp_tls_policy_maps\"</a>.",
         "tls_policy_maps_enforced_tls": "Tato pravidla také přepisují chování pro schránky, jež mají nastaveno vynucené odchozí TLS spojení. Pokud zde nejsou žádná pravidla, tyto schránky použijí výchozí hodnoty nastavené v <code>smtp_tls_mandatory_protocols</code> a <code>smtp_tls_mandatory_ciphers</code>.",
+        "tls_policy_maps_info": "Tato mapa přepisuje pravidla odchozích TLS nezávisle na TLS nastavení uživatele.<br>\r\n  Pro více informací prosím prostudujte <a href=\"http://www.postfix.org/postconf.5.html#smtp_tls_policy_maps\" target=\"_blank\">dokumentaci k \"smtp_tls_policy_maps\"</a>.",
         "tls_policy_maps_long": "Přepisování pravidel odchozího TLS",
         "toggle_all": "Označit vše",
         "username": "Uživatelské jméno",
@@ -735,12 +827,16 @@
         "action": "Akce",
         "atts": "Přílohy",
         "check_hash": "Hledat hash na serveru VT",
+        "confirm": "Potvrdit",
         "confirm_delete": "Potvrdit smazání prvku.",
         "danger": "Nebezpečí",
+        "deliver_inbox": "Doručit do schránky",
         "disabled_by_config": "Funkce karanténa je momentálně vypnuta v nastavení systému.",
         "download_eml": "Stáhnout (.eml)",
         "empty": "Žádné výsledky",
         "high_danger": "Vysoké nebezpečí",
+        "info": "Informace",
+        "junk_folder": "Složka nevyžádaná pošta",
         "learn_spam_delete": "Naučit jako spam a smazat",
         "low_danger": "Malé nebezpečí",
         "medium_danger": "Střední nebezpečí",
@@ -748,30 +844,44 @@
         "notified": "Oznámeno",
         "qhandler_success": "Požadavek úspěšně přijat. Můžete nyní zavřít okno.",
         "qid": "Rspamd QID",
+        "qinfo": "Karanténní systém uloží odmítnutou poštu do databáze (odesílatel se <em>nedozví</em>, že pošta byla doručena) jakož i pošta, která bude jako kopie doručena do složky Nevyžádaná pošta. \r\n<br>\"Naučit jako spam a smazat\" naučí zprávu jako spam přes Bayesian theorem a současně vypočítá fuzzy hashes pro odmítnutí podobných zpráv v budoucnosti. \r\n<br> Prosím, berte na vědomí, že naučení více zpráv může být - záleží na vašem systému - časově náročné . <br> Položky na černé listině jsou z karantény vyloučeny.",
         "qitem": "Položka v karanténě",
         "quarantine": "Karanténa",
         "quick_actions": "Akce",
+        "quick_delete_link": "Odkaz na rychlé odstranění",
+        "quick_info_link": "Otevřít link pro info",
+        "quick_release_link": "Odkaz na rychlé propuštění",
         "rcpt": "Příjemce",
         "received": "Přijato",
         "recipients": "Příjemci",
         "refresh": "Obnovit",
+        "rejected": "odmítnuto",
         "release": "Propustit",
         "release_body": "Zpráva připojena jako příloha EML k této zprávě.",
         "release_subject": "Potenciálně škodlivá položka v karanténě %s",
         "remove": "Smazat",
+        "rewrite_subject": "Přepsat předmět",
         "rspamd_result": "Skóre Rspamd",
         "sender": "Odesílatel (SMTP)",
         "sender_header": "Odesílatel (hlavička \"From\")",
-        "quick_release_link": "Odkaz na rychlé propuštění",
-        "quick_delete_link": "Odkaz na rychlé odstranění",
+        "settings_info": "Maximální množství položek které se umístí do karantény: %s<br>Maximální velikost emailu: %s MiB",
         "show_item": "Zobrazit položku",
+        "spam": "Spam",
         "spam_score": "Skóre",
         "subj": "Předmět",
         "table_size": "Velikost tabulky",
         "table_size_show_n": "Zobrazit %s položek",
         "text_from_html_content": "Obsah (konvertované html)",
         "text_plain_content": "Obsah (text/plain)",
-        "toggle_all": "Označit vše"
+        "toggle_all": "Označit vše",
+        "type": "Typ"
+    },
+    "ratelimit": {
+	    "disabled": "Vypnuto",
+	    "second": "zpráv za sekundu",
+	    "minute": "zpráv za minutu",
+	    "hour": "zpráv za hodinu",
+	    "day": "zpráv za den"
     },
     "start": {
         "help": "Zobrazit/skrýt panel nápovědy",
@@ -813,7 +923,7 @@
         "domain_removed": "Doména %s odebrána",
         "dovecot_restart_success": "Dovecot byl úspěšně restartován",
         "eas_reset": "ActiveSync zařízení uživatele %s vyresetováno",
-        "f2b_modified": "Změny parametrů Fail2ban uloženy",
+        "f2b_modified": "Změny v parametrech automatického firewallu uloženy",
         "forwarding_host_added": "Předávající hostitel %s přidán",
         "forwarding_host_removed": "Předávající hostitel %s odebrán",
         "global_filter_written": "Filtr byl úspěšně zapsán",
@@ -828,7 +938,9 @@
         "mailbox_added": "Poštovní schránka %s přidána",
         "mailbox_modified": "Změny poštovní schránky %s uloženy",
         "mailbox_removed": "Poštovní schránka %s  odebrána",
+        "nginx_reloaded": "Nginx reload byl úspěšný",
         "object_modified": "Změny objektu %s uloženy",
+        "password_policy_saved": "Politika hesel byla úspěšně uložena",
         "pushover_settings_edited": "Nastavení Pushover uloženo, ověřte přihlašovací údaje.",
         "qlearn_spam": "Zpráva ID %s naučena jako spam a smazána",
         "queue_command_success": "Příkaz pro frontu úspěšně dokončen",
@@ -850,6 +962,7 @@
         "tls_policy_map_entry_saved": "Položka mapy TLS pravidel \"%s\" uložena",
         "ui_texts": "Změny UI textů uloženy",
         "upload_success": "Soubor úspěšně nahrán",
+        "verified_fido2_login": "Ověřené FIDO2 přihlášení",
         "verified_totp_login": "TOTP přihlášení ověřeno",
         "verified_u2f_login": "U2F přihlášení ověřeno",
         "verified_yotp_login": "Yubico OTP přihlášení ověřeno"
@@ -871,7 +984,8 @@
         "select": "Prosím vyberte...",
         "set_tfa": "Nastavení způsobu dvoufaktorového ověření",
         "start_u2f_validation": "Zahájit inicializaci",
-        "tfa": "Dvoufaktorové ověření",
+        "tfa": "Dvoufaktorové ověření (TFA)",
+        "tfa_token_invalid": "Neplatný TFA token",
         "totp": "Časově založené OTP (Google Authenticator, Authy apod.)",
         "u2f": "U2F ověření",
         "waiting_usb_auth": "<i>Čeká se na USB zařízení...</i><br><br>Prosím stiskněte tlačítko na svém U2F USB zařízení.",
@@ -900,9 +1014,11 @@
         "apple_connection_profile_complete": "Tento profil obsahuje parametry připojení k IMAP, SMTP, CalDAV (kalendáře) a CardDAV (kontakty) pro zařízení Apple.",
         "apple_connection_profile_mailonly": "Tento profil obsahuje parametry připojení k IMAP a SMTP pro zařízení Apple.",
         "change_password": "Změnit heslo",
+        "clear_recent_successful_connections": "Vymazat nedávné úspěšné přihlášení",
         "client_configuration": "Zobrazit průvodce nastavením e-mailových klientů a smartphonů",
         "create_app_passwd": "Vytvořit heslo aplikace",
         "create_syncjob": "Vytvořit novou synchronizační úlohu",
+        "created_on": "Vytvoreno",
         "daily": "Každý den",
         "day": "den",
         "delete_ays": "Potvrďte odstranění.",
@@ -914,22 +1030,33 @@
         "edit": "Upravit",
         "email": "Pošta",
         "email_and_dav": "Pošta, kalendáře a kontakty",
+        "empty": "Nejsou k dispozici žádné záznamy",
         "encryption": "Šifrování",
         "excludes": "Vyloučené",
         "expire_in": "Vyprší za",
+        "fido2_webauthn": "FIDO2/WebAuthn",
         "force_pw_update": "Pro přístup k groupware funkcím <b>musíte změnit heslo</b>.",
+        "from": "od",
         "generate": "vytvořit",
         "hour": "hodinu",
         "hourly": "Každou hodinu",
         "hours": "hodin",
         "in_use": "Obsazeno",
         "interval": "Interval",
-        "is_catch_all": "Catch-all pro doménu/y",
+        "is_catch_all": "Doménový koš",
         "last_mail_login": "Poslední přihlášení",
+        "last_pw_change": "Naposledy změněno heslo",
         "last_run": "Naposledy spuštěno",
+        "last_ui_login": "Poslední přihlášení do web rozhraní",
         "loading": "Načítá se...",
+        "login_history": "Historie přihlášení",
+        "mailbox": "Poštová schránka",
         "mailbox_details": "Podrobnosti poštovní schránky",
+        "mailbox_general": "Obecné",
+        "mailbox_settings": "Nastavení",
         "messages": "zpráv",
+        "month": "měsíc",
+        "months": "měsíce",
         "never": "Nikdy",
         "new_password": "Nové heslo",
         "new_password_description": "Požadavek: min. délka 6 znaků, písmena a čísla.",
@@ -937,6 +1064,8 @@
         "no_active_filter": "Není k dispozici žádný aktivní filtr",
         "no_last_login": "Žádný záznam o přihlášení",
         "no_record": "Žádný záznam",
+        "open_logs": "Otevřít záznam",
+        "open_webmail_sso": "Přihlaste se do webmailu",
         "password": "Heslo",
         "password_now": "Současné heslo (pro potvrzení změny)",
         "password_repeat": "Heslo (znovu)",
@@ -949,8 +1078,14 @@
         "pushover_title": "Předmět upozornění",
         "pushover_vars": "Bez filtru odesílatelů se zpracují všechny příchozí zprávy.<br>Regulární výrazy i výslovné adresy lze zadat současně a budou zpracovány postupně, nezávisí na sobě.<br>Lze použít proměnné pro text a předmět upozornění (pozor na ochranu osobních údajů apod.)",
         "pushover_verify": "Ověřit přihlašovací údaje",
+        "q_add_header": "Složka nevyžádaná pošta",
+        "q_all": "Všechny kategorie",
+        "q_reject": "Odmítnuta",
+        "quarantine_category": "Kategorie oznámení karantény",
+        "quarantine_category_info": "Kategorie oznámení \"Odmítnuta\" zahrnuje poštu která byla odmítnuta, a \"Nevyžádaná pošta\" zahrnuje oznámení o poště uložené do složky Nevyžádaná pošta.",
         "quarantine_notification": "Upozornění z karantény",
         "quarantine_notification_info": "Jakmile se upozornění odešle, budou příslušné položky vyznačeny jako \"upozorněné\" a nebude pro ně odesláno žádné další upozornění.",
+        "recent_successful_connections": "Nedávné úspěšné přihlášení",
         "remove": "Smazat",
         "running": "Běží",
         "save": "Uložit změny",
@@ -967,7 +1102,7 @@
         "spamfilter": "Filtr spamu",
         "spamfilter_behavior": "Hodnocení",
         "spamfilter_bl": "Seznam zakázaných adres (blacklist)",
-        "spamfilter_bl_desc": "Zakázané emailové adresy <b>budou vždy klasifikovány jako spam a odmítnuty</b>. Lze použít zástupné znaky (*). Filtr se použije pouze na přímé aliasy (s jednou cílovou poštovní schránkou), s výjimkou aliasů typu catch-all a samotné poštovní schránky.",
+        "spamfilter_bl_desc": "Zakázané emailové adresy <b>budou vždy klasifikovány jako spam a odmítnuty</b>. Lze použít zástupné znaky (*). Filtr se použije pouze na přímé aliasy (s jednou cílovou poštovní schránkou), s výjimkou doménových košů a samotné poštovní schránky.",
         "spamfilter_default_score": "Výchozí hodnoty:",
         "spamfilter_green": "Zelená: tato zpráva není spam",
         "spamfilter_hint": "První hodnota představuje \"nízké spam skóre\" a druhá \"vysoké spam skóre\".",
@@ -979,7 +1114,7 @@
         "spamfilter_table_remove": "smazat",
         "spamfilter_table_rule": "Pravidlo",
         "spamfilter_wl": "Seznam povolených adres (whitelist)",
-        "spamfilter_wl_desc": "Povolené emailové adresy <b>nebudou nikdy klasifikovány jako spam</b>. Lze použít zástupné znaky (*). Filtr se použije pouze na přímé aliasy (s jednou cílovou poštovní schránkou), s výjimkou aliasů typu catch-all a samotné poštovní schránky.",
+        "spamfilter_wl_desc": "Povolené emailové adresy <b>nebudou nikdy klasifikovány jako spam</b>. Lze použít zástupné znaky (*). Filtr se použije pouze na přímé aliasy (s jednou cílovou poštovní schránkou), s výjimkou doménových košů a samotné poštovní schránky.",
         "spamfilter_yellow": "Žlutá: tato zpráva může být spam, bude označena jako spam a přesunuta do složky nevyžádané pošty",
         "status": "Stav",
         "sync_jobs": "Synchronizační úlohy",
@@ -1001,7 +1136,9 @@
         "waiting": "Čekání",
         "week": "týden",
         "weekly": "Každý týden",
-        "weeks": "týdny"
+        "weeks": "týdny",
+        "year": "rok",
+        "years": "let"
     },
     "warning": {
         "cannot_delete_self": "Nelze smazat právě přihlášeného uživatele",
@@ -1010,6 +1147,7 @@
         "fuzzy_learn_error": "Chyba při učení Fuzzy hash: %s",
         "hash_not_found": "Hash nenalezen",
         "ip_invalid": "Přeskočena neplatná IP: %s",
+        "is_not_primary_alias": "Přeskočit ne-primární alias %s",
         "no_active_admin": "Nelze deaktivovat posledního aktivního správce",
         "quota_exceeded_scope": "Kvóta domény překročena: v této doméně lze vytvořit jen neomezené schránky.",
         "session_token": "Token formuláře není platný: Token mismatch",
diff --git a/mailcow/src/mailcow-dockerized/data/web/lang/lang.da.json b/mailcow/src/mailcow-dockerized/data/web/lang/lang.da.json
new file mode 100644
index 0000000..3b467a3
--- /dev/null
+++ b/mailcow/src/mailcow-dockerized/data/web/lang/lang.da.json
@@ -0,0 +1,1080 @@
+{
+    "acl": {
+        "alias_domains": "Tilføj kældenavn domæner",
+        "app_passwds": "Administrer app-adgangskoder",
+        "bcc_maps": "BCC kort",
+        "delimiter_action": "Afgrænsning handling",
+        "eas_reset": "Nulstil EAS endheder",
+        "extend_sender_acl": "Tillad at udvide afsenderens ACL med eksterne adresser",
+        "filters": "Filtre",
+        "login_as": "Login som mailboks bruger",
+        "prohibited": "Forbudt af ACL",
+        "protocol_access": "Ændre protokol adgang",
+        "pushover": "Pushover",
+        "quarantine": "Karantæneaktioner",
+        "quarantine_attachments": "Karantæne vedhæftede filer",
+        "quarantine_notification": "Skift karantænemeddelelser",
+        "ratelimit": "Satsgrænse",
+        "recipient_maps": "Modtagerkort",
+        "smtp_ip_access": "Skift tilladte værter til SMTP",
+        "sogo_access": "Tillad styring af SOGo-adgang",
+        "sogo_profile_reset": "Nulstil SOGo-profil",
+        "spam_alias": "Midlertidige aliasser",
+        "spam_policy": "Sortliste / hvidliste",
+        "spam_score": "Spam-score",
+        "syncjobs": "Synkroniser job",
+        "tls_policy": "TLS politik",
+        "unlimited_quota": "Ubegrænset quote for mailbokse",
+        "domain_desc": "Skift domæne beskrivelse",
+        "xmpp_admin": "Promover XMPP-bruger til administrator",
+        "xmpp_domain_access": "Konfigurer XMPP-domæneadgang",
+        "xmpp_mailbox_access": "Konfigurer XMPP-brugeradgang",
+        "xmpp_prefix": "Skift XMPP-underdomæne (præfiks)"
+    },
+    "add": {
+        "activate_filter_warn": "Alle andre filtre deaktiveres, når aktiv er markeret.",
+        "active": "Aktiv",
+        "add": "Tilføj",
+        "add_domain_only": "Tilføj kun domæne",
+        "add_domain_restart": "Tilføj domæne og genstart SOGo",
+        "alias_address": "Alias adresse (r)",
+        "alias_address_info": "<small>Fuld e-mail-adresse eller @ eksempel.com for at fange alle beskeder til et domæne (kommasepareret). <b> kun mailcow-domæner</b>.</small>",
+        "alias_domain": "Alias-domæne",
+        "alias_domain_info": "<small>Kun gyldige domænenavne (kommasepareret).</small>",
+        "app_name": "App navn",
+        "app_password": "Tilføj app-adgangskode",
+        "automap": "Prøv at automatisere mapper (\"Sendte emner\", \"Sendt\" => \"Sendt\" etc.)",
+        "backup_mx_options": "Relæindstillinger",
+        "comment_info": "En privat kommentar er ikke synlig for brugeren, mens en offentlig kommentar vises som et værktøjstip, når den svæver i brugeroversigten",
+        "custom_params": "Brugerdefinerede parametre",
+        "custom_params_hint": "Rigtigt: --param=xy, forkert: --param xy",
+        "delete1": "Slet fra kilden, når den er afsluttet",
+        "delete2": "Slet meddelelser på destinationen, der ikke er fra kilden",
+        "delete2duplicates": "Slet duplikater på destinationen",
+        "description": "Beskrivelse",
+        "destination": "Bestemmelsessted",
+        "disable_login": "Tillad ikke login (indgående mail accepteres stadig)",
+        "domain": "Domæne",
+        "domain_matches_hostname": "Domæne %s matcher værtsnavn",
+        "domain_quota_m": "Samlet domænekvote (Mb)",
+        "enc_method": "Krypteringsmetode",
+        "exclude": "Ekskluder objekter (regex)",
+        "full_name": "Fulde navn",
+        "gal": "Global adresseliste",
+        "gal_info": "GAL indeholder alle objekter i et domæne og kan ikke redigeres af nogen bruger. Information om ledig / optaget i SOGo mangler, hvis deaktiveret! <b> Genstart SOGo for at anvende ændringer. </b>",
+        "generate": "generere",
+        "goto_ham": "Lær som <span class=\"text-success\"><b>ham</b></span>",
+        "goto_null": "Kassér e-mail i stilhed",
+        "goto_spam": "Lær som <span class=\"text-danger\"><b>spam</b></span>",
+        "hostname": "Vært",
+        "inactive": "Inaktiv",
+        "kind": "slags",
+        "mailbox_quota_def": "Standardpostkassekvote",
+        "mailbox_quota_m": "Maks. kvote pr. postkasse (Mb)",
+        "mailbox_username": "Brugernavn (venstre del af en e-mail-adressen)",
+        "max_aliases": "Maks. mulige aliasser",
+        "max_mailboxes": "Maks. mulige postkasser",
+        "mins_interval": "Afstemningsinterval (minuter)",
+        "multiple_bookings": "Flere bookinger",
+        "nexthop": "Næste hop",
+        "password": "Kodeord",
+        "password_repeat": "Bekræft adgangskode (gentag)",
+        "port": "Port",
+        "post_domain_add": "SOGo-containeren, \"sogo-mailcow\", skal genstartes efter tilføjelse af et nyt domæne! <br> <br> Derudover skal domænernes DNS-konfiguration gennemgås. Når DNS-konfigurationen er godkendt, skal du genstarte \"acme-mailcow\" for automatisk at generere certifikater til dit nye domæne (autoconfig.&lt;domain&gt;, autodiscover.&lt;domain&gt;).<br>Dette trin er valgfrit og vil blive prøvet igen hver 24. time.",
+        "private_comment": "Privat kommentar",
+        "public_comment": "Offentlig kommentar",
+        "quota_mb": "Kvota (Mb)",
+        "relay_all": "Send alle modtagere videre",
+        "relay_all_info": "↪ Hvis du vælger <b> ikke </b> at videresende alle modtagere, skal du tilføje et (\"blind\") postkasse til hver enkelt modtager, der skal videresendes.",
+        "relay_domain": "Send dette domæne videre",
+        "relay_transport_info": "<div class=\"label label-info\">Info</div> Du kan definere transportkort til en tilpasset destination for dette domæne. Hvis ikke indstillet, foretages der et MX-opslag.",
+        "relay_unknown_only": "Videresend kun ikke-eksisterende postkasser. Eksisterende postkasser leveres lokalt.",
+        "relayhost_wrapped_tls_info": "Vær sød <b>ikke</b> at bruge TLS-indpakkede porte (bruges mest på port 465) .<br>\r\nBrug en ikke-pakket port, og udgiv STARTTLS. En TLS-politik til at håndhæve TLS kan oprettes i \"TLS policy maps\".",
+        "select": "Vælg venligst...",
+        "select_domain": "Vælg først et domæne",
+        "sieve_desc": "Kort beskrivelse",
+        "sieve_type": "Filtertype",
+        "skipcrossduplicates": "Spring duplikatbeskeder over mapper (først til mølle)",
+        "subscribeall": "Abonner på alle mapper",
+        "syncjob": "Tilføj synkroniseringsjob",
+        "syncjob_hint": "Vær opmærksom på, at adgangskoder skal gemmes som almindelig tekst!",
+        "target_address": "Gå til adresser",
+        "target_address_info": "<small>Fuld e-mail-adresser (komma-adskilt).</small>",
+        "target_domain": "Måldomæne",
+        "timeout1": "Timeout for forbindelse til ekstern vært",
+        "timeout2": "Timeout for forbindelse til lokal vært",
+        "username": "Brugernavn",
+        "validate": "Bekræft",
+        "validation_success": "Valideret med succes"
+    },
+    "admin": {
+        "access": "Adgang",
+        "action": "Handling",
+        "activate_api": "Aktivér API",
+        "activate_send": "Aktivér send knap",
+        "active": "Aktiv",
+        "active_rspamd_settings_map": "Kort over aktive indstillinger",
+        "add": "Tilføj",
+        "add_admin": "tilføj administrator",
+        "add_domain_admin": "tilføj domæne administrator",
+        "add_forwarding_host": "Tilføj videresendelsesvært",
+        "add_relayhost": "Tilføj afsenderafhængig transport",
+        "add_relayhost_hint": "Vær opmærksom på, at godkendelsesdata, hvis nogen, gemmes som almindelig tekst.",
+        "add_row": "Tilføj række",
+        "add_settings_rule": "Tilføj indstillingsregel",
+        "add_transport": "Tilføj transport",
+        "add_transports_hint": "Vær opmærksom på, at hvis nogen godkendelsesdata lagres gemmes det som almindelig tekst.",
+        "additional_rows": " yderligere rækker blev tilføjet",
+        "admin": "Administrator",
+        "admin_details": "Rediger administratoroplysninger",
+        "admin_domains": "Domænetildelinger",
+        "advanced_settings": "Advanceret indstillinger",
+        "api_allow_from": "Tillad API adgang fra disse IP'er/CIDR netværksnotationer",
+        "api_info": "API'en er et igangværende arbejde. Dokumentationen kan findes på <a href=\"/api\">/api</a>",
+        "api_key": "API nøgle",
+        "api_skip_ip_check": "Spring IP tjek over for API",
+        "app_links": "App links",
+        "app_name": "App navn",
+        "apps_name": "\"mailcow Apps\" navn",
+        "arrival_time": "Ankomst tid (server tid)",
+        "authed_user": "Auth. bruger",
+        "ays": "Er du sikker på, at du vil fortsætte?",
+        "ban_list_info": "Se en liste over forbudte IP'er nedenfor: <b>netværk (resterende forbudstid) - [handlinger]</b>.<br />IPs, der står i kø for at blive ikke-spærret, vil blive fjernet fra listen over aktive forbud inden for få sekunder.<br />Red etiketter angiver aktive permanente forbud ved sortlistning. Er du sikker på, at du vil fortsætte",
+        "change_logo": "Skift logo",
+        "configuration": "Konfiguration",
+        "credentials_transport_warning": "<b>Advarsel</b>: Tilføjelse af en ny transportkortpost opdaterer legitimationsoplysningerne for alle poster med en matchende nexthop-kolonne.",
+        "customer_id": "Kunde ID",
+        "customize": "Tilpas",
+        "delete_queue": "Slet alt",
+        "destination": "Bestemmelsessted",
+        "dkim_add_key": "Tilføj ARC/DKIM nøgle",
+        "dkim_domains_selector": "Vælger",
+        "dkim_domains_wo_keys": "Vælg domæner med manglende nøgler",
+        "dkim_from": "Fra",
+        "dkim_from_title": "Kildedomæne at kopiere data fra",
+        "dkim_key_length": "DKIM nøgle længde (bits)",
+        "dkim_key_missing": "Nøgle mangler",
+        "dkim_key_unused": "Nøgle ubrugt",
+        "dkim_key_valid": "Nøglen er gyldig",
+        "dkim_keys": "ARC/DKIM nøgler",
+        "dkim_overwrite_key": "Overskriv nuværende DKIM nøgle",
+        "dkim_private_key": "Privat nøgle",
+        "dkim_to": "Til",
+        "dkim_to_title": "Måldomæne (r) - vil blive overskrevet",
+        "domain": "Domæne",
+        "domain_admin": "Domæne administrator",
+        "domain_admins": "Domæne administrators",
+        "domain_s": "Domæne/r",
+        "duplicate": "Duplikere",
+        "duplicate_dkim": "Duplikere DKIM optegnelse",
+        "edit": "Redigere",
+        "empty": "Ingen resultater",
+        "excludes": "Ekskluderer disse modtagere",
+        "f2b_ban_time": "Udelukkelses tid (s)",
+        "f2b_blacklist": "Sortlistede netværk/værter",
+        "f2b_filter": "Regex filtre",
+        "f2b_list_info": "En sortlistet vært eller et netværk opvejer altid en hvidlisted eksistens. <b> Listeopdateringer tager nogle få sekunder at blive anvendt. </b> ",
+        "f2b_max_attempts": "Max. forsøg",
+        "f2b_netban_ipv4": "IPv4 subnet størrelse at anvende forbud mod (8-32)",
+        "f2b_netban_ipv6": "IPv6 subnet størrelse at anvende forbud mod (8-128)",
+        "f2b_parameters": "Fail2ban parametre",
+        "f2b_regex_info": "Logfiler taget i betragtning: SOGo, Postfix, Dovecot, PHP-FPM.",
+        "f2b_retry_window": "Genindlæs vindue om (s) for max. forsøg",
+        "f2b_whitelist": "Hvidlisted netværk/vært",
+        "filter_table": "Filtertabel",
+        "flush_queue": "Tøm kø",
+        "forwarding_hosts": "Videresendelse af værter",
+        "forwarding_hosts_add_hint": "Du kan enten angive IPv4 / IPv6-adresser, netværk i CIDR-notation, værtsnavne (som løses til IP-adresser) eller domænenavne (som løses til IP-adresser ved at spørge SPF-poster eller i mangel af MX-poster).",
+        "forwarding_hosts_hint": "Indgående beskeder accepteres ubetinget fra værter, der er anført her. Disse værter kontrolleres derefter ikke mod DNSBL'er eller udsættes for gråt notering. Spam modtaget fra dem afvises aldrig, men det kan eventuelt arkiveres i Junk-mappen. Den mest almindelige anvendelse til dette er at specificere mailservere, hvor du har oprettet en regel, der videresender indgående e-mails til din mailcow-server. ",
+        "from": "Fra",
+        "generate": "generere",
+        "guid": "GUID - entydigt forekomst-id",
+        "guid_and_license": "GUID & License",
+        "hash_remove_info": "Hvis du fjerner en ratelimit-hash (hvis den stadig findes), nulstilles tælleren fuldstændigt. <br>\r\n  Hver hash angives med en individuel farve.",
+        "help_text": "Tilsidesæt hjælp-teksten under loginmaske (HTML tilladt)",
+        "host": "Vært",
+        "html": "HTML(Hypertekstmarkeringssprog)",
+        "import": "Importere",
+        "import_private_key": "Importere privat nøgle",
+        "in_use_by": "I brug af",
+        "inactive": "Inaktiv",
+        "include_exclude": "Medtag/udeluk",
+        "include_exclude_info": "Som standard - uden markering er - <b>alle postkasser</b> adresseret",
+        "includes": "Medtag disse modtagere",
+        "last_applied": "Sidst anvendt",
+        "license_info": "En licens er ikke påkrævet, men hjælper videreudvikling. <br><a href=\"https://www.servercow.de/mailcow?lang=en#sal\" target=\"_blank\" alt=\"SAL order\">Registrer dit GUID her</a> or <a href=\"https://www.servercow.de/mailcow?lang=en#support\" target=\"_blank\" alt=\"Support order\">køb støtte til din mailcow installation.</a>",
+        "link": "Link",
+        "loading": "Vent venligst...",
+        "logo_info": "Dit billede skaleres til en højde på 40px for den øverste navigationslinje og en max. bredde på 250px for startsiden. Skalerbar grafik anbefales på det kraftigste.",
+        "lookup_mx": "Match destination mod MX (.outlook.com at dirigere alle e-mails, der er målrettet mod en MX *.outlook.com over dette hop)",
+        "main_name": "\"mailcow UI\" navn",
+        "merged_vars_hint": "Nedtonede rækker blev flettet fra <code>vars.(local.)inc.php</code> og kan ikke ændres.",
+        "message": "Besked",
+        "message_size": "Meddelelsesstørrelse",
+        "nexthop": "Næste hop",
+        "no": "&#10005;",
+        "no_active_bans": "Ingen aktive Udelukkelser",
+        "no_new_rows": "Ingen yderligere rækker tilgængelige",
+        "no_record": "Ingen post",
+        "oauth2_client_id": "Klient ID",
+        "oauth2_client_secret": "Klient hemmelighed",
+        "oauth2_info": "OAuth2-implementeringen understøtter tilskudstypen \"Authorization Code\" og udsteder tids-bestemte opdateringstoken.<br>\r\nServeren udsteder også automatisk nye opdateringstokens, når der er brugt et opdateringstoken.<br><br>\r\n→ Standardområdet er <i>profile</i>. Det er kun brugere af postkasser, der kan godkendes mod OAuth2. Hvis områdeparameteren udelades, falder den tilbage til <i>profile</i>.<br>\r\n→ Den <i>status</i> skal sendes af klienten som en del af godkendelsesanmodningen.<br><br>\r\nStier til anmodninger til OAuth2 API: <br>\r\n<ul>\r\n  <li>Godkendelsesslutpunkt: <code>/oauth/authorize</code></li>\r\n  <li>Token slutpunkt: <code>/oauth/token</code></li>\r\n  <li>Ressource side:  <code>/oauth/profile</code></li>\r\n</ul>\r\nRegenerering af klienthemmeligheden udløber ikke eksisterende autorisationskoder, men de fornyer ikke deres token.<br><br>\r\nTilbagekaldelse af klient-tokens vil medføre øjeblikkelig afslutning af alle aktive sessioner. Alle klienter skal godkende igen.",
+        "oauth2_redirect_uri": "Omdiriger URI",
+        "oauth2_renew_secret": "Generer ny klienthemmelighed",
+        "oauth2_revoke_tokens": "Tilbagekald alle klient-tokens",
+        "optional": "valgfri",
+        "password": "Kodeord",
+        "password_repeat": "Bekræftelsesadgangskode (gentag)",
+        "priority": "Prioritet",
+        "private_key": "Privat nøgle",
+        "quarantine": "Karantæne",
+        "quarantine_bcc": "Send en kopi af alle meddelelser (BCC) til denne modtager:<br><small>Lad være tom for at deaktivere. <b>Usigneret, ikke-markeret mail. Bør kun leveres internt.</b></small>",
+        "quarantine_exclude_domains": "Ekskluder domæner og alias-domæner",
+        "quarantine_max_age": "Maximum alder i dage<br><small>Værdien skal være lig med eller større end 1 dag.</small>",
+        "quarantine_max_size": "Maksimal størrelse i MiB (større elementer kasseres):<br><small>0 indikere <b>ikke</b> ubegrænset.</small>",
+        "quarantine_max_score": "Kassér besked, hvis spam-score for en mail er højere end denne værdi:<br><small>Standardindstillingen er 9999.0</small>",
+        "quarantine_notification_html": "Notifikations-e-mail-skabelon:<br><small>Lad det være tomt for at gendanne standardskabelonen.</small>",
+        "quarantine_notification_sender": "Notification email sender",
+        "quarantine_notification_subject": "Notification email subject",
+        "quarantine_redirect": "<b>Redirect all notifications</b> to this recipient:<br><small>Leave empty to disable. <b>Unsigned, unchecked mail. Should be delivered internally only.</b></small>",
+        "quarantine_release_format": "Format på frigivne genstande",
+        "quarantine_release_format_att": "Som vedhæftet fil",
+        "quarantine_release_format_raw": "Umodificeret original",
+        "quarantine_retention_size": "Tilbageholdelse pr. Postkasse:<br><small>0 angiver <b>inaktiv</b>.</small>",
+        "queue_ays": "Bekræft venligst, at du vil slette alle emner fra den aktuelle kø.",
+        "queue_deliver_mail": "Aflevere",
+        "queue_hold_mail": "Hold",
+        "queue_manager": "Køadministrator",
+        "queue_unban": "kø ikke udeluk",
+        "queue_unhold_mail": "Unhold",
+        "queue_show_message": "Vis besked",
+        "quota_notification_html": "Notifikations-e-mail-skabelon:<br><small>Lad det være tomt for at gendanne standardskabelonen.</small>",
+        "quota_notification_sender": "Afsender af underretnings-e-mail",
+        "quota_notification_subject": "Underretningens e-mail-emne",
+        "quota_notifications": "Kvotemeddelelser",
+        "quota_notifications_info": "Kvotemeddelelser sendes til brugerne en gang, når de krydser 80%, og en gang, når de krydser 95% forbrug.",
+        "quota_notifications_vars": "{{percent}} svarer til brugerens nuværende kvote<br>{{username}} er postkassens navn",
+        "r_active": "Aktive begrænsninger",
+        "r_inactive": "Inaktive begrænsninger",
+        "r_info": "Nedtonede / deaktiverede elementer på listen over aktive begrænsninger er ikke kendt som gyldige begrænsninger for mailcow og kan ikke flyttes. Ukendte begrænsninger indstilles alligevel i rækkefølge efter udseende. <br>Du kan tilføje nye elementer i <code>inc/vars.local.inc.php</code> for at kunne skifte dem.",
+        "rate_name": "Bedøm navn",
+        "recipients": "Modtagere",
+        "refresh": "Opdater",
+        "regen_api_key": "Genopret API-nøgle",
+        "regex_maps": "Regex kort",
+        "relay_from": "\"Fra:\" adresse",
+        "relay_run": "Kør test",
+        "relayhosts": "Afsenderafhængige transporter",
+        "relayhosts_hint": "Definer afsenderafhængige transporter, så de kan vælge dem i en konfigurationsdialog for domæner.<br>\r\n  Transporttjenesten er altid \"smtp:\" og vil derfor prøve TLS, når de tilbydes. Indpakket TLS (SMTPS) understøttes ikke. En brugeres individuelle indstilling for TLS-politik tages i betragtning.<br>\r\n  Påvirker udvalgte domæner inklusive aliasdomæner.",
+        "remove": "Fjern",
+        "remove_row": "Fjern række",
+        "reset_default": "Nulstil til standard",
+        "reset_limit": "Fjern hash",
+        "routing": "Routing",
+        "rsetting_add_rule": "Tilføj regel",
+        "rsetting_content": "Regelindhold",
+        "rsetting_desc": "Kort beskrivelse",
+        "rsetting_no_selection": "Vælg en regel",
+        "rsetting_none": "Ingen tilgængelige regler",
+        "rsettings_insert_preset": "Indsæt eksempel forudindstilling \"%s\"",
+        "rsettings_preset_1": "Deaktiver alt undtagen DKIM og satsgrænse for godkendte brugere",
+        "rsettings_preset_2": "Postmestere ønsker spam",
+        "rsettings_preset_3": "Tillad kun specifikke afsendere til en postkasse (dvs. kun brug som intern postkasse)",
+        "rspamd-com_settings": "Et indstillingsnavn genereres automatisk, se eksemplet på forudindstillinger nedenfor. For flere detaljer se <a href=\"https://rspamd.com/doc/configuration/settings.html#settings-structure\" target=\"_blank\">Rspamd docs</a>",
+        "rspamd_global_filters": "Globale filterkort",
+        "rspamd_global_filters_agree": "Jeg vil være forsigtig!",
+        "rspamd_global_filters_info": "Global filter maps contain different kind of global black and whitelists.",
+        "rspamd_global_filters_regex": "Deres navne forklarer deres formål. Alt indhold skal indeholde gyldigt regulært udtryk i formatet \"/pattern/options\" (e.g. <code>/.+@domain\\.tld/i</code>).<br>\r\n  Selvom der udføres rudimentære kontroller på hver linje med regex, kan Rspamds-funktionaliteten brydes, hvis den ikke læser syntaksen korrekt.<br>\r\n  Rspamd forsøger at læse kortindholdet, når det ændres. Hvis du oplever problemer, <a href=\"\" data-toggle=\"modal\" data-container=\"rspamd-mailcow\"  data-target=\"#RestartContainer\">genstart Rspamd</a> for at håndhæve et kortindlæsning.<br>Sortlisteelementer er udelukket fra karantæne.",
+        "rspamd_settings_map": "Rspamd indstillinger kort",
+        "sal_level": "Moo niveau",
+        "save": "Gem ændringer",
+        "search_domain_da": "Søg i domæner",
+        "send": "Send",
+        "sender": "Afsender",
+        "service_id": "Service ID",
+        "source": "Kilde",
+        "spamfilter": "Spam filter",
+        "subject": "Emne",
+        "sys_mails": "System e-mails",
+        "text": "Tekst",
+        "time": "Tid",
+        "title": "Titel",
+        "title_name": "\"mailcow UI\" hjemmeside titel",
+        "to_top": "Tilbage til toppen",
+        "transport_dest_format": "Syntaks: example.org, .example.org, *, box@example.org (flere værdier kan adskilles med komma)",
+        "transport_maps": "Transport Maps",
+        "transports_hint": "→ En transportkortpost <b>tilsidesætter</b> et afsenderafhængigt transportkort</b>.<br>\r\n→ Indstillinger for udgående TLS-politik pr. Bruger ignoreres og kan kun håndhæves af TLS-politikortposter.<br>\r\n→ Transportservicen for definerede transporter er altid \"smtp:\" og vil derfor prøve TLS, når de tilbydes. Indpakket TLS (SMTPS) understøttes ikke.<br>\r\n→ Adresser, der matcher \"/localhost$/\" vil altid blive transporteret via \"local:\", derfor en \"*\" destination gælder ikke for disse adresser.<br>\r\n→ At bestemme legitimationsoplysninger for et eksemplarisk næste hop \"[host]:25\", Postfix <b>altid</b> forespørgsler til \"host\" inden du søger efter \"[host]:25\". Denne adfærd gør det umuligt at bruge \"host\" og \"[host]:25\" på samme tid.",
+        "ui_footer": "Sidefod (HTML tilladt)",
+        "ui_header_announcement": "Meddelelser",
+        "ui_header_announcement_active": "Indstil meddelelse aktiv",
+        "ui_header_announcement_content": "Tekst (HTML tilladt)",
+        "ui_header_announcement_help": "Meddelelsen er synlig for alle indloggede brugere og på loginskærmen i brugergrænsefladen.",
+        "ui_header_announcement_select": "Vælg meddelelsestype",
+        "ui_header_announcement_type": "Type",
+        "ui_header_announcement_type_info": "Info",
+        "ui_header_announcement_type_warning": "Vigtig",
+        "ui_header_announcement_type_danger": "Meget vigtigt",
+        "ui_texts": "UI-etiketter og tekster",
+        "unban_pending": "unban ventende",
+        "unchanged_if_empty": "Lad være tomt, hvis uændret",
+        "upload": "Upload",
+        "username": "Brugernavn",
+        "validate_license_now": "Valider GUID mod licensserver",
+        "verify": "Verificere",
+        "yes": "&#10003;"
+    },
+    "danger": {
+        "access_denied": "Adgang nægtet eller ugyldig formular data",
+        "alias_domain_invalid": "Aliasdomænet% s er ugyldigt",
+        "alias_empty": "Aliasadressen må ikke være tom",
+        "alias_goto_identical": "Alias og goto-adresseæ må ikke være identiske",
+        "alias_invalid": "Aliasadresse %s er ugyldig",
+        "aliasd_targetd_identical": "Aliasdomænet må ikke være lig med måldomænet: %s",
+        "aliases_in_use": "Maks. aliaser skal være større eller lig med %d",
+        "app_name_empty": "Appens navn kan ikke være tomt",
+        "app_passwd_id_invalid": "App-adgangskode-id %s ugyldig",
+        "bcc_empty": "BCC-destination kan ikke være tom",
+        "bcc_exists": "Et BCC-kort %s findes for type %s",
+        "bcc_must_be_email": "BCC-destination %s er ikke en gyldig e-mail-adresse",
+        "comment_too_long": "Kommentar for lang, maks. 160 tegn tilladt",
+        "defquota_empty": "Standardkvoten pr. Postkasse må ikke være 0.",
+        "description_invalid": "Ressource beskrivelse for %s er ugyldig",
+        "dkim_domain_or_sel_exists": "En DKIM-nøgle til \"%s\" findes og vil ikke blive overskrevet",
+        "dkim_domain_or_sel_invalid": "DKIM-domæne eller vælger er ugyldigt: %s",
+        "domain_cannot_match_hostname": "Domæne kan ikke matche værtsnavn",
+        "domain_exists": "Domæne %s eksisterer allerede",
+        "domain_invalid": "Domænenavnet er tomt eller ugyldigt",
+        "domain_not_empty": "Kan ikke fjerne ikke-tomt domæne %s",
+        "domain_not_found": "Domæne %s ikke fundet",
+        "domain_quota_m_in_use": "Domænekvote skal være større eller lig med %s MiB",
+        "extra_acl_invalid": "Ekstern afsenderadresse \"%s\" er ugyldig",
+        "file_open_error": "Filen kan ikke åbnes til skrivning",
+        "filter_type": "Forkert filtertype",
+        "from_invalid": "Afsenderen må ikke være tom",
+        "global_filter_write_error": "Kunne ikke skrive filterfil: %s",
+        "global_map_invalid": "Globalt kort-ID %s ugyldig",
+        "global_map_write_error": "Kunne ikke skrive globalt kort-id %s: %s",
+        "goto_empty": "En alias-adresse skal indeholde mindst en gyldig goto-adresse",
+        "goto_invalid": "Gå til adresse %s er ugyldig",
+        "ham_learn_error": "HAM lærer fejl: %s",
+        "imagick_exception": "Fejl: Se undtagelsen, mens du læser billedet",
+        "img_invalid": "Kan ikke validere billedfilen",
+        "img_tmp_missing": "Kan ikke validere billedfil: Midlertidig fil blev ikke fundet",
+        "invalid_bcc_map_type": "Ugyldig BCC-korttype",
+        "invalid_destination": "Destinationsformat \"%s\" er ugyldig",
+        "invalid_filter_type": "Ugyldig filtertype",
+        "invalid_host": "Ugyldig vært angivet: %s",
+        "invalid_mime_type": "Ugyldig mime-type",
+        "invalid_nexthop": "Næste hop-format er ugyldigt",
+        "invalid_nexthop_authenticated": "Næste hop findes med forskellige legitimationsoplysninger. Opdater de eksisterende legitimationsoplysninger til dette næste hop først.",
+        "invalid_recipient_map_new": "Ugyldig ny modtager er angivet: %s",
+        "invalid_recipient_map_old": "Ugyldig original modtager er angivet: %s",
+        "ip_list_empty": "Listen over tilladte IP&#39;er kan ikke være tomme",
+        "is_alias": "%s er allerede kendt som en alias-adresse",
+        "is_alias_or_mailbox": "%s er allerede kendt som et alias, en postkasse eller en aliasadresse udvidet fra et aliasdomæne.",
+        "is_spam_alias": "%s er allerede kendt som en midlertidig alias-adresse (spam alias-adresse)",
+        "last_key": "Sidste nøgle kan ikke slettes. Deaktiver venligst TFA i stedet.",
+        "login_failed": "Login mislykkedes",
+        "mailbox_defquota_exceeds_mailbox_maxquota": "Standardkvoten overstiger den maksimale kvotegrænse",
+        "mailbox_invalid": "Postkassens navn er ugyldigt",
+        "mailbox_quota_exceeded": "Kvoten overstiger domænegrænsen(max. %d MiB)",
+        "mailbox_quota_exceeds_domain_quota": "Maks. kvote overstiger domænekvotegrænsen",
+        "mailbox_quota_left_exceeded": "Der er ikke nok plads tilbage (plads tilbage: %d MiB)",
+        "mailboxes_in_use": "Maks. postkasser skal være større eller lig med %d",
+        "malformed_username": "Misformet brugernavn",
+        "map_content_empty": "Kortindholdet må ikke være tomt",
+        "max_alias_exceeded": "Maks. aliaser overskredet",
+        "max_mailbox_exceeded": "Maks. postkasser overskredet (%d af %d)",
+        "max_quota_in_use": "Postkassekvoten skal være større eller lig med %d MiB",
+        "maxquota_empty": "Maks. kvote pr. postkasse må ikke være 0.",
+        "mysql_error": "MySQL fejl: %s",
+        "network_host_invalid": "Ugyldigt netværk eller vært: %s",
+        "next_hop_interferes": "%s interfererer med nexthop %s",
+        "next_hop_interferes_any": "En eksisterende næste hop interfererer med %s",
+        "no_user_defined": "Ingen brugerdefineret",
+        "object_exists": "Objekt %s eksisterer allerede",
+        "object_is_not_numeric": "Værdi %s er ikke numerisk",
+        "password_complexity": "Adgangskoden opfylder ikke politikken",
+        "password_empty": "Adgangskoden må ikke være tom",
+        "password_mismatch": "Bekræftelsesadgangskoden stemmer ikke overens",
+        "policy_list_from_exists": "Der findes en post med fornavn",
+        "policy_list_from_invalid": "Posten har ugyldigt format",
+        "private_key_error": "Privat nøglefejl: %s",
+        "pushover_credentials_missing": "Pushover-token og / eller nøgle mangler",
+        "pushover_key": "Pushover-nøglen har et forkert format",
+        "pushover_token": "Pushover-token har et forkert format",
+        "quota_not_0_not_numeric": "Kvoten skal være numerisk og >= 0",
+        "recipient_map_entry_exists": "En modtagerkortpost \"%s\" eksisterer",
+        "redis_error": "Redis fejl: %s",
+        "relayhost_invalid": "Kortindtastning %s er ugyldig",
+        "release_send_failed": "Beskeden kunne ikke frigives: %s",
+        "reset_f2b_regex": "Regex filter kunne ikke nulstilles i tide, prøv igen eller vent et par sekunder mere, og genindlæs webstedet.",
+        "resource_invalid": "Ressource navn %s er ugyldig",
+        "rl_timeframe": "Tidsramme for satsbegrænsning er forkert",
+        "rspamd_ui_pw_length": "Rspamd UI adgangskoden skal være mindst 6 tegn lang",
+        "script_empty": "Scriptet kan ikke være tomt",
+        "sender_acl_invalid": "Afsender ACL-værdi %s er ugyldig",
+        "set_acl_failed": "Kunne ikke indstille ACL",
+        "settings_map_invalid": "Indstillinger kort-id %s ugyldig",
+        "sieve_error": "Fejl i sile-parser: %s",
+        "spam_learn_error": "Spam lære fejl: %s",
+        "subject_empty": "Emnet må ikke være tomt",
+        "target_domain_invalid": "Måldomæne %s er ugyldig",
+        "targetd_not_found": "Måldomæne %s ikke fundet",
+        "targetd_relay_domain": "Måldomæne %s er et relædomæne",
+        "temp_error": "Midlertidig fejl",
+        "text_empty": "Teksten må ikke være tom",
+        "tfa_token_invalid": "TFA-token ugyldig",
+        "tls_policy_map_dest_invalid": "Politikens destination er ugyldig",
+        "tls_policy_map_entry_exists": "En post i TLS-politikkort \"%s\" eksisterer",
+        "tls_policy_map_parameter_invalid": "Politikparameter er ugyldig",
+        "totp_verification_failed": "Bekræftelse af TOTP mislykkedes",
+        "transport_dest_exists": "Transport destination \"%s\" eksisterer",
+        "u2f_verification_failed": "U2F-bekræftelse mislykkedes: %s",
+        "fido2_verification_failed": "Bekræftelse af FIDO2 mislykkedes: %s",
+        "unknown": "Der opstod en ukendt fejl",
+        "unknown_tfa_method": "Ukendt TFA-metode",
+        "unlimited_quota_acl": "Ubegrænset kvote forbudt af ACL",
+        "username_invalid": "Brugernavn %s kan ikke bruges",
+        "validity_missing": "Tildel venligst en gyldighedsperiode",
+        "value_missing": "Angiv alle værdier",
+        "yotp_verification_failed": "Yubico OTP verifikationen mislykkedes: %s"
+    },
+    "debug": {
+        "chart_this_server": "Diagram (denne server)",
+        "containers_info": "Oplysninger om containere",
+        "disk_usage": "Diskbrug",
+        "external_logs": "Eksterne logfiler",
+        "history_all_servers": "Historie (alle servere)",
+        "in_memory_logs": "In-memory logs",
+        "jvm_memory_solr": "Brug af JVM-hukommelse",
+        "log_info": "<p>mailcow <b>in-memory logs</b> er samlet i Redis-lister og trimmet til LOG_LINES (%d) hvert minut for at reducere hamring.\r\n  <br>Logbøger i hukommelsen er ikke beregnet til at være vedholdende. Alle applikationer, der logger ind i hukommelsen, logger også på Docker-dæmonen og derfor til standardlogdriveren.\r\n  <br>Logtypen i hukommelsen skal bruges til fejlfinding af mindre problemer med containere.</p>\r\n  <p><b>Eksterne logfiler</b> indsamles via API for den givne applikation.</p>\r\n  <p><b>Statiske logfiler</b> er for det meste aktivitetslogfiler, der ikke er logget på Dockerd, men stadig skal være vedholdende (undtagen API-logfiler).</p>",
+        "logs": "Logs",
+        "restart_container": "Genstart",
+        "solr_dead": "Solr starter, deaktiveres eller døde.",
+        "solr_docs": "Dokumenter",
+        "solr_last_modified": "Sidst ændret",
+        "solr_size": "Størrelse",
+        "solr_started_at": "Startede kl",
+        "solr_status": "Solr-status",
+        "solr_uptime": "Oppetid",
+        "started_on": "Startede den",
+        "static_logs": "Statiske logfiler",
+        "system_containers": "System og Beholdere"
+    },
+    "diagnostics": {
+        "cname_from_a": "Værdi afledt af A / AAAA-post. Dette understøttes, så længe posten peger på den korrekte ressource.",
+        "dns_records": "DNS-poster",
+        "dns_records_24hours": "Bemærk, at ændringer, der foretages i DNS, kan tage op til 24 timer for at få deres aktuelle status korrekt reflekteret på denne side. Det er beregnet som en måde for dig let at se, hvordan du konfigurerer dine DNS-poster og kontrollere, om alle dine poster er korrekt gemt i DNS.",
+        "dns_records_docs": "Se også <a target=\"_blank\" href=\"https://mailcow.github.io/mailcow-dockerized-docs/prerequisite-dns/\">dokumentationen</a>.",
+        "dns_records_data": "Korrekte data",
+        "dns_records_name": "Navn",
+        "dns_records_status": "Nuværende tilstand",
+        "dns_records_type": "Type",
+        "optional": "Denne post er valgfri."
+    },
+    "edit": {
+        "active": "Active",
+        "advanced_settings": "Avancerede indstillinger",
+        "alias": "rediger mere",
+        "allow_from_smtp": "Tillad kun, at disse IP&#39;er bruges <b>SMTP</b>",
+        "allow_from_smtp_info": "Lad det være tomt for at tillade alle afsendere.<br>IPv4/IPv6 adresser og netværk.",
+        "allowed_protocols": "Tilladte protokoller",
+        "app_name": "Appens navn",
+        "app_passwd": "App-adgangskode",
+        "automap": "Prøv at automatisere mapper (\"Sent items\", \"Sent\" => \"Sent\" etc.)",
+        "backup_mx_options": "Relæindstillinger",
+        "bcc_dest_format": "BCC-destination skal være en enkelt gyldig e-mail-adresse.",
+        "client_id": "Klient-id",
+        "client_secret": "Klienthemmelighed",
+        "comment_info": "En privat kommentar er ikke synlig for brugeren, mens en offentlig kommentar vises som værktøjstip, når den svæver i en brugeroversigt",
+        "delete1": "Slet fra kilden, når den er afsluttet",
+        "delete2": "Slet meddelelser på destinationen, der ikke er fra kilden",
+        "delete2duplicates": "Slet duplikater på destinationen",
+        "delete_ays": "Bekræft sletningsprocessen.",
+        "description": "Beskrivelse",
+        "disable_login": "Tillad ikke login (indgående mail accepteres stadig)",
+        "domain": "Rediger domæne",
+        "domain_admin": "Rediger domæneadministrator",
+        "domain_quota": "Domæne kvote",
+        "domains": "Domæner",
+        "dont_check_sender_acl": "Deaktiver afsenderkontrol for domæne %s (+ alias-domæner)",
+        "edit_alias_domain": "Rediger Alias-domæne",
+        "encryption": "Kryptering",
+        "exclude": "Ekskluder objekter (regex)",
+        "extended_sender_acl": "Eksterne afsenderadresser",
+        "extended_sender_acl_info": "En DKIM-domænenøgle skal importeres, hvis den er tilgængelig.<br>\r\n  Husk at tilføje denne server til den tilsvarende SPF TXT-post.<br>\r\n  Når et domæne eller aliasdomæne føjes til denne server, der overlapper en ekstern adresse, fjernes den eksterne adresse.<br>\r\n  Brug @domain.tld til at tillade at sende som *@domæne.tld.",
+        "force_pw_update": "Tving adgangskodeopdatering til næste login",
+        "force_pw_update_info": "Denne bruger kan kun logge ind på %s.",
+        "full_name": "Fulde navn",
+        "gal": "Global adresseliste",
+        "gal_info": "GAL indeholder alle objekter i et domæne og kan ikke redigeres af nogen bruger. Information om ledig / optaget i SOGo mangler, hvis deaktiveret! <b>Genstart SOGo for at anvende ændringer.</b>",
+        "generate": "frembringe",
+        "grant_types": "Tilskudstyper",
+        "hostname": "Værtsnavn",
+        "inactive": "Inaktiv",
+        "kind": "Kind",
+        "mailbox": "Rediger postkasse",
+        "mailbox_quota_def": "Standardpostkassekvote",
+        "max_aliases": "Maks. aliaser",
+        "max_mailboxes": "Maks. mulige postkasser",
+        "max_quota": "Maks. kvote pr. postkasse (MiB)",
+        "maxage": "Maksimumalder for beskeder i dage, der vil blive pollet fra fjernbetjeningen<br><small>(0 = ignorere alder)</small>",
+        "maxbytespersecond": "Maks. bytes pr. sekund <br><small>(0 = ubegrænset)</small>",
+        "mbox_rl_info": "Denne satsgrænse anvendes på SASL-loginnavnet, den matcher ethvert \"from\" adresse, der bruges af den indloggede bruger. En grænse for sats for postkasse tilsidesætter en satsgrænse for hele domænet.",
+        "mins_interval": "Interval (min)",
+        "multiple_bookings": "Flere bookinger",
+        "nexthop": "Næste hop",
+        "password": "Adgangskode",
+        "password_repeat": "Bekræftelsesadgangskode (gentag)",
+        "previous": "Forrige side",
+        "private_comment": "Privat kommentar",
+        "public_comment": "Offentlig hvordan",
+        "pushover_evaluate_x_prio": "Eskaler e-mail med høj prioritet [<code>X-Priority: 1</code>]",
+        "pushover_info": "Indstillinger for push-meddelelser gælder for al ren (ikke-spam) post, der leveres til <b>%s</b> inklusive aliaser (delt, ikke-delt, tagget).",
+        "pushover_only_x_prio": "Overvej kun post med høj prioritet [<code>X-Priority: 1</code>]",
+        "pushover_sender_array": "Overvej kun følgende afsender-e-mail-adresser <small>(comma-separated)</small>",
+        "pushover_sender_regex": "Overvej følgende afsender regex",
+        "pushover_text": "Meddelelsestekst",
+        "pushover_title": "Meddelelsestitel",
+        "pushover_vars": "Når der ikke er defineret et afsenderfilter, overvejes alle mails.<br>Regex såvel som nøjagtige afsenderkontrol kan defineres individuelt og vil blive betragtet i rækkefølge. De er ikke afhængige af hinanden.<br>Brugbare variabler til tekst og titel (vær opmærksom på databeskyttelsespolitikker)",
+        "pushover_verify": "Bekræft legitimationsoplysninger",
+        "quota_mb": "Kvote (MiB)",
+        "redirect_uri": "Omdirigering/tilbagekald URL",
+        "relay_all": "Send alle modtagere videre",
+        "relay_all_info": "↪ Hvis du vælger <b>ikke</b> for at videresende alle modtagere skal du tilføje en (\"blind\") postkasse til hver enkelt modtager, der skal videresendes.",
+        "relay_domain": "Send dette domæne videre",
+        "relay_transport_info": "<div class=\"label label-info\">Info</div> Du kan definere transportkort til en tilpasset destination for dette domæne. Hvis den ikke er indstillet, foretages der et MX-opslag.",
+        "relay_unknown_only": "Videresend kun ikke-eksisterende postkasser. Eksisterende postkasser leveres lokalt.",
+        "relayhost": "Afsenderafhængige transporter",
+        "remove": "Fjerne",
+        "resource": "Ressource",
+        "save": "Gem ændringer",
+        "scope": "Anvendelsesområde",
+        "sender_acl": "Tillad at sende som",
+        "sender_acl_disabled": "<span class=\"label label-danger\">Afsenderkontrol er deaktiveret</span>",
+        "sender_acl_info": "Hvis postkassebruger A har tilladelse til at sende som postkassebruger B, vises afsenderadressen ikke automatisk som valgbar \"from\" felt i SOGo.<br>\r\n  Postkassebruger B skal oprette en delegation i SOGo for at tillade postkassebruger A at vælge deres adresse som afsender. For at delegere en postkasse i SOGo skal du bruge menuen (tre prikker) til højre for dit postkassens navn øverst til venstre, mens du er i postvisningen. Denne adfærd gælder ikke for aliasadresser.",
+        "sieve_desc": "Kort beskrivelse",
+        "sieve_type": "Filtertype",
+        "skipcrossduplicates": "Spring duplikatbeskeder over mapper (først til mølle)",
+        "sogo_access": "Giv adgang til SOGo",
+        "sogo_access_info": "Giv eller tillad adgang til SOGo. Denne indstilling påvirker hverken adgang til alle andre tjenester eller sletter eller ændrer en eksisterende SOGo-profil for brugere.",
+        "sogo_visible": "Alias er synligt i SOGo",
+        "sogo_visible_info": "Denne indstilling påvirker kun objekter, der kan vises i SOGo (delte eller ikke-delte aliasadresser, der peger på mindst en lokal postkasse). Hvis skjult, vises et alias ikke som valgbar afsender i SOGo.",
+        "spam_alias": "Opret eller skift tidsbegrænsede aliasadresser",
+        "spam_policy": "Tilføj eller fjern genstande til hvid- / sortliste",
+        "spam_score": "Indstil en brugerdefineret spam-score",
+        "subfolder2": "Synkroniser til undermappe på destinationen<br><small>(tom = brug ikke undermappe)</small>",
+        "syncjob": "Rediger synkroniseringsjob",
+        "target_address": "Gå til adresse (r) <small>(komma separeret)</small>",
+        "target_domain": "Måldomæne",
+        "timeout1": "Timeout for forbindelse til ekstern vært",
+        "timeout2": "Timeout for forbindelse til lokal vært",
+        "title": "Rediger objekt",
+        "unchanged_if_empty": "Lad være tomt, hvis uændret",
+        "username": "Brugernavn",
+        "validate_save": "Valider og gem"
+    },
+    "footer": {
+        "cancel": "Afbestille",
+        "confirm_delete": "Bekræft sletning",
+        "delete_now": "Slet nu",
+        "delete_these_items": "Bekræft dine ændringer til følgende objekt-id",
+        "hibp_nok": "Matchet! Dette er en potentielt farlig adgangskode!",
+        "hibp_ok": "Ingen match fundet.",
+        "loading": "Vent venligst...",
+        "restart_container": "Genstart beholderen",
+        "restart_container_info": "<b>Vigtig:</b> Det kan tage et stykke tid at gennemføre en yndefuld genstart. Vent til den er færdig.",
+        "restart_now": "Genstart nu",
+        "restarting_container": "Genstart af beholder, det kan tage et stykke tid"
+    },
+    "header": {
+        "administration": "Konfiguration og detailer",
+        "apps": "Apps",
+        "debug": "Systemoplysninger",
+        "mailboxes": "Mailopsætning",
+        "mailcow_settings": "Konfiguration",
+        "quarantine": "Karantæne",
+        "restart_netfilter": "Genstart netfilter",
+        "restart_sogo": "Genstart SOGo",
+        "user_settings": "Brugerindstillinger"
+    },
+    "info": {
+        "awaiting_tfa_confirmation": "Venter på TFA-bekræftelse",
+        "no_action": "Ingen handling gældende",
+        "session_expires": "Din session udløber om cirka 15 sekunder"
+    },
+    "login": {
+        "delayed": "Login blev forsinket med% s sekunder.",
+        "fido2_webauthn": "FIDO2/WebAuthn",
+        "login": "Login",
+        "mobileconfig_info": "Log ind som postkassebruger for at downloade den anmodede Apple-forbindelsesprofil.",
+        "other_logins": "Nøgle login",
+        "password": "Adgangskode",
+        "username": "Brugernavn"
+    },
+    "mailbox": {
+        "action": "Handling",
+        "activate": "Aktivér",
+        "active": "Aktiv",
+        "add": "Tilføje",
+        "add_alias": "Tilføj alias",
+        "add_bcc_entry": "Tilføj BCC-kort",
+        "add_domain": "Tilføj domæne",
+        "add_domain_alias": "Tilføj domænealias",
+        "add_domain_record_first": "Tilføj først et domæne",
+        "add_filter": "Tilføj filter",
+        "add_mailbox": "Tilføj postkasse",
+        "add_recipient_map_entry": "Tilføj modtagerkort",
+        "add_resource": "Tilføj ressource",
+        "add_tls_policy_map": "Tilføj TLS-politikkort",
+        "address_rewriting": "Omskrivning af adresse",
+        "alias": "Alias",
+        "alias_domain_alias_hint": "Aliaser er <b>not</b> anvendes automatisk på domænealiaser. En alias-adresse <code>mit-alias@domain</code> <b>gør ikke</b> dække adressen <code>my-alias@alias-domain</code> (hvor \"alias-domain\" er et imaginært aliasdomæne for \"domain\").<br>Brug et sigfilter til at omdirigere mail til en ekstern postkasse (se fanen \"Filters\" eller brug SOGo -> fremsender).",
+        "alias_domain_backupmx": "Alias-domæne inaktivt for relædomæne",
+        "aliases": "Aliaser",
+        "allow_from_smtp": "Tillad kun, at disse IPer bruges <b>SMTP</b>",
+        "allow_from_smtp_info": "Lad det være tomt for at tillade alle afsendere.<br>IPv4/IPv6adresser og netværk.",
+        "allowed_protocols": "Tilladte protokoller",
+        "backup_mx": "Relædomæne",
+        "bcc": "BCC",
+        "bcc_destination": "BCC bestemmelsessted",
+        "bcc_destinations": "BCC bestemmelsessted",
+        "bcc_info": "BCC-kort bruges til lydsvagt at videresende kopier af alle meddelelser til en anden adresse. En modtagerkorttypepost bruges, når den lokale destination fungerer som modtager af en mail. Afsenderkort overholder det samme princip.<br/>\r\n  Den lokale destination vil ikke blive informeret om en mislykket levering.",
+        "bcc_local_dest": "Lokal destination",
+        "bcc_map": "BCC kort",
+        "bcc_map_type": "BCC type",
+        "bcc_maps": "BCC maps",
+        "bcc_rcpt_map": "Modtagerkort",
+        "bcc_sender_map": "Afsender kort",
+        "bcc_to_rcpt": "Skift til modtagerens korttype",
+        "bcc_to_sender": "Skift til afsenderkorttype",
+        "bcc_type": "BCC-type",
+        "booking_0": "Vis altid som gratis",
+        "booking_0_short": "Altid gratis",
+        "booking_custom": "Hard-limit til et brugerdefineret antal bookinger",
+        "booking_custom_short": "Hård grænse",
+        "booking_lt0": "Ubegrænset, men vis som optaget, når booket",
+        "booking_lt0_short": "Blød grænse",
+        "daily": "Daglige",
+        "deactivate": "Deaktiver",
+        "description": "Beskrivelse",
+        "disable_login": "Tillad ikke login (indgående mail accepteres stadig)",
+        "disable_x": "Deaktiver",
+        "domain": "Domæne",
+        "domain_admins": "Domæneadministratorer",
+        "domain_aliases": "Domænealiaser",
+        "domain_quota": "Kvote",
+        "domains": "Domains",
+        "edit": "Edit",
+        "empty": "Ingen resultater",
+        "enable_x": "Aktiver",
+        "excludes": "Ekskluderer",
+        "filter_table": "Filtertabel",
+        "filters": "Filtre",
+        "fname": "Fulde navn",
+        "hourly": "Hver time",
+        "in_use": "I brug (%)",
+        "inactive": "Inaktiv",
+        "insert_preset": "Indsæt eksempel forudindstilling \"%s\"",
+        "kind": "Kind",
+        "last_mail_login": "Last mail login",
+        "last_run": "Sidste løb",
+        "last_run_reset": "Planlæg næste",
+        "mailbox": "Postkasse",
+        "mailbox_defquota": "Standardstørrelse på postkasse",
+        "mailbox_quota": "Maks. størrelsen på en postkasse",
+        "mailboxes": "Postkasser",
+        "mailbox_defaults": "Standardindstillinger",
+        "mailbox_defaults_info": "Definer standardindstillinger for nye postkasser.",
+        "mins_interval": "Interval (min)",
+        "msg_num": "Besked #",
+        "multiple_bookings": "Flere bookinger",
+        "never": "Aldrig",
+        "no": "&#10005;",
+        "no_record": "Ingen registrering for objekt %s",
+        "no_record_single": "Jeg kan ikke huske det",
+        "owner": "Ejer",
+        "private_comment": "Privat kommentar",
+        "public_comment": "Offentlig hvordan",
+        "q_add_header": "Uønsket mappe",
+        "q_all": "Alle kategorier",
+        "q_reject": "Afvist",
+        "quarantine_notification": "Karantænemeddelelser",
+        "quarantine_category": "Karantænemeddelelseskategori",
+        "quick_actions": "Handlinger",
+        "recipient_map": "Modtagerkort",
+        "recipient_map_info": "Modtagerkort bruges til at erstatte destinationsadressen i en meddelelse, før den leveres.",
+        "recipient_map_new": "Ny modtager",
+        "recipient_map_new_info": "Modtagerkortdestination skal være en gyldig e-mail-adresse.",
+        "recipient_map_old": "Original modtager",
+        "recipient_map_old_info": "En modtager kortlægger den originale destination, skal være gyldige e-mail-adresser eller et domænenavn.",
+        "recipient_maps": "Modtagerkort",
+        "remove": "Fjerne",
+        "resources": "Ressourcer",
+        "running": "Løb",
+        "set_postfilter": "Marker som postfilter",
+        "set_prefilter": "Marker som forfilter",
+        "sieve_info": "Du kan gemme flere filtre pr. Bruger, men kun et forfilter og et efterfilter kan være aktive på samme tid.<br>\r\nHvert filter behandles i den beskrevne rækkefølge. Hverken et mislykket script eller et udstedt \"keep;\" stopper behandlingen af yderligere scripts. Ændringer i globale sigtscript vil udløse en genstart af Dovecot.<br><br>Globalt sigteforfilter → Forfilter → Bruger scripts → Efterfilter → Globalt sigte efterfilter",
+        "sieve_preset_1": "Kassér e-mail med sandsynlige farlige filtyper",
+        "sieve_preset_2": "Marker altid e-mailen til en bestemt afsender som set",
+        "sieve_preset_3": "Kassér lydløst, stop al yderligere sigtebehandling",
+        "sieve_preset_4": "Fil til INBOX, spring videre behandling ved hjælp af sigtefiltre",
+        "sieve_preset_5": "Autosvar (ferie)",
+        "sieve_preset_6": "Afvis mail med svar",
+        "sieve_preset_7": "Omdiriger og hold/slip",
+        "sieve_preset_8": "Kassér besked sendt til en aliasadresse, som afsenderen er en del af",
+        "sieve_preset_header": "Se eksemplet på forudindstillinger nedenfor. For flere detaljer se <a href=\"https://en.wikipedia.org/wiki/Sieve_(mail_filtering_language)\" target=\"_blank\">Wikipedia</a>.",
+        "sogo_visible": "Alias er synligt i SOGo",
+        "sogo_visible_n": "Skjul alias i SOGo",
+        "sogo_visible_y": "Vis alias i SOGo",
+        "spam_aliases": "Temp. alias",
+        "stats": "Statistikker",
+        "status": "Status",
+        "sync_jobs": "Synkroniser job",
+        "table_size": "Bordstørrelse",
+        "table_size_show_n": "Vis %s genstande",
+        "target_address": "Gå til adresse",
+        "target_domain": "Måldomæne",
+        "tls_enforce_in": "Håndhæv TLS indgående",
+        "tls_enforce_out": "Håndhæve TLS udgående",
+        "tls_map_dest": "Bestemmelsessted",
+        "tls_map_dest_info": "Eksempler: eksempel.org, .eksempel.org, [mail.eksempel.org]:25",
+        "tls_map_parameters": "Parametre",
+        "tls_map_parameters_info": "Tom eller for eksempel parametre: protocols=!SSLv2 ciphers=medium exclude=3DES",
+        "tls_map_policy": "Politik",
+        "tls_policy_maps": "TLS-politikkort",
+        "tls_policy_maps_info": "Dette politikkort tilsidesætter udgående TLS-transportregler uafhængigt af brugernes TLS-politikindstillinger.<br>\r\n Kontroller venligst <a href=\"http://www.postfix.org/postconf.5.html#smtp_tls_policy_maps\" target=\"_blank\">the \"smtp_tls_policy_maps\" docs</a>for mere information.",
+        "tls_policy_maps_enforced_tls": "Disse politikker tilsidesætter også adfærd for postkassebrugere, der håndhæver udgående TLS-forbindelser. Hvis der ikke findes nogen politik nedenfor, anvender disse brugere standardværdierne angivet som <code>smtp_tls_mandatory_protocols</code> og <code>smtp_tls_mandatory_ciphers</code>.",
+        "tls_policy_maps_long": "Udgående TLS-politikkort tilsidesætter",
+        "toggle_all": "Skift alt",
+        "username": "Brugernavn",
+        "waiting": "Venter",
+        "weekly": "Ugentlig",
+        "yes": "&#10003;"
+    },
+    "oauth2": {
+        "access_denied": "Log ind som mailboks ejer for at give adgang via OAuth2.",
+        "authorize_app": "Godkend ansøgning",
+        "deny": "Nægte",
+        "permit": "Godkend ansøgning",
+        "profile": "Profil",
+        "profile_desc": "Se personlige oplysninger: brugernavn, fuldt navn, oprettet, ændret, aktiv",
+        "scope_ask_permission": "En applikation anmodede om følgende tilladelser"
+    },
+    "quarantine": {
+        "action": "Handling",
+        "atts": "Vedhæftede filer",
+        "check_hash": "Søgefil hash @ VT",
+        "confirm": "Bekræfte",
+        "confirm_delete": "Bekræft sletningen af dette element.",
+        "danger": "Fare",
+        "deliver_inbox": "Lever til indbakke",
+        "disabled_by_config": "Den aktuelle systemkonfiguration deaktiverer karantænefunktionaliteten. Indstil venligst \"tilbageholdelse pr. postkasse\" og en \"maksimal størrelse\" til karantæneelementer.",
+        "download_eml": "Hent (.eml)",
+        "empty": "Ingen resultater",
+        "high_danger": "Høj",
+        "info": "Information",
+        "junk_folder": "Uønsket mappe",
+        "learn_spam_delete": "Lær som spam og slet",
+        "low_danger": "Lav",
+        "medium_danger": "Medium",
+        "neutral_danger": "Neutral",
+        "notified": "Meddelt",
+        "qhandler_success": "Anmodning blev sendt til systemet. Du kan nu lukke vinduet.",
+        "qid": "Rspamd QID",
+        "qinfo": "Karantænesystemet gemmer afvist mail i databasen (afsenderen vil <em>ikke</em> få indtryk af en leveret post) såvel som mail, der leveres som kopi i skraldemappen i en postkasse.\r\n  <br>\"Lær som spam og slet\" vil lære en besked som spam via Bayesiansk sætning og også beregne fuzzy hashes for at nægte lignende meddelelser i fremtiden.\r\n  <br>Vær opmærksom på, at indlæring af flere meddelelser kan - afhængigt af dit system - være tidskrævende.<br> Sortlistede elementer er udelukket fra karantæne.",
+        "qitem": "Karantæneartikel",
+        "quarantine": "Karantæne",
+        "quick_actions": "Handlinger",
+        "rcpt": "Modtager",
+        "received": "Modtaget",
+        "recipients": "Modtagere",
+        "refresh": "Opdater",
+        "rejected": "Afvist",
+        "release": "Frigøre",
+        "release_body": "Vi har vedhæftet din besked som eml-fil til denne besked.",
+        "release_subject": "Potentielt skadelig karantæneartikel %s",
+        "remove": "Fjerne",
+        "rewrite_subject": "Omskriv emne",
+        "rspamd_result": "Rspamd resultat",
+        "sender": "Sender (SMTP)",
+        "sender_header": "Sender (\"Fra\" header)",
+        "type": "Type",
+        "quick_release_link": "Åbn link til hurtig frigivelse",
+        "quick_delete_link": "Åbn linket til hurtig sletning",
+        "quick_info_link": "Åbn info link",
+        "show_item": "Vis element",
+        "spam": "Spam",
+        "spam_score": "Score",
+        "subj": "Emne",
+        "table_size": "Bordstørrelse",
+        "table_size_show_n": "Vis %s genstande",
+        "text_from_html_content": "Indhold (konverterede html)",
+        "text_plain_content": "Indhold (text/plain)",
+        "toggle_all": "Skift alt"
+    },
+    "start": {
+        "help": "Vis / skjul hjælpepanel",
+        "imap_smtp_server_auth_info": "Brug din fulde e-mail-adresse og PLAIN-godkendelsesmekanismen.<br>\r\nDine login-data bliver krypteret af den obligatoriske kryptering på serversiden.",
+        "mailcow_apps_detail": "Brug en mailcow-app til at få adgang til dine mails, kalender, kontakter og mere.",
+        "mailcow_panel_detail": "<b>Domæneadministratorer</b> oprette, ændre eller slette postkasser og aliasser, ændre domæner og læse yderligere information om deres tildelte domæner.<br>\r\n<b>Mailbox-brugere</b>er i stand til at oprette tidsbegrænsede aliaser (spamaliaser), ændre deres adgangskode og spamfilterindstillinger."
+    },
+    "success": {
+        "acl_saved": "ACL til objekt %s gemt",
+        "admin_added": "Administrator %s er tilføjet",
+        "admin_api_modified": "Ændringer i API er gemt",
+        "admin_modified": "Ændringer til administrator er gemt",
+        "admin_removed": "Administrator %s er blevet fjernet",
+        "alias_added": "Alias-adresse %s (%d) er tilføjet",
+        "alias_domain_removed": "Domænealias %s er blevet fjernet",
+        "alias_modified": "Ændringer i alias-adresse %s er blevet gemt",
+        "alias_removed": "Alias %s er blevet fjernet",
+        "aliasd_added": "Tilføjetdomænealias %s",
+        "aliasd_modified": "Ændringer i alias-domæne %s er blevet gemt",
+        "app_links": "Gemte ændringer til applinks",
+        "app_passwd_added": "Tilføjet ny app-adgangskode",
+        "app_passwd_removed": "Fjernet app-adgangskode-id %s",
+        "bcc_deleted": "BCC-kortindgange slettet: %s",
+        "bcc_edited": "BCC-kortindgang %s redigeret",
+        "bcc_saved": "BCC-kortindgang gemt",
+        "db_init_complete": "Initialisering af database afsluttet",
+        "delete_filter": "Slettet filter-ID %s",
+        "delete_filters": "Slettede filtre: %s",
+        "deleted_syncjob": "Slettet syncjob-id %s",
+        "deleted_syncjobs": "Slettede syncjobs: %s",
+        "dkim_added": "DKIM-nøgle %s er blevet gemt",
+        "dkim_duplicated": "DKIM-nøgle til domæne %s er blevet kopieret til %s",
+        "dkim_removed": "DKIM-nøgle %s er blevet fjernet",
+        "domain_added": "Tilføjet domæne %s",
+        "domain_admin_added": "Domæne administrator %s er tilføjet",
+        "domain_admin_modified": "Ændringer til domæneadministrator %s er blevet gemt",
+        "domain_admin_removed": "Domæne administrator %s er blevet fjernet",
+        "domain_modified": "Ændringer i domæne %s er blevet gemt",
+        "domain_removed": "Domæne %s er blevet fjernet",
+        "dovecot_restart_success": "Dovecot blev genstartet",
+        "eas_reset": "ActiveSync-enheder til bruger %s blev nulstillet",
+        "f2b_modified": "Changes to Fail2ban parameters have been saved",
+        "forwarding_host_added": "Videresendende vært %s er tilføjet",
+        "forwarding_host_removed": "Videresendende vært %s er blevet fjernet",
+        "global_filter_written": "Filtret blev skrevet til filen",
+        "hash_deleted": "Hash slettet",
+        "item_deleted": "Item %s successfully deleted",
+        "item_released": "Item %s released",
+        "items_deleted": "Element %s slettet",
+        "items_released": "Selected items were released",
+        "learned_ham": "Successfully learned ID %s as ham",
+        "license_modified": "Ændringer i licens er gemt",
+        "logged_in_as": "logget ind som %s",
+        "mailbox_added": "Postkasse %s er tilføjet",
+        "mailbox_modified": "Ændringer i postkassen %s er blevet gemt",
+        "mailbox_removed": "Mailbox %s has been removed",
+        "object_modified": "Ændringer af objektet %s er blevet gemt",
+        "pushover_settings_edited": "Pushover-indstillinger er vellykket indstillet. Bekræft legitimationsoplysninger.",
+        "qlearn_spam": "Besked-id %s blev lært som spam og slettet",
+        "queue_command_success": "Køkommandoen blev fuldført",
+        "recipient_map_entry_deleted": "Modtagerkort-id %s er blevet slettet",
+        "recipient_map_entry_saved": "Modtagerkortindtastning \"%s\" er blevet gemt",
+        "relayhost_added": "Kortindtastning %s er tilføjet",
+        "relayhost_removed": "Kortindtastning %s er blevet fjernet",
+        "reset_main_logo": "Nulstil til standardlogo",
+        "resource_added": "Resource %s has been added",
+        "resource_modified": "Ændringer i postkassen %s er blevet gemt",
+        "resource_removed": "Ressource %s er blevet fjernet",
+        "rl_saved": "Satsgrænse for objekt %s gemt",
+        "rspamd_ui_pw_set": "Rspamd UI-adgangskode er indstillet",
+        "saved_settings": "Gemte indstillinger",
+        "settings_map_added": "Tilføjede indstillinger kortindtastning",
+        "settings_map_removed": "Fjernet indstillingskort-id %s",
+        "sogo_profile_reset": "SOGo-profil til bruger %s blev nulstillet",
+        "tls_policy_map_entry_deleted": "TLS-politik kort-id %s er blevet slettet",
+        "tls_policy_map_entry_saved": "TLS politik kort post \"%s\" er blevet gemt",
+        "ui_texts": "Gemte ændringer til UI-tekster",
+        "upload_success": "Filen blev uploadet",
+        "verified_totp_login": "Bekræftet TOTP-login",
+        "verified_u2f_login": "Bekræftet U2F-login",
+        "verified_fido2_login": "Bekræftet FIDO2-login",
+        "verified_yotp_login": "Bekræftet Yubico OTP-login"
+    },
+    "tfa": {
+        "api_register": "%s bruger Yubico Cloud API. Få en API-nøgle til din nøgle <a href=\"https://upgrade.yubico.com/getapikey/\" target=\"_blank\">here</a>",
+        "confirm": "Bekræft",
+        "confirm_totp_token": "Bekræft dine ændringer ved at indtaste det genererede token",
+        "delete_tfa": "Deaktiver TFA",
+        "disable_tfa": "Deaktiver TFA indtil næste vellykkede login",
+        "enter_qr_code": "Din TOTP kode hvis din enhed ikke kan scanne QR-koder",
+        "error_code": "Fejl kode",
+        "init_u2f": "Initialiserer, vent venligst...",
+        "key_id": "En identifikator til din YubiKey",
+        "key_id_totp": "En identifikator for din nøgle",
+        "none": "Deaktivere",
+        "reload_retry": "- (genindlæs browseren, hvis fejlen fortsætter)",
+        "scan_qr_code": "Scan venligst følgende kode med din godkendelsesapp, eller indtast koden manuelt.",
+        "select": "Vælg venligst",
+        "set_tfa": "Set 2-faktor godkendelses metoden",
+        "start_u2f_validation": "Start validering",
+        "tfa": "2-faktor godkendelse",
+        "tfa_token_invalid": "TFA nøgle ugyldig",
+        "totp": "Tids-baseret OTP (Google Authenticator, Authy, etc.)",
+        "u2f": "U2F godkendelse",
+        "waiting_usb_auth": "<i>Venter på USB-enhed...</i><br><br>Tryk let på knappen på din USB-enhed nu.",
+        "waiting_usb_register": "<i>Venter på USB-enhed...</i><br><br>Indtast din adgangskode ovenfor, og bekræft din registrering ved at trykke på knappen på din USB-enhed.",
+        "yubi_otp": "Yubico OTP godkendelse"
+    },
+    "fido2": {
+        "set_fn": "Set venneligt navn",
+        "fn": "Venneligt navn",
+        "rename": "omdøb",
+        "confirm": "Bekræft",
+        "register_status": "Registreringsstatus",
+        "known_ids": "Kendte ID'er",
+        "none": "Deaktiveret",
+        "set_fido2": "Registrer FIDO2 endhed",
+        "start_fido2_validation": "Start FIDO2 validering",
+        "fido2_auth": "Login med FIDO2",
+        "fido2_success": "Enheden blev registreret",
+        "fido2_validation_failed": "Validering mislykkedes"
+    },
+    "user": {
+        "action": "Handling",
+        "active": "Aktiv",
+        "active_sieve": "Aktive filtre",
+        "advanced_settings": "Avancerede indstillinger",
+        "alias": "Alias",
+        "alias_create_random": "Generer tilfældigt alias",
+        "alias_extend_all": "Forlæng aliaserne med 1 time",
+        "alias_full_date": "d.m.Y, H:i:s T",
+        "alias_remove_all": "Fjern alle aliaser",
+        "alias_select_validity": "Gyldighedsperiode",
+        "alias_time_left": "Tid tilbage",
+        "alias_valid_until": "Gyldig indtil",
+        "aliases_also_send_as": "Også tilladt at sende som bruger",
+        "aliases_send_as_all": "Do not check sender access for the following domain(s) and its alias domains",
+        "app_hint": "App adgangskoder er alternative adgangskoder til din <b>IMAP og SMTP</b> login. Brugernavnet forbliver uændret.<br>SOGo (inklusive AktivSync) er ikke tilgængelig via app-adgangskoder.",
+        "app_name": "App navn",
+        "app_passwds": "App kodeord",
+        "apple_connection_profile": "Apple forbindelses profil",
+        "apple_connection_profile_complete": "Denne forbindelses profil inkludere IMAP og SMTP parametre også CalDAV (kalendre) og CardDAV (kontakter) veje for en Apple endhed.",
+        "apple_connection_profile_mailonly": "Denne forbindelses profil inkludere IMAP og SMTP konfigurations parametere for en Apple endhed.",
+        "change_password": "Skift kodeord",
+        "client_configuration": "Vis konfigurationsvejledning for email klinter og mobiltelefoner",
+        "create_app_passwd": "Opret app kodeord",
+        "create_syncjob": "Opret nyt sync job",
+        "daily": "Dagligt",
+        "day": "dag",
+        "delete_ays": "Bekræft venligst ønsket om sletning.",
+        "direct_aliases": "Direkte alias addresser",
+        "direct_aliases_desc": "Direkte alias-adresser påvirkes af spamfilter og TLS-politiske indstillinger.",
+        "eas_reset": "Nulstil AktivSync endhed cache",
+        "eas_reset_help": "I mange tilfælde hjælper en nulstilling af enhedens cache med at gendanne en ødelagt ActiveSync-profil.<br><b>Advarsel:</b> Alle elementer downloades igen!",
+        "eas_reset_now": "Nultil nu",
+        "edit": "redigere",
+        "email": "Email",
+        "email_and_dav": "Email, kalender and kontakter",
+        "encryption": "kryptering",
+        "excludes": "Ekskluderer",
+        "expire_in": "Udløber om",
+        "force_pw_update": "Du <b>SKAL</b> indstille en ny adgangskode for at få adgang til groupware-relaterede tjenester.",
+        "generate": "generere",
+        "hour": "tid",
+        "hourly": "Timelig",
+        "hours": "timer",
+        "in_use": "I brug",
+        "interval": "Interval",
+        "is_catch_all": "Fang-alle for domæne/r",
+        "last_mail_login": "Sidste mail login",
+        "last_run": "Sidste kørsel",
+        "loading": "Indlæser...",
+        "mailbox_details": "Postkassedetaljer",
+        "messages": "beskeder",
+        "never": "Aldrig",
+        "new_password": "Nyt kodeord",
+        "new_password_description": "Krav: 6 tegn lange, bogstaver og tal.",
+        "new_password_repeat": "Bekræftelsesadgangskode (gentag)",
+        "no_active_filter": "Intet aktivt filter tilgængeligt",
+        "no_last_login": "Ingen sidste UI-loginoplysninger",
+        "no_record": "Ingen optegnelser",
+        "password": "Kodeord",
+        "password_now": "Nuværende kodeord (bekræft ændring)",
+        "password_repeat": "Kodeord (gentag)",
+        "pushover_evaluate_x_prio": "Eskaler e-mail med høj prioritet [<code>X-Prioritet: 1</code>]",
+        "pushover_info": "Indstillinger for push-meddelelser gælder for al ren (ikke-spam) post, der leveres til <b>%s</b> inklusive aliaser (delt, ikke-delt, tagget).",
+        "pushover_only_x_prio": "Only consider high priority mail [<code>X-Priority: 1</code>]",
+        "pushover_sender_array": "Overvej følgende afsender-e-mail-adresser <small>(comma-separated)</small>",
+        "pushover_sender_regex": "Match afsendere efter følgende regex",
+        "pushover_text": "Notifikations tekst",
+        "pushover_title": "Notifikations titel",
+        "pushover_vars": "Når der ikke er defineret et afsenderfilter, overvejes alle mails.<br>Regex såvel filtre som nøjagtige afsenderkontrol kan defineres individuelt og vil blive betragtet i rækkefølge. De er ikke afhængige af hinanden.<br>Brugbare variabler til tekst og titel (vær opmærksom på databeskyttelsespolitikker)",
+        "pushover_verify": "Bekræft legitimationsoplysninger",
+        "q_add_header": "Uønsket Mappe",
+        "q_all": "Alle Kategorier",
+        "q_reject": "Afvist",
+        "quarantine_notification": "Karantænemeddelelser",
+        "quarantine_category": "Karantænemeddelelseskategori",
+        "quarantine_notification_info": "Når en meddelelse er sendt, markeres elementrne som \"notified\" og der sendes ingen yderligere meddelelser om denne særlige element.",
+        "quarantine_category_info": "Meddelelseskategorien \"Rejected\" inkluderer mail, der blev afvist, mens \"Junk folder\" vil underrette en bruger om mails, der blev sat i junk-mappen.",
+        "remove": "Slet",
+        "running": "Kører",
+        "save": "Gem ændring",
+        "save_changes": "Gem ændringer",
+        "sender_acl_disabled": "<span class=\"label label-danger\">Afsender tjek er slået fra</span>",
+        "shared_aliases": "Delte aliasadresser",
+        "shared_aliases_desc": "Delt alias påvirkes ikke af brugerspecifikke indstillinger såsom spamfilter eller krypteringspolitik. Tilselementnde spamfiltre kan kun foretages af en administrator som en politik, der dækker hele domænet.",
+        "show_sieve_filters": "Vis det aktive brugerfilter",
+        "sogo_profile_reset": "Nulstil SOGo profil",
+        "sogo_profile_reset_help": "Dette vil ødelægge en bruger SOGo-profil og <b>slette alle kontakt- og kalenderdata, der ikke kan hentes</b>.",
+        "sogo_profile_reset_now": "Nulstil profil nu",
+        "spam_aliases": "Midlertidige e-mail kaldenavne",
+        "spam_score_reset": "Nulstil til server Standardværdi",
+        "spamfilter": "Spam filter",
+        "spamfilter_behavior": "Bedømmelse",
+        "spamfilter_bl": "Sortliste",
+        "spamfilter_bl_desc": "Sortlistede e-mail-adresser til <b>altid</b> at klassificeres som spam og afvise. Afvist mail vil <b>ikke</b> kopieres til karantæne. Jokertegn kan bruges. Et filter anvendes kun til direkte aliaser (aliaser med en enkelt målpostkasse) eksklusive fang-aliaser og selve en postkasse.",
+        "spamfilter_default_score": "Standardværdi",
+        "spamfilter_green": "Grøn: denne besked er ikke uønsket",
+        "spamfilter_hint": "Den første værdi beskriver \"low spam score\", det andet repræsenterer \"high spam score\".",
+        "spamfilter_red": "Rød: Denne besked er uønsket og bliver afvist af serveren",
+        "spamfilter_table_action": "Handling",
+        "spamfilter_table_add": "Tilføj element",
+        "spamfilter_table_domain_policy": "n/a (domæne politik)",
+        "spamfilter_table_empty": "Intet data at vise",
+        "spamfilter_table_remove": "slet",
+        "spamfilter_table_rule": "Regl",
+        "spamfilter_wl": "Hvisliste",
+        "spamfilter_wl_desc": "Hvidlistede e-mail-adresser til <b>aldrig</b> at klassificeres som spam. Wildcards kan bruges. Et filter anvendes kun på direkte aliaser (aliaser med en enkelt målpostkasse) eksklusive catch-aliaser og selve en postkasse.",
+        "spamfilter_yellow": "Gul: denne besked kan være spam, vil blive tagget som spam og flyttes til din junk-mappe",
+        "status": "Status",
+        "sync_jobs": "Sync jobs",
+        "tag_handling": "Set handling for taggede mails",
+        "tag_help_example": "Eksempel på en tagget e-mail-adresse : me<b>+Tacaly</b>@example.org",
+        "tag_help_explain": "I undermappe: En ny undermappe opkaldt efter tagget oprettes under INBOX  (\"INBOX/Tacaly\").<br>\r\nI emne: navnene på tags bliver præpenderet til mailsemnet, eksempel:  \"[Tacaly] Mine Nyhedder\".",
+        "tag_in_none": "Gør intet",
+        "tag_in_subfolder": "I undermappe",
+        "tag_in_subject": "I emne",
+        "text": "Tekst",
+        "title": "Titel",
+        "tls_enforce_in": "Tving TLS indgående",
+        "tls_enforce_out": "Tving TLS udgående",
+        "tls_policy": "krypterings politik",
+        "tls_policy_warning": "<strong>Warning:</strong> If you decide to enforce encrypted mail transfer, you may lose emails.<br>Messages to not satisfy the policy will be bounced with a hard fail by the mail system.<br>This option applies to your primary email address (login name), all addresses derived from alias domains as well as alias addresses <b>with only this single mailbox</b> as target.",
+        "user_settings": "Bruger indstillinger",
+        "username": "Brugernavn",
+        "verify": "Bekræft",
+        "waiting": "Venter",
+        "week": "uge",
+        "weekly": "Ugeligt",
+        "weeks": "uger"
+    },
+    "warning": {
+        "cannot_delete_self": "Kan ikke slette en bruger som er logget ind.",
+        "domain_added_sogo_failed": "Domæne er tilføjet men kan ikke genstarte SOGo, tjek venligst dine server logs.",
+        "dovecot_restart_failed": "Dovecot kunne ikke genstarte, tjek venligst dine logs",
+        "fuzzy_learn_error": "Fuzzy hash lærings fejl: %s",
+        "hash_not_found": "Hash blev ikke fundet eller allerede slettet",
+        "ip_invalid": "Sprang over ugyldige IP: %s",
+        "no_active_admin": "Kan ikke deaktivere den sidste administrator",
+        "quota_exceeded_scope": "Domænekvote overskredet: Kun ubegrænsede postkasser kan oprettes i dette domæneomfang.",
+        "session_token": "Form nøgle ugyldig: Nøgle passer ikke",
+        "session_ua": "Form nøgle ugyldig: Bruger-Agent gyldighedskontrols fejl"
+    }
+}
diff --git a/mailcow/src/mailcow-dockerized/data/web/lang/lang.de.json b/mailcow/src/mailcow-dockerized/data/web/lang/lang.de.json
index 4ab9331..4d2f27a 100644
--- a/mailcow/src/mailcow-dockerized/data/web/lang/lang.de.json
+++ b/mailcow/src/mailcow-dockerized/data/web/lang/lang.de.json
@@ -2,19 +2,22 @@
     "acl": {
         "alias_domains": "Alias-Domains hinzufügen",
         "app_passwds": "App-Passwörter verwalten",
-        "bcc_maps": "BCC Maps",
-        "delimiter_action": "Delimiter Aktionen (tags)",
+        "bcc_maps": "BCC-Maps",
+        "delimiter_action": "Delimiter-Aktionen (tags)",
+        "domain_desc": "Domainbeschreibung ändern",
+        "domain_relayhost": "Relayhost für eine Domain setzen",
         "eas_reset": "EAS-Cache zurücksetzen",
         "extend_sender_acl": "Eingabe externer Absenderadressen erlauben",
         "filters": "Filter",
         "login_as": "Einloggen als Mailbox-Benutzer",
+        "mailbox_relayhost": "Relayhost für eine Mailbox setzen",
         "prohibited": "Untersagt durch Richtlinie",
         "protocol_access": "Ändern der erlaubten Protokolle",
         "pushover": "Pushover",
         "quarantine": "Quarantäne-Aktionen",
         "quarantine_attachments": "Anhänge aus Quarantäne",
-        "quarantine_notification": "Ändern der Quarantäne-Benachrichtigung",
         "quarantine_category": "Ändern der Quarantäne-Benachrichtigungskategorie",
+        "quarantine_notification": "Ändern der Quarantäne-Benachrichtigung",
         "ratelimit": "Rate limit",
         "recipient_maps": "Empfängerumschreibungen",
         "smtp_ip_access": "Verwalten der erlaubten Hosts für SMTP",
@@ -26,10 +29,13 @@
         "syncjobs": "Sync Jobs",
         "tls_policy": "Verschlüsselungsrichtlinie",
         "unlimited_quota": "Unendliche Quota für Mailboxen",
-        "domain_desc": "Domainbeschreibung ändern"
+        "xmpp_admin": "Benutzer zum XMPP-Administrator ernennen",
+        "xmpp_domain_access": "XMPP-Zugang einer Domain konfigurieren",
+        "xmpp_mailbox_access": "XMPP-Zugang eines Benutzers einstellen",
+        "xmpp_prefix": "XMPP-Subdomain/Präfix ändern"
     },
     "add": {
-        "activate_filter_warn": "Alle anderen Filter diesen Typs werden deaktiviert, falls dieses Script aktiv markiert wird.",
+        "activate_filter_warn": "Alle anderen Filter dieses Typs werden deaktiviert, falls dieses Script aktiv markiert wird.",
         "active": "Aktiv",
         "add": "Hinzufügen",
         "add_domain_only": "Nur Domain hinzufügen",
@@ -41,7 +47,7 @@
         "app_name": "App-Name",
         "app_password": "App-Passwort hinzufügen",
         "automap": "Ordner automatisch mappen (\"Sent items\", \"Sent\" => \"Sent\" etc.)",
-        "backup_mx_options": "Relay Optionen",
+        "backup_mx_options": "Relay-Optionen",
         "comment_info": "Ein privater Kommentar ist für den Benutzer nicht einsehbar. Ein öffentlicher Kommentar wird als Tooltip im Interface des Benutzers angezeigt.",
         "custom_params": "Eigene Parameter",
         "custom_params_hint": "Richtig: --param=xy, falsch: --param xy",
@@ -53,7 +59,7 @@
         "disable_login": "Login verbieten (Mails werden weiterhin angenommen)",
         "domain": "Domain",
         "domain_matches_hostname": "Domain %s darf nicht dem Hostnamen entsprechen",
-        "domain_quota_m": "Domain Speicherplatz gesamt (MiB)",
+        "domain_quota_m": "Domain-Speicherplatz gesamt (MiB)",
         "enc_method": "Verschlüsselung",
         "exclude": "Elemente ausschließen (Regex)",
         "full_name": "Vor- und Nachname",
@@ -84,7 +90,7 @@
         "relay_all": "Alle Empfänger-Adressen relayen",
         "relay_all_info": "↪ Wenn <b>nicht</b> alle Empfänger-Adressen relayt werden sollen, müssen \"blinde\" Mailboxen für jede Adresse, die relayt werden soll, erstellen werden.",
         "relay_domain": "Diese Domain relayen",
-        "relay_transport_info": "<div class=\"label label-info\">Info</div> Transport Maps können erstellt werden, um  individuelle Ziele für eine Relay-Domain zu definieren.",
+        "relay_transport_info": "<div class=\"label label-info\">Info</div> Transport-Maps können erstellt werden, um  individuelle Ziele für eine Relay-Domain zu definieren.",
         "relay_unknown_only": "Nur nicht-lokale Mailboxen relayen. Existente Mailboxen werden weiterhin lokal zugestellt.",
         "relayhost_wrapped_tls_info": "Bitte <b>keine</b> \"TLS-wrapped Ports\" verwenden (etwa SMTPS via Port 465/tcp).<br>\r\nDer Transport wird stattdessen STARTTLS anfordern, um TLS zu verwenden. TLS kann unter \"TLS Policy Maps\" erzwungen werden.",
         "select": "Bitte auswählen",
@@ -102,7 +108,15 @@
         "timeout2": "Timeout für Verbindung zum lokalen Host",
         "username": "Benutzername",
         "validate": "Validieren",
-        "validation_success": "Erfolgreich validiert"
+        "validation_success": "Erfolgreich validiert",
+        "xmpp": "XMPP für diese Domain aktivieren",
+        "xmpp_access": "XMPP-Zugang",
+        "xmpp_access_info": "XMPP muss für diese Domain aktiviert sein.",
+        "xmpp_admin": "XMPP-Administrator",
+        "xmpp_admin_info": "<b>Vorsicht:</b> Ernennt den Benutzer zum Administrator der jeweiligen XMPP-Domain.",
+        "xmpp_info": "Diese Funktion stellt eine Chat-Funktionalität für die Domain bereit.",
+        "xmpp_prefix": "XMPP-Präfix für Domain (\"im\" für <b>im</b>.example.org)",
+        "xmpp_prefix_info": "Für die Bereitstellung eines Zertifikates sollte vorab ein DNS-Eintrag, etwa in Form eines CNAMEs, für <b>im</b>.example.org sowie <b>*.im</b>.example.org auf <b>%s</b> zeigend angelegt werden. Im Anschluss an die Aktivierung sollte der DNS-Check für diese Domain ausgeführt werden."
     },
     "admin": {
         "access": "Zugang",
@@ -118,13 +132,15 @@
         "add_relayhost": "Senderabhängigen Transport hinzufügen",
         "add_relayhost_hint": "Bitte beachten Sie, dass Anmeldedaten unverschlüsselt gespeichert werden.<br>\r\n  Angelegte Transporte dieser Art sind <b>senderabhängig</b> und müssen erst einer Domain zugewiesen werden, bevor sie als Transport verwendet werden.<br>\r\n  Diese Einstellungen entsprechen demnach <i>nicht</i> dem \"relayhost\" Parameter in Postfix.",
         "add_row": "Reihe hinzufügen",
-        "add_settings_rule": "Rspamd Regel hinzufügen",
+        "add_settings_rule": "Rspamd-Regel hinzufügen",
         "add_transport": "Transport hinzufügen",
         "add_transports_hint": "Bitte beachten Sie, dass Anmeldedaten unverschlüsselt gespeichert werden.",
         "additional_rows": " zusätzliche Zeilen geladen",
         "admin": "Administrator",
         "admin_details": "Administrator bearbeiten",
         "admin_domains": "Domain-Zuweisungen",
+        "admins": "Administratoren",
+        "admins_ldap": "LDAP-Administratoren",
         "advanced_settings": "Erweiterte Einstellungen",
         "api_allow_from": "IP-Adressen oder Netzwerke (CIDR Notation) für Zugriff auf API",
         "api_info": "Die API befindet sich noch in Entwicklung, die Dokumentation kann unter <a href=\"/api\">/api</a> abgerufen werden.",
@@ -136,10 +152,11 @@
         "arrival_time": "Ankunftszeit (Serverzeit)",
         "authed_user": "Auth. Benutzer",
         "ays": "Soll der Vorgang wirklich ausgeführt werden?",
-        "ban_list_info": "Übersicht ausgesperrter Netzwerke: <b>Netzwerk (verbleibende Banzeit) - [Aktionen]</b>.<br />IPs, die zum Entsperren eingereiht werden, verlassen die Liste aktiver Bans nach wenigen Sekunden.<br />Rote Labels sind Indikatoren für aktive Blacklisteinträge.",
+        "ban_list_info": "Übersicht ausgesperrter Netzwerke: <b>Netzwerk (verbleibende Bannzeit) - [Aktionen]</b>.<br />IPs, die zum Entsperren eingereiht werden, verlassen die Liste aktiver Banns nach wenigen Sekunden.<br />Rote Labels sind Indikatoren für aktive Blacklist-Einträge.",
         "change_logo": "Logo ändern",
         "configuration": "Konfiguration",
-        "credentials_transport_warning": "<b>Warnung</b>: Das Hinzufügen einer neuen Regel bewirkt die Aktualisierung der Authentifizierungsdaten aller vorhandenen Einträge mit identischem Host.",
+        "convert_html_to_text": "Konvertiere HTML zu reinem Text",
+        "credentials_transport_warning": "<b>Warnung</b>: Das Hinzufügen einer neuen Regel bewirkt die Aktualisierung der Authentifizierungsdaten aller vorhandenen Einträge mit identischem Next Hop.",
         "customer_id": "Kunde",
         "customize": "UI-Anpassung",
         "delete_queue": "Alle löschen",
@@ -169,11 +186,11 @@
         "excludes": "Diese Empfänger ausschließen",
         "f2b_ban_time": "Bannzeit in Sekunden",
         "f2b_blacklist": "Blacklist für Netzwerke und Hosts",
-        "f2b_filter": "Regex Filter",
+        "f2b_filter": "Regex-Filter",
         "f2b_list_info": "Ein Host oder Netzwerk auf der Blacklist wird immer eine Whitelist-Einheit überwiegen. <b>Die Aktualisierung der Liste dauert einige Sekunden.</b>",
         "f2b_max_attempts": "Max. Versuche",
-        "f2b_netban_ipv4": "Netzbereich für IPv4-Bans (8-32)",
-        "f2b_netban_ipv6": "Netzbereich für IPv6-Bans (8-128)",
+        "f2b_netban_ipv4": "Netzbereich für IPv4-Banns (8-32)",
+        "f2b_netban_ipv6": "Netzbereich für IPv6-Banns (8-128)",
         "f2b_parameters": "Fail2ban-Parameter",
         "f2b_regex_info": "Berücksichtigte Logs: SOGo, Postfix, Dovecot, PHP-FPM.",
         "f2b_retry_window": "Wiederholungen im Zeitraum von (s)",
@@ -187,9 +204,10 @@
         "generate": "generieren",
         "guid": "GUID - Eindeutige Instanz-ID",
         "guid_and_license": "GUID & Lizenz",
-        "hash_remove_info": "Das Entfernen eines Ratelimit Hashes - sofern noch existent - bewirkt den Reset gezählter Nachrichten dieses Elements.<br>\r\n  Jeder Hash wird durch eine eindeutige Farbe gekennzeichnet.",
+        "hash_remove_info": "Das Entfernen eines Ratelimit-Hashes - sofern noch existent - bewirkt den Reset gezählter Nachrichten dieses Elements.<br>\r\n  Jeder Hash wird durch eine eindeutige Farbe gekennzeichnet.",
         "help_text": "Hilfstext unter Login-Maske (HTML ist zulässig)",
         "host": "Host",
+        "html": "HTML",
         "import": "Importieren",
         "import_private_key": "Private Key importieren",
         "in_use_by": "Verwendet von",
@@ -197,28 +215,38 @@
         "include_exclude": "Ein- und Ausschlüsse",
         "include_exclude_info": "Ohne Auswahl werden <b>alle Mailboxen</b> adressiert.",
         "includes": "Diese Empfänger einschließen",
+        "is_mx_based": "MX-basiert",
         "last_applied": "Zuletzt angewendet",
         "license_info": "Eine Lizenz ist nicht erforderlich, hilft jedoch der Entwicklung mailcows.<br><a href=\"https://www.servercow.de/mailcow#sal\" target=\"_blank\" alt=\"SAL Bestellung\">Hier kann die mailcow-GUID registriert werden.</a> Alternativ ist <a href=\"https://www.servercow.de/mailcow#support\" target=\"_blank\" alt=\"SAL Bestellung\">die Bestellung von Support-Paketen möglich</a>.",
         "link": "Link",
         "loading": "Bitte warten...",
+        "login_time": "Zeit",
         "logo_info": "Die hochgeladene Grafik wird für die Navigationsleiste auf eine Höhe von 40px skaliert. Für die Darstellung auf der Login-Maske beträgt die skalierte Breite maximal 250px. Eine frei skalierbare Grafik (etwa SVG) wird empfohlen.",
-        "lookup_mx": "Ziel gegen MX prüfen (etwa .outlook.com, um alle Ziele mit MX *.outlook.com zu routen)",
+        "lookup_mx": "Ziel mit MX vergleichen (Regex, etwa <code>.*google\\.com</code>, um alle Ziele mit MX *google.com zu routen)",
         "main_name": "\"mailcow UI\" Name",
         "merged_vars_hint": "Ausgegraute Reihen wurden aus der Datei <code>vars.(local.)inc.php</code> gelesen und können hier nicht verändert werden.",
         "message": "Nachricht",
         "message_size": "Nachrichtengröße",
         "nexthop": "Next Hop",
         "no": "&#10005;",
-        "no_active_bans": "Keine aktiven Bans",
+        "no_active_bans": "Keine aktiven Banns",
         "no_new_rows": "Keine weiteren Zeilen vorhanden",
         "no_record": "Kein Eintrag",
         "oauth2_client_id": "Client ID",
         "oauth2_client_secret": "Client Secret",
-        "oauth2_info": "Die OAuth2 Implementierung unterstützt den Grant Type \"Authorization Code\" mit Refresh Tokens.<br>\r\nDer Server wird automatisch einen neuen Refresh Token ausstellen, sobald ein vorheriger Token gegen einen Access Token eingetauscht wurde.<br><br>\r\n→ Der Standard Scope lautet <i>profile</i>. Nur Mailbox-Benutzer können sich gegen OAuth2 authentifizieren. Wird kein Scope angegeben, verwendet das System per Standard <i>profile</i>.<br>\r\n→ Der <i>state</i> Parameter wird im Zuge des Autorisierungsprozesses benötigt.<br><br>\r\nDie Pfade für die OAuth2 API lauten wie folgt: <br>\r\n<ul>\r\n  <li>Authorization Endpoint: <code>/oauth/authorize</code></li>\r\n  <li>Token Endpoint: <code>/oauth/token</code></li>\r\n  <li>Resource Page:  <code>/oauth/profile</code></li>\r\n</ul>\r\nDie Regenerierung des Client Secrets wird vorhandene Authorization Codes nicht invalidieren, dennoch wird der Renew des Access Tokens durch einen Refresh Token nicht mehr gelingen.<br><br>\r\nDas Entfernen aller Client Tokens verursacht die umgehende Terminierung aller aktiven OAuth2 Sessions. Clients müssen sich erneut gegen die OAuth2 Anwendung authentifizieren.",
-        "oauth2_redirect_uri": "Redirect URI",
+        "oauth2_info": "Die OAuth2 Implementierung unterstützt den Grant Type \"Authorization Code\" mit Refresh Tokens.<br>\r\nDer Server wird automatisch einen neuen Refresh Token ausstellen, sobald ein vorheriger Token gegen einen Access Token eingetauscht wurde.<br><br>\r\n&#8226; Der Standard Scope lautet <i>profile</i>. Nur Mailbox-Benutzer können sich gegen OAuth2 authentifizieren. Wird kein Scope angegeben, verwendet das System per Standard <i>profile</i>.<br>\r\n&#8226; Der <i>state</i> Parameter wird im Zuge des Autorisierungsprozesses benötigt.<br><br>\r\nDie Pfade für die OAuth2 API lauten wie folgt: <br>\r\n<ul>\r\n  <li>Authorization Endpoint: <code>/oauth/authorize</code></li>\r\n  <li>Token Endpoint: <code>/oauth/token</code></li>\r\n  <li>Resource Page:  <code>/oauth/profile</code></li>\r\n</ul>\r\nDie Regenerierung des Client Secrets wird vorhandene Authorization Codes nicht invalidieren, dennoch wird der Renew des Access Tokens durch einen Refresh Token nicht mehr gelingen.<br><br>\r\nDas Entfernen aller Client Tokens verursacht die umgehende Terminierung aller aktiven OAuth2 Sessions. Clients müssen sich erneut gegen die OAuth2 Anwendung authentifizieren.",
+        "oauth2_redirect_uri": "Redirect-URI",
         "oauth2_renew_secret": "Neues Client Secret generieren",
         "oauth2_revoke_tokens": "Alle Client Tokens entfernen",
+        "optional": "Optional",
         "password": "Passwort",
+        "password_length": "Passwortlänge",
+        "password_policy": "Passwortrichtlinie",
+        "password_policy_chars": "Muss ein alphabetisches Zeichen enthalten",
+        "password_policy_length": "Mindestlänge des Passwortes ist %d Zeichen",
+        "password_policy_lowerupper": "Muss Großbuchstaben und Kleinbuchstaben enthalten",
+        "password_policy_numbers": "Muss eine Ziffer enthalten",
+        "password_policy_special_chars": "Muss Sonderzeichen enthalten",
         "password_repeat": "Passwort wiederholen",
         "priority": "Gewichtung",
         "private_key": "Private Key",
@@ -226,8 +254,8 @@
         "quarantine_bcc": "Eine Kopie aller Benachrichtigungen (BCC) an folgendes Postfach senden:<br><small>Leer bedeutet deaktiviert. <b>Unsignierte, ungeprüfte E-Mail. Sollte nur intern zugestellt werden.</b></small>",
         "quarantine_exclude_domains": "Domains und Alias-Domains ausschließen",
         "quarantine_max_age": "Maximales Alter in Tagen<br><small>Wert muss größer oder gleich 1 Tag sein.</small>",
-        "quarantine_max_size": "Maximale Größe in MiB (größere Elemente werden verworfen):<br><small>0 bedeutet <b>nicht</b> unlimitiert.</small>",
         "quarantine_max_score": "Nicht benachrichtigen, wenn der Spam-Score höher ist als der folgende Wert:<br><small>Standardwert 9999.0</small>",
+        "quarantine_max_size": "Maximale Größe in MiB (größere Elemente werden verworfen):<br><small>0 bedeutet <b>nicht</b> unlimitiert.</small>",
         "quarantine_notification_html": "Benachrichtigungs-E-Mail Inhalt:<br><small>Leer lassen, um Standard-Template wiederherzustellen.</small>",
         "quarantine_notification_sender": "Benachrichtigungs-E-Mail Absender",
         "quarantine_notification_subject": "Benachrichtigungs-E-Mail Betreff",
@@ -240,9 +268,9 @@
         "queue_deliver_mail": "Ausliefern",
         "queue_hold_mail": "Zurückhalten",
         "queue_manager": "Queue Manager",
+        "queue_show_message": "Nachricht anzeigen",
         "queue_unban": "Entsperren einreihen",
         "queue_unhold_mail": "Freigeben",
-        "queue_show_message": "Nachricht anzeigen",
         "quota_notification_html": "Benachrichtigungs-E-Mail Inhalt:<br><small>Leer lassen, um Standard-Template wiederherzustellen.</small>",
         "quota_notification_sender": "Benachrichtigungs-E-Mail Absender",
         "quota_notification_subject": "Benachrichtigungs-E-Mail Betreff",
@@ -256,8 +284,9 @@
         "recipients": "Empfänger",
         "refresh": "Neu laden",
         "regen_api_key": "API-Key regenerieren",
-        "regex_maps": "Regex Maps",
+        "regex_maps": "Regex-Maps",
         "relay_from": "Absenderadresse",
+        "relay_rcpt": "Empfängeradresse",
         "relay_run": "Test durchführen",
         "relayhosts": "Senderabhängige Transport Maps",
         "relayhosts_hint": "Erstellen Sie senderabhängige Transporte, um diese im Einstellungsdialog einer Domain auszuwählen.<br>\r\n  Der Transporttyp lautet immer \"smtp:\", verwendet TLS wenn angeboten und unterstützt kein wrapped TLS (SMTPS). Benutzereinstellungen bezüglich Verschlüsselungsrichtlinie werden beim Transport berücksichtigt.<br>\r\n  Gilt neben ausgewählter Domain auch für untergeordnete Alias-Domains.",
@@ -273,32 +302,36 @@
         "rsetting_none": "Keine Regel hinterlegt",
         "rsettings_insert_preset": "Beispiel \"%s\" laden",
         "rsettings_preset_1": "Alles außer DKIM und Ratelimits für authentifizierte Benutzer deaktivieren",
-        "rsettings_preset_2": "Spam an Postmaster-Addressen nicht blockieren",
+        "rsettings_preset_2": "Spam an Postmaster-Adressen nicht blockieren",
         "rsettings_preset_3": "Nur einem oder vielen Absendern erlauben, eine Mailbox anzuschreiben (etwa interne Mailboxen)",
+        "rsettings_preset_4": "Rspamd für eine Domain deaktivieren",
         "rspamd-com_settings": "Ein Name wird automatisch generiert. Beispielinhalte zur Einsicht stehen nachstehend bereit. Siehe auch <a href=\"https://rspamd.com/doc/configuration/settings.html#settings-structure\" target=\"_blank\">Rspamd docs</a>",
         "rspamd_global_filters": "Globale Filter-Maps",
         "rspamd_global_filters_agree": "Ich werde vorsichtig sein!",
         "rspamd_global_filters_info": "Globale Filter-Maps steuern globales White- und Blacklisting dieses Servers.",
         "rspamd_global_filters_regex": "Die akzeptierte Form für Einträge sind <b>ausschließlich</b> Regular Expressions.\r\n  Trotz rudimentärer Überprüfung der Map, kann es zu fehlerhaften Einträgen kommen, die Rspamd im schlechtesten Fall mit unvorhersehbarer Funktionalität bestraft.<br>\r\n  Das korrekte Format lautet \"/pattern/options\" (Beispiel: <code>/.+@domain\\.tld/i</code>).<br>\r\n  Der Name der Map beschreibt die jeweilige Funktion.<br>\r\n  Rspamd versucht die Maps umgehend aufzulösen. Bei Problemen sollte <a href=\"\" data-toggle=\"modal\" data-container=\"rspamd-mailcow\" data-target=\"#RestartContainer\">Rspamd manuell neugestartet werden</a><br>Elemente auf Blacklists sind von der Quarantäne ausgeschlossen.",
-        "rspamd_settings_map": "Rspamd Settings Map",
+        "rspamd_settings_map": "Rspamd-Settings-Map",
         "sal_level": "Moo-Level",
         "save": "Änderungen speichern",
         "search_domain_da": "Suche Domains",
         "send": "Senden",
         "sender": "Sender",
+        "service": "Dienst",
         "service_id": "Service",
         "source": "Quelle",
         "spamfilter": "Spamfilter",
         "subject": "Betreff",
+        "success": "Erfolg",
         "sys_mails": "System-E-Mails",
         "text": "Text",
         "time": "Zeit",
         "title": "Title",
         "title_name": "\"mailcow UI\" Webseiten Titel",
         "to_top": "Nach oben",
-        "transport_dest_format": "Syntax: example.org, .example.org, *, box@example.org (mehrere Werte getrennt durch Komma einzugeben)",
-        "transport_maps": "Transport Maps",
-        "transports_hint": "→ Transport Maps <b>überwiegen</b> senderabhängige Transport Maps.<br>\r\n→ Transport Maps ignorieren Mailbox-Einstellungen für ausgehende Verschlüsselung. Eine serverweite TLS-Richtlinie wird jedoch angewendet.<br>\r\n→ Der Transport erfolgt immer via \"smtp:\", verwendet TLS wenn angeboten und unterstützt kein wrapped TLS (SMTPS).<br>\r\n→ Adressen, die mit \"/localhost$/\" übereinstimmen, werden immer via \"local:\" transportiert, daher sind sie von einer Zieldefinition \"*\" ausgeschlossen.<br>\r\n→ Die Authentifizierung wird anhand des \"Next hop\" Parameters ermittelt. Hierbei würde bei einem beispielhaften Wert \"[host]:25\" immer zuerst \"host\" abfragt und <b>erst im Anschluss</b> \"[host]:25\". Dieses Verhalten schließt die <b>gleichzeitige Verwendung</b> von Einträgen der Art \"host\" sowie \"[host]:25\" aus.",
+        "transport_dest_format": "Regex oder Syntax: example.org, .example.org, *, box@example.org (getrennt durch Komma einzugeben)",
+        "transport_maps": "Transport-Maps",
+        "transport_test_rcpt_info": "&#8226; Die Verwendung von null@hosted.mailcow.de testet das Relay gegen ein fremdes Ziel.",
+        "transports_hint": "&#8226; Transport-Maps <b>überwiegen</b> senderabhängige Transport Maps.<br>\r\n&#8226; MX-basierte Transporte werden bevorzugt.<br>\r\n&#8226; Transport-Maps ignorieren Mailbox-Einstellungen für ausgehende Verschlüsselung. Eine serverweite TLS-Richtlinie wird jedoch angewendet.<br>\r\n&#8226; Der Transport erfolgt immer via \"smtp:\", verwendet TLS wenn angeboten und unterstützt kein wrapped TLS (SMTPS).<br>\r\n&#8226; Adressen, die mit \"/localhost$/\" übereinstimmen, werden immer via \"local:\" transportiert, daher sind sie von einer Zieldefinition \"*\" ausgeschlossen.<br>\r\n&#8226; Die Authentifizierung wird anhand des \"Next hop\" Parameters ermittelt. Hierbei würde bei einem beispielhaften Wert \"[host]:25\" immer zuerst \"host\" abfragt und <b>erst im Anschluss</b> \"[host]:25\". Dieses Verhalten schließt die <b>gleichzeitige Verwendung</b> von Einträgen der Art \"host\" sowie \"[host]:25\" aus.",
         "ui_footer": "Footer (HTML zulässig)",
         "ui_header_announcement": "Ankündigungen",
         "ui_header_announcement_active": "Ankündigung aktivieren",
@@ -306,9 +339,9 @@
         "ui_header_announcement_help": "Die Ankündigungsbox erzeugt einen deutlichen Hinweis für alle Benutzer und auf der Login-Seite der UI.",
         "ui_header_announcement_select": "Ankündigungstyp auswählen",
         "ui_header_announcement_type": "Typ",
+        "ui_header_announcement_type_danger": "Sehr wichtig",
         "ui_header_announcement_type_info": "Info",
         "ui_header_announcement_type_warning": "Wichtig",
-        "ui_header_announcement_type_danger": "Sehr wichtig",
         "ui_texts": "UI-Label und Texte",
         "unban_pending": "ausstehend",
         "unchanged_if_empty": "Unverändert, wenn leer",
@@ -344,13 +377,14 @@
         "domain_quota_m_in_use": "Domain-Speicherplatzlimit muss größer oder gleich %d MiB sein",
         "extra_acl_invalid": "Externe Absenderadresse \"%s\" ist ungültig",
         "extra_acl_invalid_domain": "Externe Absenderadresse \"%s\" verwendet eine ungültige Domain",
+        "fido2_verification_failed": "FIDO2-Verifizierung fehlgeschlagen: %s",
         "file_open_error": "Datei kann nicht zum Schreiben geöffnet werden",
         "filter_type": "Falscher Filtertyp",
         "from_invalid": "Die Absenderadresse muss eine gültige E-Mail-Adresse sein",
         "global_filter_write_error": "Kann Filterdatei nicht schreiben: %s",
-        "global_map_invalid": "Rspamd Map %s ist ungültig",
+        "global_map_invalid": "Rspamd-Map %s ist ungültig",
         "global_map_write_error": "Kann globale Map ID %s nicht schreiben: %s",
-        "goto_empty": "Eine Alias-Adresse muss auf mindestens eine gütlige Ziel-Adresse zeigen",
+        "goto_empty": "Eine Alias-Adresse muss auf mindestens eine gültige Ziel-Adresse zeigen",
         "goto_invalid": "Ziel-Adresse %s ist ungültig",
         "ham_learn_error": "Ham Lernfehler: %s",
         "imagick_exception": "Fataler Bildverarbeitungsfehler",
@@ -387,6 +421,7 @@
         "network_host_invalid": "Netzwerk oder Host ungültig: %s",
         "next_hop_interferes": "%s verhindert das Hinzufügen von Next Hop %s",
         "next_hop_interferes_any": "Ein vorhandener Eintrag verhindert das Hinzufügen von Next Hop %s",
+        "nginx_reload_failed": "Nginx Reload ist fehlgeschlagen: %s",
         "no_user_defined": "Kein Benutzer definiert",
         "object_exists": "Objekt %s existiert bereits",
         "object_is_not_numeric": "Wert %s ist nicht numerisch",
@@ -402,7 +437,7 @@
         "quota_not_0_not_numeric": "Speicherplatz muss numerisch und >= 0 sein",
         "recipient_map_entry_exists": "Eine Empfängerumschreibung für Objekt \"%s\" existiert bereits",
         "redis_error": "Redis Fehler: %s",
-        "relayhost_invalid": "Mapeintrag %s ist ungültig",
+        "relayhost_invalid": "Map-Eintrag %s ist ungültig",
         "release_send_failed": "Die Nachricht konnte nicht versendet werden: %s",
         "reset_f2b_regex": "Regex Filter konnten nicht in vorgegebener Zeit zurückgesetzt werden, bitte erneut versuchen oder die Webseite neu laden.",
         "resource_invalid": "Ressourcenname %s ist ungültig",
@@ -425,51 +460,63 @@
         "tls_policy_map_entry_exists": "Eine TLS-Richtlinie \"%s\" existiert bereits",
         "tls_policy_map_parameter_invalid": "Parameter ist ungültig",
         "totp_verification_failed": "TOTP-Verifizierung fehlgeschlagen",
-        "transport_dest_exists": "Transport Maps Ziel \"%s\" existiert bereits",
+        "transport_dest_exists": "Transport-Maps-Ziel \"%s\" existiert bereits",
         "u2f_verification_failed": "U2F-Verifizierung fehlgeschlagen: %s",
-        "fido2_verification_failed": "FIDO2-Verifizierung fehlgeschlagen: %s",
         "unknown": "Ein unbekannter Fehler trat auf",
-        "unknown_tfa_method": "Unbekannte TFA Methode",
+        "unknown_tfa_method": "Unbekannte TFA-Methode",
         "unlimited_quota_acl": "Unendliche Quota untersagt durch ACL",
         "username_invalid": "Benutzername %s kann nicht verwendet werden",
         "validity_missing": "Bitte geben Sie eine Gültigkeitsdauer an",
         "value_missing": "Bitte alle Felder ausfüllen",
+        "xmpp_map_write_error": "Kann XMPP-Map nicht schreiben: %s",
+        "xmpp_reload_failed": "XMPP konnte nicht neu geladen werden",
+        "xmpp_restart_failed": "XMPP konnte nicht neu gestartet werden",
         "yotp_verification_failed": "Yubico OTP-Verifizierung fehlgeschlagen: %s"
     },
     "debug": {
         "chart_this_server": "Chart (dieser Server)",
         "containers_info": "Container-Information",
         "disk_usage": "Festplattennutzung",
+        "docs": "Dokumente",
         "external_logs": "Externe Logs",
         "history_all_servers": "History (alle Server)",
         "in_memory_logs": "In-memory Logs",
         "jvm_memory_solr": "JVM-Speicherauslastung",
+        "last_modified": "Zuletzt geändert",
         "log_info": "<p>mailcow <b>in-memory Logs</b> werden in Redis Listen gespeichert, die maximale Anzahl der Einträge pro Anwendung richtet sich nach LOG_LINES (%d).\r\n  <br>In-memory Logs sind vergänglich und nicht zur ständigen Aufbewahrung bestimmt. Alle Anwendungen, die in-memory protokollieren, schreiben ebenso in den Docker Daemon.\r\n  <br>Das in-memory Protokoll versteht sich als schnelle Übersicht zum Debugging eines Containers, für komplexere Protokolle sollte der Docker Daemon konsultiert werden.</p>\r\n  <p><b>Externe Logs</b> werden via API externer Applikationen bezogen.</p>\r\n  <p><b>Statische Logs</b> sind weitestgehend Aktivitätsprotokolle, die nicht in den Docker Daemon geschrieben werden, jedoch permanent verfügbar sein müssen (ausgeschlossen API Logs).</p>",
+        "login_time": "Zeit",
         "logs": "Protokolle",
+        "online_users": "Benutzer online",
         "restart_container": "Neustart",
+        "service": "Dienst",
+        "size": "Größe",
         "solr_dead": "Solr startet, ist deaktiviert oder temporär nicht erreichbar.",
-        "solr_docs": "Dokumente",
-        "solr_last_modified": "Zuletzt geändert",
-        "solr_size": "Größe",
-        "solr_started_at": "Gestartet am",
         "solr_status": "Solr Status",
-        "solr_uptime": "Uptime",
+        "started_at": "Gestartet am",
         "started_on": "Gestartet am",
         "static_logs": "Statische Logs",
-        "system_containers": "System & Container"
+        "success": "Erfolg",
+        "system_containers": "System & Container",
+        "uptime": "Uptime",
+        "username": "Benutzername",
+        "xmpp_dead": "XMPP startet, ist deaktiviert oder temporär nicht erreichbar.",
+        "xmpp_status": "XMPP Status"
     },
     "diagnostics": {
         "cname_from_a": "Wert abgeleitet von A/AAAA-Eintrag. Wird unterstützt, sofern der Eintrag auf die korrekte Ressource zeigt.",
         "dns_records": "DNS-Einträge",
         "dns_records_24hours": "Bitte beachten Sie, dass es bis zu 24 Stunden dauern kann, bis Änderungen an Ihren DNS-Einträgen als aktueller Status auf dieser Seite dargestellt werden. Diese Seite ist nur als Hilfsmittel gedacht, um die korrekten Werte für DNS-Einträge anzuzeigen und zu überprüfen, ob die Daten im DNS hinterlegt sind.",
         "dns_records_data": "Korrekte Daten",
+        "dns_records_docs": "Die <a target=\"_blank\" href=\"https://mailcow.github.io/mailcow-dockerized-docs/prerequisite-dns/\">Online-Dokumentation</a> enthält weitere Informationen zur DNS-Konfiguration.",
         "dns_records_name": "Name",
         "dns_records_status": "Aktueller Status",
         "dns_records_type": "Typ",
         "optional": "Dieser Eintrag ist optional."
     },
     "edit": {
+        "acl": "ACL (Berechtigungen)",
         "active": "Aktiv",
+        "admin": "Administrator bearbeiten",
         "advanced_settings": "Erweiterte Einstellungen",
         "alias": "Alias bearbeiten",
         "allow_from_smtp": "Nur folgende IPs für <b>SMTP</b> erlauben",
@@ -478,10 +525,10 @@
         "app_name": "App-Name",
         "app_passwd": "App-Passwörter",
         "automap": "Ordner automatisch mappen (\"Sent items\", \"Sent\" => \"Sent\" etc.)",
-        "backup_mx_options": "Relay Optionen",
+        "backup_mx_options": "Relay-Optionen",
         "bcc_dest_format": "BCC-Ziel muss eine gültige E-Mail-Adresse sein.",
-        "client_id": "Client ID",
-        "client_secret": "Client Secret",
+        "client_id": "Client-ID",
+        "client_secret": "Client-Secret",
         "comment_info": "Ein privater Kommentar ist für den Benutzer nicht einsehbar. Ein öffentlicher Kommentar wird als Tooltip im Interface des Benutzers angezeigt.",
         "delete1": "Lösche Nachricht nach Übertragung vom Quell-Server",
         "delete2": "Lösche Nachrichten von Ziel-Server, die nicht auf Quell-Server vorhanden sind",
@@ -498,19 +545,21 @@
         "encryption": "Verschlüsselung",
         "exclude": "Elemente ausschließen (Regex)",
         "extended_sender_acl": "Externe Absenderadressen",
-        "extended_sender_acl_info": "Der DKIM Domainkey der externen Absenderdomain sollte in diesen Server importiert werden, falls vorhanden.<br>\r\n  Wird SPF verwendet, muss diesem Server der Versand gestattet werden.<br>\r\n  Wird eine Domain oder Alias-Domain zu diesem Server hinzugefügt, die sich mit der externen Absenderadresse überschneidet, wird der externe Absender hier entfernt.<br>\r\n  Ein Eintrag @domain.tld erlaubt den Versand als *@domain.tld",
+        "extended_sender_acl_info": "Der DKIM-Domainkey der externen Absenderdomain sollte in diesen Server importiert werden, falls vorhanden.<br>\r\n  Wird SPF verwendet, muss diesem Server der Versand gestattet werden.<br>\r\n  Wird eine Domain oder Alias-Domain zu diesem Server hinzugefügt, die sich mit der externen Absenderadresse überschneidet, wird der externe Absender hier entfernt.<br>\r\n  Ein Eintrag @domain.tld erlaubt den Versand als *@domain.tld",
         "force_pw_update": "Erzwinge Passwortänderung bei nächstem Login",
         "force_pw_update_info": "Dem Benutzer wird lediglich der Zugang zur %s ermöglicht.",
         "full_name": "Voller Name",
         "gal": "Globales Adressbuch",
         "gal_info": "Das globale Adressbuch enthält alle Objekte einer Domain und kann durch keinen Benutzer geändert werden. Die Verfügbarkeitsinformation in SOGo ist nur bei eingeschaltetem globalen Adressbuch ersichtlich <b>Zum Anwenden einer Änderung muss SOGo neugestartet werden.</b>",
         "generate": "generieren",
-        "grant_types": "Grant types",
+        "grant_types": "Grant-types",
         "hostname": "Servername",
         "inactive": "Inaktiv",
         "kind": "Art",
+        "lookup_mx": "Ziel mit MX vergleichen (Regex, etwa <code>.*google\\.com</code>, um alle Ziele mit MX *google.com zu routen)",
         "mailbox": "Mailbox bearbeiten",
         "mailbox_quota_def": "Standard-Quota einer Mailbox",
+        "mailbox_relayhost_info": "Wird auf eine Mailbox und direkte Alias-Adressen angewendet. Überschreibt die Einstellung einer Domain.",
         "max_aliases": "Max. Aliasse",
         "max_mailboxes": "Max. Mailboxanzahl",
         "max_quota": "Max. Größe per Mailbox (MiB)",
@@ -520,13 +569,15 @@
         "mins_interval": "Intervall (min)",
         "multiple_bookings": "Mehrfaches Buchen",
         "nexthop": "Next Hop",
+        "none_inherit": "Keine Auswahl / Erben",
         "password": "Passwort",
         "password_repeat": "Passwort wiederholen",
         "previous": "Vorherige Seite",
         "private_comment": "Privater Kommentar",
         "public_comment": "Öffentlicher Kommentar",
+        "pushover": "Pushover",
         "pushover_evaluate_x_prio": "Hohe Priorität eskalieren [<code>X-Priority: 1</code>]",
-        "pushover_info": "Push-Benachrichtungen werden angewendet auf alle nicht-Spam Nachrichten zugestellt an <b>%s</b>, einschließlich Alias-Adressen (shared, non-shared, tagged).",
+        "pushover_info": "Push-Benachrichtigungen werden angewendet auf alle nicht-Spam Nachrichten zugestellt an <b>%s</b>, einschließlich Alias-Adressen (shared, non-shared, tagged).",
         "pushover_only_x_prio": "Nur Mail mit hoher Priorität berücksichtigen [<code>X-Priority: 1</code>]",
         "pushover_sender_array": "Folgende Sender E-Mail-Adressen berücksichtigen <small>(getrennt durch Komma)</small>",
         "pushover_sender_regex": "Sender mit folgendem regulären Ausdruck auswählen",
@@ -535,6 +586,9 @@
         "pushover_vars": "Wenn kein Sender-Filter definiert ist, werden alle E-Mails berücksichtigt.<br>Die direkte Absenderprüfung und reguläre Ausdrücke werden unabhängig voneinander geprüft, sie <b>hängen nicht voneinander ab</b> und werden der Reihe nach ausgeführt. <br>Verwendbare Variablen für Titel und Text (Datenschutzrichtlinien beachten)",
         "pushover_verify": "Verbindung verifizieren",
         "quota_mb": "Speicherplatz (MiB)",
+        "quota_warning_bcc": "Quota-Warnung BCC",
+        "quota_warning_bcc_info": "Die Warnungen werden als separate Kopie an die nachstehenden Empfänger versendet. Dem Betreff wird der jeweilige Benutzername in Klammern (etwa <code>Quota-Warnung (user@example.com)</code>) angehangen.",
+        "ratelimit": "Rate Limit",
         "redirect_uri": "Redirect/Callback-URL",
         "relay_all": "Alle Empfänger-Adressen relayen",
         "relay_all_info": "↪ Wenn <b>nicht</b> alle Empfänger-Adressen relayt werden sollen, müssen \"blinde\" Mailboxen für jede Adresse, die relayt werden soll, erstellen werden.",
@@ -547,7 +601,7 @@
         "save": "Änderungen speichern",
         "scope": "Scope",
         "sender_acl": "Darf Nachrichten versenden als",
-        "sender_acl_disabled": "↳ <span class=\"label label-danger\">Absenderprüfung deaktiviert</span>",
+        "sender_acl_disabled": "<span class=\"label label-danger\">Absenderprüfung deaktiviert</span>",
         "sender_acl_info": "Wird einem Mailbox-Benutzer A der Versand als Mailbox-Benutzer B gestattet, so erscheint der Absender <b>nicht</b> automatisch in SOGo zur Auswahl.<br>\r\n  In SOGo muss zusätzlich eine Delegation eingerichtet werden. Dieses Verhalten trifft nicht auf Alias-Adressen zu.",
         "sieve_desc": "Kurze Beschreibung",
         "sieve_type": "Filtertyp",
@@ -557,18 +611,42 @@
         "sogo_visible": "Alias in SOGo sichtbar",
         "sogo_visible_info": "Diese Option hat lediglich Einfluss auf Objekte, die in SOGo darstellbar sind (geteilte oder nicht-geteilte Alias-Adressen mit dem Ziel mindestens einer lokalen Mailbox).",
         "spam_alias": "Anpassen temporärer Alias-Adressen",
+        "spam_filter": "Spamfilter",
         "spam_policy": "Hinzufügen und Entfernen von Einträgen in White- und Blacklists",
         "spam_score": "Einen benutzerdefiniterten Spam-Score festlegen",
         "subfolder2": "Ziel-Ordner<br><small>(leer = kein Unterordner)</small>",
         "syncjob": "Sync-Job bearbeiten",
-        "target_address": "Ziel-Adresse(n) <small>(getrennt durch Komma)</small>",
+        "target_address": "Ziel-Adresse(n)",
         "target_domain": "Ziel-Domain",
         "timeout1": "Timeout für Verbindung zum Remote-Host",
         "timeout2": "Timeout für Verbindung zum lokalen Host",
         "title": "Objekt bearbeiten",
         "unchanged_if_empty": "Unverändert, wenn leer",
         "username": "Benutzername",
-        "validate_save": "Validieren und speichern"
+        "validate_save": "Validieren und speichern",
+        "xmpp": "XMPP für diese Domain aktivieren",
+        "xmpp_access": "XMPP-Zugang",
+        "xmpp_access_info": "XMPP muss für diese Domain aktiviert sein.",
+        "xmpp_admin": "XMPP-Administrator",
+        "xmpp_admin_info": "<b>Vorsicht:</b> Ernennt den Benutzer zum Administrator der jeweiligen XMPP Domain.",
+        "xmpp_example_jid": "<b>Beispiel JID</b> (Passwort entspricht Mailbox-Passwort)",
+        "xmpp_info": "Diese Funktion stellt eine Chat-Funktionalität für die Domain bereit.",
+        "xmpp_prefix": "XMPP-Präfix für Domain (\"im\" für <b>im</b>.example.org)",
+        "xmpp_prefix_info": "Für die Bereitstellung eines Zertifikates sollte vorab ein DNS-Eintrag, etwa in Form eines CNAMEs, für <b>im</b>.example.org sowie <b>*.im</b>.example.org auf <b>%s</b> zeigend angelegt werden. Im Anschluss an die Aktivierung sollte der DNS-Check für diese Domain ausgeführt werden."
+    },
+    "fido2": {
+        "confirm": "Bestätigen",
+        "fido2_auth": "Anmeldung über FIDO2",
+        "fido2_success": "Das Gerät wurde erfolgreich registriert",
+        "fido2_validation_failed": "Validierung fehlgeschlagen",
+        "fn": "Benutzerfreundlicher Name",
+        "known_ids": "Bekannte IDs",
+        "none": "Deaktiviert",
+        "register_status": "Registrierungsstatus",
+        "rename": "Umbenennen",
+        "set_fido2": "Registriere FIDO2-Gerät",
+        "set_fn": "Benutzerfreundlichen Namen konfigurieren",
+        "start_fido2_validation": "Starte FIDO2-Validierung"
     },
     "footer": {
         "cancel": "Abbrechen",
@@ -578,6 +656,7 @@
         "hibp_nok": "Übereinstimmung gefunden! Dieses Passwort ist potenziell gefährlich!",
         "hibp_ok": "Keine Übereinstimmung gefunden.",
         "loading": "Einen Moment bitte...",
+        "nothing_selected": "Nichts ausgewählt",
         "restart_container": "Container neustarten",
         "restart_container_info": "<b>Wichtig:</b> Der Neustart eines Containers kann eine Weile in Anspruch nehmen.",
         "restart_now": "Jetzt neustarten",
@@ -614,6 +693,7 @@
         "active": "Aktiv",
         "add": "Hinzufügen",
         "add_alias": "Alias hinzufügen",
+        "add_alias_expand": "Alias über Alias-Domains expandieren",
         "add_bcc_entry": "BCC-Eintrag hinzufügen",
         "add_domain": "Domain hinzufügen",
         "add_domain_alias": "Domain-Alias hinzufügen",
@@ -625,7 +705,7 @@
         "add_tls_policy_map": "TLS-Richtlinieneintrag hinzufügen",
         "address_rewriting": "Adressumschreibung",
         "alias": "Alias",
-        "alias_domain_alias_hint": "Alias-Adressen werden <b>nicht</b> automatisch auch auf Domain-Alias Adressen angewendet. Eine Alias-Adresse <code>mein-alias@domain</code> bildet demnach <b>nicht</b> die Adresse <code>mein-alias@alias-domain</code> ab.<br>E-Mail-Weiterleitungen an externe Postfächer sollten über Sieve (SOGo Weiterleitung oder im Reiter \"Filter\") angelegt werden.",
+        "alias_domain_alias_hint": "Alias-Adressen werden <b>nicht</b> automatisch auch auf Domain-Alias Adressen angewendet. Eine Alias-Adresse <code>mein-alias@domain</code> bildet demnach <b>nicht</b> die Adresse <code>mein-alias@alias-domain</code> ab.<br>E-Mail-Weiterleitungen an externe Postfächer sollten über Sieve (SOGo Weiterleitung oder im Reiter \"Filter\") angelegt werden. Der Button \"Alias über Alias-Domains expandieren\" erstellt fehlende Alias-Adressen in Alias-Domains.",
         "alias_domain_backupmx": "Alias-Domain für Relay-Domain inaktiv",
         "aliases": "Aliasse",
         "allow_from_smtp": "Nur folgende IPs für <b>SMTP</b> erlauben",
@@ -674,14 +754,15 @@
         "insert_preset": "Beispiel \"%s\" laden",
         "kind": "Art",
         "last_mail_login": "Letzter Mail-Login",
+        "last_pw_change": "Letzte Passwortänderung",
         "last_run": "Letzte Ausführung",
         "last_run_reset": "Als nächstes ausführen",
         "mailbox": "Mailbox",
+        "mailbox_defaults": "Standardeinstellungen",
+        "mailbox_defaults_info": "Steuert die Standardeinstellungen für neue Mailboxen.",
         "mailbox_defquota": "Standard-Quota",
         "mailbox_quota": "Max. Größe einer Mailbox",
         "mailboxes": "Mailboxen",
-        "mailbox_defaults": "Standardeinstellungen",
-        "mailbox_defaults_info": "Steuert die Standardeinstellungen für neue Mailboxen.",
         "mins_interval": "Intervall (min)",
         "msg_num": "Anzahl Nachrichten",
         "multiple_bookings": "Mehrfachbuchen",
@@ -692,17 +773,17 @@
         "owner": "Besitzer",
         "private_comment": "Privater Kommentar",
         "public_comment": "Öffentlicher Kommentar",
-        "q_add_header": "Junk-Ordner",
-        "q_all": "Alle Kategorien",
-        "q_reject": "Abgelehnt",
-        "quarantine_notification": "Quarantäne-Benachrichtigung",
+        "q_add_header": "bei Mail in Junk-Ordner",
+        "q_all": "bei Reject und Mail in Junk-Ordner",
+        "q_reject": "bei Reject",
         "quarantine_category": "Quarantäne-Benachrichtigungskategorie",
+        "quarantine_notification": "Quarantäne-Benachrichtigung",
         "quick_actions": "Aktionen",
         "recipient_map": "Empfängerumschreibung",
         "recipient_map_info": "Empfängerumschreibung ersetzen den Empfänger einer E-Mail vor dem Versand.",
         "recipient_map_new": "Neuer Empfänger",
         "recipient_map_new_info": "Der neue Empfänger muss eine E-Mail-Adresse sein.",
-        "recipient_map_old": "Original Empfänger",
+        "recipient_map_old": "Original-Empfänger",
         "recipient_map_old_info": "Der originale Empfänger muss eine E-Mail-Adresse oder ein Domainname sein.",
         "recipient_maps": "Empfängerumschreibungen",
         "remove": "Entfernen",
@@ -710,7 +791,7 @@
         "running": "In Ausführung",
         "set_postfilter": "Als Postfilter markieren",
         "set_prefilter": "Als Prefilter markieren",
-        "sieve_info": "Es können mehrere Filter pro Benutzer existieren, aber nur ein Filter eines Typs (Pre-/Postfilter) kann gleichzeitig aktiv sein.<br>\r\nDie Ausführung erfolgt in nachstehender Reihenfolge. Ein fehlgeschlagenes Script sowie der Befehl \"keep;\" stoppen die weitere Verarbeitung <b>nicht</b>. Änderungen an globalen Sieve-Filtern bewirken einen Neustart von Dovecot.<br><br>Global sieve prefilter → Prefilter → User scripts → Postfilter → Global sieve postfilter",
+        "sieve_info": "Es können mehrere Filter pro Benutzer existieren, aber nur ein Filter eines Typs (Pre-/Postfilter) kann gleichzeitig aktiv sein.<br>\r\nDie Ausführung erfolgt in nachstehender Reihenfolge. Ein fehlgeschlagenes Script sowie der Befehl \"keep;\" stoppen die weitere Verarbeitung <b>nicht</b>. Änderungen an globalen Sieve-Filtern bewirken einen Neustart von Dovecot.<br><br>Global sieve prefilter &#8226; Prefilter &#8226; User scripts &#8226; Postfilter &#8226; Global sieve postfilter",
         "sieve_preset_1": "E-Mails mit potenziell gefährlichen Dateitypen abweisen",
         "sieve_preset_2": "E-Mail eines bestimmten Absenders immer als gelesen markieren",
         "sieve_preset_3": "Lautlos löschen, weitere Ausführung von Filtern verhindern",
@@ -720,7 +801,6 @@
         "sieve_preset_7": "Weiterleiten und behalten oder verwerfen",
         "sieve_preset_8": "Nachricht verwerfen, wenn Absender und Alias-Ziel identisch sind.",
         "sieve_preset_header": "Beispielinhalte zur Einsicht stehen nachstehend bereit. Siehe auch <a href=\"https://de.wikipedia.org/wiki/Sieve\" target=\"_blank\">Wikipedia</a>.",
-        "sogo_allow_admin_hint": "Administrative SOGo-Logins sind nur für Mailboxen verfügbar, die bereits ein SOGo-Profil besitzen. Ein Benutzer muss zumindest einmal in SOGo eingeloggt gewesen sein, um ein Profil zu besitzen.",
         "sogo_visible": "Alias Sichtbarkeit in SOGo",
         "sogo_visible_n": "Alias in SOGo verbergen",
         "sogo_visible_y": "Alias in SOGo anzeigen",
@@ -740,8 +820,8 @@
         "tls_map_parameters_info": "Leer oder Parameter, Beispiele: protocols=!SSLv2 ciphers=medium exclude=3DES",
         "tls_map_policy": "Richtlinie",
         "tls_policy_maps": "TLS-Richtlinien",
-        "tls_policy_maps_info": "Nachstehende Richtlinien erzwingen TLS-Transportregeln unabhängig von TLS-Richtlinieneinstellungen eines Benutzers.<br>\r\n  Für weitere Informationen zur Syntax sollte <a href=\"http://www.postfix.org/postconf.5.html#smtp_tls_policy_maps\" target=\"_blank\">die \"smtp_tls_policy_maps\" Dokumentation</a> konsultiert werden.",
         "tls_policy_maps_enforced_tls": "Die Richtlinien überschreiben auch das Verhalten für Mailbox-Benutzer, die für ausgehende Verbindungen TLS erzwingen. Ist keine Policy nachstehend konfiguriert, richtet sich der Standard für diese Benutzer sich nach den Werten <code>smtp_tls_mandatory_protocols</code> und <code>smtp_tls_mandatory_ciphers</code>.",
+        "tls_policy_maps_info": "Nachstehende Richtlinien erzwingen TLS-Transportregeln unabhängig von TLS-Richtlinieneinstellungen eines Benutzers.<br>\r\n  Für weitere Informationen zur Syntax sollte <a href=\"http://www.postfix.org/postconf.5.html#smtp_tls_policy_maps\" target=\"_blank\">die \"smtp_tls_policy_maps\" Dokumentation</a> konsultiert werden.",
         "tls_policy_maps_long": "Ausgehende TLS-Richtlinien",
         "toggle_all": "Alle",
         "username": "Benutzername",
@@ -783,6 +863,9 @@
         "qitem": "Quarantäneeintrag",
         "quarantine": "Quarantäne",
         "quick_actions": "Aktionen",
+        "quick_delete_link": "Quick-Delete Link öffnen",
+        "quick_info_link": "Element-Info Link öffnen",
+        "quick_release_link": "Quick-Release Link öffnen",
         "rcpt": "Empfänger",
         "received": "Empfangen",
         "recipients": "Empfänger",
@@ -793,27 +876,25 @@
         "release_subject": "Potentiell schädliche Nachricht aus Quarantäne: %s",
         "remove": "Entfernen",
         "rewrite_subject": "Betreff geändert",
-        "rspamd_result": "Rspamd Ergebnis",
-        "quick_release_link": "Quick-Release Link öffnen",
-        "quick_delete_link": "Quick-Delete Link öffnen",
-        "quick_info_link": "Element-Info Link öffnen",
+        "rspamd_result": "Rspamd-Ergebnis",
         "sender": "Sender (SMTP)",
         "sender_header": "Sender (\"From\"-Header)",
+        "settings_info": "Maximale Anzahl der zurückgehaltenen E-Mails: %s<br>Maximale Größe einer zu speichernden E-Mail: %s MiB",
         "show_item": "Details",
         "spam": "Spam",
         "spam_score": "Bewertung",
         "subj": "Betreff",
-        "type": "Typ",
         "table_size": "Tabellengröße",
         "table_size_show_n": "Zeige %s Einträge",
         "text_from_html_content": "Inhalt (html, konvertiert)",
         "text_plain_content": "Inhalt (text/plain)",
-        "toggle_all": "Alle auswählen"
+        "toggle_all": "Alle auswählen",
+        "type": "Typ"
     },
     "start": {
         "help": "Hilfe ein-/ausblenden",
         "imap_smtp_server_auth_info": "Bitte verwenden Sie Ihre vollständige E-Mail-Adresse sowie das PLAIN-Authentifizierungsverfahren.<br>\r\nIhre Anmeldedaten werden durch die obligatorische Verschlüsselung entgegen des Begriffes \"PLAIN\" nicht unverschlüsselt übertragen.",
-        "mailcow_apps_detail": "Verwenden Sie mailcow Apps, um E-Mails abzurufen, Kalender und Kontakte zu verwalten und vieles mehr.",
+        "mailcow_apps_detail": "Verwenden Sie mailcow-Apps, um E-Mails abzurufen, Kalender und Kontakte zu verwalten und vieles mehr.",
         "mailcow_panel_detail": "<b>Domain-Administratoren</b> erstellen, verändern oder löschen Mailboxen, verwalten die Domäne und sehen sonstige Einstellungen ein.<br>\r\n\tAls <b>Mailbox-Benutzer</b> erstellen Sie hier zeitlich limitierte Aliasse, ändern das Verhalten des Spamfilters, setzen ein neues Passwort und vieles mehr."
     },
     "success": {
@@ -830,14 +911,14 @@
         "aliasd_modified": "Änderungen an Alias-Domain %s wurden gespeichert",
         "app_links": "Änderungen an App-Links wurden gespeichert",
         "app_passwd_added": "App-Passwort wurde gespeichert",
-        "app_passwd_removed": "App-Passwort ID %s wurde entfernt",
-        "bcc_deleted": "BCC Map-Einträge gelöscht: %s",
-        "bcc_edited": "BCC Map-Eintrag %s wurde geändert",
-        "bcc_saved": "BCC Map-Eintrag wurde gespeichert",
+        "app_passwd_removed": "App-Passwort-ID %s wurde entfernt",
+        "bcc_deleted": "BCC-Map-Einträge gelöscht: %s",
+        "bcc_edited": "BCC-Map-Eintrag %s wurde geändert",
+        "bcc_saved": "BCC- Map-Eintrag wurde gespeichert",
         "db_init_complete": "Datenbankinitialisierung abgeschlossen",
-        "delete_filter": "Filter ID %s wurde gelöscht",
+        "delete_filter": "Filter-ID %s wurde gelöscht",
         "delete_filters": "Filter gelöscht: %s",
-        "deleted_syncjob": "Sync-Jobs ID %s gelöscht",
+        "deleted_syncjob": "Sync-Jobs-ID %s gelöscht",
         "deleted_syncjobs": "Sync-Jobs gelöscht: %s",
         "dkim_added": "DKIM-Key %s wurde hinzugefügt",
         "dkim_duplicated": "DKIM-Key der Domain %s wurde auf Domain %s kopiert",
@@ -853,47 +934,52 @@
         "f2b_modified": "Änderungen an Fail2ban-Parametern wurden gespeichert",
         "forwarding_host_added": "Weiterleitungs-Host %s wurde hinzugefügt",
         "forwarding_host_removed": "Weiterleitungs-Host %s wurde entfernt",
-        "global_filter_written": "Filterdatei wurde erfolreich geschrieben",
+        "global_filter_written": "Filterdatei wurde erfolgreich geschrieben",
         "hash_deleted": "Hash wurde gelöscht",
         "item_deleted": "Objekt %s wurde entfernt",
         "item_released": "Objekt %s freigegeben",
         "items_deleted": "Objekt(e) %s wurde(n) erfolgreich entfernt",
         "items_released": "Ausgewählte Objekte wurden an Mailbox versendet",
-        "learned_ham": "ID %s wurde erfolreich als Ham gelernt",
+        "learned_ham": "ID %s wurde erfolgreich als Ham gelernt",
         "license_modified": "Änderungen an Lizenz wurden gespeichert",
         "logged_in_as": "Eingeloggt als %s",
         "mailbox_added": "Mailbox %s wurde angelegt",
         "mailbox_modified": "Änderungen an Mailbox %s wurden gespeichert",
         "mailbox_removed": "Mailbox %s wurde entfernt",
+        "nginx_reloaded": "Nginx wurde neu geladen",
         "object_modified": "Änderungen an Objekt %s wurden gespeichert",
-        "pushover_settings_edited": "Pushover Konfiguration gespeichert, bitte den Zugang im Anschluss verifizieren.",
-        "qlearn_spam": "Nachricht ID %s wurde als Spam gelernt und gelöscht",
+        "password_policy_saved": "Passwortrichtlinie wurde erfolgreich gespeichert",
+        "pushover_settings_edited": "Pushover-Konfiguration gespeichert, bitte den Zugang im Anschluss verifizieren.",
+        "qlearn_spam": "Nachricht-ID %s wurde als Spam gelernt und gelöscht",
         "queue_command_success": "Queue-Aufgabe erfolgreich ausgeführt",
         "recipient_map_entry_deleted": "Empfängerumschreibung mit der ID %s wurde gelöscht",
         "recipient_map_entry_saved": "Empfängerumschreibung für Objekt \"%s\" wurde gespeichert",
-        "relayhost_added": "Mapeintrag %s wurde hinzugefügt",
-        "relayhost_removed": "Mapeintrag %s wurde entfernt",
+        "relayhost_added": "Map-Eintrag %s wurde hinzugefügt",
+        "relayhost_removed": "Map-Eintrag %s wurde entfernt",
         "reset_main_logo": "Standardgrafik wurde wiederhergestellt",
         "resource_added": "Ressource %s wurde angelegt",
         "resource_modified": "Änderungen an Ressource %s wurden gespeichert",
         "resource_removed": "Ressource %s wurde entfernt",
         "rl_saved": "Ratelimit für Objekt %s wurde gesetzt",
-        "rspamd_ui_pw_set": "Rspamd UI-Passwort wurde gesetzt",
+        "rspamd_ui_pw_set": "Rspamd-UI-Passwort wurde gesetzt",
         "saved_settings": "Regel wurde gespeichert",
         "settings_map_added": "Regel wurde gespeichert",
         "settings_map_removed": "Regeln wurden entfernt: %s",
-        "sogo_profile_reset": "ActiveSync Gerät des Benutzers %s wurde zurückgesetzt",
+        "sogo_profile_reset": "ActiveSync-Gerät des Benutzers %s wurde zurückgesetzt",
         "tls_policy_map_entry_deleted": "TLS-Richtlinie mit der ID %s wurde gelöscht",
         "tls_policy_map_entry_saved": "TLS-Richtlinieneintrag \"%s\" wurde gespeichert",
         "ui_texts": "Änderungen an UI-Texten",
         "upload_success": "Datei wurde erfolgreich hochgeladen",
+        "verified_fido2_login": "FIDO2-Anmeldung verifiziert",
         "verified_totp_login": "TOTP-Anmeldung verifiziert",
         "verified_u2f_login": "U2F-Anmeldung verifiziert",
-        "verified_fido2_login": "FIDO2-Anmeldung verifiziert",
-        "verified_yotp_login": "Yubico OTP-Anmeldung verifiziert"
+        "verified_yotp_login": "Yubico-OTP-Anmeldung verifiziert",
+        "xmpp_maps_updated": "XMPP-Maps wurden aktualisiert",
+        "xmpp_reloaded": "XMPP-Dienst wurde neu geladen",
+        "xmpp_restarted": "XMPP-Dienst wurde neu gestartet"
     },
     "tfa": {
-        "api_register": "%s verwendet die Yubico Cloud API. Ein API-Key für den Yubico Stick kann <a href=\"https://upgrade.yubico.com/getapikey/\" target=\"_blank\">hier</a> bezogen werden.",
+        "api_register": "%s verwendet die Yubico-Cloud-API. Ein API-Key für den Yubico-Stick kann <a href=\"https://upgrade.yubico.com/getapikey/\" target=\"_blank\">hier</a> bezogen werden.",
         "confirm": "Bestätigen",
         "confirm_totp_token": "Bitte bestätigen Sie die Änderung durch Eingabe eines generierten Tokens",
         "delete_tfa": "Deaktiviere 2FA",
@@ -904,32 +990,19 @@
         "key_id": "Ein Namen für diesen YubiKey",
         "key_id_totp": "Ein eindeutiger Name",
         "none": "Deaktiviert",
-        "reload_retry": "- (bei persistierendem Fehler, bitte Browserfenster neuladen)",
+        "reload_retry": "- (bei persistierendem Fehler, bitte Browserfenster neu laden)",
         "scan_qr_code": "Bitte scannen Sie jetzt den angezeigten QR-Code:",
         "select": "Bitte auswählen",
         "set_tfa": "Konfiguriere Zwei-Faktor-Authentifizierungsmethode",
         "start_u2f_validation": "Starte Validierung",
         "tfa": "Zwei-Faktor-Authentifizierung",
-        "totp": "Time-based OTP (Google Authenticator etc.)",
+        "tfa_token_invalid": "TFA-Token ungültig!",
+        "totp": "Time-based-OTP (Google Authenticator etc.)",
         "u2f": "U2F-Authentifizierung",
         "waiting_usb_auth": "<i>Warte auf USB-Gerät...</i><br><br>Bitte jetzt den vorgesehenen Taster des USB-Gerätes berühren.",
         "waiting_usb_register": "<i>Warte auf USB-Gerät...</i><br><br>Bitte zuerst das obere Passwortfeld ausfüllen und erst dann den vorgesehenen Taster des USB-Gerätes berühren.",
         "yubi_otp": "Yubico OTP-Authentifizierung"
     },
-    "fido2": {
-        "set_fn": "Benutzerfreundlichen Namen konfigurieren",
-        "fn": "Benutzerfreundlicher Name",
-        "rename": "umbenennen",
-        "confirm": "Bestätigen",
-        "register_status": "Registrierungsstatus",
-        "known_ids": "Bekannte IDs",
-        "none": "Deaktiviert",
-        "set_fido2": "Registriere FIDO2 Gerät",
-        "start_fido2_validation": "Starte FIDO2 Validierung",
-        "fido2_auth": "Anmeldung über FIDO2",
-        "fido2_success": "Das Gerät wurde erfolgreich registriert",
-        "fido2_validation_failed": "Validierung fehlgeschlagen"
-    },
     "user": {
         "action": "Aktion",
         "active": "Aktiv",
@@ -949,27 +1022,32 @@
         "app_name": "App-Name",
         "app_passwds": "App-Passwörter",
         "apple_connection_profile": "Apple-Verbindungsprofil",
-        "apple_connection_profile_complete": "Dieses Verbindungsprofil beinhaltet neben IMAP- und SMTP-Konfigurationen auch Pfade für die Konfiguration von CalDAV (Kalender) und CardDAV (Adressbücher) für ein Apple Gerät.",
+        "apple_connection_profile_complete": "Dieses Verbindungsprofil beinhaltet neben IMAP- und SMTP-Konfigurationen auch Pfade für die Konfiguration von CalDAV (Kalender) und CardDAV (Adressbücher) für ein Apple-Gerät.",
         "apple_connection_profile_mailonly": "Dieses Verbindungsprofil beinhaltet IMAP- und SMTP-Konfigurationen für ein Apple-Gerät.",
         "change_password": "Passwort ändern",
+        "clear_recent_successful_connections": "Alle erfolgreichen Verbindungen bereinigen",
         "client_configuration": "Konfigurationsanleitungen für E-Mail-Programme und Smartphones anzeigen",
         "create_app_passwd": "Erstelle App-Passwort",
         "create_syncjob": "Neuen Sync-Job erstellen",
+        "created_on": "Erstellt am",
         "daily": "Täglich",
         "day": "Tag",
         "delete_ays": "Soll der Löschvorgang wirklich ausgeführt werden?",
         "direct_aliases": "Direkte Alias-Adressen",
         "direct_aliases_desc": "Nur direkte Alias-Adressen werden für benutzerdefinierte Einstellungen berücksichtigt.",
-        "eas_reset": "ActiveSync Geräte-Cache zurücksetzen",
-        "eas_reset_help": "In vielen Fällen kann ein ActiveSync Profil durch das Zurücksetzen des Caches repariert werden.<br><b>Vorsicht:</b> Alle Elemente werden erneut heruntergeladen!",
+        "eas_reset": "ActiveSync-Geräte-Cache zurücksetzen",
+        "eas_reset_help": "In vielen Fällen kann ein ActiveSync-Profil durch das Zurücksetzen des Caches repariert werden.<br><b>Vorsicht:</b> Alle Elemente werden erneut heruntergeladen!",
         "eas_reset_now": "Jetzt zurücksetzen",
         "edit": "Bearbeiten",
         "email": "E-Mail",
         "email_and_dav": "E-Mail, Kalender und Adressbücher",
+        "empty": "Keine Einträge vorhanden",
         "encryption": "Verschlüsselung",
         "excludes": "Ausschlüsse",
         "expire_in": "Ungültig in",
-        "force_pw_update": "Das Passwort für diesen Benutzer <b>muss</b> geändert werden, damit die Zugriffssperre auf die Groupwarekomponenten wieder freigeschaltet wird.",
+        "fido2_webauthn": "FIDO2/WebAuthn",
+        "force_pw_update": "Das Passwort für diesen Benutzer <b>muss</b> geändert werden, damit die Zugriffssperre auf die Groupware-Komponenten wieder freigeschaltet wird.",
+        "from": "von",
         "generate": "generieren",
         "hour": "Stunde",
         "hourly": "Stündlich",
@@ -978,17 +1056,25 @@
         "interval": "Intervall",
         "is_catch_all": "Ist Catch-All-Adresse für Domain(s)",
         "last_mail_login": "Letzter Mail-Login",
+        "last_pw_change": "Letzte Passwortänderung",
         "last_run": "Letzte Ausführung",
+        "last_ui_login": "Letzte UI Anmeldung",
         "loading": "Lade...",
-        "mailbox_details": "Mailbox-Details",
+        "login_history": "Login-Historie",
+        "mailbox": "Mailbox",
+        "mailbox_details": "Details",
+        "mailbox_general": "Allgemein",
+        "mailbox_settings": "Einstellungen",
         "messages": "Nachrichten",
+        "month": "Monat",
+        "months": "Monate",
         "never": "Niemals",
         "new_password": "Neues Passwort",
-        "new_password_description": "Mindestanforderung: 6 Zeichen lang, Buchstaben und Zahlen.",
         "new_password_repeat": "Neues Passwort (Wiederholung)",
         "no_active_filter": "Kein aktiver Filter vorhanden",
         "no_last_login": "Keine letzte UI-Anmeldung gespeichert",
         "no_record": "Kein Eintrag",
+        "open_webmail_sso": "In Webmail einloggen",
         "password": "Passwort",
         "password_now": "Aktuelles Passwort (Änderungen bestätigen)",
         "password_repeat": "Passwort (Wiederholung)",
@@ -1004,10 +1090,11 @@
         "q_add_header": "Junk-Ordner",
         "q_all": "Alle Kategorien",
         "q_reject": "Abgelehnt",
-        "quarantine_notification": "Quarantäne-Benachrichtigung",
         "quarantine_category": "Quarantäne-Benachrichtigungskategorie",
-        "quarantine_notification_info": "Wurde über eine E-Mail in Quarantäne informiert, wird sie als \"benachrichtigt\" markiert und keine weitere Benachrichtigung zu dieser E-Mail versendet.",
         "quarantine_category_info": "Die Kategorie \"Abgelehnt\" informiert über abgelehnte E-Mails, während \"Junk-Ordner\" über E-Mails berichtet, die im Junk-Ordner des jeweiligen Benutzers abgelegt wurden.",
+        "quarantine_notification": "Quarantäne-Benachrichtigung",
+        "quarantine_notification_info": "Wurde über eine E-Mail in Quarantäne informiert, wird sie als \"benachrichtigt\" markiert und keine weitere Benachrichtigung zu dieser E-Mail versendet.",
+        "recent_successful_connections": "Kürzlich erfolgreiche Verbindungen",
         "remove": "Entfernen",
         "running": "Wird ausgeführt",
         "save": "Änderungen speichern",
@@ -1016,10 +1103,10 @@
         "shared_aliases": "Geteilte Alias-Adressen",
         "shared_aliases_desc": "Geteilte Alias-Adressen werden nicht bei benutzerdefinierten Einstellungen, wie die des Spam-Filters oder der Verschlüsselungsrichtlinie, berücksichtigt. Entsprechende Spam-Filter können lediglich von einem Administrator vorgenommen werden.",
         "show_sieve_filters": "Zeige aktiven Filter des Benutzers",
-        "sogo_profile_reset": "SOGo Profil zurücksetzen",
+        "sogo_profile_reset": "SOGo-Profil zurücksetzen",
         "sogo_profile_reset_help": "Das Profil wird inklusive <b>aller</b> Kalender- und Kontaktdaten <b>unwiederbringlich gelöscht</b>.",
         "sogo_profile_reset_now": "Profil jetzt zurücksetzen",
-        "spam_aliases": "Temporäre E-Mail Aliasse",
+        "spam_aliases": "Temporäre E-Mail-Aliasse",
         "spam_score_reset": "Auf Server-Standard zurücksetzen",
         "spamfilter": "Spamfilter",
         "spamfilter_behavior": "Bewertung",
@@ -1058,17 +1145,20 @@
         "waiting": "Warte auf Ausführung",
         "week": "Woche",
         "weekly": "Wöchentlich",
-        "weeks": "Wochen"
+        "weeks": "Wochen",
+        "year": "Jahr",
+        "years": "Jahren"
     },
     "warning": {
         "cannot_delete_self": "Kann derzeit eingeloggten Benutzer nicht entfernen",
         "domain_added_sogo_failed": "Domain wurde hinzugefügt, aber SOGo konnte nicht neugestartet werden",
         "dovecot_restart_failed": "Dovecot wurde nicht erfolgreich neu gestartet, bitte prüfen Sie die Logs.",
-        "fuzzy_learn_error": "Fuzzy Lernfehler: %s",
+        "fuzzy_learn_error": "Fuzzy-Lernfehler: %s",
         "hash_not_found": "Hash nicht gefunden. Möglicherweise wurde dieser bereits gelöscht.",
         "ip_invalid": "Ungültige IP übersprungen: %s",
+        "is_not_primary_alias": "Überspringe nicht-primären Alias %s",
         "no_active_admin": "Kann letzten aktiven Administrator nicht deaktivieren",
-        "quota_exceeded_scope": "Domain-Quota erschöpft: Es können nur noch unlimiterte Mailboxen in dieser Domain erstellt werden.",
+        "quota_exceeded_scope": "Domain-Quota erschöpft: Es können nur noch unlimitierte Mailboxen in dieser Domain erstellt werden.",
         "session_token": "Formular-Token ungültig: Token stimmt nicht überein",
         "session_ua": "Formular-Token ungültig: User-Agent-Validierungsfehler"
     }
diff --git a/mailcow/src/mailcow-dockerized/data/web/lang/lang.en.json b/mailcow/src/mailcow-dockerized/data/web/lang/lang.en.json
index ceee60e..d5494e5 100644
--- a/mailcow/src/mailcow-dockerized/data/web/lang/lang.en.json
+++ b/mailcow/src/mailcow-dockerized/data/web/lang/lang.en.json
@@ -4,17 +4,20 @@
         "app_passwds": "Manage app passwords",
         "bcc_maps": "BCC maps",
         "delimiter_action": "Delimiter action",
+        "domain_desc": "Change domain description",
+        "domain_relayhost": "Change relayhost for a domain",
         "eas_reset": "Reset EAS devices",
         "extend_sender_acl": "Allow to extend sender ACL by external addresses",
         "filters": "Filters",
         "login_as": "Login as mailbox user",
+        "mailbox_relayhost": "Change relayhost for a mailbox",
         "prohibited": "Prohibited by ACL",
         "protocol_access": "Change protocol access",
         "pushover": "Pushover",
         "quarantine": "Quarantine actions",
         "quarantine_attachments": "Quarantine attachments",
-        "quarantine_notification": "Change quarantine notifications",
         "quarantine_category": "Change quarantine notification category",
+        "quarantine_notification": "Change quarantine notifications",
         "ratelimit": "Rate limit",
         "recipient_maps": "Recipient maps",
         "smtp_ip_access": "Change allowed hosts for SMTP",
@@ -26,7 +29,10 @@
         "syncjobs": "Sync jobs",
         "tls_policy": "TLS policy",
         "unlimited_quota": "Unlimited quota for mailboxes",
-        "domain_desc": "Change domain description"
+        "xmpp_admin": "Promote XMPP user to administrator",
+        "xmpp_domain_access": "Configure XMPP domain access",
+        "xmpp_mailbox_access": "Configure XMPP user access",
+        "xmpp_prefix": "Change XMPP subdomain (prefix)"
     },
     "add": {
         "activate_filter_warn": "All other filters will be deactivated, when active is checked.",
@@ -42,7 +48,8 @@
         "app_password": "Add app password",
         "automap": "Try to automap folders (\"Sent items\", \"Sent\" => \"Sent\" etc.)",
         "backup_mx_options": "Relay options",
-        "comment_info": "A private comment is not visible to the user, while a public comment is shown as tooltip when hovering it in a users overview",
+        "bcc_dest_format": "BCC destination must be a single valid email address.<br> If you need to send a copy to multiple addresses, create an Alias and use it here.",
+        "comment_info": "A private comment is not visible to the user, while a public comment is shown as tooltip when hovering it in a user's overview",
         "custom_params": "Custom parameters",
         "custom_params_hint": "Right: --param=xy, wrong: --param xy",
         "delete1": "Delete from source when completed",
@@ -102,7 +109,13 @@
         "timeout2": "Timeout for connection to local host",
         "username": "Username",
         "validate": "Validate",
-        "validation_success": "Validated successfully"
+        "validation_success": "Validated successfully",
+        "xmpp": "Activate XMPP for this domain",
+        "xmpp_access": "XMPP access",
+        "xmpp_access_info": "XMPP must be enabled for this domain.",
+        "xmpp_admin": "XMPP administrator",
+        "xmpp_admin_info": "<b>Danger:</b> Promotes a user to an XMPP administrator of this domain.",
+        "xmpp_info": "This function will enable chat functionality for this domain."
     },
     "admin": {
         "access": "Access",
@@ -125,10 +138,14 @@
         "admin": "Administrator",
         "admin_details": "Edit administrator details",
         "admin_domains": "Domain assignments",
+        "admins": "Administrators",
+        "admins_ldap": "LDAP Administrators",
         "advanced_settings": "Advanced settings",
         "api_allow_from": "Allow API access from these IPs/CIDR network notations",
         "api_info": "The API is a work in progress. The documentation can be found at <a href=\"/api\">/api</a>",
         "api_key": "API key",
+        "api_read_only": "Read-Only Access",
+        "api_read_write": "Read-Write Access",
         "api_skip_ip_check": "Skip IP check for API",
         "app_links": "App links",
         "app_name": "App name",
@@ -140,7 +157,7 @@
         "change_logo": "Change logo",
         "configuration": "Configuration",
         "convert_html_to_text": "Convert HTML to plain text",
-        "credentials_transport_warning": "<b>Warning</b>: Adding a new transport map entry will update the credentials for all entries with a matching nexthop column.",
+        "credentials_transport_warning": "<b>Warning</b>: Adding a new transport map entry will update the credentials for all entries with a matching next hop column.",
         "customer_id": "Customer ID",
         "customize": "Customize",
         "delete_queue": "Delete all",
@@ -199,12 +216,14 @@
         "include_exclude": "Include/Exclude",
         "include_exclude_info": "By default - with no selection - <b>all mailboxes</b> are addressed",
         "includes": "Include these recipients",
+        "is_mx_based": "MX based",
         "last_applied": "Last applied",
         "license_info": "A license is not required but helps further development.<br><a href=\"https://www.servercow.de/mailcow?lang=en#sal\" target=\"_blank\" alt=\"SAL order\">Register your GUID here</a> or <a href=\"https://www.servercow.de/mailcow?lang=en#support\" target=\"_blank\" alt=\"Support order\">buy support for your mailcow installation.</a>",
         "link": "Link",
         "loading": "Please wait...",
+        "login_time": "Login time",
         "logo_info": "Your image will be scaled to a height of 40px for the top navigation bar and a max. width of 250px for the start page. A scalable graphic is highly recommended.",
-        "lookup_mx": "Match destination against MX (.outlook.com to route all mail targeted to a MX *.outlook.com over this hop)",
+        "lookup_mx": "Destination is a regular expression to match against MX name (<code>.*google\\.com</code> to route all mail targeted to a MX ending in google.com over this hop)",
         "main_name": "\"mailcow UI\" name",
         "merged_vars_hint": "Greyed out rows were merged from <code>vars.(local.)inc.php</code> and cannot be modified.",
         "message": "Message",
@@ -214,14 +233,23 @@
         "no_active_bans": "No active bans",
         "no_new_rows": "No further rows available",
         "no_record": "No record",
+        "oauth2_apps": "OAuth2 Apps",
+        "oauth2_add_client": "Add OAuth2 client",
         "oauth2_client_id": "Client ID",
         "oauth2_client_secret": "Client secret",
-        "oauth2_info": "The OAuth2 implementation supports the grant type \"Authorization Code\" and issues refresh tokens.<br>\r\nThe server also automatically issues new refresh tokens, after a refresh token has been used.<br><br>\r\n→ The default scope is <i>profile</i>. Only mailbox users can be authenticated against OAuth2. If the scope parameter is omitted, it falls back to <i>profile</i>.<br>\r\n→ The <i>state</i> parameter is required to be sent by the client as part of the authorize request.<br><br>\r\nPaths for requests to the OAuth2 API: <br>\r\n<ul>\r\n  <li>Authorization endpoint: <code>/oauth/authorize</code></li>\r\n  <li>Token endpoint: <code>/oauth/token</code></li>\r\n  <li>Resource page:  <code>/oauth/profile</code></li>\r\n</ul>\r\nRegenerating the client secret will not expire existing authorization codes, but they will fail to renew their token.<br><br>\r\nRevoking client tokens will cause immediate termination of all active sessions. All clients need to re-authenticate.",
+        "oauth2_info": "The OAuth2 implementation supports the grant type \"Authorization Code\" and issues refresh tokens.<br>\r\nThe server also automatically issues new refresh tokens, after a refresh token has been used.<br><br>\r\n&#8226; The default scope is <i>profile</i>. Only mailbox users can be authenticated against OAuth2. If the scope parameter is omitted, it falls back to <i>profile</i>.<br>\r\n&#8226; The <i>state</i> parameter is required to be sent by the client as part of the authorize request.<br><br>\r\nPaths for requests to the OAuth2 API: <br>\r\n<ul>\r\n  <li>Authorization endpoint: <code>/oauth/authorize</code></li>\r\n  <li>Token endpoint: <code>/oauth/token</code></li>\r\n  <li>Resource page:  <code>/oauth/profile</code></li>\r\n</ul>\r\nRegenerating the client secret will not expire existing authorization codes, but they will fail to renew their token.<br><br>\r\nRevoking client tokens will cause immediate termination of all active sessions. All clients need to re-authenticate.",
         "oauth2_redirect_uri": "Redirect URI",
         "oauth2_renew_secret": "Generate new client secret",
         "oauth2_revoke_tokens": "Revoke all client tokens",
         "optional": "optional",
         "password": "Password",
+        "password_length": "Password length",
+        "password_policy": "Password policy",
+        "password_policy_chars": "Must contain at least one alphabetic character",
+        "password_policy_length": "Minimum password length is %d",
+        "password_policy_lowerupper": "Must contain lowercase and uppercase characters",
+        "password_policy_numbers": "Must contain at least one number",
+        "password_policy_special_chars": "Must contain special characters",
         "password_repeat": "Confirmation password (repeat)",
         "priority": "Priority",
         "private_key": "Private key",
@@ -229,8 +257,8 @@
         "quarantine_bcc": "Send a copy of all notifications (BCC) to this recipient:<br><small>Leave empty to disable. <b>Unsigned, unchecked mail. Should be delivered internally only.</b></small>",
         "quarantine_exclude_domains": "Exclude domains and alias-domains",
         "quarantine_max_age": "Maximum age in days<br><small>Value must be equal to or greater than 1 day.</small>",
-        "quarantine_max_size": "Maximum size in MiB (larger elements are discarded):<br><small>0 does <b>not</b> indicate unlimited.</small>",
         "quarantine_max_score": "Discard notification if spam score of a mail is higher than this value:<br><small>Defaults to 9999.0</small>",
+        "quarantine_max_size": "Maximum size in MiB (larger elements are discarded):<br><small>0 does <b>not</b> indicate unlimited.</small>",
         "quarantine_notification_html": "Notification email template:<br><small>Leave empty to restore default template.</small>",
         "quarantine_notification_sender": "Notification email sender",
         "quarantine_notification_subject": "Notification email subject",
@@ -243,14 +271,14 @@
         "queue_deliver_mail": "Deliver",
         "queue_hold_mail": "Hold",
         "queue_manager": "Queue manager",
+        "queue_show_message": "Show message",
         "queue_unban": "queue unban",
         "queue_unhold_mail": "Unhold",
-        "queue_show_message": "Show message",
         "quota_notification_html": "Notification email template:<br><small>Leave empty to restore default template.</small>",
         "quota_notification_sender": "Notification email sender",
         "quota_notification_subject": "Notification email subject",
         "quota_notifications": "Quota notifications",
-        "quota_notifications_info": "Quota notications are sent to users once when crossing 80% and once when crossing 95% usage.",
+        "quota_notifications_info": "Quota notifications are sent to users once when crossing 80% and once when crossing 95% usage.",
         "quota_notifications_vars": "{{percent}} equals the current quota of the user<br>{{username}} is the mailbox name",
         "r_active": "Active restrictions",
         "r_inactive": "Inactive restrictions",
@@ -261,6 +289,7 @@
         "regen_api_key": "Regenerate API key",
         "regex_maps": "Regex maps",
         "relay_from": "\"From:\" address",
+        "relay_rcpt": "\"To:\" address",
         "relay_run": "Run test",
         "relayhosts": "Sender-dependent transports",
         "relayhosts_hint": "Define sender-dependent transports to be able to select them in a domains configuration dialog.<br>\r\n  The transport service is always \"smtp:\" and will therefore try TLS when offered. Wrapped TLS (SMTPS) is not supported. A users individual outbound TLS policy setting is taken into account.<br>\r\n  Affects selected domains including alias domains.",
@@ -278,6 +307,7 @@
         "rsettings_preset_1": "Disable all but DKIM and rate limit for authenticated users",
         "rsettings_preset_2": "Postmasters want spam",
         "rsettings_preset_3": "Only allow specific senders for a mailbox (i.e. usage as internal mailbox only)",
+        "rsettings_preset_4": "Disable Rspamd for a domain",
         "rspamd-com_settings": "A setting name will be auto-generated, please see the example presets below. For more details see <a href=\"https://rspamd.com/doc/configuration/settings.html#settings-structure\" target=\"_blank\">Rspamd docs</a>",
         "rspamd_global_filters": "Global filter maps",
         "rspamd_global_filters_agree": "I will be careful!",
@@ -289,19 +319,22 @@
         "search_domain_da": "Search domains",
         "send": "Send",
         "sender": "Sender",
+        "service": "Service",
         "service_id": "Service ID",
         "source": "Source",
         "spamfilter": "Spam filter",
         "subject": "Subject",
+        "success": "Success",
         "sys_mails": "System mails",
         "text": "Text",
         "time": "Time",
         "title": "Title",
         "title_name": "\"mailcow UI\" website title",
         "to_top": "Back to top",
-        "transport_dest_format": "Syntax: example.org, .example.org, *, box@example.org (multiple values can be comma-separated)",
+        "transport_dest_format": "Regex or syntax: example.org, .example.org, *, box@example.org (multiple values can be comma-separated)",
         "transport_maps": "Transport Maps",
-        "transports_hint": "→ A transport map entry <b>overrules</b> a sender-dependent transport map</b>.<br>\r\n→ Outbound TLS policy settings per-user are ignored and can only be enforced by TLS policy map entries.<br>\r\n→ The transport service for defined transports is always \"smtp:\" and will therefore try TLS when offered. Wrapped TLS (SMTPS) is not supported.<br>\r\n→ Addresses matching \"/localhost$/\" will always be transported via \"local:\", therefore a \"*\" destination will not apply to those addresses.<br>\r\n→ To determine credentials for an exemplary next hop \"[host]:25\", Postfix <b>always</b> queries for \"host\" before searching for \"[host]:25\". This behavior makes it impossible to use \"host\" and \"[host]:25\" at the same time.",
+        "transport_test_rcpt_info": "&#8226; Use null@hosted.mailcow.de to test relaying to a foreign destination.",
+        "transports_hint": "&#8226; A transport map entry <b>overrules</b> a sender-dependent transport map</b>.<br>\r\n&#8226; MX-based transports are preferably used.<br>\r\n&#8226; Outbound TLS policy settings per-user are ignored and can only be enforced by TLS policy map entries.<br>\r\n&#8226; The transport service for defined transports is always \"smtp:\" and will therefore try TLS when offered. Wrapped TLS (SMTPS) is not supported.<br>\r\n&#8226; Addresses matching \"/localhost$/\" will always be transported via \"local:\", therefore a \"*\" destination will not apply to those addresses.<br>\r\n&#8226; To determine credentials for an exemplary next hop \"[host]:25\", Postfix <b>always</b> queries for \"host\" before searching for \"[host]:25\". This behavior makes it impossible to use \"host\" and \"[host]:25\" at the same time.",
         "ui_footer": "Footer (HTML allowed)",
         "ui_header_announcement": "Announcements",
         "ui_header_announcement_active": "Set announcement active",
@@ -309,9 +342,9 @@
         "ui_header_announcement_help": "The announcement is visible for all logged in users and on the login screen of the UI.",
         "ui_header_announcement_select": "Select announcement type",
         "ui_header_announcement_type": "Type",
+        "ui_header_announcement_type_danger": "Very important",
         "ui_header_announcement_type_info": "Info",
         "ui_header_announcement_type_warning": "Important",
-        "ui_header_announcement_type_danger": "Very important",
         "ui_texts": "UI labels and texts",
         "unban_pending": "unban pending",
         "unchanged_if_empty": "If unchanged leave blank",
@@ -347,6 +380,7 @@
         "domain_quota_m_in_use": "Domain quota must be greater or equal to %s MiB",
         "extra_acl_invalid": "External sender address \"%s\" is invalid",
         "extra_acl_invalid_domain": "External sender \"%s\" uses an invalid domain",
+        "fido2_verification_failed": "FIDO2 verification failed: %s",
         "file_open_error": "File cannot be opened for writing",
         "filter_type": "Wrong filter type",
         "from_invalid": "Sender must not be empty",
@@ -390,6 +424,7 @@
         "network_host_invalid": "Invalid network or host: %s",
         "next_hop_interferes": "%s interferes with nexthop %s",
         "next_hop_interferes_any": "An existing next hop interferes with %s",
+        "nginx_reload_failed": "Nginx reload failed: %s",
         "no_user_defined": "No user defined",
         "object_exists": "Object %s already exists",
         "object_is_not_numeric": "Value %s is not numeric",
@@ -430,49 +465,61 @@
         "totp_verification_failed": "TOTP verification failed",
         "transport_dest_exists": "Transport destination \"%s\" exists",
         "u2f_verification_failed": "U2F verification failed: %s",
-        "fido2_verification_failed": "FIDO2 verification failed: %s",
         "unknown": "An unknown error occurred",
         "unknown_tfa_method": "Unknown TFA method",
         "unlimited_quota_acl": "Unlimited quota prohibited by ACL",
         "username_invalid": "Username %s cannot be used",
         "validity_missing": "Please assign a period of validity",
         "value_missing": "Please provide all values",
+        "xmpp_map_write_error": "Could not write XMPP map: %s",
+        "xmpp_reload_failed": "XMPP could not be reloaded",
+        "xmpp_restart_failed": "XMPP could not be restarted",
         "yotp_verification_failed": "Yubico OTP verification failed: %s"
     },
     "debug": {
         "chart_this_server": "Chart (this server)",
         "containers_info": "Container information",
         "disk_usage": "Disk usage",
+        "docs": "Docs",
         "external_logs": "External logs",
         "history_all_servers": "History (all servers)",
         "in_memory_logs": "In-memory logs",
         "jvm_memory_solr": "JVM memory usage",
+        "last_modified": "Last modified",
         "log_info": "<p>mailcow <b>in-memory logs</b> are collected in Redis lists and trimmed to LOG_LINES (%d) every minute to reduce hammering.\r\n  <br>In-memory logs are not meant to be persistent. All applications that log in-memory, also log to the Docker daemon and therefore to the default logging driver.\r\n  <br>The in-memory log type should be used for debugging minor issues with containers.</p>\r\n  <p><b>External logs</b> are collected via API of the given application.</p>\r\n  <p><b>Static logs</b> are mostly activity logs, that are not logged to the Dockerd but still need to be persistent (except for API logs).</p>",
+        "login_time": "Time",
         "logs": "Logs",
+        "online_users": "Users online",
         "restart_container": "Restart",
+        "service": "Service",
+        "size": "Size",
         "solr_dead": "Solr is starting, disabled or died.",
-        "solr_docs": "Docs",
-        "solr_last_modified": "Last modified",
-        "solr_size": "Size",
-        "solr_started_at": "Started at",
         "solr_status": "Solr status",
-        "solr_uptime": "Uptime",
+        "started_at": "Started at",
         "started_on": "Started on",
         "static_logs": "Static logs",
-        "system_containers": "System & Containers"
+        "success": "Success",
+        "system_containers": "System & Containers",
+        "uptime": "Uptime",
+        "username": "Username",
+        "xmpp_dead": "XMPP is starting, disabled or died.",
+        "xmpp_status": "XMPP status"
     },
     "diagnostics": {
         "cname_from_a": "Value derived from A/AAAA record. This is supported as long as the record points to the correct resource.",
         "dns_records": "DNS Records",
         "dns_records_24hours": "Please note that changes made to DNS may take up to 24 hours to correctly have their current state reflected on this page. It is intended as a way for you to easily see how to configure your DNS records and to check whether all your records are correctly stored in DNS.",
         "dns_records_data": "Correct Data",
+        "dns_records_docs": "Please also consult <a target=\"_blank\" href=\"https://mailcow.github.io/mailcow-dockerized-docs/prerequisite-dns/\">the documentation</a>.",
         "dns_records_name": "Name",
         "dns_records_status": "Current State",
         "dns_records_type": "Type",
         "optional": "This record is optional."
     },
     "edit": {
+        "acl": "ACL (Permission)",
         "active": "Active",
+        "admin": "Edit administrator",
         "advanced_settings": "Advanced settings",
         "alias": "Edit alias",
         "allow_from_smtp": "Only allow these IPs to use <b>SMTP</b>",
@@ -482,10 +529,10 @@
         "app_passwd": "App password",
         "automap": "Try to automap folders (\"Sent items\", \"Sent\" => \"Sent\" etc.)",
         "backup_mx_options": "Relay options",
-        "bcc_dest_format": "BCC destination must be a single valid email address.",
+        "bcc_dest_format": "BCC destination must be a single valid email address.<br> If you need to send a copy to multiple addresses, create an Alias and use it here.",
         "client_id": "Client ID",
         "client_secret": "Client secret",
-        "comment_info": "A private comment is not visible to the user, while a public comment is shown as tooltip when hovering it in a users overview",
+        "comment_info": "A private comment is not visible to the user, while a public comment is shown as tooltip when hovering it in a user's overview",
         "delete1": "Delete from source when completed",
         "delete2": "Delete messages on destination that are not on source",
         "delete2duplicates": "Delete duplicates on destination",
@@ -512,8 +559,10 @@
         "hostname": "Hostname",
         "inactive": "Inactive",
         "kind": "Kind",
+        "lookup_mx": "Destination is a regular expression to match against MX name (<code>.*google\\.com</code> to route all mail targeted to a MX ending in google.com over this hop)",
         "mailbox": "Edit mailbox",
         "mailbox_quota_def": "Default mailbox quota",
+        "mailbox_relayhost_info": "Applied to the mailbox and direct aliases only, does override a domain relayhost.",
         "max_aliases": "Max. aliases",
         "max_mailboxes": "Max. possible mailboxes",
         "max_quota": "Max. quota per mailbox (MiB)",
@@ -522,12 +571,14 @@
         "mbox_rl_info": "This rate limit is applied on the SASL login name, it matches any \"from\" address used by the logged-in user. A mailbox rate limit overrides a domain-wide rate limit.",
         "mins_interval": "Interval (min)",
         "multiple_bookings": "Multiple bookings",
+        "none_inherit": "None / Inherit",
         "nexthop": "Next hop",
         "password": "Password",
         "password_repeat": "Confirmation password (repeat)",
         "previous": "Previous page",
         "private_comment": "Private comment",
         "public_comment": "Public comment",
+        "pushover": "Pushover",
         "pushover_evaluate_x_prio": "Escalate high priority mail [<code>X-Priority: 1</code>]",
         "pushover_info": "Push notification settings will apply to all clean (non-spam) mail delivered to <b>%s</b> including aliases (shared, non-shared, tagged).",
         "pushover_only_x_prio": "Only consider high priority mail [<code>X-Priority: 1</code>]",
@@ -538,6 +589,9 @@
         "pushover_vars": "When no sender filter is defined, all mails will be considered.<br>Regex filters as well as exact sender checks can be defined individually and will be considered sequentially. They do not depend on each other.<br>Useable variables for text and title (please take note of data protection policies)",
         "pushover_verify": "Verify credentials",
         "quota_mb": "Quota (MiB)",
+        "quota_warning_bcc": "Quota warning BCC",
+        "quota_warning_bcc_info": "Warnings will be sent as separate copies to the following recipients. The subject will be suffixed by the corresponding username in brackets, for example: <code>Quota warning (user@example.com)</code>.",
+        "ratelimit": "Rate limit",
         "redirect_uri": "Redirect/Callback URL",
         "relay_all": "Relay all recipients",
         "relay_all_info": "↪ If you choose <b>not</b> to relay all recipients, you will need to add a (\"blind\") mailbox for every single recipient that should be relayed.",
@@ -550,16 +604,17 @@
         "save": "Save changes",
         "scope": "Scope",
         "sender_acl": "Allow to send as",
-        "sender_acl_disabled": "↳ <span class=\"label label-danger\">Sender check is disabled</span>",
+        "sender_acl_disabled": "<span class=\"label label-danger\">Sender check is disabled</span>",
         "sender_acl_info": "If mailbox user A is allowed to send as mailbox user B, the sender address is not automatically displayed as selectable \"from\" field in SOGo.<br>\r\n  Mailbox user B needs to create a delegation in SOGo to allow mailbox user A to select their address as sender. To delegate a mailbox in SOGo, use the menu (three dots) to the right of your mailbox name in the upper left while in mail view. This behaviour does not apply to alias addresses.",
         "sieve_desc": "Short description",
         "sieve_type": "Filter type",
         "skipcrossduplicates": "Skip duplicate messages across folders (first come, first serve)",
         "sogo_access": "Grant access to SOGo",
-        "sogo_access_info": "Grant or permit access to SOGo. This setting does neither affect access to all other services nor does it delete or change a users existing SOGo profile.",
+        "sogo_access_info": "Grant or permit access to SOGo. This setting does neither affect access to all other services nor does it delete or change a user's existing SOGo profile.",
         "sogo_visible": "Alias is visible in SOGo",
         "sogo_visible_info": "This option only affects objects, that can be displayed in SOGo (shared or non-shared alias addresses pointing to at least one local mailbox). If hidden, an alias will not appear as selectable sender in SOGo.",
         "spam_alias": "Create or change time limited alias addresses",
+        "spam_filter": "Spam filter",
         "spam_policy": "Add or remove items to white-/blacklist",
         "spam_score": "Set a custom spam score",
         "subfolder2": "Sync into subfolder on destination<br><small>(empty = do not use subfolder)</small>",
@@ -571,16 +626,41 @@
         "title": "Edit object",
         "unchanged_if_empty": "If unchanged leave blank",
         "username": "Username",
-        "validate_save": "Validate and save"
+        "validate_save": "Validate and save",
+        "xmpp": "Activate XMPP for this domain",
+        "xmpp_access": "XMPP access",
+        "xmpp_access_info": "XMPP must be enabled for this domain.",
+        "xmpp_admin": "XMPP administrator",
+        "xmpp_admin_info": "<b>Danger:</b> Promotes a user to an XMPP administrator of this domain.",
+        "xmpp_example_jid": "<b>Example JID</b> (login with mailbox password)",
+        "xmpp_info": "This function will enable chat functionality for this domain.",
+        "xmpp_prefix": "XMPP prefix for domain (\"im\" to use <b>im</b>.example.org)",
+        "xmpp_prefix_info": "To request certificates for XMPP, two CNAME DNS records should point from <b>im</b>.example.org as well as <b>*.im</b>.example.org to <b>%s</b>. Please also run the DNS check for this domain after enabling XMPP."
+    },
+    "fido2": {
+        "confirm": "Confirm",
+        "fido2_auth": "Login with FIDO2",
+        "fido2_success": "Device successfully registered",
+        "fido2_validation_failed": "Validation failed",
+        "fn": "Friendly name",
+        "known_ids": "Known IDs",
+        "none": "Disabled",
+        "register_status": "Registration status",
+        "rename": "Rename",
+        "set_fido2": "Register FIDO2 device",
+        "set_fn": "Set friendly name",
+        "start_fido2_validation": "Start FIDO2 validation"
     },
     "footer": {
         "cancel": "Cancel",
         "confirm_delete": "Confirm deletion",
         "delete_now": "Delete now",
         "delete_these_items": "Please confirm your changes to the following object id",
+        "hibp_check": "Check against haveibeenpwned.com",
         "hibp_nok": "Matched! This is a potentially dangerous password!",
         "hibp_ok": "No match found.",
         "loading": "Please wait...",
+        "nothing_selected": "Nothing selected",
         "restart_container": "Restart container",
         "restart_container_info": "<b>Important:</b> A graceful restart may take a while to complete, please wait for it to finish.",
         "restart_now": "Restart now",
@@ -617,6 +697,7 @@
         "active": "Active",
         "add": "Add",
         "add_alias": "Add alias",
+        "add_alias_expand": "Expand alias over alias domains",
         "add_bcc_entry": "Add BCC map",
         "add_domain": "Add domain",
         "add_domain_alias": "Add domain alias",
@@ -628,9 +709,10 @@
         "add_tls_policy_map": "Add TLS policy map",
         "address_rewriting": "Address rewriting",
         "alias": "Alias",
-        "alias_domain_alias_hint": "Aliases are <b>not</b> applied on domain aliases automatically. An alias address <code>my-alias@domain</code> <b>does not</b> cover the address <code>my-alias@alias-domain</code> (where \"alias-domain\" is an imaginary alias domain for \"domain\").<br>Please use a sieve filter to redirect mail to an external mailbox (see tab \"Filters\" or use  SOGo -> Forwarder).",
+        "alias_domain_alias_hint": "Aliases are <b>not</b> applied on domain aliases automatically. An alias address <code>my-alias@domain</code> <b>does not</b> cover the address <code>my-alias@alias-domain</code> (where \"alias-domain\" is an imaginary alias domain for \"domain\").<br>Please use a sieve filter to redirect mail to an external mailbox (see tab \"Filters\" or use  SOGo -> Forwarder). Use \"Expand alias over alias domains\" to automatically add missing aliases.",
         "alias_domain_backupmx": "Alias domain inactive for relay domain",
         "aliases": "Aliases",
+        "all_domains": "All Domains",
         "allow_from_smtp": "Only allow these IPs to use <b>SMTP</b>",
         "allow_from_smtp_info": "Leave empty to allow all senders.<br>IPv4/IPv6 addresses and networks.",
         "allowed_protocols": "Allowed protocols",
@@ -654,6 +736,7 @@
         "booking_custom_short": "Hard limit",
         "booking_lt0": "Unlimited, but show as busy when booked",
         "booking_lt0_short": "Soft limit",
+        "catch_all": "Catch-All",
         "daily": "Daily",
         "deactivate": "Deactivate",
         "description": "Description",
@@ -671,20 +754,23 @@
         "filter_table": "Filter table",
         "filters": "Filters",
         "fname": "Full name",
+        "goto_ham": "Learn as <b>ham</b>",
+        "goto_spam": "Learn as <b>spam</b>",
         "hourly": "Hourly",
         "in_use": "In use (%)",
         "inactive": "Inactive",
         "insert_preset": "Insert example preset \"%s\"",
         "kind": "Kind",
         "last_mail_login": "Last mail login",
+        "last_pw_change": "Last password change",
         "last_run": "Last run",
         "last_run_reset": "Schedule next",
         "mailbox": "Mailbox",
+        "mailbox_defaults": "Default settings",
+        "mailbox_defaults_info": "Define default settings for new mailboxes.",
         "mailbox_defquota": "Default mailbox size",
         "mailbox_quota": "Max. size of a mailbox",
         "mailboxes": "Mailboxes",
-        "mailbox_defaults": "Default settings",
-        "mailbox_defaults_info": "Define default settings for new mailboxes.",
         "mins_interval": "Interval (min)",
         "msg_num": "Message #",
         "multiple_bookings": "Multiple bookings",
@@ -692,15 +778,17 @@
         "no": "&#10005;",
         "no_record": "No record for object %s",
         "no_record_single": "No record",
+        "open_logs": "Open logs",
         "owner": "Owner",
         "private_comment": "Private comment",
         "public_comment": "Public comment",
-        "q_add_header": "Junk folder",
-        "q_all": "All categories",
-        "q_reject": "Rejected",
-        "quarantine_notification": "Quarantine notifications",
+        "q_add_header": "when moved to Junk folder",
+        "q_all": " when moved to Junk folder and on reject",
+        "q_reject": "on reject",
         "quarantine_category": "Quarantine notification category",
+        "quarantine_notification": "Quarantine notifications",
         "quick_actions": "Actions",
+        "recipient": "Recipient",
         "recipient_map": "Recipient map",
         "recipient_map_info": "Recipient maps are used to replace the destination address on a message before it is delivered.",
         "recipient_map_new": "New recipient",
@@ -711,9 +799,10 @@
         "remove": "Remove",
         "resources": "Resources",
         "running": "Running",
+        "sender": "Sender",
         "set_postfilter": "Mark as postfilter",
         "set_prefilter": "Mark as prefilter",
-        "sieve_info": "You can store multiple filters per user, but only one prefilter and one postfilter can be active at the same time.<br>\r\nEach filter will be processed in the described order. Neither a failed script nor an issued \"keep;\" will stop processing of further scripts. Changes to global sieve scripts will trigger a restart of Dovecot.<br><br>Global sieve prefilter → Prefilter → User scripts → Postfilter → Global sieve postfilter",
+        "sieve_info": "You can store multiple filters per user, but only one prefilter and one postfilter can be active at the same time.<br>\r\nEach filter will be processed in the described order. Neither a failed script nor an issued \"keep;\" will stop processing of further scripts. Changes to global sieve scripts will trigger a restart of Dovecot.<br><br>Global sieve prefilter &#8226; Prefilter &#8226; User scripts &#8226; Postfilter &#8226; Global sieve postfilter",
         "sieve_preset_1": "Discard mail with probable dangerous file types",
         "sieve_preset_2": "Always mark the e-mail of a specific sender as seen",
         "sieve_preset_3": "Discard silently, stop all further sieve processing",
@@ -723,7 +812,6 @@
         "sieve_preset_7": "Redirect and keep/drop",
         "sieve_preset_8": "Discard message sent to an alias address the sender is part of",
         "sieve_preset_header": "Please see the example presets below. For more details see <a href=\"https://en.wikipedia.org/wiki/Sieve_(mail_filtering_language)\" target=\"_blank\">Wikipedia</a>.",
-        "sogo_allow_admin_hint": "Administrative SOGo logins are only available for mailboxes with an existing SOGo profile. A user must have been logged in to SOGo at least once.",
         "sogo_visible": "Alias is visible in SOGo",
         "sogo_visible_n": "Hide alias in SOGo",
         "sogo_visible_y": "Show alias in SOGo",
@@ -743,8 +831,8 @@
         "tls_map_parameters_info": "Empty or parameters, for example: protocols=!SSLv2 ciphers=medium exclude=3DES",
         "tls_map_policy": "Policy",
         "tls_policy_maps": "TLS policy maps",
-        "tls_policy_maps_info": "This policy map overrides outgoing TLS transport rules independently of a users TLS policy settings.<br>\r\n  Please check <a href=\"http://www.postfix.org/postconf.5.html#smtp_tls_policy_maps\" target=\"_blank\">the \"smtp_tls_policy_maps\" docs</a> for further information.",
         "tls_policy_maps_enforced_tls": "These policies will also override the behaviour for mailbox users that enforce outgoing TLS connections. If no policy exists below, these users will apply the default values specified as <code>smtp_tls_mandatory_protocols</code> and <code>smtp_tls_mandatory_ciphers</code>.",
+        "tls_policy_maps_info": "This policy map overrides outgoing TLS transport rules independently of a user's TLS policy settings.<br>\r\n  Please check <a href=\"http://www.postfix.org/postconf.5.html#smtp_tls_policy_maps\" target=\"_blank\">the \"smtp_tls_policy_maps\" docs</a> for further information.",
         "tls_policy_maps_long": "Outgoing TLS policy map overrides",
         "toggle_all": "Toggle all",
         "username": "Username",
@@ -786,6 +874,9 @@
         "qitem": "Quarantine item",
         "quarantine": "Quarantine",
         "quick_actions": "Actions",
+        "quick_delete_link": "Open quick delete link",
+        "quick_info_link": "Open info link",
+        "quick_release_link": "Open quick release link",
         "rcpt": "Recipient",
         "received": "Received",
         "recipients": "Recipients",
@@ -799,10 +890,7 @@
         "rspamd_result": "Rspamd result",
         "sender": "Sender (SMTP)",
         "sender_header": "Sender (\"From\" header)",
-        "type": "Type",
-        "quick_release_link": "Open quick release link",
-        "quick_delete_link": "Open quick delete link",
-        "quick_info_link": "Open info link",
+        "settings_info": "Maximum amount of elements to be quarantined: %s<br>Maximum email size: %s MiB",
         "show_item": "Show item",
         "spam": "Spam",
         "spam_score": "Score",
@@ -811,7 +899,15 @@
         "table_size_show_n": "Show %s items",
         "text_from_html_content": "Content (converted html)",
         "text_plain_content": "Content (text/plain)",
-        "toggle_all": "Toggle all"
+        "toggle_all": "Toggle all",
+        "type": "Type"
+    },
+    "ratelimit": {
+      "disabled": "Disabled",
+      "second": "msgs / second",
+      "minute": "msgs / minute",
+      "hour": "msgs / hour",
+      "day": "msgs / day"
     },
     "start": {
         "help": "Show/Hide help panel",
@@ -868,7 +964,9 @@
         "mailbox_added": "Mailbox %s has been added",
         "mailbox_modified": "Changes to mailbox %s have been saved",
         "mailbox_removed": "Mailbox %s has been removed",
+        "nginx_reloaded": "Nginx was reloaded",
         "object_modified": "Changes to object %s have been saved",
+        "password_policy_saved": "Password policy was saved successfully",
         "pushover_settings_edited": "Pushover settings successfully set, please verify credentials.",
         "qlearn_spam": "Message ID %s was learned as spam and deleted",
         "queue_command_success": "Queue command completed successfully",
@@ -890,10 +988,13 @@
         "tls_policy_map_entry_saved": "TLS policy map entry \"%s\" has been saved",
         "ui_texts": "Saved changes to UI texts",
         "upload_success": "File uploaded successfully",
+        "verified_fido2_login": "Verified FIDO2 login",
         "verified_totp_login": "Verified TOTP login",
         "verified_u2f_login": "Verified U2F login",
-        "verified_fido2_login": "Verified FIDO2 login",
-        "verified_yotp_login": "Verified Yubico OTP login"
+        "verified_yotp_login": "Verified Yubico OTP login",
+        "xmpp_maps_updated": "XMPP maps were updated",
+        "xmpp_reloaded": "XMPP service was reloaded",
+        "xmpp_restarted": "XMPP service was restarted"
     },
     "tfa": {
         "api_register": "%s uses the Yubico Cloud API. Please get an API key for your key <a href=\"https://upgrade.yubico.com/getapikey/\" target=\"_blank\">here</a>",
@@ -920,20 +1021,6 @@
         "waiting_usb_register": "<i>Waiting for USB device...</i><br><br>Please enter your password above and confirm your registration by tapping the button on your USB device.",
         "yubi_otp": "Yubico OTP authentication"
     },
-    "fido2": {
-        "set_fn": "Set friendly name",
-        "fn": "Friendly name",
-        "rename": "rename",
-        "confirm": "Confirm",
-        "register_status": "Registration status",
-        "known_ids": "Known IDs",
-        "none": "Disabled",
-        "set_fido2": "Register FIDO2 device",
-        "start_fido2_validation": "Start FIDO2 validation",
-        "fido2_auth": "Login with FIDO2",
-        "fido2_success": "Device successfully registered",
-        "fido2_validation_failed": "Validation failed"
-    },
     "user": {
         "action": "Action",
         "active": "Active",
@@ -956,9 +1043,11 @@
         "apple_connection_profile_complete": "This connection profile includes IMAP and SMTP parameters as well as CalDAV (calendars) and CardDAV (contacts) paths for an Apple device.",
         "apple_connection_profile_mailonly": "This connection profile includes IMAP and SMTP configuration parameters for an Apple device.",
         "change_password": "Change password",
+        "clear_recent_successful_connections": "Clear seen successful connections",
         "client_configuration": "Show configuration guides for email clients and smartphones",
         "create_app_passwd": "Create app password",
         "create_syncjob": "Create new sync job",
+        "created_on": "Created on",
         "daily": "Daily",
         "day": "day",
         "delete_ays": "Please confirm the deletion process.",
@@ -970,10 +1059,13 @@
         "edit": "Edit",
         "email": "Email",
         "email_and_dav": "Email, calendars and contacts",
+        "empty": "No results",
         "encryption": "Encryption",
         "excludes": "Excludes",
         "expire_in": "Expire in",
+        "fido2_webauthn": "FIDO2/WebAuthn",
         "force_pw_update": "You <b>must</b> set a new password to be able to access groupware related services.",
+        "from": "from",
         "generate": "generate",
         "hour": "hour",
         "hourly": "Hourly",
@@ -982,17 +1074,26 @@
         "interval": "Interval",
         "is_catch_all": "Catch-all for domain/s",
         "last_mail_login": "Last mail login",
+        "last_pw_change": "Last password change",
         "last_run": "Last run",
+        "last_ui_login": "Last UI login",
         "loading": "Loading...",
-        "mailbox_details": "Mailbox details",
+        "login_history": "Login history",
+        "mailbox": "Mailbox",
+        "mailbox_details": "Details",
+        "mailbox_general": "General",
+        "mailbox_settings": "Settings",
         "messages": "messages",
+        "month": "month",
+        "months": "months",
         "never": "Never",
         "new_password": "New password",
-        "new_password_description": "Requirement: 6 characters long, letters and numbers.",
         "new_password_repeat": "Confirmation password (repeat)",
         "no_active_filter": "No active filter available",
         "no_last_login": "No last UI login information",
         "no_record": "No record",
+        "open_logs": "Open logs",
+        "open_webmail_sso": "Login to webmail",
         "password": "Password",
         "password_now": "Current password (confirm changes)",
         "password_repeat": "Password (repeat)",
@@ -1008,10 +1109,11 @@
         "q_add_header": "Junk folder",
         "q_all": "All categories",
         "q_reject": "Rejected",
-        "quarantine_notification": "Quarantine notifications",
         "quarantine_category": "Quarantine notification category",
-        "quarantine_notification_info": "Once a notification has been sent, items will be marked as \"notified\" and no further notifications will be sent for this particular item.",
         "quarantine_category_info": "The notification category \"Rejected\" includes mail that was rejected, while \"Junk folder\" will notify a user about mails that were put into the junk folder.",
+        "quarantine_notification": "Quarantine notifications",
+        "quarantine_notification_info": "Once a notification has been sent, items will be marked as \"notified\" and no further notifications will be sent for this particular item.",
+        "recent_successful_connections": "Seen successful connections",
         "remove": "Remove",
         "running": "Running",
         "save": "Save changes",
@@ -1021,7 +1123,7 @@
         "shared_aliases_desc": "Shared aliases are not affected by user specific settings such as the spam filter or encryption policy. Corresponding spam filters can only be made by an administrator as a domain-wide policy.",
         "show_sieve_filters": "Show active user sieve filter",
         "sogo_profile_reset": "Reset SOGo profile",
-        "sogo_profile_reset_help": "This will destroy a users SOGo profile and <b>delete all contact and calendar data irretrievable</b>.",
+        "sogo_profile_reset_help": "This will destroy a user's SOGo profile and <b>delete all contact and calendar data irretrievable</b>.",
         "sogo_profile_reset_now": "Reset profile now",
         "spam_aliases": "Temporary email aliases",
         "spam_score_reset": "Reset to server default",
@@ -1062,7 +1164,9 @@
         "waiting": "Waiting",
         "week": "week",
         "weekly": "Weekly",
-        "weeks": "weeks"
+        "weeks": "weeks",
+        "year": "year",
+        "years": "years"
     },
     "warning": {
         "cannot_delete_self": "Cannot delete logged in user",
@@ -1071,6 +1175,7 @@
         "fuzzy_learn_error": "Fuzzy hash learn error: %s",
         "hash_not_found": "Hash not found or already deleted",
         "ip_invalid": "Skipped invalid IP: %s",
+        "is_not_primary_alias": "Skipped non-primary alias %s",
         "no_active_admin": "Cannot deactivate last active admin",
         "quota_exceeded_scope": "Domain quota exceeded: Only unlimited mailboxes can be created in this domain scope.",
         "session_token": "Form token invalid: Token mismatch",
diff --git a/mailcow/src/mailcow-dockerized/data/web/lang/lang.es.json b/mailcow/src/mailcow-dockerized/data/web/lang/lang.es.json
index 4e78b6f..eac99a5 100644
--- a/mailcow/src/mailcow-dockerized/data/web/lang/lang.es.json
+++ b/mailcow/src/mailcow-dockerized/data/web/lang/lang.es.json
@@ -344,12 +344,12 @@
         "logs": "Logs",
         "restart_container": "Reiniciar",
         "solr_dead": "Solr está empezando, deshabilitado o caído.",
-        "solr_docs": "Docs",
-        "solr_last_modified": "Última modificación",
-        "solr_size": "Tamaño",
-        "solr_started_at": "Iniciado el",
+        "docs": "Docs",
+        "last_modified": "Última modificación",
+        "size": "Tamaño",
+        "started_at": "Iniciado el",
         "solr_status": "Solr status",
-        "solr_uptime": "Uptime",
+        "uptime": "Uptime",
         "static_logs": "Logs estáticos",
         "system_containers": "Sistema y Contenedores"
     },
@@ -772,4 +772,4 @@
         "fuzzy_learn_error": "Error aprendiendo hash: %s",
         "ip_invalid": "IP inválida omitida: %s"
     }
-}
\ No newline at end of file
+}
diff --git a/mailcow/src/mailcow-dockerized/data/web/lang/lang.fi.json b/mailcow/src/mailcow-dockerized/data/web/lang/lang.fi.json
index f762401..3410ccc 100644
--- a/mailcow/src/mailcow-dockerized/data/web/lang/lang.fi.json
+++ b/mailcow/src/mailcow-dockerized/data/web/lang/lang.fi.json
@@ -389,12 +389,12 @@
         "logs": "Logit tausta palveluista",
         "restart_container": "Uudelleen käynnistä",
         "solr_dead": "Solr käynnistyy, on poissa käytöstä tai kuoli.",
-        "solr_docs": "Docs",
-        "solr_last_modified": "Viimeksi muokattu",
-        "solr_size": "Koko",
-        "solr_started_at": "Käynnistetty",
+        "docs": "Docs",
+        "last_modified": "Viimeksi muokattu",
+        "size": "Koko",
+        "started_at": "Käynnistetty",
         "solr_status": "Solr-tila",
-        "solr_uptime": "Päällä",
+        "uptime": "Päällä",
         "started_on": "Aloitettiin",
         "static_logs": "Staattiset lokit",
         "system_containers": "Systeemi & Säiliöt"
@@ -468,7 +468,7 @@
         "save": "Tallenna muutokset",
         "scope": "Laajuus",
         "sender_acl": "Salli lähettää nimellä",
-        "sender_acl_disabled": "↳ <span class=\"label label-danger\">Lähettäjän tarkistus on poistettu käytöstä</span>",
+        "sender_acl_disabled": "<span class=\"label label-danger\">Lähettäjän tarkistus on poistettu käytöstä</span>",
         "sender_acl_info": "Jos postilaatikon käyttäjän A sallitaan lähettävän postilaatikon käyttäjäksi B, lähettäjän osoitetta ei näytetä automaattisesti valittavana \"alkaen\" -kentässä SOGossa.<br>\r\nSähkö postilaatikon käyttäjän A on luotava valtuutus SOGoon, jotta sähkö postilaatikon käyttäjä b voi valita osoitteen lähettäjäksi. Tämä käyttäytyminen ei koske alias-osoitteita",
         "sieve_desc": "Lyhyt kuvaus",
         "sieve_type": "Suodattimen tyyppi",
@@ -889,4 +889,4 @@
         "session_token": "Lomakkeen tunnus sanoma ei kelpaa: tunnus sanoman risti riita",
         "session_ua": "Lomakkeen tunnus sanoma ei kelpaa: käyttäjä agentin tarkistus virhe"
     }
-}
\ No newline at end of file
+}
diff --git a/mailcow/src/mailcow-dockerized/data/web/lang/lang.fr.json b/mailcow/src/mailcow-dockerized/data/web/lang/lang.fr.json
index 94f8657..07cd326 100644
--- a/mailcow/src/mailcow-dockerized/data/web/lang/lang.fr.json
+++ b/mailcow/src/mailcow-dockerized/data/web/lang/lang.fr.json
@@ -9,10 +9,12 @@
 		"filters": "Filtres",
 		"login_as": "S'identifier en tant qu'utilisateur",
 		"prohibited": "Interdit par les ACL",
+		"protocol_access": "Modifier le protocol d'acces",
 		"pushover": "Pushover",
 		"quarantine": "Actions de quarantaine",
 		"quarantine_attachments": "Pièces jointes en quarantaine",
 		"quarantine_notification": "Modifier la notification de quarantaine",
+		"quarantine_category": "Modifier la catégorie de la notification de quarantaine",
 		"ratelimit": "Limite d'envoi",
 		"recipient_maps": "Cartes destinataire",
 		"smtp_ip_access": "Changer les hôtes autorisés pour SMTP",
@@ -23,7 +25,12 @@
 		"spam_score": "Score SPAM",
 		"syncjobs": "Tâches de synchronisation",
 		"tls_policy": "Police TLS",
-		"unlimited_quota": "Quota illimité pour les boites de courriel"
+		"unlimited_quota": "Quota illimité pour les boites de courriel",
+		"domain_desc": "Modifier la description du domaine",
+		"xmpp_admin": "Promouvoir l'utilisateur XMPP en administrateur",
+		"xmpp_domain_access": "Configurer l'accès au domaine XMPP",
+		"xmpp_mailbox_access": "Configurer l'accès à l'utilisateur XMPP",
+		"xmpp_prefix": "Changer le sous-domaine XMPP (préfixe)"
 	},
 	"add": {
 		"activate_filter_warn": "Tous les autres filtres seront désactivés, quand activé est coché.",
@@ -31,7 +38,7 @@
 		"add": "Ajouter",
 		"add_domain_only": "Ajouter uniquement le domaine",
 		"add_domain_restart": "Ajouter le domaine et redémarrer SOGo",
-		"alias_address": "Alias d'adresse/s",
+		"alias_address": "Alias d'adresse(s)",
 		"alias_address_info": "<small>Adresse(s) courriel complète(s) ou @example.com, pour capturer tous les messages d'un domaine (séparées par des virgules). <b>Seulement des domaines Mailcow</b>.</small>",
 		"alias_domain": "Alias de domaine",
 		"alias_domain_info": "<small>Seulement des noms de domaines valides (séparés par des virgules).</small>",
@@ -56,6 +63,12 @@
 		"full_name": "Nom complet",
 		"gal": "Carnet d'Adresses Global (GAL)",
 		"gal_info": "La liste d'adresse globale (GAL) contient tous les objets d'un domaine et ne peut être modifié par aucun utilisateur. Si elles sont désactivées,les informations libres/occupées dans SOGo sont cachées, ! <b>Redémarrez SOGo pour appliquer les changements.</b>",
+		"xmpp": "Activer XMPP pour ce domaine",
+		"xmpp_info": "Cette fonction activera la fonctionnalité de chat pour ce domaine.",
+		"xmpp_access": "Accès XMPP",
+		"xmpp_access_info": "XMPP doit être activé pour ce domaine.",
+		"xmpp_admin": "Administrateur XMPP",
+		"xmpp_admin_info": "<b>Attention</b>: promeut un utilisateur au rang d'administrateur XMPP pour ce domaine.",
 		"generate": "Générer",
 		"goto_ham": "Apprendre en tant que <span class=\"text-success\"><b>Courrier légitime (ham)</b></span>",
 		"goto_null": "Ignorer silencieusement le courriel",
@@ -136,6 +149,7 @@
 		"ban_list_info": "Consultez la liste des adresses IP interdites ci-dessous: <b>réseau (durée d'interdiction restante) - [actions]</b>.<br />Les adresses IP mises en file d'attente pour être interdites seront supprimées de la liste d'interdiction active dans quelques secondes.<br />Les étiquettes rouges indiquent des interdictions permanentes actives par liste noire.",
 		"change_logo": "Changer de logo",
 		"configuration": "Configuration",
+		"convert_html_to_text": "Convertir le code HTML en texte brut",
 		"credentials_transport_warning": "<b>Attention</b>: L’ajout d’une nouvelle entrée de carte de transport mettra à jour les informations d’identification pour toutes les entrées avec une colonne nexthop correspondante.",
 		"customer_id": "ID client",
 		"customize": "Personnaliser",
@@ -156,20 +170,23 @@
 		"dkim_to": "Vers",
 		"dkim_to_title": "Les domaines ciblés seront réécrits",
 		"domain": "Domaine",
+		"domain_admin": "Administrateur de domaine",
 		"domain_admins": "Administrateurs de domaine",
-		"domain_s": "Domaine/s",
+		"domain_s": "Domaine(s)",
 		"duplicate": "Dupliquer",
 		"duplicate_dkim": "Dupliquer l'enregistrement DKIM",
 		"edit": "Editer",
 		"empty": "Aucun résultat",
 		"excludes": "Exclure ces destinataires",
-		"f2b_ban_time": "Durée du bannissement (s)",
+		"f2b_ban_time": "Durée du bannissement(s)",
 		"f2b_blacklist": "Réseaux/Domaines sur Liste Noire",
+		"f2b_filter": "Filtre(s) Regex",
 		"f2b_list_info": "Un hôte ou un réseau sur liste noire l'emportera toujours sur une entité de liste blanche. <b>L'application des mises à jour de liste prendra quelques secondes.</b>",
 		"f2b_max_attempts": "Nb max. de tentatives",
 		"f2b_netban_ipv4": "Taille du sous-réseau IPv4 pour l'application du bannissement (8-32)",
 		"f2b_netban_ipv6": "Taille du sous-réseau IPv6 pour l'application du bannissement (8-128)",
 		"f2b_parameters": "Paramètres Fail2ban",
+		"f2b_regex_info": "Logs pris en compte: SOGo, Postfix, Dovecot, PHP-FPM.",
 		"f2b_retry_window": "Fenêtre de nouvel essai pour le nb max. de tentatives",
 		"f2b_whitelist": "Réseaux/hôtes en liste blanche",
 		"filter_table": "Table de filtrage",
@@ -184,6 +201,7 @@
 		"hash_remove_info": "La suppression d'un hachage ratelimit (s'il existe toujours) réinitialisera complètement son compteur.<br>\r\n  Chaque hachage est indiqué par une couleur individuelle.",
 		"help_text": "Remplacer le texte d'aide sous le masque de connexion (HTML autorisé)",
 		"host": "Hôte",
+		"html": "HTML",
 		"import": "Importer",
 		"import_private_key": "Importer la clè privée",
 		"in_use_by": "Utilisé par",
@@ -212,6 +230,7 @@
 		"oauth2_redirect_uri": "URI de redirection",
 		"oauth2_renew_secret": "Générer un nouveau secret client",
 		"oauth2_revoke_tokens": "Révoquer tous les jetons",
+		"optional": "Optionnel",
 		"password": "Mot de passe",
 		"password_repeat": "Confirmation du mot de passe (répéter)",
 		"priority": "Priorité",
@@ -221,6 +240,7 @@
 		"quarantine_exclude_domains": "Exclure les domaines et les alias de domaine",
 		"quarantine_max_age": "Âge maximun en jour(s)<br><small>La valeur doit être égale ou supérieure à 1 jour.</small>",
 		"quarantine_max_size": "Taille maximum en Mo (les éléments plus grands sont mis au rebut):<br><small>0 ne signifie <b>pas</b> illimité.</small>",
+		"quarantine_max_score": "Ignorer la notification si le score de spam est au dessus de cette valeur:<br><small>Par défaut: 9999.0</small>",
 		"quarantine_notification_html": "Modèle de courriel de notification:<br><small>Laisser vide pour restaurer le modèle par défaut.</small>",
 		"quarantine_notification_sender": "Notification par e-mail de l’expéditeur",
 		"quarantine_notification_subject": "Objet du courriel de notification",
@@ -343,6 +363,7 @@
 		"global_filter_write_error": "Impossible d’écrire le fichier de filtre: %s",
 		"global_map_invalid": "ID de carte globale %s non valide",
 		"global_map_write_error": "Impossible d’écrire l’ID de la carte globale %s: %s",
+		"xmpp_map_write_error": "Impossible d'écrire la carte XMPP: %s",
 		"goto_empty": "Une adresse alias doit contenir au moins une adresse 'goto'valide",
 		"goto_invalid": "Adresse Goto %s non valide",
 		"ham_learn_error": "Erreur d'apprentissage Ham: %s",
@@ -377,6 +398,7 @@
 		"max_quota_in_use": "Le quota de la boîte doit être supérieur ou égal à %d Mo",
 		"maxquota_empty": "Le quota maximum par boîte ne doit pas être de 0.",
 		"mysql_error": "Erreur MySQL: %s",
+		"nginx_reload_failed": "Le rechargement de Nginx a échoué: %s",
 		"network_host_invalid": "Réseau ou host non valide: %s",
 		"next_hop_interferes": "%s interfère avec le nexthop %s",
 		"next_hop_interferes_any": "Un saut suivant existant interfère avec %s",
@@ -397,6 +419,7 @@
 		"redis_error": "Erreur Redis: %s",
 		"relayhost_invalid": "La saisie de la carte %s est invalide",
 		"release_send_failed": "Le message n’a pas pu être diffusé: %s",
+		"reset_f2b_regex": "Le filtre regex n'a pas pu être réinitialisé à temps, veuillez réessayer ou attendre quelques secondes de plus et recharger le site web.",
 		"resource_invalid": "Le nom de la resource %s n'est pas valide",
 		"rl_timeframe": "Le délai limite du taux est incorrect",
 		"rspamd_ui_pw_length": "Le mot de passe de l'interface Rspamd doit être de 6 caratères au minimum",
@@ -412,19 +435,23 @@
 		"targetd_relay_domain": "Le domaine cible %s est un domaine de relais",
 		"temp_error": "Erreur temporaire",
 		"text_empty": "La zone texte ne peut pas être vide",
+		"tfa_token_invalid": "Le token TFA est invalide",
 		"tls_policy_map_dest_invalid": "La politique de destination n'est pas valide",
 		"tls_policy_map_entry_exists": "Une entrée de carte de politique \"%s\" existe",
 		"tls_policy_map_parameter_invalid": "Le paramètre Policy est invalide",
 		"totp_verification_failed": "Echec de la vérification TOTP",
 		"transport_dest_exists": "La destination de transport \"%s\" existe",
 		"u2f_verification_failed": "Echec de la vérification U2F: %s",
+		"fido2_verification_failed": "La vérification FIDO2 a échoué: %s",
 		"unknown": "Une erreur inconnue est survenue",
 		"unknown_tfa_method": "Methode TFA inconnue",
 		"unlimited_quota_acl": "Quota illimité interdit par les ACL",
 		"username_invalid": "Le nom d'utilisateur %s ne peut pas être utilisé",
 		"validity_missing": "Veuillez attribuer une période de validité",
 		"value_missing": "Veuillez fournir toutes les valeurs",
-		"yotp_verification_failed": "La vérification Yubico OTP en échec: %s"
+		"yotp_verification_failed": "La vérification Yubico OTP a échoué: %s",
+		"xmpp_restart_failed": "XMPP n'a pas pu être redémarré",
+		"xmpp_reload_failed": "XMPP n'a pas pu être rechargé"
 	},
 	"debug": {
 		"chart_this_server": "Graphique (ce serveur)",
@@ -438,20 +465,24 @@
 		"logs": "Logs",
 		"restart_container": "Redémarrer",
 		"solr_dead": "Solr est en cours de démarrage, désactivé ou mort.",
-		"solr_docs": "Docs",
-		"solr_last_modified": "Dernière modification",
-		"solr_size": "Taille",
-		"solr_started_at": "Démarré à",
+		"xmpp_dead": "XMPP est en cours de démarrage, désactivé ou mort.",
+		"docs": "Docs",
+		"last_modified": "Dernière modification",
+		"online_users": "Utilisateurs en ligne",
+		"size": "Taille",
+		"started_at": "Démarré à",
 		"solr_status": "Etat Solr",
-		"solr_uptime": "Disponibilité",
+		"uptime": "Disponibilité",
 		"started_on": "Démarré à",
 		"static_logs": "Logs statiques",
-		"system_containers": "Système & Conteneurs"
+		"system_containers": "Système & Conteneurs",
+		"xmpp_status": "Status de XMPP"
 	},
 	"diagnostics": {
 		"cname_from_a": "Valeur dérivée de l’enregistrement A/AAAA. Ceci est supporté tant que l’enregistrement indique la bonne ressource.",
 		"dns_records": "Enregistrements DNS",
 		"dns_records_24hours": "Veuillez noter que les modifications apportées au DNS peuvent prendre jusqu’à 24 heures pour que leurs états actuels soient correctement reflétés sur cette page. Il est conçu comme un moyen pour vous de voir facilement comment configurer vos enregistrements DNS et de vérifier si tous vos enregistrements sont correctement stockés dans les DNS.",
+		"dns_records_docs": "Veuillez également consulter <a target=\"_blank\" href=\"https://mailcow.github.io/mailcow-dockerized-docs/prerequisite-dns/\">la documentation</a>.",
 		"dns_records_data": "Données correcte",
 		"dns_records_name": "Nom",
 		"dns_records_status": "Etat courant",
@@ -464,6 +495,7 @@
 		"alias": "Editer les alias",
 		"allow_from_smtp": "Restreindre l'utilisation de <b>SMTP</b> à ces adresses IP",
 		"allow_from_smtp_info": "Laissez vide pour autoriser tous les expéditeurs.<br>Adresses IPv4/IPv6 et réseaux.",
+		"allowed_protocols": "Protocoles autorisés",
 		"app_name": "Nom de l'application",
 		"app_passwd": "Mot de passe de l'application",
 		"automap": "Essayer d’automatiser les dossiers (\"Sent items\", \"Sent\" => \"Sent\" etc.)",
@@ -493,6 +525,15 @@
 		"full_name": "Nom complet",
 		"gal": "Liste d'adresses globale (GAL)",
 		"gal_info": "La liste d'adresses globale (GAL) contient tous les objets d’un domaine et ne peut pas être édité par un utilisateur. Les informations libres/occupées dans SOGo sont manquantes si elles sont désactivées! <b>Redémarrer SOGo pour appliquer les modifications.</b>",
+		"xmpp": "Activer XMPP pour ce domaine",
+		"xmpp_prefix": "Préfixe XMPP pour le domaine (\"im\" pour utiliser <b>im</b>.exemple.org)",
+		"xmpp_prefix_info": "Pour demander des certificats XMPP, deux enregistrements DNS CNAME doivent pointer de <b> im </b> .exemple.org ainsi que de <b> * .im </b> .exemple.org vers <b>% s </ b>. Veuillez également exécuter la vérification DNS pour ce domaine après avoir activé XMPP.",
+		"xmpp_info": "Cette fonction activera la fonctionnalité de chat pour ce domaine.",
+		"xmpp_access": "Accès XMPP",
+		"xmpp_access_info": "XMPP doit être activé pour ce domaine.",
+		"xmpp_admin": "Administrateur XMPP",
+		"xmpp_admin_info": "<b>Attention:</b> Promeut un utilisateur au rang d'administrateur XMPP de ce domaine.",
+		"xmpp_example_jid": "<b>Exemple JID</b> (se connecter avec le mot de passe de la boîte aux lettres)",		
 		"generate": "générer",
 		"grant_types": "Types 'autorisation",
 		"hostname": "Nom d'hôte",
@@ -524,6 +565,7 @@
 		"pushover_vars": "Lorsque aucun filtre d’expéditeur n’est défini, tous les messages seront considérés.<br>Les filtres Regex ainsi que les vérifications exactes de l’expéditeur peuvent être définis individuellement et seront considérés de façon séquentielle. Ils ne dépendent pas les uns des autres.<br>Variables utilisables pour le texte et le titre (veuillez prendre note des politiques de protection des données)",
 		"pushover_verify": "Vérifier les justificatifs",
 		"quota_mb": "Quota (Mo)",
+		"ratelimit": "Limite de taux",
 		"redirect_uri": "Redirection/rappel URL",
 		"relay_all": "Relayer tous les destinataires",
 		"relay_all_info": "↪ Si vous <b>ne choissisez pas</b> de relayer tous les destinataires, vous devrez ajouter une boîte (\"aveugle\") pour chaque destinataire qui devrait être relayé.",
@@ -536,7 +578,7 @@
 		"save": "Enregistrer les modifications",
 		"scope": "Portée",
 		"sender_acl": "Permettre d’envoyer comme",
-		"sender_acl_disabled": "↳ <span class=\"label label-danger\">Le contrôle de l’expéditeur est désactivé</span>",
+		"sender_acl_disabled": "<span class=\"label label-danger\">Le contrôle de l’expéditeur est désactivé</span>",
 		"sender_acl_info": "Si l’utilisateur de la boîte A est autorisé à envoyer en tant qu’utilisateur de la boîte B, l’adresse de l’expéditeur n’est pas automatiquement affichée comme sélectionnable du champ \"from\" dans SOGo.<br>\r\n  L’utilisateur B de la boîte doit créer une délégation dans Sogo pour permettre à l’utilisateur A de la boîte de sélectionner son adresse comme expéditeur. Pour déléguer une boîte dans Sogo, utilisez le menu (trois points) à droite du nom de votre boîte dans le coin supérieur gauche dans la vue de courrier. Ce comportement ne s’applique pas aux adresses alias.",
 		"sieve_desc": "Description courte",
 		"sieve_type": "Type de filtre",
@@ -546,11 +588,12 @@
 		"sogo_visible": "Alias visible dans SOGo",
 		"sogo_visible_info": "Cette option affecte uniquement les objets qui peuvent être affichés dans SOGo (adresses alias partagées ou non partagées pointant vers au moins une boîte mail locale). Si caché, un alias n’apparaîtra pas comme expéditeur sélectionnable dans SOGo.",
 		"spam_alias": "Créer ou modifier des adresses alias limitées dans le temps",
+		"spam_filter": "Filtre spam",
 		"spam_policy": "Ajouter ou supprimer des éléments à la liste blanche/noire",
 		"spam_score": "Définir un score spam personnalisé",
 		"subfolder2": "Synchronisation dans le sous-dossier sur la destination<br><small>(vide = ne pas utiliser de sous-dossier)</small>",
 		"syncjob": "Modifier la tâche de synchronisation",
-		"target_address": "Adresse/s Goto<small>(séparé/s par des virgules)</small>",
+		"target_address": "Adresse(s) Goto<small>(séparé(s) par des virgules)</small>",
 		"target_domain": "Domaine cible",
 		"timeout1": "Délai de connexion à l’hôte distant",
 		"timeout2": "Délai de connexion à l’hôte local",
@@ -590,8 +633,10 @@
 	},
 	"login": {
 		"delayed": "La connexion a été retardée de %s secondes.",
+		"fido2_webauthn": "FIDO2/WebAuthn",
 		"login": "Connexion",
 		"mobileconfig_info": "Veuillez vous connecter en tant qu’utilisateur de la boîte pour télécharger le profil de connexion Apple demandé.",
+		"other_logins": "Clé d'authentification",
 		"password": "Mot de passe",
 		"username": "Nom d'utilisateur"
 	},
@@ -617,6 +662,7 @@
 		"aliases": "Aliases",
 		"allow_from_smtp": "Restreindre l'utilisation de <b>SMTP</b> à ces adresses IP",
 		"allow_from_smtp_info": "Laissez vide pour autoriser tous les expéditeurs.<br>Adresses IPv4/IPv6 et réseaux.",
+		"allowed_protocols": "Protocoles autorisés",
 		"backup_mx": "Sauvegarde MX",
 		"bcc": "BCC",
 		"bcc_destination": "Destination BCC",
@@ -666,6 +712,8 @@
 		"mailbox_defquota": "Taille de boîte par défaut",
 		"mailbox_quota": "Taille max. d’une boîte",
 		"mailboxes": "Boîtes mail",
+		"mailbox_defaults": "Paramètres par défaut",
+		"mailbox_defaults_info": "Définir les paramètres par défaut pour les nouvelles boîtes aux lettres.",
 		"mins_interval": "Intervalle (min)",
 		"msg_num": "Message #",
 		"multiple_bookings": "Réservations multiples",
@@ -676,7 +724,11 @@
 		"owner": "Propriétaire",
 		"private_comment": "Commentaire privé",
 		"public_comment": "Commentaire public",
+		"q_add_header": "Courriers indésirables",
+		"q_all": "Toutes les catégories",
+		"q_reject": "Rejecté",
 		"quarantine_notification": "Avis de quarantaine",
+		"quarantine_category": "Catégorie de la notification de quarantaine",
 		"quick_actions": "Actions",
 		"recipient_map": "Carte du destinataire",
 		"recipient_map_info": "Les cartes des destinataires sont utilisées pour remplacer l’adresse de destination d’un message avant sa livraison.",
@@ -700,7 +752,6 @@
 		"sieve_preset_7": "Rediriger et garder/déposer",
 		"sieve_preset_8": "Supprimer le message envoyé à une adresse alias dont fait partie l’expéditeur",
 		"sieve_preset_header": "Voir les exemples de préréglages ci-dessous. Pour plus de détails voir <a href=\"https://en.wikipedia.org/wiki/Sieve_(mail_filtering_language)\" target=\"_blank\">Wikipedia</a>.",
-		"sogo_allow_admin_hint": "Les connexions administratives Sogo ne sont disponibles que pour les boîtes mail avec un profil SOGo existant. Un utilisateur doit avoir été connecté à Sogo au moins une fois.",
 		"sogo_visible": "Alias visible dans SOGo",
 		"sogo_visible_n": "Masquer alias dans SOGo",
 		"sogo_visible_y": "Afficher alias dans SOGo",
@@ -711,7 +762,7 @@
 		"table_size": "Taille de la table",
 		"table_size_show_n": "Montrer %s articles",
 		"target_address": "Goto adresse",
-		"target_domain": "Domain cible",
+		"target_domain": "Domaine cible",
 		"tls_enforce_in": "Appliquer le TLS entrant",
 		"tls_enforce_out": "Appliquer le TLS sortant",
 		"tls_map_dest": "Destination",
@@ -742,12 +793,17 @@
 		"action": "Action",
 		"atts": "Pièces jointes",
 		"check_hash": "Hachage du fichier de recherche @ VT",
+		"confirm": "Confirmer",
 		"confirm_delete": "Confirmer la suppression de cet élément.",
 		"danger": "Danger",
+		"deliver_inbox": "Envoyer dans la boîte de reception",
 		"disabled_by_config": "La configuration actuelle du système désactive la fonctionnalité de quarantaine. Veuillez définir \"retentions par boîte\" et une \"taille maximum\" pour les éléments en quarantaine.",
+		"settings_info": "Quantité maximum d'éléments à mettre en quarantaine: %s<br>Taille maximale des e-mails: %s MiB",
 		"download_eml": "Télécharger (.eml)",
 		"empty": "Pas de résultat",
 		"high_danger": "Haut",
+		"info": "Information",
+		"junk_folder": "Courriers indésirables",
 		"learn_spam_delete": "Apprendre comme spam et supprimer",
 		"low_danger": "Danger faible",
 		"medium_danger": "Danger moyen",
@@ -755,6 +811,7 @@
 		"notified": "Notifié",
 		"qhandler_success": "Demande envoyée avec succès au système. Vous pouvez maintenant fermer la fenêtre.",
 		"qid": "Rspamd QID",
+		"qinfo": "Le système de quarantaine enregistrera le courrier rejeté dans la base de données (l'expéditeur n'aura <em> pas </em> l'impression d'un courrier remis) ainsi que le courrier, qui est remis sous forme de copie dans le dossier indésirable d'une boîte aux lettres.\r\n  <br>\"Apprendre comme spam et supprimer\" apprendra un message comme spam via le théorème Bayesianet calculera également des hachages flous pour refuser des messages similaires à l'avenir.\r\n  <br>Veuillez noter que l'apprentissage de plusieurs messages peut prendre du temps, selon votre système. <br> Les éléments figurant sur la liste noire sont exclus de la quarantaine.",
 		"qitem": "Élément de quarantaine",
 		"quarantine": "Quarantaine",
 		"quick_actions": "Actions",
@@ -762,16 +819,21 @@
 		"received": "Reçu",
 		"recipients": "Destinataires",
 		"refresh": "Rafraîchir",
+		"rejected": "Rejeté",
 		"release": "Libérer",
 		"release_body": "Nous avons joint votre message comme fichier eml à ce message.",
 		"release_subject": "Article de quarantaine potentiellement dommageable %s",
 		"remove": "Enlever",
+		"rewrite_subject": "Réécrire le sujet",
 		"rspamd_result": "Résultat Rspamd",
 		"sender": "Expéditeur (SMTP)",
 		"sender_header": "Expéditeur (\"From\" header)",
+		"type": "Type",
 		"quick_release_link": "Ouvrir le lien de dégagement rapide",
 		"quick_delete_link": "Ouvrir le lien de suppression rapide",
+		"quick_info_link": "Ouvrir le lien d'informations",
 		"show_item": "Montrer l'article",
+		"spam": "Spam",
 		"spam_score": "Score",
 		"subj": "Sujet",
 		"table_size": "Dimension de la table",
@@ -835,6 +897,7 @@
 		"mailbox_added": "La boîte mail %s a été ajoutée",
 		"mailbox_modified": "Les modifications de la boîte %s ont été sauvées",
 		"mailbox_removed": "La boîte %s a été supprimée",
+		"nginx_reloaded": "Nginx a été rechargé",
 		"object_modified": "Les changements de %s ont été sauvés",
 		"pushover_settings_edited": "Paramètres Pushover réglés avec succès, veuillez vérifier les informations d’identification.",
 		"qlearn_spam": "Le message ID %s a été appris comme spam et supprimé",
@@ -859,7 +922,11 @@
 		"upload_success": "Fichier téléchargé avec succès",
 		"verified_totp_login": "Authentification TOTP vérifiée",
 		"verified_u2f_login": "Authentification U2F vérifiée",
-		"verified_yotp_login": "Authentification Yubico OTP vérifiée"
+		"verified_fido2_login": "Authentification FIDO2 vérifiée",
+		"verified_yotp_login": "Authentification Yubico OTP vérifiée",
+		"xmpp_restarted": "Le service XMPP a été redémarré",
+		"xmpp_reloaded": "Le service XMPP a été rechargé",
+		"xmpp_maps_updated": "Les cartes XMPP ont été mises à jour"
 	},
 	"tfa": {
 		"api_register": "%s utilise l'API Yubico Cloud. Veuillez obtenir une clé API pour votre clé <a href=\"https://upgrade.yubico.com/getapikey/\" target=\"_blank\">here</a>",
@@ -879,15 +946,30 @@
 		"set_tfa": "Définir une méthode d’authentification à deux facteurs",
 		"start_u2f_validation": "Début de la validation",
 		"tfa": "Authentification à deux facteurs",
+		"tfa_token_invalid": "Token TFA invalide",
 		"totp": "OTP (One Time Password = Mot de passe à usage unique : Google Authenticator, Authy, etc.)",
 		"u2f": "Authentification U2F",
 		"waiting_usb_auth": "<i>En attente d’un périphérique USB...</i><br><br>S’il vous plaît appuyez maintenant sur le bouton de votre périphérique USB U2F.",
 		"waiting_usb_register": "<i>En attente d’un périphérique USB...</i><br><br>Veuillez entrer votre mot de passe ci-dessus et confirmer votre inscription U2F en appuyant sur le bouton de votre périphérique USB U2F.",
 		"yubi_otp": "Authentification OTP Yubico"
 	},
+	"fido2": {
+		"set_fn": "Définir un nom",
+		"fn": "Nom",
+		"rename": "renommer",
+		"confirm": "Confirmer",
+		"register_status": "Etat de l'enregistrement",
+		"known_ids": "Identifiant(s) connu(s)",
+		"none": "Désactivé",
+		"set_fido2": "Enregistrer un nouvel appareil FIDO2",
+		"start_fido2_validation": "Tester la validation FIDO2",
+		"fido2_auth": "Se connecter avec FIDO2",
+		"fido2_success": "L'appareil est enregistré avec succès",
+		"fido2_validation_failed": "La validation a échoué"
+	},
 	"user": {
 		"action": "Action",
-		"active": "Active",
+		"active": "Actif",
 		"active_sieve": "Filtre actif",
 		"advanced_settings": "Paramètres avancés",
 		"alias": "Alias",
@@ -904,8 +986,8 @@
 		"app_name": "Nom d'application",
 		"app_passwds": "Mots de passe de l'application",
 		"apple_connection_profile": "Profil de connexion Apple",
-		"apple_connection_profile_complete": "Ce profil de connexion inclut les paramètres IMAP et SMTP ainsi que les chemins Caldav (calendriers) et Carddav (contacts) pour un appareil Apple." ,
-		"apple_connection_profile_mailonly" : "Ce profil de connexion inclut les paramètres de configuration IMAP et SMTP pour un périphérique Apple.",
+		"apple_connection_profile_complete": "Ce profil de connexion inclut les paramètres IMAP et SMTP ainsi que les chemins Caldav (calendriers) et Carddav (contacts) pour un appareil Apple.",
+		"apple_connection_profile_mailonly": "Ce profil de connexion inclut les paramètres de configuration IMAP et SMTP pour un périphérique Apple.",
 		"change_password": "Changer le mot de passe",
 		"client_configuration": "Afficher les guides de configuration pour les clients de messagerie et les smartphones",
 		"create_app_passwd": "Créer un mot de passe application",
@@ -931,7 +1013,7 @@
 		"hours": "heures",
 		"in_use": "Utilisé",
 		"interval": "Intervalle",
-		"is_catch_all": "Attrape-tout pour le domaine/s",
+		"is_catch_all": "Attrape-tout pour le domaine(s)",
 		"last_mail_login": "Dernière connexion mail",
 		"last_run": "Dernière exécution",
 		"loading": "Chargement...",
@@ -956,8 +1038,13 @@
 		"pushover_title": "Titre de la notification",
 		"pushover_vars": "Lorsqu’aucun filtre d’expéditeur n’est défini, tous les messages seront considérés.<br>Les filtres Regex ainsi que les vérifications exactes de l’expéditeur peuvent être définis individuellement et seront considérés de façon séquentielle. Ils ne dépendent pas les uns des autres.<br>Variables utilisables pour le texte et le titre (veuillez prendre note des politiques de protection des données)",
 		"pushover_verify": "Vérifier les justificatifs",
+		"q_add_header": "Courrier indésirable",
+		"q_all": "Toutes les catégories",
+		"q_reject": "Rejeté",
 		"quarantine_notification": "Avis de quarantaine",
+		"quarantine_category": "Catégorie de la notification de quarantaine",
 		"quarantine_notification_info": "Une fois qu’un avis a été envoyé, les articles seront marqués comme \"notified\" et aucune autre notification ne sera envoyée pour ce point particulier.",
+		"quarantine_category_info": "La catégorie de notification \"Rejeté\" inclut le courrier qui a été rejeté, tandis que \"Dossier indésirable\" informera un utilisateur des e-mails qui ont été placés dans le dossier indésirable.",
 		"remove": "Enlever",
 		"running": "En fonction",
 		"save": "Sauvegarder les changements",
diff --git a/mailcow/src/mailcow-dockerized/data/web/lang/lang.it.json b/mailcow/src/mailcow-dockerized/data/web/lang/lang.it.json
index b3ad092..c02057f 100644
--- a/mailcow/src/mailcow-dockerized/data/web/lang/lang.it.json
+++ b/mailcow/src/mailcow-dockerized/data/web/lang/lang.it.json
@@ -1,203 +1,682 @@
 {
     "acl": {
-        "syncjobs": "Processi di sync"
+        "alias_domains": "Aggiungi alias di dominio",
+        "app_passwds": "Gestisci le password delle app",
+        "bcc_maps": "BCC maps",
+        "delimiter_action": "Delimiter action",
+        "domain_desc": "Modifica la descrizione del dominio",
+        "domain_relayhost": "Modifica relayhost per un dominio",
+        "eas_reset": "Ripristina i dispositivi EAS",
+        "extend_sender_acl": "Allow to extend sender ACL by external addresses",
+        "filters": "Filtri",
+        "login_as": "Accedi come utente della casella di posta",
+        "mailbox_relayhost": "Modifica relayhost per una casella di posta",
+        "prohibited": "Vietato dall'ACL",
+        "protocol_access": "Modifica l'accesso al protocollo",
+        "pushover": "Pushover",
+        "quarantine": "Azioni di quarantena",
+        "quarantine_attachments": "Allegati in quarantena",
+        "quarantine_category": "Modifica la categoria delle notifiche di quarantena",
+        "quarantine_notification": "Modifica notifiche quarantena",
+        "ratelimit": "Rate limit",
+        "recipient_maps": "Recipient maps",
+        "smtp_ip_access": "Modifica gli host consentiti per SMTP",
+        "sogo_access": "Consenti la gestione dell'accesso SOGo",
+        "sogo_profile_reset": "Ripristina profilo SOGo",
+        "spam_alias": "Alias temporanei",
+        "spam_policy": "Blacklist/Whitelist",
+        "spam_score": "Punteggio SPAM",
+        "syncjobs": "Processi di sync",
+        "tls_policy": "TLS policy",
+        "unlimited_quota": "Spazio illimitato per le caselle di posta",
+        "xmpp_admin": "Promuovi l'utente XMPP ad amministratore",
+        "xmpp_domain_access": "Configura l'accesso al dominio XMPP",
+        "xmpp_mailbox_access": "Configura l'accesso utente XMPP",
+        "xmpp_prefix": "Cambia sottodominio XMPP (prefisso)"
     },
     "add": {
+        "activate_filter_warn": "Tutti gli altri filtri saranno disattivati, quando è attivo.",
         "active": "Attiva",
         "add": "Aggiungi",
-        "alias_address": "Indirizzo alias/es:",
-        "alias_address_info": "<small>Indirizzo e-mail completo/es @example.com, per catturare tutti i messaggi di un dominio (separati da virgola). <b>solo domini mailcow</b>.</small>",
+        "add_domain_only": "Aggiungi solamente il dominio",
+        "add_domain_restart": "Aggiungi il dominio e riavvia SOGo",
+        "alias_address": "Indirizzo alias",
+        "alias_address_info": "<small>Indirizzo e-mail completo/i @example.com, per catturare tutti i messaggi di un dominio (separati da virgola). <b>Solo domini mailcow</b>.</small>",
         "alias_domain": "Dominio alias",
-        "alias_domain_info": "<small>Solo nomi di dominio validi (cseparati da virgola).</small>",
-        "backup_mx_options": "Backup MX options:",
-        "delete1": "Elimina dalla sorgente al termine",
+        "alias_domain_info": "<small>Solo nomi di dominio validi (separati da virgola).</small>",
+        "app_name": "Nome app",
+        "app_password": "Aggiungi la password dell'app",
+        "automap": "Prova a mappare automaticamente le cartelle (\"Sent items\", \"Sent\" => \"Posta inviata\" ecc.)",
+        "backup_mx_options": "Relay options",
+        "comment_info": "Un commento privato non è visibile all'utente, mentre un commento pubblico viene mostrato come suggerimento quando si passa con il mouse nella panoramica di un utente",
+        "custom_params": "Parametri personalizzati",
+        "custom_params_hint": "Corretto: --param=xy, errato: --param xy",
+		"delete1": "Elimina dalla sorgente al termine",
+		"delete2": "Elimina i messaggi nella casella di destinazione che non sono presenti nell'origine",
         "delete2duplicates": "Elimina duplicati nella destinazione",
-        "description": "Descrizione:",
+        "description": "Descrizione",
+        "destination": "Destinazione",
+        "disable_login": "Disabilita l'accesso (la posta in arrivo viene correttamente recapitata)",
         "domain": "Dominio",
-        "domain_quota_m": "Spazio totale dominio (MiB):",
-        "enc_method": "Metodo di criptazione",
+        "domain_matches_hostname": "Il dominio %s corrisponde al'hostname",		
+        "domain_quota_m": "Spazio totale dominio (MiB)",
+        "enc_method": "Metodo di crittografia",
         "exclude": "Escludi oggetti (regex)",
-        "full_name": "Nome completo:",
+        "full_name": "Nome completo",
+        "gal": "Global Address List",
+        "gal_info": "La GAL contiene tutti gli indirizzi del dominio e non può essere modificata da nessun utente. Le infomazioni sulla disponibilità di ogni utente non sono presenti in SOGo, se sono state disabilitate! <b>Riavvia SOGo per applicare le modifiche.</b>",
+        "generate": "crea",
+        "goto_ham": "Etichetta come <span class=\"text-success\"><b>ham</b></span>",
+        "goto_null": "Elimina silenziosamente il messaggio",
+        "goto_spam": "Etichetta come <span class=\"text-danger\"><b>spam</b></span>",   
         "hostname": "Hostname",
+        "inactive": "Inattivo",
         "kind": "Genere",
-        "mailbox_quota_m": "Spazio massimo per casella di posta (MiB):",
-        "mailbox_username": "Username (parte a sinistra della @):",
-        "max_aliases": "Numero massimo alias:",
-        "max_mailboxes": "Numero massimo caselle di posta:",
-        "mins_interval": "intervallo di Pooling (minuti)",
+        "mailbox_quota_def": "Spazio predefinito della casella di posta",
+        "mailbox_quota_m": "Spazio massimo per casella di posta (MiB)",
+        "mailbox_username": "Username (parte a sinistra della @)",
+        "max_aliases": "Numero massimo alias",
+        "max_mailboxes": "Numero massimo caselle di posta",
+        "mins_interval": "intervallo (minuti)",
         "multiple_bookings": "Prenotazioni multiple",
-        "password": "Password:",
-        "password_repeat": "Conferma password (riscrivi):",
+        "nexthop": "Hop successivo",
+        "password": "Password",
+        "password_repeat": "Conferma password (riscrivi)",
         "port": "Porta",
-        "post_domain_add": "Dovrai riavviare il servizio SOGo dopo aver aggiunto un nuovo dominio!",
+        "post_domain_add": "Il container di SOGo, \"sogo-mailcow\", deve essere riavviato dopo aver aggiunto un nuovo dominio!<br><br>Inoltre la configurazione dei DNS del dominio verrà riesaminata. Quando la configurazione dei DNS sarà attiva, riavvia \"acme-mailcow\" per generare automaticamente i certificati per il nuovo dominio (autoconfig.&lt;domain&gt;, autodiscover.&lt;domain&gt;).<br>Quest'ultimo passaggio è facoltativo, in quanto il sistema si aggiorna ogni 24 ore.",
+        "private_comment": "Commento privato",
+        "public_comment": "Commento pubblico",
         "quota_mb": "Spazio (MiB):",
         "relay_all": "Trasmettere a tutti i destinatari",
-        "relay_all_info": "<small>Se si sceglie di <b>non</b> inviare tutti i destinatari, è necessario aggiungere una cassetta postale (\"blind\") per ogni singolo destinatario a cui deve essere inoltrato.</small>",
+        "relay_all_info": "<small>Se si sceglie di <b>non</b> inviare a tutti i destinatari, è necessario aggiungere una casella di posta (\"blind\") per ogni singolo destinatario a cui deve essere inoltrato.</small>",
         "relay_domain": "Trasmetti questo dominio",
-        "select": "Perfavore seleziona...",
-        "select_domain": "Perfavore seleziona il dominio prima",
+        "relay_transport_info": "<div class=\"label label-info\">Info</div> Puoi definire mappe di trasporto verso una destinazione a tua scelta per questo dominio. Se non viene impostata, si guarderà il record MX.",
+        "relay_unknown_only": "Inoltra solo caselle di posta inesistenti. I messaggi per gli indirizzi esistenti verranno consegnati localmente.",
+        "relayhost_wrapped_tls_info": "Please do <b>not</b> use TLS-wrapped ports (mostly used on port 465).<br>\r\nUse any non-wrapped port and issue STARTTLS. A TLS policy to enforce TLS can be created in \"TLS policy maps\".",
+        "select": "Si prega di selezionare...",
+        "select_domain": "Seleziona prima un dominio",
+        "sieve_desc": "Descrizione breve",
+        "sieve_type": "Tipologia di filtro",
+        "skipcrossduplicates": "Salta i messaggi duplicati tra le cartelle (precedenza al primo arrivato)",
+        "subscribeall": "Iscriviti a tutte le cartelle",
         "syncjob": "Aggiungi sincronizzazione",
         "syncjob_hint": "Ricordati che le password vanno salvate in testo semplice!",
-        "target_address": "Inoltra all'indirizzo:",
-        "target_address_info": "<small>Indirizzo e-mail completo/es (separati da virgole).</small>",
-        "target_domain": "Target dominio:",
-        "username": "Username"
+        "target_address": "Inoltra all'indirizzo",
+        "target_address_info": "<small>Indirizzo e-mail completo/i (separati da virgole).</small>",
+        "target_domain": "Dominio di destinazione",
+        "timeout1": "Timeout per la connessione all'host remoto",
+        "timeout2": "Timeout per la connessione all'host locale",
+        "username": "Username",
+        "validate": "Convalida",
+        "validation_success": "Convalidato con successo",
+        "xmpp": "Attiva XMPP per questo dominio",
+        "xmpp_access": "Accesso XMPP",
+        "xmpp_access_info": "XMPP deve essere abilitato per questo dominio.",
+        "xmpp_admin": "Amministratore XMPP",
+        "xmpp_admin_info": "<b>Attenzione:</b> Promuove un utente ad amministratore XMPP di questo dominio.",
+        "xmpp_info": "Questa funzione abiliterà la funzionalità di chat per questo dominio."																			
     },
     "admin": {
         "access": "Accedi",
         "action": "Azione",
+        "activate_api": "Attiva API",
+        "activate_send": "Attiva bottone di invio",
         "active": "Attiva",
+        "active_rspamd_settings_map": "Active settings map",
         "add": "Aggiungi",
+        "add_admin": "Aggiungi amministratore",
         "add_domain_admin": "Aggiungi amministratore di dominio",
         "add_forwarding_host": "Aggiungi host inoltro",
+        "add_relayhost": "Add sender-dependent transport",
+        "add_relayhost_hint": "Tieni presente che i dati di autenticazione, se presenti, verranno archiviati come testo semplice.",
+        "add_row": "Aggiungi riga",
+        "add_settings_rule": "Add settings rule",
+        "add_transport": "Aggiungi transport",
+        "add_transports_hint": "Tieni presente che i dati di autenticazione, se presenti, verranno archiviati come testo semplice.",
+        "additional_rows": " righe aggiuntive inserite",
         "admin": "Amministratore",
         "admin_details": "Modifica impostazioni amministratore",
         "admin_domains": "Assengazioni di dominio",
+        "admins": "Amministratori",
+        "admins_ldap": "Amministratori LDAP",
+        "advanced_settings": "Impostazioni avanzate",
+        "api_allow_from": "Allow API access from these IPs/CIDR network notations",
+        "api_info": "The API is a work in progress. The documentation can be found at <a href=\"/api\">/api</a>",
+        "api_key": "API key",
+        "api_skip_ip_check": "Skip IP check for API",
+        "app_links": "App links",
+        "app_name": "App name",
+        "apps_name": "\"mailcow Apps\" name",
+        "arrival_time": "Arrival time (server time)",
+        "authed_user": "Auth. user",
+        "ays": "Sei sicuro di voler procedere?",
+        "ban_list_info": "See a list of banned IPs below: <b>network (remaining ban time) - [actions]</b>.<br />IPs queued to be unbanned will be removed from the active ban list within a few seconds.<br />Red labels indicate active permanent bans by blacklisting.",
+        "change_logo": "Cambia logo",
         "configuration": "Configurazione",
+        "convert_html_to_text": "Convert HTML to plain text",
+        "credentials_transport_warning": "<b>Warning</b>: Adding a new transport map entry will update the credentials for all entries with a matching next hop column.",
+        "customer_id": "ID cliente",
+        "customize": "Personalizzare",
+        "delete_queue": "Elimina tutto",
+        "destination": "Destinazione",				 
         "dkim_add_key": "Aggiungi chiave ARC/DKIM",
-        "dkim_key_length": "DKIM key length (bits)",
-        "dkim_key_missing": "Key mancante",
-        "dkim_key_unused": "Key non usata",
-        "dkim_key_valid": "Key valida",
-        "dkim_keys": "chiave ARC/DKIM",
+        "dkim_domains_selector": "Selettore",
+        "dkim_domains_wo_keys": "Seleziona i domini senza chiavi",
+        "dkim_from": "Da",
+        "dkim_from_title": "Source domain to copy data from",
+        "dkim_key_length": "Lunghezza chiave DKIM (bits)",
+        "dkim_key_missing": "Chiave mancante",
+        "dkim_key_unused": "Chiave non usata",
+        "dkim_key_valid": "Chiave valida",
+        "dkim_keys": "Chiavi ARC/DKIM",
+        "dkim_overwrite_key": "Sovrascrivi la chiave DKIM esistente",
+        "dkim_private_key": "Chiave privata",
+        "dkim_to": "A",
+        "dkim_to_title": "Dominio/i di destinazione - verranno sovrascritti",
         "domain": "Dominio",
+        "domain_admin": "Amministratore di dominio",
         "domain_admins": "Amministratori di dominio",
+        "domain_s": "Dominio/i",
+        "duplicate": "Duplica",
+        "duplicate_dkim": "Duplica record DKIM",
         "edit": "Modifica",
         "empty": "Nessun risultato",
+        "excludes": "Esclude questi destinatari",
+        "f2b_ban_time": "Tempo di blocco (s)",
+        "f2b_blacklist": "Host/reti in blacklist",
+        "f2b_filter": "Filtri Regex",
+        "f2b_list_info": "Un host oppure una rete in blacklist, avrà sempre un peso maggiore rispetto ad una in whitelist. <b>L'aggiornamento della lista richiede alcuni secondi per la sua entrata in azione.</b>",
+        "f2b_max_attempts": "Tentativi massimi",
+        "f2b_netban_ipv4": "IPv4 subnet size to apply ban on (8-32)",
+        "f2b_netban_ipv6": "IPv6 subnet size to apply ban on (8-128)",
+        "f2b_parameters": "Parametri Fail2ban",
+        "f2b_regex_info": "Log presi in considerazione: SOGo, Postfix, Dovecot, PHP-FPM.",
+        "f2b_retry_window": "Retry window (s) for max. attempts",
+        "f2b_whitelist": "Host/reti in whitelist",
         "filter_table": "Tabella filtro",
+        "flush_queue": "Svuota la coda",
         "forwarding_hosts": "Inoltro degli host",
         "forwarding_hosts_add_hint": "È possibile specificare indirizzi IPv4 / IPv6, reti nella notazione CIDR, nomi host (che verranno risolti in indirizzi IP) o nomi di dominio (che verranno risolti agli indirizzi IP richiamando i record SPF o, in assenza, i record MX) .",
-        "forwarding_hosts_hint": "I messaggi in entrata sono accettati in maniera incondizionata da tutti gli host elencati qui. Questi host sono quindi non controllati contro DNSBL o sottoposti a greylisting. Spam ricevuti da loro non viene mai rifiutata e sempre archiviata nella cartella Junk. L'utilizzo più comune per questo è quello di specificare i server di posta elettronica su cui è stata impostata una regola che inoltra le email in arrivo al server mailcow.",
-        "host": "Hostname",
-        "loading": "Attendere...",
+        "forwarding_hosts_hint": "I messaggi in entrata sono accettati in maniera incondizionata da tutti gli host qui elencati. Questi host sono quindi non controllati tramite DNSBL o sottoposti a greylisting. Lo spam ricevuto da questi host non viene mai rifiutato, ma potrebbe essere archiviato nella cartella Posta indesiderata. L'utilizzo più comune è quello di specificare i server di posta elettronica su cui è stata impostata una regola che inoltra le email in arrivo al server mailcow.",
+        "from": "Da",
+        "generate": "generate",
+        "guid": "GUID - ID istanza univoco",
+        "guid_and_license": "GUID & Licenza",
+        "hash_remove_info": "Removing a ratelimit hash (if still existing) will reset its counter completely.<br>\r\n  Each hash is indicated by an individual color.",
+        "help_text": "Sovrascrivi il testo d'aiuto nella maschera di login (HTML consentito)",
+		"host": "Hostname",
+        "html": "HTML",
+        "import": "Importa",
+        "import_private_key": "Importa chiave privata",
+        "in_use_by": "In uso da",
+        "inactive": "Inattivo",
+        "include_exclude": "Includi/Escludi",
+        "include_exclude_info": "Di default - se nessuna voce viene selezionata - <b>tutte le caselle di posta</b> risultano attivate",
+        "includes": "Includi questi destinatari",
+        "is_mx_based": "Basato sul record MX",
+        "last_applied": "Last applied",
+        "license_info": "Non è necessario essere in possesso di una licenza ma aiuta gli sviluppatori a far crescere il prodotto.<br><a href=\"https://www.servercow.de/mailcow?lang=en#sal\" target=\"_blank\" alt=\"SAL order\">Registra qui il tuo GUID </a> oppure <a href=\"https://www.servercow.de/mailcow?lang=en#support\" target=\"_blank\" alt=\"Support order\">acquista il supporto per la tua installazione di mailcow.</a>",
+        "link": "Link",
+        "loading": "Caricamento in corso...",
+        "login_time": "Ora di accesso",
+        "logo_info": "La tua immagine verrà ridimensionata a 40px di altezza, quando verrà usata nella barra di navigazione in alto, ed ad una larghezza massima di 250px nella schermata iniziale. È altamente consigliato l'utilizzo di un'immagine modulabile.",
+        "lookup_mx": "Destination is a regular expression to match against MX name (<code>.*google\\.com</code> to route all mail targeted to a MX ending in google.com over this hop)",
+        "main_name": "Nome \"mailcow UI\"",
+        "merged_vars_hint": "Greyed out rows were merged from <code>vars.(local.)inc.php</code> and cannot be modified.",
+        "message": "Messaggio",
+        "message_size": "Dimensione mesaggio",
+        "nexthop": "Next hop",
+        "no": "&#10005;",
+        "no_active_bans": "Nessun ban attivo",
+        "no_new_rows": "Nessuna ulteriore riga disponibile",										   
         "no_record": "Nessun risultato",
+        "oauth2_client_id": "ID cliente",
+        "oauth2_client_secret": "Client secret",
+        "oauth2_info": "The OAuth2 implementation supports the grant type \"Authorization Code\" and issues refresh tokens.<br>\r\nThe server also automatically issues new refresh tokens, after a refresh token has been used.<br><br>\r\n&#8226; The default scope is <i>profile</i>. Only mailbox users can be authenticated against OAuth2. If the scope parameter is omitted, it falls back to <i>profile</i>.<br>\r\n&#8226; The <i>state</i> parameter is required to be sent by the client as part of the authorize request.<br><br>\r\nPaths for requests to the OAuth2 API: <br>\r\n<ul>\r\n  <li>Authorization endpoint: <code>/oauth/authorize</code></li>\r\n  <li>Token endpoint: <code>/oauth/token</code></li>\r\n  <li>Resource page:  <code>/oauth/profile</code></li>\r\n</ul>\r\nRegenerating the client secret will not expire existing authorization codes, but they will fail to renew their token.<br><br>\r\nRevoking client tokens will cause immediate termination of all active sessions. All clients need to re-authenticate.",
+        "oauth2_redirect_uri": "URI di reindirizzamento",
+        "oauth2_renew_secret": "Generate new client secret",
+        "oauth2_revoke_tokens": "Revoca tutti i token del client",
+        "optional": "facoltativo",
         "password": "Password",
-        "password_repeat": "Conferma password(ripeti)",
+        "password_length": "Lunghezza password",
+        "password_policy": "Password policy",
+        "password_policy_chars": "Deve contenere almeno un carattere alfabetico",
+        "password_policy_length": "La lunghezza minima della password è %d caratteri",
+        "password_policy_lowerupper": "Deve contenere caratteri minuscoli e maiuscoli",
+        "password_policy_numbers": "Deve contenere almeno un numero",
+        "password_policy_special_chars": "Deve contenere almeno un carattere speciale",
+        "password_repeat": "Conferma password (riscrivi)",
+        "priority": "Priorità",
+        "private_key": "Chiave privata",
+        "quarantine": "Quarantena",
+        "quarantine_bcc": "Invia una copia di tutte le notifiche (CCN) a questo destinatario:<br><small>Lascia vuoto per disabilitare la funzione. <b>Messaggi non firmati e non controllati. Dovrebbero essere consegnati solo localmente.</b></small>",
+        "quarantine_exclude_domains": "Escludi domini e alias di dominio",
+        "quarantine_max_age": "Età massima in giorni<br><small>Il valore deve essere maggiore o uguale ad 1 giorno.</small>",
+        "quarantine_max_score": "Ignora la notifica se il punteggio spam di una mail è superiore a questo valore:<br><small>Di default è 9999.0</small>",
+        "quarantine_max_size": "Dimensione massima in MiB (gli elementi più grandi vengono scartati):<br><small>0 <b>non</b> significa illimitato.</small>",
+        "quarantine_notification_html": "Modello e-mail di notifica:<br><small>Lascia vuoto per utilizzare il modello predefinito.</small>",
+        "quarantine_notification_sender": "Mittente e-mail di notifica",
+        "quarantine_notification_subject": "Oggetto e-mail di notifica",
+        "quarantine_redirect": "<b>Reindirizza tutte le notifiche</b> a questo destinatario:<br><small>Lascia vuoto per disabilitare la funzione. <b>Messaggi non firmati e non controllati. Dovrebbero essere consegnati solo localmente.</b></small>",
+        "quarantine_release_format": "Format of released items",
+        "quarantine_release_format_att": "Come allegato",
+        "quarantine_release_format_raw": "Originale non modificato",
+        "quarantine_retention_size": "Retention per casella di posta:<br><small>0 indica <b>inattivo</b>.</small>",
+        "queue_ays": "Conferma di voler eliminare tutti gli elementi dalla coda corrente.",
+        "queue_deliver_mail": "Consegna",
+        "queue_hold_mail": "Trattieni",
+        "queue_manager": "Gestore code",
+        "queue_show_message": "Visualizza messaggio",
+        "queue_unban": "queue unban",
+        "queue_unhold_mail": "Rilascia",
+        "quota_notification_html": "Modello e-mail di notifica:<br><small>Lascia vuoto per utilizzare il modello predefinito.</small>",
+        "quota_notification_sender": "Mittente e-mail di notifica",
+        "quota_notification_subject": "Oggetto e-mail di notifica",
+        "quota_notifications": "Notifiche sulle quote",
+        "quota_notifications_info": "Le notifiche di spazio vengono inviate agli utenti la cui capienza della casella di posta supera l'80% oppure il 95%.",
+        "quota_notifications_vars": "{{percent}} è lo spazio attualmente utilizzato dell'utente<br>{{username}} è il nome della casella di posta",
         "r_active": "Restrizioni attive",
         "r_inactive": "Restrizioni inattive",
-        "r_info": "Gli elementi disabilitati nell'elenco delle restrizioni attive non sono conosciute come restrizioni valide per la posta e non possono essere spostate. Le restrizioni sconosciute verranno comunque impostate in ordine di aspetto. <br />Puoi aggiungere nuovi elementi in <code>inc/vars.local.inc.php</code> per poterli attivare.",
+        "r_info": "Gli elementi disabilitati nell'elenco delle restrizioni attive non sono conosciute come restrizioni valide per la posta e non possono essere spostate. Le restrizioni sconosciute verranno comunque impostate in ordine di aspetto.<br />Puoi aggiungere nuovi elementi in <code>inc/vars.local.inc.php</code> per poterli attivare.",
+        "rate_name": "Rate name",
+        "recipients": "Destinatari",
+        "refresh": "Aggiorna",
+        "regen_api_key": "Rinnova la chiave delle API",
+        "regex_maps": "Regex maps",
+        "relay_from": "\"Da:\" indirizzi",
+        "relay_rcpt": "\"A:\" indirizzi",
+        "relay_run": "Esegui test",
+        "relayhosts": "Sender-dependent transports",
+        "relayhosts_hint": "Define sender-dependent transports to be able to select them in a domains configuration dialog.<br>\r\n  The transport service is always \"smtp:\" and will therefore try TLS when offered. Wrapped TLS (SMTPS) is not supported. A users individual outbound TLS policy setting is taken into account.<br>\r\n  Affects selected domains including alias domains.",
         "remove": "Rimuovi",
+        "remove_row": "Elimina riga",
+        "reset_default": "Riporta alle condizioni di default",
+        "reset_limit": "Remove hash",
+        "routing": "Routing",
+        "rsetting_add_rule": "Aggiungi regola",
+        "rsetting_content": "Contenuto della regola",
+        "rsetting_desc": "Descrizione breve",
+        "rsetting_no_selection": "Seleziona una regola",
+        "rsetting_none": "Nessuna regola presente",
+        "rsettings_insert_preset": "Insert example preset \"%s\"",
+        "rsettings_preset_1": "Disable all but DKIM and rate limit for authenticated users",
+        "rsettings_preset_2": "I postmaster vogliono lo spam",
+        "rsettings_preset_3": "Consenti solo mittenti specifici per una casella di posta (ad esempio: utilizzo solo come casella di posta interna)",
+        "rspamd-com_settings": "A setting name will be auto-generated, please see the example presets below. For more details see <a href=\"https://rspamd.com/doc/configuration/settings.html#settings-structure\" target=\"_blank\">Rspamd docs</a>",
+        "rspamd_global_filters": "Global filter maps",
+        "rspamd_global_filters_agree": "Starò attento!",
+        "rspamd_global_filters_info": "Global filter maps contain different kind of global black and whitelists.",
+        "rspamd_global_filters_regex": "Their names explain their purpose. All content must contain valid regular expression in the format of \"/pattern/options\" (e.g. <code>/.+@domain\\.tld/i</code>).<br>\r\n  Although rudimentary checks are being executed on each line of regex, Rspamds functionality can be broken, if it fails to read the syntax correctly.<br>\r\n  Rspamd will try to read the map content when changed. If you experience problems, <a href=\"\" data-toggle=\"modal\" data-container=\"rspamd-mailcow\" data-target=\"#RestartContainer\">restart Rspamd</a> to enforce a map reload.<br>Blacklisted elements are excluded from quarantine.",
+        "rspamd_settings_map": "Rspamd settings map",
+        "sal_level": "Moo level",
         "save": "Salva modifiche",
         "search_domain_da": "Ricerca domini",
+        "send": "Invia",
+        "sender": "Mittente",
+        "service": "Servizio",
+        "service_id": "ID del servizio",
+        "source": "Source",
         "spamfilter": "Filtri spam",
+        "subject": "Oggetto",
+        "success": "Successo",
+        "sys_mails": "System mails",
+        "text": "Testo",
+        "time": "Orario",
+        "title": "Titolo",
+        "title_name": "Titolo del sito \"mailcow UI\"",
+        "to_top": "Torna in cima",
+        "transport_dest_format": "Regex or syntax: example.org, .example.org, *, box@example.org (multiple values can be comma-separated)",
+        "transport_maps": "Transport Maps",
+        "transport_test_rcpt_info": "&#8226; Use null@hosted.mailcow.de to test relaying to a foreign destination.",
+        "transports_hint": "&#8226; A transport map entry <b>overrules</b> a sender-dependent transport map</b>.<br>\r\n&#8226; MX-based transports are preferably used.<br>\r\n&#8226; Outbound TLS policy settings per-user are ignored and can only be enforced by TLS policy map entries.<br>\r\n&#8226; The transport service for defined transports is always \"smtp:\" and will therefore try TLS when offered. Wrapped TLS (SMTPS) is not supported.<br>\r\n&#8226; Addresses matching \"/localhost$/\" will always be transported via \"local:\", therefore a \"*\" destination will not apply to those addresses.<br>\r\n&#8226; To determine credentials for an exemplary next hop \"[host]:25\", Postfix <b>always</b> queries for \"host\" before searching for \"[host]:25\". This behavior makes it impossible to use \"host\" and \"[host]:25\" at the same time.",
+        "ui_footer": "Footer (HTML consentito)",
+        "ui_header_announcement": "Annunci",
+        "ui_header_announcement_active": "Attiva annuncio",
+        "ui_header_announcement_content": "Testo (HTML consentito)",
+        "ui_header_announcement_help": "L'annuncio è visibile per tutti gli utenti che hanno effettuato l'accesso e nella schermata di accesso dell'interfaccia utente.",
+        "ui_header_announcement_select": "Seleziona il tipo di annuncio",
+        "ui_header_announcement_type": "Tipo",
+        "ui_header_announcement_type_danger": "Molto importante",
+        "ui_header_announcement_type_info": "Info",
+        "ui_header_announcement_type_warning": "Importante",
+        "ui_texts": "UI labels and texts",
+        "unban_pending": "unban pending",
         "unchanged_if_empty": "Se immutato lasciare vuoto",
-        "username": "Username"
+        "upload": "Upload",				   
+        "username": "Username",
+        "validate_license_now": "Validate GUID against license server",
+        "verify": "Verifica",
+        "yes": "&#10003;"
     },
     "danger": {
         "access_denied": "Accesso negato o form di login non corretto",
-        "alias_domain_invalid": "Alias domain non è valido",
-        "alias_empty": "L'indirizzo di alias non può restare vuoto",
-        "alias_goto_identical": "Alias and goto address must not be identical",
-        "alias_invalid": "L'indirizzo alias non è valido",
-        "aliasd_targetd_identical": "Alias domain must not be equal to target domain",
-        "aliases_in_use": "Il numero massimo di alias must deve essere maggiore o uguale a %d",
+        "alias_domain_invalid": "L'alias di dominio %s non è valido",
+        "alias_empty": "L'indirizzo di alias non può essere vuoto",
+        "alias_goto_identical": "L'alias e l'indirizzo di destinazione non possono essere identici",
+        "alias_invalid": "L'indirizzo alias %s non è valido",
+        "aliasd_targetd_identical": "L'alias di dominio non può essere identico al dominio di destinazione",
+        "aliases_in_use": "Il numero massimo di alias deve essere maggiore o uguale a %d",
+        "app_name_empty": "Il nome dell'app non può essere vuoto",
+        "app_passwd_id_invalid": "App password ID %s invalid",
+        "bcc_empty": "BCC destination cannot be empty",
+        "bcc_exists": "A BCC map %s exists for type %s",
+        "bcc_must_be_email": "BCC destination %s is not a valid email address",
+        "comment_too_long": "Commento troppo lungo, 160 caratteri massimi consentiti",
+        "defquota_empty": "Lo spazio predefinito di una casella di posta non può essere 0.",
         "description_invalid": "La descrizione della risorsa non è valido",
-        "dkim_domain_or_sel_invalid": "DKIM domain or selector invalid",
-        "domain_exists": "Domain %s esiste già",
+        "dkim_domain_or_sel_exists": "Esiste già una chiave DKIM per \"%s\" e non verrà quindi sovrascritta",
+        "dkim_domain_or_sel_invalid": "Dominio DKIM o selettore errato: %s",
+        "domain_cannot_match_hostname": "Il dominio non può corrispondere all'hostname",
+        "domain_exists": "Dominio %s esiste già",
         "domain_invalid": "Il nome di dominio non è valido",
         "domain_not_empty": "Non posso rimuovere domini in non vuoti",
         "domain_not_found": "Dominio non trovato.",
-        "domain_quota_m_in_use": "La quota di dominio deve essere maggiore o uguale a %s MiB",
-        "goto_empty": "L'indirizzo di destinazione non può restare vuoto",
-        "goto_invalid": "Goto address non è valido",
+        "domain_quota_m_in_use": "Lo spazio del dominio deve essere maggiore o uguale a %s MiB",
+        "extra_acl_invalid": "External sender address \"%s\" is invalid",
+        "extra_acl_invalid_domain": "External sender \"%s\" uses an invalid domain",
+        "fido2_verification_failed": "FIDO2 verification failed: %s",
+        "file_open_error": "File cannot be opened for writing",
+        "filter_type": "Wrong filter type",
+        "from_invalid": "Il mittente non può essere vuoto",
+        "global_filter_write_error": "Could not write filter file: %s",
+        "global_map_invalid": "Global map ID %s invalid",
+        "global_map_write_error": "Could not write global map ID %s: %s",
+		"goto_empty": "L'indirizzo di destinazione non può essere vuoto",
+        "goto_invalid": "L'indirizzo di destinazione %s non è valido",
+        "ham_learn_error": "Ham learn error: %s",
+        "imagick_exception": "Error: Imagick exception while reading image",
+        "img_invalid": "Cannot validate image file",
+        "img_tmp_missing": "Cannot validate image file: Temporary file not found",
+        "invalid_bcc_map_type": "Invalid BCC map type",
+        "invalid_destination": "Destination format \"%s\" is invalid",
+        "invalid_filter_type": "Invalid filter type",
+        "invalid_host": "Invalid host specified: %s",
+        "invalid_mime_type": "Invalid mime type",
+        "invalid_nexthop": "Next hop format is invalid",
+        "invalid_nexthop_authenticated": "Next hop exists with different credentials, please update the existing credentials for this next hop first.",
+        "invalid_recipient_map_new": "Invalid new recipient specified: %s",
+        "invalid_recipient_map_old": "Invalid original recipient specified: %s",
+        "ip_list_empty": "L'elenco degli IP consentiti non può essere vuoto",
         "is_alias": "%s è già presente come alias",
-        "is_alias_or_mailbox": "%s è già presente come alias o casella",
+        "is_alias_or_mailbox": "%s è già presente come alias, casella di posta oppure come alias di dominio",
         "is_spam_alias": "%s è già presente come indirizzo spam alias",
         "last_key": "L'ultima chiave non può essere rimossa",
         "login_failed": "Login fallito",
+        "mailbox_defquota_exceeds_mailbox_maxquota": "Default quota exceeds max quota limit",
         "mailbox_invalid": "Il nome della casella non è valido",
-        "mailbox_quota_exceeded": "La quota ha oltrepassato il limite di dominio (max. %d MiB)",
-        "mailbox_quota_exceeds_domain_quota": "La quota massima eccede la quota di dominio",
+        "mailbox_quota_exceeded": "Lo spazio assegnato oltrepassa il limite del dominio (max. %d MiB)",
+        "mailbox_quota_exceeds_domain_quota": "Lo spazio massimo supera la spazio del dominio",
         "mailbox_quota_left_exceeded": "Non c'è abbastanza spazio libero (space left: %d MiB)",
-        "mailboxes_in_use": "La quota della casella massima deve essere maggiore o uguale a %d",
+        "mailboxes_in_use": "Lo spazio massimo della casella deve essere maggiore o uguale a %d",
+        "malformed_username": "Malformed username",
+        "map_content_empty": "Map content cannot be empty",
         "max_alias_exceeded": "Numero massimo di alias superato",
         "max_mailbox_exceeded": "Numero massimo di caselle superato (%d of %d)",
-        "max_quota_in_use": "La quota della casella deve essere maggiore o uguale a %d MiB",
-        "maxquota_empty": "Max. quota per mailbox must not be 0.",
-        "object_exists": "Object %s esiste già",
+        "max_quota_in_use": "Lo spazio della casella deve essere maggiore o uguale a %d MiB",
+        "maxquota_empty": "Lo spazio massimo della casella di posta non può essere 0.",
+        "mysql_error": "Errore MySQL: %s",
+        "network_host_invalid": "Rete o host non valido: %s",
+        "next_hop_interferes": "%s interferes with nexthop %s",
+        "next_hop_interferes_any": "An existing next hop interferes with %s",
+        "nginx_reload_failed": "Nginx reload failed: %s",
+        "no_user_defined": "No user defined",
+        "object_exists": "L'oggetto %s esiste già",
         "object_is_not_numeric": "Il valore %s non è numerico",
         "password_complexity": "La password non soddisfa le regole di sicurezza",
         "password_empty": "Il campo password non può essere vuoto",
         "password_mismatch": "La password di conferma non corrisponde",
         "policy_list_from_exists": "Un elemento con lo stesso nome è già presente",
         "policy_list_from_invalid": "L'elemento ha un formato non valido",
-        "quota_not_0_not_numeric": "La quota deve essere numerica e >= 0",
+        "private_key_error": "Private key error: %s",
+        "pushover_credentials_missing": "Pushover token and or key missing",
+        "pushover_key": "Pushover key has a wrong format",
+        "pushover_token": "Pushover token has a wrong format",
+        "quota_not_0_not_numeric": "Lo spazio deve essere numerico e >= 0",
+        "recipient_map_entry_exists": "A Recipient map entry \"%s\" exists",
+        "redis_error": "Redis error: %s",
+        "relayhost_invalid": "Map entry %s is invalid",
+        "release_send_failed": "Message could not be released: %s",
+        "reset_f2b_regex": "Regex filter could not be reset in time, please try again or wait a few more seconds and reload the website.",
         "resource_invalid": "Il nome della risorsa non è valido",
+        "rl_timeframe": "Rate limit time frame is incorrect",
+        "rspamd_ui_pw_length": "Rspamd UI password should be at least 6 chars long",
+        "script_empty": "Script cannot be empty",
         "sender_acl_invalid": "Il valore di Sender ACL non è valido",
+        "set_acl_failed": "Failed to set ACL",
+        "settings_map_invalid": "Settings map ID %s invalid",
+        "sieve_error": "Sieve parser error: %s",
+        "spam_learn_error": "Spam learn error: %s",
+        "subject_empty": "Subject must not be empty",
         "target_domain_invalid": "Goto domain non è valido",
         "targetd_not_found": "Il target del dominio non è stato trovato",
-        "username_invalid": "Username non può essere utilizzato",
-        "validity_missing": "Assegnare un periodo di validità"
+        "targetd_relay_domain": "Target domain %s is a relay domain",
+        "temp_error": "Temporary error",
+        "text_empty": "Text must not be empty",
+        "tfa_token_invalid": "TFA token invalid",
+        "tls_policy_map_dest_invalid": "Policy destination is invalid",
+        "tls_policy_map_entry_exists": "A TLS policy map entry \"%s\" exists",
+        "tls_policy_map_parameter_invalid": "Policy parameter is invalid",
+        "totp_verification_failed": "TOTP verification failed",
+        "transport_dest_exists": "Transport destination \"%s\" exists",
+        "u2f_verification_failed": "U2F verification failed: %s",
+        "unknown": "An unknown error occurred",
+        "unknown_tfa_method": "Unknown TFA method",
+        "unlimited_quota_acl": "Unlimited quota prohibited by ACL",
+        "username_invalid": "Username %s non può essere utilizzato",
+        "validity_missing": "Assegnare un periodo di validità",
+        "value_missing": "Please provide all values",
+        "xmpp_map_write_error": "Could not write XMPP map: %s",
+        "xmpp_reload_failed": "XMPP could not be reloaded",
+        "xmpp_restart_failed": "XMPP could not be restarted",
+        "yotp_verification_failed": "Yubico OTP verification failed: %s"
+    },
+    "debug": {
+        "chart_this_server": "Grafico (questo server)",
+        "containers_info": "Container information",
+        "disk_usage": "Uso del disco",
+        "docs": "Docs",
+        "external_logs": "External logs",
+        "history_all_servers": "History (all servers)",
+        "in_memory_logs": "In-memory logs",
+        "jvm_memory_solr": "JVM memory usage",
+        "last_modified": "Ultima modifica",
+        "log_info": "<p>mailcow <b>in-memory logs</b> are collected in Redis lists and trimmed to LOG_LINES (%d) every minute to reduce hammering.\r\n  <br>In-memory logs are not meant to be persistent. All applications that log in-memory, also log to the Docker daemon and therefore to the default logging driver.\r\n  <br>The in-memory log type should be used for debugging minor issues with containers.</p>\r\n  <p><b>External logs</b> are collected via API of the given application.</p>\r\n  <p><b>Static logs</b> are mostly activity logs, that are not logged to the Dockerd but still need to be persistent (except for API logs).</p>",
+        "login_time": "Time",
+        "logs": "Logs",
+        "online_users": "Users online",
+        "restart_container": "Riavvio",
+        "service": "Servizio",
+        "size": "Size",
+        "solr_dead": "Solr is starting, disabled or died.",
+        "solr_status": "Stato Solr",
+        "started_at": "Started at",
+        "started_on": "Started on",
+        "static_logs": "Static logs",
+        "success": "Successo",
+        "system_containers": "System & Containers",
+        "uptime": "Tempo di attività",
+        "username": "Username",
+        "xmpp_dead": "XMPP is starting, disabled or died.",
+        "xmpp_status": "Stato XMPP"
+    },
+    "diagnostics": {
+        "cname_from_a": "Valore letto dal record A/AAAA. Questo è supportato finché il record punta alla risorsa corretta.",
+        "dns_records": "Record DNS",
+        "dns_records_24hours": "Tieni presente che le modifiche apportate ai record DNS potrebbero richiedere fino a 24 ore per poter essere visualizzate correttamente in questa pagina. Tutto ciò è da intendersi come un modo per voi di vedere come configurare i record DNS e per controllare se tutti i record DNS sono stati inseriti correttamente.",
+        "dns_records_data": "Dati corretti",
+        "dns_records_docs": "Si prega di consultare anche <a target=\"_blank\" href=\"https://mailcow.github.io/mailcow-dockerized-docs/prerequisite-dns/\">la documentazione</a>.",
+        "dns_records_name": "Nome",
+        "dns_records_status": "Stato attuale",
+        "dns_records_type": "Tipo",
+        "optional": "Questo record è facoltativo."
     },
     "edit": {
         "active": "Attivo",
+        "admin": "Modifica amministratore",
+        "advanced_settings": "Impostazioni avanzate",
         "alias": "Modifica alias",
+        "allow_from_smtp": "Consenti solo a questi IP di utilizzare <b>SMTP</b>",
+        "allow_from_smtp_info": "Leave empty to allow all senders.<br>IPv4/IPv6 addresses and networks.",
+        "allowed_protocols": "Protocolli consentiti",
+        "app_name": "App name",
+        "app_passwd": "App password",
+        "automap": "Try to automap folders (\"Sent items\", \"Sent\" => \"Sent\" etc.)",
         "backup_mx_options": "Backup MX options",
+        "bcc_dest_format": "BCC destination must be a single valid email address.",
+        "client_id": "Client ID",
+        "client_secret": "Client secret",
+        "comment_info": "A private comment is not visible to the user, while a public comment is shown as tooltip when hovering it in a user's overview",
         "delete1": "Elimina dalla sorgente al termine",
+        "delete2": "Delete messages on destination that are not on source",
         "delete2duplicates": "Elimina duplicati nella destinazione",
+        "delete_ays": "Please confirm the deletion process.",
         "description": "Descrizione",
+        "disable_login": "Disabilita l'accesso (la posta in arrivo viene correttamente recapitata)",
         "domain": "Modifica dominio",
         "domain_admin": "Modifica amministratore dominio",
-        "domain_quota": "Spazio Dominio",
+        "domain_quota": "Spazio del dominio",
         "domains": "Dominio",
-        "dont_check_sender_acl": "Disattiva il controllo del mittente per il dominio %s + alias domains",
-        "edit_alias_domain": "Modifica Alias dominio",
-        "encryption": "Criptazione",
+        "dont_check_sender_acl": "Disattiva il controllo del mittente per il dominio %s + alias di dominio",
+        "edit_alias_domain": "Modifica alias di dominio",
+        "encryption": "Crittografia",
         "exclude": "Escludi oggetti (regex)",
+        "extended_sender_acl": "External sender addresses",
+        "extended_sender_acl_info": "A DKIM domain key should be imported, if available.<br>\r\n  Remember to add this server to the corresponding SPF TXT record.<br>\r\n  Whenever a domain or alias domain is added to this server, that overlaps with an external address, the external address is removed.<br>\r\n  Use @domain.tld to allow to send as *@domain.tld.",
+        "force_pw_update": "Force password update at next login",
+        "force_pw_update_info": "Questo utente potrà accedere solo a %s.",
         "full_name": "Nome completo",
-        "host": "Host",
+        "gal": "Global Address List",
+        "gal_info": "The GAL contains all objects of a domain and cannot be edited by any user. Free/busy information in SOGo is missing, if disabled! <b>Restart SOGo to apply changes.</b>",
+        "generate": "generate",
+        "grant_types": "Grant types",
         "hostname": "Hostname",
+        "inactive": "Inattivo",
         "kind": "Genere",
+        "lookup_mx": "Destination is a regular expression to match against MX name (<code>.*google\\.com</code> to route all mail targeted to a MX ending in google.com over this hop)",
         "mailbox": "Modifica casella di posta",
+        "mailbox_quota_def": "Default mailbox quota",
+        "mailbox_relayhost_info": "Applied to the mailbox and direct aliases only, does override a domain relayhost.",
         "max_aliases": "Numero massimo alias",
         "max_mailboxes": "Caselle di posta massime",
         "max_quota": "Massimo spazio per casella (MiB)",
-        "maxage": "Massima età dei messaggi che verranno scaricati dal server remoto<br /><small>(0 = ignorà età)</small>",
+        "maxage": "Massima età dei messaggi che verranno scaricati dal server remoto<br /><small>(0 = ignora età)</small>",
+        "maxbytespersecond": "Max. bytes per second <br><small>(0 = unlimited)</small>",
+        "mbox_rl_info": "This rate limit is applied on the SASL login name, it matches any \"from\" address used by the logged-in user. A mailbox rate limit overrides a domain-wide rate limit.",
         "mins_interval": "Intervallo (min)",
         "multiple_bookings": "Prenotazioni multiple",
+        "nexthop": "Next hop",
         "password": "Password",
-        "password_repeat": "Conferma password (riscrivila)",
+        "password_repeat": "Conferma password (riscrivi)",
         "previous": "Pagina precedente",
+        "private_comment": "Commento privato",
+        "public_comment": "Commento pubblico",
+        "pushover_evaluate_x_prio": "Escalate high priority mail [<code>X-Priority: 1</code>]",
+        "pushover_info": "Push notification settings will apply to all clean (non-spam) mail delivered to <b>%s</b> including aliases (shared, non-shared, tagged).",
+        "pushover_only_x_prio": "Only consider high priority mail [<code>X-Priority: 1</code>]",
+        "pushover_sender_array": "Only consider the following sender email addresses <small>(comma-separated)</small>",
+        "pushover_sender_regex": "Consider the following sender regex",
+        "pushover_text": "Notification text",
+        "pushover_title": "Notification title",
+        "pushover_vars": "When no sender filter is defined, all mails will be considered.<br>Regex filters as well as exact sender checks can be defined individually and will be considered sequentially. They do not depend on each other.<br>Useable variables for text and title (please take note of data protection policies)",
+        "pushover_verify": "Verify credentials",
         "quota_mb": "Spazio (MiB)",
+        "quota_warning_bcc": "Quota warning BCC",
+        "quota_warning_bcc_info": "Warnings will be sent as separate copies to the following recipients. The subject will be suffixed by the corresponding username in brackets, for example: <code>Quota warning (user@example.com)</code>.",
+        "ratelimit": "Rate limit",
+        "redirect_uri": "Redirect/Callback URL",								
         "relay_all": "Relay tutti i destinatari",
-        "relay_all_info": "<small>Se si sceglie di <b>non</b> inviare tutti i destinatari, è necessario aggiungere una cassetta postale (\"blind\") per ogni singolo destinatario a cui deve essere inoltrato.</small>",
+        "relay_all_info": "<small>Se si sceglie di <b>non</b> inviare a tutti i destinatari, è necessario aggiungere una casella di posta (\"blind\") per ogni singolo destinatario a cui deve essere inoltrato.</small>",
         "relay_domain": "Relay dominio",
+        "relay_transport_info": "<div class=\"label label-info\">Info</div> You can define transport maps for a custom destination for this domain. If not set, a MX lookup will be made.",
+        "relay_unknown_only": "Relay non-existing mailboxes only. Existing mailboxes will be delivered locally.",
+        "relayhost": "Sender-dependent transports",
         "remove": "Rimuovi",
         "resource": "Risorsa",
         "save": "Salva modifiche",
+        "scope": "Scope",
         "sender_acl": "Consenti di inviare come",
-        "source": "Sorgente",
-        "subfolder2": "Sincronizza in una sottocartella<br /><small>(vuoto = non sincronizzare in sottocartella)</small>",
+        "sender_acl_disabled": "<span class=\"label label-danger\">Sender check is disabled</span>",
+        "sender_acl_info": "If mailbox user A is allowed to send as mailbox user B, the sender address is not automatically displayed as selectable \"from\" field in SOGo.<br>\r\n  Mailbox user B needs to create a delegation in SOGo to allow mailbox user A to select their address as sender. To delegate a mailbox in SOGo, use the menu (three dots) to the right of your mailbox name in the upper left while in mail view. This behaviour does not apply to alias addresses.",
+        "sieve_desc": "Short description",
+        "sieve_type": "Filter type",
+        "skipcrossduplicates": "Skip duplicate messages across folders (first come, first serve)",
+        "sogo_access": "Grant access to SOGo",
+        "sogo_access_info": "Grant or permit access to SOGo. This setting does neither affect access to all other services nor does it delete or change a user's existing SOGo profile.",
+        "sogo_visible": "Alias is visible in SOGo",
+        "sogo_visible_info": "This option only affects objects, that can be displayed in SOGo (shared or non-shared alias addresses pointing to at least one local mailbox). If hidden, an alias will not appear as selectable sender in SOGo.",
+        "spam_alias": "Create or change time limited alias addresses",
+        "spam_filter": "Spam filter",
+        "spam_policy": "Add or remove items to white-/blacklist",
+        "spam_score": "Set a custom spam score",
+        "subfolder2": "Sincronizza in una sottocartella<br /><small>(vuoto = non sincronizzare in sottocartella)</small>",		
         "syncjob": "Modifica sincronizzazione",
-        "target_address": "Vai all'indirizzo/es <small>(comma-separated)</small>",
+        "target_address": "Vai all'indirizzo/i <small>(separato da virgola)</small>",
         "target_domain": "Target dominio",
+        "timeout1": "Timeout for connection to remote host",
+        "timeout2": "Timeout for connection to local host",
         "title": "Modifica oggetto",
         "unchanged_if_empty": "Se immutato lasciare vuoto",
-        "username": "Username"
+        "username": "Username",
+        "validate_save": "Convalida e salva",
+        "xmpp": "Activate XMPP for this domain",
+        "xmpp_access": "XMPP access",
+        "xmpp_access_info": "XMPP must be enabled for this domain.",
+        "xmpp_admin": "XMPP administrator",
+        "xmpp_admin_info": "<b>Danger:</b> Promotes a user to an XMPP administrator of this domain.",
+        "xmpp_example_jid": "<b>Example JID</b> (login with mailbox password)",
+        "xmpp_info": "This function will enable chat functionality for this domain.",
+        "xmpp_prefix": "XMPP prefix for domain (\"im\" to use <b>im</b>.example.org)",
+        "xmpp_prefix_info": "To request certificates for XMPP, two CNAME DNS records should point from <b>im</b>.example.org as well as <b>*.im</b>.example.org to <b>%s</b>. Please also run the DNS check for this domain after enabling XMPP."
+    },
+    "fido2": {
+        "confirm": "Confirm",
+        "fido2_auth": "Login with FIDO2",
+        "fido2_success": "Device successfully registered",
+        "fido2_validation_failed": "Validation failed",
+        "fn": "Friendly name",
+        "known_ids": "Known IDs",
+        "none": "Disabled",
+        "register_status": "Registration status",
+        "rename": "Rename",
+        "set_fido2": "Register FIDO2 device",
+        "set_fn": "Set friendly name",
+        "start_fido2_validation": "Start FIDO2 validation"
     },
     "footer": {
         "cancel": "Annulla",
         "confirm_delete": "Conferma eliminazione",
         "delete_now": "Elimina ora",
         "delete_these_items": "Sicuro di voler eliminare gli oggetti selezionati?",
-        "loading": "Attendere...",
+        "hibp_nok": "Matched! This is a potentially dangerous password!",
+        "hibp_ok": "Nessuna corrispondenza trovata.",
+        "loading": "Caricamento in corso...",
+        "restart_container": "Riavvia il container",
+        "restart_container_info": "<b>Importante:</b> Il completamento di un normale riavvio potrebbe richiedere diversi minuti, ti consigliamo di attendere.",
         "restart_now": "Riavvia adesso",
-        "restart_sogo": "Riavvia SOGo",
-        "restart_sogo_info": "Some tasks, e.g. adding a domain, require you to restart SOGo to catch changes made in the mailcow UI.<br /><br /><b>Important:</b> A graceful restart may take a while to complete, please wait for it to finish."
+        "restarting_container": "Riavvia il container, potrebbe richiedere diversi minuti"
     },
     "header": {
         "administration": "Amministrazione",
+        "apps": "App",
+        "debug": "Informazioni di sistema",
         "mailboxes": "Caselle",
         "mailcow_settings": "Configurazione",
+        "quarantine": "Quarantena",
+        "restart_netfilter": "Riavvia netfilter",
         "restart_sogo": "Riavvia SOGo",
         "user_settings": "Impostazioni utente"
     },
     "info": {
-        "no_action": "Azione non applicabile"
+        "awaiting_tfa_confirmation": "In attesa di conferma TFA",
+        "no_action": "Azione non applicabile",
+        "session_expires": "La tua sessione scadrà tra 15 secondi"
     },
     "login": {
         "delayed": "L'accesso è stato ritardato di %s secondi.",
+        "fido2_webauthn": "FIDO2/WebAuthn",
         "login": "Login",
+        "mobileconfig_info": "Please login as mailbox user to download the requested Apple connection profile.",
+        "other_logins": "Key login",
         "password": "Password",
         "username": "Username"
     },
@@ -207,111 +686,321 @@
         "active": "Attiva",
         "add": "Aggiungi",
         "add_alias": "Aggiungi alias",
-        "add_domain": "Aggiungi Dominio",
-        "add_domain_alias": "Aggiungi alias Dominio",
-        "add_domain_record_first": "Perfavore aggiungi il dominio prima",
+        "add_alias_expand": "Expand alias over alias domains",
+        "add_bcc_entry": "Add BCC map",
+        "add_domain": "Aggiungi Ddminio",
+        "add_domain_alias": "Aggiungi alias di dominio",
+        "add_domain_record_first": "Per favore aggiungi il dominio prima",
+        "add_filter": "Aggiungi filtro",
         "add_mailbox": "Aggiungi casella mail",
+        "add_recipient_map_entry": "Add recipient map",
         "add_resource": "Aggiungi risorsa",
+        "add_tls_policy_map": "Add TLS policy map",
+        "address_rewriting": "Address rewriting",
         "alias": "Alias",
-        "aliases": "Aliases",
+        "alias_domain_alias_hint": "Aliases are <b>not</b> applied on domain aliases automatically. An alias address <code>my-alias@domain</code> <b>does not</b> cover the address <code>my-alias@alias-domain</code> (where \"alias-domain\" is an imaginary alias domain for \"domain\").<br>Please use a sieve filter to redirect mail to an external mailbox (see tab \"Filters\" or use  SOGo -> Forwarder). Use \"Expand alias over alias domains\" to automatically add missing aliases.",
+        "alias_domain_backupmx": "Alias domain inactive for relay domain",
+        "aliases": "Alias",
+        "allow_from_smtp": "Consenti solo l'uso di questi IP per l'<b>SMTP</b>",
+        "allow_from_smtp_info": "Leave empty to allow all senders.<br>IPv4/IPv6 addresses and networks.",
+        "allowed_protocols": "Protocolli consentiti",
         "backup_mx": "Backup MX",
+        "bcc": "CCN",
+        "bcc_destination": "Destinatario CCN",
+        "bcc_destinations": "Destinatari CCN",
+        "bcc_info": "BCC maps are used to silently forward copies of all messages to another address. A recipient map type entry is used, when the local destination acts as recipient of a mail. Sender maps conform to the same principle.<br/>\r\n  The local destination will not be informed about a failed delivery.",
+        "bcc_local_dest": "Local destination",
+        "bcc_map": "BCC map",
+        "bcc_map_type": "BCC type",
+        "bcc_maps": "BCC maps",
+        "bcc_rcpt_map": "Recipient map",
+        "bcc_sender_map": "Sender map",
+        "bcc_to_rcpt": "Switch to recipient map type",
+        "bcc_to_sender": "Switch to sender map type",
+        "bcc_type": "BCC type",
+        "booking_0": "Always show as free",
+        "booking_0_short": "Always free",
+        "booking_custom": "Hard-limit to a custom amount of bookings",
+        "booking_custom_short": "Hard limit",
+        "booking_lt0": "Unlimited, but show as busy when booked",
+        "booking_lt0_short": "Soft limit",
+        "daily": "Giornaliero",
         "deactivate": "Disattiva",
         "description": "Descrizione",
+        "disable_login": "Disabilita l'accesso (la posta in arrivo viene correttamente recapitata)",
+        "disable_x": "Disabilita",
         "domain": "Dominio",
         "domain_admins": "Amministratori di dominio",
         "domain_aliases": "Alias di domini",
-        "domain_quota": "Quota",
+        "domain_quota": "Spazio",
         "domains": "Domini",
         "edit": "Modifica",
         "empty": "Nessun risultato",
+        "enable_x": "Abilita",
         "excludes": "Esclude",
-        "filter_table": "Filra tabella",
+        "filter_table": "Filtra tabella",
+        "filters": "Filtri",
         "fname": "Nome completo",
+        "hourly": "Orario",
         "in_use": "In uso (%)",
+        "inactive": "Inattivo",
+        "insert_preset": "Insert example preset \"%s\"",
         "kind": "Tipo",
+        "last_mail_login": "Last mail login",
+        "last_pw_change": "Ultima modifica della password",
         "last_run": "Ultima esecuzione",
+        "last_run_reset": "Schedule next",
+        "mailbox": "Casella di posta",
+        "mailbox_defaults": "Impostazioni predefinite",
+        "mailbox_defaults_info": "Definire le impostazioni predefinite per le nuove caselle di posta.",
+        "mailbox_defquota": "Dimensione predefinita della casella di posta",
         "mailbox_quota": "Massima dimensione della casella",
         "mailboxes": "Caselle",
         "mins_interval": "Intervallo (min)",
         "msg_num": "Messaggio #",
-        "multiple_bookings": "Multiple bookings",
-        "no_record": "Nessun record per l' oggetto %s",
+        "multiple_bookings": "Prenotazioni multiple",
+        "never": "Mai",
+        "no": "&#10005;",
+        "no_record": "Nessun record per l'oggetto %s",
         "no_record_single": "Nessun record",
+        "owner": "Proprietario",
+        "private_comment": "Commento privato",
+        "public_comment": "Commento pubblico",
+        "q_add_header": "quando spostato nella cartella Posta indesiderata",
+        "q_all": " when moved to Junk folder and on reject",
+        "q_reject": "on reject",
+        "quarantine_category": "Quarantine notification category",
+        "quarantine_notification": "Notifiche di quarantena",
         "quick_actions": "Azione veloce",
+        "recipient_map": "Recipient map",
+        "recipient_map_info": "Recipient maps are used to replace the destination address on a message before it is delivered.",
+        "recipient_map_new": "New recipient",
+        "recipient_map_new_info": "Recipient map destination must be a valid email address.",
+        "recipient_map_old": "Original recipient",
+        "recipient_map_old_info": "A recipient maps original destination must be valid email addresses or a domain name.",
+        "recipient_maps": "Recipient maps",
         "remove": "Rimuovi",
         "resources": "Risorse",
+        "running": "In esecuzione",
+        "set_postfilter": "Mark as postfilter",
+        "set_prefilter": "Mark as prefilter",
+        "sieve_info": "You can store multiple filters per user, but only one prefilter and one postfilter can be active at the same time.<br>\r\nEach filter will be processed in the described order. Neither a failed script nor an issued \"keep;\" will stop processing of further scripts. Changes to global sieve scripts will trigger a restart of Dovecot.<br><br>Global sieve prefilter &#8226; Prefilter &#8226; User scripts &#8226; Postfilter &#8226; Global sieve postfilter",
+        "sieve_preset_1": "Elimina messaggi con allegati probabilmente pericolosi",
+        "sieve_preset_2": "Contrassegna sempre i messaggi di un mittente specifico come già letti",
+        "sieve_preset_3": "Scarta senza avvisi, interrompendo l'elaborazione di altri filtri",
+        "sieve_preset_4": "File into INBOX, skip further processing by sieve filters",
+        "sieve_preset_5": "Risponditore automatico (vacanze)",
+        "sieve_preset_6": "Rifiuta posta con risposta",
+        "sieve_preset_7": "Inoltra e mantieni/elimina",
+        "sieve_preset_8": "Rifiuta il messaggio inviato ad un indirizzo alias di cui fa parte il mittente",
+        "sieve_preset_header": "Si prega di guardare i settaggi di esempio riportati qui sotto. Per maggiori dettagli, visita <a href=\"https://en.wikipedia.org/wiki/Sieve_(mail_filtering_language)\" target=\"_blank\">Wikipedia</a>.",
+        "sogo_visible": "Alias visibile in SOGo",
+        "sogo_visible_n": "Nascondi alias in SOGo",
+        "sogo_visible_y": "Mostra alias in SOGo",
         "spam_aliases": "Alias temporanei",
+        "stats": "Statistiche",
+        "status": "Stato",
         "sync_jobs": "Processi di sync",
-        "target_address": "Vai ad indirizzo",
-        "target_domain": "Target domain",
+        "table_size": "Dimensioni della tabella",
+        "table_size_show_n": "Mostra %s elementi",
+        "target_address": "Vai agli indirizzi",
+        "target_domain": "Dominio di destinazione",
         "tls_enforce_in": "Imponi TLS in ingresso",
         "tls_enforce_out": "Imponi TLS in uscita",
+        "tls_map_dest": "Destinazione",
+        "tls_map_dest_info": "Esempi: example.org, .example.org, [mail.example.org]:25",
+        "tls_map_parameters": "Parametri",
+        "tls_map_parameters_info": "Vuoto o parametri, ad esempio: protocols=!SSLv2 ciphers=medium exclude=3DES",
+        "tls_map_policy": "Policy",
+        "tls_policy_maps": "Mappa dei criteri TLS",
+        "tls_policy_maps_enforced_tls": "These policies will also override the behaviour for mailbox users that enforce outgoing TLS connections. If no policy exists below, these users will apply the default values specified as <code>smtp_tls_mandatory_protocols</code> and <code>smtp_tls_mandatory_ciphers</code>.",
+        "tls_policy_maps_info": "This policy map overrides outgoing TLS transport rules independently of a user's TLS policy settings.<br>\r\n  Please check <a href=\"http://www.postfix.org/postconf.5.html#smtp_tls_policy_maps\" target=\"_blank\">the \"smtp_tls_policy_maps\" docs</a> for further information.",
+        "tls_policy_maps_long": "Sovrascritture della mappa dei criteri TLS",
         "toggle_all": "Inverti tutti",
-        "username": "Nome utente"
+        "username": "Nome utente",
+        "waiting": "In attesa",
+        "weekly": "Settimanale",
+        "yes": "&#10003;"
+    },
+    "oauth2": {
+        "access_denied": "Effettua il login alla casella di posta per garantire l'accesso tramite OAuth2.",
+        "authorize_app": "Autorizza applicazione",
+        "deny": "Nega",
+        "permit": "Autorizza applicazione",
+        "profile": "Profilo",
+        "profile_desc": "Visualizza le informazioni personali: nome utente, nome e cognome, creazione, modifica, stato attivazione",
+        "scope_ask_permission": "Un'applicazione ha richiesto le seguenti autorizzazioni"
     },
     "quarantine": {
         "action": "Azione",
+        "atts": "Allegati",
+        "check_hash": "Search file hash @ VT",
+        "confirm": "Conferma",
+        "confirm_delete": "Conferma l'eliminazione di questo elemento.",
+        "danger": "Pericolo",
+        "deliver_inbox": "Consegna nella posta in arrivo",
+        "disabled_by_config": "The current system configuration disables the quarantine functionality. Please set \"retentions per mailbox\" and a \"maximum size\" for quarantine elements.",
+        "download_eml": "Download (.eml)",
         "empty": "Nessun risultato",
+        "high_danger": "Alto",
+        "info": "Informazione",
+        "junk_folder": "Cartella SPAM",
+        "learn_spam_delete": "Segnala come spam ed elimina",
+        "low_danger": "Basso",
+        "medium_danger": "Medio",
+        "neutral_danger": "Neutrale",
+        "notified": "Notificato",
+        "qhandler_success": "Richiesta inviata con successo al sistema. Ora puoi chiudere questa finestra.",
+        "qid": "Rspamd QID",
+        "qinfo": "The quarantine system will save rejected mail to the database (the sender will <em>not</em> be given the impression of a delivered mail) as well as mail, that is delivered as copy into the Junk folder of a mailbox.\r\n  <br>\"Learn as spam and delete\" will learn a message as spam via Bayesian theorem and also calculate fuzzy hashes to deny similar messages in the future.\r\n  <br>Please be aware that learning multiple messages can be - depending on your system - time consuming.<br>Blacklisted elements are excluded from the quarantine.",
+        "qitem": "Elemento in quarantena",
+        "quarantine": "Quarantena",
         "quick_actions": "Azione veloce",
+        "quick_delete_link": "Open quick delete link",
+        "quick_info_link": "Open info link",
+        "quick_release_link": "Open quick release link",
+        "rcpt": "Destinatario",
+        "received": "Ricevuto",
+        "recipients": "Destinatari",
+        "refresh": "Aggiorna",
+        "rejected": "Respinto",
+        "release": "Release",
+        "release_body": "Abbiamo allegato il tuo messaggio come file eml a questo messaggio.",
+        "release_subject": "Potentially damaging quarantine item %s",
         "remove": "Elimina",
-        "toggle_all": "Inverti tutti"
+        "rewrite_subject": "Riscrivi oggetto",
+        "rspamd_result": "Risultato Rspamd",
+        "sender": "Mittente (SMTP)",
+        "sender_header": "Mittente (\"From\" header)",
+        "settings_info": "Maximum amount of elements to be quarantined: %s<br>Maximum email size: %s MiB",
+        "show_item": "Mostra elemento",
+        "spam": "Spam",
+        "spam_score": "Punteggio",
+        "subj": "Oggetto",
+        "table_size": "Dimensioni della tabella",
+        "table_size_show_n": "Mostra %s elementi",
+        "text_from_html_content": "Contenuto (convertito in HTML)",
+        "text_plain_content": "Contenuto (text/plain)",
+        "toggle_all": "Inverti tutti",
+        "type": "Tipologia"
     },
     "start": {
         "help": "Mostra/Nascondi pannello di aiuto",
         "imap_smtp_server_auth_info": "Please use your full email address and the PLAIN authentication mechanism.<br />\r\nYour login data will be encrypted by the server-side mandatory encryption.",
         "mailcow_apps_detail": "Usa l'app mailcow per accedere alla posta, calendari, contatti ed altro.",
-        "mailcow_panel_detail": "<b>Amministratori di dominio</b> crea, modifica o cancella caselle e alias, cambia i domini e informazioni relative ai domini associati.<br />\r\n\t<b>Utenti di caselle</b> possono creare degli alias temporanei (spam aliases), cambiare la loro password e le impostazioni relative ai filtri spam."
+        "mailcow_panel_detail": "<b>Amministratori di dominio</b> crea, modifica od elimina caselle ed alias, cambia i domini e informazioni relative ai domini associati.<br />\r\n\t<b>Utenti di caselle</b> possono creare degli alias temporanei (spam aliases), cambiare la loro password e le impostazioni relative ai filtri spam."
     },
     "success": {
-        "admin_modified": "I cambiamenti a administrator è stato salvato",
-        "alias_added": "Alias address/es has/have been added",
+        "acl_saved": "ACL for object %s saved",
+        "admin_added": "L'amministratore %s è stato aggiunto",
+        "admin_api_modified": "Le modifiche alle API sono state salvate",
+        "admin_modified": "I cambiamenti all'amministratore sono stati salvati",
+        "admin_removed": "L'amministratore %s è stato rimosso",
+        "alias_added": "Uno o più alias sono stati correttamente aggiunti",
         "alias_domain_removed": "L'alias di dominio %s è stato rimosso",
-        "alias_modified": "I cambiamenti all'alias/es %s è stato salvato",
+        "alias_modified": "I cambiamenti all'alias %s sono stati salvati",
         "alias_removed": "L'alias %s è stato rimosso",
         "aliasd_added": "Aggiunto l'alias per il dominio %s",
-        "aliasd_modified": "I cambiamenti a alias domain %s è stato salvato",
+        "aliasd_modified": "I cambiamenti all'alias di dominio %s sono stati salvati",
+        "app_links": "Saved changes to app links",
+        "app_passwd_added": "Aggiunta nuova password per l'app",
+        "app_passwd_removed": "Password dell'app con ID %s rimossa",
+        "bcc_deleted": "BCC map entries deleted: %s",
+        "bcc_edited": "BCC map entry %s edited",
+        "bcc_saved": "BCC map entry saved",
+        "db_init_complete": "Inizializzazione del database completata",
+        "delete_filter": "Filtri eliminati - ID %s",
+        "delete_filters": "Filtri eliminati: %s",
+        "deleted_syncjob": "Eliminato syncjob - ID %s",
+        "deleted_syncjobs": "Eliminati syncjobs: %s",
         "dkim_added": "La chiave DKIM è stata salvata",
+        "dkim_duplicated": "La chiave DKIM per il dominio %s è stata copiata in %s",
         "dkim_removed": "La chiave DKIM è stata rimossa",
         "domain_added": "Aggiunto dominio %s",
         "domain_admin_added": "L'amministratore di dominio %s è stato aggiunto",
-        "domain_admin_modified": "I cambiamenti a domain administrator %s è stato salvato",
+        "domain_admin_modified": "I cambiamenti all'amministratore di dominio %s sono stati salvati",
         "domain_admin_removed": "L'amministratore di dominio %s è stato rimosso",
-        "domain_modified": "I cambiamenti a domain %s è stato salvato",
+        "domain_modified": "I cambiamenti al dominio %s sono stati salvati",
         "domain_removed": "Il dominio %s è stato aggiunto",
-        "eas_reset": "Dispositivi ActiveSync dell'utente %s resettati",
+        "dovecot_restart_success": "Dovecot è stato riavviato con successo",
+        "eas_reset": "I dispositivi ActiveSync dell'utente %s sono stati resettati",
+        "f2b_modified": "Le modifiche ai parametri Fail2ban sono state salvate",
         "forwarding_host_added": "Inoltro dell' host %s è stato aggiunto",
         "forwarding_host_removed": "Inoltro dell' host %s è stato rimosso",
+        "global_filter_written": "Il filtro è stato scritto con successo nel file",
+        "hash_deleted": "Hash eliminato",
+        "item_deleted": "Item %s successfully deleted",
+        "item_released": "Item %s released",
+        "items_deleted": "Item %s successfully deleted",
+        "items_released": "Selected items were released",
+        "learned_ham": "Successfully learned ID %s as ham",
+        "license_modified": "Le modifiche alla licenza sono state salvate",
+        "logged_in_as": "Collegato come %s",
         "mailbox_added": "La casella %s è stata aggiunta",
-        "mailbox_modified": "I cambiamenti alla mailbox %s è stato salvato",
+        "mailbox_modified": "Le modifiche alla casella di posta %s sono state salvate",
         "mailbox_removed": "La casella %s è stata rimossa",
-        "object_modified": "I cambiamenti all'oggetto %s è stato salvato",
+        "nginx_reloaded": "Nginx è stato ricaricato",
+        "object_modified": "Le modifiche all'oggetto %s sono state salvate",
+        "password_policy_saved": "Password policy was saved successfully",
+        "pushover_settings_edited": "Pushover settings successfully set, please verify credentials.",
+        "qlearn_spam": "Message ID %s was learned as spam and deleted",
+        "queue_command_success": "Queue command completed successfully",
+        "recipient_map_entry_deleted": "Recipient map ID %s has been deleted",
+        "recipient_map_entry_saved": "Recipient map entry \"%s\" has been saved",
+        "relayhost_added": "Map entry %s has been added",
+        "relayhost_removed": "Map entry %s has been removed",
+        "reset_main_logo": "Ripristina il logo predefinito",
         "resource_added": "La risorsa %s è stata aggiunta",
-        "resource_modified": "I cambiamenti alla mailbox %s è stato salvato",
-        "resource_removed": "La risorsa %s è stata rimossa"
+        "resource_modified": "Le modifiche alla casella di posta %s sono state salvate",
+        "resource_removed": "La risorsa %s è stata rimossa",
+        "rl_saved": "Rate limit for object %s saved",
+        "rspamd_ui_pw_set": "Password dell'interfaccia utente di Rspamd UI impostata con successo",
+        "saved_settings": "Impostazioni salvate",
+        "settings_map_added": "Added settings map entry",
+        "settings_map_removed": "Removed settings map ID %s",
+        "sogo_profile_reset": "Il profilo SOGo dell'utente %s è stato resettato",
+        "tls_policy_map_entry_deleted": "TLS policy map ID %s has been deleted",
+        "tls_policy_map_entry_saved": "TLS policy map entry \"%s\" has been saved",
+        "ui_texts": "Saved changes to UI texts",
+        "upload_success": "File caricato con successo",
+        "verified_fido2_login": "Verified FIDO2 login",
+        "verified_totp_login": "Verified TOTP login",
+        "verified_u2f_login": "Verified U2F login",
+        "verified_yotp_login": "Verified Yubico OTP login",
+        "xmpp_maps_updated": "XMPP maps were updated",
+        "xmpp_reloaded": "Il servizio XMPP è stato ricaricato",
+        "xmpp_restarted": "Il servizio XMPP è stato riavviato"
     },
     "tfa": {
-        "api_register": "%s usa le Api Yubico Cloud. Richiedi una Chiave API <a href=\"https://upgrade.yubico.com/getapikey/\" target=\"_blank\">qui</a>",
+        "api_register": "%s usa le API Yubico Cloud. Richiedi una chiave API <a href=\"https://upgrade.yubico.com/getapikey/\" target=\"_blank\">qui</a>",
         "confirm": "Conferma",
         "confirm_totp_token": "Conferma le modifiche inserendo il token generato",
         "delete_tfa": "Disabilita TFA",
         "disable_tfa": "Disabilita TFA fino al prossimo accesso",
         "enter_qr_code": "Il codice TOTP se il tuo dispositivo non è in grado di acquisire i codici QR",
+        "error_code": "Codice di errore",
+        "init_u2f": "Inizializzazione, attendere prego...",
         "key_id": "Identificatore per il tuo YubiKey",
         "key_id_totp": "Identificatore per la tua chiave",
-        "none": "Disattiva",
+        "none": "Disattivato",
+        "reload_retry": "- (ricaricare la pagina se l'errore persiste)",
         "scan_qr_code": "Esegui la scansione del seguente codice con l'applicazione di autenticazione o inserisci manualmente il codice.",
         "select": "Seleziona",
         "set_tfa": "Imposta il metodo di autenticazione a due fattori",
+        "start_u2f_validation": "Avvia convalida",
+        "set_tfa": "Imposta il metodo di autenticazione a due fattori",
         "tfa": "Autenticazione a due fattori",
         "totp": "Time-based OTP (Google Authenticator etc.)",
         "u2f": "Autenticazione U2F",
-        "waiting_usb_auth": "<i>Attendo il device USB...</i><br /><br />Tocca ora il pulsante sul dispositivo U2F USB.",
-        "waiting_usb_register": "<i>Attendo il device USB...</i><br /><br />Inserisci la tua password sopra e conferma la tua registrazione U2F toccando il pulsante del dispositivo U2F USB.",
+        "waiting_usb_auth": "<i>In attesa del device USB...</i><br /><br />Tocca ora il pulsante sul dispositivo U2F USB.",
+        "waiting_usb_register": "<i>In attesa del device USB...</i><br /><br />Inserisci la tua password qui sopra e conferma la tua registrazione U2F toccando il pulsante del dispositivo U2F USB.",
         "yubi_otp": "Autenticazione Yubico OTP"
     },
     "user": {
         "action": "Azione",
         "active": "Attiva",
+        "active_sieve": "Filtro attivo",
+        "advanced_settings": "Impostazioni avanzate",
         "alias": "Alias",
         "alias_create_random": "Genera un alias generico",
         "alias_extend_all": "Estendi la durata di 1 ora agli alias",
@@ -322,36 +1011,101 @@
         "alias_valid_until": "Valido fino a",
         "aliases_also_send_as": "Può inviare come utente",
         "aliases_send_as_all": "Do not check sender access for the following domain(s) and its alias domains",
+        "app_hint": "App passwords are alternative passwords for your <b>IMAP and SMTP</b> login. The username remains unchanged.<br>SOGo (including ActiveSync) is not available through app passwords.",
+        "app_name": "App name",
+        "app_passwds": "App passwords",
+        "apple_connection_profile": "Profilo di connessione Apple",
+        "apple_connection_profile_complete": "This connection profile includes IMAP and SMTP parameters as well as CalDAV (calendars) and CardDAV (contacts) paths for an Apple device.",
+        "apple_connection_profile_mailonly": "This connection profile includes IMAP and SMTP configuration parameters for an Apple device.",
         "change_password": "Cambia password",
+        "clear_recent_successful_connections": "Clear seen successful connections",
+        "client_configuration": "Show configuration guides for email clients and smartphones",
+        "create_app_passwd": "Create app password",
         "create_syncjob": "Crea un azione di sync",
-        "day": "Giorno",
+        "created_on": "Creato il",
+        "daily": "Giornaliero",
+        "day": "giorno",
+        "delete_ays": "Please confirm the deletion process.",
+        "direct_aliases": "Direct alias addresses",
+        "direct_aliases_desc": "Direct alias addresses are affected by spam filter and TLS policy settings.",
         "eas_reset": "Ripristina la cache dei dispositivi ActiveSync",
         "eas_reset_help": "In molti casi un ripristino risolve i problemi di sincronizzazione dei dispositivi.<br /><b>Attenzione:</b> Tutti gli elementi verranno scaricati nuovamente!",
         "eas_reset_now": "Ripristina ora",
         "edit": "Modifica",
+        "email": "E-mail",
+        "email_and_dav": "E-mail, calendari e contatti",
+        "empty": "Nessun risultato",
         "encryption": "Crittografia",
         "excludes": "Esclude",
-        "hour": "Ora",
-        "hours": "Ore",
+        "expire_in": "Scade in",
+        "fido2_webauthn": "FIDO2/WebAuthn",
+        "force_pw_update": "<b>Devi</b> impostare una nuova password per poter accedere ai servizi relativi al groupware.",
+        "from": "Da",
+        "generate": "generato",
+        "hour": "ora",
+        "hourly": "orario",
+        "hours": "ore",
         "in_use": "Utilizzati",
         "interval": "Intervallo",
         "is_catch_all": "Catch-all per il dominio/i",
-        "last_run": "Ultima esecuzione",
+        "last_mail_login": "Ultimo accesso alla casella di posta",
+        "last_pw_change": "Ultima modifica della password",
+		"last_run": "Ultima esecuzione",
+        "last_ui_login": "Ultimo login all'interfaccia utente",
+        "loading": "Caricamento in corso...",
+        "login_history": "Cronologia accessi",
+        "mailbox": "Casella di posta",
         "mailbox_details": "Dettagli casella",
+        "mailbox_general": "Generale",
+        "mailbox_settings": "Impostazioni",
         "messages": "messaggi",
+        "month": "mese",
+        "months": "mesi",
+        "never": "Mai",
         "new_password": "Nuova password",
-        "new_password_description": "Requisiti: Lunghezza di 6 caratteri, lettere e numeri.",
-        "new_password_repeat": "Conferma password (ripeti)",
+        "new_password_repeat": "Conferma password (riscrivi)",
+        "no_active_filter": "No active filter available",
+        "no_last_login": "No last UI login information",
         "no_record": "Nessun elemento",
+        "open_webmail_sso": "Accedi alla webmail",
+        "password": "Password",
         "password_now": "Password attuale (conferma modifiche)",
+        "password_repeat": "Conferma password (riscrivi)",
+        "pushover_evaluate_x_prio": "Escalate high priority mail [<code>X-Priority: 1</code>]",
+        "pushover_info": "Push notification settings will apply to all clean (non-spam) mail delivered to <b>%s</b> including aliases (shared, non-shared, tagged).",
+        "pushover_only_x_prio": "Considera solo la posta ad alta priorità [<code>X-Priority: 1</code>]",
+        "pushover_sender_array": "Consider the following sender email addresses <small>(comma-separated)</small>",
+        "pushover_sender_regex": "Match senders by the following regex",
+        "pushover_text": "Testo di notifica",
+        "pushover_title": "Titolo della notifica",
+        "pushover_vars": "When no sender filter is defined, all mails will be considered.<br>Regex filters as well as exact sender checks can be defined individually and will be considered sequentially. They do not depend on each other.<br>Useable variables for text and title (please take note of data protection policies)",
+        "pushover_verify": "Verifica le credenziali",
+        "q_add_header": "Cartella SPAM",
+        "q_all": "Tutte le categorie",
+        "q_reject": "Respinto",
+        "quarantine_category": "Quarantine notification category",
+        "quarantine_category_info": "La categoria di notifica \"Rifiutata\" include la posta che è stata rifiutata, mentre \"Posta indesiderata\" avviserà l'utente dei messaggi che sono stati spostati nella cartella omonima.",
+        "quarantine_notification": "Notifiche di quarantena",
+        "quarantine_notification_info": "Una volta inviata la notifica, gli elementi saranno contrassegnati come \"notificati\" e non verranno inviate ulteriori notifiche per questo particolare elemento.",
+        "recent_successful_connections": "Seen successful connections",
         "remove": "Elimina",
+        "running": "In esecuzione",
+        "save": "Salva modifiche",
         "save_changes": "Salva modifiche",
+        "sender_acl_disabled": "<span class=\"label label-danger\">Sender check is disabled</span>",
+        "shared_aliases": "Indirizzi alias condivisi",
+        "shared_aliases_desc": "Shared aliases are not affected by user specific settings such as the spam filter or encryption policy. Corresponding spam filters can only be made by an administrator as a domain-wide policy.",
+        "show_sieve_filters": "Show active user sieve filter",
+        "sogo_profile_reset": "Ripristina il profilo SOGo",
+        "sogo_profile_reset_help": "Questo distruggerà il profilo SOGo dell'utente ed <b>eliminerà tutti i contatti e i dati del calendario definitivamente</b>.",
+        "sogo_profile_reset_now": "Ripristina il profilo ora",
         "spam_aliases": "Indirizzi mail temporanei",
+        "spam_score_reset": "Reset to server default",
         "spamfilter": "Filtri spam",
         "spamfilter_behavior": "Punteggio",
         "spamfilter_bl": "Blacklist",
         "spamfilter_bl_desc": "Email inserita nella blacklisted per <b>essere sempre</b> riconosciuta come spam e rifiutata. Si possono usare le wildcards.",
-        "spamfilter_default_score": "Valori di default:",
+        "spamfilter_default_score": "Valori di default",
         "spamfilter_green": "Verde: Questo messaggio non è spam",
         "spamfilter_hint": "Il primo valore rappresenta un \"basso punteggio di spam\", il secondo rappresenta un \"alto punteggio di spam\".",
         "spamfilter_red": "Rosso: uesto messaggio è spam e verrà rifiutato dal server",
@@ -362,22 +1116,43 @@
         "spamfilter_table_remove": "rimuovi",
         "spamfilter_table_rule": "Regola",
         "spamfilter_wl": "Whitelist",
-        "spamfilter_wl_desc": "Email inserita nella whitelist per <b>non essere mai</b> riconosciuta come spam. Si possono usare le wildcards.",
+        "spamfilter_wl_desc": "Email inserita nella whitelist per <b>non essere mai</b> riconosciuta come spam. Si possono usare le wildcards. Un filtro viene applicato solo agli alias diretti (alias con una singola casella postale di destinazione) esclusi gli alias catch-all e la casella postale stessa.",
         "spamfilter_yellow": "Giallo: Questo messaggio può essere spam, verrà segnalato come spam e spostato nella cartella spazzatura",
+        "status": "Stato",
         "sync_jobs": "Processi di sync",
         "tag_handling": "Imposta le gestione della mail evidenziate",
         "tag_help_example": "Esempio di mail con tag: ich<b>+Facebook</b>@example.org",
-        "tag_help_explain": "In sotto cartelle: Una nuova cartella dal nome del tag verrà creata sotto INBOX (\"INBOX/Facebook\").<br />\r\nNell'oggetto: Il nome del tag verrà aggiunto all'inizio dell'oggetto mail, esempio: \"[Facebook] Meine Neuigkeiten\".",
+        "tag_help_explain": "In sottocartelle: Una nuova cartella con il nome del tag verrà creata sotto INBOX (\"INBOX/Facebook\").<br />\r\nNell'oggetto: Il nome del tag verrà aggiunto all'inizio dell'oggetto della mail, esempio: \"[Facebook] Le mie notizie\".",
         "tag_in_none": "Fare niente",
-        "tag_in_subfolder": "Nella sotto cartella",
+        "tag_in_subfolder": "Nella sottocartella",
         "tag_in_subject": "Nell'oggetto",
+        "text": "Testo",
+        "title": "Titolo",
         "tls_enforce_in": "Imponi TLS in ingresso",
         "tls_enforce_out": "Imponi TLS in uscita",
         "tls_policy": "Politica di crittografia",
         "tls_policy_warning": "<strong>Attenzione:</strong> If you decide to enforce encrypted mail transfer, you may lose emails.<br />Messages to not satisfy the policy will be bounced with a hard fail by the mail system.<br />This option applies to your primary email address (login name), all addresses derived from alias domains as well as alias addresses <b>with only this single mailbox</b> as target.",
         "user_settings": "Impostazioni utente",
         "username": "Nome utente",
-        "week": "Settimana",
-        "weeks": "Settimane"
+        "verify": "Verifica",
+        "waiting": "In attesa",
+        "week": "settimana",
+        "weekly": "Settimanale",
+        "weeks": "settimane",
+        "year": "anno",
+        "years": "anni"
+    },
+    "warning": {
+        "cannot_delete_self": "Cannot delete logged in user",
+        "domain_added_sogo_failed": "Il dominio è stato aggiunto ma non è stato possibile riavviare SOGo, controlla i log del tuo server.",
+        "dovecot_restart_failed": "Non è stato possibile riavviare Dovecot, controlla i log del tuo server.",
+        "fuzzy_learn_error": "Fuzzy hash learn error: %s",
+        "hash_not_found": "Hash not found or already deleted",
+        "ip_invalid": "Skipped invalid IP: %s",
+        "is_not_primary_alias": "Skipped non-primary alias %s",
+        "no_active_admin": "Cannot deactivate last active admin",
+        "quota_exceeded_scope": "Domain quota exceeded: Only unlimited mailboxes can be created in this domain scope.",
+        "session_token": "Form token invalid: Token mismatch",
+        "session_ua": "Form token invalid: User-Agent validation error"
     }
-}
\ No newline at end of file
+}
diff --git a/mailcow/src/mailcow-dockerized/data/web/lang/lang.ko.json b/mailcow/src/mailcow-dockerized/data/web/lang/lang.ko.json
index 59be683..cdd34b1 100644
--- a/mailcow/src/mailcow-dockerized/data/web/lang/lang.ko.json
+++ b/mailcow/src/mailcow-dockerized/data/web/lang/lang.ko.json
@@ -438,12 +438,12 @@
         "logs": "Logs",
         "restart_container": "Restart",
         "solr_dead": "Solr is starting, disabled or died.",
-        "solr_docs": "Docs",
-        "solr_last_modified": "Last modified",
-        "solr_size": "Size",
-        "solr_started_at": "Started at",
+        "docs": "Docs",
+        "last_modified": "Last modified",
+        "size": "Size",
+        "started_at": "Started at",
         "solr_status": "Solr status",
-        "solr_uptime": "Uptime",
+        "uptime": "Uptime",
         "started_on": "Started on",
         "static_logs": "Static logs",
         "system_containers": "System & Containers"
@@ -534,7 +534,7 @@
         "save": "Save changes",
         "scope": "Scope",
         "sender_acl": "Allow to send as",
-        "sender_acl_disabled": "↳ <span class=\"label label-danger\">Sender check is disabled</span>",
+        "sender_acl_disabled": "<span class=\"label label-danger\">Sender check is disabled</span>",
         "sender_acl_info": "If mailbox user A is allowed to send as mailbox user B, the sender address is not automatically displayed as selectable \"from\" field in SOGo.<br>\r\n  Mailbox user B needs to create a delegation in SOGo to allow mailbox user A to select their address as sender. To delegate a mailbox in SOGo, use the menu (three dots) to the right of your mailbox name in the upper left while in mail view. This behaviour does not apply to alias addresses.",
         "sieve_desc": "Short description",
         "sieve_type": "Filter type",
@@ -696,7 +696,6 @@
         "sieve_preset_7": "Redirect and keep/drop",
         "sieve_preset_8": "Discard message sent to an alias address the sender is part of",
         "sieve_preset_header": "Please see the example presets below. For more details see <a href=\"https://en.wikipedia.org/wiki/Sieve_(mail_filtering_language)\" target=\"_blank\">Wikipedia</a>.",
-        "sogo_allow_admin_hint": "Administrative SOGo logins are only available for mailboxes with an existing SOGo profile. A user must have been logged in to SOGo at least once.",
         "sogo_visible": "Alias is visible in SOGo",
         "sogo_visible_n": "Hide alias in SOGo",
         "sogo_visible_y": "Show alias in SOGo",
diff --git a/mailcow/src/mailcow-dockerized/data/web/lang/lang.lv.json b/mailcow/src/mailcow-dockerized/data/web/lang/lang.lv.json
index 57b6951..c73a185 100644
--- a/mailcow/src/mailcow-dockerized/data/web/lang/lang.lv.json
+++ b/mailcow/src/mailcow-dockerized/data/web/lang/lang.lv.json
@@ -542,4 +542,4 @@
         "week": "Nedēļa",
         "weeks": "Nedēļas"
     }
-}
\ No newline at end of file
+}
diff --git a/mailcow/src/mailcow-dockerized/data/web/lang/lang.nl.json b/mailcow/src/mailcow-dockerized/data/web/lang/lang.nl.json
index 053e109..03c55e9 100644
--- a/mailcow/src/mailcow-dockerized/data/web/lang/lang.nl.json
+++ b/mailcow/src/mailcow-dockerized/data/web/lang/lang.nl.json
@@ -26,7 +26,11 @@
         "syncjobs": "Sync jobs",
         "tls_policy": "Versleutelingsbeleid",
         "unlimited_quota": "Onbeperkte quota voor mailboxen",
-        "domain_desc": "Wijzig domeinbeschrijving"
+        "domain_desc": "Wijzig domeinbeschrijving",
+        "xmpp_admin": "Promoveer XMPP-gebruiker tot administrator",
+        "xmpp_domain_access": "Configureer XMPP-domeintoegang",
+        "xmpp_mailbox_access": "Configureer XMPP-gebruikerstoegang",
+        "xmpp_prefix": "Wijzig XMPP subdomein (prefix)"
     },
     "add": {
         "activate_filter_warn": "Alle andere filters worden gedeactiveerd zolang deze geactiveerd is.",
@@ -59,6 +63,12 @@
         "full_name": "Volledige naam",
         "gal": "Globale adreslijst",
         "gal_info": "De globale adreslijst bevat alle objecten van een domein. Deze kunnen door geen enkele gebruiker worden bewerkt. <b>Herstart SOGo om wijzigingen door te voeren.</b>",
+        "xmpp": "Activeer XMPP voor dit domein",
+        "xmpp_info": "Deze optie activeert de chatfunctionaliteit voor dit domein.",
+        "xmpp_access": "XMPP-toegang",
+        "xmpp_access_info": "XMPP dient ingeschakeld te zijn voor dit domein.",
+        "xmpp_admin": "XMPP-administrator",
+        "xmpp_admin_info": "<b>Waarschuwing:</b> Promoveert een gebruiker tot XMPP-administrator van dit domein.",
         "generate": "genereer",
         "goto_ham": "Train als <span class=\"text-success\"><b>ham</b></span>",
         "goto_null": "Verwijder mail onmiddelijk",
@@ -351,6 +361,7 @@
         "global_filter_write_error": "Filter kon niet opgeslagen worden: %s",
         "global_map_invalid": "Globaal filter %s is ongeldig",
         "global_map_write_error": "Globaal filter %s kon niet opgeslagen worden: %s",
+        "xmpp_map_write_error": "XMPP-map kon niet opgeslagen worden: %s",
         "goto_empty": "Een aliasadres dient ten minste één doeladres te hebben",
         "goto_invalid": "Doeladres %s is ongeldig",
         "ham_learn_error": "Ham training-error: %s",
@@ -385,6 +396,7 @@
         "max_quota_in_use": "Mailboxquota dient gelijk te zijn aan, of groter te zijn dan %d MiB",
         "maxquota_empty": "Maximale mailboxquota dient groter dan 0 te zijn.",
         "mysql_error": "MySQL-error: %s",
+        "nginx_reload_failed": "Nginx reload mislukt: %s",
         "network_host_invalid": "Ongeldig netwerk of host: %s",
         "next_hop_interferes": "%s interfereert met nexthop %s",
         "next_hop_interferes_any": "Een bestaande nexthop interfereert met %s",
@@ -435,7 +447,9 @@
         "username_invalid": "Gebruikersnaam %s kan niet worden gebruikt",
         "validity_missing": "Wijs een geldigheidstermijn toe",
         "value_missing": "Niet alle waarden zijn ingevuld",
-        "yotp_verification_failed": "Yubico OTP-verificatie mislukt: %s"
+        "yotp_verification_failed": "Yubico OTP-verificatie mislukt: %s",
+        "xmpp_restart_failed": "XMPP herstart mislukt",
+        "xmpp_reload_failed": "XMPP reload mislukt"
     },
     "debug": {
         "chart_this_server": "Grafiek (deze server)",
@@ -449,20 +463,24 @@
         "logs": "Logs",
         "restart_container": "Herstart",
         "solr_dead": "Solr is uitgeschakeld, uitgevallen of nog bezig met opstarten.",
-        "solr_docs": "Documenten",
-        "solr_last_modified": "Voor het laatst bijgewerkt op",
-        "solr_size": "Grootte",
-        "solr_started_at": "Opgestart op",
-        "solr_status": "Status van Solr",
-        "solr_uptime": "Uptime",
+        "xmpp_dead": "XMPP is uitgeschakeld, uitgevallen of nog bezig met opstarten.",
+        "docs": "Documenten",
+        "last_modified": "Voor het laatst bijgewerkt op",
+        "online_users": "Gebruikers online",
+        "size": "Grootte",
+        "started_at": "Opgestart op",
+        "solr_status": "Solr-status",
+        "uptime": "Uptime",
         "started_on": "Gestart op",
         "static_logs": "Statische logs",
-        "system_containers": "Systeem & containers"
+        "system_containers": "Systeem & containers",
+        "xmpp_status": "XMPP-status"
     },
     "diagnostics": {
         "cname_from_a": "Waarde afgeleid van een A- of AAAA-vermelding.",
         "dns_records": "DNS-configuratie",
         "dns_records_24hours": "Houd er rekening mee dat wijzigingen aan DNS tot wel 24 uur in beslag kunnen nemen voordat ze op deze pagina worden weergegeven. Deze informatie is bedoeld om gemakkelijk te bekijken of de DNS-configuratie aan de eisen voldoet.",
+        "dns_records_docs": "Raadpleeg ook <a target=\"_blank\" href=\"https://mailcow.github.io/mailcow-dockerized-docs/prerequisite-dns/\">de documentatie</a>.",
         "dns_records_data": "Correcte gegevens",
         "dns_records_name": "Naam",
         "dns_records_status": "Huidige staat",
@@ -505,6 +523,17 @@
         "full_name": "Volledige naam",
         "gal": "Globale adreslijst",
         "gal_info": "De globale adreslijst bevat alle objecten van een domein. Deze kunnen door geen enkele gebruiker worden bewerkt. <b>Herstart SOGo om wijzigingen door te voeren.</b>",
+
+        "xmpp": "Activeer XMPP voor dit domein",
+        "xmpp_prefix": "XMPP-prefix (\"im\" om <b>im</b>.example.org te gebruiken)",
+        "xmpp_prefix_info": "Om certificaten voor XMPP aan te vragen, dienen twee CNAME records te verwijzen van <b>im</b>.example.org en <b>*.im</b>.example.org naar <b>%s</b>. Controleer na het inschakelen van XMPP de DNS-configuratie in het Domeinen-overzicht.",
+        "xmpp_info": "Deze optie activeert de chatfunctionaliteit voor dit domein.",
+        "xmpp_access": "XMPP-toegang",
+        "xmpp_access_info": "XMPP dient ingeschakeld te zijn voor dit domein.",
+        "xmpp_admin": "XMPP-administrator",
+        "xmpp_admin_info": "<b>Waarschuwing:</b> Promoveert een gebruiker tot XMPP-administrator van dit domein.",
+        "xmpp_example_jid": "<b>Voorbeeld JID</b> (log in met mailboxwachtwoord)",
+
         "generate": "genereer",
         "grant_types": "Grant types",
         "hostname": "Hostname",
@@ -536,6 +565,7 @@
         "pushover_vars": "Wanneer er geen afzenders zijn uitgesloten zullen alle mails doorkomen.<br>Regex-filters en afzendercontroles kunnen individueel worden ingesteld en zullen in volgorde worden verwerkt. Ze zijn niet afhankelijk van elkaar.<br>Bruikbare variabelen voor tekst en titel (neem het gegevensbeschermingsbeleid in acht)",
         "pushover_verify": "Verifieer aanmeldingsgegevens",
         "quota_mb": "Quota (MiB)",
+        "ratelimit": "Ratelimit",
         "redirect_uri": "Redirect/Callback URL",
         "relay_all": "Forward alle ontvangers",
         "relay_all_info": "↪ Wanneer er wordt gekozen om <b>niet</b> alle ontvangers te forwarden, dient er per ontvanger een lege mailbox aangemaakt te worden.",
@@ -548,7 +578,7 @@
         "save": "Wijzigingen opslaan",
         "scope": "Scope",
         "sender_acl": "Sta toe om te verzenden als",
-        "sender_acl_disabled": "↳ <span class=\"label label-danger\">Verzendcontrole is uitgeschakeld</span>",
+        "sender_acl_disabled": "<span class=\"label label-danger\">Verzendcontrole is uitgeschakeld</span>",
         "sender_acl_info": "Wanneer mailboxgebruiker A toegestaan is te verzenden namens mailboxgebruiker B, zal het verzendadres niet automatisch worden weergegeven in het \"van\"-veld in SOGo. Mailboxgebruiker A dient hiervoor een aparte vermelding te maken in SOGo. Om een mailbox te delegeren in SOGo kan het menu (drie punten) aan de rechterkant van de naam van het mailbox linksboven worden gebruikt in de mailweergave. Dit is niet van toepassing op aliasadressen.",
         "sieve_desc": "Korte beschrijving",
         "sieve_type": "Filtertype",
@@ -558,6 +588,7 @@
         "sogo_visible": "Alias tonen in SOGo",
         "sogo_visible_info": "Wanneer verborgen zal een alias niet worden weergegeven als een selecteerbaar verzendadres. Deze optie beïnvloedt uitsluitend objecten die kunnen worden weergegeven in SOGo (gedeelde of niet-gedeelde aliasadressen die naar minstens één mailbox verwijzen).",
         "spam_alias": "Maak een nieuw tijdelijk alias aan, of pas deze aan",
+        "spam_filter": "Spamfilter",
         "spam_policy": "Voeg items toe of verwijder items van de white- of blacklist",
         "spam_score": "Stel een aangepaste spamscore in",
         "subfolder2": "Synchroniseer in submap op bestemming<br><small>(leeg = gebruik geen submappen)</small>",
@@ -720,7 +751,6 @@
         "sieve_preset_7": "Forward en behoud/verwijder",
         "sieve_preset_8": "Verwijder mail verstuurd naar een aliasadres van de afzender",
         "sieve_preset_header": "Zie de onderstaande voorbeelden. Raadpleeg <a href=\"https://en.wikipedia.org/wiki/Sieve_(mail_filtering_language)\" target=\"_blank\">Wikipedia</a> voor meer informatie.",
-        "sogo_allow_admin_hint": "Administratieve SOGo-logins zijn uitsluitend beschikbaar voor mailboxen met een bestaand SOGo-profiel. Een gebruiker moet zich ten minste één keer aanmelden bij SOGo.",
         "sogo_visible": "Alias tonen in SOGo",
         "sogo_visible_n": "Verberg alias in SOGo",
         "sogo_visible_y": "Toon alias in SOGo",
@@ -766,6 +796,7 @@
         "danger": "Risico",
         "deliver_inbox": "Vrijgeven naar inbox",
         "disabled_by_config": "De huidige systeemconfiguratie deactiveert de quarantainefunctionaliteit. Het instellen van \"Maximale retenties per mailbox\" en \"Maximale grootte\" is vereist om deze functie te activeren.",
+        "settings_info": "Maximaal aantal items in quarantaine: %s<br>Maximale mailgrootte: %s MiB",
         "download_eml": "Download (.eml)",
         "empty": "Geen resultaten",
         "high_danger": "Hoog",
@@ -864,6 +895,7 @@
         "mailbox_added": "Mailbox %s is toegevoegd",
         "mailbox_modified": "Wijzigingen aan mailbox %s zijn opgeslagen",
         "mailbox_removed": "Mailbox %s is verwijderd",
+        "nginx_reloaded": "Nginx is herladen",
         "object_modified": "Wijzigingen aan object %s zijn opgeslagen",
         "pushover_settings_edited": "Pushover-instellingen zijn opgeslagen, verifieer nu de aanmeldingsgegevens.",
         "qlearn_spam": "Bericht %s is als spam gemarkeerd en verwijderd",
@@ -889,7 +921,10 @@
         "verified_totp_login": "TOTP succesvol geverifieerd",
         "verified_u2f_login": "U2F succesvol geverifieerd",
         "verified_fido2_login": "FIDO2 succesvol geverifieerd",
-        "verified_yotp_login": "Yubico OTP succesvol geverifieerd"
+        "verified_yotp_login": "Yubico OTP succesvol geverifieerd",
+        "xmpp_restarted": "XMPP-service is hestart",
+        "xmpp_reloaded": "XMPP-service is herladen",
+        "xmpp_maps_updated": "XMPP-maps zijn bijgewerkt"
     },
     "tfa": {
         "api_register": "%s maakt gebruik van de Yubico Cloud API. Om dit te benutten is er een API-key van Yubico vereist, deze kan <a href=\"https://upgrade.yubico.com/getapikey/\" target=\"_blank\">hier</a> opgevraagd worden",
@@ -1012,7 +1047,7 @@
         "running": "Wordt uitgevoerd",
         "save": "Sla wijzigingen op",
         "save_changes": "Wijzigingen opslaan",
-        "sender_acl_disabled": "↳ <span class=\"label label-danger\">Verzendcontrole is uitgeschakeld</span>",
+        "sender_acl_disabled": "<span class=\"label label-danger\">Verzendcontrole is uitgeschakeld</span>",
         "shared_aliases": "Gedeelde aliasadressen",
         "shared_aliases_desc": "Een gedeeld aliasadres wordt niet beïnvloed door gebruikersspecifieke instellingen. Een aangepast spamfilter kan eventueel worden ingesteld door een administrator.",
         "show_sieve_filters": "Toon actieve filters",
@@ -1063,7 +1098,7 @@
     "warning": {
         "cannot_delete_self": "Gebruikers kunnen niet worden verwijderd wanneer deze zijn aangemeld",
         "domain_added_sogo_failed": "Domein is toegevoegd, maar de hestart van SOGo mislukte. Controleer de logs.",
-        "dovecot_restart_failed": "De herstart van Dovecot mislukte. Controleer de logs.",
+        "dovecot_restart_failed": "Herstart van Dovecot mislukte. Controleer de logs.",
         "fuzzy_learn_error": "Fuzzy-hash training-error: %s",
         "hash_not_found": "Hash niet gevonden of reeds verwijderd",
         "ip_invalid": "Ongeldig IP-adres overgeslagen: %s",
diff --git a/mailcow/src/mailcow-dockerized/data/web/lang/lang.pl.json b/mailcow/src/mailcow-dockerized/data/web/lang/lang.pl.json
index 1af3d98..6c897a8 100644
--- a/mailcow/src/mailcow-dockerized/data/web/lang/lang.pl.json
+++ b/mailcow/src/mailcow-dockerized/data/web/lang/lang.pl.json
@@ -106,13 +106,13 @@
         "alias_empty": "Alias nie może być pusty",
         "alias_goto_identical": "Alias i Idź do nie mogą być identyczne",
         "alias_invalid": "Alias nieprawidłowy",
-        "aliasd_targetd_identical": "Alias domeny nie może być identyczny z domenš docelową",
+        "aliasd_targetd_identical": "Alias domeny nie może być identyczny z domeną docelową",
         "aliases_in_use": "Maks. liczba aliasów musi być większa od lub równa %d",
         "description_invalid": "Nieprawidłowy opis źródła",
         "dkim_domain_or_sel_invalid": "Nieprawidłowa domena lub selektor DKIM",
         "domain_exists": "Domena %s już istnieje",
         "domain_invalid": "Błędna nazwa domeny",
-        "domain_not_empty": "Nie można usunšć niepustej domeny",
+        "domain_not_empty": "Nie można usunąć niepustej domeny",
         "domain_not_found": "Nie znaleziono domeny %s",
         "domain_quota_m_in_use": "Limit domeny %s MiB",
         "goto_empty": "Adres Idź do nie może być pusty",
@@ -120,15 +120,15 @@
         "is_alias": "%s został już podany jako alias",
         "is_alias_or_mailbox": "%s podano wcześniej jako alias lub skrzynkę",
         "is_spam_alias": "%s podano wcześniej jako alias dla spam",
-        "last_key": "Nie można usunšć ostatniego klucza",
+        "last_key": "Nie można usunąć ostatniego klucza",
         "login_failed": "Niepowodzenie logowania",
         "mailbox_invalid": "Nieprawidłowa nazwa skrzynki",
         "mailbox_quota_exceeded": "Wielkość przekracza limit domeny (maks. %d MiB)",
         "mailbox_quota_exceeds_domain_quota": "Maksymalna wielkość przekracza limit domeny",
         "mailbox_quota_left_exceeded": "Za mało dostępnego miejsca (zostało: %d MiB)",
         "mailboxes_in_use": "Maks. liczba skrzynek musi być większa od lub równa %d",
-        "max_alias_exceeded": "Przekroczono maksymalnš liczbę aliasów",
-        "max_mailbox_exceeded": "Przekroczono maksymalnš liczbę skrzynek (%d z %d)",
+        "max_alias_exceeded": "Przekroczono maksymalną liczbę aliasów",
+        "max_mailbox_exceeded": "Przekroczono maksymalną liczbę skrzynek (%d z %d)",
         "max_quota_in_use": "Limit skrzynki musi być większy od lub równy %d MiB",
         "maxquota_empty": "Maks wielkość. dla skrzynki nie może wynosić 0.",
         "object_exists": "Obiekt %s już istnieje",
@@ -302,7 +302,7 @@
         "domain_admin_removed": "Usunięto administratora domeny %s",
         "domain_modified": "Zapisano zmiany w domenie %s",
         "domain_removed": "Usunięto domenę %s",
-        "eas_reset": "Zresetowano urzšdzenia ActiveSync dla użytkownika %s",
+        "eas_reset": "Zresetowano urządzenia ActiveSync dla użytkownika %s",
         "f2b_modified": "Zmiany w Fail2ban zostały zapisane",
         "forwarding_host_added": "Dodano hosta przekazującego %s",
         "forwarding_host_removed": "Usunięto hosta przekazującego %s",
@@ -424,4 +424,4 @@
         "weekly": "Co tydzień",
         "weeks": "Tygodnie"
     }
-}
\ No newline at end of file
+}
diff --git a/mailcow/src/mailcow-dockerized/data/web/lang/lang.ro.json b/mailcow/src/mailcow-dockerized/data/web/lang/lang.ro.json
index 21af291..80a776c 100644
--- a/mailcow/src/mailcow-dockerized/data/web/lang/lang.ro.json
+++ b/mailcow/src/mailcow-dockerized/data/web/lang/lang.ro.json
@@ -4,10 +4,13 @@
         "app_passwds": "Gestionați parolele aplicației",
         "bcc_maps": "Hărți BCC",
         "delimiter_action": "Acțiune de delimitare",
+        "domain_desc": "Schimbați descrierea domeniului",
+        "domain_relayhost": "Schimbați gazda de transmitere pentru un domeniu",
         "eas_reset": "Resetează dispozitivele EAS",
         "extend_sender_acl": "Permiteți extinderea ACL-ului expeditorului prin adrese externe",
         "filters": "Filtre",
         "login_as": "Conectează-te ca utilizator al cutiei poștale",
+        "mailbox_relayhost": "Schimbați gazda de transmitere pentru un utilizator",
         "prohibited": "Interzis de ACL",
         "protocol_access": "Schimbați protocolul de acces",
         "pushover": "Pushover",
@@ -26,7 +29,10 @@
         "syncjobs": "Lucrări de sincronizare",
         "tls_policy": "Politică TLS",
         "unlimited_quota": "Cota nelimitată pentru cutiile poștale",
-        "domain_desc": "Schimbați descrierea domeniului"
+        "xmpp_admin": "Promovează utilizatorul XMPP ca administrator",
+        "xmpp_domain_access": "Configurează accesul domeniului la XMPP",
+        "xmpp_mailbox_access": "Configurează accesul utilizatorului la XMPP",
+        "xmpp_prefix": "Schimbă subdomeniul (prefixul) pentru XMPP"
     },
     "add": {
         "activate_filter_warn": "Toate celelalte filtre vor fi dezactivate, când este bifată opțiunea activă.",
@@ -59,6 +65,12 @@
         "full_name": "Nume complet",
         "gal": "Lista adreselor globale",
         "gal_info": "GAL conține toate obiectele unui domeniu și nu poate fi editat de niciun utilizator. Informația liber/ocupat din SOGo lipsește dacă este dezactivat! <b>Reporniți SOGo pentru a aplica modificările.</b>",
+        "xmpp": "Activează XMPP pentru acest domeniu",
+        "xmpp_info": "Această funcție va activa mesageria pentru acest domeniu.",
+        "xmpp_access": "Acces XMPP",
+        "xmpp_access_info": "XMPP trebuie să fie activ pentru acest domeniu.",
+        "xmpp_admin": "Administrator XMPP",
+        "xmpp_admin_info": "<b>Atenție:</b> Promovează un utilizator ca administrator XMPP pentru acest domeniu.",
         "generate": "generează",
         "goto_ham": "Învață ca <span class=\"text-success\"><b>ham</b></span>",
         "goto_null": "Aruncă emailul în mod silențios",
@@ -125,6 +137,8 @@
         "admin": "Administrator",
         "admin_details": "Modifică detaliile administratorului",
         "admin_domains": "Sarcini de domenii",
+        "admins": "Administratori",
+        "admins_ldap": "Administratori LDAP",
         "advanced_settings": "Setări avansate",
         "api_allow_from": "Permite accesul API de la aceste adrese IP/CIDR",
         "api_info": "API-ul este în dezvoltare. Documentația se găsește la adresa: <a href=\"/api\">/api</a>",
@@ -199,10 +213,12 @@
         "include_exclude": "Include/Exclude",
         "include_exclude_info": "În mod implicit - fără nici o selecție - <b>toate cutiile poștale</b> sunt adresate",
         "includes": "Include acești destinatari",
+        "is_mx_based": "bazat pe MX",
         "last_applied": "Ultima aplicare",
         "license_info": "O licență nu este necesară, dar ajută la dezvoltarea ulterioară.<br><a href=\"https://www.servercow.de/mailcow?lang=en#sal\" target=\"_blank\" alt=\"Comandă SAL\">Înregistrează GUID aici</a> sau <a href=\"https://www.servercow.de/mailcow?lang=en#support\" target=\"_blank\" alt=\"Comandă suport\">cumpără asistență pentru instalarea platformei.</a>",
         "link": "Link",
         "loading": "Se încarcă...",
+        "login_time": "Moment autentificare",
         "logo_info": "Imaginea ta va fi scalată la o înălțime de 40px pentru bara de navigare de sus și o lățime maximă de 250px pentru pagina de pornire. O grafică scalabilă este foarte recomandată.",
         "lookup_mx": "Potriviți destinația cu MX (.outlook.com pentru a direcționa toate mesajele țintite către un MX * .outlook.com peste acest salt)",
         "main_name": "Nume \"mailcow UI\"",
@@ -222,6 +238,13 @@
         "oauth2_revoke_tokens": "Revocă toate jetoanele clientului",
         "optional": "optional",
         "password": "Parolă",
+        "password_length": "Lungime parolă",
+        "password_policy": "Politica pentru parole",
+        "password_policy_chars": "Trebuie să conțină cel puțin un caracter alfabetic",
+        "password_policy_length": "Lungimea minimă a parolei este %d",
+        "password_policy_numbers": "Trebuie să conțină cel puțin o cifră",
+        "password_policy_lowerupper": "Trebuie să conțină și litere mari și litere mici",
+        "password_policy_special_chars": "Trebuie să conțină caractere speciale",
         "password_repeat": "Parola de confirmare (repetă)",
         "priority": "Prioritate",
         "private_key": "Cheie privată",
@@ -261,6 +284,7 @@
         "regen_api_key": "Regenerează cheia API",
         "regex_maps": "Hărți regex",
         "relay_from": "Adresă \"De la:\"",
+        "relay_rcpt": "Adresă \"Către:\"",
         "relay_run": "Execută test",
         "relayhosts": "Transport dependent de expeditor",
         "relayhosts_hint": "Definește transporturile dependente de expeditor pentru a le putea selecta într-un dialog de configurare a domeniilor.<br>\n  Serviciul de transport este întotdeauna \"smtp:\". Este luată în considerare o setare individuală a politicii TLS de ieșire a utilizatorilor.",
@@ -278,6 +302,7 @@
         "rsettings_preset_1": "Dezactivați tot în afară de DKIM și limita de rată pentru utilizatorii autentificați",
         "rsettings_preset_2": "Postmasterii doresc spam",
         "rsettings_preset_3": "Permiteți numai expeditori specifici pentru o căsuță poștală (ex: utilizare numai ca adresa de email internă)",
+        "rsettings_preset_4": "Dezactivați Rspamd pentru domeniu",
         "rspamd-com_settings": "<a href=\"https://rspamd.com/doc/configuration/settings.html#settings-structure\" target=\"_blank\">Documente Rspamd</a>\n  - Un nume de setare va fi generat automat, te rog să consulți presetările exemplu de mai jos.",
         "rspamd_global_filters": "Hărți cu filtru global",
         "rspamd_global_filters_agree": "Voi fi atent!",
@@ -289,10 +314,12 @@
         "search_domain_da": "Caută domenii",
         "send": "Trimite",
         "sender": "Expeditor",
+        "service": "Serviciu",
         "service_id": "ID serviciu",
         "source": "Sursă",
         "spamfilter": "Filtru de spam",
         "subject": "Subiect",
+        "success": "Succes",
         "sys_mails": "Mailuri sistem",
         "text": "Text",
         "time": "Timp",
@@ -302,6 +329,7 @@
         "transport_dest_format": "Sintaxa: exemplu.org, .example.org, *, box@example.org (mai multe valori pot fi separate prin virgulă)",
         "transport_maps": "Hărți de transport",
         "transports_hint": "→ O intrare a hărții de transport <b>suprascrie</b> o hartă de transport dependentă de expeditor</b>.<br>\n→ Setările pentru politica TLS de ieșire per-utilizator sunt ignorate și pot fi impuse numai prin intrările hărții politicii TLS.<br>\n→ Serviciul de transport pentru transporturi definite este întotdeauna \"smtp:\".<br>\n→ Adresele care se potrivesc cu \"/localhost$/\" vor fi întotdeauna transportate prin \"local:\", prin urmare, o destinație \"*\" nu se va aplica acelor adrese.<br>\n→ Pentru a determina datele de identificare pentru un hop următor \"[host]:25\", Postfix <b>întotdeauna</b> interoghează pentru \"host\" înainte de a căuta \"[host]:25\". Acest comportament face imposibilă folosirea în același timp a \"host\" și \"[host]:25\".",
+        "transport_test_rcpt_info": "→ Utilizează null@hosted.mailcow.de pentru a testa retransmisia către o destinație străină.",
         "ui_footer": "Subsol (HTML permis)",
         "ui_header_announcement": "Anunțuri",
         "ui_header_announcement_active": "Setează activ anunțul",
@@ -353,6 +381,7 @@
         "global_filter_write_error": "Nu se poate scrie fișier filtru: %s",
         "global_map_invalid": "ID hartă globală %s invalid",
         "global_map_write_error": "Nu se poate scrie ID hartă globală %s: %s",
+        "xmpp_map_write_error": "Harta XMPP nu poate fi scrisă: %s",
         "goto_empty": "Adresa goto nu trebuie să fie goală",
         "goto_invalid": "Adresa goto %s este invalidă",
         "ham_learn_error": "Eroare de învățare Ham: %s",
@@ -387,6 +416,7 @@
         "max_quota_in_use": "Cota cutiilor poștale trebuie să fie mai mare sau egală cu %d MiB",
         "maxquota_empty": "Cota maximă pentru cutia poștală nu trebuie să fie 0.",
         "mysql_error": "Eroare MySQL: %s",
+        "nginx_reload_failed": "Reîncărcarea Nginx eșuată: %s",
         "network_host_invalid": "Rețea sau gazdă invalidă: %s",
         "next_hop_interferes": "%s interferează cu următorul hop %s",
         "next_hop_interferes_any": "Un hop următor existent interferează cu %s",
@@ -437,34 +467,44 @@
         "username_invalid": "Numele de utilizator %s nu poate fi utilizat",
         "validity_missing": "Atribuie o perioadă de valabilitate",
         "value_missing": "Furnizează toate valorile",
-        "yotp_verification_failed": "Verificarea Yubico OTP a eșuat: %s"
+        "yotp_verification_failed": "Verificarea Yubico OTP a eșuat: %s",
+        "xmpp_restart_failed": "XMPP nu a putut fi repornit",
+        "xmpp_reload_failed": "XMPP nu a putut fi reîncărcat"
     },
     "debug": {
         "chart_this_server": "Grafic (acest server)",
         "containers_info": "Informaţii container",
         "disk_usage": "Utilizare disc",
+        "docs": "Documente",
         "external_logs": "Jurnale externe",
         "history_all_servers": "Istoric (toate serverele)",
         "in_memory_logs": "Jurnale din memorie",
         "jvm_memory_solr": "Memorie utilizată de JVM",
+        "last_modified": "Ultima modificare",
         "log_info": "<p><b>jurnalele din memorie</b> pentru mailcow sunt colectate în listele Redis și trimise la LOG_LINES (%d) în fiecare minut pentru a reduce ciocnirea.\n  <br>Jurnalele din memorie nu sunt menite a fi persistente. Toate aplicațiile care înregistrează jurnale în memorie, înregistrează de asemenea jurnale în daemonul Docker și, prin urmare, în driverul de jurnale implicit.\n  <br>Tipul de jurnal din memorie trebuie utilizat pentru depanarea problemelor minore cu containerele.</p>\n  <p><b>Jurnalele externe</b> sunt colectate prin API-ul aplicației respective.</p>\n  <p><b>Jurnalele statice</b> sunt, în majoritate, jurnale de activitate care nu sunt înregistrate în Docker, dar trebuie să fie persistente (cu excepția jurnalelor API).</p>",
+        "login_time": "Moment",
         "logs": "Jurnale",
+        "online_users": "Utilizatori online",
         "restart_container": "Repornire",
+        "service": "Serviciu",
+        "size": "Mărime",
         "solr_dead": "Solr începe, este invalid sau s-a oprit.",
-        "solr_docs": "Documente",
-        "solr_last_modified": "Ultima modificare",
-        "solr_size": "Mărime",
-        "solr_started_at": "Pornit la",
         "solr_status": "Stare Solr",
-        "solr_uptime": "Timp de funcționare",
+        "started_at": "Pornit la",
         "started_on": "Început pe",
         "static_logs": "Jurnale statice",
-        "system_containers": "Sistem și Containere"
+        "success": "Succes",
+        "system_containers": "Sistem și Containere",
+        "uptime": "Timp de funcționare",
+        "username": "Utilizator",
+        "xmpp_dead": "XMPP pornește, este dezactivat sau nefuncțional.",
+        "xmpp_status": "Stare XMPP"
     },
     "diagnostics": {
         "cname_from_a": "Valoare derivată din înregistrarea A/AAAA. Acest lucru este acceptat atâta timp cât înregistrarea indică resursele corecte.",
         "dns_records": "Înregistrări DNS",
         "dns_records_24hours": "Rețineți că modificările aduse DNS-ului pot dura până la 24 de ore pentru a reflecta corect starea lor curentă pe această pagină. Acest mecanism este conceput ca o modalitate să vezi ușor cum să îți configurezi înregistrările DNS și să verifici dacă toate înregistrările sunt stocate corect în DNS.",
+        "dns_records_docs": "Vă rugăm să consultați și <a target=\"_blank\" href=\"https://mailcow.github.io/mailcow-dockerized-docs/prerequisite-dns/\">documentația</a>.",
         "dns_records_data": "Date corecte",
         "dns_records_name": "Nume",
         "dns_records_status": "Stare curentă",
@@ -473,6 +513,7 @@
     },
     "edit": {
         "active": "Activ",
+        "admin": "Editează administrator",
         "advanced_settings": "Setări avansate",
         "alias": "Editează alias",
         "allow_from_smtp": "Permiteți acestor adrese IP să utilizeze numai <b>SMTP</b>",
@@ -507,13 +548,24 @@
         "full_name": "Nume complet",
         "gal": "Listă globală de adrese",
         "gal_info": "GAL-ul conține toate obiectele dintr-un domeniu și nu poate fi editată de nici un utilizator. <b>Repornește SOGo pentru a aplica modificările.</b>",
+        "xmpp": "Activează XMPP pentru acest domeniu",
+        "xmpp_prefix": "Prefixul XMPP pentru domeniu (\"im\" pentru <b>im</b>.example.org)",
+        "xmpp_prefix_info": "Pentru a solicita certificate pentru XMPP, două înregistrări DNS CNAME ar trebui să trimită de la <b>im</b>.example.org precum și <b>*.im</b>.example.org la <b>%s</b>. De asemenea, rulați verificarea DNS pentru acest domeniu după activarea XMPP.",
+        "xmpp_info": "Această funcție va activa mesageria pentru acest domeniu.",
+        "xmpp_access": "Acces XMPP",
+        "xmpp_access_info": "XMPP trebuie să fie activ pentru acest domeniu.",
+        "xmpp_admin": "Administrator XMPP",
+        "xmpp_admin_info": "<b>Atenție:</b> Promovează un utilizator ca administrator XMPP pentru acest domeniu.",
+        "xmpp_example_jid": "<b>Exemplu JID</b> (autentificare cu parolă email)",
         "generate": "Generează",
         "grant_types": "Tipuri de subvenții",
         "hostname": "Nume gazdă",
         "inactive": "Inactiv",
         "kind": "Fel",
+        "lookup_mx": "Destinația este o expresie regulată care potrivită cu numele MX (<code>.*google\\.com</code> pentru a direcționa toate e-mailurile vizate către un MX care se termină în google.com peste acest hop)",
         "mailbox": "Editează căsuța poștală",
         "mailbox_quota_def": "Cota implicită a căsuței poștale",
+        "mailbox_relayhost_info": "Aplicat numai căsuței poștale și aliasurilor directe, suprascrie un transport dependent de domeniu.",
         "max_aliases": "Număr maxim de aliasuri",
         "max_mailboxes": "Număr maxim de cutii poștale",
         "max_quota": "Cotă maximă pentru cutia poștală (MiB)",
@@ -538,6 +590,9 @@
         "pushover_vars": "Când nu este definit niciun filtru pentru expeditor, toate mailurile vor fi luate în considerare. <br> Filtrele regex, precum și verificările exacte ale expeditorului pot fi definite individual și vor fi luate în considerare secvențial. Ele nu depind unul de celălalt. <br> Variabile utilizabile pentru text și titlu (vă rugăm să luați nota de politicile de protecție a datelor)",
         "pushover_verify": "Verifică credențialele",
         "quota_mb": "Cotă (MiB)",
+        "quota_warning_bcc": "Avertizare cotă BCC",
+        "quota_warning_bcc_info": "Avertismentele vor fi trimise sub formă de copii separate către următorii destinatari. Subiectul va fi completat de numele de utilizator corespunzător între paranteze, de exemplu: <code>Avertisment privind cota (utilizator@example.com)</code>.",
+        "ratelimit": "Limită pentru rata de trimitere",
         "redirect_uri": "Adresă URL de redirecționare/inversare",
         "relay_all": "Retransmite toți destinatarii",
         "relay_all_info": "↪ Dacă alegi să <b>nu</b> retransmiți toți destinatarii, va trebui să adaugi o cutie poștală (\"oarbă\") pentru fiecare destinatar care trebuie retransmis.",
@@ -550,7 +605,7 @@
         "save": "Salvează modificările",
         "scope": "Scop",
         "sender_acl": "Permite trimiterea ca",
-        "sender_acl_disabled": "↳ <span class=\"label label-danger\">Verificarea expeditorului este dezactivată</span>",
+        "sender_acl_disabled": "<span class=\"label label-danger\">Verificarea expeditorului este dezactivată</span>",
         "sender_acl_info": "Dacă utilizatorului A de căsuță poștală îi este permis să trimită ca utilizatorul B, adresa expeditorului nu este afișată automat ca fiind câmp selectabil \"de la\" în SOGo.<br>\r\n  Utilizatorul căsuței poștale B trebuie să creeze o delegație în SOGo pentru a permite utilizatorul cutiei poștale A să selecteze adresa ca expeditor. Pentru a delega o cutie poștală în SOGo, utilizați meniul (trei puncte) din dreapta numelui căsuței poștale în stânga sus, în timp ce vă aflați în vizualizarea e-mailului. Acest comportament nu se aplică adreselor alias.",
         "sieve_desc": "Descriere scurtă",
         "sieve_type": "Tip filtru",
@@ -560,6 +615,7 @@
         "sogo_visible": "Aliasul este vizibil în SOGo",
         "sogo_visible_info": "Această opțiune afectează doar obiecte, care pot fi afișate în SOGo (adrese alias partajate sau ne-partajate cu cel puțin o căsuță poștală locală). Dacă este ascuns, un alias nu va apărea ca expeditor selectabil în SOGo.",
         "spam_alias": "Crează sau modifică adrese alias limitate în funcție de timp",
+        "spam_filter": "Filtru spam",
         "spam_policy": "Adaugă sau elimină elemente în lista albă/neagră",
         "spam_score": "Stabilește un scor de spam personalizat",
         "subfolder2": "Sincronizează în subfolderul destinației<br><small>(gol = nu se utilizează subfolderul)</small>",
@@ -578,9 +634,11 @@
         "confirm_delete": "Confirmă ștergerea",
         "delete_now": "Șterge acum",
         "delete_these_items": "Confirmă modificările aduse următorului id de obiect:",
+        "hibp_check": "Verificare prin haveibeenpwned.com",
         "hibp_nok": "Potrivire! Aceasta este o parolă potențial periculoasă!",
         "hibp_ok": "Nu s-a găsit niciun rezultat.",
         "loading": "Te rog așteaptă...",
+        "nothing_selected": "Nicio selecție",
         "restart_container": "Repornire container",
         "restart_container_info": "<b>Important:</b> O repornire elegantă poate dura ceva timp până la finalizare, așteaptă să termine.",
         "restart_now": "Repornire acum",
@@ -617,6 +675,7 @@
         "active": "Activ",
         "add": "Adaugă",
         "add_alias": "Adaugă alias",
+        "add_alias_expand": "Extinde aliasul ca domeniu alias",
         "add_bcc_entry": "Adaugă hartă BCC",
         "add_domain": "Adaugă domeniu",
         "add_domain_alias": "Adaugă un domeniu alias",
@@ -677,6 +736,7 @@
         "insert_preset": "Inserați un exemplu presetat \"%s\"",
         "kind": "Fel",
         "last_mail_login": "Ultima autentificare pe mail",
+        "last_pw_change": "Ultima modificare a parolei",
         "last_run": "Ultima rulare",
         "last_run_reset": "Programează următorul",
         "mailbox": "Cutie poștală",
@@ -692,6 +752,7 @@
         "no": "&#10005;",
         "no_record": "Nu există înregistrări pentru obiectul %s",
         "no_record_single": "Nici o înregistrare",
+        "open_logs": "Deschide jurnalele",
         "owner": "Proprietar",
         "private_comment": "Comentariu privat",
         "public_comment": "Comentariu public",
@@ -723,7 +784,6 @@
         "sieve_preset_7": "Redirecționează și păstrează/aruncă",
         "sieve_preset_8": "Renunțați la mesajul trimis la o adresă alias din care face parte expeditorul",
         "sieve_preset_header": "Vedeți exemplul de presetări de mai jos. Pentru mai multe detalii accesați <a href=\"https://en.wikipedia.org/wiki/Sieve_(mail_filtering_language)\" target=\"_blank\">Wikipedia</a>.",
-        "sogo_allow_admin_hint": "Conectările SOGo administrative sunt disponibile numai pentru căsuțele poștale cu un profil SOGo existent. Un utilizator trebuie să se fi fost conectat la SOGo cel puțin o dată.",
         "sogo_visible": "Aliasul este vizibil în SOGo",
         "sogo_visible_n": "Ascunde alias în SOGo",
         "sogo_visible_y": "Afișază alias în SOGo",
@@ -770,6 +830,7 @@
         "danger": "Pericol",
         "deliver_inbox": "Livrați în căsuța de e-mail",
         "disabled_by_config": "Configurația actuală a sistemului dezactivează funcția de carantină.",
+        "settings_info": "Numărul maxim de elemente în carantină: %s<br>Mărime maximă email: %s MiB",
         "download_eml": "Descarcă (.eml)",
         "empty": "Nici un rezultat",
         "high_danger": "Ridicat",
@@ -868,10 +929,12 @@
         "mailbox_added": "Cutia poștală %s a fost adăugată",
         "mailbox_modified": "Modificările cutiei poștale %s au fost salvate",
         "mailbox_removed": "Cutia poștală %s a fost eliminată",
+        "nginx_reloaded": "Nginx a fost reîncărcat",
         "object_modified": "Modificările obiectului %s au fost salvate",
         "pushover_settings_edited": "Setările pushover au fost setate cu succes, vă rugăm să verificați credențialele.",
         "qlearn_spam": "ID-ul mesajului %s a fost învățat ca spam și a fost șters",
         "queue_command_success": "Șirul de comenzi a fost terminat cu succes",
+        "password_policy_saved": "Politica pentru parole a fost salvată cu success",
         "recipient_map_entry_deleted": "ID-ul hărții destinatarului %s a fost șters",
         "recipient_map_entry_saved": "Intrarea hărții destinatarului \"%s\" a fost salvată",
         "relayhost_added": "Înregistrarea pentru hartă %s a fost adăugată",
@@ -893,7 +956,10 @@
         "verified_totp_login": "Autentificarea TOTP verificată",
         "verified_u2f_login": "Autentificarea U2F verificată",
         "verified_fido2_login": "Conectare FIDO2 verificată",
-        "verified_yotp_login": "Autentificarea Yubico OTP verificată"
+        "verified_yotp_login": "Autentificarea Yubico OTP verificată",
+        "xmpp_restarted": "Serviciul XMPP a fost repornit",
+        "xmpp_reloaded": "Serviciul XMPP a fost reîncărcat",
+        "xmpp_maps_updated": "Hărțile serviciului XMPP au fost actualizate"
     },
     "tfa": {
         "api_register": "%s utilizează API-ul Yubico Cloud. Obțineți o cheie API pentru cheia dvs. de <a href=\"https://upgrade.yubico.com/getapikey/\" target=\"_blank\">aici</a>",
@@ -956,9 +1022,11 @@
         "apple_connection_profile_complete": "Acest profil de conexiune include parametrii IMAP și SMTP, precum și calDAV (calendar) și carduri CardDAV (contacte) pentru dispozitivele Apple.",
         "apple_connection_profile_mailonly": "Acest profil de conexiune include parametrii de configurare IMAP și SMTP pentru dispozitivele Apple.",
         "change_password": "Schimbă parola",
+        "clear_recent_successful_connections": "Ștergeți conexiunile reușite văzute",
         "client_configuration": "Afișează ghidurile de configurare pentru clienții de email și smartphone-uri",
         "create_app_passwd": "Crează parola aplicației",
         "create_syncjob": "Crează o nouă lucrare de sincronizare",
+        "created_on": "Creat în",
         "daily": "Zilnic",
         "day": "zi",
         "delete_ays": "Vă rugăm să confirmați stergerea.",
@@ -970,10 +1038,13 @@
         "edit": "Editează",
         "email": "Email",
         "email_and_dav": "Email, calendar și contacte",
+        "empty": "Niciun rezultat",
         "encryption": "Criptare",
         "excludes": "Exclude",
         "expire_in": "Expiră în",
+        "fido2_webauthn": "FIDO2/AutWeb",
         "force_pw_update": "<b>Trebuie</b> să setezi o nouă parolă pentru a putea accesa serviciile legate de grupuri.",
+        "from": "de la",
         "generate": "generează",
         "hour": "oră",
         "hourly": "Din oră în oră",
@@ -982,17 +1053,26 @@
         "interval": "Interval",
         "is_catch_all": "Catch-all pentru domeniu/i",
         "last_mail_login": "Ultima autentificare pe mail",
+        "last_pw_change": "Ultima modificare a parolei",
         "last_run": "Ultima rulare",
+        "last_ui_login": "Ultima autentificare UI",
         "loading": "Se încarcă...",
+        "login_history": "Istoric autentificare",
+        "mailbox": "Mailbox",
         "mailbox_details": "Informații cutie poștală",
+        "mailbox_general": "Generale",
+        "mailbox_settings": "Setări",
         "messages": "mesaje",
+        "month": "lună",
+        "months": "luni",
         "never": "Niciodată",
         "new_password": "Parolă nouă",
-        "new_password_description": "Cerință: 6 caractere lungime, litere și numere.",
         "new_password_repeat": "Parola de confirmare (repetă)",
         "no_active_filter": "Nu este disponibil niciun filtru activ",
         "no_last_login": "Nu există informații despre ultima autentificare în interfață",
         "no_record": "Nici o înregistrare",
+        "open_logs": "Deschide jurnalele",
+        "open_webmail_sso": "Autentificare în webmail",
         "password": "Parolă",
         "password_now": "Parola curentă (confirmă modificările)",
         "password_repeat": "Parolă (repetă)",
@@ -1012,6 +1092,7 @@
         "quarantine_category": "Schimbați categoria notificărilor despre carantină",
         "quarantine_notification_info": "Odată ce o notificare a fost trimisă, elementele vor fi marcate ca fiind \"notificate\" și nu vor fi trimise alte notificări pentru acest articol.",
         "quarantine_category_info": "Categoria de notificări \"Respins\" include e-mailurile care au fost respinse, în timp ce \"Dosarul nedorit\" va notifica un utilizator despre mesajele care au fost introduse în dosarul nedorit.",
+        "recent_successful_connections": "Conexiuni reușite văzute",
         "remove": "Șterge",
         "running": "Funcţionare",
         "save": "Salvează modificările",
@@ -1062,7 +1143,9 @@
         "waiting": "Aşteptare",
         "week": "săptămână",
         "weekly": "Săptămânal",
-        "weeks": "săptămâni"
+        "weeks": "săptămâni",
+        "year": "an",
+        "years": "ani"
     },
     "warning": {
         "cannot_delete_self": "Nu se poate șterge utilizatorul conectat",
@@ -1071,6 +1154,7 @@
         "fuzzy_learn_error": "Eroare de învățare fuzzy hash: %s",
         "hash_not_found": "Hash-ul nu a fost găsit",
         "ip_invalid": "S-a ignorat adresa IP invalidă: %s",
+        "is_not_primary_alias": "Alias non-primary omis %s",
         "no_active_admin": "Nu se poate dezactiva ultimul administrator activ",
         "quota_exceeded_scope": "Cota de spațiu a domeniului depășită: Numai căsuțe poștale nelimitate pot fi create pe acest domeniu.",
         "session_token": "Token formular invalid: Nepotrivire token",
diff --git a/mailcow/src/mailcow-dockerized/data/web/lang/lang.ru.json b/mailcow/src/mailcow-dockerized/data/web/lang/lang.ru.json
index 3eba344..f24ae35 100644
--- a/mailcow/src/mailcow-dockerized/data/web/lang/lang.ru.json
+++ b/mailcow/src/mailcow-dockerized/data/web/lang/lang.ru.json
@@ -26,7 +26,11 @@
         "syncjobs": "Задания синхронизации",
         "tls_policy": "Политика шифрования",
         "unlimited_quota": "Неограниченная квота для почтовых ящиков",
-        "domain_desc": "Изменение описания домена"
+        "domain_desc": "Изменение описания домена",
+        "xmpp_admin": "Повышение пользователя XMPP до администратора",
+        "xmpp_domain_access": "Настройка доступа XMPP для домена",
+        "xmpp_mailbox_access": "Настройка доступа XMPP для пользователей",
+        "xmpp_prefix": "Измение субдомена (префикса) XMPP"
     },
     "add": {
         "activate_filter_warn": "Активация этого фильтра отключит все остальные фильтры этого типа.",
@@ -35,14 +39,14 @@
         "add_domain_only": "Только добавить домен",
         "add_domain_restart": "Добавить домен и перезапустить SOGo",
         "alias_address": "Псевдоним/ы",
-        "alias_address_info": "<small>Укажите почтовые адреса разделенные запятыми или, если хотите пересылать все сообщения для домена владельцам псевонима то: <code>@example.com</code>. <b>Только домены mailcow разрешены</b>.</small>",
+        "alias_address_info": "<small>Укажите почтовые адреса разделенные запятыми или, если хотите пересылать все сообщения для домена владельцам псевдонима то: <code>@example.com</code>. <b>Только домены mailcow разрешены</b>.</small>",
         "alias_domain": "Псевдоним домена",
-        "alias_domain_info": "<small>Действительные имена доменов, разделенные запятыми.</small>",
+        "alias_domain_info": "<small>Действительные имена доменов, раздёленные запятыми.</small>",
         "app_name": "Название приложения",
         "app_password": "Добавить пароль приложения",
         "automap": "Автоматическое слияние папок (\"Sent items\", \"Sent\" => \"Sent\" etc.)",
         "backup_mx_options": "Параметры резервного MX",
-        "comment_info": "Приватный комментарий не виден пользователям, а публичный - отображается рядом с певдонимом в личном кабинете пользователя.",
+        "comment_info": "Приватный комментарий не виден пользователям, а публичный - отображается рядом с псевдонимом в личном кабинете пользователя.",
         "custom_params": "Пользовательские параметры",
         "custom_params_hint": "Верно: --param=xy, не верно: --param xy",
         "delete1": "Удаление из источника после завершения",
@@ -50,7 +54,7 @@
         "delete2duplicates": "Удаление дубликатов по назначению",
         "description": "Описание",
         "destination": "Назначение",
-        "disable_login": "Вход в систему запрещен",
+        "disable_login": "Вход в систему запрещён",
         "domain": "Домен",
         "domain_matches_hostname": "Домен %s соответствует имени хоста",
         "domain_quota_m": "Квота домена (MiB)",
@@ -59,9 +63,15 @@
         "full_name": "Полное имя",
         "gal": "GAL - Глобальная адресная книга",
         "gal_info": "GAL содержит все объекты домена и не подлежит редактированию. Информация о занятости в SOGo будет отсутствовать для домена, если эта функция не будет включена! <b>Требуется перезапустить SOGo, чтобы изменения применились.</b>",
+        "xmpp": "Активировать XMPP для этого домена",
+        "xmpp_info": "Эта опция добавит функциональность чата для этого домена.",
+        "xmpp_access": "Пользователь XMPP",
+        "xmpp_access_info": "XMPP должен быть включен для этого домена.",
+        "xmpp_admin": "Администратор XMPP",
+        "xmpp_admin_info": "Повысить пользователя XMPP до <span class=\"text-danger\">администратора домена</span>.",
         "generate": "сгенерировать",
-        "goto_ham": "Запомнить как <span class=\"text-success\"><b>хам</b></span>",
-        "goto_null": "Отключить входящюю почту",
+        "goto_ham": "Запомнить как <span class=\"text-success\"><b>&laquo;ham&raquo;</b></span>",
+        "goto_null": "Отключить входящую почту",
         "goto_spam": "Запомнить как <span class=\"text-danger\"><b>спам</b></span>",
         "hostname": "Имя хоста",
         "inactive": "Неактивный",
@@ -94,7 +104,7 @@
         "skipcrossduplicates": "Пропускать повторяющиеся сообщения в папках",
         "subscribeall": "Подписаться на все папки и подпапки",
         "syncjob": "Добавить задание синхронизации",
-        "syncjob_hint": "К сведению: пароли к вашему аккаунту бытут сохранены на сервере в виде простого текста!",
+        "syncjob_hint": "К сведению: пароли к вашему аккаунту будут сохранены на сервере в виде простого текста!",
         "target_address": "Владельцы псевдонима",
         "target_address_info": "<small>Адреса почтовых ящиков, разделенные запятыми.</small>",
         "target_domain": "Целевой домен",
@@ -123,6 +133,8 @@
         "add_transports_hint": "Пожалуйста имейте в виду, что данные для аутентификации будут храниться в виде обычного текста.",
         "additional_rows": " добавлены дополнительные строки",
         "admin": "Администратор",
+        "admins": "Администраторы",
+        "admins_ldap": "LDAP Администраторы",
         "admin_details": "Изменить данные администратора",
         "admin_domains": "Домен назначения",
         "advanced_settings": "Расширенные настройки",
@@ -136,7 +148,7 @@
         "arrival_time": "Время получения (час.пояс сервера)",
         "authed_user": "Автор. польз.",
         "ays": "Вы уверены что хотите продолжить?",
-        "ban_list_info": "Список забаненных IP адресов: <b>подсеть (оставшееся время бана) - [действие]</b>.<br />IP-адреса, находящиеся в очереди на разблокирование, будут удалены из списка активных банов в течение нескольких секунд.<br />Красная метка обозначает что подсеть/хост находится в черном списоке.",
+        "ban_list_info": "Список забаненных IP адресов: <b>подсеть (оставшееся время бана) - [действие]</b>.<br />IP-адреса, находящиеся в очереди на разблокирование, будут удалены из списка активных банов в течение нескольких секунд.<br />Красная метка обозначает что подсеть/хост находится в черном списке.",
         "change_logo": "Изменить логотип",
         "configuration": "Глобальные настройки",
         "convert_html_to_text": "Сконвертировать HTML в обычный текст",
@@ -147,7 +159,7 @@
         "destination": "Назначение",
         "dkim_add_key": "Добавить ARC/DKIM ключ",
         "dkim_domains_selector": "Selector",
-        "dkim_domains_wo_keys": "Выберать домены с отсутствующими DKIM ключами",
+        "dkim_domains_wo_keys": "Выбрать домены с отсутствующими DKIM ключами",
         "dkim_from": "из",
         "dkim_from_title": "Исходный домен для копирования ключа",
         "dkim_key_length": "Длина DKIM ключа (bits)",
@@ -158,7 +170,7 @@
         "dkim_overwrite_key": "Перезаписать существующий ключ DKIM",
         "dkim_private_key": "Закрытый ключ",
         "dkim_to": "в",
-        "dkim_to_title": "Целевой домен/ы, учитите что DKIM будет перезаписан",
+        "dkim_to_title": "Целевой домен/ы (учтите, что DKIM будет перезаписан)",
         "domain": "Домен",
         "domain_admin": "Администратор домена",
         "domain_admins": "Администраторы домена",
@@ -183,12 +195,12 @@
         "flush_queue": "Отправить все сообщения",
         "forwarding_hosts": "Переадресация хостов",
         "forwarding_hosts_add_hint": "Можно указывать: IPv4/IPv6 подсети в нотации CIDR, имена хостов (которые будут разрешаться в IP-адреса) или доменные имена (которые будут решаться с IP-адресами путем запроса SPF записей или, в случае их отсутствия - запросом MX записей).",
-        "forwarding_hosts_hint": "Входящие сообщения безоговорочно принимаются от любых хостов, перечисленных здесь. Эти хосты не проходят проверку DNSBL и graylisting. Спам, полученный от них, никогда не отклоняется, но при желании можно включить фильтр спама и письма с плохим рейтингом будут попадать в Junk. Наиболее распространенное использование - указать почтовые серверы, на которых вы установили правило, которое перенаправляет входящие электронные письма на ваш почтовый сервер.",
+        "forwarding_hosts_hint": "Входящие сообщения безоговорочно принимаются от любых хостов, перечисленных здесь. Эти хосты не проходят проверку DNSBL и graylisting. Спам, полученный от них, никогда не отклоняется, но при желании можно включить спам фильтр и письма с плохим рейтингом будут попадать в Junk. Наиболее распространенное использование - указать почтовые серверы, на которых вы установили правило, которое перенаправляет входящие электронные письма на ваш почтовый сервер.",
         "from": "От",
         "generate": "сгенерировать",
         "guid": "GUID - уникальный ID",
         "guid_and_license": "Лицензия и GUID",
-        "hash_remove_info": "Удаление хеша лимитов отправки (если оно правило настроено) полностью сбрасывает счетчики лимитов.<br>\r\n  Каждый хэш обозначен отдельным цветом.",
+        "hash_remove_info": "Удаление хеша лимитов отправки (если правило настроено) полностью сбрасывает счётчики лимитов.<br>\r\n  Каждый хэш обозначен своим цветом.",
         "help_text": "Заменить текст справки на странице логина (использование HTML разрешено)",
         "host": "Хост",
         "html": "HTML",
@@ -200,7 +212,7 @@
         "include_exclude_info": "По умолчанию - без выбора - <b>все почтовые ящики</b> адресованы",
         "includes": "Включить этих получателей",
         "last_applied": "Посл. применение",
-        "license_info": "Лицензия не обезательна, но ее приобритение помогает дальнейшему развитию mailcow.<br><a href=\"https://www.servercow.de/mailcow?lang=en#sal\" target=\"_blank\" alt=\"SAL order\">Зарегистрируйте свой GUID здесь</a> или <a href=\"https://www.servercow.de/mailcow?lang=en#support\" target=\"_blank\" alt=\"Заказать поддержку\">приобретите поддержку для вашей установки mailcow.</a>",
+        "license_info": "Лицензия не обязательна, но её приобретение помогает дальнейшему развитию mailcow.<br><a href=\"https://www.servercow.de/mailcow?lang=en#sal\" target=\"_blank\" alt=\"SAL order\">Зарегистрируйте свой GUID здесь</a> или <a href=\"https://www.servercow.de/mailcow?lang=en#support\" target=\"_blank\" alt=\"Заказать поддержку\">приобретите поддержку для вашей установки mailcow.</a>",
         "link": "Ссылка",
         "loading": "Пожалуйста, подождите...",
         "logo_info": "Ваше изображение будет масштабироваться до высоты 40px для верхней панели навигации и до 250px ширины для стартовой страницы. <br>Рекомендуется использовать векторную графику, на пример: .svg.",
@@ -211,17 +223,24 @@
         "message_size": "Размер сообщения",
         "nexthop": "Следующий хост",
         "no": "&#10005;",
-        "no_active_bans": "В данный момент нет забаненых подсетей/хостов",
+        "no_active_bans": "В данный момент нет забаненных подсетей/хостов",
         "no_new_rows": "Нет доступных строк",
         "no_record": "Нет записей",
         "oauth2_client_id": "ID клиента",
         "oauth2_client_secret": "Секретный ключ пользователя",
-        "oauth2_info": "Реализация OAuth2 поддерживает предоставления кодов авторизации и выдает токены продленния сесии.<br>\r\nСервер также автоматически выдает новый токен продления сессии, после того, как предыдущий был использован.<br><br>\r\n→ Scope по умолчанию: <i>profile</i>. Только пользователи почтовых аккаунтов могут проходить аутентификацию через OAuth2. Если параметр области не указан, он возвращается к <i>profile</i>.<br>\r\n→ Параметр <i>state</i> должен быть отправлен клиентом как часть запроса для авторизации.<br><br>\r\nПути для запросов OAuth2 API: <br>\r\n<ul>\r\n  <li>Authorization endpoint: <code>/oauth/authorize</code></li>\r\n  <li>Token endpoint: <code>/oauth/token</code></li>\r\n  <li>Resource page:  <code>/oauth/profile</code></li>\r\n</ul>\r\nГенерирование нового клиентского секрета не приводит к истечению существующих кодов авторизации, но они не смогут обновить свой токен.<br><br>\r\nОтзыв клиентских токенов приведет к немедленному прекращению всех активных сеансов. Все клиенты должны будут пройти повторную аутентификацию.",
+        "oauth2_info": "Реализация OAuth2 поддерживает предоставления кодов авторизации и выдает токены продления сессии.<br>\r\nСервер также автоматически выдает новый токен продления сессии, после того, как предыдущий был использован.<br><br>\r\n→ Scope по умолчанию: <i>profile</i>. Только пользователи почтовых аккаунтов могут проходить аутентификацию через OAuth2. Если параметр области не указан, он возвращается к <i>profile</i>.<br>\r\n→ Параметр <i>state</i> должен быть отправлен клиентом как часть запроса для авторизации.<br><br>\r\nПути для запросов OAuth2 API: <br>\r\n<ul>\r\n  <li>Authorization endpoint: <code>/oauth/authorize</code></li>\r\n  <li>Token endpoint: <code>/oauth/token</code></li>\r\n  <li>Resource page:  <code>/oauth/profile</code></li>\r\n</ul>\r\nГенерирование нового клиентского секрета не приводит к истечению существующих кодов авторизации, но они не смогут обновить свой токен.<br><br>\r\nОтзыв клиентских токенов приведет к немедленному прекращению всех активных сеансов. Все клиенты должны будут пройти повторную аутентификацию.",
         "oauth2_redirect_uri": "Переадресация URI",
         "oauth2_renew_secret": "Сгенерировать новый ключ клиента",
         "oauth2_revoke_tokens": "Отозвать все клиентские токены",
-        "optional": "опцыонально",
+        "optional": "опционально",
         "password": "Пароль",
+        "password_length": "Минимальная длина пароля",
+        "password_policy": "Политика паролей",
+        "password_policy_chars": "Должен содержать алфавитный символ",
+        "password_policy_length": "Минимальная длина пароля %d символов",
+        "password_policy_numbers": "Должен содержать цифру",
+        "password_policy_lowerupper": "Должны содержать символы верхнего и нижнего регистров",
+        "password_policy_special_chars": "Должны содержать специальный символ",
         "password_repeat": "Подтверждение пароля (повтор)",
         "priority": "Приоритет",
         "private_key": "Закрытый ключ",
@@ -229,8 +248,8 @@
         "quarantine_bcc": "Отправка копии всех уведомлений (BCC) к получателю:<br><small><b>Получатель должен быть внутренним, так как почта не подписана и не проверена. </b></br>Отключено, если получатель не указан.</small>",
         "quarantine_exclude_domains": "Исключить домены и псевдонимы доменов",
         "quarantine_max_age": "Максимальный период хранения в днях<br><small>Значение должно быть равно или больше 1 дня.</small>",
-        "quarantine_max_size": "Максимальный размер в MiB (письма большего размера не будет сохранены):<br><small>0 <b>не означает</b> неограниченый размер.</small>",
-        "quarantine_max_score": "Не уведомлять о спаме если оценка письма выче чем:<br><small>По умолчанию 9999.0</small>",
+        "quarantine_max_size": "Максимальный размер в MiB (письма большего размера не будет сохранены):<br><small>0 означает, что карантин <b>отключён</b>.</small>",
+        "quarantine_max_score": "Не уведомлять о спаме, если оценка письма выше, чем:<br><small>По умолчанию 9999.0</small>",
         "quarantine_notification_html": "Шаблон уведомления:<br><small>Оставьте пустым, чтобы восстановить шаблон по умолчанию.</small>",
         "quarantine_notification_sender": "Email-адрес для отправки уведомления",
         "quarantine_notification_subject": "Тема письма",
@@ -238,7 +257,7 @@
         "quarantine_release_format": "Формат доставки писем после восстановления",
         "quarantine_release_format_att": "Как вложение",
         "quarantine_release_format_raw": "Оригинальное письмо",
-        "quarantine_retention_size": "Количество писем сохраненных в карантине на аккаунт:<br><small>0 значит что лимита <b>нет</b>.</small>",
+        "quarantine_retention_size": "Количество писем, сохраняемых в карантине на аккаунт:<br><small>0 означает, что карантин <b>отключён</b>.</small>",
         "queue_ays": "Пожалуйста, подтвердите, что вы хотите удалить все элементы из очереди.",
         "queue_deliver_mail": "Доставить",
         "queue_hold_mail": "Поставить на удержание",
@@ -254,13 +273,14 @@
         "quota_notifications_vars": "{{percent}} равно текущей квоте пользователя<br>{{username}} - имя почтового аккаунта",
         "r_active": "Включенные ограничения",
         "r_inactive": "Отключенные ограничения",
-        "r_info": "Не активные (серые) елементы списка ограничений - это не валидные ограничения, и они не могут быть перемещены. <br>Вы можете добавить новые элементы в <code>inc/vars.local.inc.php</code> чтобы иметь возможность настраивать их.",
+        "r_info": "Не активные (серые) элементы списка ограничений - это не валидные ограничения, и они не могут быть перемещены. <br>Вы можете добавить новые элементы в <code>inc/vars.local.inc.php</code> чтобы иметь возможность настраивать их.",
         "rate_name": "Название очереди",
         "recipients": "Получатели",
         "refresh": "Обновить",
         "regen_api_key": "Сгенерировать новый ключ для API",
         "regex_maps": "Фильтрация с помощью регулярных выражений",
-        "relay_from": "\"От:\" адрес",
+        "relay_from": "\"От:\"",
+        "relay_rcpt": "\"Кому:\"",
         "relay_run": "Запустить тест",
         "relayhosts": "Транспортировка в зависимости от отправителя",
         "relayhosts_hint": "Определите промежуточные узлы здесь, чтобы иметь возможность выбрать их в диалоговом окне конфигурации доменов.",
@@ -275,14 +295,14 @@
         "rsetting_no_selection": "Пожалуйста, выберите правило",
         "rsetting_none": "Нет доступных правил",
         "rsettings_insert_preset": "Вставить пример \"%s\"",
-        "rsettings_preset_1": "Disable all but DKIM and rate limit for authenticated users",
+        "rsettings_preset_1": "Отключить все, кроме DKIM и ограничения скорости для аутентифицированных пользователей ",
         "rsettings_preset_2": "Postmasters want spam",
-        "rsettings_preset_3": "Only allow specific senders for a mailbox (i.e. usage as internal mailbox only)",
-        "rspamd-com_settings": "Имена правил будут сгенерированы на основе их ID.<br> Инструкция доступна на сайте <a href=\"https://rspamd.com/doc/configuration/settings.html#settings-structure\" target=\"_blank\">документация Rspamd user settings</a>, заготовленые шаблоны:",
+        "rsettings_preset_3": "Разрешить только определённых отправителей для почтового ящика (использование только в качестве внутреннего почтового ящика) ",
+        "rspamd-com_settings": "Имена правил будут сгенерированы на основе их ID.<br> Инструкция доступна на сайте <a href=\"https://rspamd.com/doc/configuration/settings.html#settings-structure\" target=\"_blank\">документация Rspamd user settings</a>, заготовленные шаблоны:",
         "rspamd_global_filters": "Глобальные правила фильтрации",
-        "rspamd_global_filters_agree": "Я понимаю что я делаю, и буду осторожен!",
+        "rspamd_global_filters_agree": "Я понимаю, что я делаю, и буду осторожен!",
         "rspamd_global_filters_info": "Глобальные правила фильтрации содержат различные виды глобальных черных и белых списков.",
-        "rspamd_global_filters_regex": "Названия фильтров отражают их предназначение. Все правила должены состоять из регулярных выражений в формате \"/pattern/options\" (на пример: <code>/.+@domain\\.tld/i</code>).<br>\r\nНе смотря на то что перед сохранением правил выполняются проверка регулярных выражения, функциональность Rspamds может быть нарушена, если будет использован<br>\r\n некорректный синтаксис. Бульте вниматильны при написании правил.<br>Электронные письма от адресов электронной почты проходящие по регулярным выражениям черных списков будут отклонены без сохранения в карантин.<br>\r\n Rspamd попытается прочитать содержимое правил при их изменении. Но, если что, вы можете <a href=\"\" data-toggle=\"modal\" data-container=\"rspamd-mailcow\" data-target=\"#RestartContainer\">перезапустить Rspamd</a>, что бы приминить последние изменения принудительно.",
+        "rspamd_global_filters_regex": "Названия фильтров отражают их предназначение. Все правила должены состоять из регулярных выражений в формате \"/pattern/options\" (на пример: <code>/.+@domain\\.tld/i</code>).<br>\r\nНесмотря на то, что перед сохранением правил выполняется проверка регулярных выражений, функциональность Rspamds может быть нарушена, если будет использован<br>\r\n некорректный синтаксис. Будьте внимательны при написании правил.<br>Электронные письма от адресов электронной почты, проходящие по регулярным выражениям черных списков, будут отклонены без сохранения в карантин.<br>\r\n Rspamd попытается прочитать содержимое правил при их изменении. Но, если что, вы можете <a href=\"\" data-toggle=\"modal\" data-container=\"rspamd-mailcow\" data-target=\"#RestartContainer\">перезапустить Rspamd</a>, чтобы принять последние изменения принудительно.",
         "rspamd_settings_map": "Правила Rspamd",
         "sal_level": "Уровень Муу",
         "save": "Сохранить изменения",
@@ -291,17 +311,18 @@
         "sender": "Отправитель",
         "service_id": "ID сервиса",
         "source": "Источник",
-        "spamfilter": "Фильтр спама",
+        "spamfilter": "Спам фильтр",
         "subject": "Тема письма",
         "sys_mails": "Системные сообщения",
         "text": "Обычный текст",
         "time": "Время",
-        "title": "Заголовок",
-        "title_name": "Заглавие сайта \"mailcow UI\"",
+        "title": "Название \"mailcow UI\" для страницы входа:",
+        "title_name": "Заголовок <b>title</b> \"mailcow UI\":",
         "to_top": "Вернуться к началу",
         "transport_dest_format": "example.org, .example.org, *, box@example.org (несколько значений могут быть разделены запятыми)",
         "transport_maps": "Глобальные правила отправки",
-        "transports_hint": "→ Записи в transport map <b>отменяют</b> sender-dependent transport map</b>.<br>\r\n→ Пользовательские политики TLS для исодящей почты будут проигнорированы и будут использовать политику TLS для записей используемых сдесь.<br>\r\n→ Протокол для доставки всегда \"smtp:\".<br>\r\n→ Адреса соответствующие \"/localhost$/\" всегда будут доставлены \"local:\", следовательно политика \"*\" не распостраняется на них.<br>\r\n→ Чтобы определить учетные данные для следующего узла \"[host]:25\", Postfix <b>всегда</b> ищет данные для \"host\" перед тем как искать \"[host]:25\". Такое поведение делает невозможным использование \"host\" and \"[host]:25\" одновременно.",
+        "transports_hint": "→ Записи в transport map <b>отменяют</b> sender-dependent transport map</b>.<br>\r\n→ Пользовательские политики TLS для исходящей почты будут проигнорированы и будут использовать политику TLS для записей используемых здесь.<br>\r\n→ Протокол для доставки всегда \"smtp:\".<br>\r\n→ Адреса соответствующие \"/localhost$/\" всегда будут доставлены \"local:\", следовательно политика \"*\" не распространяется на них.<br>\r\n→ Чтобы определить учётные данные для следующего узла \"[host]:25\", Postfix <b>всегда</b> ищет данные для \"host\" перед тем как искать \"[host]:25\". Такое поведение делает невозможным использование \"host\" and \"[host]:25\" одновременно.",
+        "transport_test_rcpt_info": "→ Используйте null@hosted.mailcow.de для тестирования пересылки на внешний пункт назначения.",
         "ui_footer": "Добавить нижний колонтитул (использование HTML разрешено)",
         "ui_header_announcement": "Объявления",
         "ui_header_announcement_active": "Активировать объявление",
@@ -312,9 +333,9 @@
         "ui_header_announcement_type_danger": "Очень важное",
         "ui_header_announcement_type_info": "Инфо",
         "ui_header_announcement_type_warning": "Важное",
-        "ui_texts": "UI найменования и описания",
+        "ui_texts": "UI наименования и описания",
         "unban_pending": "ожидает разблокировки",
-        "unchanged_if_empty": "Если без изменений оставьте пустым",
+        "unchanged_if_empty": "Если без изменений, оставьте пустым",
         "upload": "Загрузить",
         "username": "Имя пользователя",
         "validate_license_now": "Получить лицензию на основе GUID с сервера лицензий",
@@ -322,7 +343,7 @@
         "yes": "&#10003;"
     },
     "danger": {
-        "access_denied": "Доступ запрещен или указаны неверные данные",
+        "access_denied": "Доступ запрещён, или указаны неверные данные",
         "alias_domain_invalid": "Недопустимый псевдоним домена",
         "alias_empty": "Псевдоним не может быть пустым",
         "alias_goto_identical": "Псевдоним и основной адрес не могут быть идентичными",
@@ -333,8 +354,8 @@
         "app_passwd_id_invalid": "Пароль приложения ID %s неверный",
         "bcc_empty": "Назначение BCC не может быть пустым",
         "bcc_exists": "Для типов %s уже существует карта BCC %s",
-        "bcc_must_be_email": "Назначение BCC %s является не валдиным адресом электронной почты",
-        "comment_too_long": "Комментарий слишком длинный, макс. 160 символов разрешено использовать.",
+        "bcc_must_be_email": "Назначение BCC %s не является правильным адресом электронной почты",
+        "comment_too_long": "Комментарий слишком длинный. Разрешено использовать максимум 160 символов.",
         "defquota_empty": "Квота по умолчанию не может быть 0.",
         "description_invalid": "Недопустимое описание ресурса %s",
         "dkim_domain_or_sel_exists": "Ключ DKIM для \"%s\" уже существует",
@@ -348,24 +369,25 @@
         "extra_acl_invalid": "Адрес внешнего отправителя \"%s\" не валидный.",
         "extra_acl_invalid_domain": "Адрес внешнего отправителя \"%s\" не валидный домен.",
         "file_open_error": "Файл не может быть открыт на запись",
-        "filter_type": "Не верный тип фильтра",
+        "filter_type": "Неверный тип фильтра",
         "from_invalid": "Отправитель не может быть пустым",
         "global_filter_write_error": "Ошибка записи фильтра в файл: %s",
         "global_map_invalid": "Идентификатор глобального правила %s не валидный",
         "global_map_write_error": "Не удалось создать глобальное правило ID %s: %s",
+        "xmpp_map_write_error": "Ошибка записи настроек XMPP: %s",
         "goto_empty": "Псевдоним должен содержать по крайней мере один валидный адрес владельца",
         "goto_invalid": "Недопустимый основной адрес %s",
-        "ham_learn_error": "Ошибка при обучении хам фильтра: %s",
+        "ham_learn_error": "Ошибка при обучении &laquo;ham&raquo; фильтра: %s",
         "imagick_exception": "Ошибка в Imagick при чтении изображения",
         "img_invalid": "Невозможно проверить файл изображения",
         "img_tmp_missing": "Невозможно проверить файл изображения: временный файл не найден",
-        "invalid_bcc_map_type": "Не верный тип правила BBC",
-        "invalid_destination": "Назначение \"%s\" указано не верно",
-        "invalid_filter_type": "Не верный тип фильтра",
-        "invalid_host": "Хост %s указан не верно",
-        "invalid_mime_type": "Не верный mime type",
-        "invalid_nexthop": "Формат следующего хоста не верен",
-        "invalid_nexthop_authenticated": "Cледующий хост существует с разными данными авторизации, пожалуйста, обновите существующие данные авторизации сначала для этого хоста.",
+        "invalid_bcc_map_type": "Неверный тип правила BBC",
+        "invalid_destination": "Назначение \"%s\" указано неверно",
+        "invalid_filter_type": "Неверный тип фильтра",
+        "invalid_host": "Хост %s указан неверно",
+        "invalid_mime_type": "Неверный mime type",
+        "invalid_nexthop": "Формат следующего хоста неверен",
+        "invalid_nexthop_authenticated": "Следующий хост существует с разными данными авторизации, пожалуйста, обновите существующие данные авторизации сначала для этого хоста.",
         "invalid_recipient_map_new": "Новый получатель: %s не валидный",
         "invalid_recipient_map_old": "Первоначальный получатель: %s не валидный",
         "ip_list_empty": "Список разрешенных IP адресов не может быть пустым",
@@ -384,9 +406,10 @@
         "map_content_empty": "Содержание правила не может быть пустым",
         "max_alias_exceeded": "Превышено максимальное количество псевдонимов",
         "max_mailbox_exceeded": "Превышено максимальное количество почтовых ящиков (%d из %d)",
-        "max_quota_in_use": "Квота почтового аккаунта должна быть больше или равена %d MiB",
+        "max_quota_in_use": "Квота почтового аккаунта должна быть больше или равна %d MiB",
         "maxquota_empty": "Максимальная квота почтового аккаунта не должна быть 0.",
         "mysql_error": "Ошибка в MySQL: %s",
+        "nginx_reload_failed": "Обновление конфигурации Nginx не удалось: %s",
         "network_host_invalid": "Сеть или хост: %s не валидный",
         "next_hop_interferes": "%s пересекается с %s",
         "next_hop_interferes_any": "Существующий хост пересекается с %s",
@@ -407,7 +430,7 @@
         "redis_error": "Ошибка в Redis: %s",
         "relayhost_invalid": "Правило %s не валидное",
         "release_send_failed": "Сообщение не может быть восстановлено: %s",
-        "reset_f2b_regex": "Сброс фильтров не был выполнен за отведеный промежуток времени, пожалуйста, повторите попытку или подождите еще несколько секунд и перезагрузите веб страницу.",
+        "reset_f2b_regex": "Сброс фильтров не был выполнен за отведённый промежуток времени, пожалуйста, повторите попытку или подождите еще несколько секунд и перезагрузите веб страницу.",
         "resource_invalid": "Недопустимое имя ресурса",
         "rl_timeframe": "Не верный временной интервал для лимита отправки",
         "rspamd_ui_pw_length": "Длина пароля должна составлять не менее 6 символов для Rspamd UI",
@@ -433,11 +456,13 @@
         "fido2_verification_failed": "Ошибка валидации FIDO2: %s",
         "unknown": "Произошла неизвестная ошибка",
         "unknown_tfa_method": "Неизвестный метод TFA",
-        "unlimited_quota_acl": "Неограниченная квота запрещена политкой доступа",
+        "unlimited_quota_acl": "Неограниченная квота запрещена политикой доступа",
         "username_invalid": "Имя пользователя %s нельзя использовать",
         "validity_missing": "Пожалуйста, назначьте срок действия",
         "value_missing": "Пожалуйста заполните все поля",
-        "yotp_verification_failed": "Ошибка валидации Yubico OTP: %s"
+        "yotp_verification_failed": "Ошибка валидации Yubico OTP: %s",
+        "xmpp_restart_failed": "Перезагрузка XMPP не удалась",
+        "xmpp_reload_failed": "Обновление конфигурации Dovecot не удалось"
     },
     "debug": {
         "chart_this_server": "Диаграмма (текущий сервер)",
@@ -447,49 +472,54 @@
         "history_all_servers": "История (все серверы)",
         "in_memory_logs": "Журналы контейнеров",
         "jvm_memory_solr": "Использовано оперативной памяти JVM",
-        "log_info": "<p><b>Журналы контейнеров</b> mailcow сохраняются в Redis, и раз в минуту строки журнала за приделами <code>LOG_LINES (%d)</code> удаляются, чтобы уменьшить нагрузку на сервер.\r\n  <br> Сами журналы контейнеров не сохраняются после перезагрузка контейнера. Все контейнеры дополнительно пишут логи в службу Docker и следовательно используют драйвер логирования по умолчанию. Журналы контейнеров предусмотрены только для отладки мелких проблем. Для других задач, пожалуйста, настройте драйвер логирования Docker под свои задачи.</p>\r\n  <p><b>Внешние журналы</b> собираются через API приложений.</p>\r\n  <p><b>Статические журналы</b> - это в основном журналы активности, которые не записываются в Dockerd, но все равно должны быть постоянными (за исключением журналов API).</p>",
+        "log_info": "<p><b>Журналы контейнеров</b> mailcow сохраняются в Redis, и раз в минуту строки журнала за пределами <code>LOG_LINES (%d)</code> удаляются, чтобы уменьшить нагрузку на сервер.\r\n  <br>Сами журналы контейнеров не сохраняются после перезагрузки контейнера. Все контейнеры дополнительно пишут логи в службу Docker, и, следовательно, используют драйвер логирования по умолчанию. Журналы контейнеров предусмотрены только для отладки мелких проблем. Для других задач, пожалуйста, настройте драйвер логирования Docker самостоятельно.</p>\r\n  <p><b>Внешние журналы</b> собираются через API приложений.</p>\r\n  <p><b>Статические журналы</b> &ndash; это, в основном, журналы активности, которые не записываются в Dockerd, но все равно должны быть постоянными (за исключением журналов API).</p>",
         "logs": "Журналы",
         "restart_container": "Перезапустить",
-        "solr_dead": "Solr не запущен. Если вы включили Solf в файле настроек <code>mailcow.conf</code> и это сообщение отображает более получаса, скорее всего Solr сломан.",
-        "solr_docs": "Проиндексировано обьектов",
-        "solr_last_modified": "Последние изменения",
-        "solr_size": "Индексы занимают",
-        "solr_started_at": "Запущен",
+        "solr_dead": "Solr не запущен. Если вы включили Solf в файле настроек <code>mailcow.conf</code> и это сообщение отображается более получаса, скорее всего Solr сломан.",
+        "xmpp_dead": "XMPP не запущен. Если вы включили XMPP в настройках домена и это сообщение отображается более получаса, скорее всего XMPP сломан.",
+        "docs": "Проиндексировано объектов",
+        "last_modified": "Последние изменения",
+        "online_users": "Подключено пользователей",
+        "size": "Индексы занимают",
+        "started_at": "Запущен",
         "solr_status": "Состояние Solr",
-        "solr_uptime": "Время работы",
+        "uptime": "Время работы",
         "started_on": "Запущен в",
         "static_logs": "Статические журналы",
-        "system_containers": "Система и контейнеры"
+        "system_containers": "Система и контейнеры",
+        "xmpp_status": "Статус XMPP"
     },
     "diagnostics": {
         "cname_from_a": "Значение, полученное из записи A/AAAA. Это поддерживается до тех пор, пока запись указывает на правильный ресурс.",
         "dns_records": "Записи DNS",
         "dns_records_24hours": "Обратите внимание, что для внесения изменений в DNS может потребоваться до 24 часов, чтобы правильно отобразить их текущее состояние на этой странице. Эта страница предназначен для того, чтобы вы могли легко увидеть, как настроить записи DNS и проверить, все ли записи правильно занесены в DNS.",
+        "dns_records_docs": "Пожалуйста, ознакомьтесь с <a target=\"_blank\" href=\"https://mailcow.github.io/mailcow-dockerized-docs/prerequisite-dns/\">документацией</a>.",
         "dns_records_data": "Значение",
         "dns_records_name": "Название",
         "dns_records_status": "Статус",
         "dns_records_type": "Тип",
-        "optional": "Эта запись не обезательна."
+        "optional": "Эта запись не обязательна."
     },
     "edit": {
         "active": "Активный",
+        "admin": "Изменение администратора",
         "advanced_settings": "Расширенные настройки",
         "alias": "Изменить псевдоним",
         "allow_from_smtp": "Разрешить использование <b>SMTP</b> только для этих IP",
-        "allow_from_smtp_info": "Укажите IPv4/IPv6 адреса и/или подсети.<br>Оставьте поле пустым, чтобы разрешить отправитвку с любых адресов.",
-        "allowed_protocols": "Разрешенные протоколы",
+        "allow_from_smtp_info": "Укажите IPv4/IPv6 адреса и/или подсети.<br>Оставьте поле пустым, чтобы разрешить отправку с любых адресов.",
+        "allowed_protocols": "Разрешённые протоколы",
         "app_name": "Название приложения",
         "app_passwd": "Пароль приложения",
         "automap": "Автоматическое слияние папок (\"Sent items\", \"Sent\" => \"Sent\" etc.)",
         "backup_mx_options": "Параметры резервного копирования MX",
-        "bcc_dest_format": "Назначением для правила BBC долженен быть единственным действительный адресом электронной почты.",
+        "bcc_dest_format": "Назначением для правила BBC должен быть единственный действительный адрес электронной почты.",
         "client_id": "ID клиента",
         "client_secret": "Секретный ключ пользователя",
-        "comment_info": "Приватный комментарий не виден пользователям, а публичный - отображается рядом с певдонимом в личном кабинете пользователя",
+        "comment_info": "Приватный комментарий не виден пользователям, а публичный - отображается рядом с псевдонимом в личном кабинете пользователя",
         "delete1": "Удаление из источника после завершения",
         "delete2": "Удаление писем по месту назначения, которые не находятся на исходном",
         "delete2duplicates": "Удаление дубликатов по назначению",
-        "delete_ays": "Пожалуйста, подтвердите удалитение",
+        "delete_ays": "Пожалуйста, подтвердите удаление",
         "description": "Описание",
         "disable_login": "Вход в систему запрещен",
         "domain": "Изменение домена",
@@ -501,12 +531,21 @@
         "encryption": "Шифрование",
         "exclude": "Исключить объекты (regex)",
         "extended_sender_acl": "Внешние адреса почты",
-        "extended_sender_acl_info": "Для внешних доменов должен быть импортирован или сгенерирован доменный ключ DKIM с соответствующей записью TXT в домене если внешний домен использует DMARC.<br>\r\n  Не забудьте добавить этот сервер к соответствующей записи SPF TXT внешнего домена.<br>\r\n  Добавление домена из списка внешних адресов в mailcow автоматически удалит соответствующие записи из внешних адресов пользователей.<br>\r\n  Что бы разрешить пользователю отправку от имени *@domain.tld, укажите @domain.tld.",
+        "extended_sender_acl_info": "Для внешних доменов должен быть импортирован или сгенерирован доменный ключ DKIM с соответствующей записью TXT в домене, если внешний домен использует DMARC.<br>\r\n  Не забудьте добавить этот сервер к соответствующей записи SPF TXT внешнего домена.<br>\r\n  Добавление домена из списка внешних адресов в mailcow автоматически удалит соответствующие записи из внешних адресов пользователей.<br>\r\n  Чтобы разрешить пользователю отправку от имени *@domain.tld, укажите @domain.tld.",
         "force_pw_update": "Требовать смены пароля при следующем входе в систему",
         "force_pw_update_info": "Пользователь должен будет войти в %s и сменить свой пароль. mailcow OAuth2, SOGo, EAS, IMAP/POP3 и SMTP будут не доступны до смены пароля.",
         "full_name": "Полное имя",
         "gal": "GAL - Глобальная адресная книга",
-        "gal_info": "GAL содержит все объекты домена и не подлежит редактированию. Информация о занятости в SOGo будет отсутствовать для домена, если эта функция не будет включена! <b>Требуется перезапустить SOGo, чтобы изменения применились.</b>",
+        "gal_info": "GAL содержит все объекты домена и не подлежит редактированию. Информация о занятости в SOGo будет отсутствовать для домена, если данная функция будет отключена! <b>Требуется перезапустить SOGo, чтобы применить изменения.</b>",
+        "xmpp": "Включить поддержку XMPP для этого домена",
+        "xmpp_prefix": "Префикс домена XMPP",
+        "xmpp_prefix_info": "Для получения SSL сертификатов для XMPP сервера необходимо настроить дополнительные CNAME DNS записи <b>im</b>.example.org и <b>*.im</b>.example.org, указывающие на <b>%s</b>. Пожалуйста, посетите страницу проверки DNS записей домена после включения XMPP сервера в mailcow UI.",
+        "xmpp_info": "Эта опция добавит функциональность чата для этого домена.",
+        "xmpp_access": "Пользователь XMPP",
+        "xmpp_access_info": "XMPP должен быть включен для этого домена.",
+        "xmpp_admin": "Администратор XMPP",
+        "xmpp_admin_info": "Повысить пользователя XMPP до <span class=\"text-danger\">администратора домена</span>.",
+        "xmpp_example_jid": "<b>Пример JID</b> (используя пароль почтового аккаунта)",
         "generate": "сгенерировать",
         "grant_types": "Разрешено типы",
         "hostname": "Имя хоста",
@@ -532,12 +571,13 @@
         "pushover_info": "Настройки Push-уведомления будут применяться ко всей почте <b>%s</b> (за исключением спама) включая псевдонимы (личные, общие и тегированные).",
         "pushover_only_x_prio": "Получать уведомления только об письмах с высоким приоритетом [<code>X-Priority: 1</code>]",
         "pushover_sender_array": "Получать уведомления от списка адресов электронной почты <small>(envelop-from разделенные запятыми)</small>:",
-        "pushover_sender_regex": "Получать уведомления от отправителей удовлетворяющих regex-выражение:",
+        "pushover_sender_regex": "Получать уведомления от отправителей, удовлетворяющих regex-выражению:",
         "pushover_text": "Текст уведомления",
         "pushover_title": "Заголовок уведомления",
-        "pushover_vars": "Когда фильтрация по отправителю не определена, уведомения будут доставлятся от всех отправителей.<br>Можно использовать обычный фильтр по отправителю и разширенный regex-фильтр, а так же оба сразу.<br>Пожалуйста, ознакомьтесь с <a href=\"https://pushover.net/privacy\">Pushover Privacy Policy</a> перед использованием шаблонов для текста и заголовка",
+        "pushover_vars": "Когда фильтрация по отправителю не определена, уведомления будут доставлятся от всех отправителей.<br>Можно использовать обычный фильтр по отправителю и расширенный regex-фильтр, а также оба сразу.<br>Пожалуйста, ознакомьтесь с <a href=\"https://pushover.net/privacy\">Pushover Privacy Policy</a> перед использованием шаблонов для текста и заголовка",
         "pushover_verify": "Проверить доступ",
         "quota_mb": "Квота (MiB)",
+        "ratelimit": "Лимит отправки",
         "redirect_uri": "URL-адрес переадресация/обратный вызов",
         "relay_all": "Ретрансляция всех получателей",
         "relay_all_info": "↪<small>Если вы решите <b>не</b> ретранслировать всех получателей, вам нужно будет добавить (\"слепой\") почтовый аккаунт для каждого получателя, которого следует ретранслировать.</small>",
@@ -551,20 +591,21 @@
         "scope": "Область",
         "sender_acl": "Разрешить отправлять письма от имени",
         "sender_acl_disabled": "<span class=\"label label-danger\">Проверка отправителя отключена</span>",
-        "sender_acl_info": "Учтите, что если пользователю почтового аккаунта A разрешено отправлять от имени пользователя B, адрес пользователя B автоматически не отобразится в списке \"Отправитель\" при написании писем в SOGo.<br>\r\n  Пользователь почтового аккаунта B должен создать делегирование в SOGo, чтобы пользователь почтового аккаунта A мог выбрать его адрес в качестве отправителя. Делегирование находится в меню (троеточие) справа от имени почтового аккаунта в окне почты SOGo. Это поведение не относится к псевдонимам.",
+        "sender_acl_info": "Учтите, что если пользователю почтового аккаунта A разрешено отправлять от имени пользователя B, то адрес пользователя B не отобразится автоматически в списке \"Отправитель\" при написании писем в SOGo.<br>\r\n  Пользователь почтового аккаунта B должен создать делегирование в SOGo, чтобы пользователь почтового аккаунта A мог выбрать его адрес в качестве отправителя. Делегирование находится в меню (троеточие) справа от имени почтового аккаунта в окне почты SOGo. Это поведение не относится к псевдонимам.",
         "sieve_desc": "Краткое описание",
         "sieve_type": "Тип фильтра",
         "skipcrossduplicates": "Пропускать повторяющиеся сообщения в папках",
         "sogo_access": "Предоставить доступ к SOGo",
         "sogo_access_info": "Этот параметр не влияет на доступ ко всем другим службам, в том числе на право удаления или изменение существующего профиля пользователя SOGo.",
         "sogo_visible": "Отображать псевдоним в SOGo",
-        "sogo_visible_info": "Влияет только на объекты, которые могут отображаться в SOGo (персональные или общие псевдонимы, указывающие как минимум на один локальный почтовый аккаунт). Учтите что если функция отключена, у пользователей не будет возможности выбрать адрес псевдонима в качестве отправителя в SOGo.",
+        "sogo_visible_info": "Влияет только на объекты, которые могут отображаться в SOGo (персональные или общие псевдонимы, указывающие как минимум на один локальный почтовый аккаунт). Учтите, что если функция отключена, у пользователей не будет возможности выбрать адрес псевдонима в качестве отправителя в SOGo.",
         "spam_alias": "Создать или изменить временные (спам) псевдонимы",
         "spam_policy": "Добавление или удаление элементов в белом/черном списке",
+        "spam_filter": "Спам фильтр",
         "spam_score": "Задать индивидуальное определение спама",
         "subfolder2": "Синхронизировать в подпапку<br><small>(пусто = в корень)</small>",
         "syncjob": "Изменить задание синхронизации",
-        "target_address": "Владельцы псевдонима <small>(разделенные запятыми)</small>",
+        "target_address": "Владельцы псевдонима, <small>(разделённые запятыми)</small>",
         "target_domain": "Целевой домен",
         "timeout1": "Тайм-аут для подключения к удаленному хосту",
         "timeout2": "Тайм-аут для подключения к локальному хосту",
@@ -578,15 +619,13 @@
         "confirm_delete": "Подтвердите удаление",
         "delete_now": "Удалить сейчас",
         "delete_these_items": "Пожалуйста, подтвердите свои изменения в следующих объектах:",
-        "hibp_nok": "Совпадание найдено! Это потенциально опасный пароль!",
+        "hibp_nok": "Найдено совпадение! Это потенциально опасный пароль!",
         "hibp_ok": "Совпадений не найдено.",
         "loading": "Пожалуйста, подождите...",
         "restart_container": "Перезапустить контейнер",
-        "restart_container_info": "<b>Важно:</b> полный перезапуск может занять некоторое время, пожалуйста, дождитесь его завершения - не обновляйте и не закрывайте страницу.",
+        "restart_container_info": "<b>Важно:</b> полный перезапуск может занять некоторое время, пожалуйста, дождитесь его завершения &ndash; не обновляйте и не закрывайте страницу.",
         "restart_now": "Перезапустить сейчас",
-        "restart_sogo": "Перезапустить SOGo",
-        "restart_sogo_info": "Некоторые операции, например при добавлении домена, требуют перезапустить SOGo, для вступления в силу внесенных изменений.<br><br><b>Важно:</b> Перезагрузка может занять некоторое время, дождитесь ее окончания.",
-        "restarting_container": "Перезапуск контейнера, это может занять какое то время..."
+        "restarting_container": "Перезапуск контейнера, это может занять какое-то время..."
     },
     "header": {
         "administration": "Настройка сервера",
@@ -619,6 +658,7 @@
         "active": "Активный",
         "add": "Добавить",
         "add_alias": "Добавить псевдоним",
+        "add_alias_expand": "Скопировать псевдонимы на псевдонимы домена",
         "add_bcc_entry": "Добавить правило BBC",
         "add_domain": "Добавить домен",
         "add_domain_alias": "Добавить псевдоним домена",
@@ -630,11 +670,11 @@
         "add_tls_policy_map": "Добавить политику TLS",
         "address_rewriting": "Перезапись адресов",
         "alias": "Псевдоним",
-        "alias_domain_alias_hint": "Псевдонимы <b>не</b> применяются к псевдонимам домена автоматически. Адрес псевдонима <code>my-alias@domain</code> <b>не</b> охватывает адрес <code>my-alias@alias-domain</code> (где \"alias-domain\" - воображаемый псевдоним домена для \"domain\").",
+        "alias_domain_alias_hint": "Псевдонимы <b>не</b> применяются к псевдонимам домена автоматически. Адрес псевдонима <code>my-alias@domain</code> <b>не</b> охватывает адрес <code>my-alias@alias-domain</code> (где \"alias-domain\" &ndash; воображаемый псевдоним домена для \"domain\").<br>Используйте кнопку <b>\"Скопировать псевдонимы на псевдонимы домена\"</b> чтобы добавить выбранные псевдонимы на все псевдонимы доменов.<br>Пожалуйста, используйте Sieve фильтры для перенаправления почты на внешние почтовые аккаунты (см. вкладку \"Фильтры\" или используйте SOGo -> Настройки -> Почта -> Пересылка).",
         "alias_domain_backupmx": "Псевдонимы домена не могут быть использованы для домена ретрансляции",
         "aliases": "Псевдонимы",
         "allow_from_smtp": "Разрешить использование <b>SMTP</b> только для этих IP",
-        "allow_from_smtp_info": "Укажите IPv4/IPv6 адреса и/или подсети.<br>Оставьте поле пустым, чтобы разрешить отправитвку с любых адресов.",
+        "allow_from_smtp_info": "Укажите IPv4/IPv6 адреса и/или подсети.<br>Оставьте поле пустым, чтобы разрешить отправку с любых адресов.",
         "allowed_protocols": "Разрешенные протоколы",
         "backup_mx": "Резервный MX",
         "bcc": "Правила BBC",
@@ -714,18 +754,17 @@
         "resources": "Ресурсы",
         "running": "В процессе выполнения",
         "set_postfilter": "Использовать как постфильтр",
-        "set_prefilter": "Использовать как предв. фильтр",
-        "sieve_info": "Вы можете сохранить несколько фильтров для каждого пользователя, но только один предварительный фильтр и один постфильтр могут быть активными одновременно.<br>\r\n Каждый фильтр будет обработан в описанном порядке. Не сломаный скрипт, не <code>keep;</code> не остановит обработку дальнейших скриптов.<br><br>Global sieve prefilter → Prefilter → User scripts → Postfilter → Global sieve postfilter",
+        "set_prefilter": "Использовать как предварительный фильтр",
+        "sieve_info": "Вы можете сохранить несколько фильтров для каждого пользователя, но только один предварительный фильтр и один постфильтр могут быть активными одновременно.<br>\r\n Каждый фильтр будет обработан в описанном порядке. Не сломанный скрипт, не <code>keep;</code> не остановит обработку дальнейших скриптов.<br><br>Global sieve prefilter → Prefilter → User scripts → Postfilter → Global sieve postfilter",
         "sieve_preset_1": "Discard mail with probable dangerous file types",
         "sieve_preset_2": "Always mark the e-mail of a specific sender as seen",
         "sieve_preset_3": "Discard silently, stop all further sieve processing",
         "sieve_preset_4": "File into INBOX, skip further processing by sieve filters",
         "sieve_preset_5": "Auto responder (vacation)",
-        "sieve_preset_6": "Reject mail with reponse",
+        "sieve_preset_6": "Reject mail with response",
         "sieve_preset_7": "Redirect and keep/drop",
         "sieve_preset_8": "Discard message sent to an alias address the sender is part of",
         "sieve_preset_header": "Пожалуйста, ознакомьтесь с примерами ниже. Для более подробной информации прочитайте <a href=\"https://en.wikipedia.org/wiki/Sieve_(mail_filtering_language)\" target=\"_blank\">Sieve Wikipedia</a>.",
-        "sogo_allow_admin_hint": "Административные логины SOGo доступны только для почтовых ящиков с существующим профилем SOGo. Пользователь должен был войти в SOGo хотя бы один раз.",
         "sogo_visible": "Отображать псевдоним в SOGo",
         "sogo_visible_n": "Не отображать псевдоним в SOGo",
         "sogo_visible_y": "Отображать псевдоним в SOGo",
@@ -737,17 +776,17 @@
         "table_size_show_n": "Отображать %s полей",
         "target_address": "Владельцы псевдонима",
         "target_domain": "Целевой домен",
-        "tls_enforce_in": "Принудительный TLS - входящие",
-        "tls_enforce_out": "Принудительный TLS - исходящие",
+        "tls_enforce_in": "Принудительный TLS (входящие)",
+        "tls_enforce_out": "Принудительный TLS (исходящие)",
         "tls_map_dest": "Назначение",
         "tls_map_dest_info": "пример: example.org, .example.org, [mail.example.org]:25",
         "tls_map_parameters": "Параметры",
         "tls_map_parameters_info": "Оставьте поле пустым или укажите параметры, на пример: protocols=!SSLv2 ciphers=medium exclude=3DES",
         "tls_map_policy": "Политика",
         "tls_policy_maps": "Правила TLS",
-        "tls_policy_maps_enforced_tls": "Для исходящих сообщений от пользователей с включенной принудительной политикой шифрования исходящих соеденений не описаные глобальной политикой,<br>\r\n будут применены значения по умолчанию, указанные в <code>smtp_tls_mandatory_protocols</code> и <code>smtp_tls_mandatory_ciphers</code>.",
-        "tls_policy_maps_info": "Глобальные политики переопределяют политики исходящих соеденений TLS, независимо от настроек принудительных политик TLS у пользователей.<br>\r\n  Пожалуйста, ознакомьтесь с <a href=\"http://www.postfix.org/postconf.5.html#smtp_tls_policy_maps\" target=\"_blank\">документацией \"smtp_tls_policy_maps\"</a> для дополнительной информации.",
-        "tls_policy_maps_long": "Переопределение правил для политик исходящих соеденений TLS",
+        "tls_policy_maps_enforced_tls": "Для исходящих сообщений от пользователей с включенной принудительной политикой шифрования исходящих соединений не описанные глобальной политикой,<br>\r\n будут применены значения по умолчанию, указанные в <code>smtp_tls_mandatory_protocols</code> и <code>smtp_tls_mandatory_ciphers</code>.",
+        "tls_policy_maps_info": "Глобальные политики переопределяют политики исходящих соединений TLS, независимо от настроек принудительных политик TLS у пользователей.<br>\r\n  Пожалуйста, ознакомьтесь с <a href=\"http://www.postfix.org/postconf.5.html#smtp_tls_policy_maps\" target=\"_blank\">документацией \"smtp_tls_policy_maps\"</a> для дополнительной информации.",
+        "tls_policy_maps_long": "Переопределение правил для политик исходящих соединений TLS",
         "toggle_all": "Выбрать все",
         "username": "Имя пользователя",
         "waiting": "Ожидание",
@@ -771,7 +810,8 @@
         "confirm_delete": "Подтвердите удаление этого элемента.",
         "danger": "Опасность",
         "deliver_inbox": "Освободить из карантина",
-        "disabled_by_config": "В текущей конфигурации системы функцию карантина отключена.",
+        "disabled_by_config": "В текущей конфигурации системы функция карантина отключена.",
+        "settings_info": "Максимальное количество элементов, которые будут помещены в карантин: %s<br>Максимальный размер электронного письма: %s MiB",
         "download_eml": "Скачать (.eml)",
         "empty": "Пусто",
         "high_danger": "Высокая",
@@ -784,7 +824,7 @@
         "notified": "Увед.",
         "qhandler_success": "Запрос успешно отправлен в систему. Теперь вы можете закрыть окно.",
         "qid": "Rspamd QID",
-        "qinfo": "Карантин сохраняет входящие сообщения класифицированные как нежелательные в базу данных.\r\n  <br>Отправители писем которые помечены как отвергнутые будут уверены что их письма <b>не</b> были доставлены Вам.\r\n  <br>\"Освободить из карантина\" изучит сообщение как хам по теореме Байеса и доставит его вам в Inbox.\r\n  <br>\"Запомнить как спам и удалить\" изучит сообщение как спам по теореме Байеса, а также вычислит нечеткие хэши, чтобы лучше блокировать подобные сообщения в дальнейшем.\r\n  <br>Учтите, что в зависимости от технических характеристик вашей системы, изучение большого количества сообщений может занять много времени.",
+        "qinfo": "Карантин сохраняет входящие сообщения, классифицированные как нежелательные, в базу данных.\r\n  <br>Отправители писем, которые помечены как отвергнутые, будут уверены что их письма <b>не</b> были доставлены вам.\r\n  <br>\"Освободить из карантина\" изучит сообщение как &laquo;ham&raquo; по теореме Байеса и доставит его вам в Inbox.\r\n  <br>\"Запомнить как спам и удалить\" изучит сообщение как спам по теореме Байеса, а также вычислит нечёткие хэши, чтобы лучше блокировать подобные сообщения в дальнейшем.\r\n  <br>Учтите, что в зависимости от технических характеристик вашей системы, изучение большого количества сообщений может занять много времени.",
         "qitem": "Обьект карантина",
         "quarantine": "Карантин",
         "quick_actions": "Действия",
@@ -802,7 +842,7 @@
         "sender": "Отправитель (SMTP)",
         "sender_header": "Отправитель (заголовок \"From\")",
         "type": "Тип",
-        "quick_release_link": "Ссылка для востановления",
+        "quick_release_link": "Ссылка для восстановления",
         "quick_delete_link": "Ссылка для удаления",
         "quick_info_link": "Ссылка на доп. информацию",
         "show_item": "Показать",
@@ -817,71 +857,73 @@
     },
     "start": {
         "help": "Справка",
-        "imap_smtp_server_auth_info": "Пожалуйста, используйте свой полный адрес электронной почты в формате <code>user@example.com</code> и PLAIN механизм авторизации.<br>\r\nВаши данные авторизации будут зашифрованы на уровне шифрования канала подключения к серверу, по этому убедитесь что вы используете надежное TLS подключение.",
-        "mailcow_apps_detail": "Используйте приложения для доступа к вашей почте, календарю, контактам и многое другое.",
-        "mailcow_panel_detail": "<b>Администраторы домена</b> могут создавать, изменять или удалять почтовые ящики и псевдонимы, измененять домены и смотреть информацию о своих назначенных доменов. <br><b>Пользователи почтовых ящиков</b> имеют возможность создавать временные псевдонимы (спам псевдонимы), менять свой пароль и настройки фильтра спама."
+        "imap_smtp_server_auth_info": "Пожалуйста, используйте свой полный адрес электронной почты в формате <code>user@example.com</code> и PLAIN механизм авторизации.<br>\r\nВаши данные авторизации будут зашифрованы на уровне шифрования канала подключения к серверу, поэтому убедитесь, что вы используете надежное TLS подключение.",
+        "mailcow_apps_detail": "Используйте приложения для доступа к вашей почте, календарю, контактам, и прочим функциям.",
+        "mailcow_panel_detail": "<b>Администраторы домена</b> могут создавать, изменять или удалять почтовые ящики и псевдонимы, измененять домены и смотреть информацию о своих назначенных доменах. <br><b>Пользователи почтовых ящиков</b> имеют возможность создавать временные псевдонимы (спам псевдонимы), менять свой пароль и настройки фильтра спама."
     },
     "success": {
         "acl_saved": "ACL для %s сохранено",
         "admin_added": "Администратор %s добавлен",
         "admin_api_modified": "Изменения в API сохранены",
         "admin_modified": "Изменения администратора сохранены",
-        "admin_removed": "Администратор %s удален",
+        "admin_removed": "Администратор %s удалён",
         "alias_added": "Псевдоним %s (%d) добавлен",
-        "alias_domain_removed": "Псевдоним домена %s удален",
+        "alias_domain_removed": "Псевдоним домена %s удалён",
         "alias_modified": "Изменения псевдонима %s сохранены",
-        "alias_removed": "Псевдоним %s удален",
+        "alias_removed": "Псевдоним %s удалён",
         "aliasd_added": "Добавлен псевдоним домена %s",
         "aliasd_modified": "Сохранить изменения псевдонима домена %s",
         "app_links": "Изменения ссылок на приложения сохранены",
         "app_passwd_added": "Добавлен новый пароль приложения",
-        "app_passwd_removed": "Пароль приложения ID %s удален",
+        "app_passwd_removed": "Пароль приложения ID %s удалён",
         "bcc_deleted": "Правила BCC удалены: %s",
         "bcc_edited": "Правило BCC %s отредактировано",
         "bcc_saved": "Правило BCC сохранено",
         "db_init_complete": "Инициализация базы данных завершена",
-        "delete_filter": "Фильтр ID %s удален",
+        "delete_filter": "Фильтр ID %s удалён",
         "delete_filters": "Фильтры удалены: %s",
         "deleted_syncjob": "Задание синхронизации ID %s удалено",
         "deleted_syncjobs": "Задания синхронизации удалены: %s",
-        "dkim_added": "DKIM ключ сохранен",
+        "dkim_added": "DKIM ключ сохранён",
         "dkim_duplicated": "DKIM ключи для домена %s были скопированы в %s",
-        "dkim_removed": "DKIM ключ %s удален",
+        "dkim_removed": "DKIM ключ %s удалён",
         "domain_added": "Добавлен домен %s",
         "domain_admin_added": "Администратор домена %s добавлен",
         "domain_admin_modified": "Сохранить изменения администратора домена %s",
-        "domain_admin_removed": "Администратор домена %s удален",
+        "domain_admin_removed": "Администратор домена %s удалён",
         "domain_modified": "Сохранить изменения домена %s",
-        "domain_removed": "Домен %s удален",
-        "dovecot_restart_success": "Dovecot перезапусщен успешно",
+        "domain_removed": "Домен %s удалён",
+        "dovecot_restart_success": "Dovecot перезапущен успешно",
         "eas_reset": "Кеш ActiveSync для пользователя %s был сброшен",
         "f2b_modified": "Изменения параметров Fail2ban сохранены",
         "forwarding_host_added": "Перенаправление узла %s добавлено",
         "forwarding_host_removed": "Перенаправление узла %s удалено",
         "global_filter_written": "Фильтр успешно записан в файл",
-        "hash_deleted": "Хеш удален",
-        "item_deleted": "Обьект %s удален",
+        "hash_deleted": "Хеш удалён",
+        "item_deleted": "Обьект %s удалён",
         "item_released": "Письмо %s восстановлено из карантина",
         "items_deleted": "Обьекты %s удалены",
         "items_released": "Выбраные письма восстановлены из карантина",
-        "learned_ham": "Письмо ID %s было изучено как хам",
-        "license_modified": "Изменения в лицензии были сохранены",
+        "learned_ham": "Письмо ID %s было изучено как &laquo;ham&raquo;",
+        "license_modified": "Изменения в лицензии сохранены",
         "logged_in_as": "Вы вошли как %s",
         "mailbox_added": "Почтовый аккаунт %s добавлен",
         "mailbox_modified": "Изменения почтового аккаунта %s сохранены",
-        "mailbox_removed": "Почтовый аккаунт %s удален",
+        "mailbox_removed": "Почтовый аккаунт %s удалён",
+        "nginx_reloaded": "Обновление конфигурация Nginx закончено",
         "object_modified": "Изменения объекта %s сохранены",
         "pushover_settings_edited": "Настройки сохранены, пожалуйста, выполните проверку доступа",
         "qlearn_spam": "Письмо ID %s было изучено как спам и удалено",
         "queue_command_success": "Команда выполнена успешно",
+        "password_policy_saved": "Политика паролей сохранена",
         "recipient_map_entry_deleted": "Правило перезаписи получателя ID %s было удалено",
         "recipient_map_entry_saved": "Правило перезаписи получателя \"%s\" было сохранено",
         "relayhost_added": "Промежуточный узел %s добавлен",
-        "relayhost_removed": "Промежуточный узел %s удален",
+        "relayhost_removed": "Промежуточный узел %s удалён",
         "reset_main_logo": "Восстановить логотип по умолчанию",
         "resource_added": "Ресурс %s добавлен",
         "resource_modified": "Изменения почтового аккаунта %s сохранены",
-        "resource_removed": "Ресурс %s удален",
+        "resource_removed": "Ресурс %s удалён",
         "rl_saved": "Лимиты для %s сохранены",
         "rspamd_ui_pw_set": "Пароль для Rspamd успешно установлен",
         "saved_settings": "Настройки сохранены",
@@ -895,7 +937,10 @@
         "verified_totp_login": "Авторизация TOTP пройдена",
         "verified_u2f_login": "Авторизация U2F пройдена",
         "verified_fido2_login": "Авторизация FIDO2 пройдена",
-        "verified_yotp_login": "Авторизация Yubico OTP пройдена"
+        "verified_yotp_login": "Авторизация Yubico OTP пройдена",
+        "xmpp_restarted": "Сервис XMPP перезагружен",
+        "xmpp_reloaded": "Обновление конфигурация XMPP закончено",
+        "xmpp_maps_updated": "Настройки XMPP обновлены"
     },
     "tfa": {
         "api_register": "%s использует Yubico Cloud API. Пожалуйста, получите ключ API для вашего ключа <a href=\"https://upgrade.yubico.com/getapikey/\" target=\"_blank\">здесь</a>",
@@ -925,7 +970,7 @@
     "fido2": {
         "set_fn": "Укажите понятное название",
         "fn": "Название",
-        "rename": "перейменовать",
+        "rename": "Переименовать",
         "confirm": "Подтвердить",
         "register_status": "Статус регистрации",
         "known_ids": "Известные ID",
@@ -963,11 +1008,11 @@
         "create_syncjob": "Создание нового задания синхронизации",
         "daily": "Раз в день",
         "day": "день",
-        "delete_ays": "Пожалуйста, подтвердите удалитение",
+        "delete_ays": "Пожалуйста, подтвердите удаление",
         "direct_aliases": "Личные псевдонимы",
-        "direct_aliases_desc": "На адреса с прямым псевдонимом распостраняются фильтры нежелательной почты и параметры политики TLS.",
+        "direct_aliases_desc": "На адреса с прямым псевдонимом распространяются фильтры нежелательной почты и параметры политики TLS.",
         "eas_reset": "Сбросить кеш ActiveSync устройств",
-        "eas_reset_help": "Во многих случаях сброс кеша устройств помогает восстановить поврежденный профиль ActiveSync.<br><b>Внимание:</b> все письма, календари и контакты будут загружены заново на все Ваши устройства!",
+        "eas_reset_help": "Во многих случаях сброс кеша устройств помогает восстановить повреждённый профиль ActiveSync.<br><b>Внимание:</b> все письма, календари и контакты будут загружены заново на все ваши устройства!",
         "eas_reset_now": "Сбросить кеш сейчас",
         "edit": "Изменить",
         "email": "Почта",
@@ -990,50 +1035,49 @@
         "messages": "письма",
         "never": "Никогда",
         "new_password": "Новый пароль",
-        "new_password_description": "Минимальные требование: 6 символов, включая буквы и цифры. Администратор мог изменить данную политику.",
         "new_password_repeat": "Подтверждение пароля (повтор)",
-        "no_active_filter": "Активированые фильтры отсутствуют",
+        "no_active_filter": "Активированные фильтры отсутствуют",
         "no_last_login": "Информация о последнем входе в пользовательский интерфейс отсутствует",
         "no_record": "Записи отсутствуют",
         "password": "Пароль",
         "password_now": "Текущий пароль (подтверждение изменения)",
         "password_repeat": "Подтверждение пароля (повтор)",
         "pushover_evaluate_x_prio": "Установить высокий приоритет уведомлений для писем с высоким приоритетом [<code>X-Priority: 1</code>]",
-        "pushover_info": "Настройки Push-уведомления будут применяться ко всей почте <b>%s</b> (за исключением спама) включая псевдонимы (личные, общие и тегированные).",
-        "pushover_only_x_prio": "Получать уведомления только об письмах с высоким приоритетом [<code>X-Priority: 1</code>]",
-        "pushover_sender_array": "Получать уведомления от списка адресов электронной почты <small>(envelop-from разделенные запятыми)</small>:",
-        "pushover_sender_regex": "Получать уведомления от отправителей удовлетворяющих regex-выражение:",
+        "pushover_info": "Настройки Push-уведомления будут применяться ко всей почте <b>%s</b> (за исключением спама), включая псевдонимы (личные, общие и тегированные).",
+        "pushover_only_x_prio": "Получать уведомления только о письмах с высоким приоритетом [<code>X-Priority: 1</code>]",
+        "pushover_sender_array": "Получать уведомления от списка адресов электронной почты <small>(envelop-from, разделённые запятыми)</small>:",
+        "pushover_sender_regex": "Получать уведомления от отправителей, удовлетворяющих regex-выражению:",
         "pushover_text": "Текст уведомления",
         "pushover_title": "Заголовок уведомления",
-        "pushover_vars": "Когда фильтрация по отправителю не определена, уведомения будут доставлятся от всех отправителей.<br>Можно использовать обычный фильтр по отправителю и разширенный regex-фильтр, а так же оба сразу.<br>Пожалуйста, ознакомьтесь с <a href=\"https://pushover.net/privacy\">Pushover Privacy Policy</a> перед использованием шаблонов для текста и заголовка",
+        "pushover_vars": "Когда фильтрация по отправителю не определена, уведомения будут доставлятся от всех отправителей.<br>Можно использовать обычный фильтр по отправителю и расширенный regex-фильтр, а также оба сразу.<br>Пожалуйста, ознакомьтесь с <a href=\"https://pushover.net/privacy\">Pushover Privacy Policy</a> перед использованием шаблонов для текста и заголовка",
         "pushover_verify": "Проверить доступ",
         "q_add_header": "Нежелательная почта",
         "q_all": "Все категории",
         "q_reject": "Отклонённая почта",
         "quarantine_notification": "Уведомления о спаме",
         "quarantine_category": "Категория уведомлений о спаме",
-        "quarantine_notification_info": "После того, как уведомление будет отправлено, элементы будут помечены как \"уведомленные\", и дальнейшие уведомления для этого сообщения отправляться не будут.",
-        "quarantine_category_info": "Категория \"Отклонённая почта\" включает в себя почту, которая была <code>отклонена</code>, тогда как \"Нежелательная почта\" будет уведомлять пользователя только о письмах, которые были помещены в папку <code>Junk</code>. Для того что бы получать уведомления об всех категориях спама выберите опцию \"Все категории\".",
+        "quarantine_notification_info": "После того, как уведомление будет отправлено, элементы будут помечены как \"уведомлённые\", и дальнейшие уведомления для этого сообщения отправляться не будут.",
+        "quarantine_category_info": "Категория \"Отклонённая почта\" включает в себя почту, которая была <code>отклонена</code>, тогда как \"Нежелательная почта\" содержит письма, которые были помещены в папку <code>Junk</code>. Для того, чтобы получать уведомления обо всех категориях спама, выберите опцию \"Все категории\".",
         "remove": "Удалить",
         "running": "В процессе выполнения",
         "save": "Сохранить изменения",
         "save_changes": "Сохранить изменения",
         "sender_acl_disabled": "<span class=\"label label-danger\">Проверка отправителя отключена</span>",
         "shared_aliases": "Общие псевдонимы",
-        "shared_aliases_desc": "На общие псевдонимы не влияют пользовательские настройки, такие как фильтр нежелательной почты или политика шифрования. Соответствующие фильтры нежелательной почты могут быть созданы только администратором в рамках политики домена.",
+        "shared_aliases_desc": "На общие псевдонимы не влияют пользовательские настройки, такие как фильтр нежелательной почты, или политика шифрования. Соответствующие фильтры нежелательной почты могут быть созданы только администратором в рамках политики домена.",
         "show_sieve_filters": "Показать включенные фильтры sieve",
         "sogo_profile_reset": "Сбросить профиль SOGo",
-        "sogo_profile_reset_help": "<b>Внимание:</b> это удалит настройки профиля SOGo вместе с <b>всеми контакты, календарями и фильтрами безвозвратно</b>.",
+        "sogo_profile_reset_help": "<b>Внимание:</b> это удалит настройки профиля SOGo вместе с <b>всеми контактами, календарями и фильтрами безвозвратно</b>.",
         "sogo_profile_reset_now": "Сбросить профиль сейчас",
         "spam_aliases": "Временные псевдонимы электронной почты",
         "spam_score_reset": "Сброс на настройки по умолчанию",
-        "spamfilter": "Фильтр спама",
+        "spamfilter": "Спам фильтр",
         "spamfilter_behavior": "Фильтрация спама",
-        "spamfilter_bl": "Черный список",
-        "spamfilter_bl_desc": "<b>Все</b> письма полученые от адресов электронной почты добавленных в черный список будут отклонены и <b>не</b> будут скопированы в карантин. Использование <code>*</code> разрешено. Фильтр применяется только к личным псевдонимам (с одним получателем), исключая catch-all псевдонимы и сам почтовый аккаунт.",
+        "spamfilter_bl": "Чёрный список",
+        "spamfilter_bl_desc": "<b>Все</b> письма, полученные от адресов электронной почты, добавленных в чёрный список, будут отклонены и <b>не</b> будут скопированы в карантин. Использование <code>*</code> разрешено. Фильтр применяется только к личным псевдонимам (с одним получателем), исключая catch-all псевдонимы и сам почтовый аккаунт.",
         "spamfilter_default_score": "Значения по умолчанию",
-        "spamfilter_green": "Зеленый: эти письма не являются спамом",
-        "spamfilter_hint": "Первое значение отображает низкую оценку спама, второе - высокую. <br />Заметка: пользователи POP3 должны использовать настройку 15:15 по умолчанию, что бы отключить попадание потенциального спама в \"Спам\" так как POP3 скачивает только содержимое папки \"Входящие\"",
+        "spamfilter_green": "Зелёный: эти письма не являются спамом",
+        "spamfilter_hint": "Первое значение отображает низкую оценку спама, второе &ndash; высокую. <br />Заметка: пользователи POP3 должны использовать настройку 15:15 по умолчанию, чтобы отключить попадание потенциального спама в \"Спам\", так как POP3 скачивает только содержимое папки \"Входящие\"",
         "spamfilter_red": "Красный: эти письма являются спамом и будут помещены в карантин, отправитель будет уведомлен об отказе доставки его письма, потому что оно не прошло спам-фильтр",
         "spamfilter_table_action": "Действия",
         "spamfilter_table_add": "Добавить элемент",
@@ -1042,8 +1086,8 @@
         "spamfilter_table_remove": "удалить",
         "spamfilter_table_rule": "Правило",
         "spamfilter_wl": "Белый список",
-        "spamfilter_wl_desc": "Белый список адресов электронной почты, позволяет <b>никогда</b> не классифицировать все полученные письма с указанных адресов как спам. Можно добавлять маски адресов. Фильтр применяется только к личным псевдонимам (с одним получателем), исключая catch-all псевдонимы и сам почтовый аккаунт.",
-        "spamfilter_yellow": "Желтый: это письма могут быть спамом, будут помечены как потенциальный спам и перемещены в папку \"Спам\"",
+        "spamfilter_wl_desc": "Белый список адресов электронной почты позволяет <b>никогда</b> не классифицировать все полученные письма с указанных адресов как спам. Можно добавлять маски адресов. Фильтр применяется только к личным псевдонимам (с одним получателем), исключая catch-all псевдонимы и сам почтовый аккаунт.",
+        "spamfilter_yellow": "Жёлтый: это письма могут быть спамом, будут помечены как потенциальный спам и перемещены в папку \"Спам\"",
         "status": "Статус",
         "sync_jobs": "Задания синхронизации",
         "tag_handling": "Обработка тегированной почты",
@@ -1054,10 +1098,10 @@
         "tag_in_subject": "Добавить к теме письма",
         "text": "Текст",
         "title": "Заголовок",
-        "tls_enforce_in": "Принудительный TLS - входящие",
-        "tls_enforce_out": "Принудительный TLS - исходящие",
+        "tls_enforce_in": "Принудительный TLS (входящие)",
+        "tls_enforce_out": "Принудительный TLS (исходящие)",
         "tls_policy": "Политика шифрования",
-        "tls_policy_warning": "<strong>Предупреждение:</strong> Если Вы включите принудетельное шифрованние почты, вы можете столкнутся с потерей писем.<br>Сообщения, которые не соответствуют политике, будут отбрасыватся с сообщением о серьезном сбое почтовым сервером.<br>Этот параметр применяется к вашему основному адресу электронной почты (логину), всем личным псевдонимам и псевдонимам доменов. Подразумеваются только псевдонимы <b>с одним почтовым ящиком</b> как получатель.",
+        "tls_policy_warning": "<strong>Предупреждение:</strong> Если вы включите принудительное шифрованние почты, вы можете столкнуться с потерей писем.<br>Сообщения, которые не соответствуют политике, будут отбрасываться с сообщением почтовым сервером о серьёзном сбое.<br>Этот параметр применяется к вашему основному адресу электронной почты (логину), всем личным псевдонимам и псевдонимам доменов. Подразумеваются только псевдонимы <b>с одним почтовым ящиком</b>, как получатель.",
         "user_settings": "Настройки пользователя",
         "username": "Имя пользователя",
         "verify": "Проверить",
@@ -1067,14 +1111,15 @@
         "weeks": "недели"
     },
     "warning": {
-        "cannot_delete_self": "Невозможно удалить пользователя, Вы сейчас его используете",
+        "cannot_delete_self": "Вы не можете удалить сами себя",
         "domain_added_sogo_failed": "Домен был добавлен, но перезагрузить SOGo не удалось, пожалуйста, проверьте журналы сервера.",
         "dovecot_restart_failed": "Перезагрузка Dovecot не удалась, пожалуйста, проверьте журналы сервера.",
-        "fuzzy_learn_error": "Ошибка сохранения нечеткого хэша: %s",
-        "hash_not_found": "Хеш не найден или уже удален",
-        "ip_invalid": "Пропущен не верный IP: %s",
+        "fuzzy_learn_error": "Ошибка сохранения нечёткого хэша: %s",
+        "hash_not_found": "Хеш не найден или уже удалён",
+        "ip_invalid": "Пропущен неверный IP: %s",
+        "is_not_primary_alias": "Пропущен неосновной псевдоним %s",
         "no_active_admin": "Невозможно деактивировать последнего активного администратора",
-        "quota_exceeded_scope": "Квота домена превышена: только почтовые ящики без лимита могут быть созданы.",
+        "quota_exceeded_scope": "Квота домена превышена: могут быть созданы только почтовые ящики без лимита.",
         "session_token": "Неверный токен формы: несоответствие токена",
         "session_ua": "Неверный токен формы: ошибка проверки User-Agent"
     }
diff --git a/mailcow/src/mailcow-dockerized/data/web/lang/lang.sk.json b/mailcow/src/mailcow-dockerized/data/web/lang/lang.sk.json
index e51f148..40ed5c6 100644
--- a/mailcow/src/mailcow-dockerized/data/web/lang/lang.sk.json
+++ b/mailcow/src/mailcow-dockerized/data/web/lang/lang.sk.json
@@ -4,20 +4,23 @@
         "app_passwds": "Spravovať heslá",
         "bcc_maps": "BCC mapy",
         "delimiter_action": "Oddeliť",
+        "domain_desc": "Zmeniť popis domény",
+        "domain_relayhost": "Zmeniť predávajúci server domény",
         "eas_reset": "Reset EAS zariadení",
         "extend_sender_acl": "Povoliť rozšírenie ACL odosielateľa externými adresami",
         "filters": "Filtre",
         "login_as": "Prihlásiť sa ako poštový používateľ",
+        "mailbox_relayhost": "Zmeniť predávajúci server schránky",
         "prohibited": "Zakázané cez ACL",
-        "protocol_access": "Meniť prístup k protokolom",
+        "protocol_access": "Upraviť povolené protokoly",
         "pushover": "Pushover",
         "quarantine": "Karanténa",
         "quarantine_attachments": "Umiestniť prílohy do karantény",
-        "quarantine_notification": "Zmeniť notifikácie karantény",
         "quarantine_category": "Zmeniť kategóriu karanténnych notifikácií",
-        "ratelimit": "Limit prenosu",
+        "quarantine_notification": "Zmeniť notifikácie karantény",
+        "ratelimit": "Obmedzenie prenosu",
         "recipient_maps": "Mapy príjemcu",
-        "smtp_ip_access": "Meniť prístup hostiteľov k SMTP",
+        "smtp_ip_access": "Spravovať povolených hostiteľov pre SMTP",
         "sogo_access": "Povoliť spravovanie prístupu do SOGo",
         "sogo_profile_reset": "Znovu nastaviť SOGo profil",
         "spam_alias": "Dočasné aliasy",
@@ -26,7 +29,10 @@
         "syncjobs": "Synchronizačné úlohy",
         "tls_policy": "TLS pravidlá",
         "unlimited_quota": "Neobmedzená kvóta pre poštové schránky",
-        "domain_desc": "Meniť popis domény"
+        "xmpp_admin": "Povýšiť XMPP používateľa na správcu",
+        "xmpp_domain_access": "Nakonfigurovať prístup k XMPP doméne.",
+        "xmpp_mailbox_access": "Nakonfigurovať používateľovi XMPP prístup.",
+        "xmpp_prefix": "Zmeniť XMPP subdoménu (prefix)"
     },
     "add": {
         "activate_filter_warn": "Všetky ostatné filtre budú deaktivované, ak bude zaškrtnuté pole \"Aktívny\".",
@@ -42,12 +48,13 @@
         "app_password": "Pridať heslo aplikácie",
         "automap": "Skúsiť automaticky mapovať priečinky (\"Sent items\", \"Sent\" => \"Sent\" atd.)",
         "backup_mx_options": "Možnosti preposielania",
+        "bcc_dest_format": "Cieľ kópie musí byť jedna platná emailová adresa. Pokiaľ potrebujete posielať kópie na viac adries, vytvorte Alias a použite ho tu.",
         "comment_info": "Súkromný komentár nie je viditeľný používateľovi, na rozdiel od verejného komentára, ktorý je prezentovaný ako popis v prehľade používateľov",
         "custom_params": "Voliteľné parametre",
         "custom_params_hint": "Správne: --param=xy, nesprávne: --param xy",
-        "delete1": "Vymazať zo zdroja, po dokončení",
-        "delete2": "Vymazať správy na cieli, ktoré nie sú na zdroji",
-        "delete2duplicates": "Vymazať duplikáty v cieľovom umiestnení",
+        "delete1": "Vymazať zo zdrojovej schránky, po dokončení prenosu",
+        "delete2": "Vymazať správy v cieľovej schránke, ak nie sú v zdrojovej",
+        "delete2duplicates": "Vymazať duplikáty v cieľovej schránke",
         "description": "Popis",
         "destination": "Cieľ",
         "disable_login": "Zablokovať prihlásenie (nevzťahuje sa na prichádzajúcu poštu)",
@@ -82,7 +89,7 @@
         "public_comment": "Verejný komentár",
         "quota_mb": "Kvóta (MiB)",
         "relay_all": "Preposielať všetkým príjemcom",
-        "relay_all_info": "↪ Ak sa rozhodnete <b>neposielať ďalej</b> všetkých príjemcov, budete musieť pridať (\"tzv. slepú\") poštovú schránku pre každého príjemcu.",
+        "relay_all_info": "↪ Ak sa rozhodnete <b>nepreposielať ďalej</b> všetkých príjemcov, budete musieť pridať (\"tzv. slepú\") poštovú schránku pre každého príjemcu.",
         "relay_domain": "Preposielať túto doménu",
         "relay_transport_info": "<div class=\"label label-info\">Info</div> Môžete definovať transportné mapy pre vlastné určenie cieľa pre túto doménu. Ak nie sú nastavené, použije sa MX záznam.",
         "relay_unknown_only": "Preposielať len neexistujúce poštové schránky. Existujúce budú doručené lokálne.",
@@ -92,17 +99,23 @@
         "sieve_desc": "Krátky popis",
         "sieve_type": "Typ filtru",
         "skipcrossduplicates": "Preskočiť duplikované správy naprieč priečinkami (akceptuje sa prvý nález)",
-        "subscribeall": "Odoberať všetky priečinky",
+        "subscribeall": "Synchronizovať všetky priečinky",
         "syncjob": "Pridať novú synchronizačnú úlohu",
         "syncjob_hint": "Upozornenie, heslá budú uložené v obyčajnom texte!",
         "target_address": "Cieľové adresy",
         "target_address_info": "<small>Celá emailová adresa/y (oddelené čiarkou).</small>",
         "target_domain": "Cieľová doména",
-        "timeout1": "Časový limit pre spojenie s diaľkovým hostiteľom",
-        "timeout2": "Časový limit pre spojenie s lokálnym hostiteľom",
+        "timeout1": "Časový limit pre spojenie so vzdialeným serverom",
+        "timeout2": "Časový limit pre spojenie s lokálnym serverom",
         "username": "Používateľské meno",
         "validate": "Overiť",
-        "validation_success": "Úspešne overené"
+        "validation_success": "Úspešne overené",
+        "xmpp": "Aktivovať XMPP pre túto doménu",
+        "xmpp_access": "XMPP prístup",
+        "xmpp_access_info": "XMPP musí byť aktivované pre túto doménu.",
+        "xmpp_admin": "XMPP administrátor",
+        "xmpp_admin_info": "<b>Upozornenie:</b> Povýši užívateľa na XMPP administrátora pre túto doménu.",
+        "xmpp_info": "Aktivovanie tejto funkcie umožní četovanie v tejto doméne."
     },
     "admin": {
         "access": "Prístup",
@@ -114,28 +127,33 @@
         "add": "Pridať",
         "add_admin": "Pridať administrátora",
         "add_domain_admin": "Pridať administrátora domény",
-        "add_forwarding_host": "Pridať doručovacieho hostiteľa",
-        "add_relayhost": "Pridať transportný záznam",
-        "add_relayhost_hint": "Prosím berte do úvahy, že autentifikačné dáta, ak existujú, budú uložené ako jednoduchý text.",
+        "add_forwarding_host": "Pridať preposielací server",
+        "add_relayhost": "Pridať transport",
+        "add_relayhost_hint": "Prosím berte do úvahy, že údaje overenia budú uložené ako nešifrovaný reťazec.",
         "add_row": "Pridať riadok",
         "add_settings_rule": "Pridať pravidlo nastavenia",
         "add_transport": "Pridať transport",
-        "add_transports_hint": "Prosím berte do úvahy, že overovacie dáta, ak existujú, budú uložené ako jednoduchý text.",
-        "additional_rows": " ďalšie riadky boli pridané",
+        "add_transports_hint": "Prosím berte do úvahy, že údaje overenia budú uložené ako nešifrovaný reťazec.",
+        "additional_rows": " boli pridané ďalšie riadky",
         "admin": "Administrátor",
         "admin_details": "Upraviť detaily administrátora",
         "admin_domains": "Pridelené domény",
+        "admins": "Administrátori",
+        "admins_ldap": "LDAP Administrátori",
+        "advanced_settings": "Pokročilé nastavenia",
         "api_allow_from": "Povoliť API prístup z týchto adries alebo rozsahov - IP/CIDR",
-        "api_info": "API momentálne pracuje. Dokumentáciu nájdete na <a href=\"/api\">/api</a>",
+        "api_info": "Dokumentáciu nájdete na <a href=\"/api\">/api</a>",
         "api_key": "API kľúč",
-        "api_skip_ip_check": "Preskočiť kontrolu IP pre API",
+        "api_read_only": "Prístup iba na čítanie",
+        "api_read_write": "Prístup aj so zápisom",
+        "api_skip_ip_check": "Vypnúť kontrolu IP",
         "app_links": "Odkazy na aplikácie",
         "app_name": "Meno aplikácie",
-        "apps_name": "\"mailcow Apps\" meno",
+        "apps_name": "\"mailcow Apps\" názov",
         "arrival_time": "Čas príchodu (čas servera)",
         "authed_user": "Overený používateľ",
         "ays": "Naozaj chcete pokračovať?",
-        "ban_list_info": "Ukázať zoznam zakázaných IP nižšie: <b>sieť (zostávajúci čas zákazu) - [akcia]</b>.<br />IP adresy čakajúce na unban budú odstránené z aktívneho zoznamu v priebehu niekoľkých sekúnd.<br />Červené značky indikujú aktívny permanentný zákaz.",
+        "ban_list_info": "Zoznam zakázaných IP je zobrazený nižšie: <b>sieť (zostávajúci čas zákazu) - [akcia]</b>.<br />IP adresy zaradené na unban budú odstránené z aktívneho zoznamu v priebehu niekoľkých sekúnd.<br />Červené položky zobrazujú permanentné blokovanie.",
         "change_logo": "Zmeniť logo",
         "configuration": "Konfigurácia",
         "convert_html_to_text": "Konvertovať HTML do obyčajného textu",
@@ -148,16 +166,16 @@
         "dkim_domains_selector": "Selektor",
         "dkim_domains_wo_keys": "Vybrať domény s chýbajúcimi kľúčmi",
         "dkim_from": "Od",
-        "dkim_from_title": "Zdrojová doména kopíruje dáta od",
+        "dkim_from_title": "Zdrojová doména, z ktorej sa majú kopírovať údaje",
         "dkim_key_length": "Dĺžka DKIM kľúča (bity)",
         "dkim_key_missing": "Chýbajúci kľúč",
-        "dkim_key_unused": "Kľúč je nepoužívaný",
-        "dkim_key_valid": "Kľúč je platný",
+        "dkim_key_unused": "Nepoužívaný kľúč",
+        "dkim_key_valid": "Platný kľúč",
         "dkim_keys": "ARC/DKIM kľúče",
         "dkim_overwrite_key": "Prepísať existujúci DKIM kľúč",
         "dkim_private_key": "Súkromný kľúč",
-        "dkim_to": "Komu",
-        "dkim_to_title": "Cieľová doména/y – bude prepísaná",
+        "dkim_to": "Do",
+        "dkim_to_title": "Cieľová doména/y – údaje budú prepísané",
         "domain": "Doména",
         "domain_admin": "Administrátor domény",
         "domain_admins": "Administrátori domény",
@@ -174,21 +192,21 @@
         "f2b_max_attempts": "Max. počet pokusov",
         "f2b_netban_ipv4": "Veľkosť IPv4 subnetu na ktorý sa aplikuje zákaz (8-32)",
         "f2b_netban_ipv6": "Veľkosť IPv6 subnetu na ktorý sa aplikuje zákaz (8-128)",
-        "f2b_parameters": "Fail2ban parametre",
-        "f2b_regex_info": "Logy ktoré sa berú do úvahy: SOGo, Postfix, Dovecot, PHP-FPM.",
+        "f2b_parameters": "Parametre automatického firewallu",
+        "f2b_regex_info": "Záznamy ktoré sa berú do úvahy: SOGo, Postfix, Dovecot, PHP-FPM.",
         "f2b_retry_window": "Čas v ktorom je treba uplatniť max. počet pokusov (s)",
         "f2b_whitelist": "Whitelist sietí/hostiteľov",
         "filter_table": "Tabuľka filtrov",
         "flush_queue": "Vyprázdniť frontu",
-        "forwarding_hosts": "Doručovací hostitelia",
-        "forwarding_hosts_add_hint": "Môžete buď špecifikovať IPv4/IPv6 adresy, siete v CIDR notácii, hostiteľské mená (ktoré budú preložené na IP adresy), alebo doménové mená (ktoré budú ako IP získané z SPF záznamov, alebo v prípade ich neprítomnosti, pomocou MX záznamov).",
-        "forwarding_hosts_hint": "Prichádzajúce správy sú bezpodmienečne prijaté z uvedených hostiteľov. Nekontroluje sa ich prítomnosť v DNSBL a neaplikuje sa u nich greylisting. Spam z uvedených hostiteľov sa neodmieta, ale občas môže skončiť nevyžiadanej pošte. Najčastejšie sa tu definujú hostitelia ktorý doručujú alebo majú presmerovanú poštu na tento server.",
+        "forwarding_hosts": "Preposielacie servery",
+        "forwarding_hosts_add_hint": "Môžete buď špecifikovať IPv4/IPv6 adresy, siete v CIDR notácii, názvy serverov (ktoré budú preložené na IP adresy), alebo doménové mená (ktoré budú ako IP získané z SPF záznamov, alebo v prípade ich neprítomnosti, pomocou MX záznamov).",
+        "forwarding_hosts_hint": "Prichádzajúce správy sú bezpodmienečne prijaté z uvedených serverov. Nekontroluje sa ich prítomnosť v DNSBL a neaplikuje sa u nich greylisting. Spam z uvedených serverov sa neodmieta, ale občas môže skončiť nevyžiadanej pošte. Najčastejšie sa tu definujú servery ktoré doručujú alebo majú presmerovanú poštu na tento server.",
         "from": "Od",
         "generate": "generovať",
         "guid": "GUID – unikátne ID",
         "guid_and_license": "GUID & Licencia",
-        "hash_remove_info": "Odstránením hashu pre limit prenosu (ak stále existuje), sa kompletne resetuje počítadlo.<br>\r\n Každý hash je označený individuálnou farbou.",
-        "help_text": "Pomocný text pod prihlasovacou maskou (HTML povolené)",
+        "hash_remove_info": "Odstránením hashu pre obmedzenie prenosu (ak stále existuje), sa kompletne resetuje počítadlo.<br>\r\n Každý hash je označený individuálnou farbou.",
+        "help_text": "Prepísať text nápovede pod prihlasovacou obrazovkou (HTML povolené)",
         "host": "Hostiteľ",
         "html": "HTML",
         "import": "Importovať",
@@ -196,15 +214,17 @@
         "in_use_by": "Používané",
         "inactive": "Neaktívny",
         "include_exclude": "Zahrnúť/Vylúčiť",
-        "include_exclude_info": "Podľa predvolených nastavení – so žiadnym výberom- <b>všetky schránky</b> sú adresované",
+        "include_exclude_info": "Ak nič nevyberiete tak bude adresované <b>všetkým schránkam</b>",
         "includes": "Zahrnúť týchto príjemcov",
+        "is_mx_based": "Na základe MX",
         "last_applied": "Naposledy aplikované",
         "license_info": "Licencia nie je potrebná, ale napomáha ďalšiemu vývoju.<br><a href=\"https://www.servercow.de/mailcow?lang=en#sal\" target=\"_blank\" alt=\"SAL order\">Registrujte váš GUID tu</a> alebo <a href=\"https://www.servercow.de/mailcow?lang=en#support\" target=\"_blank\" alt=\"Objednávka podpory\">zakúpte si podporu pre vašu mailcow inštaláciu.</a>",
         "link": "Odkaz",
         "loading": "Čakajte prosím ...",
+        "login_time": "Čas prihlásenia",
         "logo_info": "Váš obrázok bude upravený na výšku 40px pre vrchný navigačný riadok a na maximálnu šírku 250px pre úvodnú stránku. Odporúča sa škálovateľná grafika.",
-        "lookup_mx": "Overiť cieľ voči MX záznamu (doručenie pre .outlook.com bude smerované cez MX *.outlook.com na konkrétny server)",
-        "main_name": "\"mailcow UI\" meno",
+        "lookup_mx": "Cieľ je regulárny výraz ktorý sa zhoduje s MX záznamom (<code>.*google\\.com</code> smeruje všetku poštu na MX ktoré sú cieľom pre google.com cez tento skok)",
+        "main_name": "\"mailcow UI\" názov",
         "merged_vars_hint": "Sivé riadky boli načítané z <code>vars.(local.)inc.php</code> a nemôžu byť modifikované cez UI.",
         "message": "Správa",
         "message_size": "Veľkosť správy",
@@ -213,43 +233,52 @@
         "no_active_bans": "Žiadne aktívne zákazy",
         "no_new_rows": "Žiadne ďalšie riadky nie sú k dispozícii",
         "no_record": "Žiaden záznam",
+        "oauth2_apps": "OAuth2 Aplikácie",
+        "oauth2_add_client": "Pridať OAuth2 klienta",
         "oauth2_client_id": "ID klienta",
         "oauth2_client_secret": "Tajný kľuč",
-        "oauth2_info": "OAuth2 implementácia podporuje typ prideľovania \"Authorization Code\" a vydáva tokeny k obnoveniu.<br>\r\nServer taktiež automaticky vydáva nové tokeny k obnoveniu, akonáhle bol predchádzajúci token použitý.<br><br>\r\n→ Predvolený rozsah je <i>profile</i>. Iba používatelia poštovej schránky môžu byť autentifikovaný cez OAuth2. Ak je rozsahový pramater vynechaný, spadá naspäť do <i>profile</i>.<br>\r\n→ <i>Stavový</i> parameter je potrebný poslať klientom ako súčasť autorizačnej požiadavky.<br><br>\r\nCesty pre požiadavky ku OAuth2 API: <br>\r\n<ul>\r\n  <li>Koncový bod autorizácie: <code>/oauth/authorize</code></li>\r\n  <li>Koncový bod tokenu: <code>/oauth/token</code></li>\r\n  <li>Zdrojová stránka:  <code>/oauth/profile</code></li>\r\n</ul>\r\nAk príde k obnoveniu <i>tajného kľúča</i>, nezruší sa platnosť existujúcich autorizačných kódov, ale nebude možné obnoviť ich token.<br><br>\r\nOdobratím <i>tajného kľúča</i> bude mať za následok zrušenie všetkých aktívnych relácií. Všetci klienti musia podstúpiť re-autentifikačný proces.",
+        "oauth2_info": "OAuth2 implementácia podporuje typ prideľovania \"Authorization Code\" a vydáva tokeny k obnoveniu.<br>\r\nServer automaticky vydáva nové tokeny k obnoveniu, akonáhle bol predchádzajúci token použitý.<br><br>\r\n&#8226; Predvolený rozsah je <i>profile</i>. Iba používatelia poštovej schránky môžu byť autentifikovaný cez OAuth2. Ak je rozsahový pramater vynechaný, spadá naspäť do <i>profile</i>.<br>\r\n&#8226; <i>Stavový</i> parameter je potrebný poslať klientom ako súčasť autorizačnej požiadavky.<br><br>\r\nCesty pre požiadavky ku OAuth2 API: <br>\r\n<ul>\r\n <li>Koncový bod autorizácie: <code>/oauth/authorize</code></li>\r\n <li>Koncový bod tokenu: <code>/oauth/token</code></li>\r\n <li>Zdrojová stránka: <code>/oauth/profile</code></li>\r\n</ul>\r\nAk príde k obnoveniu <i>tajného kľúča</i>, nezruší sa platnosť existujúcich autorizačných kódov, ale nebude možné obnoviť ich token.<br><br>\r\nOdobratím <i>tajného kľúča</i> bude mať za následok zrušenie všetkých aktívnych relácií. Všetci klienti musia podstúpiť re-autentifikačný proces.",
         "oauth2_redirect_uri": "Presmerovať URI",
         "oauth2_renew_secret": "Vygenerovať nový tajný kľuč",
         "oauth2_revoke_tokens": "Odobrať všetky tokeny klienta",
         "optional": "voliteľné",
         "password": "Heslo",
+        "password_length": "Dĺžka hesla",
+        "password_policy": "Politika hesiel",
+        "password_policy_chars": "Musí obsahovať najmenej jedno písmeno",
+        "password_policy_length": "Minimálna dĺžka hesla je %d",
+        "password_policy_lowerupper": "Musí obsahovať malé a veľké písmeno",
+        "password_policy_numbers": "Musí obsahovať najmenej jedno číslo",
+        "password_policy_special_chars": "Musí obsahovať špeciálny znak",
         "password_repeat": "Potvrdzujúce heslo (opakovať)",
         "priority": "Priorita",
         "private_key": "Súkromný kľúč",
         "quarantine": "Karanténa",
-        "quarantine_bcc": "Poslať kópiu všetkých upozornení (BCC) tomuto príjemcovi:<br><small>Nechať prázdne pre vypnutie. <b>Nepodpísaná, neskontrolovaná pošta, by mala byť doručená interne.</b></small>",
-        "quarantine_exclude_domains": "Vymedziť domény a doménové aliasy",
-        "quarantine_max_age": "Maximálne obdobie v dňoch<br><small>Hodnota sa musí rovnať alebo byť väčšia ako 1 deň.</small>",
-        "quarantine_max_size": "Maximálna veľkosť v MiB (väčšie prvky sú vyradené):<br><small>0 neznamená <b>neobmedzené</b>.</small>",
+        "quarantine_bcc": "Poslať kópiu všetkých upozornení (BCC) tomuto príjemcovi:<br><small>Pre deaktiváciu nechajte nevyplnené. <b>Nepodpísaná, neskontrolovaná pošta, mala by byť doručovaná iba interne.</b></small>",
+        "quarantine_exclude_domains": "Vylúčiť domény a doménové aliasy",
+        "quarantine_max_age": "Maximálne obdobie v dňoch<br><small>Hodnota musí byť 1 alebo viac dní.</small>",
         "quarantine_max_score": "Neposielať notifikácie ak je spam skóre väčšie ako hodnota:<br><small>Predvolená je 9999.0</small>",
-        "quarantine_notification_html": "Predloha notifikácie:<br><small>Nechať prázdne pre obnovenie originálnej predlohy.</small>",
+        "quarantine_max_size": "Maximálna veľkosť v MiB (väčšie správy sú vyradené):<br><small>0 <b>neznamená</b> neobmedzené.</small>",
+        "quarantine_notification_html": "Šablóna notifikácie:<br><small>Nechajte prázdne pre použitie originálnej šablóny.</small>",
         "quarantine_notification_sender": "Odosielateľ notifikácie",
         "quarantine_notification_subject": "Predmet notifikácie",
-        "quarantine_redirect": "<b>Presmerovať notifikácie</b> na túto adresu:<br><small>Pre vypnutie nechajte nevyplnené. <b>Nepodpísaná, neskontrolovaná pošta, by mala byť doručená interne.</b></small>",
-        "quarantine_release_format": "Uvoľniť položky z karantény ako",
-        "quarantine_release_format_att": "Ako príloha",
+        "quarantine_redirect": "<b>Presmerovať všetky notifikácie</b> na túto adresu:<br><small>Pre deaktiváciu nechajte nevyplnené. <b>Nepodpísaná, neskontrolovaná pošta, mala by byť doručovaná iba interne.</b></small>",
+        "quarantine_release_format": "Uvoľňovať položky z karantény ako",
+        "quarantine_release_format_att": "Prílohu",
         "quarantine_release_format_raw": "Nemodifikovaný originál",
         "quarantine_retention_size": "Počet zadržaných správ pre jednotlivé poštové schránky<br><small>0 znamená <b>neaktívne</b>.</small>",
         "queue_ays": "Prosím potvrďte vymazanie všetkých položiek z aktuálnej fronty.",
         "queue_deliver_mail": "Doručiť",
         "queue_hold_mail": "Pozdržať",
         "queue_manager": "Správca fronty",
-        "queue_unban": "Povoliť",
-        "queue_unhold_mail": "Povoliť",
         "queue_show_message": "Zobraziť správu",
+        "queue_unban": "Odblokovať",
+        "queue_unhold_mail": "Uvoľniť",
         "quota_notification_html": "Notifikácia email predloha:<br><small>Nechať prázdne pre obnovenie originálnej predlohy.</small>",
-        "quota_notification_sender": "Notifikácia email odosielateľ",
-        "quota_notification_subject": "Notifikácia email predmet",
+        "quota_notification_sender": "Odosielateľ notifikácií",
+        "quota_notification_subject": "Predmet notifikácií",
         "quota_notifications": "Notifikácie o kvótach",
-        "quota_notifications_info": "Upozornenie na kvótu sú odoslané používateľom, keď prekročia 80% a 95% objemu schránky.",
+        "quota_notifications_info": "Notifikácie o kvóte sú odosielané používateľom, keď prekročia 80% a 95% objemu schránky.",
         "quota_notifications_vars": "{{percent}} sa rovná aktuálnej kvóte používateľa <br>{{užívateľské meno}} je poštová schránka",
         "r_active": "Aktívne obmedzenia",
         "r_inactive": "Neaktívne obmedzenia",
@@ -258,8 +287,9 @@
         "recipients": "Príjemcovia",
         "refresh": "Aktualizovať",
         "regen_api_key": "Obnoviť API kľúč",
-        "regex_maps": "Mapy regulérnych výrazov",
-        "relay_from": "\"From:\" adresa",
+        "regex_maps": "Mapy regulárnych výrazov",
+        "relay_from": "\"Od:\" adresa",
+        "relay_rcpt": "\"Komu:\" adresa",
         "relay_run": "Spustiť test",
         "relayhosts": "Transportné mapy pre odosielanie",
         "relayhosts_hint": "Definuje transportné mapy tak, aby ich bolo možné použiť pri konfigurácii domény.<br>\r\n  Transportná služba je vždy \"smtp:\" a použije TLS ak to bude umožnené. Wrapped TLS (SMTPS) nie je podporované. Zohľadňujú sa TLS pravidlá jednotlivých používateľov pri odosielaní.<br>\r\n  Ovplyvňuje vybrané domény vrátane doménových aliasov.",
@@ -274,10 +304,11 @@
         "rsetting_no_selection": "Prosím vyberte pravidlo",
         "rsetting_none": "Žiadne dostupné pravidlá",
         "rsettings_insert_preset": "Vložiť príklad \"%s\"",
-        "rsettings_preset_1": "Vypnúť všetky obmedzenia pre overených používateľov okrem DKIM a prenosového obmedzenia ",
+        "rsettings_preset_1": "Vypnúť všetky obmedzenia pre overených používateľov okrem DKIM a obmedzenia prenosu (rate limiting)",
         "rsettings_preset_2": "Prijať každý spam",
         "rsettings_preset_3": "Povoliť len špecifických odosielateľov (využitie ako interná schránka pre lokálne doručovanie)",
-        "rspamd-com_settings": "Názov nastavenia bude automaticky generovaný, prosím pozrite sa na príklad uvedeny nižšie. Pre viac informácií navštívte <a href=\"https://rspamd.com/doc/configuration/settings.html#settings-structure\" target=\"_blank\">Rspamd docs</a>",
+        "rsettings_preset_4": "Deaktivujte Rspamd pre doménu",
+        "rspamd-com_settings": "Názov nastavenia bude automaticky vygenerovaný, pozrite sa prosím na ukážky uvedené nižšie. Pre viac informácií navštívte <a href=\"https://rspamd.com/doc/configuration/settings.html#settings-structure\" target=\"_blank\">Rspamd dokumentáciu</a>",
         "rspamd_global_filters": "Mapy globálnych filtrov",
         "rspamd_global_filters_agree": "Budem opatrný!",
         "rspamd_global_filters_info": "Mapy globálnych filtrov obsahujú rozličné druhy globálnych blacklistov a whitelistov.",
@@ -288,18 +319,22 @@
         "search_domain_da": "Vyhľadať domény",
         "send": "Odoslať",
         "sender": "Odosielateľ",
+        "service": "Služba",
         "service_id": "ID služba",
         "source": "Zdroj",
         "spamfilter": "Spam filter",
         "subject": "Predmet",
+        "success": "Úspech",
         "sys_mails": "Systémové správy",
         "text": "Text",
         "time": "Čas",
-        "title_name": "\"mailcow UI\" názov webstránky",
+        "title": "Názov",
+        "title_name": "\"mailcow UI\" titulka",
         "to_top": "Naspať navrch",
-        "transport_dest_format": "Syntax: example.org, .example.org, *, box@example.org (viacero hodnôt môžu byť oddelené čiarkou)",
+        "transport_dest_format": "Regulárny výraz alebo syntax: example.org, .example.org, *, box@example.org (viacero hodnôt môžu byť oddelené čiarkou)",
         "transport_maps": "Transportné Mapy",
-        "transports_hint": "→ Záznam v transportnej mape <b>prevažuje</b> nad transportnou mapou pre odosielanie</b>.<br>\r\n→ Nastavenie TLS pre používateľa je ignorované a môže byť vynútené TLS mapovaním.<br>\r\n→ Transportná služba je definovaná vždy \"smtp:\" a použije TLS ak to bude umožnené. Wrapped TLS (SMTPS) nie je podporované.<br>\r\n→ Adresy ktoré sa rovnajú hodnote \"/localhost$/\" budú vždy transportované cez \"local:\" a nebudú použité pre cieľový záznam \"*\".<br>\r\n→ Po zadaní prihlasovacích údajov pre ďalší skok \"[host]:25\", Postfix <b>vždy</b> hľadá \"host\" a následne \"[host]:25\". Táto vlastnosť znemožňuje používať \"host\" a \"[host]:25\" naraz.",
+        "transport_test_rcpt_info": "&#8226; Na otestovanie odchádzajúcej pošty je možné použiť null@hosted.mailcow.de ako adresáta",
+        "transports_hint": "&#8226; Záznam v transportnej mape <b>prevažuje</b> nad transportnou mapou pre odosielanie</b>.<br>\r\n&#8226; Prenos na základe MX je preferovaná voľba.<br>\r\n&#8226; Nastavenie TLS pre používateľa je ignorované a môže byť vynútené TLS mapovaním.<br>\r\n&#8226; Transportná služba je definovaná vždy \"smtp:\" a použije TLS ak to bude umožnené. Wrapped TLS (SMTPS) nie je podporované.<br>\r\n&#8226; Adresy ktoré sa rovnajú hodnote \"/localhost$/\" budú vždy transportované cez \"local:\" a nebudú použité pre cieľový záznam \"*\".<br>\r\n&#8226; Po zadaní prihlasovacích údajov pre ďalší skok \"[host]:25\", Postfix <b>vždy</b> hľadá \"host\" a následne \"[host]:25\". Táto vlastnosť znemožňuje používať \"host\" a \"[host]:25\" naraz.",
         "ui_footer": "Pätička (HTML povolené)",
         "ui_header_announcement": "Oznámenie",
         "ui_header_announcement_active": "Aktivovať oznámenie",
@@ -307,15 +342,16 @@
         "ui_header_announcement_help": "Oznámenie je viditeľné pre všetkých prihlásených používateľov a na prihlasovacej obrazovke používateľského rozhrania.",
         "ui_header_announcement_select": "Zvoľte typ oznámenia",
         "ui_header_announcement_type": "Typ",
+        "ui_header_announcement_type_danger": "Veľmi dôležité",
         "ui_header_announcement_type_info": "Info",
         "ui_header_announcement_type_warning": "Dôležité",
-        "ui_header_announcement_type_danger": "Veľmi dôležité",
         "ui_texts": "UI značky a texty",
         "unban_pending": "čakajúci na unban",
         "unchanged_if_empty": "Nechajte prázdne, ak sa nemení",
         "upload": "Nahrať",
         "username": "Prihlasovacie meno",
         "validate_license_now": "Validovať GUID cez licenčný server",
+        "verify": "Kontrola",
         "yes": "&#10003;"
     },
     "danger": {
@@ -328,9 +364,9 @@
         "aliases_in_use": "Max. počet aliasov musí byť väčší alebo rovnajúci sa %d",
         "app_name_empty": "Meno aplikácie nemôže byť prázdne",
         "app_passwd_id_invalid": "Heslo aplikácie ID %s neplatné",
-        "bcc_empty": "BCC cieľ nemôže byť prázdny",
-        "bcc_exists": "BCC mapa %s existuje pre typ %s",
-        "bcc_must_be_email": "BCC cieľ %s nie je platná emailová adresa",
+        "bcc_empty": "Cieľ kópie nemôže byť prázdny",
+        "bcc_exists": "Skrytá kópia %s už existuje pre typ %s",
+        "bcc_must_be_email": "Cieľ kópie %s nie je platná emailová adresa",
         "comment_too_long": "Komentár je príliš dlhý, povolených je max. 160 znakov",
         "defquota_empty": "Predvolená kvóta pre poštovú schránku nemôže byť 0.",
         "description_invalid": "Popis zdroja pre %s je neplatný",
@@ -344,6 +380,7 @@
         "domain_quota_m_in_use": "Doménová kvóta musí byť väčšia alebo rovnajúca sa %s MiB",
         "extra_acl_invalid": "Externá adresa odosielateľa \"%s\" je neplatná",
         "extra_acl_invalid_domain": "Externý odosielateľ \"%s\" používa neplatnú doménu",
+        "fido2_verification_failed": "FIDO2 overenie zlyhalo: %s",
         "file_open_error": "Nemožno otvoriť súbor pre zápis",
         "filter_type": "Nesprávny typ filtra",
         "from_invalid": "Odosielateľ nemôže byť prázdny",
@@ -367,7 +404,7 @@
         "invalid_recipient_map_old": "Neplatná pôvodná mapa príjemcu: %s",
         "ip_list_empty": "Zoznam povolených IP nemôže byť prázdny",
         "is_alias": "%s je už používané ako alias adresa",
-        "is_alias_or_mailbox": "%s je už používaná ako adresa aliasu, poštovej schránky nebo aliasu odvodeného z aliasu domény",
+        "is_alias_or_mailbox": "%s je už používaná ako adresa aliasu, poštovej schránky alebo aliasu odvodeného z aliasu domény",
         "is_spam_alias": "%s je už používaná ako adresa dočasného aliasu (spam alias adresa)",
         "last_key": "Posledný kľúč nemôže byť vymazaný, deaktivujte najprv TFA",
         "login_failed": "Prihlásenie zlyhalo",
@@ -387,6 +424,7 @@
         "network_host_invalid": "Neplatná sieť alebo hostiteľ: %s",
         "next_hop_interferes": "%s narúša ďalší skok %s",
         "next_hop_interferes_any": "Existujúci ďalší skok narúša %s",
+        "nginx_reload_failed": "Nginx reload zlyhal: %s",
         "no_user_defined": "Nie je definovaný žiadny používateľ",
         "object_exists": "Objekt %s už existuje",
         "object_is_not_numeric": "Hodnota %s nie je numerická",
@@ -404,7 +442,7 @@
         "redis_error": "Redis chyba: %s",
         "relayhost_invalid": "Položka %s je neplatná",
         "release_send_failed": "Správa nemohla byť uvoľnená: %s",
-        "reset_f2b_regex": "Regex filter sa nepodarilo resetovať, skúste to znovu alebo počkajte pár sekúnd a reloadnite stránku.",
+        "reset_f2b_regex": "Regex filter sa nepodarilo resetovať, skúste to znovu alebo počkajte pár sekúnd a obnovte stránku.",
         "resource_invalid": "Zdrojové meno %s je neplatné",
         "rl_timeframe": "Obmedzenie časového rámca je nesprávny",
         "rspamd_ui_pw_length": "Heslo pre Rspamd rozhranie by malo mať minimálne 6 znakov",
@@ -427,42 +465,52 @@
         "totp_verification_failed": "TOTP overenie zlyhalo",
         "transport_dest_exists": "Transportný cieľ \"%s\" už existuje",
         "u2f_verification_failed": "U2F overenie zlyhalo: %s",
-        "fido2_verification_failed": "FIDO2 overenie zlyhalo: %s",
         "unknown": "Nastala neznáma chyba",
         "unknown_tfa_method": "Neznáma TFA metóda",
         "unlimited_quota_acl": "Neobmedzené kvóta je zakázaná cez ACL",
-        "username_invalid": "Užívateľské meno %s nemôže byť použité",
+        "username_invalid": "Používateľské meno %s nemôže byť použité",
         "validity_missing": "Zadajte periódu platnosti",
         "value_missing": "Prosím poskytnite všetky hodnoty",
+        "xmpp_map_write_error": "Nemožno zapísať XMPP mapu: %s",
+        "xmpp_reload_failed": "Reloadnutie XMPP zlyhalo",
+        "xmpp_restart_failed": "Reštartovanie XMPP zlyhalo",
         "yotp_verification_failed": "Yubico OTP overenie zlyhalo: %s"
     },
     "debug": {
         "chart_this_server": "Graf (tento server)",
         "containers_info": "Informácie o kontajneroch",
         "disk_usage": "Použitie disku",
-        "external_logs": "Externé správy",
+        "docs": "Dokumenty",
+        "external_logs": "Externé logy",
         "history_all_servers": "História (všetky servery)",
-        "in_memory_logs": "Správy uložené v pamäti",
+        "in_memory_logs": "Logy uložené v pamäti",
         "jvm_memory_solr": "JVM spotreba pamäte",
-        "log_info": "<b>Logy v pamäti</b> sú zbierané do Redis listu s max. limitom (%d) riadkov každú minútu, čo bráni nadmernej záťaži servera.\r\n  <br>Logy v pamäti nemajú trvalý charakter. Všetky aplikácie ktoré vedú logy v pamäti, taktiež logujú do Docker démona a súčasne do nastaveného logging drivera.\r\n  <br>Logy v pamäti sa môžu použiť na ladenie menších problémov s kontajnermi.</p>\r\n  <p><b>Externé logy</b> sú zbierané cez API danej aplikácie.</p>\r\n  <p><b>Statické logy</b> sú väčšinou aktivity, ktoré nie sú logované do Docker démona, ale musia byť trvalo zaznamenané (s výnimkou API záznamov).</p>",
-        "logs": "Správy",
+        "last_modified": "Naposledy upravené",
+        "log_info": "<b>Logy v pamäti</b> sú zbierané do Redis listu s max. limitom LOG_LINES (%d) riadkov každú minútu, čo bráni nadmernej záťaži servera.\r\n  <br>Logy v pamäti nemajú trvalý charakter. Všetky aplikácie ktoré vedú logy v pamäti, tiež logujú do Docker démona a súčasne do nastaveného logging drivera.\r\n  <br>Logy v pamäti sa môžu použiť na ladenie menších problémov s kontajnermi.</p>\r\n  <p><b>Externé logy</b> sú zbierané cez API danej aplikácie.</p>\r\n  <p><b>Statické logy</b> sú väčšinou aktivity, ktoré nie sú logované do Docker démona, ale musia byť trvalo zaznamenané (s výnimkou API záznamov).</p>",
+        "login_time": "Čas",
+        "logs": "Logy",
+        "online_users": "Používateľov online",
         "restart_container": "Reštartovať",
-        "solr_dead": "Solr štartuje, bol vypnutý alebo zlyhal.",
-        "solr_docs": "Dokumenty",
-        "solr_last_modified": "Naposledy upravené",
-        "solr_size": "Veľkosť",
-        "solr_started_at": "Spustený",
+        "service": "Služba",
+        "size": "Veľkosť",
+        "solr_dead": "Solr štartuje, je vypnutý alebo nebeží.",
         "solr_status": "Solr status",
-        "solr_uptime": "Doba behu",
+        "started_at": "Spustený",
         "started_on": "Spustený",
-        "static_logs": "Statické správy",
-        "system_containers": "Systém & Kontajnery"
+        "static_logs": "Statické logy",
+        "success": "Úspech",
+        "system_containers": "Systém & Kontajnery",
+        "uptime": "Doba behu",
+        "username": "Používateľské meno",
+        "xmpp_dead": "XMPP štartuje, je vypnutý alebo nebeží.",
+        "xmpp_status": "XMPP status"
     },
     "diagnostics": {
         "cname_from_a": "Hodnota odvodená od A/AAAA záznamu. Toto je podporené len v prípade ak záznam poukazuje na správny zdroj.",
         "dns_records": "DNS záznamy",
         "dns_records_24hours": "Berte prosím do úvahy, že zmeny v DNS môžu trvať až 24 hodín, aby sa zmeny prejavili na tejto stránke. Pre jednoduchosť DNS konfigurácie môžete použiť údaje uvedené nižšie, prípadne skontrolovať tak správnosť záznamov v DNS.",
         "dns_records_data": "Správne dáta",
+        "dns_records_docs": "Pozrite si prosím <a target=\"_blank\" href=\"https://mailcow.github.io/mailcow-dockerized-docs/prerequisite-dns/\">dokumentáciu</a>.",
         "dns_records_name": "Meno",
         "dns_records_status": "Súčasný stav",
         "dns_records_type": "Typ",
@@ -470,21 +518,23 @@
     },
     "edit": {
         "active": "Aktívny",
+        "admin": "Upraviť administrátora",
+        "advanced_settings": "Pokročilé nastavenia",
         "alias": "Upraviť alias",
         "allow_from_smtp": "Umožniť iba týmto IP adresám používať <b>SMTP</b>",
-        "allow_from_smtp_info": "Nechať prázdne pre povolenie všetkých odosielateľov.<br>IPv4/IPv6 adresy a siete.",
+        "allow_from_smtp_info": "Nechajte prázdne pre povolenie všetkých odosielateľov.<br>IPv4/IPv6 adresy a siete.",
         "allowed_protocols": "Povolené protokoly",
         "app_name": "Meno aplikácie",
         "app_passwd": "Heslo aplikácie",
         "automap": "Skúsiť automapovať priečinky (\"Sent items\", \"Sent\" => \"Sent\" atd.)",
         "backup_mx_options": "Možnosti preposielania",
-        "bcc_dest_format": "BCC cieľ musí byť jedna platná emailová adresa.",
+        "bcc_dest_format": "Cieľ kópie musí byť jedna platná emailová adresa. Pokiaľ potrebujete posielať kópie na viac adries, vytvorte Alias a použite ho tu.",
         "client_id": "ID klienta",
         "client_secret": "Klientský tajný kľúč",
         "comment_info": " Súkromný komentár nie je viditeľný používateľovi, na rozdiel od verejného komentára, ktorý je prezentovaný ako popis v prehľade používateľov",
-        "delete1": "Vymazať zo zdroja, po dokončení",
-        "delete2": "Vymazať správy na cieli, ktoré nie sú na zdroji",
-        "delete2duplicates": "Vymazať duplikáty na cieli",
+        "delete1": "Vymazať zo zdrojovej schránky, po dokončení prenosu",
+        "delete2": "Vymazať správy v cieľovej schránke, ak nie sú v zdrojovej",
+        "delete2duplicates": "Vymazať duplikáty v cieľovej schránke",
         "delete_ays": "Potvrďte zmazanie.",
         "description": "Popis",
         "disable_login": "Zablokovať prihlásenie (nevzťahuje sa na prichádzajúcu poštu)",
@@ -493,13 +543,13 @@
         "domain_quota": "Kvóta domény",
         "domains": "Domény",
         "dont_check_sender_acl": "Vypnúť kontrolu odosielateľa pre doménu %s (+ alias domény)",
-        "edit_alias_domain": "Upraviť Alias domény",
+        "edit_alias_domain": "Upraviť alias domény",
         "encryption": "Zašifrovanie",
         "exclude": "Vyradiť objekty (regex)",
         "extended_sender_acl": "Externé adresy odosielateľa",
         "extended_sender_acl_info": "DKIM doménový kľúč by mal byť importovaný, ak je dostupný.<br>\r\n Nezabudnite pridať tento server prislúchajúcemu SPF TXT záznamu.<br>\r\n  Kedykoľvek je doména alebo alias doména pridaná na server, ktorá sa zhoduje s externou adresou, táto externá adresa je odstránená.<br>\r\n  Použite @domain.tld pre schopnosť poslať ako *@domain.tld.",
-        "force_pw_update": "Prinútiť aktualizáciu hesla pri ďalšom prihlásení",
-        "force_pw_update_info": "Tento používateľ bude schopný prihlásiť sa len do %s.",
+        "force_pw_update": "Vynútiť zmenu hesla pri ďalšom prihlásení",
+        "force_pw_update_info": "Používateľ sa bude môcť prihlásiť len do administrácie.",
         "full_name": "Celé meno",
         "gal": "Globálny zoznam adries",
         "gal_info": "Globálny zoznam adries obsahuje všetky objekty v doméne a nemôže byť upravená žiadnym používateľom. Informácie o Free/Busy stave budú chýbať ak bude vypnutý! <b>Reštartujte SOGo na aplikáciu zmien.</b>",
@@ -508,17 +558,20 @@
         "hostname": "Hostiteľ",
         "inactive": "Neaktívny",
         "kind": "Druh",
+        "lookup_mx": "Cieľ je regulárny výraz ktorý sa zhoduje s MX záznamom (<code>.*google\\.com</code> smeruje všetku poštu na MX ktoré sú cieľom pre google.com cez tento skok)",
         "mailbox": "Upraviť poštovú schránku",
         "mailbox_quota_def": "Predvolená veľkosť poštovej schránky",
+        "mailbox_relayhost_info": "Aplikované len na používateľské schránky a priame aliasy, prepisuje doménového preposielateľa.",
         "max_aliases": "Max. počet aliasov",
         "max_mailboxes": "Max. počet schránok",
         "max_quota": "Max. kvóta pre poštovú schránku (MiB)",
         "maxage": "Maximálne obdobie správ v dňoch, ktoré sa budú vzdialene dotazovať<br><small>(0 = ignorovať obdobie age)</small>",
         "maxbytespersecond": "Max. bajtov za sekundu <br><small>(0 = bez limitu)</small>",
-        "mbox_rl_info": "Tento limit je aplikovaný na SASL prihlasovacom meno, je zhodný s \"from\" adresou používanou prihláseným používateľom. Prenosový limit u poštovej adresy má prednosť pred domain-wide prenosovým limitom.",
+        "mbox_rl_info": "Tento limit je aplikovaný na báze prihlasovacieho mena SASL, je zhodný s \"from\" adresou používanou prihláseným používateľom. Prenosový limit u poštovej adresy má prednosť pred domain-wide prenosovým limitom.",
         "mins_interval": "Interval (min)",
         "multiple_bookings": "Viaceré rezervácie",
         "nexthop": "Ďalší skok",
+        "none_inherit": "Žiadne / Zdediť",
         "password": "Heslo",
         "password_repeat": "Potvrdzovacie heslo (opakovať)",
         "previous": "Predchádzajúca strana",
@@ -528,12 +581,15 @@
         "pushover_info": "Push notifikácie budú aplikované na všetky správy (s výnimkou spamu) doručené pre <b>%s</b> vrátane aliasov (zdieľané, nezdieľané, označené).",
         "pushover_only_x_prio": "Vyberať len správy s vysokou prioritou [<code>X-Priority: 1</code>]",
         "pushover_sender_array": "Zohľadňujú sa nasledujúce adresy odosielateľa <small>(oddelené čiarkou)</small>",
-        "pushover_sender_regex": "Užívateľ vybraný regulérnym výrazom",
+        "pushover_sender_regex": "Používateľ vybraný regulárnym výrazom",
         "pushover_text": "Text notifikácie",
         "pushover_title": "Názov notifikácie",
         "pushover_vars": "Ak nie je definovaný žiadny filter odosielateľa, zohľadnia sa všetky správy.<br>Priama kontrola odosielateľa a regulárne výrazy sa kontrolujú nezávisle od seba, <b>nezávisia od seba navzájom</b> a vykonávajú sa postupne.<br>Použiteľné premenné pre názov a text (dodržujte pokyny na ochranu osobných údajov)",
         "pushover_verify": "Overiť prístupové údaje",
         "quota_mb": "Kvóta (MiB)",
+        "quota_warning_bcc": "Upozornenie na kvótu BCC",
+        "quota_warning_bcc_info": "Upozornenia budú poslané ako samostatné kópie nasledujúcim prijímateľom. Predmet bude doplnený o použivateľské meno v zátvorkách, príklad: <code>Upozornenie na kvótu (user@example.com)</code>.",
+        "ratelimit": "Obmedzenie prenosu",
         "redirect_uri": "Presmerovať URL",
         "relay_all": "Preposielať všetkých prijemcov",
         "relay_all_info": "↪ Ak sa rozhodnete <b>nepreposielať</b> všetkých príjemcov, budete musieť pridať (\"tzv. slepú\") poštovú schránku pre každého príjemcu.",
@@ -546,7 +602,7 @@
         "save": "Uložiť zmeny",
         "scope": "Rozsah",
         "sender_acl": "Povoliť odosielanie ako",
-        "sender_acl_disabled": "↳ <span class=\"label label-danger\">Kontrola odosielateľa vypnutá</span>",
+        "sender_acl_disabled": "<span class=\"label label-danger\">Kontrola odosielateľa vypnutá</span>",
         "sender_acl_info": "Ak poštový používateľ A má povolenie poslať ako poštový používateľ B, adresa odosielateľa nieje automaticky viditeľná ako voliteľné \"from\" pole v SOGo.<br>\r\n Poštový používateľ B potrebuje vytvoriť delegáciu v SOGo, aby bol schopný poštový používateľ A vybrať svoju adresu ako odosielateľ. Na delegovanie poštovej adresy v SOGo, použite menu (tri bodky) napravo vášho poštového mena v hornom ľavom rohu, v prehľade správ. Toto neplatí pre alias adresy.",
         "sieve_desc": "Krátky popis",
         "sieve_type": "Typ filtru",
@@ -556,27 +612,53 @@
         "sogo_visible": "Alias je viditeľný v SOGo",
         "sogo_visible_info": "Táto voľba ovplyvňuje len objekty, ktoré dokážu byť zobrazené v SOGo (zdieľané alebo nezdieľané alias adresy ukazujúc na minimálne jednu lokálnu poštovú schránku). Ak je skrytý, alias nebude prezentovaný ako voliteľný odosielateľ v SOGo.",
         "spam_alias": "Vytvoriť alebo zmeniť časovo limitované alias adresy",
+        "spam_filter": "Spam filter",
         "spam_policy": "Pridať alebo odstrániť položky do bielej/čiernej listiny",
         "spam_score": "Stanoviť vlastnú spam hodnotu",
         "subfolder2": "Synchronizovať do podadresára na cieli<br><small>(prázdne = nevytvárať podpriečinok)</small>",
         "syncjob": "Upraviť synchronizačnú úlohu",
         "target_address": "Cieľová adresa/y <small>(oddelené čiarkou)</small>",
         "target_domain": "Cieľová doména",
-        "timeout1": "Timeout pre spojenie s diaľkovým hostiteľom",
-        "timeout2": "Timeout pre spojenie s lokálnym hostiteľom",
+        "timeout1": "Timeout pre spojenie s vzdialeným serverom",
+        "timeout2": "Timeout pre spojenie s lokálnym serverom",
         "title": "Upraviť objekt",
         "unchanged_if_empty": "Ak nemeníte, nechajte prázdne",
         "username": "Používateľské meno",
-        "validate_save": "Validovať a uložiť"
+        "validate_save": "Validovať a uložiť",
+        "xmpp": "Aktivovať XMPP pre túto doménu",
+        "xmpp_access": "XMPP prístup",
+        "xmpp_access_info": "XMPP musí byť aktivované pre túto doménu.",
+        "xmpp_admin": "XMPP administrátor",
+        "xmpp_admin_info": "<b>Upozornenie:</b> Povýši užívateľa na XMPP administrátora pre túto doménu.",
+        "xmpp_example_jid": "<b>Príklad JID</b> (prihlásenie s mail heslom)",
+        "xmpp_info": "Aktivovanie tejto funkcie umožní četovanie v tejto doméne.",
+        "xmpp_prefix": "XMPP prefix pre doménu (\"im\" bude použitý ako <b>im</b>.example.org)",
+        "xmpp_prefix_info": "Pre vyžiadanie certifikátov pre XMPP by mali smerovať dva CNAME DNS záznamy z <b>im</b>.example.org ako aj <b>*.im</b>.example.org na <b>%s</b>. Prosím spustie DNS kontrolu po zapnutí XMPP."
+    },
+    "fido2": {
+        "confirm": "Potvrdiť",
+        "fido2_auth": "Prihlásiť sa cez FIDO2",
+        "fido2_success": "Zariadenie úspešne zaregistrované",
+        "fido2_validation_failed": "Overenie zlyhalo",
+        "fn": "Užívateľsky prívetivý názov",
+        "known_ids": "Známe ID",
+        "none": "Vypnuté",
+        "register_status": "Stav registrácie",
+        "rename": "Premenovať",
+        "set_fido2": "Registrovať FIDO2 zariadenie",
+        "set_fn": "Nastaviť zjednodušené meno",
+        "start_fido2_validation": "Spustiť FIDO2 overenie"
     },
     "footer": {
         "cancel": "Zrušiť",
         "confirm_delete": "Potvrďte vymazanie",
         "delete_now": "Vymazať teraz",
         "delete_these_items": "Prosím potvrďte svoje vykonané zmeny nasledujúcemu objektovému id",
+        "hibp_check": "Overiť heslo v databáze hacknutých hesiel haveibeenpwned.com",
         "hibp_nok": "Zhoda! Toto je potenciálne nebezpečné heslo!",
         "hibp_ok": "Nenašla sa zhoda.",
         "loading": "Prosím čakajte...",
+        "nothing_selected": "Nie je nič vybrané",
         "restart_container": "Reštartovať kontajner",
         "restart_container_info": "<b>Dôležité:</b> Reštartovanie môže trvať dlhšie, čakajte prosím ...",
         "restart_now": "Reštartuj teraz",
@@ -591,7 +673,7 @@
         "quarantine": "Karanténa",
         "restart_netfilter": "Reštartovať netfilter",
         "restart_sogo": "Reštart SOGo",
-        "user_settings": "Užívateľské nastavenia"
+        "user_settings": "Používateľské nastavenia"
     },
     "info": {
         "awaiting_tfa_confirmation": "Očakávanie TFA potvrdenia",
@@ -613,43 +695,46 @@
         "active": "Aktívny",
         "add": "Pridať",
         "add_alias": "Pridať alias",
-        "add_bcc_entry": "Pridať BCC mapu",
+        "add_alias_expand": "Rozšíriť alias o alias domény",
+        "add_bcc_entry": "Pridať skrytú kópiu",
         "add_domain": "Pridať doménu",
-        "add_domain_alias": "Pridať alias domény",
+        "add_domain_alias": "Pridať alias doménu",
         "add_domain_record_first": "Prosím pridajte najprv doménu",
         "add_filter": "Pridať filter",
         "add_mailbox": "Pridať poštovú schránku",
         "add_recipient_map_entry": "Pridať mapu príjemcu",
         "add_resource": "Pridať zdroj",
         "add_tls_policy_map": "Pridať TLS mapu pravidiel",
-        "address_rewriting": "Prepisovanie adresy",
+        "address_rewriting": "Prepisovanie adries",
         "alias": "Alias",
-        "alias_domain_alias_hint": "Aliasy <b>nie sú</b> aplikované na aliasy domén automaticky. Alias adresa <code>my-alias@domain</code> <b>nezahŕňa adresu</b> <code>my-alias@alias-domain</code> (kde \"alias-doména\" je imaginárna alias doména pre \"doména\").<br>Prosím použite sieve filter na presmerovanie pošty na externú poštovú schránku (pozri sekciu \"Filtre\" alebo použite SOGo -> Forwarder).",
+        "alias_domain_alias_hint": "Aliasy <b>nie sú</b> aplikované na aliasy domén automaticky. Alias adresa <code>my-alias@domain</code> <b>nezahŕňa adresu</b> <code>my-alias@alias-domain</code> (kde \"alias-doména\" je imaginárna alias doména pre \"doména\").<br>Prosím použite sieve filter na presmerovanie pošty na externú poštovú schránku (pozri sekciu \"Filtre\" alebo použite SOGo -> Forwarder). Použite \"Rozšíriť alias o aliasové domény\" na automatické doplnenie chýbajúcich aliasov.",
         "alias_domain_backupmx": "Doménový alias je neaktívny pre preposielaciu doménu",
         "aliases": "Aliasy",
+        "all_domains": "Všetky Domény",
         "allow_from_smtp": "Umožniť iba týmto IP adresám používať <b>SMTP</b>",
-        "allow_from_smtp_info": "Nechať prázdne pre povolenie všetkých odosielateľov.<br>IPv4/IPv6 adresy a siete.",
+        "allow_from_smtp_info": "Nechajte prázdne pre povolenie všetkých odosielateľov.<br>IPv4/IPv6 adresy a siete.",
         "allowed_protocols": "Povolené protokoly",
         "backup_mx": "Preposielať doménu",
         "bcc": "BCC",
-        "bcc_destination": "BCC cieľ",
-        "bcc_destinations": "BCC ciele",
-        "bcc_info": "BCC mapy sú používané na preposlanie kópií všetkých správ na ďalšiu adresu. Mapa príjemcov je použitá, keď lokálny cieľ je príjemcom správy. Mapy odosielateľov podliehajú tomu istému princípu.<br/>\r\n Lokálny cieľ nebude informovaný o zlyhanom doručení.",
-        "bcc_local_dest": "Lokálny cieľ",
-        "bcc_map": "BCC mapa",
-        "bcc_map_type": "BCC typ mapy",
-        "bcc_maps": "BCC mapy",
-        "bcc_rcpt_map": "Mapa príjemcu",
-        "bcc_sender_map": "Mapa odosielateľa",
-        "bcc_to_rcpt": "Prepnúť na mapu príjemcu",
-        "bcc_to_sender": "Prepnúť na mapu odosielateľa",
-        "bcc_type": "BCC typ",
-        "booking_0": "Vždy ukázať ako voľný",
-        "booking_0_short": "Neustále voľno",
-        "booking_custom": "Tvrdý limit nastaviteľné množstvo rezervácií",
+        "bcc_destination": "Cieľ kópie",
+        "bcc_destinations": "Ciele kópií",
+        "bcc_info": "Skyté kópie (BCC mapy) sú používané na preposlanie skrytých kópií všetkých správ na ďalšiu adresu. Pri použití skrytej kópie typu <i>Prijatý e-mail</i> budú preposlané všetky maily smerujúce na dotyčnú adresu alebo doménu.\nPri type <i>Odoslaný e-mail</i> budú preposlané všetky maily odoslané z dotyčnej adresy alebo domény.\nPokiaľ zlyhá preposlanie na cieľovú adresu, tak odosielateľ o tom nebude informovaný.",
+        "bcc_local_dest": "Týka sa",
+        "bcc_map": "Skrytá kópia",
+        "bcc_map_type": "Typ skrytej kópie",
+        "bcc_maps": "Skryté kópie",
+        "bcc_rcpt_map": "Prijatý e-mail",
+        "bcc_sender_map": "Odoslaný e-mail",
+        "bcc_to_rcpt": "Prepnúť typ na Prijatý e-mail",
+        "bcc_to_sender": "Prepnúť typ na Odoslaný e-mail",
+        "bcc_type": "Typ skrytej kópie",
+        "booking_0": "Vždy zobraziť ako voľný",
+        "booking_0_short": "Neustále voľný",
+        "booking_custom": "Limitované na pevný počet rezervácií",
         "booking_custom_short": "Tvrdý limit",
         "booking_lt0": "Bez limitu, ale zobraziť obsadené po rezervácii",
-        "booking_lt0_short": "Mäkký limit",
+        "booking_lt0_short": "Voľný limit",
+        "catch_all": "Doménový kôš",
         "daily": "Denný",
         "deactivate": "Deaktivovať",
         "description": "Popis",
@@ -657,30 +742,33 @@
         "disable_x": "Pozastaviť",
         "domain": "Doména",
         "domain_admins": "Administrátori domény",
-        "domain_aliases": "Aliasy domény",
+        "domain_aliases": "Alias domény",
         "domain_quota": "Kvóta",
         "domains": "Domény",
         "edit": "Upraviť",
         "empty": "Žiadne výsledky",
         "enable_x": "Povolené",
         "excludes": "Vyraďuje",
-        "filter_table": "Tabuľka filtrov",
+        "filter_table": "Filtrovať tabuľku",
         "filters": "Filtre",
         "fname": "Celé meno",
+        "goto_ham": "Považovať za <b>ham</b>",
+        "goto_spam": "Považovať za <b>spam</b>",
         "hourly": "Hodinový",
         "in_use": "Obsadenosť (%)",
         "inactive": "Neaktívny",
         "insert_preset": "Vložiť vzor nastavenia \"%s\"",
         "kind": "Druh",
         "last_mail_login": "Posledné prihlásenie",
+        "last_pw_change": "Naposledy zmenené heslo",
         "last_run": "Posledné spustenie",
-        "last_run_reset": "Naplánovať ďalší",
+        "last_run_reset": "Znovu naplánovať",
         "mailbox": "Poštová schránka",
+        "mailbox_defaults": "Predvolené nastavenia",
+        "mailbox_defaults_info": "Definuje predvolené nastavenia pre nové schránky",
         "mailbox_defquota": "Predvolená veľkosť schránky",
         "mailbox_quota": "Max. veľkosť schránky",
         "mailboxes": "Poštové schránky",
-        "mailbox_defaults": "Predvolené nastavenia",
-        "mailbox_defaults_info": "Definuje predvolené nastavenia pre nové schránky",
         "mins_interval": "Interval (min)",
         "msg_num": "Počet správ",
         "multiple_bookings": "Viaceré rezervácie",
@@ -688,15 +776,17 @@
         "no": "&#10005;",
         "no_record": "Žiaden záznam pre objekt %s",
         "no_record_single": "Žiaden záznam",
+        "open_logs": "Otvoriť záznam",
         "owner": "Majiteľ",
         "private_comment": "Súkromný komentár",
         "public_comment": "Verejný komentár",
         "q_add_header": "Priečinok nevyžiadaná pošta",
         "q_all": "Všetky kategórie",
         "q_reject": "Odmietnutá",
-        "quarantine_notification": "Karanténne notifikácie",
         "quarantine_category": "Kategória karanténnych notifikácií",
+        "quarantine_notification": "Karanténne notifikácie",
         "quick_actions": "Akcia",
+        "recipient": "Prijatý e-mail",
         "recipient_map": "Mapa príjemcu",
         "recipient_map_info": "Mapy príjemcov sú používané ako náhrada cieľovej adresy u správy pred doručením.",
         "recipient_map_new": "Nový príjemca",
@@ -707,9 +797,10 @@
         "remove": "Odstrániť",
         "resources": "Zdroje",
         "running": "Bežiaci",
+        "sender": "Odoslaný e-mail",
         "set_postfilter": "Označiť ako postfilter",
         "set_prefilter": "Označiť ako prefilter",
-        "sieve_info": "Môžete uchovávať viacero filtrov pre používateľa, ale iba jeden prefilter a jeden postfilter môže byť aktívny v daný okamih.<br>\r\n Každý filter bude spracovaný v nastavenom poradí. Ani zlyhanie skriptu alebo zadržanie nezastaví spracovanie ďalších skriptov. Po úprave sieve filtrov bude nasledovať reštart dovecotu.<br><br>Globálny sieve prefilter → Prefilter → Skripty používateľa → Postfilter → Globálny sieve postfilter",
+        "sieve_info": "Môžete uchovávať viacero filtrov pre používateľa, ale iba jeden prefilter a jeden postfilter môže byť aktívny v daný okamih.<br>\r\n Každý filter bude spracovaný v nastavenom poradí. Ani zlyhanie skriptu alebo zadržanie nezastaví spracovanie ďalších skriptov. Po úprave sieve filtrov bude nasledovať reštart dovecotu.<br><br>Globálny sieve prefilter &#8226; Prefilter &#8226; Skripty používateľa &#8226; Postfilter &#8226; Globálny sieve postfilter",
         "sieve_preset_1": "Vyradiť poštu s pravdepodobnými typmi nebezpečných súborov",
         "sieve_preset_2": "Neustále označovať poštu špecifického odosielateľa ako videnú",
         "sieve_preset_3": "Potichu zahodiť a zastaviť všetky nasledovné spracovanie sieve filtrami",
@@ -719,10 +810,9 @@
         "sieve_preset_7": "Presmerovať a uchovať/zahodiť",
         "sieve_preset_8": "Zahodiť správu odoslanú na alias adresu, ktorej je odosielateľ súčasťou",
         "sieve_preset_header": "Prosím pozrite sa na ukážku nižšie. Pre viac informácií pozrite <a href=\"https://en.wikipedia.org/wiki/Sieve_(mail_filtering_language)\" target=\"_blank\">Wikipedia</a>.",
-        "sogo_allow_admin_hint": "Administratívne SOGo prihlásenia sú dostupné pre poštové schránky s existujúcim SOGo profilom. Požívateľ musí byť prihlásený do SOGo najmenej raz.",
         "sogo_visible": "Alias je viditeľný v SOGo",
         "sogo_visible_n": "Skryť alias v SOGo",
-        "sogo_visible_y": "Ukázať alias v SOGo",
+        "sogo_visible_y": "Zobraziť alias v SOGo",
         "spam_aliases": "Dočasný alias",
         "stats": "Štatistika",
         "status": "Status",
@@ -739,11 +829,11 @@
         "tls_map_parameters_info": "Prázdny alebo parametre, napríklad: protocols=!SSLv2 ciphers=medium exclude=3DES",
         "tls_map_policy": "Podmienky",
         "tls_policy_maps": "Mapy TLS pravidiel",
-        "tls_policy_maps_info": "Táto mapa prevažuje nad TLS pravidlami nezávisle od TLS pravidiel jednotlivých používateľov.<br>\r\n  Viac informácií navštívte <a href=\"http://www.postfix.org/postconf.5.html#smtp_tls_policy_maps\" target=\"_blank\"> info k \"smtp_tls_policy_maps\" </a>",
         "tls_policy_maps_enforced_tls": "Tieto politiky prepisujú používateľské nastavenia pre poštové schránky ktore majú vynútene odchodzie TLS pripojenie. Ak nižšie nie sú uvedené žiadne pravidlá, budú použité ako východzie pravidlá <code>smtp_tls_mandatory_protocols</code> a <code>smtp_tls_mandatory_ciphers</code>.",
+        "tls_policy_maps_info": "Táto mapa prevažuje nad TLS pravidlami nezávisle od TLS pravidiel jednotlivých používateľov.<br>\r\n  Viac informácií navštívte <a href=\"http://www.postfix.org/postconf.5.html#smtp_tls_policy_maps\" target=\"_blank\"> info k \"smtp_tls_policy_maps\" </a>",
         "tls_policy_maps_long": "Prepisovanie TLS pravidiel pre odosielanie",
         "toggle_all": "Označiť všetky",
-        "username": "Užívateľské meno",
+        "username": "Používateľské meno",
         "waiting": "Čakanie",
         "weekly": "Týždenný",
         "yes": "&#10003;"
@@ -782,6 +872,9 @@
         "qitem": "Karanténna položka",
         "quarantine": "Karanténa",
         "quick_actions": "Akcia",
+        "quick_delete_link": "Otvoriť link pre zmazanie",
+        "quick_info_link": "Otvoriť link pre info",
+        "quick_release_link": "Otvoriť link pre uvoľnenie",
         "rcpt": "Príjemca",
         "received": "Prijaté",
         "recipients": "Príjemcovia",
@@ -795,11 +888,8 @@
         "rspamd_result": "Rspamd výsledok",
         "sender": "Odosielateľ (SMTP)",
         "sender_header": "Odosielateľ (\"From\" hlavička)",
-        "type": "Typ",
-        "quick_release_link": "Otvoriť link pre uvoľnenie",
-        "quick_delete_link": "Otvoriť link pre zmazanie",
-        "quick_info_link": "Otvoriť link pre info",
-        "show_item": "Ukázať súbor",
+        "settings_info": "Maximálne množstvo položiek ktoré sa umiestnia do karantény: %s<br>Maximálna veľkosť emailu: %s MiB",
+        "show_item": "Zobraziť súbor",
         "spam": "Spam",
         "spam_score": "Výsledok",
         "subj": "Predmet",
@@ -807,7 +897,15 @@
         "table_size_show_n": "Zobraziť %s položiek",
         "text_from_html_content": "Obsah (konvertovaný html)",
         "text_plain_content": "Obsah (text/jednoduchý)",
-        "toggle_all": "Označiť všetky"
+        "toggle_all": "Označiť všetky",
+        "type": "Typ"
+    },
+    "ratelimit": {
+	    "disabled": "Vypnuté",
+	    "second": "správ za sekundu",
+	    "minute": "správ za minútu",
+	    "hour": "správ za hodinu",
+	    "day": "správ za deň"
     },
     "start": {
         "help": "Zobraziť/Skryť panel nápoveď",
@@ -847,9 +945,9 @@
         "domain_admin_removed": "Administrátorská doména %s odstránená",
         "domain_modified": "Zmeny v doméne %s uložené",
         "domain_removed": "Doména %s odstránená",
-        "dovecot_restart_success": "Dovecot sa úspešne reštartoval",        
+        "dovecot_restart_success": "Dovecot sa úspešne reštartoval",
         "eas_reset": "ActiveSync zariadenia pre používateľa %s resetovaný",
-        "f2b_modified": "Zmeny v Fail2ban parametroch uložené",
+        "f2b_modified": "Zmeny v parametroch automatického firewallu uložené",
         "forwarding_host_added": "Doručovací hostiteľ %s pridaný",
         "forwarding_host_removed": "Doručovací hostiteľ %s vymazaný",
         "global_filter_written": "Filter bol úspešne zapísaný do súboru",
@@ -864,7 +962,9 @@
         "mailbox_added": "Poštová schránka %s pridaná",
         "mailbox_modified": "Zmeny v poštovej schránke %s uložené",
         "mailbox_removed": "Mailbox %s odstránený ",
+        "nginx_reloaded": "Nginx sa reloadol",
         "object_modified": "Zmeny v objekte %s uložené",
+        "password_policy_saved": "Politika hesiel bola úspešne uložená",
         "pushover_settings_edited": "Pushover úspešne nastavený, skontrolujte si prístupové údaje.",
         "qlearn_spam": "Správa s ID %s považovaná za spam a vymazaná",
         "queue_command_success": "Príkaz pre poštovú frontu úspešne dokončený",
@@ -876,7 +976,7 @@
         "resource_added": "Zdroj %s pridaný",
         "resource_modified": "Zmeny v poštovej schránke %s uložené",
         "resource_removed": "Zdroj %s odstránený",
-        "rl_saved": "Limit prenosu pre objekt %s uložený",
+        "rl_saved": "Obmedzenie prenosu pre objekt %s uložený",
         "rspamd_ui_pw_set": "Heslo pre Rspamd rozhranie úspešne nastavené",
         "saved_settings": "Uložené nastavenia",
         "settings_map_added": "Pridaná mapa nastavení",
@@ -886,10 +986,13 @@
         "tls_policy_map_entry_saved": "Položka mapy TLS pravidiel \"%s\" uložená",
         "ui_texts": "Zmeny v UI textoch uložené",
         "upload_success": "Súbor úspešne nahratý",
+        "verified_fido2_login": "Overené FIDO2 prihlásenie",
         "verified_totp_login": "Overené TOTP prihlásenie",
         "verified_u2f_login": "Overené U2F prihlásenie",
-        "verified_fido2_login": "Overené FIDO2 prihlásenie",
-        "verified_yotp_login": "Overené Yubico OTP prihlásenie"
+        "verified_yotp_login": "Overené Yubico OTP prihlásenie",
+        "xmpp_maps_updated": "XMPP mapy boli aktualizované",
+        "xmpp_reloaded": "XMPP služba sa reloadla",
+        "xmpp_restarted": "XMPP služba sa reštartovala"
     },
     "tfa": {
         "api_register": "%s využíva Yubico Cloud API. Prosím, zaobstarajte si API kľúč pre váš kľúč <a href=\"https://upgrade.yubico.com/getapikey/\" target=\"_blank\">tu</a>",
@@ -908,7 +1011,7 @@
         "select": "Prosím vyberte",
         "set_tfa": "Nastaviť dvojúrovňovú autentifikačnú metódu",
         "start_u2f_validation": "Spustiť validáciu",
-        "tfa": "Dvojúrovňová autentifikácia",
+        "tfa": "Dvojúrovňová autentifikácia (TFA)",
         "tfa_token_invalid": "Neplatný TFA token",
         "totp": "Časovo-založený OTP (Google Authenticator, Authy, atď.)",
         "u2f": "U2F autentifikácia",
@@ -916,34 +1019,20 @@
         "waiting_usb_register": "<i>Čakanie na USB zariadenie...</i><br><br>Prosím zadajte vaše heslo a potvrďte registráciu stlačením tlačidla na vašom USB zariadení.",
         "yubi_otp": "Yubico OTP autentifikácia"
     },
-    "fido2": {
-        "set_fn": "Nastaviť zjednodušené meno",
-        "fn": "Zjednodušené meno",
-        "rename": "premenovať",
-        "confirm": "Potvrdiť",
-        "register_status": "Stav registrácie",
-        "known_ids": "Známe ID",
-        "none": "Vypnuté",
-        "set_fido2": "Registrovať FIDO2 zariadenie",
-        "start_fido2_validation": "Spustiť FIDO2 overenie",
-        "fido2_auth": "Prihlásiť sa cez FIDO2",
-        "fido2_success": "Zariadenie úspešne zaregistrované",
-        "fido2_validation_failed": "Overenie zlyhalo"
-    },
     "user": {
         "action": "Akcia",
         "active": "Aktívny",
         "active_sieve": "Aktívny filter",
         "advanced_settings": "Pokročilé nastavenia",
         "alias": "Alias",
-        "alias_create_random": "Generovať náhodný alias.",
+        "alias_create_random": "Generovať náhodný alias",
         "alias_extend_all": "Predĺžiť aliasy o ďalšiu hodinu",
         "alias_full_date": "d.m.R, H:i:s T",
         "alias_remove_all": "Odstrániť všetky aliasy",
         "alias_select_validity": "Lehota platnosti",
         "alias_time_left": "Zostávajúci čas",
         "alias_valid_until": "Platné do",
-        "aliases_also_send_as": "Taktiež povolené poslať ako používateľ",
+        "aliases_also_send_as": "Môže odosielať ako používateľ",
         "aliases_send_as_all": "Nekontrolovať prístup odosielateľa pre nasledujúcu doménu/y a jej alias domény",
         "app_hint": "Heslá aplikácií sú alternatívne heslá pre vaše <b>IMAP a SMTP</b> prihlásenie. Používateľské meno zostáva nezmenené.<br>SOGo (zahŕňajúc ActiveSync) nie je momentálne podporovaný.",
         "app_name": "Meno aplikácie",
@@ -952,43 +1041,57 @@
         "apple_connection_profile_complete": "Tento profil zahŕňa IMAP a SMTP parametre, ako aj CalDAV (kalendáre) a CardDAV (kontakty) pre zariadenia Apple.",
         "apple_connection_profile_mailonly": "Tento profil zahŕňa IMAP a SMTP konfiguračné parametre pre zariadenia Apple.",
         "change_password": "Zmeniť heslo",
-        "client_configuration": "Ukázať konfiguračné pokyny pre emailových klientov a smartfóny",
+        "clear_recent_successful_connections": "Vymazať nedávne úspešné prihlásenia",
+        "client_configuration": "Zobraziť konfiguračné pokyny pre emailových klientov a smartfóny",
         "create_app_passwd": "Vytvoriť heslo aplikácie",
         "create_syncjob": "Vytvoriť novú synchronizačnú úlohu",
+        "created_on": "Vytvorené",
         "daily": "Denne",
         "day": "deň",
         "delete_ays": "Potvrďte zmazanie.",
         "direct_aliases": "Priame alias adresy",
-        "direct_aliases_desc": "Priame alias adresy sú ovplyvnené spam filtrom a nastaveniami TLS pravidiel.",
+        "direct_aliases_desc": "Priame aliasy sú ovplyvnené spam filtrom a nastavením TLS pravidiel.",
         "eas_reset": "Resetovať medzipamäť u ActiveSync zariadení",
-        "eas_reset_help": "Vo väčšine prípadov, reset medzipamäte ActiveSync môže opravit nefunkčný profil.<br><b>Pozor:</b> Všetky potrebné dáta budú opäť stiahnuté!",
-        "eas_reset_now": "Resetovať medzipamäť teraz",
+        "eas_reset_help": "Vo väčšine prípadov, reset medzipamäte ActiveSync pomôže opravit nefunkčný profil.<br><b>Pozor:</b> Všetky potrebné dáta budú opäť stiahnuté!",
+        "eas_reset_now": "Reset ActiveSync",
         "edit": "Upraviť",
         "email": "Email",
         "email_and_dav": "Email, kalendáre a kontakty",
+        "empty": "Nie sú k dispozícii žiadne záznamy",
         "encryption": "Zašifrovanie",
         "excludes": "Nezahŕňa",
         "expire_in": "Vyprší za",
+        "fido2_webauthn": "FIDO2/WebAuthn",
         "force_pw_update": "<b>Musíte</b> nastaviť nové heslo, aby ste mohli získať opätovný prístup ku groupware a súvisiacim službám.",
+        "from": "od",
         "generate": "generuj",
         "hour": "hodinu",
         "hourly": "Každú hodinu",
         "hours": "hodiny",
         "in_use": "Použité",
         "interval": "Interval",
-        "is_catch_all": "Catch-all pre doménu/y",
+        "is_catch_all": "Doménový kôš",
         "last_mail_login": "Posledné poštové prihlásenie",
+        "last_pw_change": "Naposledy zmenené heslo",
         "last_run": "Posledné spustenie",
+        "last_ui_login": "Posledné prihlásenie do web rozhrania",
         "loading": "Načítavanie...",
-        "mailbox_details": "Nastavenie schránky",
+        "login_history": "História prihlásenia",
+        "mailbox": "Poštová schránka",
+        "mailbox_details": "Detail",
+        "mailbox_general": "Všeobecné",
+        "mailbox_settings": "Nastavenia",
         "messages": "správy",
+        "month": "mesiac",
+        "months": "mesiace",
         "never": "Nikdy",
         "new_password": "Nové heslo",
-        "new_password_description": "Požiadavka: Minimálne 6 znakov, písmená a číslice.",
         "new_password_repeat": "Potvrdiť heslo (opakovať)",
         "no_active_filter": "Nie je dostupný žiadny aktívny filter.",
         "no_last_login": "Žiadne informácie o UI prihlásení.",
         "no_record": "Žiaden záznam",
+        "open_logs": "Otvoriť záznam",
+        "open_webmail_sso": "Prihláste sa do webmailu",
         "password": "Heslo",
         "password_now": "Aktuálne heslo (potvrdiť zmeny)",
         "password_repeat": "Heslo (opakovať)",
@@ -996,7 +1099,7 @@
         "pushover_info": "Push notifikácie budú aplikované na všetky správy (s výnimkou spamu) doručené pre <b>%s</b> vrátane aliasov (zdieľané, nezdieľané, označené).",
         "pushover_only_x_prio": "Vyberať len správy s vysokou prioritou [<code>X-Priority: 1</code>]",
         "pushover_sender_array": "Zohľadňujú sa nasledujúce adresy odosielateľa <small>(oddelené čiarkou)</small>",
-        "pushover_sender_regex": "Užívateľ vybraný regulérnym výrazom",
+        "pushover_sender_regex": "Odosielateľ vybraný regulárnym výrazom",
         "pushover_text": "Text notifikácie",
         "pushover_title": "Názov notifikácie",
         "pushover_vars": "Ak nie je definovaný žiadny filter odosielateľa, zohľadnia sa všetky správy.<br>Priama kontrola odosielateľa a regulárne výrazy sa kontrolujú nezávisle od seba, <b>nezávisia od seba navzájom</b> a vykonávajú sa postupne.<br>Použiteľné premenné pre názov a text (dodržujte pokyny na ochranu osobných údajov)",
@@ -1004,26 +1107,28 @@
         "q_add_header": "Priečinok nevyžiadná pošta",
         "q_all": "Všetky kategórie",
         "q_reject": "Odmietnutá",
-        "quarantine_notification": "Karanténne notifikácie",
         "quarantine_category": "Kategória karanténnych notifikácií",
-        "quarantine_notification_info": "Akonáhle sa odošle notifikáica, položky budú označené ako \"notifikované\" a žiadne ďalšie notifikácie nebudú poslané pre túto špecifickú položku.",
-        "quarantine_category_info": "Kategória notifikácií \"Odmietnutá\" zahŕňa poštu ktorá bola odmietnutá, kde \"Nevyžiadná pošta\" bude notifikovať používateľa o pošte vloženej do priečinka Nevyžiadná pošta.",
+        "quarantine_category_info": "Kategória notifikácií \"Odmietnutá\" zahŕňa poštu ktorá bola odmietnutá, a \"Nevyžiadná pošta\" zahŕňa notifikácie o pošte uloženej do priečinka Nevyžiadná pošta.",
+        "quarantine_notification": "Karanténne notifikácie",
+        "quarantine_notification_info": "Akonáhle sa odošle notifikácia, položky budú označené ako \"notifikované\" a žiadne ďalšie notifikácie nebudú zasielané pre túto položku.",
+        "recent_successful_connections": "Nedávne úspešné prihlásenia",
         "remove": "Odstrániť",
         "running": "Beží",
+        "save": "Uložiť zmeny",
         "save_changes": "Uložiť zmeny",
         "sender_acl_disabled": "<span class=\"label label-danger\">Kontrola odosielateľa je pozastavená</span>",
         "shared_aliases": "Zdieľané alias adresy",
-        "shared_aliases_desc": "Zdieľané aliasy nie sú ovplyvnené používateľskými špecifickými nastaveniami, ako spam filter alebo šifrovacie podmienky. Zodpovedajúce spam filtre môžu byť vytvorené len administrátorom podľa podmienok domén.",
-        "show_sieve_filters": "Ukázať sieve filter aktívneho používateľa",
+        "shared_aliases_desc": "Zdieľané aliasy nie sú ovplyvnené používateľskými nastaveniami, ako spam filter alebo šifrovacie pravidlá. Zodpovedajúce spam filtre môžu byť vytvorené len administrátorom podľa podmienok domén.",
+        "show_sieve_filters": "Zobraziť sieve filter aktívneho používateľa",
         "sogo_profile_reset": "Resetnúť SOGo profil",
-        "sogo_profile_reset_help": "Táto činnosť odstraní SOGo profil používateľa a <b>nenávratne vymaže všetky kontakty a kalendárové dáta</b>.",
-        "sogo_profile_reset_now": "Resetnúť profil teraz",
+        "sogo_profile_reset_help": "Táto činnosť odstraní SOGo profil používateľa a <b>nenávratne vymaže všetky kontakty a kalendár</b>.",
+        "sogo_profile_reset_now": "Resetnúť profil",
         "spam_aliases": "Dočasný poštový alias",
         "spam_score_reset": "Obnoviť pôvodné spam nastavenia",
         "spamfilter": "Spam filter",
         "spamfilter_behavior": "Hodnotenie",
         "spamfilter_bl": "Čierna listina - blacklist",
-        "spamfilter_bl_desc": "Adresy na tomto zozname budú <b>vždy</b> klasifikované ako spam a budú odmietnuté. Odmietnutá pošta <b>nebude</b> zaradená do karantény. Môže byť použitý widlcard záznam (*). Filter je aplikovaný len na priame aliasy (aliasy s jedným cieľovým mailboxom) s výnimkou catch-all aliasov a samotnou schránkou.",
+        "spamfilter_bl_desc": "Adresy na tomto zozname budú <b>vždy</b> klasifikované ako spam a budú odmietnuté. Odmietnutá pošta <b>nebude</b> zaradená do karantény. Môže byť použitý widlcard záznam (*). Filter je aplikovaný len na priame aliasy (aliasy s jedným cieľovým mailboxom) s výnimkou doménových košov a samotnou schránkou.",
         "spamfilter_default_score": "Implicitné nastavenia",
         "spamfilter_green": "Zelená: Táto správa nie je spam",
         "spamfilter_hint": "Prvá hodnota opisuje \"nízku spam hodnotu\" a druhá opisuje \"vysokú spam hodnotu\".",
@@ -1035,11 +1140,11 @@
         "spamfilter_table_remove": "odstrániť",
         "spamfilter_table_rule": "Podmienka",
         "spamfilter_wl": "Biela listina - whitelist",
-        "spamfilter_wl_desc": "Adresy na tomto zozname nebudú <b>nikdy klasifikované ako spam</b>. Môže byť použitý wildcard záznam (*). Filter je aplikovaný len na priame aliasy (aliasy s jednou cieľovou schránkou) s výnimkou catch-all aliasov a samotnou schránkou.",
+        "spamfilter_wl_desc": "Adresy na tomto zozname nebudú <b>nikdy klasifikované ako spam</b>. Môže byť použitý wildcard záznam (*). Filter je aplikovaný len na priame aliasy (aliasy s jednou cieľovou schránkou) s výnimkou doménových košov a samotnou schránkou.",
         "spamfilter_yellow": "Žltá: Táto správa môže byť spam, bude označená ako spam a presunutá do priečinku nevyžiadanej pošty",
         "status": "Status",
         "sync_jobs": "Synchronizačné úlohy",
-        "tag_handling": "Nastaviť chovanie pre označenú poštu",
+        "tag_handling": "Zaobchádzanie s označenou poštou",
         "tag_help_example": "Príklad tagu e-mailovej adresy: me<b>+Facebook</b>@example.org",
         "tag_help_explain": "V podadresári: nový podadresár s menom tag-u bude vytvorený nižšie INBOX (\"INBOX/Facebook\").<br>\r\nIn subject: meno štítka bude pridané pred predmet pošty, napríklad: \"[Facebook] My News\".",
         "tag_in_none": "Žiadne kroky",
@@ -1048,16 +1153,18 @@
         "text": "Text",
         "title": "Názov",
         "tls_enforce_in": "Vynútiť TLS pre prichádzajúcu poštu",
-        "tls_enforce_out": "Vynútiť TLS odchádzajúcu poštu",
+        "tls_enforce_out": "Vynútiť TLS pre odchádzajúcu poštu",
         "tls_policy": "TLS pravidlá",
-        "tls_policy_warning": "<strong>Upozornenie:</strong> Ak sa rozhodnete vynútiť zašifrovaný poštový prenos, môže príjsť k strate e-mailov.<br>Správy nespĺňajúce túto podmienku budú trvalo odmietané serverom.<br>Táto možnosť platí pre vašu primárnu emailovú adresu (prihlasovacie meno), všetky odvodené adresy ako aj alias <b>cieľovej poštovej schránky</b>.",
-        "user_settings": "Užívateľské nastavenia",
+        "tls_policy_warning": "<strong>Upozornenie:</strong> Ak sa rozhodnete vynútiť šifrovaný prenos, môže prísť k strate e-mailov.<br>Správy nespĺňajúce túto podmienku budú trvalo odmietané serverom.<br>Táto možnosť platí pre vašu primárnu emailovú adresu (prihlasovacie meno), všetky odvodené adresy ako aj alias <b>cieľovej poštovej schránky</b>.",
+        "user_settings": "Používateľské nastavenia",
         "username": "Prihlasovacie meno",
         "verify": "Overiť",
         "waiting": "Čakanie",
         "week": "týždeň",
         "weekly": "Týždenne",
-        "weeks": "týždne"
+        "weeks": "týždne",
+        "year": "rok",
+        "years": "rokov"
     },
     "warning": {
         "cannot_delete_self": "Nemožno vymazať prihláseného používateľa",
@@ -1066,6 +1173,7 @@
         "fuzzy_learn_error": "Chyba počas učenia Fuzzy hash: %s",
         "hash_not_found": "Chýbajúci hash",
         "ip_invalid": "Preskočená neplatná IP adresa: %s",
+        "is_not_primary_alias": "Preskočiť ne-primárny alias %s",
         "no_active_admin": "Nemožno deaktivovať posledného aktívneho admina",
         "quota_exceeded_scope": "Prekročená kvóta domény, pre túto doménu je možné vytvárať iba neobmedzené poštové schránky.",
         "session_token": "Formulárový token neplatný: Tokenová nezhoda",
diff --git a/mailcow/src/mailcow-dockerized/data/web/lang/lang.sv.json b/mailcow/src/mailcow-dockerized/data/web/lang/lang.sv.json
index 39aa588..d4e1daf 100644
--- a/mailcow/src/mailcow-dockerized/data/web/lang/lang.sv.json
+++ b/mailcow/src/mailcow-dockerized/data/web/lang/lang.sv.json
@@ -26,7 +26,11 @@
         "syncjobs": "synkroniseringsjobb",
         "tls_policy": "Krypteringspolicy",
         "unlimited_quota": "Obegränsad kvot för postlådor",
-        "domain_desc": "Ändra domänbeskrivningen"
+        "domain_desc": "Ändra domänbeskrivningen",
+        "xmpp_admin": "Ändra XMPP administratörs-status på en användare",
+        "xmpp_domain_access": "Ändra XMPP-åtkomsten på en domän",
+        "xmpp_mailbox_access": "Ändra XMPP-åtkomsten på en användare",
+        "xmpp_prefix": "Ändra XMPP-subdomän/prefix"
     },
     "add": {
         "activate_filter_warn": "Alla andra filter av den här typen kommer inaktiveras om det här skriptet markeras som aktivt.",
@@ -35,9 +39,9 @@
         "add_domain_only": "Lägg bara till domänen",
         "add_domain_restart": "Lägg till domänen, och starta om SOGo",
         "alias_address": "Alias-adress/adresser",
-        "alias_address_info": "<small>Fulständig e-postadress/adresser, eller @example.com för att fånga alla meddelanden för en domän (kommaseparerade). <b>endast mailcow domäner</b>.</small>",
+        "alias_address_info": "<small>Fulständig e-postadress/adresser, eller @example.com för att fånga alla meddelanden på en domän (separerade med komma). <b>endast mailcow domäner</b>.</small>",
         "alias_domain": "Aliasdomän",
-        "alias_domain_info": "<small>Endast giltiga domännamn (kommaseparerade).</small>",
+        "alias_domain_info": "<small>Endast giltiga domännamn (separerade med komma).</small>",
         "app_name": "Applikationsnamn",
         "app_password": "Lägg till applikationslösenord",
         "automap": "Koppla automatiskt de vanliga e-post katalogerna (\"Skickade meddelanden\", \"Skickat\" => \"Skickat\" mm)",
@@ -59,6 +63,14 @@
         "full_name": "Fullständiga namn",
         "gal": "Global adressbok",
         "gal_info": "Den global adressboken innehåller alla objekt i en domän och kan inte redigeras av någon användare. Informationen om tillgänglighet i SOGo är endast synlig när den globala adressboken är påslagen.  <b>Starta om SOGo för att tillämpa ändringar.</b>",
+        "xmpp": "Aktivera XMPP funktion på denna domän",
+        "xmpp_prefix": "XMPP-prefix för domänen (Exempelvis \"im\" för <b>im</b>.example.org)",
+        "xmpp_prefix_info": "För att tillhandahålla ett säkerhetscertifikat måste vissa DNS-uppslag skapas, exempelvis två CNAME uppslag, ett för <b>im</b>.example.org och ett för <b>*.im</b>.example.org, som pekar mot <b>%s</b>. Efter att denna funktion har aktiverats, utför en DNS-kontroll för att testa att uppslagen är korrekt uppsatta.",
+        "xmpp_info": "Denna funktion aktiverar chatt-funktionalitet på denna domän.",
+        "xmpp_access": "XMPP-åtkomst",
+        "xmpp_access_info": "XMPP måste aktiveras på den här domänen.",
+        "xmpp_admin": "XMPP Administratör",
+        "xmpp_admin_info": "<b>Varning:</b> Befodrar en användare till XMPP-administratör på den här domänen.",
         "generate": "generera",
         "goto_ham": "Markera detta som en <span class=\"text-success\"><b>felaktig spam-registrering</b>, detta kommer förhindra liknande fel i framtiden</span>",
         "goto_null": "Kasta e-postmeddelanande omedelbart",
@@ -84,7 +96,7 @@
         "relay_all": "Vidarebefordra alla mottagaradresser",
         "relay_all_info": "↪ Om <b>inte</b> alla mottagare ska vidarebefordras måste (\"blinda\") postlådor skapas för varje adress som ska vidarebefordras.",
         "relay_domain": "Vidarebefordra denna domän",
-        "relay_transport_info": "<div class=\"label label-info\">Info</div> Transportkartor kan skapas för att definiera enskilda destinationer för en relädomän.",
+        "relay_transport_info": "<div class=\"label label-info\">Info</div> Transportkartor kan skapas för att definiera enskilda destinationer på en relädomän.",
         "relay_unknown_only": "Vidarebefodra endast om det saknas en lokal postlåda. Existerar det en postlåda kommer det levereras lokalt.",
         "relayhost_wrapped_tls_info": "Använd <b>inte</b> TLS-bundna portar (exempelvis SMTPS via port 465).<br>\r\nTrafiken kommer istället transporteras med TLS genom att använda STARTTLS. En sådan TLS-policy kan skapas under \"TLS-policyföreskrifter\".",
         "select": "Välj ...",
@@ -96,7 +108,7 @@
         "syncjob": "Lägg till synkroniseringsjobb",
         "syncjob_hint": "Observera att lösenord lagras i klartext!",
         "target_address": "Destinationsadresser",
-        "target_address_info": "<small>Fullständig e-postadress/adresser (kommaseparerade).</small>",
+        "target_address_info": "<small>Fullständig e-postadress/adresser (separerade med komma).</small>",
         "target_domain": "Måldomän",
         "timeout1": "Timeout för anslutning till fjärrservern",
         "timeout2": "Timeout för anslutning till lokalserver",
@@ -123,6 +135,8 @@
         "add_transports_hint": "Tänk på att autentiseringsdata lagras okrypterat.",
         "additional_rows": "ytterliggare rader har lagts till",
         "admin": "Administratör",
+        "admins": "Administratörer",
+        "admins_ldap": "LDAP-Administratörer",
         "admin_details": "Hantera administratörer",
         "admin_domains": "Tilldelad domän",
         "advanced_settings": "Avancerade inställningar",
@@ -139,6 +153,7 @@
         "ban_list_info": "Se en lista över banlysta IP-adresser nedan: <b>nätverk (återstående banlysningstid) - [åtgärd]</b>.<br />IP-adresser som står i kö för att tas bort från den aktiva banlysningslistan tas bort inom några sekunder.<br />Röd markering indikerar en aktiv permanent banlysning pga. en svartlistning.",
         "change_logo": "Byt logotyp",
         "configuration": "Konfiguration",
+        "convert_html_to_text": "Konventera HTML till oformaterad text",
         "credentials_transport_warning": "<b>Varning</b>: När en ny reläserver läggs till uppdateras uppgifterna för alla reläservrar som hör till samma värd.",
         "customer_id": "Kundnummer",
         "customize": "Anpassa gränssnittet",
@@ -190,6 +205,7 @@
         "hash_remove_info": "Ta bort kontrollsumman för hastighetsbegränsningen. Det kommer att återställa räknaren helt och hållet.<br>\r\n Varje kontrollsumma är unikt med en induviduell färg.",
         "help_text": "Hjälptext på inloggningssidan (HTML är tillåtet)",
         "host": "Värd",
+        "html": "HTML",
         "import": "Importera",
         "import_private_key": "Importera en privatnyckel",
         "in_use_by": "Används av",
@@ -218,7 +234,15 @@
         "oauth2_redirect_uri": "omdirigerings URI",
         "oauth2_renew_secret": "Generera ny klienthemlighet",
         "oauth2_revoke_tokens": "Återkalla alla klientnycklar",
+        "optional": "Valfri",
         "password": "Lösenord",
+        "password_length": "Lösenordslängd",
+        "password_policy": "Lösenordspolicy",
+        "password_policy_chars": "Måste innehålla minst ett alfabetiskt tecken",
+        "password_policy_length": "Minsta lösenordslängden är %d tecken",
+        "password_policy_numbers": "Måste innehålla minst en siffra",
+        "password_policy_lowerupper": "Måste innehålla både versaler och gemener",
+        "password_policy_special_chars": "Måste innehålla specialtecken",
         "password_repeat": "Lösenord (igen)",
         "priority": "Prioritet",
         "private_key": "Privatnyckel",
@@ -258,6 +282,7 @@
         "regen_api_key": "Generera ny API-nyckel",
         "regex_maps": "Regex-filter",
         "relay_from": "Avsändaradress",
+        "relay_rcpt": "Mottagaradress",
         "relay_run": "Testa reläservern",
         "relayhosts": "Generell reläserver för vidare posttransport",
         "relayhosts_hint": "Ange vilka reläservrar som ska finnas tillgängliga för posttransport, för att kunna välja dessa vid domänkonfigureringen.<br>\r\nTransportprotokollet kommer alltid att vara \"smtp:\", TLS användas om det är tillgängligt och tunnlad TLS (SMTPS) stöds inte. Nuvarande TLS-policyföreskrift för utgående trafik kommer att gälla för transporten.<br>\r\nDetta kommer att påverka den valda domänen, aliasdomäner inkluderat.",
@@ -299,6 +324,7 @@
         "transport_dest_format": "Syntax: example.org, .example.org, *, box@example.org (fler värdar kan anges med kommatecken)",
         "transport_maps": "Destinationsspecifik reläserver för vidare posttransport",
         "transports_hint": "→ En destinationsspecifik reläserver kommer att <b>ignorerar</b> en generell reläserver</b>.<br>\r\n→ Utgående TLS-policy för användarens postlåda kommer ignoreras, men den generella TLS-policyn för servern kommer att tillämpas.<br>\r\n→ Transportprotokollet kommer alltid att vara \"smtp:\", TLS användas om det är tillgängligt och tunnlad TLS (SMTPS) stöds inte.<br>\r\n→ Adresser som matchar \"/localhost$/\" transporteras alltid via \"local:\", därför kommer en \"*\" destination inte vara möjlig för dessa adresser.<br>\r\n→ När uppgifterna för reläservern ska hämtas ex. \"[host]:25\" kommer Postfix <b>först</b> att söka efter \"host\", och sedan söka på \"[host]:25\". Detta görs för att förhindra en situation där både \"host\" och \"[host]:25\" används samtidigt.",
+        "transport_test_rcpt_info": "→ Använd adressen null@hosted.mailcow.de för att testa vidarebefodring till en extern destination.",
         "ui_footer": "Sidfot (HTML-taggar tillåtna)",
         "ui_header_announcement": "Meddelanden",
         "ui_header_announcement_active": "Aktivera meddelandet nu",
@@ -349,7 +375,8 @@
         "from_invalid": "Avsändarens adress måste vara en giltig e-postadress",
         "global_filter_write_error": "Kan inte skriva till filterfilen: %s",
         "global_map_invalid": "Rspamd kartan med ID %s är felaktig",
-        "global_map_write_error": "Kunde inte skriva globalkartan med ID %s: %s",
+        "global_map_write_error": "Kunde inte skapa en global-koppling med ID %s: %s",
+        "xmpp_map_write_error": "Kunde inte skapa en XMPP-koppling: %s",
         "goto_empty": "En aliasadress måste peka mot minst en giltig destinationsadress",
         "goto_invalid": "Destinationsadressen %s är ogiltig",
         "ham_learn_error": "Felaktigt-Spam inlärningsfel: %s",
@@ -362,7 +389,7 @@
         "invalid_host": "Angiven värd är inte giltig: %s",
         "invalid_mime_type": "Grafiken kunde inte valideras: Ogiltig MIME-typ",
         "invalid_nexthop": "Formatet för reläservern är felaktigt",
-        "invalid_nexthop_authenticated": "En reläserver existerar redan, men med andra uppgifter. Uppdatera först uppgifterna för den existerande reläservern.",
+        "invalid_nexthop_authenticated": "En reläserver existerar redan, men med andra uppgifter. Uppdatera först uppgifterna på den existerande reläservern.",
         "invalid_recipient_map_new": "Den nya mottagaren: %s är ogiltid",
         "invalid_recipient_map_old": "Den ursprungliga mottagaren: %s är ogiltig",
         "ip_list_empty": "Listan över tillåtna IP adresser kan inte vara tom",
@@ -384,7 +411,8 @@
         "max_quota_in_use": "Postlådans kvotgräns måste vara större än, eller lika med %d MiB",
         "maxquota_empty": "Max kvoten per mejlåda kan inte vara 0.",
         "mysql_error": "MySQL-fel: %s",
-        "network_host_invalid": "Ntverk, eller värden %s är ogiltig",
+        "nginx_reload_failed": "Misslyckades att ladda om Nginx: %s",
+        "network_host_invalid": "Nätverk, eller värden %s är ogiltig",
         "next_hop_interferes": "%s förhindras av reläservern %s",
         "next_hop_interferes_any": "En befintlig reläserver hindrar skapandet av %s",
         "no_user_defined": "Ingen användare har definierats",
@@ -434,7 +462,9 @@
         "username_invalid": "Användarnamnet %s kan inte användas",
         "validity_missing": "Ange en giltighetsperiod",
         "value_missing": "Ange alla värden",
-        "yotp_verification_failed": "Yubico OTP-verifiering misslyckades: %s"
+        "yotp_verification_failed": "Yubico OTP-verifiering misslyckades: %s",
+        "xmpp_restart_failed": "Misslyckades att starta om XMPP",
+        "xmpp_reload_failed": "Misslyckades att ladda om XMPP"
     },
     "debug": {
         "chart_this_server": "Tabell (denna server)",
@@ -444,24 +474,28 @@
         "history_all_servers": "Historik (alla servrar)",
         "in_memory_logs": "Loggar sparade i minnet",
         "jvm_memory_solr": "JVM minnesanvändning",
-        "log_info": "<p>mailcow <b>loggar sparade i minnet</b> samlas in i Redis-listor och trimmas till LOG_LINES (%d) varje minut för att minska lasten.\r\n  <br>Loggar sparade i minnet är inte tänkta att vara beständiga. Alla applikationer som loggar i minnet loggar också till Docker-demonen och därefter till standardrutinen för loggning.\r\n  <br>Loggar sparade i minnet bör användas för felsökning av mindre problem med olika behållare.</p>\r\n  <p><b>Externa loggar</b> samlas in via ett API för den givna applikationen.</p>\r\n  <p><b>Statiska loggar</b> är mestadels aktivitetsloggar som inte är loggas i Docker, men som fortfarande måste vara beständiga (utom API-loggar).</p>",
+        "log_info": "<p>mailcow <b>loggar sparade i minnet</b> samlas in i Redis-listor och trimmas till LOG_LINES (%d) varje minut för att minska lasten.\r\n  <br>Loggar sparade i minnet är inte tänkta att vara beständiga. Alla applikationer som loggar i minnet loggar också till Docker-demonen och därefter till standardrutinen för loggning.\r\n  <br>Loggar sparade i minnet bör användas för felsökning av mindre problem med olika behållare.</p>\r\n  <p><b>Externa loggar</b> samlas in via ett API på den givna applikationen.</p>\r\n  <p><b>Statiska loggar</b> är mestadels aktivitetsloggar som inte är loggas i Docker, men som fortfarande måste vara beständiga (utom API-loggar).</p>",
         "logs": "Loggar",
         "restart_container": "Omstart",
         "solr_dead": "Solr är i uppstart, har inaktiveras eller är tillfälligt avstängd.",
-        "solr_docs": "Dokumentation",
-        "solr_last_modified": "Senast ändrad",
-        "solr_size": "Storlek",
-        "solr_started_at": "Startades kl.",
+        "xmpp_dead": "XMPP startet, ist deaktiviert oder temporär nicht erreichbar.",
+        "online_users": "Användare online",
+        "docs": "Dokumentation",
+        "last_modified": "Senast ändrad",
+        "size": "Storlek",
+        "started_at": "Startades kl.",
         "solr_status": "Solr status",
-        "solr_uptime": "Upptid",
+        "uptime": "Upptid",
         "started_on": "Startades",
         "static_logs": "Statiska loggar",
-        "system_containers": "System & behållare"
+        "system_containers": "System & behållare",
+        "xmpp_status": "XMPP Status"
     },
     "diagnostics": {
         "cname_from_a": "Värde härstammar från A/AAAA-uppslaget. Detta stöds så länge som uppslaget pekar mot rätt resurs.",
         "dns_records": "DNS-uppslag",
         "dns_records_24hours": "Observera att ändringar gjorda i DNS kan ta upp till 24 timmar innan det visas korrekt på denna sida. Syftet med sidan är att enkelt se hur DNS-uppslagen är konfigurerade. Det är lätt att kontrollera att DNS-uppslagen är korrekt uppsatta.",
+        "dns_records_docs": "Se även <a target=\"_blank\" href=\"https://mailcow.github.io/mailcow-dockerized-docs/prerequisite-dns/\">dokumentationen</a>.",
         "dns_records_data": "Korrektdata",
         "dns_records_name": "Namn",
         "dns_records_status": "Nuvarande status",
@@ -470,6 +504,7 @@
     },
     "edit": {
         "active": "Aktiv",
+        "admin": "Ändra administratör",
         "advanced_settings": "Avancerade inställningar",
         "alias": "Ändra alias",
         "allow_from_smtp": "Tillåt endast följande IP-adresser att använda <b>SMTP</b>",
@@ -498,12 +533,21 @@
         "encryption": "Kryptering",
         "exclude": "Exkludera objekt (regex-filter)",
         "extended_sender_acl": "Externa avsändaradresser",
-        "extended_sender_acl_info": "En DKIM-domännyckel bör importeras, om det är möjligt.<br>\r\n  Kom ihåg att även lägga till motsvarande SPF TXT-uppslag för den här servern.<br>\r\n  När en domän eller aliasdomän läggs till på den här servern som överlappar en extern adress, tas den externa adressen bort.<br>\r\n  Använd @domain.tld för att kunna  skicka som *@domain.tld.",
+        "extended_sender_acl_info": "En DKIM-domännyckel bör importeras, om det är möjligt.<br>\r\n  Kom ihåg att även lägga till motsvarande SPF TXT-uppslag på den här servern.<br>\r\n  När en domän eller aliasdomän läggs till på den här servern som överlappar en extern adress, tas den externa adressen bort.<br>\r\n  Använd @domain.tld för att kunna  skicka som *@domain.tld.",
         "force_pw_update": "Kräv uppdatering av lösenordet vid nästa inloggning",
         "force_pw_update_info": "Den här användaren kan bara logga in på %s.",
         "full_name": "Fullständigt namn",
         "gal": "Global adressbok",
         "gal_info": "Den global adressboken innehåller alla objekt i en domän och kan inte redigeras av någon användare. Informationen om tillgänglighet i SOGo är endast synlig när den globala adressboken är påslagen.  <b>Starta om SOGo för att tillämpa ändringar.</b>",
+        "xmpp": "Aktivera XMPP funktion på denna domän",
+        "xmpp_prefix": "XMPP-prefix för domänen (Exempelvis \"im\" för <b>im</b>.example.org)",
+        "xmpp_prefix_info": "För att tillhandahålla ett säkerhetscertifikat måste vissa DNS-uppslag skapas, exempelvis två CNAME uppslag, ett för <b>im</b>.example.org och ett för <b>*.im</b>.example.org, som pekar mot <b>%s</b>. Efter att denna funktion har aktiverats, utför en DNS-kontroll för att testa att uppslagen är korrekt uppsatta.",
+        "xmpp_info": "Denna funktion aktiverar chatt-funktionalitet på denna domän.",
+        "xmpp_access": "XMPP-åtkomst",
+        "xmpp_access_info": "XMPP måste aktiveras på den här domänen.",
+        "xmpp_admin": "XMPP Administratör",
+        "xmpp_admin_info": "<b>Varning:</b> Befodrar en användare till XMPP-administratör på den här domänen.",
+        "xmpp_example_jid": "<b>Exempel JID</b> (Använd samma lösenord som på postlådan)",
         "generate": "generera",
         "grant_types": "Grant-typer",
         "hostname": "Värdnamn",
@@ -516,7 +560,7 @@
         "max_quota": "Max. kvot per postlåda (MiB)",
         "maxage": "Hur många antal dagar bakåt som meddelanden ska hämtas <br><small>(0 = ignorera ålder)</small>",
         "maxbytespersecond": "Max antal bitar per sekund <br><small>(0 = obegränsat)</small>",
-        "mbox_rl_info": "Hastighetsgränsen tillämpas på SASL-inloggningsnamnet och påverkar därför alla avsändaradresser som den inloggade användaren använder. Gränsvärde för en enskild postlåda åsidosätter gränsvärdet för domänen.",
+        "mbox_rl_info": "Hastighetsgränsen tillämpas på SASL-inloggningsnamnet och påverkar därför alla avsändaradresser som den inloggade användaren använder. Gränsvärde på en enskild postlåda åsidosätter gränsvärdet för domänen.",
         "mins_interval": "Intervall (min)",
         "multiple_bookings": "Flera bokningar",
         "nexthop": "Reläserver",
@@ -535,11 +579,14 @@
         "pushover_vars": "Om inget avsändarfilter är definerat, kommer alla e-postmeddelanden att behandlas.<br>Direkt avsändarkontroll och Regex-filter kontrolleras induviduellt, de är <b>inte beroende av varandra</b> och bearbetas i följd.<br>Variabler som kan användas för text och titel. (Notera gällande dataskyddsförordning)",
         "pushover_verify": "Verifiera anslutningen",
         "quota_mb": "Kvot (MiB)",
+        "quota_warning_bcc": "Kvotvarning dålda-kopior",
+        "quota_warning_bcc_info": "Varningarna skickas som separat kopia till följande mottagare. Ämnesraden kommer att innehålla användarens användarnamn i parenteser (ex. <code>Kvot-Warning (användare@exempel.se)</code>).",
+        "ratelimit": "Hastighetsgräns",
         "redirect_uri": "Omdirigering/Callback-URL",
         "relay_all": "Vidarebefordra alla mottagare",
         "relay_all_info": "↪ Om <b>inte</b> alla mottagare ska vidarebefordras måste (\"blinda\") postlådor skapas för varje adress som ska vidarebefordras.",
         "relay_domain": "Relädomän",
-        "relay_transport_info": "<div class=\"label label-info\">Info</div> Transportkartor kan skapas för att definiera enskilda destinationer för en relädomän.",
+        "relay_transport_info": "<div class=\"label label-info\">Info</div> Transportkartor kan skapas för att definiera enskilda destinationer på en relädomän.",
         "relay_unknown_only": "Vidarebefodra endast om det saknas en lokal postlåda. Existerar det en postlåda kommer det levereras lokalt.",
         "relayhost": "Reläserver",
         "remove": "Ta bort",
@@ -547,7 +594,7 @@
         "save": "Spara ändringar",
         "scope": "Omfattning",
         "sender_acl": "Tillåt att skicka som",
-        "sender_acl_disabled": "↳ <span class=\"label label-danger\">Avsändarkontroll är avaktiverad</span>",
+        "sender_acl_disabled": "<span class=\"label label-danger\">Avsändarkontroll är avaktiverad</span>",
         "sender_acl_info": "Om användaren A tillåts skicka som användaren B visas inte avsändaradressen automatiskt i \"från\" fältet i SOGo.<br>\r\n  Användaren B måste skapa en delegation i SOGo för att låta användaren A välja Användaren B's adress som avsändare. För att delegera en postlåda i SOGo, gå till menyn (tre punkter) till höger om ditt namn uppe till vänster i postvyn. Detta gäller inte för aliasadresser.",
         "sieve_desc": "Kort beskrivning",
         "sieve_type": "Filtertyp",
@@ -557,11 +604,12 @@
         "sogo_visible": "Alias visas i SOGo",
         "sogo_visible_info": "Det här alternativet påverkar endast objekt som kan visas i SOGo (delade eller icke-delade aliasadresser med destination för minst en lokal postlåda).",
         "spam_alias": "Skapa eller ändra tillfälliga e-postalias",
+        "spam_filter": "Spamfilter",
         "spam_policy": "Lägg till eller ta bort objekt på vit- eller svartlista",
         "spam_score": "Ange ett anpassad skräppostvärde",
         "subfolder2": "Synkronisera till en undermapp <br><small>(lämna tomt = använd inte undermapp)</small>",
         "syncjob": "Ändra synkroniseringsjobb",
-        "target_address": "Vidarbefodringsadresser <small>(separerade med komma)</small>",
+        "target_address": "Vidarbefodringsadresser",
         "target_domain": "Måldomän",
         "timeout1": "Timeout för anslutning till fjärrservern",
         "timeout2": "Timeout för anslutning till lokalserver",
@@ -614,6 +662,7 @@
         "active": "Aktiv",
         "add": "Lägg till",
         "add_alias": "Lägg till alias",
+        "add_alias_expand": "Överför aliasadresser till aliasdomäner",
         "add_bcc_entry": "Lägg till ny koppling",
         "add_domain": "Lägg till domän",
         "add_domain_alias": "Lägg till domänalias",
@@ -625,7 +674,7 @@
         "add_tls_policy_map": "Lägg till TLS-policyföreskrift",
         "address_rewriting": "Adress omskrivning",
         "alias": "Alias",
-        "alias_domain_alias_hint": "Aliasadresser kopplas <b>inte</b> automatiskt med domänalias-adresser. En aliasadress <code>alias@domän</code> täcker <b>inte</b> adressen <code>alias@alias-domän</code> (ett exempel där \"alias-domän\" är en aliasdomän för \"domän\").<br>Använd istället ett sieve filter för att dirigera om e-post till en extern postlåda (Gå till \"Postfilter\" eller använd SOGo -> Forwarder).",
+        "alias_domain_alias_hint": "Aliasadresser och domänalias-adresser uppdateras inte automatiskt. Exempel: En alias <code>info@domän.se</code > kommer inte automatiskt också att skapa <code>info@alias-till-domän.se</code> (alias-till-domän.se är ett alias till domän.se).<br>Använd ett <b>Sieve-filter</b> för att dirigera om e-post till en extern postlåda (Gå till \"Postfilter\" eller använd SOGo -> Forwarder). \"Överför aliasadresser till aliasdomäner\" Överför befintliga aliasadresser till att även fungera för domänalias-adresser.",
         "alias_domain_backupmx": "Aliasdomänen för relädomänen är inaktiv",
         "aliases": "Alias",
         "allow_from_smtp": "Tillåt endast följande IP-adresser att använda <b>SMTP</b>",
@@ -635,7 +684,7 @@
         "bcc": "Dåld kopia",
         "bcc_destination": "Destination för dåld kopia",
         "bcc_destinations": "Destinationer för dålda kopior",
-        "bcc_info": "En dåld kopia koppling kan användas för att vidarebefodra kopior av skickade meddelanden till en annan adress som dåld kopia. Det kan kopplas till en e-postadress eller för en domän.<br/>\r\n Den lokala destinationen kommer inte att informeras om leveransen skulle misslyckas.",
+        "bcc_info": "En dåld kopia koppling kan användas för att vidarebefodra kopior av skickade meddelanden till en annan adress som dåld kopia. Det kan kopplas till en e-postadress eller på en domän.<br/>\r\n Den lokala destinationen kommer inte att informeras om leveransen skulle misslyckas.",
         "bcc_local_dest": "Lokal destination",
         "bcc_map": "Dåld kopia koppling",
         "bcc_map_type": "Vilken typ av koppling",
@@ -692,9 +741,9 @@
         "owner": "Ägare",
         "private_comment": "Privat kommentar",
         "public_comment": "Offentlig kommentar",
-        "q_add_header": "Skräppost",
-        "q_all": "Alla kategorier",
-        "q_reject": "Avvisad",
+        "q_add_header": "via Skräppost",
+        "q_all": "via avvisade och skräppost",
+        "q_reject": "via avvisade",
         "quarantine_notification": "Ändra meddelandet som skickas vid karantän",
         "quarantine_category": "Kategori för karantänsnotifiering",
         "quick_actions": "Åtgärder",
@@ -720,7 +769,6 @@
         "sieve_preset_7": "Vidarebefodra och behåll, eller kasta meddelandet.",
         "sieve_preset_8": "Kasta meddelanden som skickas till en alias-adress som avsändaren redan tillhör.",
         "sieve_preset_header": "Exempel på postfilter finns nedan. För mer information se <a href=\"https://en.wikipedia.org/wiki/Sieve_(mail_filtering_language)\" target=\"_blank\">Wikipedia</a>.",
-        "sogo_allow_admin_hint": "Administrativ SOGo-inloggning är endast tillgängliga för postlådor med en befintlig SOGo-profil. Användaren måste ha varit inloggad på SOGo minst en gång innan.",
         "sogo_visible": "Visa detta alias i SOGo",
         "sogo_visible_n": "Dölj alias i SOGo",
         "sogo_visible_y": "Visa alias i SOGo",
@@ -767,6 +815,7 @@
         "danger": "Fara",
         "deliver_inbox": "Leverera till inboxen",
         "disabled_by_config": "Med nuvarande konfigurationen är karantänfunktionen inaktiverad. För att aktivera funktionen behöver inställningen för antal meddelanden att förvara i karantän, och storleksgräns per meddelanden i karantän anges.",
+        "settings_info": "Maximalt antal e-postmeddelanden som placeras i karantän: %s<br>Maximal storlek på e-postmeddelanden som sparas: %s MiB",
         "download_eml": "Ladda ner (.eml)",
         "empty": "Inga resultat",
         "high_danger": "Hög",
@@ -865,9 +914,11 @@
         "mailbox_added": "Postlådan %s har lagts till",
         "mailbox_modified": "Ändringarna på postlådan %s har sparats",
         "mailbox_removed": "Postlådan %s har tagits bort",
+        "nginx_reloaded": "Nginx laddades om",
         "object_modified": "Ändringarna på objektet %s har sparats",
         "pushover_settings_edited": "Konfigurationen för Pushover är sparad, kontrollera att det finns korrekt åtkomst.",
         "qlearn_spam": "Medelandet med ID %s har markerats som spam och har tagits bort",
+        "password_policy_saved": "Lösenordspolicyn har sparats",
         "queue_command_success": "Köuppgiften har slutförts",
         "recipient_map_entry_deleted": "Mottagaröverföringen med ID %s har tagits bort",
         "recipient_map_entry_saved": "Mottagaröverföring \"%s\" har sparats",
@@ -890,7 +941,10 @@
         "verified_totp_login": "Verifierad TOTP inloggning",
         "verified_u2f_login": "Verifierad U2F inloggning",
         "verified_fido2_login": "Verifierad FIDO2 inloggning",
-        "verified_yotp_login": "Verifierad Yubico OTP inloggning"
+        "verified_yotp_login": "Verifierad Yubico OTP inloggning",
+        "xmpp_restarted": "XMPP-tjänsten har startat om",
+        "xmpp_reloaded": "XMPP-tjänsten har laddats om",
+        "xmpp_maps_updated": "XMPP-kopplingen har aktiverats"
     },
     "tfa": {
         "api_register": "%s använder Yubico Moln-API. Vänligen skaffa en API-nyckel för din nyckel <a href=\"https://upgrade.yubico.com/getapikey/\" target=\"_blank\">här</a>",
@@ -910,6 +964,7 @@
         "set_tfa": "Metod för tvåfaktorsautentisering",
         "start_u2f_validation": "Startar validering",
         "tfa": "Tvåfaktorsautentisering",
+        "tfa_token_invalid": "TFA nyckeln är ogiltig!",
         "totp": "Tidsbaserad OTP (Google Authenticator, Authy, mm)",
         "u2f": "U2F-autentisering",
         "waiting_usb_auth": "<i>Väntar på USB-enhet...</i><br><br>Tryck på knappen på USB-enheten nu.",
@@ -949,12 +1004,13 @@
         "app_name": "Applikationsnamn",
         "app_passwds": "Applikationslösenord",
         "apple_connection_profile": "Apple-anslutningsprofil",
-        "apple_connection_profile_complete": "Denna anslutningsprofil inkluderar både konfigurationsparametrar till IMAP, SMTP, CalDAV (för kalendrar) och CardDAV (för kontakter) för en Apple-enhet.",
-        "apple_connection_profile_mailonly": "Denna anslutningsprofil inkluderar både konfigurationsparametrar till IMAP och SMTP för en Apple-enhet.",
+        "apple_connection_profile_complete": "Denna anslutningsprofil inkluderar både konfigurationsparametrar till IMAP, SMTP, CalDAV (för kalendrar) och CardDAV (för kontakter) på en Apple-enhet.",
+        "apple_connection_profile_mailonly": "Denna anslutningsprofil inkluderar både konfigurationsparametrar till IMAP och SMTP på en Apple-enhet.",
         "change_password": "Ändra lösenordet",
         "client_configuration": "Visa konfigurationsguider för e-postklienter och smartatelefoner",
         "create_app_passwd": "Skapa applikationslösenord",
         "create_syncjob": "Skapa ett nytt synkroniseringsjobb",
+        "created_on": "Skapad vid",
         "daily": "Dagligen",
         "day": "dag",
         "delete_ays": "Är du säker att du vill ta bort det här objektet?",
@@ -982,9 +1038,10 @@
         "loading": "Vänta...",
         "mailbox_details": "Påstlådans detaljer",
         "messages": "meddelanden",
+        "month": "Månad",
+        "months": "Månader",
         "never": "Aldrig",
         "new_password": "Nytt lösenord",
-        "new_password_description": "Krav: 6 tecken, bokstäver och nummer.",
         "new_password_repeat": "Lösenord (igen)",
         "no_active_filter": "Finns inga aktiva filter",
         "no_last_login": "Senaste inloggningen till gränssnittet saknas",
@@ -1058,7 +1115,9 @@
         "waiting": "Väntar",
         "week": "vecka",
         "weekly": "Varje vecka",
-        "weeks": "veckor"
+        "weeks": "veckor",
+        "year": "år",
+        "years": "år"
     },
     "warning": {
         "cannot_delete_self": "Inloggade användare kan inte tas bort",
@@ -1066,9 +1125,10 @@
         "dovecot_restart_failed": "Dovecot kunde inte startas om, kontrollera Dovecot loggen.",
         "fuzzy_learn_error": "En oklar kontrollsumma resulterade i ett inlärningsfel: %s",
         "hash_not_found": "Kontrollsumman hittas inte. Den kan redan vara borttagen",
-        "ip_invalid": "Skippar en ogiltig IP-adress: %s",
+        "ip_invalid": "Hoppade över en ogiltig IP-adress: %s",
+        "is_not_primary_alias": "Hoppade över en ej-primär alias: %s",
         "no_active_admin": "Den senaste kända administratören kan inte inaktiveras",
-        "quota_exceeded_scope": "Domänkvoten fylld: Endast postlådor med obegränsade kvoter kan skapas för den här domänen.",
+        "quota_exceeded_scope": "Domänkvoten fylld: Endast postlådor med obegränsade kvoter kan skapas på den här domänen.",
         "session_token": "Formulär-nyckeln är ogiltig: Nyckeln matchar inte",
         "session_ua": "Formulär-nyckeln är ogiltig: User-Agenten kunde inte valideras"
     }
diff --git a/mailcow/src/mailcow-dockerized/data/web/lang/lang.zh.json b/mailcow/src/mailcow-dockerized/data/web/lang/lang.zh.json
index 9dea0af..8993cb9 100644
--- a/mailcow/src/mailcow-dockerized/data/web/lang/lang.zh.json
+++ b/mailcow/src/mailcow-dockerized/data/web/lang/lang.zh.json
@@ -437,20 +437,20 @@
         "chart_this_server": "图表 (此服务器)",
         "containers_info": "容器信息",
         "disk_usage": "磁盘使用",
-        "external_logs": "外部日至",
+        "external_logs": "外部日志",
         "history_all_servers": "历史 (所有服务器)",
-        "in_memory_logs": "内存日至",
+        "in_memory_logs": "内存日志",
         "jvm_memory_solr": "JVM内存使用",
-        "log_info": "<p>mailcow <b>内存日志</b> 收集于Redis列表中并且每分钟地修整到 LOG_LINES (%d) 以减少错误(Rowhammer)。\r\n  <br>内存日志不是为了持久化，所有使用内存日志的应用同时也会写入日志到Docker守护程序的默认日志驱动中。\r\n  <br>内存日志应该用于debug容器中的不明显问题。</p>\r\n  <p><b>外部日志</b> 通过相应应用提供的API收集。</p>\r\n  <p><b>静态日志</b> 大多为不写入日志到Dockerd但仍然需要被持久化的活动日志(API日志外的)。</p>",
+        "log_info": "<p>mailcow <b>内存日志</b> 收集于Redis列表中并且每分钟自动缩减到 LOG_LINES (%d) 以减少错误(Rowhammer)。\r\n  <br>内存日志不是为了持久化，所有使用内存日志的应用同时也会写入日志到Docker守护程序的默认日志驱动中。\r\n  <br>内存日志应该用于debug容器中的不明显问题。</p>\r\n  <p><b>外部日志</b> 通过相应应用提供的API收集。</p>\r\n  <p><b>静态日志</b> 大多为不写入日志到Dockerd但仍然需要被持久化的活动日志(API日志外的)。</p>",
         "logs": "日志",
         "restart_container": "重启",
         "solr_dead": "Solr在启动中、已关闭或已停止运行",
-        "solr_docs": "文档",
-        "solr_last_modified": "最后修改",
-        "solr_size": "大小",
-        "solr_started_at": "开始于",
+        "docs": "文档",
+        "last_modified": "最后修改",
+        "size": "大小",
+        "started_at": "开始于",
         "solr_status": "Solr状态",
-        "solr_uptime": "运行时间",
+        "uptime": "运行时间",
         "started_on": "启动于",
         "static_logs": "静态日志",
         "system_containers": "系统和容器"
@@ -544,7 +544,7 @@
         "save": "保存更改",
         "scope": "范围",
         "sender_acl": "允许发送为",
-        "sender_acl_disabled": "↳ <span class=\"label label-danger\">发件人检查已关闭</span>",
+        "sender_acl_disabled": "<span class=\"label label-danger\">发件人检查已关闭</span>",
         "sender_acl_info": "如果允许邮箱用户A作为邮箱用户B发送邮件，发件人的地址不会在SOGo中\"来自\"区域自动地作为下拉可选项显示。<br>\r\n 邮箱用户B需要添加授权以允许邮箱用户A选择B的地址作为发件人；授权方法为，在SOGo中点击左上方邮箱地址右边的菜单按钮(三个点)并授权。",
         "sieve_desc": "简短描述",
         "sieve_type": "过滤器类型",
@@ -711,7 +711,6 @@
         "sieve_preset_7": "重定向邮件并保留/删除",
         "sieve_preset_8": "删除发件人发送给自己别名地址的邮件",
         "sieve_preset_header": "请看下方的示例预设。 查看 <a href=\"https://en.wikipedia.org/wiki/Sieve_(mail_filtering_language)\" target=\"_blank\">Wikipedia</a> 以了解更多细节。",
-        "sogo_allow_admin_hint": "只允许存在个人资料的邮箱帐号以SOGo管理员登录，即用户需要在先前至少登录过一次。",
         "sogo_visible": "SOGo别名显示",
         "sogo_visible_n": "在SOGo中隐藏别名",
         "sogo_visible_y": "在SOGo中显示别名",
@@ -1033,7 +1032,7 @@
     "warning": {
         "cannot_delete_self": "不能删除已登录用户",
         "domain_added_sogo_failed": "域名已添加但是重启Dovecot失败，请检查日志。",
-        "dovecot_restart_failed": "Dovecot重启失败，请检查日至",
+        "dovecot_restart_failed": "Dovecot重启失败，请检查日志",
         "fuzzy_learn_error": "模糊特征学习失败: %s",
         "hash_not_found": "找不到特征或已被删除",
         "ip_invalid": "跳过的非法IP: %s",
