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

    <string name="app_name">Fairphone Updater</string>
    <string name="fairphone">Fairphone</string>
    <string name="supportAppStoreUrl">https://fairphone.zendesk.com/hc/en-us/articles/201882788-Hoe-herinstalleer-ik-de-App-Store-NL-</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_error_message">Fout tijdens downloaden configuratiebestand</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">Nieuwe Fairphone update</string>
    <string name="go_ahead_and_install_it">Installeer</string>
    <string name="google_apps_connection_description">Het bestand dat je probeert te downloaden is te groot voor mobiele verbindingen (~100MB). Breng de Wi-Fi verbinding tot stand en probeer het opnieuw.</string>
    <string name="google_apps_connection_title">Wi-Fi niet beschikbaar</string>
    <string name="google_apps_denied_permissions_description">Fairphone Updater heeft geen toestemming voor het installeren van Google Apps. Als je NEGEREN koos, start dan de installer opnieuw en selecteer geef TOESTEMMING en PERMANENT ONTHOUDEN.</string>
    <string name="google_apps_denied_permissions_title">Geen toestemming</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_download_error">Fout bij het downloaden van de bestanden. Probeer het opnieuw.</string>
    <string name="google_apps_download_title">Bezig met de download van Google Apps</string>
    <string name="google_apps_failed_download_description">De gedownloade bestanden zijn corrupt. Opnieuw proberen?</string>
    <string name="google_apps_failed_download_title">Downloaden mislukt</string>
    <string name="google_apps_initial_title">Installeer\nGoogle Apps</string>
    <string name="google_apps_install_title">Bezig met het installeren van Google Apps</string>
    <string name="google_apps_installer_name">Google Apps Installer</string>
    <string name="google_apps_permissions_description">Fairphone Updater vraagt nu om toegang als Superuser. We verzekeren je dat het helemaal veilig is. Kies TOESTAAN en PERMANENT ONTHOUDEN als daarom wordt gevraagd.</string>
    <string name="google_apps_permissions_title">Toegangsrechten tot het systeem</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="google_apps_reboot_description">Het systeem moet opnieuw worden gestart om de installatie af te ronden.\n\nVolg na het herstarten de stappen voor het opzetten van Google Apps.</string>
    <string name="google_apps_reboot_failed_description">Google Apps zijn geïnstalleerd. Herstart van het apparaat is niet gelukt. Herstart je apparaat handmatig a.u.b.</string>
    <string name="google_apps_reboot_failed_title">Herstarten mislukt</string>
    <string name="google_apps_reboot_title">Apparaat aan het herstarten</string>
    <string name="google_apps_reinstall_description">Om de app store op je telefoon opnieuw te installeren, druk op het startscherm en houd deze ingedrukt, selecteer de Widgets knop, zoek de Google Apps Installer widget en sleep de widget naar het startscherm en selecteer deze.</string>
    <string name="google_apps_reinstall_request_title">Herinnering</string>
    <string name="google_apps_uninstall_description">Deze Installer verwijderen</string>
    <string name="google_apps_uninstall_title">Google Apps geïnstalleerd</string>
    <string name="google_apps_unzip_title">Bezig met het uitpakken van Google Apps</string>
    <string name="google_apps_updater_installing_description">Fairphone Updater is je besturingssysteem aan het updaten op de achtergrond. Probeer het later opnieuw.</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="updater_google_apps_installing_description">Google Apps installatie vindt plaats op de achtergrond. Probeer het later opnieuw.</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 (~200MB). Breng de Wi-Fi verbinding tot stand 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>

</resources>