{
    "acl": {
        "alias_domains": "Voeg aliasdomeinen toe",
        "app_passwds": "Beheer appwachtwoorden",
        "bcc_maps": "BCC-maps",
        "delimiter_action": "Delimiter-actie",
        "eas_reset": "Herstel ActiveSync-apparaatcache",
        "extend_sender_acl": "Sta verzenden via externe adressen toe",
        "filters": "Filters",
        "login_as": "Log in als mailboxgebruiker",
        "prohibited": "Toegang geweigerd",
        "protocol_access": "Wijzig protocoltoegang",
        "pushover": "Pushover",
        "quarantine": "Quarantaine-acties",
        "quarantine_attachments": "Quarantainebijlagen",
        "quarantine_notification": "Quarantainemeldingen",
        "quarantine_category": "Wijzig categorie van quarantainemeldingen",
        "ratelimit": "Ratelimit",
        "recipient_maps": "Ontvanger-maps",
        "smtp_ip_access": "Wijzig toegestane hosts voor SMTP",
        "sogo_access": "Sta beheer van SOGo-toegang toe",
        "sogo_profile_reset": "Verwijder SOGo-profiel",
        "spam_alias": "Tijdelijke aliassen",
        "spam_policy": "Blacklist/Whitelist",
        "spam_score": "Spamscore",
        "syncjobs": "Sync jobs",
        "tls_policy": "Versleutelingsbeleid",
        "unlimited_quota": "Onbeperkte quota voor mailboxen",
        "domain_desc": "Wijzig domeinbeschrijving"
    },
    "add": {
        "activate_filter_warn": "Alle andere filters worden gedeactiveerd zolang deze geactiveerd is.",
        "active": "Actief",
        "add": "Voeg toe",
        "add_domain_only": "Voeg enkel domein toe",
        "add_domain_restart": "Voeg domein toe en herstart SOGo",
        "alias_address": "Aliasadres(sen)",
        "alias_address_info": "<small>Volledig(e) mailadres(sen) of @example.com, om een catch-all aan te maken voor een domein (kommagescheiden). <b>Uitsluitend Mailcow-domeinen</b>.</small>",
        "alias_domain": "Aliasdomein",
        "alias_domain_info": "<small>Uitsluitend geldige domeinnamen (kommagescheiden).</small>",
        "app_name": "Naam van app",
        "app_password": "Maak appwachtwoord aan",
        "automap": "Probeer mappen automatisch te koppelen (\"Verzonden items\", \"Verzonden\" => \"Verzonden\" etc.)",
        "backup_mx_options": "Relay-opties",
        "comment_info": "Een persoonlijke opmerking is niet zichtbaar voor de gebruiker, terwijl een publieke opmerking wel getoond wordt in het overzicht van de gebruiker.",
        "custom_params": "Aangepaste parameters",
        "custom_params_hint": "Juist: --param=xy, onjuist: --param xy",
        "delete1": "Verwijder van bron wanneer voltooid",
        "delete2": "Verwijder berichten die zich niet in de bron bevinden",
        "delete2duplicates": "Verwijder duplicaten op de bestemming",
        "description": "Beschrijving",
        "destination": "Bestemming",
        "disable_login": "Weiger aanmelden (inkomende mail blijft binnenkomen)",
        "domain": "Domein",
        "domain_matches_hostname": "Domein %s komt overeen met hostname",
        "domain_quota_m": "Totale domeinquota (MiB)",
        "enc_method": "Versleutelingsmethode",
        "exclude": "Sluit objecten uit (regex)",
        "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>",
        "generate": "genereer",
        "goto_ham": "Train als <span class=\"text-success\"><b>ham</b></span>",
        "goto_null": "Verwijder mail onmiddelijk",
        "goto_spam": "Train als <span class=\"text-danger\"><b>spam</b></span>",
        "hostname": "Hostname",
        "inactive": "Inactief",
        "kind": "Soort",
        "mailbox_quota_def": "Standaard mailboxquota",
        "mailbox_quota_m": "Maximale mailboxquota (MiB)",
        "mailbox_username": "Gebruikersnaam (linkergedeelte van een mailadres)",
        "max_aliases": "Maximaal aantal aliassen",
        "max_mailboxes": "Maximaal aantal mailboxen",
        "mins_interval": "Interval (min)",
        "multiple_bookings": "Meerdere boekingen",
        "nexthop": "Nexthop",
        "password": "Wachtwoord",
        "password_repeat": "Herhaal wachtwoord",
        "port": "Poort",
        "post_domain_add": "De SOGo-container, \"sogo-mailcow\", dient herstart te worden na het toevoegen van een nieuw domein!<br><br>Daarnaast wordt het aanbevolen om de DNS-configuratie te herzien. Nadat de DNS-configuratie juist is ingesteld, herstart je \"acme-mailcow\" om direct certificaten voor het nieuwe domein te genereren.<br>De laatste stap is optioneel, en zal elke 24 uur automatisch geprobeerd worden.",
        "private_comment": "Persoonlijke opmerking",
        "public_comment": "Publieke opmerking",
        "quota_mb": "Quota (MiB)",
        "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.",
        "relay_domain": "Forward dit domein",
        "relay_transport_info": "<div class=\"badge fs-6 bg-info\">Info</div> Je kunt transport-maps aanmaken om een aangepaste bestemming in te stellen voor dit domein. Zo niet, zal er een MX-lookup plaatsvinden.",
        "relay_unknown_only": "Forward uitsluitend niet-bestaande mailboxen. Bestaande mailboxen zullen lokaal afgeleverd worden.",
        "relayhost_wrapped_tls_info": "Gebruik <b>geen</b> in TLS verpakte poorten (meestal poort 465).<br>Gebruik een reguliere poort en initieer STARTTLS. Beleid om verleuteling te forceren kan worden ingesteld bij \"Globaal versleutelingsbeleid\".",
        "select": "Selecteer...",
        "select_domain": "Selecteer eerst een domein",
        "sieve_desc": "Korte beschrijving",
        "sieve_type": "Filtertype",
        "skipcrossduplicates": "Sla duplicaten verspreid over mappen over (wie het eerst komt, het eerst maalt)",
        "subscribeall": "Abonneer op alle mappen",
        "syncjob": "Voeg sync job toe",
        "syncjob_hint": "Wees ervan bewust dat de authenticatiedata onversleuteld wordt opgeslagen!",
        "target_address": "Doeladressen",
        "target_address_info": "<small>Volledig(e) mailadres(sen) (kommagescheiden).</small>",
        "target_domain": "Doeldomein",
        "timeout1": "Time-out voor verbinding met externe hosts",
        "timeout2": "Time-out voor verbinding met lokale hosts",
        "username": "Gebruikersnaam",
        "validate": "Verifieer",
        "validation_success": "Succesvol geverifieerd",
        "tags": "Tags",
        "bcc_dest_format": "BCC-bestemming moet één geldig e-mailadres zijn.<br>Als u een kopie naar meerdere adressen wilt sturen, maak dan een alias aan en gebruik die hier."
    },
    "admin": {
        "access": "Toegang",
        "action": "Handeling",
        "activate_api": "Activeer API",
        "activate_send": "Bevestig bovenstaande gegevens",
        "active": "Actief",
        "active_rspamd_settings_map": "Huidige instellingen",
        "add": "Voeg toe",
        "add_admin": "Voeg administrator toe",
        "add_domain_admin": "Voeg domeinadministrator toe",
        "add_forwarding_host": "Voeg forwarding host toe",
        "add_relayhost": "Voeg afzendergebonden transport-map toe",
        "add_relayhost_hint": "Wees ervan bewust dat de authenticatiedata onversleuteld wordt opgeslagen!",
        "add_row": "Voeg rij toe",
        "add_settings_rule": "Voeg regel toe",
        "add_transport": "Voeg transport-map toe",
        "add_transports_hint": "Wees ervan bewust dat de authenticatiedata onversleuteld wordt opgeslagen!",
        "additional_rows": " extra rijen zijn toegevoegd",
        "admin": "Administrator",
        "admin_details": "Toegangsinstellingen",
        "admin_domains": "Domeintoewijzingen",
        "advanced_settings": "Geavanceerde instellingen",
        "api_allow_from": "Sta API-toegang toe vanaf deze IP-adressen/CIDR-notaties",
        "api_info": "De API is nog in ontwikkeling. Documentatie is beschikbaar op <a href=\"/api\">/api</a>",
        "api_key": "API-key",
        "api_skip_ip_check": "Sla IP-adrescontrole over voor API",
        "app_links": "Applicatielinks",
        "app_name": "Naam",
        "apps_name": "\"Mailcow-apps\"",
        "arrival_time": "Aankomsttijd",
        "authed_user": "Geauthenticeerde gebruiker",
        "ays": "Weet je zeker dat je deze actie wilt uitvoeren?",
        "ban_list_info": "Bekijk de lijst met verbannen IP-adressen hieronder: <b>netwerk (resterende tijd) - [acties]</b>.<br />Rode labels geven een permanente verbanning aan.<br />Het kan enkele seconden duren voordat wijzigingen hieronder zichtbaar zijn.",
        "change_logo": "Logo",
        "configuration": "Instellingen",
        "convert_html_to_text": "Converteer HTML naar plaintext",
        "credentials_transport_warning": "<b>Waarschuwing</b>: Bij het toevoegen van een nieuwe transport-map zullen de aanmeldingsgegevens voor alle items met een overeenkomende nexthop-kolom worden overgeschreven.",
        "customer_id": "Klantnummer",
        "customize": "Personalisatie",
        "destination": "Bestemming",
        "dkim_add_key": "Voeg key toe",
        "dkim_domains_selector": "Selector",
        "dkim_domains_wo_keys": "Selecteer domeinen met ontbrekende keys",
        "dkim_from": "Van",
        "dkim_from_title": "Kopieer data van domein",
        "dkim_key_length": "Grootte van key (bits)",
        "dkim_key_missing": "Key ontbreekt",
        "dkim_key_unused": "Key ongebruikt",
        "dkim_key_valid": "Key geldig",
        "dkim_keys": "ARC/DKIM-keys",
        "dkim_overwrite_key": "Schrijf bestaande key over",
        "dkim_private_key": "Private key",
        "dkim_to": "Naar",
        "dkim_to_title": "Doeldomein(en) - worden overgeschreven",
        "domain": "Domein",
        "domain_admin": "Domeinadministrator",
        "domain_admins": "Domeinadministrators",
        "domain_s": "Domein(en)",
        "duplicate": "Dupliceer",
        "duplicate_dkim": "Dupliceer key",
        "edit": "Wijzig",
        "empty": "Geen resultaten",
        "excludes": "Exclusief",
        "f2b_ban_time": "Verbanningstijd (s)",
        "f2b_ban_time_increment": "Verbanningstijd wordt verhoogd met elk verbanning",
        "f2b_blacklist": "Netwerken/hosts op de blacklist",
        "f2b_filter": "Regex-filters",
        "f2b_list_info": "Een host of netwerk op de blacklist staat altijd boven eenzelfde op de whitelist. <b>Het doorvoeren van wijzigingen kan enkele seconden in beslag nemen.</b>",
        "f2b_max_attempts": "Maximaal aantal pogingen",
        "f2b_max_ban_time": "Maximaal verbanningstijd (s)",
        "f2b_netban_ipv4": "Voer de IPv4-subnetgrootte in waar de verbanning van kracht moet zijn (8-32)",
        "f2b_netban_ipv6": "Voer de IPv6-subnetgrootte in waar de verbanning van kracht moet zijn (8-128)",
        "f2b_parameters": "Fail2ban",
        "f2b_regex_info": "De volgende logs worden gebruikt: SOGo, Postfix, Dovecot, PHP-FPM.",
        "f2b_retry_window": "Tijdsbestek voor maximale pogingen (s)",
        "f2b_whitelist": "Netwerken/hosts op de whitelist",
        "filter_table": "Filtertabel",
        "forwarding_hosts": "Forwarding hosts",
        "forwarding_hosts_add_hint": "Het is mogelijk om IPv4- of IPv6-adressen, netwerken in CIDR-notatie, hostnames (worden omgezet naar IP-adressen) of domeinnamen (worden tevens omgezet naar IP-adressen of, bij gebrek daaraan, MX-records) op te geven.",
        "forwarding_hosts_hint": "Inkomende berichten worden onvoorwaardelijk geaccepteerd vanaf iedere host hieronder vermeld. Deze hosts worden hierdoor niet gecontroleerd op DNSBLs, en zullen de greylisting omzeilen. Spam wordt daarentegen zoals gebruikelijk in de spamfolder geplaatst. Dit wordt vaak gebruikt om mailservers te specificeren die forwarden naar deze Mailcow-server.",
        "from": "Afzender",
        "generate": "genereer",
        "guid": "Identificatienummer - GUID",
        "guid_and_license": "Licentie en identificatie",
        "hash_remove_info": "Het verwijderen van een ratelimit-hash, indien nog aanwezig, zal zijn teller volledig herstellen.<br>Elke hash wordt aangeduid met een aparte kleur.",
        "help_text": "Hulpteksten onder aanmeldvenster (HTML toegestaan)",
        "host": "Host",
        "html": "HTML",
        "import": "Importeer",
        "import_private_key": "Importeer private key",
        "in_use_by": "In gebruik door",
        "inactive": "Inactief",
        "include_exclude": "Ontvangers",
        "include_exclude_info": "Zonder selectie worden <b>alle mailboxen</b> benaderd!",
        "includes": "Inclusief",
        "last_applied": "Voor het laatst toegepast",
        "license_info": "Een licentie is niet vereist. Je steunt hier echter wel de ontwikkeling van Mailcow mee.<br><a href=\"https://www.servercow.de/mailcow?lang=nl#sal\" target=\"_blank\" alt=\"SAL order\">Registreer je GUID hier</a>, of <a href=\"https://www.servercow.de/mailcow?lang=nl#support\" target=\"_blank\" alt=\"Support order\">schaf ondersteuning aan voor deze installatie.</a>",
        "link": "Link",
        "loading": "Even geduld aub...",
        "logo_info": "De afbeelding zal worden geschaald naar een hoogte van 40px voor de navigatiebar, en naar een breedte van 250px voor de startpagina.",
        "lookup_mx": "Match bestemming aan MX (gebruik .outlook.com om alle mail gericht aan MX *.outlook.com over deze hop te laten gaan)",
        "main_name": "\"Mailcow\"",
        "merged_vars_hint": "Grijze rijen zijn samengevoegd van <code>vars.(local.)inc.php</code> en kunnen niet worden gewijzigd.",
        "message": "Bericht",
        "message_size": "Berichtgrootte",
        "nexthop": "Nexthop",
        "no_active_bans": "Geen actieve verbanningen",
        "no_new_rows": "Er zijn geen extra rijen beschikbaar",
        "no_record": "Geen vermelding",
        "oauth2_client_id": "Client-ID",
        "oauth2_client_secret": "Client-secret",
        "oauth2_info": "De OAuth2-implementatie ondersteunt grant type \"Authorization Code\" en geeft refresh-tokens uit.<br>De server geeft automatisch nieuwe refresh-tokens uit nadat er één is gebruikt.<br><br>→ De standaard scope is <i>profiel</i>. Uitsluitend mailboxgebruikers kunnen OAuth2 gebruiken om zich te authenticeren. Als de scope-parameter wordt weggelaten, zal deze terugvallen op <i>profiel</i>.<br>→ De <i>state</i>-parameter dient verzonden te worden door de client als onderdeel van het authorize-request.<br><br>Paden voor requests naar de OAuth2-API: <br><ul><li>Authorization endpoint: <code>/oauth/authorize</code></li><li>Token endpoint: <code>/oauth/token</code></li><li>Resource page:  <code>/oauth/profile</code></li></ul>Het regenereren van de client-secret zal oudere authorization codes niet doen verlopen. Het verversen van de tokens zal echter niet langer werken.<br><br>Het intrekken van client-tokens zal alle actieve sessies per direct beëindigen. Alle clients dienen zich opnieuw te authenticeren.",
        "oauth2_redirect_uri": "Redirect URI",
        "oauth2_renew_secret": "Genereer een nieuw client-secret",
        "oauth2_revoke_tokens": "Trek alle client-tokens in",
        "optional": "optioneel",
        "password": "Wachtwoord",
        "password_repeat": "Herhaal wachtwoord",
        "priority": "Prioriteit",
        "private_key": "Private key",
        "quarantine": "Quarantaine",
        "quarantine_bcc": "Forward alle meldingen (bcc) naar dit adres:<br><small>Laat leeg om uit te schakelen. <b>Mails zijn niet gesigneerd of gecontroleerd. Uitsluitend bedoeld voor intern gebruik.</b></small>",
        "quarantine_exclude_domains": "Sluit de volgende domeinen en aliasdomeinen uit",
        "quarantine_max_age": "Maximale leeftijd in dagen<br><small>Dit kan niet minder zijn dan 1 dag.</small>",
        "quarantine_max_size": "Maximale grootte in MiB (mail die de limiet overschrijdt zal worden verwijderd):<br><small>0 betekent <b>niet</b> onbeperkt!</small>",
        "quarantine_max_score": "Stuur geen notificatie wanneer de spamscore hoger is dan:<br><small>Standaard: 9999.0</small>",
        "quarantine_notification_html": "Meldingssjabloon:<br><small>Laat leeg om de standaardsjabloon te herstellen.</small>",
        "quarantine_notification_sender": "Afzender van meldingen",
        "quarantine_notification_subject": "Onderwerp van meldingen",
        "quarantine_redirect": "<b>Redirect alle meldingen</b> naar dit adres:<br><small>Laat leeg om uit te schakelen. <b>Mails zijn niet gesigneerd of gecontroleerd. Uitsluitend bedoeld voor intern gebruik.</b></small>",
        "quarantine_release_format": "Formaat van vrijgegeven items",
        "quarantine_release_format_att": "Bijlage",
        "quarantine_release_format_raw": "Origineel",
        "quarantine_retention_size": "Maximale retenties per mailbox:<br><small>Gebruik 0 om deze functionaliteit <b>uit te schakelen</b>.</small>",
        "quota_notification_html": "Meldingssjabloon:<br><small>Laat leeg om de standaardsjabloon te herstellen.</small>",
        "quota_notification_sender": "Afzender van meldingen",
        "quota_notification_subject": "Onderwerp van meldingen",
        "quota_notifications": "Quotameldingen",
        "quota_notifications_info": "Quotameldingen worden verzonden naar gebruikers wanneer deze 80% of 95% van hun opslagcapaciteit overschreden hebben.",
        "quota_notifications_vars": "{{percent}} toont de huidige quota van van de gebruiker<br>{{username}} staat voor de naam van de desbetreffende mailbox",
        "r_active": "Actieve beperkingen",
        "r_inactive": "Inactieve beperkingen",
        "r_info": "Grijze elementen op de lijst van actieve beperkingen zijn niet geldig en kunnen niet worden verplaatst. Onbekende beperkingen zullen hoe dan ook in volgorde van weergave worden ingesteld. <br>Er kunnen nieuwe elementen worden toegevoegd in <code>inc/vars.local.inc.php</code> om ze te kunnen gebruiken.",
        "rate_name": "Rate-naam",
        "recipients": "Ontvangers",
        "refresh": "Ververs",
        "regen_api_key": "Vernieuw API-key",
        "regex_maps": "Regex-maps",
        "relay_from": "\"Van:\" adres",
        "relay_run": "Voer test uit",
        "relayhosts": "Afzendergebonden transport-maps",
        "relayhosts_hint": "Stel afzendergebonden transport-maps in om deze te kunnen gebruiken bij de configuratie van een domein.<br>De transportservice is altijd \"smtp:\" en zal daarom met TLS proberen te verbinden. Wrapped TLS (SMTPS) wordt niet ondersteund. Er wordt rekening gehouden met het uitgaande versleutelingsbeleid van individuele gebruikers.<br>Beïnvloedt geselecteerde domeinen, inclusief bijbehorende aliasdomeinen.",
        "remove": "Verwijder",
        "remove_row": "Verwijder rij",
        "reset_default": "Herstel standaardinstellingen",
        "reset_limit": "Verwijder hash",
        "routing": "Routing",
        "rsetting_add_rule": "Voeg regel toe",
        "rsetting_content": "Regelinhoud",
        "rsetting_desc": "Korte beschrijving",
        "rsetting_no_selection": "Selecteer een regel",
        "rsetting_none": "Geen regels beschikbaar",
        "rsettings_insert_preset": "Voeg voorbeeld \"%s\" in",
        "rsettings_preset_1": "Schakel alles uit voor geauthenticeerde gebruikers, behalve ARC/DKIM en ratelimiting",
        "rsettings_preset_2": "Laat postmasters spam ontvangen",
        "rsettings_preset_3": "Sta uitsluitend specifieke afzenders toe voor een mailbox (bijvoorbeeld als interne mailbox)",
        "rspamd_com_settings": "Een beschrijving voor deze instelling zal automatisch worden gegenereerd, gebruik de onderstaande presets als voorbeeld. Raadpleeg de <a href=\"https://rspamd.com/doc/configuration/settings.html#settings-structure\" target=\"_blank\">Rspamd-documentatie</a> voor meer informatie.",
        "rspamd_global_filters": "Globale filters",
        "rspamd_global_filters_agree": "Ik ben me ervan bewust dat aanpassingen desastreuze gevolgen kunnen hebben",
        "rspamd_global_filters_info": "Ieder globaal filter heeft zijn eigen functie, zie de namen.",
        "rspamd_global_filters_regex": "De velden kunnen uitsluitend regular expressions bevatten met het formaat \"/pattern/options\", bijvoorbeeld <code>/.+@domain\\.tld/i</code>.<br>Ondanks dat alle invoer wordt gecontroleerd op fouten, is het toch mogelijk dat Rspamd onbruikbaar wordt als deze de invoer niet kan lezen.<br>Als je problemen ervaart, <a href=\"\" data-toggle=\"modal\" data-container=\"rspamd-mailcow\" data-target=\"#RestartContainer\">herstart Rspamd</a> dan om de filters opnieuw te laten lezen.<br>Elementen op de blacklist zijn uitgesloten van de quarantaine.",
        "rspamd_settings_map": "Rspamd",
        "sal_level": "Moo-level",
        "save": "Sla wijzigingen op",
        "search_domain_da": "Zoek domeinen",
        "send": "Verzenden",
        "sender": "Afzender",
        "service_id": "Servicenummer",
        "source": "Bron",
        "spamfilter": "Spamfilter",
        "subject": "Onderwerp",
        "sys_mails": "Systeemmails",
        "text": "Tekst",
        "time": "Tijd",
        "title": "Titel",
        "title_name": "\"Mailcow\" (websitetitel)",
        "to_top": "Naar boven",
        "transport_dest_format": "Voorbeeld: example.org, .example.org, *, mailbox@example.org (meerdere waarden zijn kommagescheiden)",
        "transport_maps": "Transport-maps",
        "transports_hint": "→ Een transport-map wordt boven een afzendergebonden transport-map verkozen.<br>→ Het uitgaande versleutelingsbeleid van individuele gebruikers wordt genegeerd en kan uitsluitend worden gehandhaafd doormiddel van globaal versleutelingsbeleid.<br>→ De transportservice is altijd \"smtp:\" en zal daarom met TLS proberen te verbinden. Wrapped TLS (SMTPS) wordt niet ondersteund.<br>→ Adressen overeenkomend met \"/localhost$/\" zullen altijd via \"local:\" getransporteerd worden, hierdoor zullen \"*\"-bestemmingen niet van toepassing zijn op deze adressen.<br>→ Om de aanmeldingsgegevens van een (voorbeeld) nexthop \"[host]:25\" te bepalen, zoekt Postfix <b>altijd</b> naar \"nexthop\" voodat er wordt gekeken naar \"[nexthop]:25\". Dit maakt het onmogelijk om \"nexthop\" en \"[nexthop]:25\" tegelijkertijd te gebruiken.",
        "ui_footer": "Footer (HTML toegestaan)",
        "ui_header_announcement": "Aankondigingen",
        "ui_header_announcement_active": "Activeer aankondiging",
        "ui_header_announcement_content": "Tekst (HTML toegestaan)",
        "ui_header_announcement_help": "De aankondiging zal zichtbaar zijn voor zowel alle aangemelde gebruikers als op het aanmeldingsscherm van Mailcow.",
        "ui_header_announcement_select": "Selecteer type aankondiging",
        "ui_header_announcement_type": "Type",
        "ui_header_announcement_type_info": "Info",
        "ui_header_announcement_type_warning": "Belangrijk",
        "ui_header_announcement_type_danger": "Zeer belangrijk",
        "ui_texts": "Labels en teksten",
        "unban_pending": "bezig met toestaan",
        "unchanged_if_empty": "Laat leeg wanneer ongewijzigd",
        "upload": "Upload",
        "username": "Gebruikersnaam",
        "validate_license_now": "Valideer licentie",
        "verify": "Verifieer",
        "logo_normal_label": "Normaal",
        "logo_dark_label": "Omgekeerd voor donkere modus",
        "cors_settings": "CORS instellingen",
        "is_mx_based": "MX gebasseerd",
        "password_length": "Wachtwoordlengte",
        "password_policy": "Wachtwoordbeleid",
        "password_policy_chars": "Moet tenminste één alfanumeriek karakter bevatten",
        "password_policy_length": "Minimale wachtwoord lengte is %d",
        "ip_check": "IP controle",
        "ip_check_disabled": "IP controle is uitgeschakeld. Je kan het inschakelen onder<br> <strong>Systeem > Configuratie > Opties > Aanpassen</strong>",
        "oauth2_apps": "OAuth2 applicaties",
        "oauth2_add_client": "Voeg OAuth2 client toe",
        "options": "Opties",
        "password_policy_lowerupper": "Moet hoofdletters en kleine letters bevatten",
        "password_policy_numbers": "Moet ten minste één nummer bevatten",
        "password_policy_special_chars": "Moet tenminste één speciaal teken bevatten",
        "relay_rcpt": "\"Aan:\" adres",
        "rsettings_preset_4": "Rspamd voor domein uitschakelen",
        "service": "Dienst",
        "success": "Succes",
        "admins": "Administrators",
        "admins_ldap": "LDAP administrators",
        "api_read_only": "Alleen-lezen toegang",
        "api_read_write": "Lees en schrijf toegang",
        "login_time": "Login tijd"
    },
    "danger": {
        "access_denied": "Toegang geweigerd of ongeldige gegevens",
        "alias_domain_invalid": "Aliasdomein %s is ongeldig",
        "alias_empty": "Aliasadres dient ingevuld te worden",
        "alias_goto_identical": "Het alias- en doeladres mogen niet identiek zijn",
        "alias_invalid": "Aliasadres %s is ongeldig",
        "aliasd_targetd_identical": "Aliasdomein %s dient af te wijken van het doeldomein",
        "aliases_in_use": "Maximaal aantal aliassen dient gelijk te zijn aan, of groter te zijn dan %d",
        "app_name_empty": "Naam van app dient ingevuld te worden",
        "app_passwd_id_invalid": "Appwachtwoord %s is ongeldig",
        "bcc_empty": "BCC-bestemming dient ingevuld te worden",
        "bcc_exists": "BCC-map %s bestaat voor type %s",
        "bcc_must_be_email": "BCC-bestemming %s is geen geldig mailadres",
        "comment_too_long": "Opmerkingen mogen niet langer dan 160 karakters zijn",
        "defquota_empty": "Standaardquota per mailbox dient geen 0 te zijn.",
        "description_invalid": "Beschrijving voor %s is ongeldig",
        "dkim_domain_or_sel_exists": "Key voor \"%s\" bestaat reeds en zal niet worden overgeschreven",
        "dkim_domain_or_sel_invalid": "ARC/DKIM-domein of selector ongeldig: %s",
        "domain_cannot_match_hostname": "Het domein dient af te wijken van de hostname",
        "domain_exists": "Domain %s bestaat reeds",
        "domain_invalid": "Domeinnaam is ongeldig",
        "domain_not_empty": "Domein %s is in gebruik, verwijderen niet mogelijk",
        "domain_not_found": "Domein %s niet gevonden",
        "domain_quota_m_in_use": "Domeinquota dient gelijk te zijn aan, of groter te zijn dan %s MiB",
        "extra_acl_invalid": "Extern verzendadres \"%s\" is ongeldig",
        "extra_acl_invalid_domain": "Extern verzendadres \"%s\" gebruikt een ongeldig domein",
        "file_open_error": "Er kan niet geschreven worden naar het bestand",
        "filter_type": "Verkeerd filtertype",
        "from_invalid": "De afzender dient ingevuld te worden",
        "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",
        "goto_empty": "Een aliasadres dient ten minste één doeladres te hebben",
        "goto_invalid": "Doeladres %s is ongeldig",
        "ham_learn_error": "Ham training-error: %s",
        "imagick_exception": "Error: Er is een fout opgetreden met Imagick tijdens het lezen van de afbeelding",
        "img_invalid": "Kan afbeelding niet valideren",
        "img_tmp_missing": "Kan afbeelding niet valideren, tijdelijk bestand niet gevonden",
        "invalid_bcc_map_type": "Ongeldig BCC-map type",
        "invalid_destination": "Formaat van bestemming \"%s\" is ongeldig",
        "invalid_filter_type": "Ongeldig filtertype",
        "invalid_host": "Ongeldige host gespecificeerd: %s",
        "invalid_mime_type": "Ongeldig mime-type",
        "invalid_nexthop": "Formaat van nexthop is ongeldig",
        "invalid_nexthop_authenticated": "Er bestaat al een nexthop met andere aanmeldingsgegevens. Pas deze gegevens voor de reeds bestaande nexthop eerst aan.",
        "invalid_recipient_map_new": "Ongeldige nieuwe ontvanger ingevoerd: %s",
        "invalid_recipient_map_old": "Ongeldige oorspronkelijke ontvanger ingevoerd: %s",
        "ip_list_empty": "Lijst met toegestane IP-adressen dient ingevuld te worden",
        "is_alias": "Aliasadres %s bestaat reeds",
        "is_alias_or_mailbox": "Aliasadres of mailbox %s bestaat reeds",
        "is_spam_alias": "Tijdelijk alias (spamalias) %s bestaat reeds",
        "last_key": "De laatste key kan niet worden verwijderd. Schakel tweefactorauthenticatie in plaats daarvan uit.",
        "login_failed": "Aanmelding mislukt",
        "mailbox_defquota_exceeds_mailbox_maxquota": "Standaardquota overschrijdt de quotalimiet",
        "mailbox_invalid": "Naam van de mailbox is ongeldig",
        "mailbox_quota_exceeded": "Mailboxquota heeft het domeinlimiet overschreden (max. %d MiB)",
        "mailbox_quota_exceeds_domain_quota": "Maximale mailboxquota is groter dan domeinquota",
        "mailbox_quota_left_exceeded": "Onvoldoende ruimte beschikbaar (%d MiB)",
        "mailboxes_in_use": "Maximaal aantal mailboxen dient gelijk te zijn aan, of groter te zijn dan %d",
        "malformed_username": "Ongeldige gebruikersnaam",
        "map_content_empty": "Inhoud dient ingevuld te zijn",
        "max_alias_exceeded": "Maximaal aantal aliassen overschreden",
        "max_mailbox_exceeded": "Maximaal aantal mailboxen overschreden (%d van %d)",
        "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",
        "no_user_defined": "Geen gebruiker gespecificeerd",
        "object_exists": "Object %s bestaat reeds",
        "object_is_not_numeric": "Waarde %s is niet numeriek",
        "password_complexity": "Wachtwoord voldoet niet aan de vereisten (6 tekens lang, letters en nummers)",
        "password_empty": "Het wachtwoord dient ingevuld worden",
        "password_mismatch": "De ingevoerde wachtwoorden komen niet overeen",
        "policy_list_from_exists": "Er bestaat reeds een vermelding met dezelfde naam",
        "policy_list_from_invalid": "Invoer is ongeldig",
        "private_key_error": "Private key error: %s",
        "pushover_credentials_missing": "Pushover-token/key niet ingevuld",
        "pushover_key": "Formaat van Pushover-key is ongeldig",
        "pushover_token": "Formaat van Pushover-token is ongeldig",
        "quota_not_0_not_numeric": "Quota dient numeriek en groter dan 0 te zijn",
        "recipient_map_entry_exists": "Ontvanger-map met \"%s\" bestaat reeds",
        "redis_error": "Redis-error: %s",
        "relayhost_invalid": "Invoer %s is ongeldig",
        "release_send_failed": "Het volgende bericht kon niet worden vrijgegeven: %s",
        "reset_f2b_regex": "Regex-filters konden niet worden hersteld, probeer het opnieuw of herlaad de pagina over enkele seconden.",
        "resource_invalid": "Naam van resource %s is ongeldig",
        "rl_timeframe": "Ratelimit-tijdsbestek is ongeldig",
        "rspamd_ui_pw_length": "Rspamd-wachtwoord dient minstens 6 tekens lang te zijn",
        "script_empty": "Script dient ingevuld te worden",
        "sender_acl_invalid": "Toegangscontrole van afzender %s is ongeldig",
        "set_acl_failed": "Toegangscontrole kon niet worden ingesteld",
        "settings_map_invalid": "Instellingen ongeldig",
        "sieve_error": "Sieve-error: %s",
        "spam_learn_error": "Spam training-error: %s",
        "subject_empty": "Het onderwerp dient ingevuld te worden",
        "target_domain_invalid": "Doeladres %s is ongeldig",
        "targetd_not_found": "Doeldomein %s niet gevonden",
        "targetd_relay_domain": "Doeldomein %s is een geforward domein",
        "temp_error": "Tijdelijke fout",
        "text_empty": "De tekst dient ingevuld te worden",
        "tfa_token_invalid": "Tweefactorauthenticatietoken is ongeldig",
        "tls_policy_map_dest_invalid": "Beleidsbestemming is ongeldig",
        "tls_policy_map_entry_exists": "Versleutelingsbeleid met \"%s\" bestaat reeds",
        "tls_policy_map_parameter_invalid": "Beleidsparameter is ongeldig",
        "totp_verification_failed": "TOTP-verificatie mislukt",
        "transport_dest_exists": "Transportbestemming \"%s\" bestaat reeds",
        "webauthn_verification_failed": "WebAuthn-verificatie mislukt: %s",
        "fido2_verification_failed": "FIDO2-verificatie mislukt: %s",
        "unknown": "Er is een onbekende fout opgetreden",
        "unknown_tfa_method": "Onbekende tweefactorauthenticatiemethode",
        "unlimited_quota_acl": "Onbeperkte quota geweigerd door toegangscontrole",
        "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",
        "cors_invalid_method": "Ongeldige Allow-Method opgegeven",
        "webauthn_authenticator_failed": "De geselecteerde authenticator kon niet wordcen gevonden",
        "webauthn_publickey_failed": "Er was geen publieke sleutel opgeslagen voor de geselecteerde authenticator",
        "demo_mode_enabled": "Demo modus is ingeschakeld",
        "template_exists": "Sjabloon %s bestaat al",
        "template_id_invalid": "Sjabloon ID %s ongeldig",
        "template_name_invalid": "Sjabloon naam ongeldig"
    },
    "debug": {
        "chart_this_server": "Grafiek (deze server)",
        "containers_info": "Containerinformatie",
        "disk_usage": "Schijfgebruik",
        "external_logs": "Externe logs",
        "history_all_servers": "Geschiedenis (alle servers)",
        "in_memory_logs": "Geheugenlogs",
        "jvm_memory_solr": "JVM-geheugengebruik",
        "log_info": "<p>Mailcows <b>geheugenlogs</b> worden elke minuut afgesneden naar maximaal %d regels (LOG_LINES) om de stabiliteit te garanderen.<br>Geheugenlogs zijn niet bedoeld om bewaard te blijven. Alle applicaties die geheugenlogs schrijven worden ook naar het Docker-proces gelogd.<br>De geheugenlogs kunnen gebruikt worden voor het oplossen van problemen met bepaalde containers.</p><p><b>Externe logs</b> worden verzameld doormiddel van de API van deze applicaties.</p><p><b>Statische logs</b> zijn activiteitenlogs die niet naar het Docker-proces worden gelogd, maar wel bewaard moeten blijven (uitgezonderd API-logs).</p>",
        "logs": "Logs",
        "restart_container": "Herstart",
        "solr_dead": "Solr 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",
        "container_running": "Actief",
        "container_disabled": "Container gestopt of uitgeschakeld",
        "container_stopped": "Gestopt",
        "current_time": "Systeemtijd",
        "error_show_ip": "Kon het publieke IP adres niet resolven",
        "login_time": "Tijd",
        "memory": "Geheugen",
        "show_ip": "Toon publiek IP",
        "success": "Succes",
        "timezone": "Tijdzone",
        "update_available": "Er is een update beschikbaar",
        "no_update_available": "Het systeem heeft de laatste versie",
        "update_failed": "Kon niet op updates controleren",
        "username": "Gebruikersnaam",
        "wip": "Momenteel werk in uitvoering",
        "architecture": "Architectuur",
        "cores": "Kernen",
        "service": "Dienst"
    },
    "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://docs.mailcow.email/prerequisite/prerequisite-dns/\">de documentatie</a>.",
        "dns_records_data": "Correcte gegevens",
        "dns_records_name": "Naam",
        "dns_records_status": "Huidige staat",
        "dns_records_type": "Type",
        "optional": "Deze vermelding is optioneel."
    },
    "edit": {
        "active": "Actief",
        "advanced_settings": "Geavanceerde instellingen",
        "alias": "Wijzig alias",
        "allow_from_smtp": "Sta enkel de volgende IP-adressen toe voor <b>SMTP</b>",
        "allow_from_smtp_info": "Laat leeg om alle afzenders toe te staan.<br>IPv4/IPv6-adressen en netwerken.",
        "allowed_protocols": "Toegestane protocollen",
        "app_name": "Naam van app",
        "app_passwd": "Appwachtwoord",
        "automap": "Probeer mappen automatisch te koppelen (\"Verzonden items\", \"Verzonden\" => \"Verzonden\" etc.)",
        "backup_mx_options": "Relay-opties",
        "bcc_dest_format": "Een BCC-bestemming dient één geldig mailadres te zijn.",
        "client_id": "Client-ID",
        "client_secret": "Client-secret",
        "comment_info": "Een persoonlijke opmerking is niet zichtbaar voor de gebruiker, terwijl een publieke opmerking wel getoond wordt in het overzicht van de gebruiker.",
        "delete1": "Verwijder van bron wanneer voltooid",
        "delete2": "Verwijder berichten die zich niet in de bron bevinden",
        "delete2duplicates": "Verwijder duplicaten op de bestemming",
        "delete_ays": "Bevestig de verwijdering.",
        "description": "Beschrijving",
        "disable_login": "Weiger aanmelden (inkomende mail blijft binnenkomen)",
        "domain": "Wijzig domein",
        "domain_admin": "Wijzig administrator",
        "domain_quota": "Domeinquota (MiB)",
        "domains": "Domeinen",
        "dont_check_sender_acl": "Schakel verzendcontrole uit voor domein %s (inclusief aliasdomeinen)",
        "edit_alias_domain": "Wijzig aliasdomein",
        "encryption": "Versleuteling",
        "exclude": "Sluit objecten uit (regex)",
        "extended_sender_acl": "Externe verzendadressen",
        "extended_sender_acl_info": "Wanneer mogelijk dient er een ARC/DKIM-key geïmporteerd te worden. Vergeet niet om deze server toe te voegen aan het SPF-record <br>Zodra er een domein of aliasdomein wordt toegevoegd aan deze server, overeenkomend met een extern verzendadres, wordt het externe adres verwijderd.<br>Gebruik @domain.tld om verzenden vanuit *@domain.tld toe te staan.",
        "force_pw_update": "Vereis nieuw wachtwoord bij eerstvolgende login",
        "force_pw_update_info": "Deze gebruiker kan zich hierdoor uitsluitend aanmelden bij %s, totdat de procedure succesvol doorlopen is.",
        "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>",
        "generate": "genereer",
        "grant_types": "Grant types",
        "hostname": "Hostname",
        "inactive": "Inactief",
        "kind": "Soort",
        "last_modified": "Voor het laatst bijgewerkt op",
        "mailbox": "Wijzig mailbox",
        "mailbox_quota_def": "Standaard mailboxquota",
        "max_aliases": "Maximaal aantal aliassen",
        "max_mailboxes": "Maximaal aantal mailboxen",
        "max_quota": "Mailboxquota (MiB)",
        "maxage": "Maximale leeftijd van berichten (in dagen) die extern worden opgehaald<br><small>(0 = negeer leeftijd)</small>",
        "maxbytespersecond": "Maximale bytes per seconde <br><small>(0 = onbeperkt)</small>",
        "mbox_rl_info": "De ratelimit wordt toegepast op de huidige mailboxgebruiker en geldt voor elk verzendadres die door deze wordt gebruikt. Een mailbox-ratelimit staat boven een domein-ratelimit.",
        "mins_interval": "Interval (min)",
        "multiple_bookings": "Meerdere boekingen",
        "nexthop": "Nexthop",
        "password": "Wachtwoord",
        "password_repeat": "Herhaal wachtwoord",
        "previous": "Vorige pagina",
        "private_comment": "Persoonlijke opmerking",
        "public_comment": "Publieke opmerking",
        "pushover_evaluate_x_prio": "Escaleer mail met hoge prioriteit [<code>X-Priority: 1</code>]",
        "pushover_info": "Pushmeldingen zijn van toepassing op alle spamvrije mail afgeleverd aan <b>%s</b>, inclusief aliassen (gedeeld, niet gedeeld en getagd).",
        "pushover_only_x_prio": "Uitsluitend mail met hoge prioriteit [<code>X-Priority: 1</code>]",
        "pushover_sender_array": "Uitsluitend de volgende afzenders <small>(kommagescheiden)</small>",
        "pushover_sender_regex": "Uitsluitend een afzender met de volgende regex",
        "pushover_text": "Meldingstekst ({SUBJECT} zal worden vervangen door het onderwerp)",
        "pushover_title": "Meldingstitel",
        "pushover_sound": "Geluid",
        "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.",
        "relay_domain": "Forward dit domein",
        "relay_transport_info": "<div class=\"badge fs-6 bg-info\">Info</div> Je kunt transport-maps aanmaken om een aangepaste bestemming in te stellen voor dit domein. Zo niet, zal er een MX-lookup plaatsvinden.",
        "relay_unknown_only": "Forward uitsluitend niet-bestaande mailboxen. Bestaande mailboxen zullen lokaal afgeleverd worden.",
        "relayhost": "Afzendergebonden transport-maps",
        "remove": "Verwijder",
        "resource": "Resource",
        "save": "Wijzigingen opslaan",
        "scope": "Scope",
        "sender_acl": "Sta toe om te verzenden als",
        "sender_acl_disabled": "<span class=\"badge fs-6 bg-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",
        "skipcrossduplicates": "Sla duplicaten verspreid over mappen over (wie het eerst komt, het eerst maalt)",
        "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>",
        "syncjob": "Wijzig sync job",
        "target_address": "Doeladres(sen) <small>(kommagescheiden)</small>",
        "target_domain": "Doeldomein",
        "timeout1": "Time-out voor verbinding met externe hosts",
        "timeout2": "Time-out voor verbinding met lokale hosts",
        "title": "Wijzig object",
        "unchanged_if_empty": "Laat leeg wanneer ongewijzigd",
        "username": "Gebruikersnaam",
        "validate_save": "Verifieer en sla op",
        "domain_footer_info": "Domeinwijde voetteksten worden toegevoegd aan alle uitgaande e-mails die zijn gekoppeld aan een adres binnen dit domein. <br> De volgende variabelen kunnen worden gebruikt voor de voettekst:",
        "admin": "Bewerk administrator",
        "app_passwd_protocols": "Toegestane protocollen voor app wachtwoord",
        "created_on": "Gemaakt op",
        "acl": "ACL (Toestemming)",
        "domain_footer": "Domeinbreede footer",
        "domain_footer_html": "HTML footer",
        "mailbox_relayhost_info": "Wordt alleen toegepast op de mailbox en directe aliassen, maar heft een domein relayhost op."
    },
    "footer": {
        "cancel": "Annuleren",
        "confirm_delete": "Bevestig verwijdering",
        "delete_now": "Nu verwijderen",
        "delete_these_items": "Bevestig de wijzigingen aan het volgende item",
        "hibp_nok": "Dit is een onveilig wachtwoord!",
        "hibp_ok": "Dit wachtwoord is niet publiekelijk bekend",
        "loading": "Even geduld aub...",
        "restart_container": "Herstart container",
        "restart_container_info": "<b>Belangrijk:</b> Een herstart kan enige tijd in beslag nemen, wacht aub totdat dit proces voltooid is.<br>Deze pagina zal zichzelf verversen zodra het proces voltooid is.",
        "restart_now": "Nu herstarten",
        "restarting_container": "Container wordt herstart, even geduld aub..."
    },
    "header": {
        "administration": "Configuratie & details",
        "apps": "Apps",
        "debug": "Systeeminformatie",
        "email": "E-Mail",
        "mailcow_config": "Beheer",
        "quarantine": "Quarantaine",
        "restart_netfilter": "Herstart netfilter",
        "restart_sogo": "Herstart SOGo",
        "user_settings": "Gebruikersinstellingen"
    },
    "info": {
        "awaiting_tfa_confirmation": "In afwachting van tweefactorauthenticatie...",
        "no_action": "Geen handeling van toepassing",
        "session_expires": "Je huidige sessie verloopt over ongeveer 15 seconden"
    },
    "login": {
        "delayed": "Aanmelding vertraagd met %s seconden.",
        "fido2_webauthn": "FIDO2/WebAuthn Login",
        "login": "Aanmelden",
        "mobileconfig_info": "Log in als mailboxgebruiker om het Apple-verbindingsprofiel te downloaden.",
        "other_logins": "Meld aan met key",
        "password": "Wachtwoord",
        "username": "Gebruikersnaam"
    },
    "mailbox": {
        "action": "Handeling",
        "activate": "Activeer",
        "active": "Actief",
        "add": "Voeg toe",
        "add_alias": "Voeg alias toe",
        "add_bcc_entry": "Voeg BCC-map toe",
        "add_domain": "Voeg domein toe",
        "add_domain_alias": "Voeg domeinalias toe",
        "add_domain_record_first": "Voeg eerst een domein toe",
        "add_filter": "Voeg filter toe",
        "add_mailbox": "Voeg mailbox toe",
        "add_recipient_map_entry": "Voeg ontvanger-map toe",
        "add_resource": "Voeg resource toe",
        "add_tls_policy_map": "Voeg versleutelingsbeleid toe",
        "address_rewriting": "Adresomleidingen",
        "alias": "Alias",
        "alias_domain_alias_hint": "Aliassen worden <b>niet</b> automatisch toegepast op domeinaliassen. Aliasadres <code>alias@domein</code> dekt het adres <code>alias@alias-domein</code> <b>niet</b> (waarbij \"alias-domein\" een aliasdomein is voor \"domein\").<br>Gebruik een filter om mail te forwarden naar een externe mailbox (zie het tabje \"Filters\" of gebruik SOGo -> Doorsturen).",
        "alias_domain_backupmx": "Aliasdomein inactief voor geforward domein",
        "aliases": "Aliassen",
        "allow_from_smtp": "Sta enkel de volgende IP-adressen toe voor <b>SMTP</b>",
        "allow_from_smtp_info": "Laat leeg om alle afzenders toe te staan.<br>IPv4/IPv6-adressen en netwerken.",
        "allowed_protocols": "Toegestane protocollen",
        "backup_mx": "Relaydomein",
        "bcc": "BCC",
        "bcc_destination": "BCC-bestemming",
        "bcc_destinations": "BCC-bestemmingen",
        "bcc_info": "BCC-maps worden gebruikt om kopieën van alle berichten naar een ander adres te forwarden.<br>Wees er van bewust dat er geen melding wordt gedaan van een mislukte aflevering.",
        "bcc_local_dest": "Lokale bestemming",
        "bcc_map": "BCC-map",
        "bcc_map_type": "BCC-type",
        "bcc_maps": "BCC-maps",
        "bcc_rcpt_map": "Ontvanger-map",
        "bcc_sender_map": "Afzender-map",
        "bcc_to_rcpt": "Schakel over naar ontvanger-map",
        "bcc_to_sender": "Schakel over naar afzender-map",
        "bcc_type": "BCC-type",
        "booking_null": "Toon altijd als vrij",
        "booking_0_short": "Altijd vrij",
        "booking_custom": "Zet vast op een specifiek aantal boekingen",
        "booking_custom_short": "Hard limit",
        "booking_ltnull": "Onbeperkt, maar toon als bezet wanneer geboekt",
        "booking_lt0_short": "Soft limit",
        "daily": "Dagelijks",
        "deactivate": "Deactiveer",
        "description": "Beschrijving",
        "disable_login": "Weiger aanmelden (inkomende mail blijft binnenkomen)",
        "disable_x": "Schakel uit",
        "dkim_domains_selector": "Selector",
        "dkim_key_length": "Grootte van key (bits)",
        "domain": "Domein",
        "domain_admins": "Domeinadministrators",
        "domain_aliases": "Domeinaliassen",
        "domain_quota": "Quota",
        "domains": "Domeinen",
        "edit": "Wijzig",
        "empty": "Geen resultaten",
        "enable_x": "Schakel in",
        "excludes": "Exclusief",
        "filter_table": "Filtertabel",
        "filters": "Filters",
        "fname": "Volledige naam",
        "force_pw_update": "Vereis nieuw wachtwoord bij eerstvolgende login",
        "gal": "Globale adreslijst",
        "hourly": "Ieder uur",
        "in_use": "In gebruik (%)",
        "inactive": "Inactief",
        "insert_preset": "Voeg voorbeelden in \"%s\"",
        "kind": "Soort",
        "last_mail_login": "Laatste mail login",
        "last_modified": "Voor het laatst bijgewerkt op",
        "last_run": "Laatst uitgevoerd",
        "last_run_reset": "Plan volgende",
        "mailbox": "Mailbox",
        "mailbox_defquota": "Standaard mailboxgrootte",
        "mailbox_quota": "Maximale mailboxgrootte",
        "mailboxes": "Mailboxen",
        "mailbox_defaults": "Standaardinstellingen",
        "mailbox_defaults_info": "Stel standaardinstellingen in voor nieuwe mailboxen.",
        "max_aliases": "Maximaal aantal aliassen",
        "max_mailboxes": "Maximaal aantal mailboxen",
        "max_quota": "Mailboxquota",
        "mins_interval": "Interval (min)",
        "msg_num": "Bericht #",
        "multiple_bookings": "Meerdere boekingen",
        "never": "Nooit",
        "no_record": "Geen vermelding voor object %s",
        "no_record_single": "Geen vermelding",
        "owner": "Eigenaar",
        "private_comment": "Persoonlijke opmerking",
        "public_comment": "Publieke opmerking",
        "q_add_header": "Spamfolder",
        "q_all": "Alle categorieën",
        "q_reject": "Geweigerd",
        "quarantine_notification": "Quarantainemeldingen",
        "quarantine_category": "Categorie van quarantainemelding",
        "quick_actions": "Handelingen",
        "recipient_map": "Ontvanger-map",
        "recipient_map_info": "Ontvanger-maps worden gebruikt om het doeladres van een bericht te vervangen voordat het in een mailbox terecht komt.",
        "recipient_map_new": "Nieuwe ontvanger",
        "recipient_map_new_info": "De bestemming van een ontvanger-map dient een geldig mailadres te zijn.",
        "recipient_map_old": "Oorspronkelijke ontvanger",
        "recipient_map_old_info": "De oorspronkelijke bestemming van een ontvanger-map dient een geldig mailadres of domeinnaam te zijn.",
        "recipient_maps": "Ontvanger-maps",
        "relay_all": "Forward alle ontvangers",
        "remove": "Verwijder",
        "resources": "Resources",
        "running": "Wordt uitgevoerd",
        "set_postfilter": "Stel in als nafilter",
        "set_prefilter": "Stel in als voorfilter",
        "sieve_info": "Het is mogelijk om meerdere filters per gebruiker in te stellen, maar er kan slechts één voorfilter en één nafilter tegelijkertijd actief zijn.<br>Elk filter zal in de aangegeven volgorde worden verwerkt. Noch een mislukt script, noch een gespecificeerde \"keep;\" zal de verwerking van volgende scripts stoppen. Bij wijzigingen aan globale filters zal Dovecot herstart worden.<br><br>Globaal voorfilter</a> → Voorfilter → Gebruikersscripts → Nafilter → Globaal nafilter",
        "sieve_preset_1": "Weiger mail met mogelijk schadelijke bestandstypes",
        "sieve_preset_2": "Markeer de mail van een specifieke afzender altijd als gelezen",
        "sieve_preset_3": "Verwijder en stop het filterproces",
        "sieve_preset_4": "Behoud en stop het filterproces",
        "sieve_preset_5": "Autoreply (vakantie)",
        "sieve_preset_6": "Weiger mail met antwoord",
        "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_visible": "Alias tonen in SOGo",
        "sogo_visible_n": "Verberg alias in SOGo",
        "sogo_visible_y": "Toon alias in SOGo",
        "spam_aliases": "Tijdelijk alias",
        "stats": "Statistieken",
        "status": "Status",
        "sync_jobs": "Sync jobs",
        "table_size": "Tabelgrootte",
        "table_size_show_n": "Toon %s items",
        "target_address": "Doeladres",
        "target_domain": "Doeldomein",
        "tls_enforce_in": "Forceer inkomende versleuteling",
        "tls_enforce_out": "Forceer uitgaande versleuteling",
        "tls_map_dest": "Bestemming",
        "tls_map_dest_info": "Voorbeeld: example.org, .example.org, [mail.example.org]:25",
        "tls_map_parameters": "Parameters",
        "tls_map_parameters_info": "Voorbeeld: protocols=!SSLv2 ciphers=medium exclude=3DES",
        "tls_map_policy": "Beleid",
        "tls_policy_maps": "Globaal versleutelingsbeleid",
        "tls_policy_maps_info": "Deze opties worden boven het versleutelingsbeleid van een gebruiker verkozen.<br>Bekijk <a href=\"http://www.postfix.org/postconf.5.html#smtp_tls_policy_maps\" target=\"_blank\">de documentatie</a> voor meer informatie.",
        "tls_policy_maps_enforced_tls": "Dit is ook van invloed op mailboxgebruikers die uitgaande versleuteling forceren. Wanneer er geen beleid is ingesteld zullen de standaardwaarden, <code>smtp_tls_mandatory_protocols</code> en <code>smtp_tls_mandatory_ciphers</code>, van toepassing zijn.",
        "tls_policy_maps_long": "Uitgaand versleutelingsbeleid",
        "toggle_all": "Selecteer alles",
        "username": "Gebruikersnaam",
        "waiting": "Wachten",
        "weekly": "Wekelijks"
    },
    "oauth2": {
        "access_denied": "Log in als een mailboxgebruiker om toegang via OAuth te verlenen",
        "authorize_app": "Autoriseer applicatie",
        "deny": "Weiger",
        "permit": "Autoriseer applicatie",
        "profile": "Profiel",
        "profile_desc": "Persoonlijke informatie: gebruikersnaam, volledige naam, aanmaakdatum, bewerkdatum, activiteit",
        "scope_ask_permission": "Een applicatie heeft toegang tot de volgende onderdelen gevraagd"
    },
    "quarantine": {
        "action": "Handeling",
        "atts": "Bijlagen",
        "check_hash": "Zoek bestandshash op in VT",
        "confirm": "Bevestig",
        "confirm_delete": "Bevestig de verwijdering van dit item.",
        "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",
        "info": "Informatie",
        "junk_folder": "Spamfolder",
        "learn_spam_delete": "Markeer als spam en verwijder",
        "low_danger": "Laag",
        "medium_danger": "Gemiddeld",
        "neutral_danger": "Neutraal",
        "notified": "Verwittigd",
        "qhandler_success": "Aanvraag succesvol verzonden naar het systeem. Je kunt nu het venster sluiten.",
        "qid": "Rspamd QID",
        "qinfo": "Het quarantainesysteem slaat een kopie van zowel geweigerde mail (voor de afzender zal het lijken alsof de mail <em>niet</em> afgeleverd is), als mail die afgeleverd is de spamfolder, op in de database.\r\n  <br>\"Markeer als spam en verwijder\" traint het systeem om soortgelijke mails in de toekomst opnieuw als spam te markeren.\r\n  <br>Wanneer er meerdere berichten tegelijkertijd worden behandeld kan het mogelijk enige tijd duren.<br>Elementen op de blacklist zijn uitgesloten van de quarantaine.",
        "qitem": "Quarantaine-item",
        "quarantine": "Quarantaine",
        "quick_actions": "Handelingen",
        "rcpt": "Ontvanger",
        "received": "Ontvangen",
        "recipients": "Ontvangers",
        "refresh": "Ververs",
        "rejected": "Geweigerd",
        "release": "Geef vrij",
        "release_body": "We hebben het oorspronkelijke bericht als los bestand bijgevoegd. Open dit bestand om het bericht weer te geven.",
        "release_subject": "Mogelijk schadelijk quarantaine-item %s",
        "remove": "Verwijder",
        "rewrite_subject": "Herschrijf onderwerp",
        "rspamd_result": "Rspamd-resultaat",
        "sender": "Afzender (SMTP)",
        "sender_header": "Afzender (\"From\" header)",
        "type": "Type",
        "quick_release_link": "Open snelkoppeling voor vrijgeven",
        "quick_delete_link": "Open snelkoppeling voor verwijderen",
        "quick_info_link": "Open snelkoppeling met informatie",
        "show_item": "Toon item",
        "spam": "Spam",
        "spam_score": "Score",
        "subj": "Onderwerp",
        "table_size": "Tabelgrootte",
        "table_size_show_n": "Toon %s items",
        "text_from_html_content": "Inhoud (geconverteerde html)",
        "text_plain_content": "Inhoud (tekst)",
        "toggle_all": "Selecteer alles"
    },
    "queue": {
        "queue_manager": "Queue manager"
    },
    "start": {
        "help": "Toon/verberg hulppaneel",
        "imap_smtp_server_auth_info": "Gebruik je volledige mailadres en het bijbehorende (onversleutelde) verificatiemechanisme.<br>De aanmeldgegevens worden versleuteld verzonden.",
        "mailcow_apps_detail": "Gebruik een Mailcow-app om je mails, agenda, contacten en meer te bekijken.",
        "mailcow_panel_detail": "<b>Domeinadministrators</b> kunnen mailboxen en aliassen aanmaken, wijzigen en verwijderen. Ook kunnen ze domeinen weergeven en aanpassen.<br><b>Gebruikers</b> kunnen tijdelijke aliassen aanmaken, hun wachtwoord aanpassen en de spamfilterinstellingen wijzigen."
    },
    "success": {
        "acl_saved": "Toegangscontrole voor object %s is opgeslagen",
        "admin_added": "Administrator %s is toegevoegd",
        "admin_api_modified": "Wijzigingen aan de API zijn opgeslagen",
        "admin_modified": "Wijzigingen aan administrator zijn opgeslagen",
        "admin_removed": "Administrator %s is verwijderd",
        "alias_added": "Aliasadres %s (%d) is toegevoegd",
        "alias_domain_removed": "Aliasdomein %s is verwijderd",
        "alias_modified": "Wijzigingen aan alias %s zijn opgeslagen",
        "alias_removed": "Alias %s is verwijderd",
        "aliasd_added": "Aliasdomein %s is toegevoegd",
        "aliasd_modified": "Wijzigingen aan aliasadres %s zijn opgeslagen",
        "app_links": "Wijzigingen aan app links zijn opgeslagen",
        "app_passwd_added": "Appwachtwoord toegevoegd",
        "app_passwd_removed": "Appwachtwoord verwijderd: %s",
        "bcc_deleted": "BCC-maps %s zijn verwijderd",
        "bcc_edited": "BCC-map %s is gewijzigd",
        "bcc_saved": "BCC-map is opgeslagen",
        "db_init_complete": "Database-initialisatie voltooid",
        "delete_filter": "Filter %s is verwijderd",
        "delete_filters": "Filters %s zijn verwijderd",
        "deleted_syncjob": "Sync job %s is verwijderd",
        "deleted_syncjobs": "Sync jobs %s zijn verwijderd",
        "dkim_added": "ARC/DKIM-key %s is opgeslagen",
        "dkim_duplicated": "ARC/DKIM-key voor domein %s is gekopieerd naar %s",
        "dkim_removed": "ARC/DKIM-key %s is verwijderd",
        "domain_added": "Domein %s is toegevoegd",
        "domain_admin_added": "Domeinadministrator %s is toegevoegd",
        "domain_admin_modified": "Wijzigingen aan domeinadministrator %s zijn opgeslagen",
        "domain_admin_removed": "Domeinadministrator %s is verwijderd",
        "domain_modified": "Wijzigingen aan domein %s zijn opgeslagen",
        "domain_removed": "Domein %s is verwijderd",
        "dovecot_restart_success": "Dovecot is succesvol herstart",
        "eas_reset": "De ActiveSync-apparaatcache van gebruiker %s is hersteld",
        "f2b_modified": "Wijzigingen aan Fail2ban zijn opgeslagen",
        "forwarding_host_added": "Forwarding host %s is toegevoegd",
        "forwarding_host_removed": "Forwarding host %s is verwijderd",
        "global_filter_written": "Filter is opgeslagen",
        "hash_deleted": "Hash verwijderd",
        "item_deleted": "Item %s is verwijderd",
        "item_released": "Item %s is vrijgegeven",
        "items_deleted": "Items %s zijn verwijderd",
        "items_released": "Geselecteerde items zijn vrijgegeven",
        "learned_ham": "Bericht %s is als ham gemarkeerd",
        "license_modified": "Wijzigingen aan de licentie zijn opgeslagen",
        "logged_in_as": "Succesvol aangemeld als %s",
        "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",
        "queue_command_success": "Opdracht succesvol voltooid",
        "recipient_map_entry_deleted": "Ontvanger-map %s is verwijderd",
        "recipient_map_entry_saved": "Ontvanger-map %s is opgeslagen",
        "relayhost_added": "Invoer %s is toegevoegd",
        "relayhost_removed": "Invoer %s is verwijderd",
        "reset_main_logo": "Het standaardlogo is hersteld",
        "resource_added": "Resource %s is toegevoegd",
        "resource_modified": "Wijzigingen aan mailbox %s zijn opgeslagen",
        "resource_removed": "Resource %s is verwijderd",
        "rl_saved": "Ratelimit voor object %s is opgeslagen",
        "rspamd_ui_pw_set": "Rspamd-wachtwoord succesvol ingesteld",
        "saved_settings": "Instellingen opgeslagen",
        "settings_map_added": "Instellingen toegevoegd",
        "settings_map_removed": "Instellingen verwijderd: %s",
        "sogo_profile_reset": "Het SOGo-profiel van gebruiker %s is verwijderd",
        "tls_policy_map_entry_deleted": "Versleutelingsbeleid %s is verwijderd",
        "tls_policy_map_entry_saved": "Versleutelingsbeleid \"%s\" is opgeslagen",
        "ui_texts": "Wijzigingen aan labels en teksten zijn opgeslagen",
        "upload_success": "Bestand succesvol geupload",
        "verified_totp_login": "TOTP succesvol geverifieerd",
        "verified_webauthn_login": "WebAuthn succesvol geverifieerd",
        "verified_fido2_login": "FIDO2 succesvol geverifieerd",
        "verified_yotp_login": "Yubico OTP succesvol geverifieerd"
    },
    "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",
        "confirm": "Bevestig",
        "confirm_totp_token": "Bevestig de wijzigingen door de, door je authenticatie-app gegenereerde code, in te voeren.",
        "delete_tfa": "Schakel tweefactorauthenticatie uit",
        "disable_tfa": "Pauzeer tweefactorauthenticatie tot de eerstvolgende succesvolle login",
        "enter_qr_code": "Voer deze code in als je apparaat geen QR-codes kan scannen:",
        "error_code": "Errorcode",
        "init_webauthn": "Even geduld aub...",
        "key_id": "Geef deze YubiKey een naam",
        "key_id_totp": "Geef deze key een naam",
        "none": "Deactiveer",
        "reload_retry": "- (herlaad de pagina als het probleem aanhoudt)",
        "scan_qr_code": "Scan de volgende QR-code met je authenticatie-app:",
        "select": "Selecteer...",
        "set_tfa": "Kies methode voor tweefactorauthenticatie",
        "start_webauthn_validation": "Start validatie",
        "tfa": "Tweefactorauthenticatie",
        "tfa_token_invalid": "Tweefactorauthenticatietoken is ongeldig",
        "totp": "TOTP (Step Two, Authy, etc.)",
        "webauthn": "WebAuthn",
        "waiting_usb_auth": "<i>In afwachting van USB-apparaat...</i><br><br>Druk nu op de knop van je WebAuthn-apparaat.",
        "waiting_usb_register": "<i>In afwachting van USB-apparaat...</i><br><br>Voer je wachtwoord hierboven in en bevestig de registratie van het WebAuthn-apparaat door op de knop van het apparaat te drukken.",
        "yubi_otp": "Yubico OTP"
    },
    "fido2": {
        "set_fn": "Stel naam in",
        "fn": "Naam",
        "rename": "Hernoem",
        "confirm": "Bevestig",
        "register_status": "Registratiestatus",
        "known_ids": "Bekende IDs",
        "none": "Uitgeschakeld",
        "set_fido2": "Registreer FIDO2-apparaat",
        "start_fido2_validation": "Start FIDO2-validatie",
        "fido2_auth": "Aanmelden met FIDO2",
        "fido2_success": "Apparaat succesvol geregistreerd",
        "fido2_validation_failed": "Validatie mislukt"
    },
    "user": {
        "action": "Handeling",
        "active": "Actief",
        "active_sieve": "Actieve filters",
        "advanced_settings": "Geavanceerde instellingen",
        "alias": "Alias",
        "alias_create_random": "Genereer tijdelijk alias",
        "alias_extend_all": "Verleng alias met 1 uur",
        "alias_full_date": "d.m.Y, H:i:s T",
        "alias_remove_all": "Verwijder alle aliassen",
        "alias_select_validity": "Geldigheid",
        "alias_time_left": "Resterende tijd",
        "alias_valid_until": "Geldig tot",
        "aliases_also_send_as": "Toegestaan om te verzenden als",
        "aliases_send_as_all": "Controleer verzendtoegang voor de volgende domeinen, inclusief aliassen, niet",
        "app_hint": "Appwachtwoorden zijn alternatieve wachtwoorden voor IMAP, SMTP, CalDAV, CardDAV en EAS. De gebruikersnaam blijft ongewijzigd.<br>SOGo is niet toegankelijk met een appwachtwoord.",
        "app_name": "Naam van app",
        "app_passwds": "Appwachtwoorden",
        "apple_connection_profile": "Apple-verbindingsprofiel",
        "apple_connection_profile_complete": "Dit verbindingsprofiel bevat de configuratie voor mail, contacten en agenda's op een Apple-apparaat.",
        "apple_connection_profile_mailonly": "Dit verbindingsprofiel bevat de configuratie voor mail op een Apple-apparaat.",
        "change_password": "Wijzig wachtwoord",
        "client_configuration": "Toon configuratiegidsen voor mailprogramma's",
        "create_app_passwd": "Maak appwachtwoord aan",
        "create_syncjob": "Voeg sync job toe",
        "daily": "Dagelijks",
        "day": "dag",
        "delete_ays": "Bevestig de verwijdering.",
        "direct_aliases": "Directe aliasadressen",
        "direct_aliases_desc": "Directe aliasadressen worden beïnvloed door spamfilters en het versleutelingsbeleid.",
        "eas_reset": "Herstel ActiveSync-apparaatcache",
        "eas_reset_help": "In de meeste gevallen verhelpt dit problemen met ActiveSync op je apparaten<br><b>Let wel:</b> alle mails, contacten en agenda's zullen opnieuw gedownload worden!",
        "eas_reset_now": "Herstel nu",
        "edit": "Wijzig",
        "email": "Mail",
        "email_and_dav": "Mail, contacten en agenda's",
        "encryption": "Versleuteling",
        "excludes": "Exclusief",
        "expire_in": "Verloopt over",
        "force_pw_update": "Er <b>dient</b> een nieuw wachtwoord ingesteld te worden, voordat er gebruik kan worden gemaakt van deze dienst.",
        "generate": "genereer",
        "hour": "uur",
        "hourly": "Ieder uur",
        "hours": "uren",
        "in_use": "Gebruikt",
        "interval": "Interval",
        "is_catch_all": "Catch-all voor domeinen",
        "last_mail_login": "Laatste mail login",
        "last_run": "Laatst uitgevoerd",
        "loading": "Bezig met laden...",
        "mailbox_details": "Mailboxdetails",
        "messages": "berichten",
        "never": "Nooit",
        "new_password": "Nieuw wachtwoord",
        "new_password_repeat": "Herhaal wachtwoord",
        "no_active_filter": "Geen actieve filters gevonden",
        "no_last_login": "Geen informatie over laatste login",
        "no_record": "Geen vermelding",
        "password": "Wachtwoord",
        "password_now": "Huidig wachtwoord",
        "password_repeat": "Herhaal wachtwoord",
        "pushover_evaluate_x_prio": "Escaleer mail met hoge prioriteit [<code>X-Priority: 1</code>]",
        "pushover_info": "Pushmeldingen zijn van toepassing op alle schone mail (geen spam) afgeleverd aan <b>%s</b>, inclusief aliassen (gedeeld, niet gedeeld en getagd).",
        "pushover_only_x_prio": "Uitsluitend mail met hoge prioriteit [<code>X-Priority: 1</code>]",
        "pushover_sender_array": "Uitsluitend de volgende afzenders <small>(kommagescheiden)</small>",
        "pushover_sender_regex": "Uitsluitend een afzender met de volgende regex",
        "pushover_text": "Meldingstekst ({SUBJECT} zal worden vervangen door het onderwerp)",
        "pushover_title": "Meldingstitel",
        "pushover_sound": "Geluid",
        "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 (let op het gegevensbeschermingsbeleid)",
        "pushover_verify": "Verifieer aanmeldingsgegevens",
        "q_add_header": "Spamfolder",
        "q_all": "Alle categorieën",
        "q_reject": "Geweigerd",
        "quarantine_notification": "Quarantainemeldingen",
        "quarantine_category": "Categorie van quarantainemelding",
        "quarantine_notification_info": "Zodra een melding is verzonden worden de items als gelezen gemarkeerd. Er zal niet nogmaals melding van diezelfde items worden gemaakt.",
        "quarantine_category_info": "De meldingscategorie \"Geweigerd\" bevat mail die geweigerd is, terwijl \"Spamfolder\" mail bevat die afgeleverd is in de spamfolder van een gebruiker.",
        "remove": "Verwijder",
        "running": "Wordt uitgevoerd",
        "save": "Sla wijzigingen op",
        "save_changes": "Wijzigingen opslaan",
        "sender_acl_disabled": "<span class=\"badge fs-6 bg-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",
        "sogo_profile_reset": "Verwijder SOGo-profiel",
        "sogo_profile_reset_help": "Bij het verwijderen van een SOGo-profiel worden <b>alle gegevens, inclusief contacten en agenda's,</b> permanent verwijderd.",
        "sogo_profile_reset_now": "Verwijder nu",
        "spam_aliases": "Tijdelijke aliassen",
        "spam_score_reset": "Herstel naar standaardwaarde",
        "spamfilter": "Spamfilter",
        "spamfilter_behavior": "Beoordeling",
        "spamfilter_bl": "Blacklist",
        "spamfilter_bl_desc": "Zet mailadressen op de blacklist om ze <b>altijd</b> als spam te markeren. Geweigerde mail zal <b>niet</b> gekopieerd worden naar de quarantaine. Deze lijst wordt niet toegepast op een gedeeld aliasadres. Wildcards (*) zijn toegestaan.",
        "spamfilter_default_score": "Standaardwaarden",
        "spamfilter_green": "Groen: dit bericht is geen spam.",
        "spamfilter_hint": "De eerste waarde omschrijft een lage spamscore, de tweede een hoge spamscore.",
        "spamfilter_red": "Rood: dit bericht is spam en zal, op basis van de instellingen, worden geweigerd of in de quarantaine worden geplaatst.",
        "spamfilter_table_action": "Handeling",
        "spamfilter_table_add": "Voeg toe",
        "spamfilter_table_domain_policy": "n.v.t. (domeinbeleid)",
        "spamfilter_table_empty": "Geen gegevens om weer te geven",
        "spamfilter_table_remove": "verwijder",
        "spamfilter_table_rule": "Regel",
        "spamfilter_wl": "Whitelist",
        "spamfilter_wl_desc": "Zet mailadressen op de whitelist om ze <b>nooit</b> als spam te markeren.<br>Deze lijst wordt niet toegepast op een gedeeld aliasadres.<br>Wildcards (*) zijn toegestaan.",
        "spamfilter_yellow": "Geel: dit bericht is mogelijk spam en zal in de spamfolder geplaatst worden.",
        "status": "Status",
        "sync_jobs": "Sync jobs",
        "tag_handling": "Mailtags",
        "tag_help_example": "Voorbeeld van een maildres met tag: me<b>+Tesla</b>@example.org",
        "tag_help_explain": "In submap: er wordt een nieuwe map aangemaakt, genoemd naar de tag (bijv.: \"INBOX/Tesla\").<br>In onderwerp: de tag wordt vóór het oorspronkelijke onderwerp geplaatst (bijv.: \"[Tesla] Uw serviceafspraak\").",
        "tag_in_none": "Niets doen",
        "tag_in_subfolder": "In submap",
        "tag_in_subject": "In onderwerp",
        "text": "Tekst",
        "title": "Titel",
        "tls_enforce_in": "Vereis inkomend",
        "tls_enforce_out": "Vereis uitgaand",
        "tls_policy": "Versleutelingsbeleid",
        "tls_policy_warning": "<strong>Let wel:</strong> Door versleuteling te forceren, worden mogelijk niet alle mails afgeleverd.<br>Berichten die niet aan het ingestelde beleid voldoen, worden resoluut geweigerd.<br>Dit is van toepassing op het primaire mailadres, inclusief alle <b>directe</b> aliasadressen.",
        "user_settings": "Gebruikersinstellingen",
        "username": "Gebruikersnaam",
        "verify": "Verifieer",
        "waiting": "Wachten",
        "week": "week",
        "weekly": "Wekelijks",
        "weeks": "weken"
    },
    "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": "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",
        "no_active_admin": "Het is niet mogelijk om de laatste actieve administrator te verwijderen",
        "quota_exceeded_scope": "Domeinquota overschreden: Voor dit domein kunnen uitsluitend onbeperkte mailboxen aangemaakt worden.",
        "session_token": "Token ongeldig: komt niet overeen",
        "session_ua": "Token ongeldig: gebruikersagentvalidatie mislukt"
    },
    "datatables": {
        "emptyTable": "Geen data beschikbaar in tabel",
        "expand_all": "Alles uitbreiden",
        "paginate": {
            "last": "Laatste",
            "next": "Volgende",
            "previous": "Vorige",
            "first": "Eerste"
        },
        "aria": {
            "sortAscending": ": activeer om kolommen oplopend te sorteren",
            "sortDescending": ": activeer om kolommen aflopend te sorteren"
        },
        "collapse_all": "Alle samenvoegen",
        "decimal": ".",
        "info": "_START_ tot _END_ van _TOTAL_ worden getoond",
        "infoEmpty": "0 tot 0 van 0 items worden getoond",
        "thousands": ",",
        "lengthMenu": "Toon _MENU_ items",
        "loadingRecords": "Laden...",
        "processing": "Wachten alstublieft..",
        "search": "Zoeken:",
        "zeroRecords": "Geen overeenkomsten gevonden"
    }
}
