<?xml version="1.0" encoding="utf-8"?>
<resources>

    <string name="app_name">Updater</string>
    <string name="fairphone">Fairphone</string>
    <string name="android">Android</string>
    <string name="updater_service">Updater Service</string>
    <string name="a_different_os_from_the_current">een ander besturingssysteem dan je huidige</string>
    <string name="an_older_version_of_os">een oudere versie van je huidige besturingssysteem</string>
    <string name="android_os">Stock Android</string>
    <string name="config_file_download_link_error_message">Fout tijdens downloaden configuratiebestand. Gebruikte link:</string>
    <string name="dev_mode_message">Ontwikkelaarsmodus aangezet voor deze sessie</string>
    <string name="device_not_supported_message">Apparaat wordt niet ondersteund</string>
    <string name="download_complete">Download compleet</string>
    <string name="download_started">Download is gestart</string>
    <string name="erase_all_data_warning_message">Deze update wist alle gegevens van je toestel.</string>
    <string name="erase_all_partitions_warning_message">Deze update wist alle gegevens van je toestel. Wil je doorgaan?</string>
    <string name="error_downloading">Fout tijdens het downloaden</string>
    <string name="fairphone_os">Android voor Fairphone</string>
    <string name="fairphone_update_message">Nieuwe Fairphone update beschikbaar</string>
    <string name="fairphone_update_message_title">Controleren op updates</string>
    <string name="go_ahead_and_install_it">Installeer</string>
    <string name="google_apps_disclaimer_agree">Accepteren</string>
    <string name="google_apps_disclaimer_description">Voor de volledige Android en Google mobile toepassingen, zoals de app store, heeft je telefoon extra inhoud en software nodig. Omdat Fairphone nog geen licentie heeft kunnen we die inhoud jammer genoeg niet van tevoren installeren en we kunnen het ook niet rechtstreeks ter beschikking stellen. We zijn hierover in overleg met de eigenaar van de inhoud.\nDruk op « Accepteren » hieronder om de inhoud te downloaden van een externe, veilige bron. Het installeren van deze inhoud is je eigen verantwoordelijkheid.\nAls je hier niet mee akkoord gaat, zal je telefoon natuurlijk nog werken met de basis apps voor Android, maar je zult een aantal diensten van Google niet kunnen gebruiken.</string>
    <string name="google_apps_disclaimer_title">Installeer Google Apps</string>
    <string name="google_apps_initial_title">Installeer\nGoogle Apps</string>
    <string name="google_apps_installer_name">Google Apps Installer</string>
    <string name="google_apps_re_install_description">Verwijder deze of klik\nom opnieuw te installeren</string>
    <string name="google_apps_re_install_title">Google Apps geïnstalleerd</string>
    <string name="important_notice">Belangrijke mededeling</string>
    <string name="important_notice_message">Het is belangrijk te realiseren dat het installeren van andere besturingssystemen de gebruikerservaring verandert.</string>
    <string name="install">Installeer</string>
    <string name="install_update">Installeer update</string>
    <string name="installed">Geïnstalleerd</string>
    <string name="invalid_md5_download_message">Ongeldig bestand gedownload: verkeerde MD5</string>
    <string name="invalid_signature_download_message">Ongeldig bestand gedownload: foutieve handtekening</string>
    <string name="latest_version">Laatste versie</string>
    <string name="new_os">Nieuw besturingssysteem</string>
    <string name="no_space_available_cache_message">Geen ruimte beschikbaar in /cache</string>
    <string name="no_space_available_sd_card_message">Geen ruimte beschikbaar op de SD kaart</string>
    <string name="older_version">Oudere versie</string>
    <string name="older_version_os_install_confirmation">Weet je zeker dat je wilt doorgaan?</string>
    <string name="older_version_os_install_confirmation_checkbox">Ik ken en begrijp alle implicaties van het uitvoeren van deze installatie</string>
    <string name="older_versions">Oudere versies</string>
    <string name="os_update_has_started_message">De update is gestart. Dit kan enige tijd duren, afhankelijk van de snelheid van je netwerkverbinding.</string>
    <string name="other_os_options">Open de geavanceerde modus</string>
    <string name="please_be_patient">Een ogenblik geduld&#8230;</string>
    <string name="restart">Herstart</string>
    <string name="restart_your_phone_message">Herstart je telefoon om de update te voltooien.</string>
    <string name="take_me_back">Breng me terug</string>
    <string name="update_is_available">Update beschikbaar</string>
    <string name="update_version">Update versie</string>
    <string name="want_to_change_your_os">Ben je een geavanceerde gebruiker?</string>
    <string name="warning">Waarschuwing</string>
    <string name="wifi_disabled">Wi-Fi niet beschikbaar</string>
    <string name="wifi_discaimer_message">Het bestand dat je probeert te downloaden is te groot voor mobiele verbindingen. Maak verbinding met een Wi-Fi netwerk en probeer het opnieuw.</string>
    <string name="your_are_about_to_install">Je staat op het punt te installeren</string>
    <string name="your_current_os_version">Je huidige versie van het besturingssysteem</string>
    <string name="your_os_is_up_to_date">Je besturingssysteem is up-to-date</string>
    <string name="fairphone_os_info">Dit Android voor Fairphone besturingssysteem heeft een extra laag van Fairphone zelf, met functies zoals de Geniet van de Rust widget, Edge Swipe en de Laatst gebruikte / Meest gebruikte Apps widget.\n\nWij raden aan Android for Fairphone op je apparaat te installeren voor de beste Fairphone beleving.</string>
    <string name="android_os_info">Dit Stock Android besturingssysteem is de pure Android ervaring zonder de extra Fairphone functies.</string>
    <string name="about">over</string>
    <string name="gapps_store_install">Installeer Google Apps</string>
    <string name="gapps_store_hide_reminder">of sluit deze melding</string>
    <string name="title_activity_beta_enabler">Fairphone Beta programma</string>
    <string name="enable_beta">Activeer Beta</string>
    <string name="beta_is_enabled">Beta is geactiveerd</string>
    <string name="beta_activation_failed">Fout tijdens Beta activering</string>
    <string name="failed_mkdirs_cache_message">Fout bij creëren folders in /cache</string>
    <string name="copy_to_cache_failed_message">Fout bij kopiëren bestand naar /cache</string>
    <string name="file_not_found_message">Bestand niet gevonden</string>
    <string name="reboot_failed">Fout bij herstarten van recovery</string>
    <string name="command_write_to_cache_failed">Fout bij wegschrijven commands naar /cache</string>
    <string name="wifi_discaimer_message_startup">Je dient verbonden te zijn met een Wi-Fi netwerk voor het controleren op updates en het installeren van software.</string>
    <string name="appStoreReinstall">Herinstalleer de app store</string>
    <string name="app_store">App Stores</string>
    <string name="got_it">Ik snap het</string>
    <string name="connect_to_wifi">Maak verbinding met een Wi-Fi netwerk</string>
    <string name="charge_battery">Zorg er voor dat je batterij minstens 80% opgeladen is</string>

</resources>