<?xml version="1.0" encoding="UTF-8"?>
<!--  Copyright (C) 2007 The Android Open Source Project

     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
     You may obtain a copy of the License at

          http://www.apache.org/licenses/LICENSE-2.0

     Unless required by applicable law or agreed to in writing, software
     distributed under the License is distributed on an "AS IS" BASIS,
     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     See the License for the specific language governing permissions and
     limitations under the License.
 -->

<resources xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
    <string name="yes" msgid="1999566976857398962">"Ja"</string>
    <string name="no" msgid="5541738710521607130">"Nee"</string>
    <string name="create" msgid="986997212165228751">"Aanmaken"</string>
    <string name="allow" msgid="3763244945363657722">"Toestaan"</string>
    <string name="deny" msgid="7326117222944479942">"Weigeren"</string>
    <string name="confirmation_turn_on" msgid="2979094011928347665">"Aanzetten"</string>
    <string name="device_info_default" msgid="1406619232867343310">"Onbekend"</string>
    <string name="device_info_protected_single_press" msgid="3810785480060743677">"Tik om informatie te tonen"</string>
    <string name="show_dev_countdown" msgid="2936506773086395069">"{count,plural, =1{Nog # stap en je bent ontwikkelaar.}other{Nog # stappen en je bent ontwikkelaar.}}"</string>
    <string name="show_dev_on" msgid="2840850085134853754">"Je bent nu ontwikkelaar!"</string>
    <string name="show_dev_already" msgid="7041756429707644630">"Niet nodig, je bent al ontwikkelaar."</string>
    <string name="dev_settings_disabled_warning" msgid="6971867026249671244">"Zet eerst de opties voor ontwikkelaars aan."</string>
    <string name="header_category_system" msgid="1665516346845259058">"Systeem"</string>
    <string name="radioInfo_service_in" msgid="9088637745836646271">"In gebruik"</string>
    <string name="radioInfo_service_out" msgid="1868347333892403287">"Niet in gebruik"</string>
    <string name="radioInfo_service_off" msgid="6184928420860868571">"Radio uit"</string>
    <string name="radioInfo_roaming_in" msgid="8892550453644088692">"Roaming"</string>
    <string name="radioInfo_roaming_not" msgid="3137594549464975054">"Geen roaming"</string>
    <string name="radioInfo_data_disconnected" msgid="362604130117666924">"Verbinding verbroken"</string>
    <string name="radioInfo_data_connecting" msgid="7280819598028917888">"Verbinding maken"</string>
    <string name="radioInfo_data_connected" msgid="8816467971633020141">"Verbonden"</string>
    <string name="radioInfo_data_suspended" msgid="2001254415431299603">"Opgeschort"</string>
    <string name="radioInfo_unknown" msgid="2892562356748600367">"Onbekend"</string>
    <string name="preview_pager_content_description" msgid="3762247188224576303">"Voorbeeld"</string>
    <string name="font_size_make_smaller_desc" msgid="4978038055549590140">"Verkleinen"</string>
    <string name="font_size_make_larger_desc" msgid="5583046033381722247">"Vergroten"</string>
    <string name="auto_rotate_settings_primary_switch_title" msgid="3440951924928594520">"Automatisch draaien gebruiken"</string>
    <string name="smart_rotate_text_headline" msgid="5878008933992951904">"Gezichtsherkenning gebruikt de camera aan de voorzijde om de nauwkeurigheid van automatisch draaien te verbeteren. Afbeeldingen worden nooit opgeslagen of naar Google gestuurd."</string>
    <string name="bluetooth" msgid="8898478620943459654">"Bluetooth"</string>
    <string name="bluetooth_is_discoverable" msgid="4798961627677790935">"Zichtbaar voor alle Bluetooth-apparaten in de buurt (<xliff:g id="DISCOVERABLE_TIME_PERIOD">%1$s</xliff:g>)"</string>
    <string name="bluetooth_is_discoverable_always" msgid="8122823110652921674">"Zichtbaar voor alle Bluetooth-apparaten in de buurt"</string>
    <string name="bluetooth_not_visible_to_other_devices" msgid="6181960579190879601">"Niet zichtbaar voor andere Bluetooth-apparaten"</string>
    <string name="bluetooth_only_visible_to_paired_devices" msgid="3574936359739213455">"Alleen zichtbaar voor gekoppelde apparaten"</string>
    <string name="bluetooth_devices" msgid="1063177983261608277">"Bluetooth-apparaten"</string>
    <string name="bluetooth_device_name" msgid="1294669733490268384">"Apparaatnaam"</string>
    <string name="bluetooth_rename_device" msgid="4219655243836021443">"De naam van dit apparaat wijzigen"</string>
    <string name="bluetooth_rename_button" msgid="9162500408570289545">"Naam wijzigen"</string>
    <string name="bluetooth_disconnect_title" msgid="4581951246357823044">"Apparaat loskoppelen?"</string>
    <string name="bluetooth_pairing_pref_title" msgid="3497193027590444598">"Apparaat koppelen"</string>
    <string name="keywords_add_bt_device" msgid="4533191164203174011">"bluetooth"</string>
    <string name="bluetooth_pair_right_ear_button" msgid="3979894494803078852">"Rechteroor koppelen"</string>
    <string name="bluetooth_pair_left_ear_button" msgid="1019938875726073791">"Linkeroor koppelen"</string>
    <string name="bluetooth_pair_other_ear_dialog_title" msgid="3814943511999984012">"Je andere oor koppelen"</string>
    <string name="bluetooth_pair_other_ear_dialog_left_ear_message" msgid="5711642363615781647">"Je linkerhoortoestel is verbonden.\n\nAls je het rechterhoortoestel wilt koppelen, zorg dan dat dit aanstaat en klaar is voor koppelen."</string>
    <string name="bluetooth_pair_other_ear_dialog_right_ear_message" msgid="631521133525979967">"Je rechterhoortoestel is verbonden.\n\nAls je het linkerhoortoestel wilt koppelen, zorg dan dat dit aanstaat en klaar is voor koppelen."</string>
    <string name="bluetooth_pair_other_ear_dialog_right_ear_positive_button" msgid="533612082529204078">"Rechteroor koppelen"</string>
    <string name="bluetooth_pair_other_ear_dialog_left_ear_positive_button" msgid="6500192653171220257">"Linkeroor koppelen"</string>
    <string name="bluetooth_device_controls_general" msgid="1399214835599665488">"Voor alle beschikbare hoortoestellen"</string>
    <string name="bluetooth_device_controls_title" msgid="1895676556354697234">"Instellingen hoortoestel"</string>
    <string name="bluetooth_device_controls_summary" msgid="949566933352398337">"Audio-uitvoer, sneltoets, geschikt voor hoortoestel"</string>
    <string name="bluetooth_device_controls_specific" msgid="7706863288754077107">"Voor dit apparaat"</string>
    <string name="bluetooth_audio_routing_title" msgid="5541729245424856226">"Audio-uitgang"</string>
    <string name="bluetooth_audio_routing_about_title" msgid="5773336779246891954">"Over audio-uitvoer"</string>
    <string name="bluetooth_audio_routing_summary" msgid="7180947533985969066">"Leid geluiden naar je hoortoestel of telefoonspeaker"</string>
    <string name="bluetooth_screen_related" msgid="7976543255501825536">"Gerelateerd"</string>
    <string name="bluetooth_ringtone_title" msgid="3177308461256892085">"Ringtone en wekkers"</string>
    <string name="bluetooth_call_title" msgid="6851464952021874072">"Audio tijdens gesprekken"</string>
    <string name="bluetooth_media_title" msgid="343705257183053699">"Media"</string>
    <string name="bluetooth_system_sounds_title" msgid="6746938637128763205">"Meldingen en andere systeemgeluiden"</string>
    <string name="bluetooth_audio_routing_footer_summary" msgid="410260713589309293">"Standaard wordt audio-uitvoer bepaald door afzonderlijke apps"</string>
    <string name="bluetooth_device" msgid="2217973503732544291">"Naamloos Bluetooth-apparaat"</string>
    <string name="progress_scanning" msgid="2564746192843011826">"Zoeken"</string>
    <string name="bluetooth_no_devices_found" msgid="7704539337219953182">"Geen Bluetooth-apparaten in de buurt."</string>
    <string name="bluetooth_notif_ticker" msgid="209515545257862858">"Bluetooth-koppelingsverzoek"</string>
    <string name="bluetooth_notif_title" msgid="1196532269131348647">"Koppelingsverzoek"</string>
    <string name="bluetooth_notif_message" msgid="5584717784198086653">"Tik om te koppelen met <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="bluetooth_devices_card_off_title" msgid="1320149821945129127">"Bluetooth staat uit"</string>
    <string name="bluetooth_devices_card_off_summary" msgid="2276527382891105858">"Tik om aan te zetten"</string>
    <string name="device_picker" msgid="2427027896389445414">"Bluetooth-apparaat kiezen"</string>
    <string name="bluetooth_ask_enablement" msgid="1529030199895339199">"<xliff:g id="APP_NAME">%1$s</xliff:g> wil bluetooth aanzetten"</string>
    <string name="bluetooth_ask_disablement" msgid="1879788777942714761">"<xliff:g id="APP_NAME">%1$s</xliff:g> wil Bluetooth uitzetten"</string>
    <string name="bluetooth_ask_enablement_no_name" msgid="5091401961637405417">"Een app wil Bluetooth aanzetten"</string>
    <string name="bluetooth_ask_disablement_no_name" msgid="382299750909188822">"Een app wil Bluetooth uitzetten"</string>
    <string name="bluetooth_turning_on" msgid="3842613808709024730">"Bluetooth aanzetten…"</string>
    <string name="bluetooth_turning_off" msgid="7406309124247701148">"Bluetooth uitzetten…"</string>
    <string name="bluetooth_connection_permission_request" msgid="8793131019383198861">"Bluetooth-verbindingsverzoek"</string>
    <string name="bluetooth_phonebook_request" msgid="1085102844577089889">"Toegangsverzoek voor telefoonboek"</string>
    <string name="bluetooth_map_request" msgid="8664081227240707479">"Toegangsverzoek voor berichten"</string>
    <string name="bluetooth_device_name_summary" msgid="8678342689845439583">"Zichtbaar als <xliff:g id="DEVICE_NAME">^1</xliff:g> voor andere apparaten"</string>
    <string name="bluetooth_off_footer" msgid="76578735660216295">"Zet bluetooth aan om verbinding met andere apparaten te maken."</string>
    <string name="bluetooth_paired_device_title" msgid="3240639218362342026">"Je apparaten"</string>
    <string name="bluetooth_pairing_page_title" msgid="3403981358823707692">"Nieuw apparaat koppelen"</string>
    <string name="bluetooth_disable_a2dp_hw_offload" msgid="5942913792817797541">"Bluetooth A2DP-hardware-offload uitzetten"</string>
    <string name="bluetooth_disable_le_audio_hw_offload" msgid="4656853795514691257">"Bluetooth LE Audio-hardware-offload uitzetten"</string>
    <string name="bluetooth_disable_hw_offload_dialog_title" msgid="6001142380445276918">"Apparaat opnieuw opstarten?"</string>
    <string name="bluetooth_disable_hw_offload_dialog_message" msgid="1524373895333698779">"Start het apparaat opnieuw op om de instelling te wijzigen."</string>
    <string name="bluetooth_disable_hw_offload_dialog_confirm" msgid="5594859658551707592">"Opnieuw opstarten"</string>
    <string name="bluetooth_disable_hw_offload_dialog_cancel" msgid="3663690305043973720">"Annuleren"</string>
    <string name="bluetooth_disable_leaudio" msgid="8619410595945155354">"Bluetooth LE Audio uitzetten"</string>
    <string name="bluetooth_disable_leaudio_summary" msgid="4756307633476985470">"Hiermee zet je de functie voor Bluetooth LE Audio uit als het apparaat hardwaremogelijkheden voor LE Audio ondersteunt."</string>
    <string name="bluetooth_show_leaudio_device_details" msgid="3306637862550475370">"Schakelaar voor LE Audio tonen in Apparaatgegevens"</string>
    <string name="bluetooth_enable_leaudio_allow_list" msgid="1692999156437357534">"Toelatingslijst voor Bluetooth LE Audio aanzetten"</string>
    <string name="bluetooth_enable_leaudio_allow_list_summary" msgid="725601205276008525">"Functie voor toelatingslijst voor Bluetooth LE Audio aanzetten."</string>
    <string name="connected_device_media_device_title" msgid="3783388247594566734">"Media-apparaten"</string>
    <string name="connected_device_call_device_title" msgid="88732390601723608">"Apparaten voor gesprekken"</string>
    <string name="connected_device_other_device_title" msgid="4652120430615729193">"Andere apparaten"</string>
    <string name="connected_device_saved_title" msgid="5607274378851905959">"Opgeslagen apparaten"</string>
    <string name="connected_device_add_device_summary" msgid="8671009879957120802">"Bluetooth wordt aangezet om te koppelen"</string>
    <string name="connected_device_connections_title" msgid="4164120115341579170">"Verbindings­voorkeuren"</string>
    <string name="connected_device_previously_connected_screen_title" msgid="8823331744788100605">"Eerder verbonden"</string>
    <string name="connected_device_bluetooth_turned_on_toast" msgid="144664089794199928">"Bluetooth staat aan"</string>
    <string name="previous_connected_see_all" msgid="7759413145713251328">"Alles tonen"</string>
    <string name="stylus_device_details_title" msgid="7618295136015480864">"Stylus"</string>
    <string name="stylus_default_notes_app" msgid="4165657465911764628">"Knop bovenop indrukken"</string>
    <string name="stylus_default_notes_summary_work" msgid="4554643411627934223">"<xliff:g id="APP_NAME">%s</xliff:g> (werkprofiel)"</string>
    <string name="stylus_textfield_handwriting" msgid="2363579035338976327">"Schrijven in tekstvelden"</string>
    <string name="stylus_ignore_button" msgid="7734540973145241391">"Alle drukken op knoppen met stylus negeren"</string>
    <string name="stylus_connected_devices_title" msgid="2823967577941359812">"Stylus"</string>
    <string name="date_and_time" msgid="1788358029823431692">"Datum en tijd"</string>
    <string name="proxy_settings_title" msgid="4201866858226087066">"Proxy"</string>
    <string name="proxy_clear_text" msgid="6529658759984031149">"Wissen"</string>
    <string name="proxy_port_label" msgid="4647357286461712574">"Proxy-poort"</string>
    <string name="proxy_exclusionlist_label" msgid="2598613986784917542">"Proxy omzeilen voor"</string>
    <string name="proxy_defaultView_text" msgid="6795150505379688451">"Standaardwaarden herstellen"</string>
    <string name="proxy_action_text" msgid="1103328484441449542">"Klaar"</string>
    <string name="proxy_hostname_label" msgid="5504327742505848063">"Hostnaam van proxy"</string>
    <string name="proxy_error" msgid="3615905975598084126">"Let op"</string>
    <string name="proxy_error_dismiss" msgid="4207430265140873078">"OK"</string>
    <string name="proxy_error_invalid_host" msgid="3814412792702059247">"De hostnaam die je hebt ingevoerd, is ongeldig."</string>
    <string name="proxy_error_invalid_exclusion_list" msgid="6096353559936226599">"De getypte uitsluitingslijst is niet correct opgemaakt. Geef een door komma\'s gescheiden lijst van uitgesloten domeinen op."</string>
    <string name="proxy_error_empty_port" msgid="4250295137005082992">"Je moet het veld voor de poort invullen."</string>
    <string name="proxy_error_empty_host_set_port" msgid="8886572276450900049">"Het poortveld moet leeg zijn als het hostveld leeg is."</string>
    <string name="proxy_error_invalid_port" msgid="2830054691770209166">"De poort die je hebt ingevoerd, is ongeldig."</string>
    <string name="proxy_warning_limited_support" msgid="3277104160797351942">"De HTTP-proxy wordt gebruikt door de browser, maar mogelijk niet door de andere apps."</string>
    <string name="proxy_url_title" msgid="3502625766036404073">"PAC-URL: "</string>
    <string name="radio_info_ping_hostname_v4" msgid="4790577760885127088">"IPv4 van hostnaam (www.google.com) pingen:"</string>
    <string name="radio_info_http_client_test" msgid="5673975677271544085">"HTTP-client testen:"</string>
    <string name="ping_test_label" msgid="265427033290391845">"Pingtest uitvoeren"</string>
    <string name="skip_label" msgid="6380034601349015895">"Overslaan"</string>
    <string name="next_label" msgid="1248293387735652187">"Volgende"</string>
    <string name="language_picker_title" msgid="4271307478263345133">"Talen"</string>
    <string name="language_picker_category_title" msgid="1792199453060454565">"Volgorde van voorkeurstalen"</string>
    <string name="desc_current_default_language" msgid="1901157141663662859">"Systeemtaal"</string>
    <string name="locale_remove_menu" msgid="3521546263421387474">"Verwijderen"</string>
    <string name="add_a_language" msgid="2126220398077503271">"Taal toevoegen"</string>
    <string name="app_locale_preference_title" msgid="5513627099300360232">"Taal"</string>
    <string name="locale_picker_category_title" msgid="6212064706962721255">"Taalvoorkeur"</string>
    <string name="app_locales_picker_menu_title" msgid="7617427959223831373">"App-talen"</string>
    <string name="app_locale_picker_summary" msgid="6742557329924446252">"De taal instellen voor elke app"</string>
    <string name="app_locale_picker_title" msgid="2431448962911301366">"App-taal"</string>
    <string name="suggested_app_locales_title" msgid="8898358282377369405">"Voorgestelde talen"</string>
    <string name="all_supported_app_locales_title" msgid="5479289964316009026">"Alle talen"</string>
    <string name="preference_of_system_locale_title" msgid="8067226276038751504">"Systeemtaal"</string>
    <string name="preference_of_system_locale_summary" msgid="5612241394431188535">"Systeemstandaard"</string>
    <string name="desc_no_available_supported_locale" msgid="7883271726226947273">"Taalselectie voor deze app is niet beschikbaar via Instellingen."</string>
    <string name="desc_app_locale_disclaimer" msgid="5295933110644789052">"De taal kan verschillen van de beschikbare talen in de app. Sommige apps ondersteunen deze instelling mogelijk niet."</string>
    <string name="desc_app_locale_selection_supported" msgid="6744909281573556379">"Stel de taal in voor elke app."</string>
    <string name="desc_introduction_of_language_picker" msgid="1038423471887102449">"Je systeem, apps en websites gebruiken de eerste ondersteunde taal uit je voorkeurstalen."</string>
    <string name="desc_notice_of_language_picker" msgid="3449290526457925447">"Ga naar de taalinstellingen van een app als je een taal voor elke app wilt selecteren."</string>
    <string name="desc_locale_helper_footer_general" msgid="6112153921151780303">"Meer informatie over app-talen"</string>
    <string name="title_change_system_locale" msgid="8589844586256566951">"Systeemtaal wijzigen in %s?"</string>
    <string name="title_system_locale_addition" msgid="8218683660751479466">"%s toevoegen aan voorkeurstalen?"</string>
    <string name="desc_system_locale_addition" msgid="3409917362651596070">"Zo laat je apps en websites ook weten dat je de voorkeur geeft aan deze taal."</string>
    <string name="desc_notice_device_locale_settings_change" msgid="8311132485850714160">"Je apparaatinstellingen en regionale voorkeuren worden gewijzigd."</string>
    <string name="button_label_confirmation_of_system_locale_change" msgid="5593798559604894733">"Wijzigen"</string>
    <string name="title_unavailable_locale" msgid="2628898110416542386">"%s niet beschikbaar"</string>
    <string name="desc_unavailable_locale" msgid="2201756477400935896">"Deze taal kan niet worden gebruikt als systeemtaal, maar je hebt apps en websites laten weten dat je de voorkeur geeft aan deze taal."</string>
    <string name="regional_preferences_title" msgid="4304567374498629528">"Regionale voorkeuren"</string>
    <string name="regional_preferences_summary" msgid="1189876997389469650">"Voorkeuren voor eenheden en cijfers instellen"</string>
    <string name="regional_preferences_main_page_sub_title" msgid="4237109940015254725">"Stel je regionale voorkeuren in voor apps, zodat ze de functionaliteit kunnen personaliseren."</string>
    <string name="regional_preferences_option_page_sub_title" msgid="8303661099255197036">"Apps gebruiken waar mogelijk je regionale voorkeuren."</string>
    <string name="temperature_preferences_title" msgid="5009881556503629058">"Temperatuur"</string>
    <string name="first_day_of_week_preferences_title" msgid="1971850087589599553">"Eerste dag van de week"</string>
    <string name="numbers_preferences_title" msgid="8197418984391195446">"Cijfervoorkeuren"</string>
    <string name="default_string_of_regional_preference" msgid="7662581547334113719">"App-standaard gebruiken"</string>
    <string name="celsius_temperature_unit" msgid="8896459071273084507">"Celsius (°C)"</string>
    <string name="fahrenheit_temperature_unit" msgid="1118677820614569801">"Fahrenheit (°F)"</string>
    <string name="sunday_first_day_of_week" msgid="7644548348295686051">"zondag"</string>
    <string name="monday_first_day_of_week" msgid="7244698610476506771">"maandag"</string>
    <string name="tuesday_first_day_of_week" msgid="5085370946936582391">"dinsdag"</string>
    <string name="wednesday_first_day_of_week" msgid="6544537589727042869">"woensdag"</string>
    <string name="thursday_first_day_of_week" msgid="3035885630945594833">"donderdag"</string>
    <string name="friday_first_day_of_week" msgid="7074795061812083541">"vrijdag"</string>
    <string name="saturday_first_day_of_week" msgid="3702282590450322727">"zaterdag"</string>
    <string name="title_regional_pref_footer" msgid="7450438024324794380">"Als een app geen regionale voorkeuren ondersteunt, worden de standaard landinstellingen van de app gebruikt."</string>
    <string name="desc_regional_pref_footer_learn_more" msgid="4401708653329230081">"Meer informatie over taalvoorkeuren"</string>
    <string name="dlg_remove_locales_title" msgid="3170501604483612114">"{count,plural, =1{Geselecteerde taal verwijderen?}other{Geselecteerde talen verwijderen?}}"</string>
    <string name="dlg_remove_locales_message" msgid="8110560091134252067">"Tekst wordt getoond in een andere taal."</string>
    <string name="dlg_remove_locales_error_title" msgid="5875503658221562572">"Kan niet alle talen verwijderen"</string>
    <string name="dlg_remove_locales_error_message" msgid="6504279959974675302">"Behoud minimaal één voorkeurstaal"</string>
    <string name="locale_not_translated" msgid="3071618135527110152">"Niet beschikbaar als systeemtaal"</string>
    <string name="action_drag_label_move_up" msgid="3392196942330705015">"Omhoog"</string>
    <string name="action_drag_label_move_down" msgid="9069518740553953426">"Omlaag"</string>
    <string name="action_drag_label_move_top" msgid="2430471023612171619">"Bovenaan zetten"</string>
    <string name="action_drag_label_move_bottom" msgid="6266165197792827003">"Onderaan zetten"</string>
    <string name="action_drag_label_remove" msgid="1034900377796780568">"Taal verwijderen"</string>
    <string name="activity_picker_label" msgid="351250401590691126">"Een activiteit kiezen"</string>
    <string name="cancel" msgid="5780102414089664898">"Annuleren"</string>
    <string name="okay" msgid="4827099303045669054">"OK"</string>
    <string name="forget" msgid="3754013654135912783">"Vergeten"</string>
    <string name="save" msgid="3125033126936493822">"Opslaan"</string>
    <string name="done" msgid="7497982645646431310">"Klaar"</string>
    <string name="apply" msgid="7834684883190163536">"Toepassen"</string>
    <string name="share" msgid="8502235338607613795">"Delen"</string>
    <string name="add" msgid="8335206931421683426">"Toevoegen"</string>
    <string name="remove" msgid="1028414219245072102">"Verwijderen"</string>
    <string name="settings_label" msgid="943294133671632976">"Instellingen"</string>
    <string name="settings_label_launcher" msgid="820982375501978609">"Instellingen"</string>
    <string name="settings_shortcut" msgid="8548239727871847171">"Snelle link voor instellingen"</string>
    <string name="airplane_mode" msgid="3196085857882526817">"Vliegtuigmodus"</string>
    <string name="wireless_networks_settings_title" msgid="8557542379234105369">"Draadloos en netwerken"</string>
    <string name="roaming" msgid="3055365654530847985">"Roaming"</string>
    <string name="roaming_enable" msgid="7845716016861535340">"Maak verbinding met dataservices tijdens roaming"</string>
    <string name="roaming_disable" msgid="729512894708689604">"Maak verbinding met dataservices tijdens roaming"</string>
    <string name="roaming_warning" msgid="7703647889040229013">"Voor roaming kunnen kosten in rekening worden gebracht."</string>
    <string name="date_time_auto" msgid="4239202185055225869">"Tijd automatisch instellen"</string>
    <string name="zone_auto_title" msgid="5141692422373097957">"Automatisch instellen"</string>
    <string name="auto_zone_requires_location_summary" msgid="4831038184260596735">"De locatie wordt gebruikt om de tijdzone in te stellen als deze schakelaar aanstaat"</string>
    <string name="date_time_24hour_auto" msgid="6583078135067804252">"Standaardinstelling voor land gebruiken"</string>
    <string name="date_time_24hour" msgid="286679379105653406">"24-uurs klok gebruiken"</string>
    <string name="date_time_set_time_title" msgid="2870083415922991906">"Tijd"</string>
    <string name="time_format_category_title" msgid="7108616745509689991">"Tijdnotatie"</string>
    <string name="date_time_set_timezone_title" msgid="790404320569600222">"Tijdzone"</string>
    <string name="date_time_set_timezone" msgid="2915125337941495746">"Tijdzone selecteren"</string>
    <string name="date_time_set_date_title" msgid="7624166157167528407">"Datum"</string>
    <string name="date_time_search_region" msgid="1364133854952610919">"Zoek een regio"</string>
    <string name="date_time_select_region" msgid="5449345333305056072">"Regio"</string>
    <string name="date_time_select_fixed_offset_time_zones" msgid="594848300882055361">"Verschil met UTC selecteren"</string>
    <string name="zone_info_exemplar_location_and_offset" msgid="2186042522225153092">"<xliff:g id="EXEMPLAR_LOCATION">%1$s</xliff:g> (<xliff:g id="OFFSET">%2$s</xliff:g>)"</string>
    <string name="zone_info_offset_and_name" msgid="3960192548990990152">"<xliff:g id="TIME_TYPE">%2$s</xliff:g> (<xliff:g id="OFFSET">%1$s</xliff:g>)"</string>
    <string name="zone_info_footer_first_sentence" msgid="1326664252091302458">"Gebruikt <xliff:g id="OFFSET_AND_NAME">%1$s</xliff:g>. <xliff:g id="SECOND_SENTENCE">%2$s</xliff:g>"</string>
    <string name="zone_info_footer_second_sentence" msgid="6472889173541729110">"<xliff:g id="DST_TIME_TYPE">%1$s</xliff:g> begint op <xliff:g id="TRANSITION_DATE">%2$s</xliff:g>."</string>
    <string name="zone_info_footer_no_dst" msgid="8399585343328811158">"Gebruikt <xliff:g id="OFFSET_AND_NAME">%1$s</xliff:g>. Geen zomertijd."</string>
    <string name="zone_time_type_dst" msgid="9189689342265305808">"Zomertijd"</string>
    <string name="zone_time_type_standard" msgid="6865420715430680352">"Standaardtijd"</string>
    <string name="zone_menu_by_region" msgid="2963565278710225652">"Selecteren op basis van regio"</string>
    <string name="zone_menu_by_offset" msgid="1257702747474426745">"Selecteren op basis van UTC-verschil"</string>
    <string name="lock_after_timeout" msgid="8682769000437403444">"Vergrendelen na time-out scherm"</string>
    <string name="lock_after_timeout_summary" msgid="4869265514658147304">"<xliff:g id="TIMEOUT_STRING">%1$s</xliff:g> na time-out"</string>
    <string name="lock_immediately_summary_with_exception" msgid="40819611828339044">"Onmiddellijk na time-out, behalve wanneer ontgrendeld gehouden door <xliff:g id="TRUST_AGENT_NAME">%1$s</xliff:g>"</string>
    <string name="lock_after_timeout_summary_with_exception" msgid="3441806647509073124">"<xliff:g id="TIMEOUT_STRING">%1$s</xliff:g> na time-out, behalve wanneer ontgrendeld gehouden door <xliff:g id="TRUST_AGENT_NAME">%2$s</xliff:g>"</string>
    <string name="owner_info_settings_title" msgid="3555626140700093017">"Tekst toevoegen op vergrendelscherm"</string>
    <string name="owner_info_settings_summary" msgid="347238313388083297">"Geen"</string>
    <string name="owner_info_settings_edit_text_hint" msgid="841926875876050274">"Bijvoorbeeld \'Android van Jan\'."</string>
    <string name="location_settings_title" msgid="8375074508036087178">"Locatie"</string>
    <string name="location_settings_primary_switch_title" msgid="8849081766644685127">"Locatie gebruiken"</string>
    <string name="location_settings_summary_location_off" msgid="4797932754681162262">"Uit"</string>
    <string name="location_settings_summary_location_on" msgid="7029728269719893381">"{count,plural, =1{Aan: # app heeft toegang tot de locatie}other{Aan: # apps hebben toegang tot de locatie}}"</string>
    <string name="location_settings_loading_app_permission_stats" msgid="6054103701535557342">"Laden…"</string>
    <string name="location_settings_footer_general" msgid="1040507068701188821">"Apps met rechten voor apparaten in de buurt kunnen ongeveer inschatten waar verbonden apparaten zijn."</string>
    <string name="location_settings_footer_location_off" msgid="8568995909147566720">"Toegang tot de locatie staat uit voor apps en services. De locatie van je apparaat kan nog steeds worden verstuurd naar nooddiensten als je een alarmnummer belt of sms\'t."</string>
    <string name="location_settings_footer_learn_more_content_description" msgid="5329024810729665156">"Meer informatie over locatie-instellingen"</string>
    <string name="account_settings_title" msgid="9138880127246241885">"Accounts"</string>
    <string name="security_settings_title" msgid="6710768415432791970">"Beveiliging"</string>
    <string name="encryption_and_credential_settings_title" msgid="5856216318961482983">"Versleuteling en inloggegevens"</string>
    <string name="lockscreen_settings_title" msgid="4086121748092341549">"Vergrendelscherm"</string>
    <string name="lockscreen_settings_what_to_show_category" msgid="9205490627927741254">"Wat wordt getoond"</string>
    <string name="disabled_by_administrator_summary" msgid="5424846182313851124">"Niet beschikbaar"</string>
    <string name="security_status_title" msgid="6958004275337618656">"Beveiligingsstatus"</string>
    <string name="security_dashboard_summary" msgid="7571035662779425918">"Schermvergrendeling, Vind mijn apparaat, app-beveiliging"</string>
    <string name="safety_center_title" msgid="7732397372178774777">"Beveiliging en privacy"</string>
    <string name="safety_center_summary" msgid="3554867379951053869">"App-beveiliging, apparaatvergrendeling, rechten"</string>
    <string name="security_settings_face_preference_summary" msgid="6675126437396914838">"Gezicht toegevoegd"</string>
    <string name="security_settings_face_preference_summary_none" msgid="523320857738436024">"Instellen nodig"</string>
    <string name="security_settings_face_preference_title" msgid="2126625155005348417">"Ontgrendelen via gezichtsherkenning"</string>
    <string name="security_settings_face_profile_preference_title" msgid="7519527436266375005">"Ontgrendelen via gezichtsherkenning voor werk"</string>
    <string name="security_settings_face_enroll_education_title" msgid="6448806884597691208">"Ontgrendelen via gezichtsherkenning instellen"</string>
    <string name="security_settings_face_enroll_education_title_accessibility" msgid="3701874093226957891">"Ontgrendelen via gezichtsherkenning instellen"</string>
    <string name="security_settings_face_enroll_education_title_unlock_disabled" msgid="8810954233979716906">"Gebruik je gezicht voor verificatie"</string>
    <string name="security_settings_face_enroll_education_message" msgid="4308030157487176799"></string>
    <string name="security_settings_face_enroll_education_start" msgid="8830924400907195590">"Starten"</string>
    <string name="security_settings_face_enroll_education_accessibility_dialog_message" msgid="2965952386172202665">"Als de toegankelijkheidsfunctie Ontgrendelen via gezichtsherkenning uitstaat, werken sommige installatiestappen misschien niet goed met TalkBack."</string>
    <string name="security_settings_face_enroll_education_accessibility_dialog_negative" msgid="7872647360361245461">"Terug"</string>
    <string name="security_settings_face_enroll_education_accessibility_dialog_positive" msgid="3148077647572203458">"Doorgaan met instellen"</string>
    <string name="security_settings_face_enroll_introduction_accessibility" msgid="5748221179069430975">"Toegankelijkheidsinst. gebruiken"</string>
    <string name="security_settings_face_enroll_introduction_accessibility_diversity" msgid="2774962371839179206"></string>
    <string name="security_settings_face_enroll_introduction_accessibility_vision" msgid="7700394302162170363"></string>
    <string name="security_settings_face_enroll_introduction_cancel" msgid="7551159644361639436">"Annuleren"</string>
    <string name="security_settings_face_enroll_introduction_no_thanks" msgid="1820618982738898717">"Nee, bedankt"</string>
    <string name="security_settings_face_enroll_introduction_agree" msgid="6319476573697497750">"Ik ga akkoord"</string>
    <string name="security_settings_face_enroll_introduction_more" msgid="1970820298889710532">"Meer"</string>
    <string name="security_settings_face_enroll_introduction_title" msgid="7061610077237098046">"Ontgrendelen met je gezicht"</string>
    <string name="security_settings_face_enroll_consent_introduction_title" msgid="3942331854413767814">"Ontgrendelen via gezichtsherkenning toestaan"</string>
    <string name="security_settings_face_enroll_introduction_title_unlock_disabled" msgid="5903924766168353113">"Gebruik je gezicht voor verificatie"</string>
    <string name="security_settings_face_enroll_introduction_message_unlock_disabled" msgid="5841976283789481311">"Gebruik je gezicht om je telefoon te ontgrendelen of aankopen goed te keuren.\n\nOpmerking: Je kunt je gezicht niet gebruiken om dit apparaat te ontgrendelen. Neem contact op met de beheerder van je organisatie voor meer informatie."</string>
    <string name="security_settings_face_enroll_introduction_message_setup" msgid="765965418187421753">"Gebruik je gezicht om je telefoon te ontgrendelen, aankopen te autoriseren of in te loggen bij apps"</string>
    <string name="security_settings_face_enroll_introduction_info_title" msgid="7120796118179406944"></string>
    <string name="security_settings_face_enroll_introduction_info_glasses" msgid="2733870453868907471"></string>
    <string name="security_settings_face_enroll_introduction_info_consent_glasses" msgid="6303917184145586880"></string>
    <string name="security_settings_face_enroll_introduction_how_title" msgid="3680193263037835600"></string>
    <string name="security_settings_face_enroll_introduction_control_title" msgid="4536951089583821051"></string>
    <string name="security_settings_face_enroll_introduction_control_consent_title" msgid="5892729331412694759"></string>
    <string name="security_settings_face_enroll_repeat_title" msgid="4446229670377418717">"Centreer je gezicht in de cirkel"</string>
    <string name="security_settings_face_enroll_enrolling_skip" msgid="5568617401632528567">"Overslaan"</string>
    <string name="face_intro_error_max" msgid="2474735057709291626">"Je hebt het maximum aantal gezichten toegevoegd"</string>
    <string name="face_intro_error_unknown" msgid="1626057493054989995">"Kan geen extra gezichten toevoegen"</string>
    <string name="security_settings_face_enroll_error_dialog_title" msgid="2460820099922775936">"Registratie is niet voltooid"</string>
    <string name="security_settings_face_enroll_dialog_ok" msgid="1674650455786434426">"OK"</string>
    <string name="security_settings_face_enroll_error_timeout_dialog_message" msgid="7768349698547951750">"Tijdlimiet voor gezichtsregistratie is bereikt. Probeer het opnieuw."</string>
    <string name="security_settings_face_enroll_error_generic_dialog_message" msgid="3186810411630091490">"Gezichtsregistratie is mislukt"</string>
    <string name="security_settings_face_enroll_finish_title" msgid="5882322568359775393">"Alles is ingesteld."</string>
    <string name="security_settings_face_enroll_done" msgid="3048687969498187442">"Klaar"</string>
    <string name="security_settings_face_enroll_should_re_enroll_title" msgid="6835778900387289683">"Ontgrendelen via gezichtsherkenning verbeteren"</string>
    <string name="security_settings_face_enroll_should_re_enroll_subtitle" msgid="7055780282999744813">"Ontgrendelen via gezicht weer instellen"</string>
    <string name="security_settings_face_enroll_must_re_enroll_title" msgid="4421818770682557621">"Ontgrendelen via gezichtsherkenning weer instellen"</string>
    <string name="security_settings_face_enroll_must_re_enroll_subtitle" msgid="3584740139535177961">"Beveiliging en prestaties verbeteren"</string>
    <string name="security_settings_face_enroll_improve_face_alert_title" msgid="6194184776580066012">"Ontgrendelen via gezichtsherkenning instellen"</string>
    <string name="security_settings_face_enroll_improve_face_alert_body" msgid="2670118180411127323">"Verwijder je huidige gezichtsmodel om Ontgrendelen via gezichtsherkenning weer in te stellen.\n\nJe gezichtsmodel wordt definitief en veilig verwijderd.\n\nNa verwijdering heb je je pincode, patroon of wachtwoord nodig om je telefoon te ontgrendelen of voor verificatie in apps."</string>
    <string name="security_settings_face_enroll_improve_face_alert_body_fingerprint" msgid="2469599074650327489">"Verwijder je huidige gezichtsmodel om Ontgrendelen via gezichtsherkenning weer in te stellen.\n\nJe gezichtsmodel wordt definitief en veilig verwijderd.\n\nNa verwijdering heb je je vingerafdruk, pincode, patroon of wachtwoord nodig om je telefoon te ontgrendelen of voor verificatie in apps."</string>
    <string name="security_settings_face_settings_use_face_category" msgid="1638314154119800188">"Ontgrendelen via gezicht gebruiken voor"</string>
    <string name="security_settings_face_settings_preferences_category" msgid="7628929873407280453">"Als je ontgrendelt via gezichtsherkenning"</string>
    <string name="security_settings_face_settings_require_attention" msgid="4395309855914391104">"Vereisen dat ogen open zijn"</string>
    <string name="security_settings_face_settings_require_attention_details" msgid="2546230511769544074">"Je ogen moeten open zijn om de telefoon te ontgrendelen"</string>
    <string name="security_settings_face_settings_require_confirmation" msgid="6603039421004198334">"Altijd bevestiging vereist"</string>
    <string name="security_settings_face_settings_require_confirmation_details" msgid="3498729789625461914">"Vereis altijd bevestiging bij Ontgrendelen via gezichtsherkenning"</string>
    <string name="security_settings_face_settings_remove_face_model" msgid="812920481303980846">"Gezichtsmodel verwijderen"</string>
    <string name="security_settings_face_settings_enroll" msgid="3726313826693825029">"Ontgrendelen via gezichtsherkenning instellen"</string>
    <string name="security_settings_face_settings_remove_dialog_title" msgid="2899669764446232715">"Gezichtsmodel verwijderen?"</string>
    <string name="security_settings_face_settings_remove_dialog_details" msgid="916131485988121592">"Je gezichtsmodel wordt definitief en op een beveiligde manier verwijderd.\n\nDaarna heb je je pincode, patroon of wachtwoord nodig om je telefoon te ontgrendelen of voor verificatie in apps."</string>
    <string name="security_settings_face_settings_remove_dialog_details_convenience" msgid="475568135197468990">"Je gezichtsmodel wordt definitief en op een beveiligde manier verwijderd.\n\nDaarna heb je je pincode, patroon of wachtwoord nodig om je telefoon te ontgrendelen."</string>
    <string name="security_settings_face_settings_context_subtitle" msgid="8284262560781442403">"Ontgrendel je telefoon via gezichtsherkenning"</string>
    <string name="security_settings_fingerprint" msgid="6387775386189204201">"Vingerafdruk"</string>
    <string name="security_settings_fingerprint_preference_title" msgid="2484965173528415458">"Vingerafdruk"</string>
    <string name="security_settings_fingerprint_settings_preferences_category" msgid="8975029409126780752">"Bij gebruik van Ontgrendelen met vingerafdruk"</string>
    <string name="security_settings_work_fingerprint_preference_title" msgid="2076006873519745979">"Vingerafdruk voor werk"</string>
    <string name="fingerprint_add_title" msgid="1837610443487902050">"Vingerafdruk toevoegen"</string>
    <string name="security_settings_fingerprint_preference_summary" msgid="8486134175759676037">"{count,plural, =1{Vingerafdruk toegevoegd}other{# vingerafdrukken toegevoegd}}"</string>
    <string name="security_settings_fingerprint_preference_summary_none" msgid="1146977379031250790">"Instellen nodig"</string>
    <string name="security_settings_fingerprint_enroll_introduction_title" msgid="7931650601996313070">"Je vingerafdruk instellen"</string>
    <string name="security_settings_fingerprint_enroll_consent_introduction_title" msgid="2278592030102282364">"Ontgrendelen met vingerafdruk toestaan"</string>
    <string name="security_settings_fingerprint_enroll_introduction_title_unlock_disabled" msgid="1911710308293783998">"Je vingerafdruk gebruiken"</string>
    <string name="security_settings_fingerprint_settings_footer_learn_more" msgid="2508322993726483601">"Meer informatie over ontgrendelen met vingerafdruk"</string>
    <string name="security_settings_fingerprint_enroll_introduction_footer_title_1" msgid="6808124116419325722">"Jij hebt het voor het zeggen"</string>
    <string name="security_settings_fingerprint_enroll_introduction_footer_title_consent_1" msgid="1122676690472680734">"Jij en je kind hebben de controle"</string>
    <string name="security_settings_fingerprint_enroll_introduction_footer_title_2" msgid="5663733424583416266">"Houd rekening met het volgende"</string>
    <string name="security_settings_fingerprint_enroll_introduction_message_unlock_disabled" msgid="8957789840251747092">"Gebruik je vingerafdruk om je telefoon te ontgrendelen of aankopen goed te keuren.\n\nOpmerking: Je kunt je vingerafdruk niet gebruiken om dit apparaat te ontgrendelen. Neem contact op met de beheerder van je organisatie voor meer informatie."</string>
    <string name="security_settings_fingerprint_enroll_introduction_cancel" msgid="6086532316718920562">"Annuleren"</string>
    <string name="security_settings_fingerprint_enroll_introduction_no_thanks" msgid="6104718999323591180">"Nee, bedankt"</string>
    <string name="security_settings_fingerprint_enroll_introduction_agree" msgid="4068276083536421828">"Ik ga akkoord"</string>
    <string name="setup_fingerprint_enroll_skip_title" msgid="2473807887676247264">"Vingerafdruk overslaan?"</string>
    <string name="setup_fingerprint_enroll_skip_after_adding_lock_text" msgid="2412645723804450304">"Het instellen van een vingerafdruk kost slechts een minuut of twee. Als je dit nu overslaat, kun je je vingerafdruk later toevoegen via de instellingen."</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_message_setup" msgid="6255210343107484206">"Als je dit icoon ziet, gebruik je je vingerafdruk voor verificatie, net zoals wanneer je inlogt bij apps of aankopen goedkeurt"</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_title_1" msgid="4360262371633254407">"Houd rekening met het volgende"</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_title_2" msgid="2580899232734177771">"Hoe het werkt"</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_message_2" msgid="5909924864816776516">"Ontgrendelen met vingerafdruk maakt een uniek model van je vingerafdruk om te verifiëren dat jij het bent. Tijdens het instelproces maak je afbeeldingen van je vingerafdruk in verschillende posities om een vingerafdrukmodel te maken."</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_message_consent_2" msgid="3493356605815124807">"Ontgrendelen met vingerafdruk maakt een uniek model van de vingerafdruk van je kind om je kind te herkennen tijdens verificatie. Tijdens het instelproces maakt je kind foto\'s van de vingerafdruk in verschillende posities om een vingerafdrukmodel te maken."</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_message_6" msgid="5314031490467481499">"Voor de beste resultaten gebruik je een gecertificeerde Made for Google-screenprotector. Bij andere screenprotectors werkt je vingerafdruk misschien niet."</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_message_consent_6" msgid="3563942520716110478">"Voor de beste resultaten gebruik je een gecertificeerde Made for Google-screenprotector. Bij andere screenprotectors werkt de vingerafdruk van je kind misschien niet."</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_message_learn_more" msgid="5856010507790137793"></string>
    <string name="security_settings_activeunlock_preference_title" msgid="4257580421087062228">"Ontgrendelen via smartwatch"</string>
    <string name="biometric_settings_intro_with_activeunlock" msgid="6583248094453119314">"Als je Ontgrendelen via gezichtsherkenning en Ontgrendelen met vingerafdruk instelt, vraagt je telefoon naar je vingerafdruk als je een mondkapje draagt of in een donkere omgeving bent.\n\nJe kunt ontgrendelen met je smartwatch als je gezicht of vingerafdruk niet wordt herkend."</string>
    <string name="biometric_settings_intro_with_fingerprint" msgid="4312041617237493461">"Je kunt ontgrendelen met je smartwatch als je vingerafdruk niet wordt herkend."</string>
    <string name="biometric_settings_intro_with_face" msgid="7658123658803417930">"Je kunt ontgrendelen met je smartwatch als je gezicht niet wordt herkend."</string>
    <string name="biometric_settings_use_fingerprint_or_watch_for" msgid="1160830065613858095">"Vingerafdruk of smartwatch gebruiken voor"</string>
    <string name="biometric_settings_use_face_or_watch_for" msgid="1507077107150278532">"Gezicht of smartwatch gebruiken voor"</string>
    <string name="biometric_settings_use_face_fingerprint_or_watch_for" msgid="7495835723072020641">"Gezicht, vingerafdruk of smartwatch gebruiken voor"</string>
    <string name="biometric_settings_use_watch_for" msgid="5454545622244040110">"Smartwatch gebruiken voor"</string>
    <string name="biometric_settings_use_face_or_watch_preference_summary" msgid="4969685200340861744">"Gezicht of smartwatch gebruiken"</string>
    <string name="biometric_settings_use_fingerprint_or_watch_preference_summary" msgid="2425628094194828407">"Vingerafdruk of smartwatch gebruiken"</string>
    <string name="biometric_settings_use_face_fingerprint_or_watch_preference_summary" msgid="188805113048792007">"Gezicht, vingerafdruk of smartwatch gebruiken"</string>
    <string name="biometric_settings_use_watch_preference_summary" msgid="2311453276747908475">"Smartwatch gebruiken"</string>
    <string name="security_settings_activeunlock_require_face_fingerprint_setup_title" msgid="8776904312629209685">"Stel eerst Ontgrendelen via gezicht of vingerafdruk in"</string>
    <string name="security_settings_activeunlock_require_face_fingerprint_setup_message" msgid="1669326067732567911">"Je kunt ontgrendelen met je smartwatch als je gezicht of vingerafdruk niet wordt herkend"</string>
    <string name="security_settings_activeunlock_require_fingerprint_setup_title" msgid="6703703635881050623">"Stel eerst Ontgrendelen met vingerafdruk in"</string>
    <string name="security_settings_activeunlock_require_fingerprint_setup_message" msgid="4966813766409918392">"Je kunt ontgrendelen met je smartwatch als je vingerafdruk niet wordt herkend"</string>
    <string name="security_settings_activeunlock_require_face_setup_title" msgid="1428795376597739880">"Stel eerst Ontgrendelen via gezichtsherkenning in"</string>
    <string name="security_settings_activeunlock_require_face_setup_message" msgid="8904070645721933399">"Je kunt ontgrendelen met je smartwatch als je gezicht niet wordt herkend"</string>
    <string name="security_settings_activeunlock_biometric_setup" msgid="8876454457817955475">"Instellen"</string>
    <string name="security_settings_fingerprint_single_watch_preference_summary" msgid="6464470096384164369">"Vingerafdruk en <xliff:g id="WATCH">%s</xliff:g> toegevoegd"</string>
    <string name="security_settings_fingerprint_multiple_watch_preference_summary" msgid="2259261786932097004">"Vingerafdrukken en <xliff:g id="WATCH">%s</xliff:g> toegevoegd"</string>
    <string name="security_settings_face_watch_preference_summary" msgid="5817376447253802793">"Gezicht en <xliff:g id="WATCH">%s</xliff:g> toegevoegd"</string>
    <string name="security_settings_fingerprint_single_face_watch_preference_summary" msgid="764951912234638192">"Gezicht, vingerafdruk en <xliff:g id="WATCH">%s</xliff:g> toegevoegd"</string>
    <string name="security_settings_fingerprint_multiple_face_watch_preference_summary" msgid="3935500711366489380">"Gezicht, vingerafdrukken en <xliff:g id="WATCH">%s</xliff:g> toegevoegd"</string>
    <string name="security_settings_biometric_preference_title" msgid="298146483579539448">"Ontgrendelen via gezichtsherkenning en met vingerafdruk"</string>
    <string name="security_settings_work_biometric_preference_title" msgid="3121755615533533585">"Ontgrendelen via gezichtsherkenning en vingerafdruk voor werk"</string>
    <string name="security_settings_biometric_preference_summary_none_enrolled" msgid="213377753727694575">"Instellen nodig"</string>
    <string name="security_settings_biometric_preference_summary_both_fp_multiple" msgid="4821859306609955966">"Gezicht en vingerafdrukken toegevoegd"</string>
    <string name="security_settings_biometric_preference_summary_both_fp_single" msgid="684409535278676426">"Gezicht en vingerafdruk toegevoegd"</string>
    <string name="biometric_settings_intro" msgid="4263069383955676756">"Als je Ontgrendelen via gezichtsherkenning en Ontgrendelen met vingerafdruk instelt, vraagt je telefoon naar je vingerafdruk als je een mondkapje draagt of in een donkere omgeving bent"</string>
    <string name="biometric_settings_category_ways_to_unlock" msgid="3384767901580915266">"Manieren om te ontgrendelen"</string>
    <string name="biometric_settings_category_use_face_fingerprint" msgid="4377659744376863913">"Gezicht of vingerafdruk gebruiken voor"</string>
    <string name="biometric_settings_use_biometric_unlock_phone" msgid="8180914579885804358">"Je telefoon ontgrendelen"</string>
    <string name="biometric_settings_use_biometric_for_apps" msgid="6201168728906364189">"Verifiëren dat jij het bent in apps"</string>
    <string name="biometric_settings_use_face_preference_summary" msgid="1821648836899408477">"Gezicht gebruiken"</string>
    <string name="biometric_settings_use_fingerprint_preference_summary" msgid="6077762097826050165">"Met je vingerafdruk"</string>
    <string name="biometric_settings_use_face_or_fingerprint_preference_summary" msgid="3029102492674234728">"Met je gezicht of vingerafdruk"</string>
    <string name="biometric_settings_hand_back_to_guardian_ok" msgid="1763788801883247426">"OK"</string>
    <string name="biometric_settings_add_face_in_split_mode_title" msgid="6041232223862753222">"Kan ontgrendelen via gezichtsherkenning niet instellen"</string>
    <string name="biometric_settings_add_face_in_split_mode_message" msgid="1904738532939614456">"Sluit gesplitst scherm om ontgrendelen via gezichtsherkenning in te stellen"</string>
    <string name="biometric_settings_add_fingerprint_in_split_mode_title" msgid="9194670722730454903">"Kan vingerafdruk niet instellen"</string>
    <string name="biometric_settings_add_fingerprint_in_split_mode_message" msgid="6960548382076629454">"Sluit gesplitst scherm om Ontgrendelen met vingerafdruk in te stellen"</string>
    <string name="biometric_settings_add_biometrics_in_split_mode_ok" msgid="564103789097253645">"OK"</string>
    <string name="lock_screen_intro_skip_title" msgid="342553937472568925">"Schermvergrendeling overslaan?"</string>
    <string name="skip_anyway_button_label" msgid="3442274117023270068">"Toch overslaan"</string>
    <string name="go_back_button_label" msgid="6139455414099035594">"Terug"</string>
    <string name="skip_lock_screen_dialog_button_label" msgid="641984698150020591">"Overslaan"</string>
    <string name="cancel_lock_screen_dialog_button_label" msgid="1801132985957491690">"Annuleren"</string>
    <string name="security_settings_fingerprint_enroll_find_sensor_title" msgid="886085239313346000">"Raak de sensor aan"</string>
    <string name="security_settings_sfps_enroll_find_sensor_title" msgid="8327884364635804363">"Raak de aan/uit-knop aan zonder deze in te drukken"</string>
    <string name="security_settings_udfps_enroll_find_sensor_title" msgid="8077484429913330179">"Je vingerafdruk instellen"</string>
    <string name="security_settings_fingerprint_enroll_find_sensor_message" msgid="6160543980992596286">"De sensor bevindt zich aan de achterkant van je telefoon. Gebruik je wijsvinger."</string>
    <string name="security_settings_udfps_enroll_find_sensor_message" msgid="8383106460819519961">"De vingerafdruksensor vind je op je scherm. Je legt je vingerafdruk vast op het volgende scherm."</string>
    <string name="security_settings_udfps_enroll_find_sensor_start_button" msgid="3172268783620336357">"Starten"</string>
    <string name="security_settings_udfps_enroll_a11y" msgid="1899453114050362235">"Beweeg je vinger over het scherm om de sensor te vinden. Houd je vinger op de vingerafdruksensor"</string>
    <string name="security_settings_fingerprint_enroll_find_sensor_content_description" msgid="3065850549419750523">"Ilustratie met apparaat en locatie van vingerafdruksensor"</string>
    <string name="security_settings_fingerprint_enroll_dialog_name_label" msgid="7298812463228440333">"Naam"</string>
    <string name="security_settings_fingerprint_enroll_dialog_ok" msgid="4074335979239208021">"OK"</string>
    <string name="security_settings_fingerprint_enroll_dialog_try_again" msgid="8117874972945407006">"Opnieuw proberen"</string>
    <string name="security_settings_fingerprint_enroll_dialog_delete" msgid="6027141901007342389">"Verwijderen"</string>
    <string name="security_settings_fingerprint_enroll_start_title" msgid="7391368057800077604">"Raak de sensor aan"</string>
    <string name="security_settings_fingerprint_enroll_start_message" msgid="5010227772754175346">"Plaats je vinger op de sensor en til deze op nadat je een trilling hebt gevoeld."</string>
    <string name="security_settings_udfps_enroll_start_message" msgid="5032954588171487566">"Houd je vinger plat op de sensor totdat je een trilling voelt"</string>
    <string name="security_settings_sfps_enroll_start_message" msgid="9054672627477685212">"Houd zonder de knop in te drukken je vinger op de sensor tot je een trilling voelt.\n\nBeweeg je vinger een beetje na elke trilling. Zo kan er meer van je vingerafdruk worden geregistreerd."</string>
    <string name="security_settings_fingerprint_enroll_udfps_title" msgid="6665610134560896895">"Houd je vinger op de vingerafdruksensor"</string>
    <string name="security_settings_fingerprint_enroll_repeat_title" msgid="9172202128243545021">"Raak de sensor opnieuw aan"</string>
    <string name="security_settings_udfps_enroll_title_one_more_time" msgid="424937043843482410">"Nog een keer"</string>
    <string name="security_settings_udfps_enroll_repeat_title_touch_icon" msgid="4096344864386190335">"Volg het vingerafdrukicoon"</string>
    <string name="security_settings_fingerprint_enroll_repeat_message" msgid="5382958363770893577">"Raak de sensor meerdere keren aan om de verschillende delen van je vingerafdruk toe te voegen."</string>
    <string name="security_settings_udfps_enroll_repeat_message" msgid="2213106975297867798">"Tik en houd het vingerafdrukicoon vast elke keer dat het beweegt. Zo kan er meer van je vingerafdruk worden geregistreerd."</string>
    <string name="security_settings_udfps_enroll_fingertip_title" msgid="4123142574168831116">"Houd het puntje van je vingertop op de sensor"</string>
    <string name="security_settings_udfps_enroll_left_edge_title" msgid="1944076382202470458">"Plaats de linkerrand van je vinger"</string>
    <string name="security_settings_udfps_enroll_right_edge_title" msgid="9036744264606447490">"Plaats de rechterrand van je vinger"</string>
    <string name="security_settings_sfps_enroll_finger_center_title" msgid="1320688855767675739">"Plaats het midden van je vingertop op de sensor"</string>
    <string name="security_settings_sfps_enroll_fingertip_title" msgid="2737520837684516446">"Houd je puntje van je vingertop op de sensor"</string>
    <string name="security_settings_sfps_enroll_left_edge_title" msgid="9022963735924413343">"Plaats de linkerkant van je vinger op de sensor"</string>
    <string name="security_settings_sfps_enroll_right_edge_title" msgid="823106857743394392">"Plaats tot slot de rechterkant van je vinger op de sensor"</string>
    <string name="security_settings_udfps_enroll_edge_message" msgid="4455253923746607702">"Leg de zijkant van je vingerafdruk op de sensor en houd vast. Doe dan hetzelfde aan de andere kant."</string>
    <string name="security_settings_udfps_enroll_repeat_a11y_message" msgid="2785464357615568197">"Zo kan er meer van je vingerafdruk worden geregistreerd"</string>
    <string name="security_settings_sfps_enroll_progress_a11y_message" msgid="6450772721691523736">"Vingerafdruk vastleggen: <xliff:g id="PERCENTAGE">%d</xliff:g> procent"</string>
    <string name="security_settings_sfps_animation_a11y_label" msgid="8808819903730940446">"<xliff:g id="PERCENTAGE">%d</xliff:g> procent vastgelegd"</string>
    <string name="security_settings_udfps_enroll_progress_a11y_message" msgid="6183535114682369699">"Vingerafdruk vastleggen: <xliff:g id="PERCENTAGE">%d</xliff:g> procent"</string>
    <string name="security_settings_fingerprint_enroll_finish_title" msgid="3606325177406951457">"Vingerafdruk toegevoegd"</string>
    <string name="security_settings_require_screen_on_to_auth_title" msgid="1641621458536715518">"Aanraken om op elk moment te ontgrendelen"</string>
    <string name="security_settings_require_screen_on_to_auth_description" msgid="4158414711168345398">"Raak de sensor aan om te ontgrendelen, ook als het scherm uitstaat. Hierdoor neemt de kans op per ongeluk ontgrendelen toe."</string>
    <string name="security_settings_require_screen_on_to_auth_keywords" msgid="5557869560397089603">"Scherm, Ontgrendelen"</string>
    <string name="security_settings_fingerprint_enroll_enrolling_skip" msgid="3004786457919122854">"Later doen"</string>
    <string name="security_settings_udfps_tip_fingerprint_help" msgid="7580784640741217494">"Raak de sensor opnieuw aan"</string>
    <string name="security_settings_udfps_side_fingerprint_help" msgid="2567232481013195191">"Leg de zijkant van je vingerafdruk op de sensor en houd vast. Doe dan hetzelfde aan de andere kant."</string>
    <string name="setup_fingerprint_enroll_enrolling_skip_title" msgid="352947044008973812">"Instellen van vingerafdruk overslaan?"</string>
    <string name="setup_fingerprint_enroll_enrolling_skip_message" msgid="4876965433600560365">"Je hebt ervoor gekozen je vingerafdruk te gebruiken als manier om je telefoon te ontgrendelen. Als je dit nu overslaat, moet je het later instellen. Het instellen neemt ongeveer een minuut in beslag."</string>
    <string name="lock_screen_skip_setup_title" msgid="6979006375138175111">"Instellen overslaan voor <xliff:g id="OPTIONS">%s</xliff:g>?"</string>
    <string name="lock_screen_pin_skip_title" msgid="6853866579893458111">"Instellen pincode overslaan?"</string>
    <string name="lock_screen_pin_skip_face_title" msgid="8810770395309512358">"Pincode en gezicht instellen overslaan?"</string>
    <string name="lock_screen_pin_skip_fingerprint_title" msgid="371214283158750976">"Pincode en vingerafdruk instellen overslaan?"</string>
    <string name="lock_screen_pin_skip_biometrics_title" msgid="1082066572914073311">"Pincode, gezicht en vingerafdruk instellen overslaan?"</string>
    <string name="lock_screen_password_skip_title" msgid="8891463713793185768">"Instellen van wachtwoord overslaan?"</string>
    <string name="lock_screen_password_skip_face_title" msgid="8166210519462164998">"Wachtwoord en gezicht instellen overslaan?"</string>
    <string name="lock_screen_password_skip_fingerprint_title" msgid="2506392546016772170">"Wachtwoord en vingerafdruk instellen overslaan?"</string>
    <string name="lock_screen_password_skip_biometrics_title" msgid="900281322095862009">"Wachtwoord, gezicht en vingerafdruk instellen overslaan?"</string>
    <string name="lock_screen_pattern_skip_title" msgid="7214938393640060932">"Instellen patroon overslaan?"</string>
    <string name="lock_screen_pattern_skip_face_title" msgid="145100333454316334">"Patroon en gezicht instellen overslaan?"</string>
    <string name="lock_screen_pattern_skip_fingerprint_title" msgid="2513110208722100495">"Patroon en vingerafdruk instellen overslaan?"</string>
    <string name="lock_screen_pattern_skip_biometrics_title" msgid="2434258106825380187">"Patroon, gezicht en vingerafdruk instellen overslaan?"</string>
    <string name="security_settings_fingerprint_enroll_setup_screen_lock" msgid="3538784524778508018">"Schermvergrendeling instellen"</string>
    <string name="security_settings_fingerprint_enroll_done" msgid="9198775984215057337">"Klaar"</string>
    <string name="security_settings_fingerprint_enroll_touch_dialog_title" msgid="5742429501012827526">"Dat is niet de sensor"</string>
    <string name="security_settings_fingerprint_enroll_touch_dialog_message" msgid="7172969336386036998">"Raak de sensor achter op je telefoon aan. Gebruik je wijsvinger."</string>
    <!-- no translation found for security_settings_fingerprint_enroll_error_unable_to_process_dialog_title (6305457126747942642) -->
    <skip />
    <!-- no translation found for security_settings_fingerprint_enroll_error_unable_to_process_message_setup (2735739618722623980) -->
    <skip />
    <!-- no translation found for security_settings_fingerprint_enroll_error_unable_to_process_message (5858386244898601003) -->
    <skip />
    <string name="security_settings_fingerprint_enroll_error_dialog_title" msgid="8582267776559099046">"Time-out bij instellen van vingerafdruk"</string>
    <!-- no translation found for security_settings_fingerprint_enroll_error_timeout_dialog_message_setup (8521566666541069383) -->
    <skip />
    <!-- no translation found for security_settings_fingerprint_enroll_error_generic_dialog_message_setup (8140162986046783546) -->
    <skip />
    <!-- no translation found for security_settings_fingerprint_enroll_error_timeout_dialog_message (3534341971920335247) -->
    <skip />
    <!-- no translation found for security_settings_fingerprint_enroll_error_generic_dialog_message (4344665784935791640) -->
    <skip />
    <string name="fingerprint_enroll_button_add" msgid="6652490687672815760">"Nog een toevoegen"</string>
    <string name="fingerprint_enroll_button_next" msgid="1034110123277869532">"Volgende"</string>
    <string name="security_fingerprint_disclaimer_lockscreen_disabled_1" msgid="294529888220959309">"De optie voor schermvergrendeling is uitgezet. Neem voor meer informatie contact op met de beheerder van je organisatie."</string>
    <string name="security_fingerprint_disclaimer_lockscreen_disabled_2" msgid="8070829069640846543">"Je kunt je vingerafdruk wel gebruiken om aankopen en app-toegang goed te keuren."</string>
    <string name="security_settings_fingerprint_enroll_lift_touch_again" msgid="2590665137265458789">"Til je vinger op en raak de sensor opnieuw aan"</string>
    <!-- no translation found for security_settings_fingerprint_bad_calibration_title (3073145395701953620) -->
    <skip />
    <!-- no translation found for security_settings_fingerprint_bad_calibration (304585658839584958) -->
    <skip />
    <string name="security_advanced_settings" msgid="6260756619837834042">"Meer beveiligingsinstellingen"</string>
    <string name="security_advanced_settings_work_profile_settings_summary" msgid="7295451997961973175">"Werkprofielvergrendeling, versleuteling en meer"</string>
    <string name="security_advanced_settings_no_work_profile_settings_summary" msgid="345336447137417638">"Versleuteling, inloggegevens en meer"</string>
    <string name="security_advanced_settings_keywords" msgid="5294945170370974974">"beveiliging, meer beveiligingsinstellingen, meer instellingen, geavanceerde beveiligingsinstellingen"</string>
    <string name="privacy_advanced_settings" msgid="8828215456566937719">"Meer privacyinstellingen"</string>
    <string name="more_security_privacy_settings" msgid="123465614090328851">"Meer beveiliging en privacy"</string>
    <string name="security_header" msgid="961514795852103424">"Beveiliging"</string>
    <string name="privacy_header" msgid="5526002421324257007">"Privacy"</string>
    <string name="work_profile_category_header" msgid="85707750968948517">"Werkprofiel"</string>
    <string name="fingerprint_add_max" msgid="8639321019299347447">"Je kunt maximaal <xliff:g id="COUNT">%d</xliff:g> vingerafdrukken toevoegen"</string>
    <string name="fingerprint_intro_error_max" msgid="4431784409732135610">"Je hebt het maximale aantal vingerafdrukken toegevoegd"</string>
    <string name="fingerprint_intro_error_unknown" msgid="877005321503793963">"Kan geen extra vingerafdrukken toevoegen"</string>
    <string name="fingerprint_delete_title" msgid="5412123164503407098">"<xliff:g id="FINGERPRINT_ID">%1$s</xliff:g> verwijderen"</string>
    <string name="fingerprint_last_delete_message_profile_challenge" msgid="4104208067277655068">"Je kunt je vingerafdruk dan niet meer gebruiken om je werkprofiel te ontgrendelen, aankopen te autoriseren of in te loggen bij werk-apps."</string>
    <string name="encryption_settings_title" msgid="2848716008695618360">"Versleuteling"</string>
    <string name="encrypted_summary" msgid="545623487587251207">"Versleuteld"</string>
    <string name="no_screen_lock_issue_title" msgid="1814109590692792891">"Schermvergrendeling instellen"</string>
    <string name="no_screen_lock_issue_summary" msgid="2383217853510608406">"Stel een pincode, patroon of wachtwoord in voor dit apparaat voor extra beveiliging"</string>
    <string name="no_screen_lock_issue_action_label" msgid="2691229130486382863">"Schermvergrendeling instellen"</string>
    <string name="no_screen_lock_issue_notification_title" msgid="1214876733592830628">"Een schermvergrendeling instellen"</string>
    <string name="no_screen_lock_issue_notification_text" msgid="8696194459170873345">"Stel een pincode, patroon of wachtwoord in voor dit apparaat voor extra beveiliging"</string>
    <string name="suggested_lock_settings_title" msgid="7836065447159730217">"Beveilig je telefoon"</string>
    <string name="suggested_fingerprint_lock_settings_title" msgid="3140266181874137984">"Voeg vingerafdruk toe om te ontgrendelen"</string>
    <string name="lock_settings_picker_title" msgid="9219376327364915334">"Scherm­vergrendeling kiezen"</string>
    <string name="lock_settings_picker_new_lock_title" msgid="3113042086804290919">"Scherm­vergrendeling kiezen"</string>
    <string name="lock_settings_picker_update_lock_title" msgid="536853138943415927">"Nieuwe scherm­vergrendeling"</string>
    <string name="lock_settings_picker_new_profile_lock_title" msgid="2270462215256413800">"Vergrendeling werk-apps kiezen"</string>
    <string name="lock_settings_picker_update_profile_lock_title" msgid="5929068163516308927">"Nieuwe vergrendeling werk-apps kiezen"</string>
    <string name="lock_settings_picker_biometrics_added_security_message" msgid="1105247657304421299">"Stel een extra schermvergrendeling in voor betere beveiliging"</string>
    <string name="lock_settings_picker_biometric_message" msgid="2609666443527262781">"Kies je back-upmethode voor schermvergrendeling"</string>
    <string name="lock_settings_picker_admin_restricted_personal_message" msgid="3532653662159888328">"Als je je schermvergrendeling vergeet, kan je IT-beheerder deze niet resetten."</string>
    <string name="lock_settings_picker_admin_restricted_personal_message_action" msgid="5956615234246626264">"Afzonderlijke vergrendeling voor werk instellen"</string>
    <string name="lock_settings_picker_profile_message" msgid="9142379549980873478">"Als je deze vergrendeling vergeet, kan je IT-beheerder deze resetten"</string>
    <string name="setup_lock_settings_options_button_label" msgid="6098297461618298505">"Schermvergrendelingsopties"</string>
    <string name="setup_lock_settings_options_dialog_title" msgid="7985107300517468569">"Schermvergrendelingsopties"</string>
    <string name="lock_screen_auto_pin_confirm_title" msgid="3012128112186088375">"Ontgrendelen automatisch bevestigen"</string>
    <string name="lock_screen_auto_pin_confirm_summary" msgid="9050818870806580819">"Ontgrendel het apparaat automatisch als je de juiste pincode van 6 cijfers of meer opgeeft. Dit is iets minder veilig dan op Enter tikken om te bevestigen."</string>
    <string name="auto_pin_confirm_user_message" msgid="6194556173488939314">"Juiste pincode automatisch bevestigen"</string>
    <string name="auto_pin_confirm_opt_in_security_message" msgid="580773976736184893">"Je pincode bevestigen door op Enter te tikken is veiliger dan automatisch bevestigen gebruiken"</string>
    <string name="auto_confirm_on_pin_verify_description" msgid="2052240431173223502">"Geef de pincode van het apparaat op om automatische bevestiging aan te zetten"</string>
    <string name="auto_confirm_off_pin_verify_description" msgid="4256219155659760047">"Geef de pincode van het apparaat op om automatische bevestiging uit te zetten"</string>
    <string name="unlock_set_unlock_launch_picker_title" msgid="4981063601772605609">"Scherm­vergrendeling"</string>
    <string name="unlock_set_unlock_launch_picker_title_profile" msgid="7631371082326055429">"Werkprofiel­vergrendeling"</string>
    <string name="unlock_set_unlock_off_title" msgid="2831957685685921667">"Geen"</string>
    <string name="unlock_set_unlock_none_title" msgid="2844029875174409728">"Swipen"</string>
    <string name="unlock_set_unlock_pattern_title" msgid="8224895208452995332">"Patroon"</string>
    <string name="unlock_set_unlock_pin_title" msgid="5283636759362880407">"Pincode"</string>
    <string name="unlock_set_unlock_password_title" msgid="2559842616268607041">"Wachtwoord"</string>
    <string name="unlock_set_do_later_title" msgid="6565575303676064364">"Niet nu"</string>
    <string name="current_screen_lock" msgid="1367883977261098017">"Huidige schermvergrendeling"</string>
    <string name="fingerprint_unlock_set_unlock_pattern" msgid="2229689425933043901">"Patroon • Vingerafdruk"</string>
    <string name="fingerprint_unlock_set_unlock_pin" msgid="7979848492740627674">"Pincode • Vingerafdruk"</string>
    <string name="fingerprint_unlock_set_unlock_password" msgid="6207676267295036963">"Wachtwoord • Vingerafdruk"</string>
    <string name="fingerprint_unlock_skip_fingerprint" msgid="7631242444064287891">"Doorgaan zonder vingerafdruk"</string>
    <string name="face_unlock_set_unlock_pattern" msgid="4206669838203096608">"Patroon • Gezicht"</string>
    <string name="face_unlock_set_unlock_pin" msgid="9034912683791069602">"Pincode • Gezicht"</string>
    <string name="face_unlock_set_unlock_password" msgid="5874950853246424756">"Wachtwoord • Gezicht"</string>
    <string name="face_unlock_skip_face" msgid="189695556498300008">"Doorgaan zonder Ontgrendelen via gezichtsherkenning"</string>
    <string name="biometrics_unlock_set_unlock_pattern" msgid="8084495264354847044">"Patroon • Gezicht • Vingerafdruk"</string>
    <string name="biometrics_unlock_set_unlock_pin" msgid="5912980580857825894">"Pincode • Gezicht • Vingerafdruk"</string>
    <string name="biometrics_unlock_set_unlock_password" msgid="4612217647465743624">"Wachtwoord • Gezicht • Vingerafdruk"</string>
    <string name="biometrics_unlock_skip_biometrics" msgid="7785643433551409223">"Doorgaan zonder gezicht of vingerafdruk"</string>
    <string name="unlock_set_unlock_mode_off" msgid="4632139864722236359">"Geen"</string>
    <string name="unlock_set_unlock_mode_none" msgid="5596049938457028214">"Swipen"</string>
    <string name="unlock_set_unlock_mode_pattern" msgid="1926480143883094896">"Patroon"</string>
    <string name="unlock_set_unlock_mode_pin" msgid="9028659554829888373">"Pincode"</string>
    <string name="unlock_set_unlock_mode_password" msgid="8810609692771987513">"Wachtwoord"</string>
    <string name="unlock_disable_frp_warning_title" msgid="3606280046362811229">"Schermvergrendeling verwijderen?"</string>
    <string name="unlock_disable_frp_warning_title_profile" msgid="1005284289723910461">"Profielbeveiliging verwijderen?"</string>
    <string name="unlock_disable_frp_warning_content_pattern" msgid="6246242612158828147">"Een patroon beschermt je telefoon bij verlies of diefstal"</string>
    <string name="unlock_disable_frp_warning_content_pattern_fingerprint" msgid="2259825377085781801">"Een patroon beschermt je telefoon bij verlies of diefstal.<xliff:g id="EMPTY_LINE">

</xliff:g>Hierdoor wordt ook het vingerafdrukmodel verwijderd dat op je apparaat is opgeslagen. Je kunt je vingerafdruk dan niet meer gebruiken voor verificatie in apps."</string>
    <string name="unlock_disable_frp_warning_content_pattern_face" msgid="4699508435412336378">"Een patroon beschermt je telefoon bij verlies of diefstal.<xliff:g id="EMPTY_LINE">

</xliff:g>Je gezichtsmodel wordt ook definitief en op een beveiligde manier verwijderd. Je kunt je gezicht niet gebruiken voor verificatie in apps."</string>
    <string name="unlock_disable_frp_warning_content_pattern_face_fingerprint" msgid="7049706229344804972">"Een patroon beschermt je telefoon bij verlies of diefstal.<xliff:g id="EMPTY_LINE">

</xliff:g>Hierdoor wordt het vingerafdrukmodel verwijderd dat op je apparaat is opgeslagen. Je gezichtsmodel wordt ook definitief en op een beveiligde manier verwijderd. Je kunt je gezicht of vingerafdruk niet gebruiken voor verificatie in apps."</string>
    <string name="unlock_disable_frp_warning_content_pin" msgid="122154942944422284">"Een pincode beschermt je telefoon bij verlies of diefstal"</string>
    <string name="unlock_disable_frp_warning_content_pin_fingerprint" msgid="983373874470746066">"Een pincode beschermt je telefoon bij verlies of diefstal.<xliff:g id="EMPTY_LINE">

</xliff:g>Hierdoor wordt ook het vingerafdrukmodel verwijderd dat op je apparaat is opgeslagen. Je kunt je vingerafdruk dan niet meer gebruiken voor verificatie in apps."</string>
    <string name="unlock_disable_frp_warning_content_pin_face" msgid="5607150515413131761">"Een pincode beschermt je telefoon bij verlies of diefstal.<xliff:g id="EMPTY_LINE">

</xliff:g>Je gezichtsmodel wordt ook definitief en op een beveiligde manier verwijderd. Je kunt je gezicht niet gebruiken voor verificatie in apps."</string>
    <string name="unlock_disable_frp_warning_content_pin_face_fingerprint" msgid="1821792325159866312">"Een pincode beschermt je telefoon bij verlies of diefstal.<xliff:g id="EMPTY_LINE">

</xliff:g>Hierdoor wordt het vingerafdrukmodel verwijderd dat op je apparaat is opgeslagen. Je gezichtsmodel wordt ook definitief en op een beveiligde manier verwijderd. Je kunt je gezicht of vingerafdruk niet gebruiken voor verificatie in apps."</string>
    <string name="unlock_disable_frp_warning_content_password" msgid="6422723907917376210">"Een wachtwoord beschermt je telefoon bij verlies of diefstal"</string>
    <string name="unlock_disable_frp_warning_content_password_fingerprint" msgid="8899452884016354856">"Een wachtwoord beschermt je telefoon bij verlies of diefstal.<xliff:g id="EMPTY_LINE">

</xliff:g>Hierdoor wordt ook het vingerafdrukmodel verwijderd dat op je apparaat is opgeslagen. Je kunt je vingerafdruk dan niet meer gebruiken voor verificatie in apps."</string>
    <string name="unlock_disable_frp_warning_content_password_face" msgid="1811067332335964495">"Een wachtwoord beschermt je telefoon bij verlies of diefstal.<xliff:g id="EMPTY_LINE">

</xliff:g>Je gezichtsmodel wordt ook permanent en op een beveiligde manier verwijderd. Je kunt je gezicht niet gebruiken voor verificatie in apps."</string>
    <string name="unlock_disable_frp_warning_content_password_face_fingerprint" msgid="7063649456205159491">"Een wachtwoord beschermt je telefoon bij verlies of diefstal.<xliff:g id="EMPTY_LINE">

</xliff:g>Hierdoor wordt het vingerafdrukmodel verwijderd dat op je apparaat is opgeslagen. Je gezichtsmodel wordt ook definitief en op een beveiligde manier verwijderd. Je kunt je gezicht of vingerafdruk niet gebruiken voor verificatie in apps."</string>
    <string name="unlock_disable_frp_warning_content_unknown" msgid="8903568674104115231">"De apparaatbeveiliging werkt niet zonder je schermvergendeling."</string>
    <string name="unlock_disable_frp_warning_content_unknown_fingerprint" msgid="6542744110902941189">"Functies voor apparaatbeveiliging werken niet zonder je schermvergrendeling.<xliff:g id="EMPTY_LINE">

</xliff:g>Hierdoor wordt ook het vingerafdrukmodel verwijderd dat op je apparaat is opgeslagen. Je kunt je vingerafdruk dan niet meer gebruiken voor verificatie in apps."</string>
    <string name="unlock_disable_frp_warning_content_unknown_face" msgid="4559917661432267841">"Functies voor apparaatbeveiliging werken niet zonder je schermvergrendeling.<xliff:g id="EMPTY_LINE">

</xliff:g>Je gezichtsmodel wordt ook definitief en op een beveiligde manier verwijderd. Je kunt je gezicht niet gebruiken voor verificatie in apps."</string>
    <string name="unlock_disable_frp_warning_content_unknown_face_fingerprint" msgid="3779582301453677644">"Functies voor apparaatbeveiliging werken niet zonder je schermvergrendeling.<xliff:g id="EMPTY_LINE">

</xliff:g>Hierdoor wordt het vingerafdrukmodel verwijderd dat op je apparaat is opgeslagen. Je gezichtsmodel wordt ook definitief en op een beveiligde manier verwijderd. Je kunt je gezicht of vingerafdruk niet gebruiken voor verificatie in apps."</string>
    <string name="unlock_disable_frp_warning_ok" msgid="6173427638951230842">"Verwijderen"</string>
    <string name="unlock_footer_high_complexity_requested" msgid="4471274783909915352">"<xliff:g id="APP_NAME">%1$s</xliff:g> raadt een sterke pincode of sterk wachtwoord aan en werkt zonder een van deze mogelijk niet zoals verwacht"</string>
    <string name="unlock_footer_medium_complexity_requested" msgid="5515870066751600640">"<xliff:g id="APP_NAME">%1$s</xliff:g> raadt een nieuwe pincode of nieuw wachtwoord aan en werkt zonder een van deze mogelijk niet zoals verwacht"</string>
    <string name="unlock_footer_low_complexity_requested" msgid="2517656037576567971">"<xliff:g id="APP_NAME">%1$s</xliff:g> raadt een nieuw patroon, nieuwe pincode of nieuw wachtwoord aan en werkt zonder een van deze mogelijk niet zoals verwacht"</string>
    <string name="unlock_footer_none_complexity_requested" msgid="8534900170428140529">"<xliff:g id="APP_NAME">%1$s</xliff:g> raadt een nieuwe schermvergrendeling aan."</string>
    <string name="lock_failed_attempts_before_wipe" msgid="6874652886647631418">"Probeer het opnieuw. Poging <xliff:g id="CURRENT_ATTEMPTS">%1$d</xliff:g> van <xliff:g id="TOTAL_ATTEMPTS">%2$d</xliff:g>."</string>
    <string name="lock_last_attempt_before_wipe_warning_title" msgid="7450322567217745999">"Je gegevens worden verwijderd"</string>
    <string name="lock_last_pattern_attempt_before_wipe_device" msgid="5816668400104558952">"Als je bij de volgende poging een onjuist patroon opgeeft, worden de gegevens van dit apparaat verwijderd"</string>
    <string name="lock_last_pin_attempt_before_wipe_device" msgid="2815681042623708775">"Als je bij de volgende poging een onjuiste pincode opgeeft, worden de gegevens van dit apparaat verwijderd"</string>
    <string name="lock_last_password_attempt_before_wipe_device" msgid="985126164175708507">"Als je bij de volgende poging een onjuist wachtwoord opgeeft, worden de gegevens van dit apparaat verwijderd"</string>
    <string name="lock_last_pattern_attempt_before_wipe_user" msgid="8283944727199433440">"Als je bij de volgende poging een onjuist patroon opgeeft, wordt deze gebruiker verwijderd"</string>
    <string name="lock_last_pin_attempt_before_wipe_user" msgid="972834567684477451">"Als je bij de volgende poging een onjuiste pincode opgeeft, wordt deze gebruiker verwijderd"</string>
    <string name="lock_last_password_attempt_before_wipe_user" msgid="3797239847079686727">"Als je bij de volgende poging een onjuist wachtwoord opgeeft, wordt deze gebruiker verwijderd"</string>
    <string name="lock_last_pattern_attempt_before_wipe_profile" msgid="2479195488386373253">"Als je bij de volgende poging een onjuist patroon opgeeft, worden je werkprofiel en de bijbehorende gegevens verwijderd"</string>
    <string name="lock_last_pin_attempt_before_wipe_profile" msgid="7086428013814722436">"Als je bij de volgende poging een onjuiste pincode opgeeft, worden je werkprofiel en de bijbehorende gegevens verwijderd"</string>
    <string name="lock_last_password_attempt_before_wipe_profile" msgid="253673907244112643">"Als je bij de volgende poging een onjuist wachtwoord opgeeft, worden je werkprofiel en de bijbehorende gegevens verwijderd"</string>
    <string name="lockpassword_password_too_short" msgid="1938086368137797700">"{count,plural, =1{Moet minstens # teken bevatten}other{Moet minstens # tekens bevatten}}"</string>
    <string name="lockpassword_password_too_short_all_numeric" msgid="4301294924022401502">"{count,plural, =1{Als je alleen cijfers gebruikt, moet het minstens 1 cijfer lang zijn}other{Als je alleen cijfers gebruikt, moet het minstens # cijfers lang zijn}}"</string>
    <string name="lockpassword_pin_too_short" msgid="8910105226463085689">"{count,plural, =1{Pincode moet minstens # cijfer bevatten}other{Pincode moet minstens # cijfers bevatten}}"</string>
    <string name="lockpassword_pin_too_short_autoConfirm_extra_message" msgid="3271351502900762571">"{count,plural, =1{De pincode moet minstens # cijfer bevatten, maar een pincode van {minAutoConfirmLen} cijfers wordt aanbevolen voor betere beveiliging}other{De pincode moet minstens # cijfers bevatten, maar een pincode van {minAutoConfirmLen} cijfers wordt aanbevolen voor betere beveiliging}}"</string>
    <string name="lockpassword_password_too_long" msgid="1940345313260498308">"{count,plural, =1{Moet korter zijn dan # teken}other{Moet korter zijn dan # tekens}}"</string>
    <string name="lockpassword_pin_too_long" msgid="1678212054564388576">"{count,plural, =1{Moet korter zijn dan # cijfer}other{Moet korter zijn dan # cijfers}}"</string>
    <string name="lockpassword_pin_recently_used" msgid="6650277060998923465">"Apparaatbeheer staat het gebruik van een recente pincode niet toe"</string>
    <string name="lockpassword_illegal_character" msgid="3434031212215886433">"Mag geen ongeldig teken bevatten"</string>
    <string name="lockpassword_password_requires_letters" msgid="7058340182953750553">"{count,plural, =1{Moet minstens 1 letter bevatten}other{Moet minstens # letters bevatten}}"</string>
    <string name="lockpassword_password_requires_lowercase" msgid="3286121470522077547">"{count,plural, =1{Moet minstens 1 kleine letter bevatten}other{Moet minstens # kleine letters bevatten}}"</string>
    <string name="lockpassword_password_requires_uppercase" msgid="720312543910397772">"{count,plural, =1{Moet minstens 1 hoofdletter bevatten}other{Moet minstens # hoofdletters bevatten}}"</string>
    <string name="lockpassword_password_requires_numeric" msgid="3886918493600507548">"{count,plural, =1{Moet minstens 1 cijfer bevatten}other{Moet minstens # cijfers bevatten}}"</string>
    <string name="lockpassword_password_requires_symbols" msgid="2904870551002210131">"{count,plural, =1{Moet minstens 1 speciaal symbool bevatten}other{Moet minstens # speciale symbolen bevatten}}"</string>
    <string name="lockpassword_password_requires_nonletter" msgid="1185342065898300006">"{count,plural, =1{Moet minstens 1 teken bevatten dat geen letter is}other{Moet minstens # tekens bevatten die geen letters zijn}}"</string>
    <string name="lockpassword_password_requires_nonnumerical" msgid="389687423482993365">"{count,plural, =1{Moet minstens 1 niet-numeriek teken bevatten}other{Moet minstens # niet-numerieke tekens bevatten}}"</string>
    <string name="lockpassword_password_recently_used" msgid="5341218079730167191">"Apparaatbeheer staat het gebruik van een recent wachtwoord niet toe"</string>
    <string name="lockpassword_pin_no_sequential_digits" msgid="5843639256988031272">"Een oplopende, aflopende of herhaalde reeks cijfers is niet toegestaan"</string>
    <string name="lockpassword_confirm_label" msgid="560897521093566777">"Bevestigen"</string>
    <string name="lockpassword_clear_label" msgid="311359833434539894">"Wissen"</string>
    <string name="lockpassword_credential_changed" msgid="5934778179732392028">"Schermvergrendeling is al gewijzigd. Probeer het opnieuw met de nieuwe schermvergrendeling."</string>
    <string name="lockpattern_tutorial_cancel_label" msgid="775215267818384016">"Annuleren"</string>
    <string name="lockpattern_tutorial_continue_label" msgid="1329049481210689408">"Volgende"</string>
    <string name="manage_device_admin" msgid="1044620606203916275">"Apps voor apparaatbeheer"</string>
    <string name="number_of_device_admins_none" msgid="152926922020437312">"Geen actieve apps"</string>
    <string name="number_of_device_admins" msgid="3402909995362162876">"{count,plural, =1{# actieve app}other{# actieve apps}}"</string>
    <string name="manage_trust_agents" msgid="6410149930029992356">"Trust agents"</string>
    <string name="disabled_because_no_backup_security" msgid="4998095356607488854">"Stel voor gebruik eerst een schermvergrendeling in"</string>
    <string name="manage_trust_agents_summary" msgid="6423843123607674286">"Geen"</string>
    <string name="manage_trust_agents_summary_on" msgid="3302574418419446146">"{count,plural, =1{1 actieve trust agent}other{# actieve trust agents}}"</string>
    <string name="bluetooth_settings" msgid="2967239493428695171">"Bluetooth"</string>
    <string name="bluetooth_settings_title" msgid="2642029095769509647">"Bluetooth"</string>
    <string name="bluetooth_pairing_request" msgid="7762990650683525640">"Koppelen met <xliff:g id="DEVICE_NAME">%1$s</xliff:g>?"</string>
    <string name="bluetooth_pairing_group_late_bonding" msgid="5310869364570266209">"Voeg een nieuw lid toe aan de bestaande gecoördineerde set"</string>
    <string name="bluetooth_pairing_key_msg" msgid="1329835708475701761">"Bluetooth-koppelingscode"</string>
    <string name="bluetooth_enter_passkey_msg" msgid="5806420933599368592">"Typ de koppelingscode en druk op Return of Enter"</string>
    <string name="bluetooth_enable_alphanumeric_pin" msgid="7256286571636950635">"Pincode bevat letters of symbolen"</string>
    <string name="bluetooth_pin_values_hint" msgid="2753202519050044670">"Meestal 0000 of 1234"</string>
    <string name="bluetooth_pin_values_hint_16_digits" msgid="5603928271430883558">"Moet 16 cijfers zijn"</string>
    <string name="bluetooth_enter_pin_other_device" msgid="6737778699899780717">"Je moet deze pincode wellicht ook opgeven op het andere apparaat."</string>
    <string name="bluetooth_enter_passkey_other_device" msgid="8270426446247344709">"Je moet deze toegangscode wellicht ook opgeven op het andere apparaat."</string>
    <string name="bluetooth_paring_group_msg" msgid="4609515924670823316">"Bevestigen om te koppelen met de gecoördineerde set"</string>
    <string name="bluetooth_pairing_shares_phonebook" msgid="4329325125260724843">"Toegang geven tot je contacten en gespreksgeschiedenis"</string>
    <string name="bluetooth_error_title" msgid="2284738188253690278"></string>
    <string name="bluetooth_connecting_error_message" msgid="3941893154784152112">"Kan geen verbinding maken met <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="bluetooth_preference_found_media_devices" msgid="830061195998352840">"Beschikbare apparaten"</string>
    <string name="bluetooth_device_context_connect" msgid="4913860372216815855">"Verbinden"</string>
    <string name="bluetooth_device_context_disconnect" msgid="4464167389972513232">"Verbinding verbreken"</string>
    <string name="bluetooth_device_context_pair_connect" msgid="2406032703622371826">"Koppelen en verbinden"</string>
    <string name="bluetooth_empty_list_bluetooth_off" msgid="316627049372961941">"Als bluetooth aanstaat, kan je apparaat communiceren met andere bluetooth-apparaten in de buurt."</string>
    <string name="bluetooth_scanning_on_info_message" msgid="786648535600075223">"Als bluetooth aanstaat, kan je apparaat communiceren met andere bluetooth-apparaten in de buurt.\n\nApps en services kunnen nog steeds op elk moment naar apparaten in de buurt scannen om de apparaatfunctionaliteit te verbeteren, zelfs als bluetooth uitstaat. Dit kan worden gebruikt om bijvoorbeeld locatiegebaseerde functies en services te verbeteren. Je kunt dit wijzigen in de instellingen voor bluetooth-scannen."</string>
    <string name="bluetooth_scan_change" msgid="1744636222637390367">"Wijzigen"</string>
    <string name="device_details_title" msgid="1155622417516195481">"Apparaatgegevens"</string>
    <string name="bluetooth_device_keyboard_settings_preference_title" msgid="3411693160917620519">"Toetsenbordinstellingen"</string>
    <string name="bluetooth_device_mac_address" msgid="4873325074786732703">"Bluetooth-adres van je apparaat: <xliff:g id="ADDRESS">%1$s</xliff:g>"</string>
    <string name="bluetooth_multuple_devices_mac_address" msgid="4974301550897923376">"Bluetooth-adres van apparaat:\n<xliff:g id="ADDRESS">%1$s</xliff:g>"</string>
    <string name="bluetooth_unpair_dialog_title" msgid="6943633443716052995">"Apparaat vergeten?"</string>
    <string name="remove_association_button" msgid="5004208145998061135">"Koppeling verwijderen"</string>
    <string name="bluetooth_companion_app_remove_association_dialog_title" msgid="1344518601377991897">"App ontkoppelen?"</string>
    <string name="bluetooth_companion_app_body" msgid="8442643629075687761">"De app <xliff:g id="APP_NAME">%1$s</xliff:g> maakt geen verbinding meer met je <xliff:g id="DEVICE_NAME">%2$s</xliff:g>"</string>
    <string name="device_details_leaudio_toggle_summary" msgid="7684848254433230809">"Experimenteel. Verbetert audiokwaliteit."</string>
    <string name="bluetooth_unpair_dialog_forget_confirm_button" msgid="9184489424930549015">"Apparaat vergeten"</string>
    <string name="bluetooth_companion_app_remove_association_confirm_button" msgid="76323555527926915">"App ontkoppelen"</string>
    <string name="bluetooth_max_connected_audio_devices_string" msgid="3114156958598821615">"Maximum aantal verbonden bluetooth-audioapparaten"</string>
    <string name="bluetooth_max_connected_audio_devices_dialog_title" msgid="4056811727247312473">"Selecteer het maximum aantal verbonden Bluetooth-audioapparaten"</string>
    <string name="nfc_stack_debuglog_title" msgid="2926748386805740609">"Foutopsporingslogboek voor NFC-stack"</string>
    <string name="nfc_stack_debuglog_summary" msgid="7333205107551132121">"Verhoog registratieniveau voor NFC-stack"</string>
    <string name="nfc_verbose_vendor_log_title" msgid="5554505631122964628">"Uitgebreid NFC-leverancierslogboek voor foutopsporing"</string>
    <string name="nfc_verbose_vendor_log_summary" msgid="3049128322855928507">"Neem aanvullende apparaatspecifieke leverancierslogboeken op in bugrapporten (deze kunnen privé-informatie bevatten)"</string>
    <string name="nfc_snoop_log_title" msgid="1576197495976952388">"Niet-gefilterd NFC NCI-logbestand"</string>
    <string name="nfc_snoop_log_summary" msgid="3988383328800163180">"Leg gedetailleerde NFC-pakketten vast (deze kunnen privé-informatie bevatten)"</string>
    <string name="nfc_reboot_dialog_title" msgid="2033983438635768169">"Apparaat opnieuw opstarten?"</string>
    <string name="nfc_reboot_dialog_message" msgid="4929353168157966992">"Gedetailleerde NFC-logboekregistratie is alleen bedoeld voor ontwikkelingsdoeleinden. Aanvullende NFC-gegevens worden opgenomen in bugrapporten. Deze kunnen privé-informatie bevatten. Start je apparaat opnieuw op om deze instelling te wijzigen."</string>
    <string name="nfc_reboot_dialog_confirm" msgid="4769763632008584567">"Opnieuw opstarten"</string>
    <string name="wifi_display_settings_title" msgid="6451625615274960175">"Casten"</string>
    <string name="keywords_wifi_display_settings" msgid="5753883229564422679">"mirroren"</string>
    <string name="wifi_display_enable_menu_item" msgid="7391841780777318134">"Draadloze weergave aanzetten"</string>
    <string name="wifi_display_no_devices_found" msgid="7904877793677102805">"Geen apparaten in de buurt gevonden."</string>
    <string name="wifi_display_status_connecting" msgid="530880182560077334">"Verbinding maken"</string>
    <string name="wifi_display_status_connected" msgid="2189925211258519539">"Verbonden"</string>
    <string name="wifi_display_status_in_use" msgid="5904009697167947449">"In gebruik"</string>
    <string name="wifi_display_status_not_available" msgid="8463750208946968594">"Niet beschikbaar"</string>
    <string name="wifi_display_options_title" msgid="7584326966240865043">"Opties voor draadloze weergave"</string>
    <string name="wifi_display_options_forget" msgid="3140558691112356024">"Vergeten"</string>
    <string name="wifi_display_options_done" msgid="7608851767701954020">"Klaar"</string>
    <string name="wifi_display_options_name" msgid="8181334945680312228">"Naam"</string>
    <string name="wifi_band_24ghz" msgid="7322286660245127384">"2,4 GHz"</string>
    <string name="wifi_band_5ghz" msgid="7995204987245404797">"5 GHz"</string>
    <string name="wifi_band_6ghz" msgid="8166833829829455339">"6 GHz"</string>
    <string name="wifi_sign_in_button_text" msgid="8483892122845654850">"Inloggen"</string>
    <string name="wifi_venue_website_button_text" msgid="7749360432667175030">"Site openen"</string>
    <string name="wifi_time_remaining" msgid="8503606272869846170">"Nog <xliff:g id="REMAINING_TIME">%1$s</xliff:g>"</string>
    <string name="wifi_expiry_time" msgid="5419758551129267624">"Verloopt op <xliff:g id="EXPIRY_TIME">%1$s</xliff:g>"</string>
    <string name="tx_link_speed" msgid="3071955184703668113">"<xliff:g id="TRANSMIT_LINK_SPEED">%1$d</xliff:g> Mbps"</string>
    <string name="rx_link_speed" msgid="6292229178855567783">"<xliff:g id="RECEIVE_LINK_SPEED">%1$d</xliff:g> Mbps"</string>
    <string name="link_speed" msgid="931786745741016446">"<xliff:g id="LINK_SPEED">%1$d</xliff:g> Mbps"</string>
    <string name="wifi_ask_enable" msgid="6860056048266810769">"<xliff:g id="REQUESTER">%s</xliff:g> wil wifi aanzetten"</string>
    <string name="wifi_ask_disable" msgid="1663208096020309639">"<xliff:g id="REQUESTER">%s</xliff:g> wil wifi uitzetten"</string>
    <string name="art_verifier_for_debuggable_title" msgid="1926445785190030479">"Bytecode verifiëren van apps met foutopsporing"</string>
    <string name="art_verifier_for_debuggable_summary" msgid="4802875841862652879">"Sta ART toe de bytecode te verifiëren voor apps waarop foutopsporing kan worden toegepast"</string>
    <string name="show_refresh_rate" msgid="5742688821872354973">"Vernieuwingssnelheid tonen"</string>
    <string name="show_refresh_rate_summary" msgid="3558118122374609663">"Toon huidige vernieuwingssnelheid van scherm"</string>
    <string name="nfc_quick_toggle_title" msgid="3607620705230351666">"NFC"</string>
    <string name="nfc_secure_settings_title" msgid="4906958426927741485">"Apparaatontgrendeling vereisen voor NFC"</string>
    <string name="android_beam_settings_title" msgid="2797963824490671295">"Android Beam"</string>
    <string name="android_beam_on_summary" msgid="6067720758437490896">"Klaar om app-content te verzenden via NFC"</string>
    <string name="android_beam_off_summary" msgid="5693961375631325042">"Uit"</string>
    <string name="nfc_disabled_summary" msgid="8737797364522502351">"Niet beschikbaar omdat NFC uitstaat"</string>
    <string name="android_beam_explained" msgid="5684416131846701256">"Als deze functie aanstaat, kun je app-content naar een ander NFC-apparaat beamen door de apparaten bij elkaar te houden. Je kunt bijvoorbeeld webpagina\'s, YouTube-video\'s, contacten en meer beamen.\n\nHoud de apparaten bij elkaar (meestal met de achterkanten tegen elkaar aan) en tik op je scherm. De app bepaalt wat er wordt gebeamd."</string>
    <string name="wifi_settings" msgid="8313301946393559700">"Wifi"</string>
    <string name="wifi_settings_primary_switch_title" msgid="628360786662947258">"Wifi gebruiken"</string>
    <string name="wifi_settings_category" msgid="3523464780563778321">"Wifi-instellingen"</string>
    <string name="wifi_select_network" msgid="6692897876718813259">"Wifi selecteren"</string>
    <string name="wifi_starting" msgid="6147022683967506341">"Wifi aanzetten…"</string>
    <string name="wifi_stopping" msgid="4471699665741299711">"Wifi uitzetten…"</string>
    <string name="wifi_error" msgid="4903954145386086899">"Fout"</string>
    <string name="wifi_sap_no_channel_error" msgid="2126487622024749402">"5 GHz-band niet beschikbaar in dit land"</string>
    <string name="wifi_in_airplane_mode" msgid="1235412508135267981">"In vliegtuigmodus"</string>
    <string name="wifi_notify_open_networks" msgid="2610323626246818961">"Melding voor openbare netwerken tonen"</string>
    <string name="wifi_notify_open_networks_summary" msgid="191058832201741013">"Laat weten als er een netwerk van hoge kwaliteit beschikbaar is"</string>
    <string name="wifi_wakeup" msgid="3834327315861781611">"Wifi automatisch aanzetten"</string>
    <string name="wifi_wakeup_summary" msgid="5778059083790221465">"Wifi wordt opnieuw aangezet in de buurt van opgeslagen netwerken van hoge kwaliteit, zoals je thuisnetwerk"</string>
    <string name="wifi_wakeup_summary_no_location" msgid="681323616606485096">"Niet beschikbaar omdat locatietoegang uitstaat. Zet de "<annotation id="link">"locatietoegang"</annotation>" aan."</string>
    <string name="wifi_install_credentials" msgid="5192903644606839972">"Certificaten installeren"</string>
    <string name="wifi_scan_notify_text" msgid="7163137260385995873">"Apps en services kunnen gewoon wifi-netwerken detecteren, zelfs als wifi uitstaat, om de locatienauwkeurigheid te verbeteren. Dit kan worden gebruikt om bijvoorbeeld locatiegebaseerde functies en services te verbeteren. Je kunt dit wijzigen in de <xliff:g id="LINK_BEGIN_0">LINK_BEGIN</xliff:g>instellingen voor wifi-scannen<xliff:g id="LINK_END_1">LINK_END</xliff:g>."</string>
    <string name="wifi_scan_notify_text_scanning_off" msgid="7439201783168213149">"Zet wifi-scannen aan via de <xliff:g id="LINK_BEGIN_0">LINK_BEGIN</xliff:g>instellingen voor wifi-scannen<xliff:g id="LINK_END_1">LINK_END</xliff:g> om de locatienauwkeurigheid te verbeteren."</string>
    <string name="wifi_cellular_data_fallback_title" msgid="2844653839490977040">"Automatisch overschakelen naar mobiele data"</string>
    <string name="wifi_cellular_data_fallback_summary" msgid="7039944853033554386">"Mobiele data gebruiken als er geen internettoegang via wifi is. Er kunnen kosten voor datagebruik in rekening worden gebracht."</string>
    <string name="wifi_add_network" msgid="4178564862173751181">"Netwerk toevoegen"</string>
    <string name="wifi_configure_settings_preference_title" msgid="2536725796700696566">"Wifi-voorkeuren"</string>
    <string name="wifi_configure_settings_preference_summary_wakeup_on" msgid="7822368955551467382">"Wifi wordt automatisch opnieuw aangezet"</string>
    <string name="wifi_configure_settings_preference_summary_wakeup_off" msgid="5710203586018223864">"Wifi wordt niet automatisch opnieuw aangezet"</string>
    <string name="wifi_menu_p2p" msgid="5234165837732940385">"Wifi Direct"</string>
    <string name="wifi_empty_list_wifi_off" msgid="7697422506708419298">"Zet wifi aan om beschikbare netwerken te zien."</string>
    <string name="wifi_empty_list_wifi_on" msgid="2448010040478321376">"Netwerken zoeken…"</string>
    <string name="wifi_empty_list_user_restricted" msgid="454861411536708709">"Je hebt geen rechten om het wifi-netwerk te wijzigen."</string>
    <string name="wifi_settings_scanning_required_title" msgid="1088663325396007484">"Wifi-scannen aanzetten?"</string>
    <string name="wifi_settings_scanning_required_summary" msgid="4770243653675416569">"Als je wifi automatisch wilt aanzetten, moet je eerst wifi-scannen aanzetten."</string>
    <string name="wifi_settings_scanning_required_info" msgid="1473411566072565789">"Met wifi-scannen sta je apps en services toe altijd te scannen naar wifi-netwerken in de buurt, zelfs als wifi uitstaat. Dit kan worden gebruikt om bijvoorbeeld locatiegebaseerde functies en services te verbeteren."</string>
    <string name="wifi_settings_scanning_required_turn_on" msgid="1112223196123955447">"Aanzetten"</string>
    <string name="wifi_settings_scanning_required_enabled" msgid="4721729158927146365">"Wifi-scannen aangezet"</string>
    <string name="wifi_show_advanced" msgid="2969378109942071741">"Geavanceerde opties"</string>
    <string name="wifi_advanced_toggle_description" msgid="7299179796727934885">"Dropdownmenu \'Geavanceerde opties\'"</string>
    <string name="wifi_advanced_toggle_description_collapsed" msgid="3615140699129928913">"uitvouwen"</string>
    <string name="wifi_ssid" msgid="2713062130735103151">"Netwerknaam"</string>
    <string name="wifi_ssid_hint" msgid="1940577553241083524">"Geef de SSID op"</string>
    <string name="wifi_security" msgid="9095934643631406913">"Beveiliging"</string>
    <string name="wifi_hidden_network" msgid="6466834025375485596">"Verborgen netwerk"</string>
    <string name="wifi_hidden_network_warning" msgid="3937433813754746158">"Als je router geen netwerk-id uitzendt maar je in de toekomst verbinding wilt maken met de router, kun je het netwerk instellen als verborgen.\n\nDit kan een beveiligingsrisico vormen omdat je telefoon regelmatig een signaal uitzendt om het netwerk te vinden.\n\nDe instellingen van je router worden niet gewijzigd als je het netwerk instelt op verborgen."</string>
    <string name="wifi_signal" msgid="4442182285304271424">"Signaalsterkte"</string>
    <string name="wifi_status" msgid="5349199188871002778">"Status"</string>
    <string name="tx_wifi_speed" msgid="2368986629172050673">"Linksnelheid voor verzenden"</string>
    <string name="rx_wifi_speed" msgid="5167966079215111232">"Linksnelheid voor ontvangen"</string>
    <string name="wifi_speed" msgid="6562147734565434513">"Linksnelheid"</string>
    <string name="wifi_frequency" msgid="3120998420184702834">"Frequentie"</string>
    <string name="wifi_ip_address" msgid="8903577251845268209">"IP-adres"</string>
    <string name="passpoint_label" msgid="6513669696739302866">"Opgeslagen via"</string>
    <string name="passpoint_content" msgid="5219226173518418335">"Inloggegevens voor <xliff:g id="NAME">%1$s</xliff:g>"</string>
    <string name="wifi_eap_method" msgid="3776009521349381742">"EAP-methode"</string>
    <string name="please_select_phase2" msgid="577633852089847142">"Phase 2-verificatie"</string>
    <string name="wifi_eap_ca_cert" msgid="8033404008276298886">"CA-certificaat"</string>
    <string name="wifi_eap_min_tls_ver" msgid="174023604103299457">"Minimale TLS-versie"</string>
    <string name="wifi_eap_ocsp" msgid="8713933962516871238">"Online certificaatstatus"</string>
    <string name="wifi_eap_domain" msgid="8304301470752333203">"Domein"</string>
    <string name="wifi_eap_user_cert" msgid="3569182430929173220">"Gebruikerscertificaat"</string>
    <string name="wifi_eap_identity" msgid="3629406902174137028">"Identiteit"</string>
    <string name="wifi_eap_anonymous" msgid="8630332141751267000">"Anonieme identiteit"</string>
    <string name="wifi_password" msgid="1458802324849513755">"Wachtwoord"</string>
    <string name="wifi_show_password" msgid="6865993988238157923">"Wachtwoord tonen"</string>
    <string name="wifi_ap_choose_2G" msgid="1436802195991542016">"2,4-GHz-frequentieband"</string>
    <string name="wifi_ap_prefer_5G" msgid="2520628479818369902">"Voorkeur voor 5-GHz-frequentieband"</string>
    <string name="wifi_ip_settings" msgid="6420498748726599133">"IP-instellingen"</string>
    <string name="wifi_privacy_settings" msgid="3283946009000725698">"Privacy"</string>
    <string name="wifi_subscription" msgid="4432423938285430113">"Abonnement"</string>
    <string name="wifi_subscription_summary" msgid="18802471063384598">"Abonnement bekijken of wijzigen"</string>
    <string name="wifi_privacy_settings_ephemeral_summary" msgid="8502084692297249372">"Willekeurig MAC-adres"</string>
    <string name="wifi_dpp_add_device_to_network" msgid="6141246783457722976">"Apparaat toevoegen"</string>
    <string name="wifi_dpp_center_qr_code" msgid="5270782275746178104">"Centreer de QR-code hieronder om het apparaat toe te voegen aan <xliff:g id="SSID">%1$s</xliff:g>"</string>
    <string name="wifi_dpp_scan_qr_code" msgid="3543923817779444434">"QR-code scannen"</string>
    <string name="wifi_dpp_scan_qr_code_join_network" msgid="969985020363459133">"Centreer de onderstaande QR-code om verbinding te maken met <xliff:g id="SSID">%1$s</xliff:g>"</string>
    <string name="wifi_dpp_scan_qr_code_join_unknown_network" msgid="3180020429793614145">"Scan een QR-code om verbinding te maken met wifi"</string>
    <string name="wifi_dpp_share_wifi" msgid="2431744447544057866">"Wifi delen"</string>
    <string name="wifi_dpp_scan_qr_code_with_another_device" msgid="6967364080214325016">"Scan deze QR-code met een ander apparaat om deel te nemen aan <xliff:g id="SSID">%1$s</xliff:g>"</string>
    <string name="wifi_dpp_scan_open_network_qr_code_with_another_device" msgid="5398619697898444311">"Scan deze QR-code om verbinding te maken met \'<xliff:g id="SSID">%1$s</xliff:g>\'"</string>
    <string name="wifi_dpp_failure_authentication_or_configuration" msgid="847551626830740204">"Probeer het nog eens. Als het probleem zich blijft voordoen, neem je contact op met de fabrikant van het apparaat."</string>
    <string name="wifi_dpp_failure_not_compatible" msgid="4453775826337805825">"Er is iets misgegaan"</string>
    <string name="wifi_dpp_failure_timeout" msgid="7902971341771145564">"Zorg dat het apparaat is aangesloten en opgeladen en aanstaat"</string>
    <string name="wifi_dpp_failure_generic" msgid="6559442892600448442">"Zorg dat het apparaat is aangesloten en opgeladen en aanstaat. Als het probleem aanhoudt, neem je contact op met de fabrikant van het apparaat."</string>
    <string name="wifi_dpp_failure_not_supported" msgid="2908961523550486480">"\'<xliff:g id="SSID">%1$s</xliff:g>\' toevoegen is niet mogelijk op dit apparaat"</string>
    <string name="wifi_dpp_failure_cannot_find_network" msgid="8519567801353014036">"Zet het apparaat dichter bij je wifi-toegangspunt/-router"</string>
    <string name="wifi_dpp_failure_enrollee_authentication" msgid="7008840843663520852">"Controleer het wachtwoord en probeer het opnieuw"</string>
    <string name="wifi_dpp_failure_enrollee_rejected_configuration" msgid="982310033782652478">"Neem contact op met de fabrikant van het apparaat"</string>
    <string name="wifi_dpp_check_connection_try_again" msgid="6118892932595974823">"Controleer de verbinding en probeer het opnieuw"</string>
    <string name="wifi_dpp_choose_network" msgid="3987007684129341427">"Netwerk kiezen"</string>
    <string name="wifi_dpp_choose_network_to_connect_device" msgid="4321618376432197593">"Kies een netwerk om je apparaat te verbinden"</string>
    <string name="wifi_dpp_add_device_to_wifi" msgid="5170095438763569255">"Dit apparaat toevoegen aan \'<xliff:g id="SSID">%1$s</xliff:g>\'?"</string>
    <string name="wifi_dpp_wifi_shared_with_device" msgid="4484366631307204949">"Wifi gedeeld met apparaat"</string>
    <string name="wifi_dpp_add_another_device" msgid="3307575293580739604">"Een ander apparaat toevoegen"</string>
    <string name="wifi_dpp_choose_different_network" msgid="8963625819804792157">"Ander netwerk kiezen"</string>
    <string name="wifi_dpp_could_not_add_device" msgid="6865710911186601933">"Kan apparaat niet toevoegen"</string>
    <string name="wifi_dpp_device_found" msgid="633646744759830603">"Apparaat gevonden"</string>
    <string name="wifi_dpp_sharing_wifi_with_this_device" msgid="7250369936882080107">"Wifi delen met dit apparaat…"</string>
    <string name="wifi_dpp_connecting" msgid="2312769193202897589">"Verbinden…"</string>
    <string name="wifi_dpp_share_hotspot" msgid="6186452780604755316">"Hotspot delen"</string>
    <string name="wifi_dpp_lockscreen_title" msgid="4231438175617953652">"Verifiëren dat jij het bent"</string>
    <string name="wifi_dpp_wifi_password" msgid="4992986319806934381">"Wifi-wachtwoord: <xliff:g id="PASSWORD">%1$s</xliff:g>"</string>
    <string name="wifi_dpp_hotspot_password" msgid="688464342650820420">"Wachtwoord hotspot: <xliff:g id="PASSWORD">%1$s</xliff:g>"</string>
    <string name="wifi_auto_connect_title" msgid="1890342051674657892">"Automatisch verbinding maken"</string>
    <string name="wifi_auto_connect_summary" msgid="1707702705345670370">"Sta verbinding met dit netwerk toe indien binnen bereik"</string>
    <string name="wifi_dpp_add_device" msgid="8695656122114721335">"Apparaat toevoegen"</string>
    <string name="wifi_dpp_connect_network_using_qr_code" msgid="6975258007798254937">"Gebruik een QR-code om een apparaat aan dit netwerk toe te voegen"</string>
    <string name="wifi_dpp_qr_code_is_not_valid_format" msgid="5190689503019328279">"QR-code heeft geen geldige indeling"</string>
    <string name="retry" msgid="7542103800274026915">"Opnieuw proberen"</string>
    <string name="wifi_shared" msgid="8850748923537589782">"Delen met andere apparaatgebruikers"</string>
    <string name="wifi_unchanged" msgid="8026045290856150191">"(ongewijzigd)"</string>
    <string name="wifi_unspecified" msgid="4561964943472312208">"Maak een keuze"</string>
    <string name="wifi_multiple_cert_added" msgid="2151019652853383776">"(Meerdere certificaten toegevoegd)"</string>
    <string name="wifi_use_system_certs" msgid="5587866698144996931">"Gebruik systeemcertificaten"</string>
    <string name="wifi_do_not_provide_eap_user_cert" msgid="6336636553673065145">"Niet leveren"</string>
    <string name="wifi_trust_on_first_use" msgid="7488431582505858774">"Vertrouwen bij eerste gebruik"</string>
    <string name="wifi_ssid_too_long" msgid="5961719058705013875">"Netwerknaam is te lang."</string>
    <string name="wifi_no_domain_warning" msgid="1452133316532366772">"Je moet een domein opgeven."</string>
    <string name="wifi_no_user_cert_warning" msgid="8466376918835248956">"Certificaat vereist."</string>
    <string name="wifi_scan_always_turnon_message" msgid="2165909441512029921">"Om de locatieprecisie te verbeteren en voor andere doeleinden, wil <xliff:g id="APP_NAME">%1$s</xliff:g> de netwerkscan aanzetten, zelfs als wifi uitstaat.\n\nDit toestaan voor alle apps die willen scannen?"</string>
    <string name="wifi_scan_always_turn_on_message_unknown" msgid="4903345360745717385">"Ter verbetering van locatienauwkeurigheid en voor andere doeleinden wil een onbekende app de netwerkscan aanzetten, zelfs als wifi uitstaat.\n\nDit toestaan voor alle apps die willen scannen?"</string>
    <string name="wifi_scan_always_confirm_allow" msgid="4154200627800959777">"Toestaan"</string>
    <string name="wifi_scan_always_confirm_deny" msgid="6997087934558839256">"Weigeren"</string>
    <string name="no_internet_access_text" msgid="3611993143350310936">"Dit netwerk heeft geen internettoegang. Verbonden blijven?"</string>
    <string name="partial_connectivity_text" msgid="8874614799723694554">"Sommige apps en services werken mogelijk niet vanwege de beperkte connectiviteit. Toch gebruiken?"</string>
    <string name="no_internet_access_remember" msgid="5113610157731269258">"Niet meer vragen voor dit netwerk"</string>
    <string name="lost_internet_access_title" msgid="9032463989950384698">"Wifi heeft geen verbinding met internet"</string>
    <string name="lost_internet_access_text" msgid="1535911323549496789">"Je kunt overschakelen naar het mobiele netwerk wanneer er geen goede wifi-verbinding is. Er kunnen kosten voor datagebruik in rekening worden gebracht."</string>
    <string name="lost_internet_access_switch" msgid="7935665847081706202">"Overschakelen naar mobiel"</string>
    <string name="lost_internet_access_cancel" msgid="1981171269794585284">"Wifi blijven gebruiken"</string>
    <string name="lost_internet_access_persist" msgid="6813604557672782197">"Nooit meer tonen"</string>
    <string name="wifi_connect" msgid="2481467560349907397">"Verbinden"</string>
    <string name="wifi_turned_on_message" msgid="8069855406962662881">"Wifi staat aan"</string>
    <string name="wifi_connected_to_message" msgid="8976048616505112896">"Verbonden met <xliff:g id="NETWORK_NAME">%1$s</xliff:g>"</string>
    <string name="wifi_connecting_to_message" msgid="3153205024060064551">"Verbinding maken met <xliff:g id="NETWORK_NAME">%1$s</xliff:g>"</string>
    <string name="wifi_connecting" msgid="7450277833386859724">"Verbinden…"</string>
    <string name="wifi_failed_connect_message" msgid="8538000546604347894">"Kan geen verbinding maken met het netwerk"</string>
    <string name="wifi_not_in_range_message" msgid="3885327464037574739">"Netwerk is niet binnen bereik"</string>
    <string name="wifi_forget" msgid="3485573280364015620">"Vergeten"</string>
    <string name="wifi_modify" msgid="5127926476383659412">"Aanpassen"</string>
    <string name="wifi_failed_forget_message" msgid="8272732599235525880">"Vergeten van netwerk is mislukt"</string>
    <string name="wifi_save" msgid="2312643132472226807">"Opslaan"</string>
    <string name="wifi_failed_save_message" msgid="1830279872341387120">"Opslaan van netwerk is mislukt"</string>
    <string name="wifi_cancel" msgid="6698897376888935410">"Annuleren"</string>
    <string name="wifi_forget_dialog_title" msgid="4363829200968563164">"Netwerk vergeten?"</string>
    <string name="wifi_saved_access_points_summary" msgid="6637163320524940353">"{count,plural, =1{1 netwerk}other{# netwerken}}"</string>
    <string name="wifi_saved_passpoint_access_points_summary" msgid="8939933724918673785">"{count,plural, =1{1 abonnement}other{# abonnementen}}"</string>
    <string name="wifi_saved_all_access_points_summary" msgid="2335870101156113858">"{count,plural, =1{1 netwerk en abonnement}other{# netwerken en abonnementen}}"</string>
    <string name="wifi_advanced_ssid_title" msgid="1561437650193980185">"SSID"</string>
    <string name="wifi_advanced_device_mac_address_title" msgid="6155800851233164411">"MAC-adres van apparaat"</string>
    <string name="wifi_advanced_randomized_mac_address_title" msgid="3930671320234553088">"Willekeurig MAC-adres"</string>
    <string name="wifi_advanced_randomized_mac_address_disconnected_title" msgid="2755843130417523727">"Willekeurig herschikt MAC-adres (laatst gebruikt)"</string>
    <string name="wifi_details_title" msgid="222735438574597493">"Netwerk­gegevens"</string>
    <string name="wifi_details_subnet_mask" msgid="1619151769276260512">"Subnetmasker"</string>
    <string name="wifi_type_title" msgid="2174893488722015838">"Type"</string>
    <string name="wifi_details_dns" msgid="273231528073312579">"DNS"</string>
    <string name="wifi_details_ipv6_address_header" msgid="1913151339341722443">"IPv6-adressen"</string>
    <string name="wifi_saved_access_points_label" msgid="5691340724310548151">"Opgeslagen netwerken"</string>
    <string name="wifi_subscribed_access_points_tab" msgid="7224061396195667208">"Abonnementen"</string>
    <string name="wifi_saved_other_networks_tab" msgid="7942647415716557293">"Andere netwerken"</string>
    <string name="wifi_ip_settings_invalid_ip_address" msgid="3622891107865052307">"Voer een geldig IP-adres in."</string>
    <string name="wifi_ip_settings_invalid_gateway" msgid="1174931247370931239">"Voer een geldig gateway-adres in."</string>
    <string name="wifi_ip_settings_invalid_dns" msgid="1757402215999845975">"Voer een geldig DNS-adres in."</string>
    <string name="wifi_ip_settings_invalid_network_prefix_length" msgid="5980808986926987299">"Typ een netwerkprefix van 0-32 tekens."</string>
    <string name="wifi_dns1" msgid="6764769531843748514">"DNS 1 (tenzij overschreven door privé-DNS)"</string>
    <string name="wifi_dns2" msgid="7273133202625326148">"DNS 2 (tenzij overschreven door privé-DNS)"</string>
    <string name="wifi_gateway" msgid="3699227808616416759">"Gateway"</string>
    <string name="wifi_network_prefix_length" msgid="1003365439352276622">"Lengte van netwerkprefix"</string>
    <string name="wifi_p2p_settings_title" msgid="1689918226469221870">"Wifi Direct"</string>
    <string name="wifi_p2p_menu_search" msgid="8383306178784876840">"Apparaten zoeken"</string>
    <string name="wifi_p2p_menu_searching" msgid="3428767661028761100">"Zoeken…"</string>
    <string name="wifi_p2p_menu_rename" msgid="7059994112737743336">"Naam van apparaat wijzigen"</string>
    <string name="wifi_p2p_peer_devices" msgid="5158559154640283546">"Peer-apparaten"</string>
    <string name="wifi_p2p_remembered_groups" msgid="5497007770930525695">"Onthouden groepen"</string>
    <string name="wifi_p2p_failed_connect_message" msgid="6767831720507440027">"Kan geen verbinding maken."</string>
    <string name="wifi_p2p_failed_rename_message" msgid="1317434386267376606">"Kan naam van apparaat niet wijzigen."</string>
    <string name="wifi_p2p_disconnect_title" msgid="96361896458072463">"Ontkoppelen?"</string>
    <string name="wifi_p2p_disconnect_message" msgid="1208761239498807208">"Als je de verbinding verbreekt, wordt je verbinding met <xliff:g id="PEER_NAME">%1$s</xliff:g> beëindigd."</string>
    <string name="wifi_p2p_disconnect_multiple_message" msgid="4490648217799144078">"Als je de verbinding verbreekt, wordt je verbinding met <xliff:g id="PEER_NAME">%1$s</xliff:g> en <xliff:g id="PEER_COUNT">%2$s</xliff:g> andere apparaten beëindigd."</string>
    <string name="wifi_p2p_cancel_connect_title" msgid="8476985132989357041">"Uitnodiging annuleren?"</string>
    <string name="wifi_p2p_cancel_connect_message" msgid="2409074184473879809">"Wil je de uitnodiging voor verbinding met <xliff:g id="PEER_NAME">%1$s</xliff:g> annuleren?"</string>
    <string name="wifi_p2p_delete_group_message" msgid="4880242270742385699">"Deze groep vergeten?"</string>
    <string name="wifi_hotspot_checkbox_text" msgid="1549663436920597006">"Wifi-hotspot"</string>
    <string name="wifi_hotspot_off_subtext" msgid="2751383134504362078">"Internet of content wordt niet gedeeld met andere apparaten"</string>
    <string name="wifi_hotspot_no_password_subtext" msgid="3685689196772398783">"Geen wachtwoord ingesteld"</string>
    <string name="wifi_hotspot_name_title" msgid="6633480190014369846">"Naam hotspot"</string>
    <string name="wifi_hotspot_password_title" msgid="9096340919454296786">"Wachtwoord hotspot"</string>
    <string name="wifi_hotspot_ap_band_title" msgid="560262446129195042">"Frequentieband voor toegangspunt"</string>
    <string name="wifi_hotspot_auto_off_title" msgid="8855711787485504882">"Hotspot automatisch uitzetten"</string>
    <string name="wifi_hotspot_auto_off_summary" msgid="8283656069997871354">"Als er geen apparaten zijn verbonden"</string>
    <string name="wifi_hotspot_maximize_compatibility" msgid="6494125684420024058">"Compatibiliteit uitbreiden"</string>
    <string name="wifi_hotspot_maximize_compatibility_single_ap_summary" msgid="383355687431591441">"Hiermee kunnen andere apparaten deze hotspot vinden. De verbindingssnelheid van de hotspot wordt verlaagd."</string>
    <string name="wifi_hotspot_maximize_compatibility_dual_ap_summary" msgid="3579549223159056533">"Hiermee kunnen andere apparaten deze hotspot vinden. Het batterijgebruik neemt toe"</string>
    <string name="wifi_hotspot_speed_title" msgid="8629448084180512685">"Snelheid en compatibiliteit"</string>
    <string name="wifi_hotspot_speed_summary_2g" msgid="5063438001736234858">"2,4 GHz/Compatibel met de meeste apparaten"</string>
    <string name="wifi_hotspot_speed_summary_5g" msgid="6221158936983135040">"5 GHz/Compatibel met veel apparaten"</string>
    <string name="wifi_hotspot_speed_summary_6g" msgid="8863992901226595544">"6 GHz/Compatibel met weinig apparaten"</string>
    <string name="wifi_hotspot_speed_summary_2g_and_5g" msgid="5931052946168943750">"2,4 GHz en 5 GHz/Compatibel met de meeste apparaten"</string>
    <string name="wifi_hotspot_speed_intro" msgid="6973482196363758925">"Kies een frequentie voor je hotspot. De frequentie is van invloed op de verbindingssnelheid en welke soorten apparaten je hotspot kunnen vinden."</string>
    <string name="wifi_hotspot_speed_category" msgid="5265655850463630286">"Voorkeursfrequentie"</string>
    <string name="wifi_hotspot_speed_2g" msgid="3400600834257664480">"2,4 GHz"</string>
    <string name="wifi_hotspot_speed_2g_summary" msgid="6930273933810520155">"Lagere snelheden. Compatibel met de meeste apparaten."</string>
    <string name="wifi_hotspot_speed_5g" msgid="4058116867148848395">"5 GHz"</string>
    <string name="wifi_hotspot_speed_5g_summary" msgid="562987935924535694">"Hoge snelheden. Compatibel met veel apparaten."</string>
    <string name="wifi_hotspot_speed_2g_5g" msgid="9192756255938408285">"2,4 en 5 GHz"</string>
    <string name="wifi_hotspot_speed_2g_5g_summary" msgid="8104575293617700173">"Hoge snelheden. Deze dualband-hotspot is compatibel met de meeste apparaten."</string>
    <string name="wifi_hotspot_speed_6g" msgid="3787697484862730500">"6 GHz"</string>
    <string name="wifi_hotspot_speed_6g_summary" msgid="8675262219242174548">"Hoogste snelheden. Compatibel met weinig apparaten."</string>
    <string name="wifi_hotspot_speed_summary_unavailable" msgid="7276080644693388756">"Niet beschikbaar in jouw land of regio"</string>
    <string name="wifi_hotspot_speed_footer" msgid="8846939503916795002">"Als je voorkeursfrequentie niet beschikbaar is, kan je hotspot een andere gebruiken. Als je de frequentie wijzigt, kunnen de hotspot-beveiligingsinstellingen veranderen."</string>
    <string name="wifi_hotspot_security_summary_unavailable" msgid="117582979310345853">"Niet beschikbaar met 6 GHz"</string>
    <string name="wifi_hotspot_security_footer" msgid="4608329688744949796">"Als je de frequentie van de hotspot wijzigt, kunnen de beveiligingsinstellingen veranderen"</string>
    <string name="wifi_tether_starting" msgid="8879874184033857814">"Hotspot aanzetten…"</string>
    <string name="wifi_tether_stopping" msgid="4416492968019409188">"Hotspot uitzetten…"</string>
    <string name="wifi_tether_carrier_unsupport_dialog_title" msgid="3089432578433978073">"Tethering niet beschikbaar"</string>
    <string name="wifi_tether_carrier_unsupport_dialog_content" msgid="5920421547607921112">"Neem contact op met je provider voor meer informatie"</string>
    <string name="wifi_tether_enabled_subtext" msgid="5085002421099821056">"<xliff:g id="NETWORK_SSID">%1$s</xliff:g> is actief"</string>
    <string name="wifi_tether_configure_ssid_default" msgid="1709397571393179300">"AndroidHotspot"</string>
    <string name="wifi_add_app_single_network_title" msgid="8911612806204065225">"Dit netwerk opslaan?"</string>
    <string name="wifi_add_app_single_network_saving_summary" msgid="7366337245410388895">"Opslaan…"</string>
    <string name="wifi_add_app_single_network_saved_summary" msgid="7135016314713158289">"Opgeslagen"</string>
    <string name="wifi_add_app_network_save_failed_summary" msgid="7223817782309294652">"Kan niet opslaan. Probeer het opnieuw."</string>
    <string name="wifi_add_app_networks_title" msgid="4384594865433042851">"Netwerken opslaan?"</string>
    <string name="wifi_add_app_networks_saving_summary" msgid="577680250954742033">"<xliff:g id="NUMBER">%d</xliff:g> netwerken opslaan…"</string>
    <string name="wifi_add_app_networks_saved_summary" msgid="1648417628665152905">"Netwerken opgeslagen"</string>
    <string name="wifi_calling_settings_title" msgid="264665264535884440">"Bellen via wifi"</string>
    <string name="wifi_calling_suggestion_title" msgid="4791435106729906727">"Gesprekken uitbreiden met wifi"</string>
    <string name="wifi_calling_suggestion_summary" msgid="5413024679599742858">"Bellen via wifi aanzetten om dekking uit te breiden"</string>
    <string name="wifi_calling_mode_title" msgid="5145896168360825619">"Voorkeur voor bellen"</string>
    <string name="wifi_calling_mode_dialog_title" msgid="944146521898592440">"Voorkeur voor bellen"</string>
    <string name="wifi_calling_roaming_mode_title" msgid="7703305991991520773">"Roamingvoorkeur"</string>
    <!-- no translation found for wifi_calling_roaming_mode_summary (6061631305384464179) -->
    <skip />
    <string name="wifi_calling_roaming_mode_dialog_title" msgid="5382466713784067077">"Roamingvoorkeur"</string>
  <string-array name="wifi_calling_mode_choices_v2">
    <item msgid="6052353275413974742">"Wifi"</item>
    <item msgid="8622872038388687383">"Mobiel"</item>
    <item msgid="3027927219952052398">"Alleen wifi"</item>
  </string-array>
  <string-array name="wifi_calling_mode_choices_v2_without_wifi_only">
    <item msgid="588620799769664461">"Wifi"</item>
    <item msgid="7566603075659706590">"Mobiel"</item>
  </string-array>
    <string name="wifi_calling_mode_wifi_preferred_summary" msgid="3240387177966098351">"Mobiel netwerk gebruiken als er geen wifi beschikbaar is"</string>
    <string name="wifi_calling_mode_cellular_preferred_summary" msgid="3746914244902314059">"Gebruik wifi als er geen mobiel netwerk beschikbaar is"</string>
    <string name="wifi_calling_mode_wifi_only_summary" msgid="3155660680014892641">"Bellen via wifi. Zonder wifi-signaal wordt het gesprek beëindigd."</string>
    <string name="wifi_calling_off_explanation" msgid="6295526820826322895">"Als bellen via wifi aanstaat, kan je telefoon gesprekken doorschakelen via wifi-netwerken of het netwerk van je provider, afhankelijk van je voorkeur en welk signaal sterker is. Voordat je deze functie aanzet, neem je contact met je provider op over de kosten en andere details.<xliff:g id="ADDITIONAL_TEXT">%1$s</xliff:g>"</string>
    <string name="wifi_calling_off_explanation_2" msgid="3487475808574416183"></string>
    <string name="emergency_address_title" msgid="8102786488994263815">"Adres bij noodgevallen"</string>
    <string name="emergency_address_summary" msgid="3022628750270626473">"Dit adres wordt gebruikt als je locatie wanneer je het noodnummer belt via wifi"</string>
    <string name="private_dns_help_message" msgid="851221502063782306"><annotation id="url">"Meer informatie"</annotation>" over privé-DNS-functies"</string>
    <string name="private_dns_mode_on" msgid="8878679071975375696">"Aan"</string>
    <string name="wifi_calling_settings_activation_instructions" msgid="3936067355828542266">"Bellen via wifi activeren"</string>
    <string name="wifi_calling_turn_on" msgid="7687886259199428823">"Bellen via wifi aanzetten"</string>
    <string name="wifi_disconnected_from" msgid="5249576734324159708">"Verbinding met <xliff:g id="SSID">%1$s</xliff:g> verbroken"</string>
    <string name="sound_settings" msgid="7622986039384531304">"Geluid en trillen"</string>
    <string name="account_settings" msgid="255404935489127404">"Accounts"</string>
    <string name="accessibility_category_work" msgid="5133894487353964944">"Werkprofielaccounts - <xliff:g id="MANAGED_BY">%s</xliff:g>"</string>
    <string name="accessibility_category_personal" msgid="2228088849803484780">"Persoonlijke profielaccounts"</string>
    <string name="accessibility_category_clone" msgid="7893383448944567885">"Profielaccounts klonen"</string>
    <string name="accessibility_work_account_title" msgid="7622485151217943839">"Werkaccount - <xliff:g id="MANAGED_BY">%s</xliff:g>"</string>
    <string name="accessibility_personal_account_title" msgid="8535265881509557013">"Persoonlijk account - <xliff:g id="MANAGED_BY">%s</xliff:g>"</string>
    <string name="search_settings" msgid="7573686516434589771">"Zoeken"</string>
    <string name="display_settings" msgid="7197750639709493852">"Scherm"</string>
    <string name="accelerometer_title" msgid="7745991950833748909">"Scherm automatisch draaien"</string>
    <string name="auto_rotate_option_off" msgid="2788096269396290731">"Uit"</string>
    <string name="auto_rotate_option_on" msgid="5776678230808498171">"Aan"</string>
    <string name="auto_rotate_option_face_based" msgid="3438645484087953174">"Aan: op basis van gezicht"</string>
    <string name="auto_rotate_switch_face_based" msgid="9116123744601564320">"Gezichtsherkenning"</string>
    <string name="auto_rotate_link_a11y" msgid="5146188567212233286">"Meer informatie over automatisch draaien"</string>
    <string name="screen_resolution_title" msgid="2690518693139811486">"Schermresolutie"</string>
    <string name="screen_resolution_option_high" msgid="2617496842852992853">"Hoge resolutie"</string>
    <string name="screen_resolution_option_full" msgid="2694003735219114186">"Volledige resolutie"</string>
    <string name="screen_resolution_footer" msgid="6772341522952795647">"Volledige resolutie gebruikt meer batterijlading. Als je de resolutie wijzigt, worden sommige apps misschien opnieuw opgestart."</string>
    <string name="screen_resolution_selected_a11y" msgid="6158451180032224977">"Geselecteerd"</string>
    <string name="color_mode_title" msgid="8666690832113906028">"Kleuren"</string>
    <string name="color_mode_option_natural" msgid="6192875655101283303">"Natuurlijk"</string>
    <string name="color_mode_option_boosted" msgid="4698797857766774289">"Versterkt"</string>
    <string name="color_mode_option_saturated" msgid="3413853820158447300">"Verzadigd"</string>
    <string name="color_mode_option_automatic" msgid="2281217686509980870">"Aanpasbaar"</string>
    <string name="brightness" msgid="6216871641021779698">"Helderheidsniveau"</string>
    <string name="auto_brightness_title" msgid="4239324728760986697">"Aanpasbare helderheid"</string>
    <string name="auto_brightness_description" msgid="6807117118142381193">"Je schermhelderheid wordt automatisch aangepast aan je omgeving en je activiteiten. Je kunt de schuifregelaar handmatig verplaatsen zodat Aanpasbare helderheid je voorkeuren leert kennen."</string>
    <string name="auto_brightness_summary_on" msgid="2748088951224387004">"Aan"</string>
    <string name="auto_brightness_summary_off" msgid="8077066192887677956">"Uit"</string>
    <string name="display_white_balance_title" msgid="2624544323029364713">"Witbalans van scherm"</string>
    <string name="display_white_balance_summary" msgid="7625456704950209050"></string>
    <string name="peak_refresh_rate_title" msgid="1878771412897140903">"Smooth Display"</string>
    <string name="peak_refresh_rate_summary" msgid="3627278682437562787">"Hiermee wordt de vernieuwingssnelheid automatisch verhoogd van 60 naar <xliff:g id="ID_1">%1$s</xliff:g> Hz voor bepaalde content. Het batterijgebruik neemt toe."</string>
    <string name="force_high_refresh_rate_toggle" msgid="3325789621928312050">"Piekvernieuwingssnelheid afdwingen"</string>
    <string name="force_high_refresh_rate_desc" msgid="7794566420873814875">"De hoogste vernieuwingssnelheid voor verbeterde responsiviteit voor aanraking en animatiekwaliteit. Het batterijgebruik neemt toe."</string>
    <string name="adaptive_sleep_title" msgid="2987961991423539233">"Schermaandacht"</string>
    <string name="adaptive_sleep_title_no_permission" msgid="1719759921214237016">"Toegang tot camera nodig"</string>
    <string name="adaptive_sleep_summary_no_permission" msgid="5822591289468803691">"Cameratoegang is vereist voor schermaandacht. Tik om de rechten voor personalisatieservices voor apparaat te beheren."</string>
    <string name="adaptive_sleep_manage_permission_button" msgid="1404510197847664846">"Rechten beheren"</string>
    <string name="adaptive_sleep_description" msgid="1835321775327187860">"Deze functie voorkomt dat je scherm uitgaat als je ernaar kijkt"</string>
    <string name="adaptive_sleep_privacy" msgid="7664570136417980556">"Schermaandacht gebruikt de camera aan de voorzijde om te zien of er iemand naar het scherm kijkt. Deze functie werkt op het apparaat zelf: de afbeeldingen worden nooit opgeslagen of naar Google verzonden."</string>
    <string name="adaptive_sleep_contextual_slice_title" msgid="7467588613212629758">"Schermaandacht aanzetten"</string>
    <string name="adaptive_sleep_contextual_slice_summary" msgid="2993867044745446094">"Houd het scherm aan als je ernaar kijkt"</string>
    <string name="auto_rotate_camera_lock_title" msgid="5369003176695105872">"Camera is vergrendeld"</string>
    <string name="auto_rotate_camera_lock_summary" msgid="5699491516271544672">"De camera moet zijn ontgrendeld voor gezichtsherkenning"</string>
    <string name="adaptive_sleep_camera_lock_summary" msgid="8417541183603618098">"Camera moet zijn ontgrendeld voor schermaandacht"</string>
    <string name="auto_rotate_summary_no_permission" msgid="1025061139746254554">"Voor gezichtsherkenning is cameratoegang nodig. Tik om de rechten voor personalisatieservices voor het apparaat te beheren."</string>
    <string name="auto_rotate_manage_permission_button" msgid="2591146085906382385">"Rechten beheren"</string>
    <string name="night_display_title" msgid="8532432776487216581">"Nachtverlichting"</string>
    <string name="night_display_text" msgid="4789324042428095383">"Met Nachtverlichting krijgt je scherm een oranje tint. Zo kun je het scherm beter zien bij weinig licht en val je makkelijker in slaap."</string>
    <string name="night_display_auto_mode_title" msgid="5869128421470824381">"Schema"</string>
    <string name="night_display_auto_mode_never" msgid="2721729920187175239">"Geen"</string>
    <string name="night_display_auto_mode_custom" msgid="3938791496034086916">"Op aangepaste tijd"</string>
    <string name="night_display_auto_mode_twilight" msgid="4291855156158833997">"Van zonsondergang tot zonsopkomst"</string>
    <string name="night_display_start_time_title" msgid="2611541851596977786">"Begintijd"</string>
    <string name="night_display_end_time_title" msgid="5243112480391192111">"Eindtijd"</string>
    <string name="night_display_temperature_title" msgid="857248782470764263">"Intensiteit"</string>
    <string name="night_display_summary_off_auto_mode_never" msgid="7406899634169354142">"Wordt nooit automatisch aangezet"</string>
    <string name="night_display_summary_off_auto_mode_custom" msgid="6667008039080687931">"Wordt automatisch aangezet om <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="night_display_summary_off_auto_mode_twilight" msgid="3669132200611324994">"Wordt automatisch aangezet bij zonsondergang"</string>
    <string name="night_display_summary_on_auto_mode_never" msgid="832333009202889350">"Wordt nooit automatisch uitgezet"</string>
    <string name="night_display_summary_on_auto_mode_custom" msgid="2096677025343425755">"Wordt automatisch uitgezet om <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="night_display_summary_on_auto_mode_twilight" msgid="8070517472000680361">"Wordt automatisch uitgezet bij zonsopkomst"</string>
    <string name="night_display_not_currently_on" msgid="6600205753103093827">"Nachtverlichting staat uit"</string>
    <string name="twilight_mode_location_off_dialog_message" msgid="4559150893687124801">"Apparaatlocatie is vereist om de tijden voor zonsondergang en zonsopkomst te bepalen"</string>
    <string name="twilight_mode_launch_location" msgid="7799112373591153956">"Locatie-instellingen"</string>
    <string name="dark_ui_activation_on_manual" msgid="1541006734577325234">"Nu aanzetten"</string>
    <string name="dark_ui_activation_off_manual" msgid="2395333709291250065">"Nu uitzetten"</string>
    <string name="dark_ui_activation_on_auto" msgid="4824339634784765049">"Aanzetten tot zonsopkomst"</string>
    <string name="dark_ui_activation_off_auto" msgid="9136717444658505208">"Uitzetten tot zonsondergang"</string>
    <string name="dark_ui_title" msgid="3373976268671557416">"Donkere modus"</string>
    <string name="dark_ui_auto_mode_title" msgid="9027528859262295099">"Schema"</string>
    <string name="dark_ui_auto_mode_never" msgid="3980412582267787662">"Geen"</string>
    <string name="dark_ui_auto_mode_auto" msgid="6658909029498623375">"Van zonsondergang tot zonsopkomst"</string>
    <string name="dark_ui_auto_mode_custom" msgid="3800138185265182170">"Op aangepaste tijd"</string>
    <string name="dark_ui_auto_mode_custom_bedtime" msgid="8465023741946439266">"Gaat aan als het bedtijd is"</string>
    <string name="dark_ui_status_title" msgid="3505119141437774329">"Status"</string>
    <string name="dark_ui_summary_off_auto_mode_never" msgid="5828281549475697398">"Wordt nooit automatisch aangezet"</string>
    <string name="dark_ui_summary_off_auto_mode_auto" msgid="6766831395970887213">"Wordt automatisch aangezet bij zonsondergang"</string>
    <string name="dark_ui_summary_off_auto_mode_custom" msgid="1345906088326708376">"Wordt automatisch aangezet om <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="dark_ui_summary_off_auto_mode_custom_bedtime" msgid="7759826673214624622">"Gaat automatisch aan als het bedtijd is"</string>
    <string name="dark_ui_summary_on_auto_mode_never" msgid="2468597062391435521">"Wordt nooit automatisch uitgezet"</string>
    <string name="dark_ui_summary_on_auto_mode_auto" msgid="5553376115092648636">"Wordt automatisch uitgezet bij zonsopkomst"</string>
    <string name="dark_ui_summary_on_auto_mode_custom" msgid="2526935680241734784">"Wordt automatisch uitgezet om <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="dark_ui_summary_on_auto_mode_custom_bedtime" msgid="1976993025762551246">"Gaat na bedtijd automatisch uit"</string>
    <string name="dark_ui_text" msgid="4392646155331126666">"Het donkere thema gebruikt een zwarte achtergrond zodat je batterij langer meegaat op sommige schermen. Schema\'s voor het donkere thema worden pas aangezet als je scherm uitstaat."</string>
    <string name="dark_ui_bedtime_footer_summary" msgid="5576501833145170581">"Het donkere thema volgt op dit moment je schema voor de Bedtijdstand"</string>
    <string name="dark_ui_bedtime_footer_action" msgid="1493095487994054339">"Instellingen voor bedtijdstand"</string>
    <string name="screen_timeout" msgid="7709947617767439410">"Time-out voor scherm"</string>
    <string name="screen_timeout_summary" msgid="5558778019594643427">"Na <xliff:g id="TIMEOUT_DESCRIPTION">%1$s</xliff:g> inactiviteit"</string>
    <string name="screen_timeout_summary_not_set" msgid="5107680774964178875">"Niet ingesteld"</string>
    <string name="wallpaper_settings_title" msgid="5635129851136006383">"Achtergrond"</string>
    <string name="style_and_wallpaper_settings_title" msgid="2232042809407308946">"Achtergrond en stijl"</string>
    <string name="wallpaper_dashboard_summary" msgid="2324472863981057118">"Startscherm, vergrendelscherm"</string>
    <string name="wallpaper_suggestion_title" msgid="3812842717939877330">"Achtergrond wijzigen"</string>
    <string name="wallpaper_suggestion_summary" msgid="9077061486716754784">"Je scherm personaliseren"</string>
    <string name="wallpaper_settings_fragment_title" msgid="8445963841717633149">"Achtergrond kiezen uit"</string>
    <string name="style_suggestion_title" msgid="1213747484782364775">"Je telefoon aanpassen"</string>
    <string name="style_suggestion_summary" msgid="4271131877800968159">"Probeer verschillende stijlen, achtergronden en meer"</string>
    <string name="screensaver_settings_title" msgid="3588535639672365395">"Screensaver"</string>
    <string name="keywords_screensaver" msgid="7249337959432229172">"screensaver"</string>
    <string name="screensaver_settings_when_to_dream_bedtime" msgid="3279310576803094771">"Niet beschikbaar omdat de bedtijdstand aanstaat"</string>
    <string name="screensaver_settings_toggle_title" msgid="6194634226897244374">"Screensaver gebruiken"</string>
    <string name="screensaver_settings_summary_either_long" msgid="371949139331896271">"Tijdens opladen of docken"</string>
    <string name="screensaver_settings_summary_dock_and_charging" msgid="8485905100159376156">"Tijdens gedockt opladen"</string>
    <string name="screensaver_settings_summary_sleep" msgid="6555922932643037432">"Tijdens het opladen"</string>
    <string name="screensaver_settings_summary_dock" msgid="6997766385189369733">"Tijdens het docken"</string>
    <string name="screensaver_settings_summary_never" msgid="4988141393040918450">"Nooit"</string>
    <string name="screensaver_settings_summary_on" msgid="4210827304351483645">"Aan / <xliff:g id="SCREEN_SAVER">%1$s</xliff:g>"</string>
    <string name="screensaver_settings_summary_off" msgid="8720357504939106923">"Uit"</string>
    <string name="screensaver_settings_when_to_dream" msgid="8145025742428940520">"Wanneer starten"</string>
    <string name="lift_to_wake_title" msgid="8994218158737714046">"Optillen om te activeren"</string>
    <string name="ambient_display_screen_title" msgid="8615947016991429325">"Inactief scherm"</string>
    <string name="ambient_display_category_triggers" msgid="1216640141609270011">"Wanneer tonen"</string>
    <string name="doze_title" msgid="1523090408230862316">"Scherm activeren voor meldingen"</string>
    <string name="doze_summary" msgid="8252867381522942804">"Als het scherm donker is, gaat het aan bij nieuwe meldingen"</string>
    <string name="doze_always_on_title" msgid="7326245192352868477">"Altijd tijd en info tonen"</string>
    <string name="doze_always_on_summary" msgid="509097829739647852">"Hoger batterijgebruik"</string>
    <string name="force_bold_text" msgid="4620929631102086716">"Vetgedrukte tekst"</string>
    <string name="title_font_size" msgid="570613010306330622">"Lettergrootte"</string>
    <string name="short_summary_font_size" msgid="8444689613442419978">"Maak de tekst groter of kleiner"</string>
    <string name="sim_lock_settings" msgid="7331982427303002613">"Instellingen voor simlock"</string>
    <string name="sim_lock_settings_category" msgid="6475255139493877786">"Simlock"</string>
    <string name="sim_pin_toggle" msgid="6814489621760857328">"Simkaart vergrendelen"</string>
    <string name="sim_pin_change" msgid="5978881209990507379">"Pincode simkaart wijzigen"</string>
    <string name="sim_enter_pin" msgid="8235202785516053253">"Sim-pincode"</string>
    <string name="sim_enable_sim_lock" msgid="6486354334679225748">"Simkaart vergrendelen"</string>
    <string name="sim_disable_sim_lock" msgid="6939439812841857306">"Simkaart ontgrendelen"</string>
    <string name="sim_enter_old" msgid="6882545610939674813">"Oude sim-pincode"</string>
    <string name="sim_enter_new" msgid="9010947802784561582">"Nieuwe sim-pincode"</string>
    <string name="sim_reenter_new" msgid="6131418271490374263">"Typ nieuwe pincode opnieuw"</string>
    <string name="sim_change_pin" msgid="1104103818545005448">"Sim-pincode"</string>
    <string name="sim_invalid_pin_hint" msgid="3376397829969578877">"Geef een pincode van 4 tot 8 cijfers op"</string>
    <string name="sim_pins_dont_match" msgid="1540348773896609260">"Pincodes komen niet overeen"</string>
    <string name="sim_change_succeeded" msgid="3516905528149069739">"Sim-pincode gewijzigd"</string>
    <string name="sim_pin_disable_failed" msgid="8719890393181032837">"Kan pincode niet uitzetten."</string>
    <string name="sim_pin_enable_failed" msgid="5156513975085380284">"Kan pincode niet aanzetten."</string>
    <string name="sim_enter_ok" msgid="3401715290135787531">"OK"</string>
    <string name="sim_enter_cancel" msgid="2001859323724961490">"Annuleren"</string>
    <string name="sim_change_data_title" msgid="4663239438584588847">"<xliff:g id="CARRIER">%1$s</xliff:g> gebruiken voor mobiele data?"</string>
    <string name="sim_change_data_message" msgid="3046178883369645132">"Je gebruikt <xliff:g id="CARRIER2_0">%2$s</xliff:g> voor mobiele data. Als je overschakelt naar <xliff:g id="CARRIER1">%1$s</xliff:g>, wordt <xliff:g id="CARRIER2_1">%2$s</xliff:g> niet meer gebruikt voor mobiele data."</string>
    <string name="sim_change_data_ok" msgid="4922114750417276560">"<xliff:g id="CARRIER">%1$s</xliff:g> gebruiken"</string>
    <string name="sim_preferred_title" msgid="8850185380445309835">"Voorkeurssimkaart updaten?"</string>
    <string name="sim_preferred_message" msgid="6004009449266648351">"<xliff:g id="NEW_SIM">%1$s</xliff:g> is de enige simkaart in je apparaat. Wil je deze simkaart gebruiken voor mobiele data, gesprekken en sms-berichten?"</string>
    <string name="enable_auto_data_switch_dialog_title" msgid="3563043560556718994">"Dekking mobiele data verbeteren?"</string>
    <string name="enable_auto_data_switch_dialog_message" msgid="5777287241521946883">"Toestaan dat je apparaat voor mobiele data automatisch overschakelt naar <xliff:g id="BACKUP_CARRIER">%1$s</xliff:g> als de beschikbaarheid beter is."</string>
    <string name="auto_data_switch_dialog_managed_profile_warning" msgid="6839438290079866605">\n\n"Gesprekken, berichten en netwerkverkeer kunnen zichtbaar zijn voor je organisatie."</string>
    <string name="wrong_pin_code_pukked" msgid="3414172752791445033">"Onjuiste pincode voor simkaart. Je moet nu contact opnemen met je provider om je apparaat te ontgrendelen."</string>
    <string name="wrong_pin_code" msgid="8124222991071607958">"{count,plural, =1{Onjuiste pincode voor simkaart. Je hebt nog # poging over voordat je contact met je provider moet opnemen om je apparaat te laten ontgrendelen.}other{Onjuiste pincode voor simkaart. Je hebt nog # pogingen over.}}"</string>
    <string name="wrong_pin_code_one" msgid="6924852214263071441">"Onjuiste pincode voor simkaart. Je hebt nog één poging over voordat je contact met je provider moet opnemen om je apparaat te ontgrendelen."</string>
    <string name="pin_failed" msgid="3726505565797352255">"Bewerking met pincode voor simkaart mislukt."</string>
    <string name="system_update_settings_list_item_title" msgid="3398346836439366350">"Systeemupdates"</string>
    <string name="system_update_settings_list_item_summary" msgid="6703752298349642101"></string>
    <string name="firmware_version" msgid="1606901586501447275">"Android-versie"</string>
    <string name="security_patch" msgid="4071756145347865382">"Android-beveiligingsupdate"</string>
    <string name="model_info" msgid="8997566254717810904">"Model"</string>
    <string name="hardware_revision" msgid="3454709180861965025">"Hardwareversie"</string>
    <string name="fcc_equipment_id" msgid="6596668314025646129">"Apparatuur-ID"</string>
    <string name="baseband_version" msgid="2600182227599835857">"Smalbandversie"</string>
    <string name="kernel_version" msgid="3513538109381366881">"Kernel-versie"</string>
    <string name="build_number" msgid="9009733242117579826">"Buildnummer"</string>
    <string name="module_version" msgid="1787518340082046658">"Google Play-systeemupdate"</string>
    <string name="battery_info" msgid="7873528123969546728">"Batterij-informatie"</string>
    <string name="device_info_not_available" msgid="4804474466616712326">"Niet beschikbaar"</string>
    <string name="storage_settings" msgid="7472188817781592677">"Opslagruimte"</string>
    <string name="storage_settings_for_app" msgid="229425418984637483">"Opslag en cache"</string>
    <string name="storage_settings_title" msgid="486118156723194815">"Instellingen voor opslag"</string>
    <string name="status_eid" msgid="7532406028683438634">"EID"</string>
    <string name="eid_multi_sim" msgid="9087924808336397804">"EID (simkaartsleuf <xliff:g id="EID_SLOT_ID">%1$d</xliff:g>)"</string>
    <string name="imei_multi_sim" msgid="9001570420423929507">"IMEI (simkaartsleuf <xliff:g id="IMEI_SLOT_ID">%1$d</xliff:g>)"</string>
    <string name="imei_multi_sim_primary" msgid="7914653040843734282">"IMEI (simkaartsleuf <xliff:g id="IMEI_SLOT_ID_PRIMARY">%1$d</xliff:g>) (primair)"</string>
    <string name="view_saved_network" msgid="1232387673095080910">"Kies opgeslagen netwerk om te bekijken"</string>
    <string name="status_min_number" msgid="4492899165438225714">"MIN"</string>
    <string name="status_msid_number" msgid="3871958248824595774">"MSID"</string>
    <string name="status_prl_version" msgid="9002131357502714281">"PRL-versie"</string>
    <string name="meid_multi_sim" msgid="1460689549266621286">"MEID (simkaartsleuf <xliff:g id="MEID_SLOT_ID">%1$d</xliff:g>)"</string>
    <string name="meid_multi_sim_primary" msgid="8921262417580407201">"MEID (simkaartsleuf <xliff:g id="MEID_SLOT_ID_PRIMARY">%1$d</xliff:g>) (primair)"</string>
    <string name="scanning_status_text_on" msgid="3846571210578042940">"Aan"</string>
    <string name="scanning_status_text_off" msgid="4002352668313705132">"Uit"</string>
    <string name="status_meid_number" msgid="6040380838489162650">"MEID"</string>
    <string name="status_icc_id" msgid="7995690631650006970">"ICCID"</string>
    <string name="status_data_network_type" msgid="3689772955330665876">"Type mobiele-datanetwerk"</string>
    <string name="status_voice_network_type" msgid="8700356693062562884">"Type mobiele-telefoonnetwerk"</string>
    <string name="status_latest_area_info" msgid="8288488664620741734">"Operatorinfo"</string>
    <string name="status_data_state" msgid="525196229491743487">"Status mobiel netwerk"</string>
    <string name="status_esim_id" msgid="5158916796362809133">"EID"</string>
    <string name="status_service_state" msgid="1693424422121058791">"Servicestatus"</string>
    <string name="status_signal_strength" msgid="7644525712554444359">"Signaalsterkte"</string>
    <string name="status_roaming" msgid="1253597174715663778">"Roaming"</string>
    <string name="status_operator" msgid="4335640583552058491">"Netwerk"</string>
    <string name="status_wifi_mac_address" msgid="4447611754614388914">"MAC-adres voor wifi"</string>
    <string name="status_device_wifi_mac_address" msgid="1896121694334176494">"MAC-adres voor wifi van apparaat"</string>
    <string name="status_bt_address" msgid="6919660304578476547">"Bluetooth-adres"</string>
    <string name="status_serial_number" msgid="9060064164331466789">"Serienummer"</string>
    <string name="status_up_time" msgid="1274778533719495438">"Bedrijfstijd"</string>
    <string name="battery_manufacture_date" msgid="7139426520156833987">"Productiedatum"</string>
    <string name="battery_first_use_date" msgid="3157207331722711317">"Datum van eerste gebruik"</string>
    <string name="battery_cycle_count" msgid="2912949283386571900">"Aantal cyclussen"</string>
    <!-- no translation found for battery_cycle_count_not_available (2426584515665184664) -->
    <skip />
    <string name="memory_calculating_size" msgid="3898240439798661242">"Berekenen…"</string>
    <string name="storage_menu_rename" msgid="8549835371429159336">"Naam wijzigen"</string>
    <string name="storage_menu_mount" msgid="4760531872302820569">"Koppelen"</string>
    <string name="storage_menu_unmount" msgid="8171552487742912282">"Uitwerpen"</string>
    <string name="storage_menu_format" msgid="8903698999905354146">"SD-kaart formatteren voor draagbare opslag"</string>
    <string name="storage_menu_format_button" msgid="7623565190643699626">"Kaart formatteren"</string>
    <string name="storage_menu_format_public" msgid="5567214442727034630">"Formatteren als draagbaar"</string>
    <string name="storage_menu_format_option" msgid="4886059624052908432">"Formatteren"</string>
    <string name="storage_menu_migrate" msgid="2196088149560070193">"Gegevens overzetten"</string>
    <string name="storage_menu_forget" msgid="5154017890033638936">"Vergeten"</string>
    <string name="storage_menu_set_up" msgid="4401074025612064744">"Instellen"</string>
    <string name="storage_menu_free" msgid="616100170298501673">"Ruimte vrijmaken"</string>
    <string name="storage_menu_manage" msgid="7465522758801346408">"Opslagruimte beheren"</string>
    <string name="storage_free_up_space_title" msgid="281047807372131975">"Ruimte vrijmaken"</string>
    <string name="storage_free_up_space_summary" msgid="6650027929735481350">"Ga naar de app Bestanden om ruimte te beheren en vrij te maken"</string>
    <string name="storage_other_users" msgid="7017206190449510992">"Andere gebruikers"</string>
    <string name="storage_size_large" msgid="1155308277890194878">"<xliff:g id="NUMBER">^1</xliff:g>"<small><small>" <xliff:g id="UNIT">^2</xliff:g>"</small></small>""</string>
    <string name="storage_mount_success" msgid="393972242641313135">"<xliff:g id="NAME">%1$s</xliff:g> is gekoppeld"</string>
    <string name="storage_mount_failure" msgid="3667915814876418011">"Kan <xliff:g id="NAME">%1$s</xliff:g> niet koppelen"</string>
    <string name="storage_unmount_success" msgid="6406298575402936148">"<xliff:g id="NAME">%1$s</xliff:g> is veilig uitgeworpen"</string>
    <string name="storage_unmount_failure" msgid="3796912279003790607">"Kan <xliff:g id="NAME">%1$s</xliff:g> niet veilig uitwerpen"</string>
    <string name="storage_rename_title" msgid="5911285992205282312">"Naam van opslag wijzigen"</string>
    <string name="storage_dialog_unmountable" msgid="1761107904296941687">"Deze <xliff:g id="NAME_0">^1</xliff:g> is beschadigd. \n\nAls je de <xliff:g id="NAME_1">^1</xliff:g> wilt gebruiken, moet je deze eerst instellen."</string>
    <string name="storage_internal_format_details" msgid="2399034372813686846">"Je kunt deze SD-kaart formatteren om onder meer foto\'s, video\'s en muziek op te slaan en te openen op andere apparaten. \n\n"<b>"Alle gegevens op deze SD-kaart worden gewist."</b>" \n\n"<b>"Voordat je formatteert"</b>" \n\n"<b>"Maak een back-up van foto\'s en andere media"</b>" \nVerplaats je mediabestanden naar alternatieve opslag op dit apparaat of zet ze over naar een computer via een USB-kabel. \n\n"<b>"Maak een back-up van apps"</b>" \nAlle apps die op deze <xliff:g id="NAME">^1</xliff:g> zijn opgeslagen, worden verwijderd en de bijbehorende gegevens worden gewist. Als je deze apps wilt behouden, verplaats je ze naar alternatieve opslag op dit apparaat."</string>
    <string name="storage_internal_unmount_details" msgid="487689543322907311"><b>"Wanneer je deze <xliff:g id="NAME_0">^1</xliff:g> uitwerpt, werken apps die erop zijn opgeslagen niet meer. Mediabestanden die hierop zijn opgeslagen, zijn pas weer beschikbaar als het opslagapparaat weer wordt geplaatst."</b>" \n\nDe <xliff:g id="NAME_1">^1</xliff:g> is geformatteerd voor gebruik in dit apparaat en werkt niet in andere apparaten."</string>
    <string name="storage_internal_forget_details" msgid="5606507270046186691">"Als je de apps, foto\'s of gegevens op deze <xliff:g id="NAME">^1</xliff:g> wilt gebruiken, plaats je deze opnieuw. \n\nJe kunt er ook voor kiezen dit opslagapparaat te vergeten als het apparaat niet beschikbaar is. \n\nAls je ervoor kiest het apparaat te vergeten, gaat alle gegevens op het apparaat definitief verloren. \n\nJe kunt de apps later opnieuw installeren, maar de op het apparaat opgeslagen app-gegevens gaan verloren."</string>
    <string name="storage_internal_forget_confirm_title" msgid="379238668153099015">"<xliff:g id="NAME">^1</xliff:g> vergeten?"</string>
    <string name="storage_internal_forget_confirm" msgid="5752634604952674123">"Alle apps, foto\'s en gegevens die zijn opgeslagen op deze <xliff:g id="NAME">^1</xliff:g>, gaan definitief verloren."</string>
    <string name="storage_detail_dialog_system" msgid="7461009051858709479">"Systeem bevat bestanden die worden gebruikt voor Android-versie <xliff:g id="VERSION">%s</xliff:g>"</string>
    <string name="storage_wizard_guest" msgid="5813419895687733649">"Gebruikers van de gastmodus kunnen geen SD-kaarten formatteren"</string>
    <string name="storage_wizard_format_progress_title" msgid="9170393018855949774">"<xliff:g id="NAME">^1</xliff:g> formatteren…"</string>
    <string name="storage_wizard_format_progress_body" msgid="1044024044955390417">"Verwijder de <xliff:g id="NAME">^1</xliff:g> niet tijdens het formatteren."</string>
    <string name="storage_wizard_ready_title" msgid="3631022511474086605">"<xliff:g id="NAME">^1</xliff:g> is geformatteerd"</string>
    <string name="storage_wizard_move_confirm_title" msgid="6812469630804101590">"<xliff:g id="APP">^1</xliff:g> verplaatsen"</string>
    <string name="storage_wizard_move_confirm_body" msgid="1713022828842263574">"Je kunt <xliff:g id="APP">^1</xliff:g> en de bijbehorende gegevens snel overzetten naar de <xliff:g id="NAME_0">^2</xliff:g>. Je kunt de app pas weer gebruiken nadat deze volledig is overgezet. \n\nVerwijder de <xliff:g id="NAME_1">^2</xliff:g> niet tijdens het overzetten."</string>
    <string name="storage_wizard_move_unlock" msgid="14651384927767749">"Je moet gebruiker <xliff:g id="APP">^1</xliff:g> ontgrendelen om gegevens te verplaatsen."</string>
    <string name="storage_wizard_move_progress_title" msgid="3912406225614672391">"<xliff:g id="APP">^1</xliff:g> verplaatsen…"</string>
    <string name="storage_wizard_move_progress_body" msgid="2396714553394935094">"Verwijder de <xliff:g id="NAME">^1</xliff:g> niet tijdens het verplaatsen. \n\nDe app <xliff:g id="APP">^2</xliff:g> op dit apparaat is pas weer beschikbaar zodra het verplaatsen is voltooid."</string>
    <string name="storage_wizard_init_v2_title" msgid="2538630338392381113">"Hoe ga je deze <xliff:g id="NAME">^1</xliff:g> gebruiken?"</string>
    <string name="storage_wizard_init_v2_or" msgid="5558706089661158026">"Of"</string>
    <string name="storage_wizard_init_v2_external_title" msgid="2786416384217054112">"SD-kaart formatteren voor draagbare opslag"</string>
    <string name="storage_wizard_init_v2_external_summary" msgid="2002761631147966185">"Sla onder meer foto\'s, video\'s en muziek op en open ze vanaf andere apparaten. &lt;a href=https://support.google.com/android/answer/12153449&gt;Meer informatie over hoe je een SD-kaart instelt&lt;/a&gt;"</string>
    <string name="storage_wizard_init_v2_external_action" msgid="6140058734875839081">"Formatteren"</string>
    <string name="storage_wizard_init_v2_later" msgid="5366815913892609285">"Later instellen"</string>
    <string name="storage_wizard_format_confirm_v2_title" msgid="6294104100437326067">"Deze <xliff:g id="NAME">^1</xliff:g> formatteren?"</string>
    <string name="storage_wizard_format_confirm_v2_body" msgid="635958708974709506">"Deze <xliff:g id="NAME_0">^1</xliff:g> moet worden geformatteerd om apps, bestanden en media op te slaan. \n\nTijdens het formatteren worden alle gegevens op de <xliff:g id="NAME_1">^2</xliff:g> gewist. Maak een back-up op een andere <xliff:g id="NAME_2">^3</xliff:g> of een ander apparaat om te voorkomen dat je de gegevens kwijtraakt."</string>
    <string name="storage_wizard_format_confirm_v2_body_external" msgid="5810296966099830035">"Deze <xliff:g id="NAME_0">^1</xliff:g> moet worden geformatteerd om onder meer foto\'s, video\'s en muziek op te slaan. \n\nTijdens het formatteren wordt bestaande content op de <xliff:g id="NAME_1">^2</xliff:g> gewist. Maak een back-up op een andere <xliff:g id="NAME_2">^3</xliff:g> of een ander apparaat om te voorkomen dat je de content kwijtraakt."</string>
    <string name="storage_wizard_format_confirm_v2_action" msgid="5718254101386377126">"<xliff:g id="NAME">^1</xliff:g> formatteren"</string>
    <string name="storage_wizard_migrate_v2_title" msgid="3471564531564756698">"Content naar <xliff:g id="NAME">^1</xliff:g> verplaatsen?"</string>
    <string name="storage_wizard_migrate_v2_checklist" msgid="2618258869444553060">"Tijdens het overzetten:"</string>
    <string name="storage_wizard_migrate_v2_checklist_media" msgid="5867134681730723744">"verwijder <xliff:g id="NAME">^1</xliff:g> niet"</string>
    <string name="storage_wizard_migrate_v2_checklist_apps" msgid="1882077445750580783">"werken sommige apps niet"</string>
    <string name="storage_wizard_migrate_v2_now" msgid="3341460117088026966">"Content verplaatsen"</string>
    <string name="storage_wizard_migrate_v2_later" msgid="6067756122853315642">"Content later verplaatsen"</string>
    <string name="storage_wizard_migrate_progress_v2_title" msgid="8791318509516968103">"Content verplaatsen…"</string>
    <string name="storage_wizard_slow_v2_title" msgid="3760766921170980221">"Langzame <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_slow_v2_body" msgid="7604252106419016929">"Je kunt deze <xliff:g id="NAME_0">^1</xliff:g> nog steeds gebruiken, maar bewerkingen kunnen lang duren. \n\nApps die zijn opgeslagen op deze <xliff:g id="NAME_1">^2</xliff:g> werken mogelijk niet correct en het kan lang duren voordat content is overgezet. \n\nProbeer het met een snellere <xliff:g id="NAME_2">^3</xliff:g> of gebruik deze <xliff:g id="NAME_3">^4</xliff:g> voor draagbare opslag."</string>
    <string name="storage_wizard_slow_v2_start_over" msgid="1806852287668077536">"Opnieuw beginnen"</string>
    <string name="storage_wizard_slow_v2_continue" msgid="7469713755893007901">"Doorgaan"</string>
    <string name="storage_wizard_ready_v2_external_body" msgid="7688457485389886923">"Je kunt je <xliff:g id="NAME">^1</xliff:g> gebruiken"</string>
    <string name="storage_wizard_ready_v2_internal_body" msgid="3520269956641115883">"Je kunt je <xliff:g id="NAME">^1</xliff:g> gebruiken"</string>
    <string name="storage_wizard_ready_v2_internal_moved_body" msgid="1163588718127651062">"Je kunt je <xliff:g id="NAME">^1</xliff:g> gebruiken"</string>
    <string name="battery_status_title" msgid="4661768220545945771">"Batterijstatus"</string>
    <string name="battery_level_title" msgid="1371765298786083448">"Accuniveau"</string>
    <string name="communal_settings_title" msgid="2845678473945902115">"Gemeenschappelijk"</string>
    <string name="communal_settings_summary" msgid="4923914136953940317">"Gemeenschappelijke instellingen"</string>
    <string name="apn_settings" msgid="4295467389400441299">"APN\'s"</string>
    <string name="apn_edit" msgid="2003683641840248741">"Toegangspunt bewerken"</string>
    <string name="apn_not_set" msgid="8246646433109750293">"Niet ingesteld"</string>
    <string name="apn_not_set_for_mvno" msgid="1141490067313964640">"Niet ingesteld"</string>
    <string name="apn_name" msgid="6677695784108157953">"Naam"</string>
    <string name="apn_apn" msgid="5812828833797458602">"APN"</string>
    <string name="apn_http_proxy" msgid="1052464912365838007">"Proxy"</string>
    <string name="apn_http_port" msgid="9138610639873966046">"Poort"</string>
    <string name="apn_user" msgid="5831763936428279228">"Gebruikersnaam"</string>
    <string name="apn_password" msgid="7435086635953953029">"Wachtwoord"</string>
    <string name="apn_server" msgid="6997704279138388384">"Server"</string>
    <string name="apn_mmsc" msgid="4985570919581927224">"MMSC"</string>
    <string name="apn_mms_proxy" msgid="6592247653258283592">"MMS-proxy"</string>
    <string name="apn_mms_port" msgid="6500563737462966663">"MMS-poort"</string>
    <string name="apn_mcc" msgid="4971414138516074809">"MCC"</string>
    <string name="apn_mnc" msgid="1926382406843447854">"MNC"</string>
    <string name="apn_auth_type" msgid="4234397513494356932">"Verificatietype"</string>
    <string name="apn_type" msgid="1835573305077788773">"APN-type"</string>
    <string name="apn_protocol" msgid="181529867160380010">"APN-protocol"</string>
    <string name="apn_roaming_protocol" msgid="1645131094105362513">"Roamingprotocol voor APN"</string>
    <string name="carrier_enabled" msgid="664074151573150130">"APN aanzetten/uitzetten"</string>
    <string name="carrier_enabled_summaryOn" msgid="5212067975273903381">"APN staat aan"</string>
    <string name="carrier_enabled_summaryOff" msgid="8541959867953738521">"APN staat uit"</string>
    <string name="bearer" msgid="3231443241639159358">"Drager"</string>
    <string name="mvno_type" msgid="4734654257494971247">"MVNO-type"</string>
    <string name="mvno_match_data" msgid="5213193073684321156">"MVNO-waarde"</string>
    <string name="menu_delete" msgid="9199740901584348273">"APN verwijderen"</string>
    <string name="menu_new" msgid="6571230342655509006">"Nieuwe APN"</string>
    <string name="menu_save" msgid="6611465355127483100">"Opslaan"</string>
    <string name="menu_cancel" msgid="1197826697950745335">"Annuleren"</string>
    <string name="error_title" msgid="7158648377702417716"></string>
    <string name="error_name_empty" msgid="1258275899283079142">"Het veld \'Naam\' mag niet leeg zijn."</string>
    <string name="error_apn_empty" msgid="7657491065443746915">"De APN mag niet leeg zijn."</string>
    <string name="error_mcc_not3" msgid="883659545640179094">"MCC-veld moet 3 cijfers bevatten."</string>
    <string name="error_mnc_not23" msgid="7642478711158474918">"MNC-veld moet 2 of 3 cijfers bevatten."</string>
    <string name="error_adding_apn_type" msgid="1324263534991467943">"De provider staat het toevoegen van APN\'s van het type %s niet toe."</string>
    <string name="restore_default_apn" msgid="6596048535642130689">"Standaard-APN-instellingen herstellen."</string>
    <string name="menu_restore" msgid="4310539620115151551">"Standaardinstellingen herstellen"</string>
    <string name="restore_default_apn_completed" msgid="5167505087078340256">"Herstellen van standaard-APN-instellingen voltooid."</string>
    <string name="reset_dashboard_title" msgid="7423200250697886918">"Opties voor resetten"</string>
    <string name="reset_mobile_network_settings_title" msgid="5616713931258506842">"Instellingen mobiel netwerk resetten"</string>
    <string name="reset_mobile_network_settings_desc" msgid="7292636387692165727">"Hiermee reset je alle instellingen voor het mobiele netwerk"</string>
    <string name="reset_mobile_network_settings_confirm_title" msgid="7510965634669511241">"Instellingen mobiel netwerk resetten?"</string>
    <string name="reset_bluetooth_wifi_title" msgid="4113071322344697317">"Bluetooth en wifi resetten"</string>
    <string name="reset_bluetooth_wifi_desc" msgid="4030295669083059711">"Hiermee worden alle wifi- en bluetooth-instellingen gereset. Je kunt deze actie niet ongedaan maken."</string>
    <string name="reset_bluetooth_wifi_button_text" msgid="3974098137045963639">"Resetten"</string>
    <string name="reset_bluetooth_wifi_complete_toast" msgid="5893439291030574365">"Bluetooth en wifi zijn gereset"</string>
    <string name="erase_euicc_data_button" msgid="728078969563311737">"Wissen"</string>
    <string name="reset_esim_title" msgid="4194570573425902754">"E-simkaarten wissen"</string>
    <string name="reset_esim_desc" msgid="3662444090563399131">"Hiermee zeg je geen mobiele abonnementen op. Neem contact op met je provider als je vervangende simkaarten wilt downloaden."</string>
    <string name="reset_network_button_text" msgid="2281476496459610071">"Instellingen resetten"</string>
    <string name="reset_network_final_desc" msgid="5304365082065278425">"Alle netwerkinstellingen resetten? Je kunt deze actie niet ongedaan maken."</string>
    <string name="reset_network_final_desc_esim" msgid="1129251284212847939">"Alle netwerkinstellingen resetten en e-simkaarten wissen? Je kunt deze actie niet ongedaan maken."</string>
    <string name="reset_network_final_button_text" msgid="2433867118414000462">"Instellingen resetten"</string>
    <string name="reset_network_confirm_title" msgid="913014422184481270">"Resetten?"</string>
    <string name="network_reset_not_available" msgid="1966334631394607829">"Netwerk herstellen is niet beschikbaar voor deze gebruiker"</string>
    <string name="reset_network_complete_toast" msgid="1367872474130621115">"Netwerkinstellingen zijn gereset"</string>
    <string name="reset_esim_error_title" msgid="4670073610967959597">"Kan simkaarten niet wissen"</string>
    <string name="reset_esim_error_msg" msgid="7279607120606365250">"Door een fout kunnen e-simkaarten niet worden gewist.\n\nStart je apparaat opnieuw op en probeer het nogmaals."</string>
    <string name="main_clear_title" msgid="277664302144837723">"Alle gegevens wissen (fabrieksinstellingen terugzetten)"</string>
    <string name="main_clear_short_title" msgid="4752094765533020696">"Alle gegevens wissen (fabrieksinstellingen terugzetten)"</string>
    <string name="main_clear_desc_also_erases_external" msgid="3687911419628956693"><li>"Muziek"</li>\n<li>"Foto\'s"</li>\n<li>"Andere gebruikersgegevens"</li></string>
    <string name="main_clear_desc_also_erases_esim" msgid="4553469876411831729"><li>"E-simkaarten"</li></string>
    <string name="main_clear_desc_no_cancel_mobile_plan" msgid="369883568059127035">\n\n"Je mobiele abonnement wordt niet opgezegd."</string>
    <string name="main_clear_final_desc" msgid="5800877928569039580">"Al je persoonlijke informatie en gedownloade apps worden verwijderd. Je kunt deze actie niet ongedaan maken."</string>
    <string name="main_clear_final_desc_esim" msgid="440406836793824969">"Al je persoonlijke informatie wordt verwijderd, waaronder gedownloade apps en simkaarten. Je kunt deze actie niet ongedaan maken."</string>
    <string name="main_clear_confirm_title" msgid="6577071819657853713">"Alle gegevens wissen?"</string>
    <string name="main_clear_not_available" msgid="3433795327146684827">"Fabrieksinstellingen terugzetten is niet beschikbaar voor deze gebruiker"</string>
    <string name="main_clear_progress_title" msgid="7239741132015617719">"Wissen"</string>
    <string name="main_clear_progress_text" msgid="4636695115176327972">"Even geduld…"</string>
    <string name="call_settings_title" msgid="2531072044177194164">"Gespreksinstellingen"</string>
    <string name="call_settings_summary" msgid="8244293779053318053">"Voicemail, gesprekken doorschakelen, wisselgesprek, beller-ID instellen"</string>
    <string name="tether_settings_title_usb" msgid="5926474044238409099">"USB-tethering"</string>
    <string name="tether_settings_title_wifi" msgid="4327056146425282159">"Draagbare hotspot"</string>
    <string name="tether_settings_title_bluetooth" msgid="8878813702520141084">"Bluetooth-tethering"</string>
    <string name="tether_settings_title_usb_bluetooth" msgid="4437274151658505496">"Tethering"</string>
    <string name="tether_settings_title_all" msgid="6807525590937697228">"Hotspot en tethering"</string>
    <string name="tether_settings_summary_hotspot_on_tether_on" msgid="6110241048260139633">"Hotspot aan, tethering"</string>
    <string name="tether_settings_summary_hotspot_on_tether_off" msgid="5057598961245943644">"Hotspot aan"</string>
    <string name="tether_settings_summary_hotspot_off_tether_on" msgid="7181518138494995888">"Tethering"</string>
    <string name="tether_settings_disabled_on_data_saver" msgid="9054069463426952689">"Kan niet tetheren of draagbare hotspots gebruiken terwijl Databesparing aanstaat"</string>
    <string name="tether_settings_summary_hotspot_only" msgid="8529008147731140279">"Alleen hotspot"</string>
    <string name="tether_settings_summary_usb_tethering_only" msgid="6351624505239356221">"Alleen USB"</string>
    <string name="tether_settings_summary_bluetooth_tethering_only" msgid="1451008625343274930">"Alleen bluetooth"</string>
    <string name="tether_settings_summary_ethernet_tethering_only" msgid="3582266687537419309">"Alleen ethernet"</string>
    <string name="tether_settings_summary_hotspot_and_usb" msgid="5999349643653265016">"Hotspot, USB"</string>
    <string name="tether_settings_summary_hotspot_and_bluetooth" msgid="810514646401708557">"Hotspot, bluetooth"</string>
    <string name="tether_settings_summary_hotspot_and_ethernet" msgid="5489192670354277152">"Hotspot, ethernet"</string>
    <string name="tether_settings_summary_usb_and_bluetooth" msgid="1355680331767261967">"USB, bluetooth"</string>
    <string name="tether_settings_summary_usb_and_ethernet" msgid="2195017679820919905">"USB, ethernet"</string>
    <string name="tether_settings_summary_bluetooth_and_ethernet" msgid="1015253926959211012">"Bluetooth, ethernet"</string>
    <string name="tether_settings_summary_hotspot_and_usb_and_bluetooth" msgid="2949043525073791732">"Hotspot, USB, bluetooth"</string>
    <string name="tether_settings_summary_hotspot_and_usb_and_ethernet" msgid="5178946567323581144">"Hotspot, USB, ethernet"</string>
    <string name="tether_settings_summary_hotspot_and_bluetooth_and_ethernet" msgid="4104425838594994441">"Hotspot, bluetooth, ethernet"</string>
    <string name="tether_settings_summary_usb_and_bluetooth_and_ethernet" msgid="5880591133984166550">"USB, bluetooth, ethernet"</string>
    <string name="tether_settings_summary_all" msgid="7565193614882005775">"Hotspot, USB, bluetooth, ethernet"</string>
    <string name="tether_settings_summary_off" msgid="2526164899130351968">"Internet wordt niet gedeeld met andere apparaten"</string>
    <string name="tether_preference_summary_off" msgid="6266799346319794630">"Uit"</string>
    <string name="tethering_interface_options" msgid="7575535888135143650">"Tethering"</string>
    <string name="disable_wifi_hotspot_title" msgid="2167985468585290478">"Wifi-hotspot niet gebruiken"</string>
    <string name="disable_wifi_hotspot_when_usb_on" msgid="220439059794714583">"Internet alleen delen via USB"</string>
    <string name="disable_wifi_hotspot_when_bluetooth_on" msgid="4711723299880116345">"Internet alleen delen via bluetooth"</string>
    <string name="disable_wifi_hotspot_when_ethernet_on" msgid="4123242400542103599">"Internet alleen delen via ethernet"</string>
    <string name="disable_wifi_hotspot_when_usb_and_bluetooth_on" msgid="5258774769658150180">"Internet alleen delen via USB en bluetooth"</string>
    <string name="disable_wifi_hotspot_when_usb_and_ethernet_on" msgid="7126313562907225612">"Internet alleen delen via USB en ethernet"</string>
    <string name="disable_wifi_hotspot_when_bluetooth_and_ethernet_on" msgid="2943464651349235967">"Internet alleen delen via bluetooth en ethernet"</string>
    <string name="disable_wifi_hotspot_when_usb_and_bluetooth_and_ethernet_on" msgid="3934609816834760008">"Internet alleen delen via USB, bluetooth en ethernet"</string>
    <string name="usb_title" msgid="1157283449840612901">"USB"</string>
    <string name="usb_tethering_button_text" msgid="7364633823180913777">"USB-tethering"</string>
    <string name="bluetooth_tether_checkbox_text" msgid="6108398414967813545">"Bluetooth-tethering"</string>
    <string name="ethernet_tether_checkbox_text" msgid="959743110824197356">"Ethernet-tethering"</string>
    <string name="tethering_footer_info" msgid="6782375845587483281">"Gebruik hotspot en tethering om internet aan andere apparaten te leveren via je mobiele dataverbinding. Apps kunnen ook hotspots maken om content te delen met apparaten in de buurt."</string>
    <string name="tethering_footer_info_sta_ap_concurrency" msgid="2079039077487477676">"Gebruik hotspot en tethering om internet aan andere apparaten te leveren via je wifi- of mobiele dataverbinding. Apps kunnen ook hotspots maken om content te delen met apparaten in de buurt."</string>
    <string name="tethering_help_button_text" msgid="2823655011510912001">"Hulp"</string>
    <string name="network_settings_title" msgid="4663717899931613176">"Mobiel netwerk"</string>
    <string name="manage_mobile_plan_title" msgid="5616930513733409064">"Mobiel abonnement"</string>
    <string name="sms_application_title" msgid="4791107002724108809">"Sms-app"</string>
    <string name="sms_change_default_dialog_title" msgid="2343439998715457307">"Sms-app wijzigen?"</string>
    <string name="sms_change_default_dialog_text" msgid="8777606240342982531">"Wil je <xliff:g id="NEW_APP">%1$s</xliff:g> als je sms-app gebruiken in plaats van <xliff:g id="CURRENT_APP">%2$s</xliff:g>?"</string>
    <string name="sms_change_default_no_previous_dialog_text" msgid="6215622785087181275">"Wil je <xliff:g id="NEW_APP">%s</xliff:g> gebruiken als je sms-app?"</string>
    <string name="network_scorer_change_active_dialog_title" msgid="7005220310238618141">"Wifi-assistent wijzigen?"</string>
    <string name="network_scorer_change_active_dialog_text" msgid="7006057749370850706">"<xliff:g id="NEW_APP">%1$s</xliff:g> gebruiken in plaats van <xliff:g id="CURRENT_APP">%2$s</xliff:g> om je netwerkverbindingen te beheren?"</string>
    <string name="network_scorer_change_active_no_previous_dialog_text" msgid="680685773455072321">"<xliff:g id="NEW_APP">%s</xliff:g> gebruiken om je netwerkverbindingen te beheren?"</string>
    <string name="mobile_unknown_sim_operator" msgid="6650422533065760963">"Onbekende simkaartprovider"</string>
    <string name="mobile_no_provisioning_url" msgid="609462719893503773">"<xliff:g id="OPERATOR">%1$s</xliff:g> heeft geen bekende registratiewebsite"</string>
    <string name="mobile_insert_sim_card" msgid="3639245241283948038">"Plaats een simkaart en start het apparaat opnieuw"</string>
    <string name="mobile_connect_to_internet" msgid="8162654404357069060">"Maak verbinding met internet"</string>
    <string name="location_category_recent_location_requests" msgid="2205900488782832082">"Recente locatieverzoeken"</string>
    <string name="managed_profile_location_switch_title" msgid="1265007506385460066">"Locatie voor werkprofiel"</string>
    <string name="location_app_level_permissions" msgid="907206607664629759">"Locatierechten voor apps"</string>
    <string name="location_app_permission_summary_location_off" msgid="2711822936853500335">"Locatie staat uit"</string>
    <string name="location_app_permission_summary_location_on" msgid="7552095451731948984">"{count,plural, =1{# van {total} apps heeft toegang tot de locatie}other{# van {total} apps hebben toegang tot de locatie}}"</string>
    <string name="location_category_recent_location_access" msgid="2558063524482178146">"Recente toegang"</string>
    <string name="location_recent_location_access_see_all" msgid="4203102419355323325">"Alles tonen"</string>
    <string name="location_recent_location_access_view_details" msgid="5803264082558504544">"Details bekijken"</string>
    <string name="location_no_recent_apps" msgid="6814206631456177033">"Er zijn geen apps die je locatie onlangs hebben opgevraagd"</string>
    <string name="location_no_recent_accesses" msgid="6031735777805464247">"Geen apps hebben recent toegang gehad tot je locatie"</string>
    <string name="location_high_battery_use" msgid="4277318891200626524">"Hoog accugebruik"</string>
    <string name="location_low_battery_use" msgid="5218950289737996431">"Laag batterijgebruik"</string>
    <string name="location_scanning_wifi_always_scanning_title" msgid="5004781272733434794">"Wifi-scannen"</string>
    <string name="location_scanning_wifi_always_scanning_description" msgid="6236055656376931306">"Apps en services toestaan altijd te scannen naar wifi-netwerken in de buurt, zelfs als wifi uitstaat. Dit kan worden gebruikt om bijvoorbeeld locatiegebaseerde functies en services te verbeteren."</string>
    <string name="location_scanning_bluetooth_always_scanning_title" msgid="1809309545730215891">"Bluetooth-scannen"</string>
    <string name="location_scanning_bluetooth_always_scanning_description" msgid="5362988856388462841">"Sta apps en services toe altijd te scannen naar apparaten in de buurt, zelfs als bluetooth uitstaat. Dit kan worden gebruikt om bijvoorbeeld locatiegebaseerde functies en services te verbeteren."</string>
    <string name="location_services_preference_title" msgid="604317859531782159">"Locatieservices"</string>
    <string name="location_services_screen_title" msgid="5640002489976602476">"Locatieservices"</string>
    <string name="location_time_zone_detection_toggle_title" msgid="6478751613645015287">"Locatie gebruiken"</string>
    <string name="location_time_zone_detection_status_title" msgid="8903495354385600423">"Kan de tijdzone niet automatisch instellen"</string>
    <string name="location_time_zone_detection_status_summary_degraded_by_settings" msgid="6198939835335841106"></string>
    <string name="location_time_zone_detection_status_summary_blocked_by_settings" msgid="5276280770344278768">"Locatie of locatieservices staan uit"</string>
    <string name="location_time_zone_detection_status_summary_blocked_by_environment" msgid="2279833212923765802"></string>
    <string name="location_time_zone_detection_status_summary_temporarily_unavailable" msgid="6586801403644278967"></string>
    <string name="location_time_zone_detection_location_is_off_dialog_title" msgid="231698690198001146">"Apparaatlocatie nodig"</string>
    <string name="location_time_zone_detection_location_is_off_dialog_message" msgid="5846316326139169523">"Als je je tijdzone wilt instellen, zet je eerst locatie aan en update je daarna de instellingen voor tijdzones"</string>
    <string name="location_time_zone_detection_location_is_off_dialog_ok_button" msgid="2685647335717750297">"Locatie-instellingen"</string>
    <string name="location_time_zone_provider_fix_dialog_ok_button" msgid="9026666001835079126">"Probleem oplossen"</string>
    <string name="location_time_zone_detection_location_is_off_dialog_cancel_button" msgid="3968729678789071154">"Annuleren"</string>
    <string name="location_time_zone_detection_auto_is_off" msgid="6264253990141650280">"Automatische tijdzone staat uit"</string>
    <string name="location_time_zone_detection_not_applicable" msgid="6757964612836952714">"Tijdzonedetectie op basis van locatie staat uit"</string>
    <string name="location_time_zone_detection_not_supported" msgid="3251181656388306501">"Tijdzonedetectie op basis van locatie wordt niet ondersteund"</string>
    <string name="location_time_zone_detection_not_allowed" msgid="8264525161514617051">"Wijzigingen in tijdzonedetectie op basis van locatie zijn niet toegestaan"</string>
    <string name="location_time_zone_detection_auto_is_on" msgid="8797434659844659323">"Locatie kan worden gebruikt om tijdzone in te stellen"</string>
    <string name="about_settings_summary" msgid="4831942939227432513">"Juridische info, status, softwareversie bekijken"</string>
    <string name="legal_information" msgid="7509900979811934843">"Juridische informatie"</string>
    <string name="manual" msgid="3651593989906084868">"Handleiding"</string>
    <string name="regulatory_labels" msgid="5960251403367154270">"Regelgevingslabels"</string>
    <string name="safety_and_regulatory_info" msgid="8285048080439298528">"Handleiding voor veiligheid/regelgeving"</string>
    <string name="copyright_title" msgid="83245306827757857">"Auteursrecht"</string>
    <string name="license_title" msgid="8745742085916617540">"Licentie"</string>
    <string name="module_license_title" msgid="8705484239826702828">"Licenties voor systeemupdates van Google Play"</string>
    <string name="terms_title" msgid="2071742973672326073">"Algemene voorwaarden"</string>
    <string name="webview_license_title" msgid="5832692241345780517">"Systeemlicentie voor WebView"</string>
    <string name="wallpaper_attributions" msgid="4323659759250650736">"Credits voor achtergrond"</string>
    <string name="wallpaper_attributions_values" msgid="987277439026021925">"Providers van satellietbeelden:\n©2014 CNES / Astrium, DigitalGlobe, Bluesky"</string>
    <string name="settings_manual_activity_title" msgid="1682978148920788484">"Handleiding"</string>
    <string name="settings_manual_activity_unavailable" msgid="2514549851682321576">"Er is een probleem bij het laden van de handleiding."</string>
    <string name="settings_license_activity_title" msgid="7832071619364734914">"Licenties van derden"</string>
    <string name="settings_license_activity_unavailable" msgid="9014803774391134570">"Er is een probleem bij het laden van de licenties."</string>
    <string name="settings_license_activity_loading" msgid="1653151990366578827">"Laden..."</string>
    <string name="settings_safetylegal_activity_loading" msgid="1757860124583063395">"Laden..."</string>
    <string name="lockpassword_choose_your_password_header" msgid="2407205113298094824">"Stel een wachtwoord in"</string>
    <string name="lockpassword_choose_your_profile_password_header" msgid="7038997227611893312">"Een werkwachtwoord instellen"</string>
    <string name="lockpassword_choose_your_pin_header" msgid="7754265746504679473">"Stel een pincode in"</string>
    <string name="lockpassword_choose_your_profile_pin_header" msgid="4581749963670819048">"Een werkpincode instellen"</string>
    <string name="lockpassword_choose_your_pattern_header" msgid="5674909390779586252">"Stel een patroon in"</string>
    <string name="lockpassword_choose_your_pattern_description" msgid="6808109256008481046">"Stel voor extra beveiliging een patroon in om het apparaat te ontgrendelen"</string>
    <string name="lockpassword_choose_your_profile_pattern_header" msgid="3101811498330756641">"Een werkpatroon instellen"</string>
    <string name="lockpassword_choose_your_password_header_for_fingerprint" msgid="3167261267229254090">"Stel wachtwoord in voor gebruik van vingerafdruk"</string>
    <string name="lockpassword_choose_your_pattern_header_for_fingerprint" msgid="4707788269512303400">"Stel patroon in voor gebruik van vingerafdruk"</string>
    <string name="lockpassword_choose_your_pin_message" msgid="7230665212172041837">"Stel een pincode in voor betere beveiliging"</string>
    <string name="lockpassword_choose_your_pin_header_for_fingerprint" msgid="2783879743691792556">"Stel pincode in voor gebruik van vingerafdruk"</string>
    <string name="lockpassword_confirm_your_password_header" msgid="6132312814563023990">"Geef je wachtwoord opnieuw op"</string>
    <string name="lockpassword_reenter_your_profile_password_header" msgid="3812040127714827685">"Je werkwachtwoord opnieuw invullen"</string>
    <string name="lockpassword_confirm_your_work_password_header" msgid="4647071231702288305">"Geef je werkwachtwoord op"</string>
    <string name="lockpassword_confirm_your_pattern_header" msgid="4037701363240138651">"Bevestig je patroon"</string>
    <string name="lockpassword_confirm_your_work_pattern_header" msgid="2668883108969165844">"Geef je werkpatroon op"</string>
    <string name="lockpassword_confirm_your_pin_header" msgid="2241722970567131308">"Pincode opnieuw invoeren"</string>
    <string name="lockpassword_reenter_your_profile_pin_header" msgid="2890233614560435538">"Je werkpincode opnieuw invullen"</string>
    <string name="lockpassword_confirm_your_work_pin_header" msgid="4229765521391960255">"Geef je werkpincode op"</string>
    <string name="lockpassword_confirm_passwords_dont_match" msgid="2100071354970605232">"Wachtwoorden komen niet overeen"</string>
    <string name="lockpassword_confirm_pins_dont_match" msgid="1103699575489401030">"Pincodes komen niet overeen"</string>
    <string name="lockpassword_draw_your_pattern_again_header" msgid="1045638030120803622">"Teken het patroon opnieuw"</string>
    <string name="lockpassword_choose_lock_generic_header" msgid="5669348379247148696">"Ontgrendelingsmethode"</string>
    <string name="lockpassword_password_set_toast" msgid="6615759749393973795">"Wachtwoord is ingesteld"</string>
    <string name="lockpassword_pin_set_toast" msgid="5415783847198570890">"Pincode is ingesteld"</string>
    <string name="lockpassword_pattern_set_toast" msgid="3090582314362416762">"Patroon is ingesteld"</string>
    <string name="lockpassword_choose_your_password_header_for_face" msgid="622276003801157839">"Wachtwoord voor ontgrendelen via gezicht"</string>
    <string name="lockpassword_choose_your_pattern_header_for_face" msgid="7333603579958317102">"Patroon voor ontgrendelen via gezicht"</string>
    <string name="lockpassword_choose_your_pin_header_for_face" msgid="704061826984851309">"Pincode voor ontgrendelen via gezicht"</string>
    <string name="lockpassword_choose_your_password_header_for_biometrics" msgid="2053366309272487015">"Wachtwoord instellen om gezicht of vingerafdruk te gebruiken"</string>
    <string name="lockpassword_choose_your_pattern_header_for_biometrics" msgid="4038476475293734905">"Patroon instellen om gezicht of vingerafdruk te gebruiken"</string>
    <string name="lockpassword_choose_your_pin_header_for_biometrics" msgid="9086039918921009380">"Stel een pincode in om gezicht of vingerafdruk te gebruiken"</string>
    <string name="lockpassword_forgot_password" msgid="5730587692489737223">"Je wachtwoord vergeten?"</string>
    <string name="lockpassword_forgot_pattern" msgid="1196116549051927516">"Je patroon vergeten?"</string>
    <string name="lockpassword_forgot_pin" msgid="7164232234705747672">"Je pincode vergeten?"</string>
    <string name="lockpassword_confirm_your_pattern_generic" msgid="7692794426682501482">"Teken het patroon van je apparaat om door te gaan"</string>
    <string name="lockpassword_confirm_your_pin_generic" msgid="9206928587904701094">"Voer de pincode van het apparaat in om door te gaan"</string>
    <string name="lockpassword_confirm_your_password_generic" msgid="2616127423884477152">"Geef het wachtwoord van je apparaat op om door te gaan"</string>
    <string name="lockpassword_confirm_your_pattern_generic_profile" msgid="9110305410672321714">"Geef het patroon van je werkprofiel op om door te gaan"</string>
    <string name="lockpassword_confirm_your_pin_generic_profile" msgid="6524208128570235127">"Geef de pincode van je werkprofiel op om door te gaan"</string>
    <string name="lockpassword_confirm_your_password_generic_profile" msgid="5918738487760814147">"Geef het wachtwoord van je werkprofiel op om door te gaan"</string>
    <string name="lockpassword_strong_auth_required_device_pattern" msgid="113817518413715557">"Geef voor extra veiligheid je apparaatpatroon op"</string>
    <string name="lockpassword_strong_auth_required_device_pin" msgid="9163822166411129815">"Geef voor extra veiligheid je apparaatpincode op"</string>
    <string name="lockpassword_strong_auth_required_device_password" msgid="8310047427464299337">"Geef voor extra veiligheid je apparaatwachtwoord op"</string>
    <string name="lockpassword_strong_auth_required_work_pattern" msgid="6803652050512161140">"Geef voor extra veiligheid het patroon voor je werkprofiel op"</string>
    <string name="lockpassword_strong_auth_required_work_pin" msgid="4208510396448713500">"Geef voor extra veiligheid de pincode voor je werkprofiel op"</string>
    <string name="lockpassword_strong_auth_required_work_password" msgid="6119482061429323090">"Geef voor extra veiligheid het wachtwoord voor je werkprofiel op"</string>
    <string name="lockpassword_confirm_your_pattern_header_frp" msgid="5641858015891896427">"Patroon verifiëren"</string>
    <string name="lockpassword_confirm_your_pin_header_frp" msgid="8285647793164729982">"Pincode verifiëren"</string>
    <string name="lockpassword_confirm_your_password_header_frp" msgid="7932240547542564033">"Wachtwoord verifiëren"</string>
    <string name="lockpassword_remote_validation_header" msgid="4992647285784962073">"Laat verifiëren dat jij het bent"</string>
    <string name="lockpassword_remote_validation_pattern_details" msgid="4655537780358707983">"Geef het patroon van je andere apparaat op om onder andere Google-accounts en instellingen over te zetten. Je patroon is versleuteld."</string>
    <string name="lockpassword_remote_validation_pin_details" msgid="2373654227583206297">"Geef de pincode van je andere apparaat in om onder andere Google-accounts en instellingen over te zetten. Je pincode is versleuteld."</string>
    <string name="lockpassword_remote_validation_password_details" msgid="3482328925925888340">"Geef het wachtwoord van je andere apparaat op om onder andere Google-accounts en instellingen over te zetten. Je wachtwoord is versleuteld."</string>
    <string name="lockpassword_remote_validation_set_pattern_as_screenlock" msgid="7595104317648465901">"Ook patroon gebruiken om dit apparaat te ontgrendelen"</string>
    <string name="lockpassword_remote_validation_set_pin_as_screenlock" msgid="509672303005547218">"Ook pincode gebruiken om dit apparaat te ontgrendelen"</string>
    <string name="lockpassword_remote_validation_set_password_as_screenlock" msgid="2066701840753591922">"Ook wachtwoord gebruiken om dit apparaat te ontgrendelen"</string>
    <string name="lockpassword_invalid_pin" msgid="7530854476819820600">"Onjuiste pincode"</string>
    <string name="lockpassword_invalid_password" msgid="1588184930542221687">"Onjuist wachtwoord"</string>
    <string name="lockpattern_need_to_unlock_wrong" msgid="8109305107409924083">"Onjuist patroon"</string>
    <string name="work_challenge_emergency_button_text" msgid="5529942788380505927">"Noodgeval"</string>
    <string name="lock_settings_title" msgid="665707559508132349">"Apparaatbeveiliging"</string>
    <string name="lockpattern_change_lock_pattern_label" msgid="5853706275279878879">"Ontgrendelingspatroon wijzigen"</string>
    <string name="lockpattern_change_lock_pin_label" msgid="7327409886587802756">"Pincode voor ontgrendelen wijzigen"</string>
    <string name="lockpattern_recording_intro_header" msgid="8325736706877916560">"Teken een ontgrendelingspatroon"</string>
    <string name="lockpattern_recording_intro_footer" msgid="2656868858594487197">"Druk op \'Menu\' voor hulp."</string>
    <string name="lockpattern_recording_inprogress" msgid="7268008332694009191">"Haal je vinger van het scherm als je klaar bent"</string>
    <string name="lockpattern_recording_incorrect_too_short" msgid="3351522018450593723">"Verbind minimaal <xliff:g id="NUMBER">%d</xliff:g> punten. Probeer het opnieuw."</string>
    <string name="lockpattern_pattern_entered_header" msgid="7709618312713127249">"Patroon opgeslagen"</string>
    <string name="lockpattern_need_to_confirm" msgid="6489499109451714360">"Teken patroon nog eens ter bevestiging"</string>
    <string name="lockpattern_pattern_confirmed_header" msgid="2969990617475456153">"Je nieuwe ontgrendelingspatroon"</string>
    <string name="lockpattern_confirm_button_text" msgid="6122815520373044089">"Bevestigen"</string>
    <string name="lockpattern_restart_button_text" msgid="255339375151895998">"Opnieuw tekenen"</string>
    <string name="lockpattern_retry_button_text" msgid="4229668933251849760">"Wissen"</string>
    <string name="lockpattern_continue_button_text" msgid="5253269556259503537">"Doorgaan"</string>
    <string name="lockpattern_settings_title" msgid="9223165804553269083">"Ontgrendelingspatroon"</string>
    <string name="lockpattern_settings_enable_title" msgid="7401197111303283723">"Patroon vereist"</string>
    <string name="lockpattern_settings_enable_summary" msgid="1116467204475387886">"Je moet een patroon tekenen om het scherm te ontgrendelen"</string>
    <string name="lockpattern_settings_enable_visible_pattern_title" msgid="3340969054395584754">"Patroon zichtbaar maken"</string>
    <string name="lockpattern_settings_enhanced_pin_privacy_title" msgid="7172693275721931683">"Geoptimaliseerde privacy voor pincodes"</string>
    <string name="lockpattern_settings_enhanced_pin_privacy_summary" msgid="8639588868341114740">"Animaties uitzetten terwijl je de pincode invoert"</string>
    <string name="lockpattern_settings_enable_visible_pattern_title_profile" msgid="5138189101808127489">"Profielpatroon zichtbaar maken"</string>
    <string name="lockpattern_settings_enable_tactile_feedback_title" msgid="2273374883831956787">"Trillen bij tikken"</string>
    <string name="lockpattern_settings_enable_power_button_instantly_locks" msgid="1638619728773344099">"Aan/uit-knop vergrendelt direct"</string>
    <string name="lockpattern_settings_power_button_instantly_locks_summary" msgid="2202430156268094229">"Behalve wanneer ontgrendeld gehouden door <xliff:g id="TRUST_AGENT_NAME">%1$s</xliff:g>"</string>
    <string name="lockpattern_settings_choose_lock_pattern" msgid="2193588309557281466">"Ontgrendelingspatroon instellen"</string>
    <string name="lockpattern_settings_change_lock_pattern" msgid="7614155083815661347">"Ontgrendelingspatroon wijzigen"</string>
    <string name="lockpattern_settings_help_how_to_record" msgid="2093801939046625774">"Je tekent als volgt een ontgrendelingspatroon"</string>
    <string name="lockpattern_too_many_failed_confirmation_attempts" msgid="7891484005551794824">"Te veel onjuiste pogingen. Probeer het over <xliff:g id="NUMBER">%d</xliff:g> seconden opnieuw."</string>
    <string name="activity_not_found" msgid="5464331414465894254">"Deze app is niet geïnstalleerd op je telefoon."</string>
    <string name="lock_settings_profile_title" msgid="103605580492566086">"Beveiliging voor werkprofiel"</string>
    <string name="lock_settings_profile_screen_lock_title" msgid="3776275029218681815">"Schermvergrendeling voor werkprofiel"</string>
    <string name="lock_settings_profile_unification_title" msgid="5777961097706546513">"Eén vergrendeling gebruiken"</string>
    <string name="lock_settings_profile_unification_summary" msgid="1317553536289481654">"Gebruik één vergrendeling voor het werkprofiel en het scherm van het apparaat"</string>
    <string name="lock_settings_profile_unification_dialog_title" msgid="5163178097464820825">"Wil je één vergrendeling gebruiken?"</string>
    <string name="lock_settings_profile_unification_dialog_body" msgid="1222905637428672355">"Het apparaat gebruikt de schermvergrendeling van je werkprofiel. Werkbeleid geldt voor beide vergrendelingen."</string>
    <string name="lock_settings_profile_unification_dialog_uncompliant_body" msgid="8844682343443755895">"De schermvergrendeling voor je werkprofiel voldoet niet aan de beveiligingsvereisten van je organisatie. Je kunt voor het scherm van je apparaat dezelfde vergrendeling gebruiken als voor je werkprofiel, maar eventueel schermvergrendelingsbeleid voor je werkprofiel geldt ook voor de schermvergrendeling voor je apparaat."</string>
    <string name="lock_settings_profile_unification_dialog_confirm" msgid="6276915393736137843">"Eén vergrendeling gebruiken"</string>
    <string name="lock_settings_profile_unification_dialog_uncompliant_confirm" msgid="8509287115116369677">"Eén vergrendeling gebruiken"</string>
    <string name="lock_settings_profile_unified_summary" msgid="777095092175037385">"Hetzelfde als de apparaatschermvergrendeling"</string>
    <string name="manageapplications_settings_title" msgid="9198876415524237657">"Apps beheren"</string>
    <string name="applications_settings" msgid="1941993743933425622">"App-info"</string>
    <string name="applications_settings_header" msgid="3154670675856048015">"App-instellingen"</string>
    <string name="install_applications" msgid="3921609656584369901">"Onbekende bronnen"</string>
    <string name="install_applications_title" msgid="7890233747559108106">"Alle appbronnen toestaan"</string>
    <string name="recent_app_category_title" msgid="189758417804427533">"Recent geopende apps"</string>
    <string name="see_all_apps_title" msgid="1650653853942381797">"{count,plural, =1{Alle apps zien}other{Alle # apps zien}}"</string>
    <string name="forgot_password_title" msgid="3967873480875239885">"Neem contact op met je IT-beheerder"</string>
    <string name="forgot_password_text" msgid="2583194470767613163">"De beheerder kan je helpen je pincode, patroon of wachtwoord te resetten"</string>
    <string name="advanced_settings" msgid="2368905204839169094">"Geavanceerde instellingen"</string>
    <string name="advanced_settings_summary" msgid="1823765348195530035">"Meer opties voor instellingen aanzetten"</string>
    <string name="application_info_label" msgid="1015706497694165866">"App-info"</string>
    <string name="storage_label" msgid="2522307545547515733">"Opslagruimte"</string>
    <string name="auto_launch_label" msgid="4069860409309364872">"Standaard openen"</string>
    <string name="auto_launch_label_generic" msgid="5033137408273064599">"Standaardinstellingen"</string>
    <string name="screen_compatibility_label" msgid="7549658546078613431">"Schermcompatibiliteit"</string>
    <string name="permissions_label" msgid="1708927634370314404">"Rechten"</string>
    <string name="cache_header_label" msgid="2441967971921741047">"Cachegeheugen"</string>
    <string name="clear_cache_btn_text" msgid="8597272828928143723">"Cache wissen"</string>
    <string name="cache_size_label" msgid="313456088966822757">"Cachegeheugen"</string>
    <string name="uri_permissions_text" msgid="8406345863117405105">"{count,plural, =1{1 item}other{# items}}"</string>
    <string name="clear_uri_btn_text" msgid="4828117421162495134">"Toegang intrekken"</string>
    <string name="controls_label" msgid="8671492254263626383">"Bedieningselementen"</string>
    <string name="force_stop" msgid="2681771622136916280">"Gedwongen stoppen"</string>
    <string name="total_size_label" msgid="2052185048749658866">"Totaal"</string>
    <string name="application_size_label" msgid="6407051020651716729">"App-grootte"</string>
    <string name="external_code_size_label" msgid="7375146402660973743">"USB-opslagapp"</string>
    <string name="data_size_label" msgid="7814478940141255234">"Gebruikersgegevens"</string>
    <string name="uninstall_text" msgid="315764653029060126">"Verwijderen"</string>
    <string name="uninstall_all_users_text" msgid="5924715251087176474">"Verwijderen voor alle gebruikers"</string>
    <string name="install_text" msgid="4558333621516996473">"Installeren"</string>
    <string name="disable_text" msgid="5146002260857428005">"Uitzetten"</string>
    <string name="enable_text" msgid="8570798764647110430">"Aanzetten"</string>
    <string name="clear_user_data_text" msgid="6773186434260397947">"Opslag wissen"</string>
    <string name="app_factory_reset" msgid="8974044931667015201">"Updates verwijderen"</string>
    <string name="app_restricted_settings_lockscreen_title" msgid="5993061278264872648">"Beperkte instellingen toestaan"</string>
    <string name="auto_launch_enable_text" msgid="8912714475823807798">"Bepaalde activiteiten die je hebt geselecteerd, worden standaard geopend in deze app."</string>
    <string name="always_allow_bind_appwidgets_text" msgid="2069415023986858324">"Je hebt ervoor gekozen deze app toe te staan widgets te maken en toegang tot de widgetgegevens te geven."</string>
    <string name="auto_launch_disable_text" msgid="502648841250936209">"Geen standaardwaarden ingesteld."</string>
    <string name="clear_activities" msgid="488089228657585700">"Standaardvoorkeuren wissen"</string>
    <string name="screen_compatibility_text" msgid="5915767835411020274">"Deze app is mogelijk niet ontworpen voor je scherm. Je kunt hier bepalen hoe de app wordt aangepast aan je scherm."</string>
    <string name="ask_compatibility" msgid="8388397595148476565">"Vragen bij starten"</string>
    <string name="enable_compatibility" msgid="1163387233622859712">"App schalen"</string>
    <string name="unknown" msgid="8192160131923461175">"Onbekend"</string>
    <string name="sort_order_alpha" msgid="3400680865280266582">"Sorteren op naam"</string>
    <string name="sort_order_size" msgid="7731928486199737223">"Sorteren op grootte"</string>
    <string name="sort_order_recent_notification" msgid="1496198895330443073">"Meest recent"</string>
    <string name="sort_order_frequent_notification" msgid="4063700985742284794">"Vaakst"</string>
    <string name="show_running_services" msgid="8666008279959853318">"Actieve services tonen"</string>
    <string name="show_background_processes" msgid="5682856012453562151">"Processen in cache tonen"</string>
    <string name="default_emergency_app" msgid="1929974800666613803">"Nood-app"</string>
    <string name="reset_app_preferences" msgid="8861758340732716573">"App-voorkeuren resetten"</string>
    <string name="reset_app_preferences_title" msgid="8935136792316050759">"App-voorkeuren resetten?"</string>
    <string name="reset_app_preferences_desc" msgid="8550782670650158299">"Hiermee worden alle voorkeuren gereset voor:\n\n"<li>"Uitgezette apps"</li>\n<li>"Uitgezette app-meldingen"</li>\n<li>"Standaard-apps voor acties"</li>\n<li>"Beperkingen voor achtergrondgegevens voor apps"</li>\n<li>"Rechtenbeperkingen"</li>\n<li>"Instellingen voor batterijgebruik"</li>\n\n"Je verliest geen app-gegevens."</string>
    <string name="reset_app_preferences_button" msgid="2591318711372850058">"Apps resetten"</string>
    <string name="filter" msgid="9039576690686251462">"Filter"</string>
    <string name="filter_dlg_title" msgid="3086282431958601338">"Filteropties kiezen"</string>
    <string name="filter_apps_all" msgid="5705421199299914620">"Alle apps"</string>
    <string name="filter_apps_disabled" msgid="5068011814871004105">"Uitgezette apps"</string>
    <string name="filter_apps_third_party" msgid="9049447784849114843">"Gedownload"</string>
    <string name="filter_apps_running" msgid="535465683273284141">"Wordt uitgevoerd"</string>
    <string name="not_installed" msgid="5074606858798519449">"Niet geïnstalleerd voor deze gebruiker"</string>
    <string name="installed" msgid="2837449358488825884">"Geïnstalleerd"</string>
    <string name="no_applications" msgid="985069304755391640">"Geen apps."</string>
    <string name="internal_storage" msgid="999496851424448809">"Interne opslag"</string>
    <string name="recompute_size" msgid="1098091228370999128">"Grootte opnieuw berekenen..."</string>
    <string name="clear_data_dlg_title" msgid="180446967743732410">"Gegevens van app verwijderen?"</string>
    <string name="clear_data_dlg_text" msgid="3440011276559762619">"De gegevens van deze app, waaronder bestanden en instellingen, worden definitief verwijderd van dit apparaat"</string>
    <string name="dlg_ok" msgid="1421350367857960997">"OK"</string>
    <string name="dlg_cancel" msgid="5164705061530774899">"Annuleren"</string>
    <string name="dlg_delete" msgid="1790919205039397659">"Verwijderen"</string>
    <string name="app_not_found_dlg_text" msgid="8634675268730513704">"De app is niet gevonden in de lijst met geïnstalleerde apps."</string>
    <string name="clear_failed_dlg_text" msgid="6866741916836125732">"Kan opslag voor app niet wissen."</string>
    <string name="computing_size" msgid="4915310659841174866">"Berekenen…"</string>
    <string name="invalid_size_value" msgid="7017371543563259201">"Kan pakketgrootte niet berekenen."</string>
    <string name="version_text" msgid="7628938665256107608">"versie <xliff:g id="VERSION_NUM">%1$s</xliff:g>"</string>
    <string name="move_app" msgid="5421158479447276791">"Verplaatsen"</string>
    <string name="another_migration_already_in_progress" msgid="6550546307856052261">"Er wordt al een andere migratie uitgevoerd."</string>
    <string name="insufficient_storage" msgid="8115088042669030558">"Niet voldoende opslagruimte."</string>
    <string name="does_not_exist" msgid="6499163879348776120">"App bestaat niet."</string>
    <string name="invalid_location" msgid="8013853455355520557">"De installatielocatie is niet geldig."</string>
    <string name="system_package" msgid="7559476279008519360">"Systeemupdates kunnen niet worden geïnstalleerd op externe media."</string>
    <string name="move_error_device_admin" msgid="1561502976834303626">"Apparaatbeheer-app kan niet worden geïnstalleerd op externe media"</string>
    <string name="force_stop_dlg_title" msgid="86745852555490146">"Gedwongen stoppen?"</string>
    <string name="force_stop_dlg_text" msgid="1527286468544457368">"Als je een app gedwongen stopt, kan deze onverwacht gedrag vertonen."</string>
    <string name="app_disable_dlg_positive" msgid="1414218905322009505">"App uitzetten"</string>
    <string name="app_disable_dlg_text" msgid="2449382902751908916">"Als je deze app uitzet, werken Android en andere apps mogelijk niet meer zoals bedoeld. Je kunt deze app niet verwijderen omdat deze vooraf geïnstalleerd was op je apparaat. Door de app uit te zetten verberg je deze ook op je apparaat."</string>
    <string name="app_install_details_group_title" msgid="1172114479073704677">"Store"</string>
    <string name="app_install_details_title" msgid="7783556181897142187">"App-details"</string>
    <string name="app_install_details_summary" msgid="2013043219249992373">"App geïnstalleerd vanuit <xliff:g id="APP_STORE">%1$s</xliff:g>"</string>
    <string name="instant_app_details_summary" msgid="417197491598208216">"Meer informatie via <xliff:g id="APP_STORE">%1$s</xliff:g>"</string>
    <string name="app_ops_running" msgid="6127474473137428721">"Actief"</string>
    <string name="app_ops_never_used" msgid="9038133162371204506">"(Nooit gebruikt)"</string>
    <string name="storageuse_settings_title" msgid="3125650750657988194">"Opslaggebruik"</string>
    <string name="service_restarting" msgid="5104563288155809226">"Opnieuw starten"</string>
    <string name="cached" msgid="5379485147573438201">"Gecacht achtergrondproces"</string>
    <string name="no_running_services" msgid="9079738069349859373">"Niets wordt uitgevoerd."</string>
    <string name="service_started_by_app" msgid="6845028506417670179">"Gestart door app."</string>
    <!-- no translation found for service_client_name (2210898622981598861) -->
    <skip />
    <string name="service_background_processes" msgid="2800539421534521948">"<xliff:g id="MEMORY">%1$s</xliff:g> vrij"</string>
    <string name="service_foreground_processes" msgid="6380905887193621704">"<xliff:g id="MEMORY">%1$s</xliff:g> gebr."</string>
    <string name="memory" msgid="5253757199926592074">"RAM"</string>
    <!-- no translation found for service_process_name (7827318358399776412) -->
    <skip />
    <string name="running_process_item_user_label" msgid="1444898861984132133">"Gebruiker: <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="running_process_item_removed_user_label" msgid="4812732296696662613">"Verwijderde gebruiker"</string>
    <string name="running_processes_item_description_s_s" msgid="6835918861352501671">"<xliff:g id="NUMPROCESS">%1$d</xliff:g> proces en <xliff:g id="NUMSERVICES">%2$d</xliff:g> service"</string>
    <string name="running_processes_item_description_s_p" msgid="1209371773353932361">"<xliff:g id="NUMPROCESS">%1$d</xliff:g> proces en <xliff:g id="NUMSERVICES">%2$d</xliff:g> services"</string>
    <string name="running_processes_item_description_p_s" msgid="8957061449107822282">"<xliff:g id="NUMPROCESS">%1$d</xliff:g> processen en <xliff:g id="NUMSERVICES">%2$d</xliff:g> service"</string>
    <string name="running_processes_item_description_p_p" msgid="3292999232897469679">"<xliff:g id="NUMPROCESS">%1$d</xliff:g> processen en <xliff:g id="NUMSERVICES">%2$d</xliff:g> services"</string>
    <string name="running_processes_header_title" msgid="558961782589967366">"Apparaatgeheugen"</string>
    <string name="running_processes_header_footer" msgid="2726092156680487584">"RAM-gebruik van app"</string>
    <string name="running_processes_header_system_prefix" msgid="8819527769608555124">"Systeem"</string>
    <string name="running_processes_header_apps_prefix" msgid="4151874328324238133">"Apps"</string>
    <string name="running_processes_header_free_prefix" msgid="4271100378295864738">"Beschikbaar"</string>
    <string name="running_processes_header_used_prefix" msgid="5205762402234243007">"Gebruikt"</string>
    <string name="running_processes_header_cached_prefix" msgid="839132595831993521">"In cache"</string>
    <string name="running_processes_header_ram" msgid="3014991380467004685">"<xliff:g id="RAM_0">%1$s</xliff:g> RAM"</string>
    <string name="runningservicedetails_settings_title" msgid="1057845389092757121">"Actieve app"</string>
    <string name="no_services" msgid="3898812785511572899">"Niet actief"</string>
    <string name="runningservicedetails_services_title" msgid="11853795112787355">"Services"</string>
    <string name="runningservicedetails_processes_title" msgid="5292271587797234038">"Processen"</string>
    <string name="service_stop" msgid="5712522600201308795">"Stoppen"</string>
    <string name="service_manage" msgid="3896322986828332075">"Instellingen"</string>
    <string name="service_stop_description" msgid="6327742632400026677">"Deze service is gestart door de app. Als de service wordt gestopt, kan de app vastlopen."</string>
    <string name="heavy_weight_stop_description" msgid="3086419998820881290">"Deze app kan niet veilig worden gestopt. Als je de app stopt, kun je een deel van je huidige werk kwijtraken."</string>
    <string name="background_process_stop_description" msgid="4792038933517438037">"Dit is een oud app-proces dat nog actief is voor het geval het opnieuw nodig is. Er is meestal geen reden om dit te stoppen."</string>
    <string name="service_manage_description" msgid="6615788996428486121">"<xliff:g id="CLIENT_NAME">%1$s</xliff:g>: momenteel in gebruik. Tik op Instellingen om dit te bedienen."</string>
    <string name="main_running_process_description" msgid="6685973937935027773">"Hoofdproces in gebruik."</string>
    <string name="process_service_in_use_description" msgid="4210957264507014878">"Service <xliff:g id="COMP_NAME">%1$s</xliff:g> in gebruik."</string>
    <string name="process_provider_in_use_description" msgid="6730020083976048028">"Provider <xliff:g id="COMP_NAME">%1$s</xliff:g> in gebruik."</string>
    <string name="runningservicedetails_stop_dlg_title" msgid="6201041461740445113">"Systeemservice stoppen?"</string>
    <string name="language_input_gesture_title" msgid="3292455685728572960">"Talen, invoer en gebaren"</string>
    <string name="language_settings" msgid="8700174277543875046">"Talen en invoer"</string>
    <string name="languages_settings" msgid="5784775502251770671">"Talen"</string>
    <string name="keyboard_settings" msgid="184185708597386454">"Toetsenbord"</string>
    <string name="language_empty_list_user_restricted" msgid="8050367405839231863">"Je hebt geen rechten om de apparaattaal te wijzigen."</string>
    <string name="language_keyboard_settings_title" msgid="7934844313233544557">"Talen en invoer"</string>
    <string name="input_assistance" msgid="3437568284144952104">"Tools"</string>
    <string name="keyboard_settings_category" msgid="5392847229300117064">"Toetsenbord en invoermethoden"</string>
    <string name="system_language" msgid="1146762166579643257">"Systeemtalen"</string>
    <string name="phone_language" msgid="5986939176239963826">"Talen"</string>
    <string name="phone_language_summary" msgid="863041222809685325"></string>
    <string name="auto_replace" msgid="4830732960264447043">"Automatisch vervangen"</string>
    <string name="auto_replace_summary" msgid="1285443414597153423">"Corrigeer verkeerd getypte woorden"</string>
    <string name="auto_caps" msgid="5573583581288305355">"Automatisch hoofdlettergebruik"</string>
    <string name="auto_caps_summary" msgid="3144141933426846665">"Eerste letters in zinnen met hoofdletter"</string>
    <string name="auto_punctuate" msgid="2838809477621809507">"Automatische interpunctie"</string>
    <string name="hardkeyboard_category" msgid="8729780593378161071">"Instellingen voor vast toetsenbord"</string>
    <string name="auto_punctuate_summary" msgid="3549190848611386748">"Druk twee keer op de spatiebalk om een punt (.) in te voegen"</string>
    <string name="show_password" msgid="7101900779571040117">"Wachtwoorden tonen"</string>
    <string name="show_password_summary" msgid="9025960283785111619">"Geef tekens kort weer terwijl je typt"</string>
    <string name="spellchecker_security_warning" msgid="2016059050608271820">"Deze spellingcontrole verzamelt mogelijk alle tekst die je typt, inclusief persoonsgegevens zoals wachtwoorden en creditcardnummers. De service is afkomstig uit de app <xliff:g id="SPELLCHECKER_APPLICATION_NAME">%1$s</xliff:g>. Wil je deze spellingcontrole gebruiken?"</string>
    <string name="spellchecker_quick_settings" msgid="6449414356743946577">"Instellingen"</string>
    <string name="spellchecker_language" msgid="8905487366580285282">"Taal"</string>
    <string name="keyboard_and_input_methods_category" msgid="5296847777802891649">"Toetsenborden"</string>
    <string name="virtual_keyboard_category" msgid="2339505603075527212">"Schermtoetsenbord"</string>
    <string name="keywords_virtual_keyboard" msgid="1494726424879503434">"Gboard"</string>
    <string name="available_virtual_keyboard_category" msgid="6930012948152749337">"Beschikbaar schermtoetsenbord"</string>
    <string name="add_virtual_keyboard" msgid="2515850206289352606">"Schermtoetsen­borden beheren"</string>
    <string name="keyboard_options_category" msgid="8040137073401152608">"Opties"</string>
    <string name="physical_keyboard_title" msgid="3328134097512350958">"Fysiek toetsenbord"</string>
    <string name="show_ime" msgid="4334255501724746849">"Schermtoetsenbord gebruiken"</string>
    <string name="show_ime_summary" msgid="7293345791727205975">"Toon op het scherm terwijl het fysieke toetsenbord actief is"</string>
    <string name="keyboard_shortcuts_helper" msgid="2553221039203165344">"Sneltoetsen"</string>
    <string name="keyboard_shortcuts_helper_summary" msgid="5979507677602559203">"Toon lijst met sneltoetsen"</string>
    <string name="language_and_input_for_work_category_title" msgid="2546950919124199743">"Toetsenborden en tools van werkprofiel"</string>
    <string name="virtual_keyboards_for_work_title" msgid="786459157034008675">"Schermtoetsenbord voor werk"</string>
    <string name="keyboard_default_layout" msgid="5377811770620422301">"Standaard"</string>
    <string name="trackpad_settings" msgid="2071131324087677005">"Touchpad"</string>
    <string name="trackpad_mouse_settings" msgid="136226693583218429">"Touchpad en muis"</string>
    <string name="trackpad_settings_summary" msgid="3369855644136760402">"Snelheid van aanwijzer, gebaren"</string>
    <string name="trackpad_tap_to_click" msgid="1938230946542070746">"Tikken om te klikken"</string>
    <string name="trackpad_touchpad_gesture_title" msgid="7568052847609914436">"Touchpadgebaren"</string>
    <string name="trackpad_touchpad_gesture_summary" msgid="6256074591395359124">"Pas afzonderlijke navigatiegebaren voor de touchpad aan"</string>
    <string name="trackpad_reverse_scrolling_title" msgid="422877284529360866">"Omgekeerd scrollen"</string>
    <string name="trackpad_reverse_scrolling_summary" msgid="6048648562887499036">"Content beweegt omhoog als je omlaag scrollt"</string>
    <string name="trackpad_bottom_right_tap_title" msgid="6275428879042702880">"Rechtsonder tikken"</string>
    <string name="trackpad_bottom_right_tap_summary" msgid="8734094086900680674">"Tik rechtsonder op de touchpad voor meer opties"</string>
    <string name="trackpad_pointer_speed" msgid="7786579408631352625">"Snelheid van aanwijzer"</string>
    <string name="trackpad_touch_gesture" msgid="8641725062131922497">"Touchpadgebaren leren"</string>
    <string name="gesture_title_go_home" msgid="3682238648647225933">"Naar de homepage"</string>
    <string name="gesture_summary_go_home" msgid="6409031586904205741">"Swipe ergens op je touchpad omhoog met 3 vingers"</string>
    <string name="gesture_title_go_back" msgid="6619462058488419802">"Terug"</string>
    <string name="gesture_summary_go_back" msgid="4981604277892236888">"Swipe vanaf links of rechts met 3 vingers"</string>
    <string name="gesture_title_recent_apps" msgid="6082688963233208761">"Recente apps bekijken"</string>
    <string name="gesture_summary_recent_apps" msgid="6643179135202417509">"Swipe omhoog met 3 vingers, houd vast en laat dan los"</string>
    <string name="gesture_title_notifications" msgid="791717222472350194">"Meldingen en Snelle instellingen bekijken"</string>
    <string name="gesture_summary_notifications" msgid="8419514601638387255">"Swipe omlaag met 3 vingers op je startscherm"</string>
    <string name="gesture_title_switch_apps" msgid="5840994412037872157">"Schakelen tussen apps"</string>
    <string name="gesture_summary_switch_apps" msgid="6842648062151413042">"Swipe naar links of rechts met 4 vingers"</string>
    <string name="gesture_button_skip" msgid="5174842083451193213">"Overslaan"</string>
    <string name="gesture_button_next" msgid="695288092704187356">"Volgende"</string>
    <string name="gesture_button_restart" msgid="1895850891992530133">"Opnieuw opstarten"</string>
    <string name="gesture_button_done" msgid="6387900351203032188">"Klaar"</string>
    <string name="trackpad_go_back_title" msgid="5312164160947491440">"Terug"</string>
    <string name="trackpad_go_back_summary" msgid="4201901101085902768">"Swipe naar links of rechts met 3 vingers"</string>
    <string name="trackpad_go_home_title" msgid="2146525662148291552">"Naar de homepage"</string>
    <string name="trackpad_go_home_summary" msgid="2222744701528360887">"Swipe omhoog met 3 vingers"</string>
    <string name="trackpad_recent_apps_title" msgid="8195970908411585445">"Recente apps"</string>
    <string name="trackpad_recent_apps_summary" msgid="2685092851677573794">"Swipe omhoog met 3 vingers en houd vast"</string>
    <string name="trackpad_notifications_title" msgid="3521663305043747880">"Meldingen"</string>
    <string name="trackpad_notifications_summary" msgid="7663647367648690040">"Swipe omlaag met 3 vingers"</string>
    <string name="trackpad_switch_apps_title" msgid="7342032935377284039">"Schakelen tussen apps"</string>
    <string name="trackpad_switch_apps_summary" msgid="9193942041912927440">"Swipe naar links of rechts met 4 vingers"</string>
    <string name="modifier_keys_settings" msgid="2537108435032034683">"Functietoetsen"</string>
    <string name="modifier_keys_settings_summary" msgid="6933143361657444436">"Wijzig het gedrag van toetsen"</string>
    <string name="modifier_keys_reset_title" msgid="948294258402761066">"Alles resetten"</string>
    <string name="modifier_keys_default_summary" msgid="8701640508670973258">"Standaard"</string>
    <string name="modifier_keys_reset_message" msgid="5236994817619936058">"Weet je zeker dat je alle functietoetsen wilt terugzetten op de standaardinstellingen?"</string>
    <string name="modifier_keys_done" msgid="8196199314913909700">"Klaar"</string>
    <string name="modifier_keys_cancel" msgid="7136520252570826772">"Annuleren"</string>
    <string name="modifier_keys_reset" msgid="551170906710422041">"Resetten"</string>
    <string name="modifier_keys_picker_title" msgid="244545904150587851">"Functietoets kiezen"</string>
    <string name="modifier_keys_picker_summary" msgid="739397232249560785">"Kies een nieuwe toets voor <xliff:g id="MODIFIER_KEY_DEFAULT_NAME">%1$s</xliff:g>:"</string>
    <string name="default_keyboard_layout" msgid="8690689331289452201">"Standaard"</string>
    <string name="speech_category_title" msgid="5995161659186229742">"Spraak"</string>
    <string name="pointer_speed" msgid="7398649279282675718">"Snelheid van aanwijzer"</string>
    <string name="game_controller_settings_category" msgid="8557472715034961918">"Gamecontroller"</string>
    <string name="vibrate_input_devices" msgid="5192591087864449142">"Trilling omleiden"</string>
    <string name="vibrate_input_devices_summary" msgid="8791680891376689823">"Trilling verzenden naar gamecontroller wanneer deze is aangesloten"</string>
    <string name="keyboard_layout_dialog_title" msgid="8770130364048089954">"Toetsenbordindeling kiezen"</string>
    <string name="keyboard_layout_dialog_setup_button" msgid="6546245862744626706">"Toetsenbordindelingen instellen"</string>
    <string name="keyboard_layout_dialog_switch_hint" msgid="3303564123674979354">"Druk op Ctrl-spatiebalk om te schakelen"</string>
    <string name="keyboard_layout_default_label" msgid="6078569989261528039">"Standaard"</string>
    <string name="keyboard_layout_picker_title" msgid="240504762718562906">"Toetsenbordindelingen"</string>
    <string name="keyboard_layout_picker_category_title" msgid="2369473692906329772">"Indelingen fysiek toetsenbord"</string>
    <string name="user_dict_settings_title" msgid="680410651924276991">"Persoonlijk woordenboek"</string>
    <string name="user_dict_settings_for_work_title" msgid="1245315720684961770">"Persoonlijk woordenboek voor je werk"</string>
    <string name="user_dict_settings_summary" msgid="4939694372338975081">"Voeg woorden toe om te gebruiken in apps zoals Spellingcontrole"</string>
    <string name="user_dict_settings_add_menu_title" msgid="8046882347281382968">"Toevoegen"</string>
    <string name="user_dict_settings_add_dialog_title" msgid="3485845465134083084">"Toevoegen aan woordenboek"</string>
    <string name="user_dict_settings_add_screen_title" msgid="1866408024073475379">"Woordgroep"</string>
    <string name="user_dict_settings_add_dialog_more_options" msgid="2642928746425808108">"Meer opties"</string>
    <string name="user_dict_settings_add_dialog_less_options" msgid="100432503633458156">"Minder opties"</string>
    <string name="user_dict_settings_add_dialog_confirm" msgid="1866751313790655088">"OK"</string>
    <string name="user_dict_settings_add_word_option_name" msgid="2686051785623698231">"Woord:"</string>
    <string name="user_dict_settings_add_shortcut_option_name" msgid="5722204336242646866">"Snelkoppeling:"</string>
    <string name="user_dict_settings_add_locale_option_name" msgid="2117468247460253346">"Taal:"</string>
    <string name="user_dict_settings_add_word_hint" msgid="4560494723256242785">"Typ een woord"</string>
    <string name="user_dict_settings_add_shortcut_hint" msgid="6209624157217434640">"Optionele snelkoppeling"</string>
    <string name="user_dict_settings_edit_dialog_title" msgid="316493656442362284">"Woord bewerken"</string>
    <string name="user_dict_settings_context_menu_edit_title" msgid="4909198741914531509">"Bewerken"</string>
    <string name="user_dict_settings_context_menu_delete_title" msgid="651550824433043545">"Verwijderen"</string>
    <string name="user_dict_settings_empty_text" msgid="86562873609647919">"Het persoonlijke woordenboek is leeg. Tik op de knop Toevoegen (+) om een woord toe te voegen."</string>
    <string name="user_dict_settings_all_languages" msgid="8563387437755363526">"Voor alle talen"</string>
    <string name="user_dict_settings_more_languages" msgid="5378870726809672319">"Meer talen..."</string>
    <string name="testing" msgid="6294172343766732037">"Testen"</string>
    <string name="keyboard_settings_summary" msgid="9188442758316476986">"Schermtoetsenbord, tools"</string>
    <string name="keyboard_settings_with_physical_keyboard_summary" msgid="2240779804018260938">"Schermtoetsenbord, fysiek toetsenbord, tools"</string>
    <string name="builtin_keyboard_settings_title" msgid="5096171620714179661">"Fysiek toetsenbord"</string>
    <string name="enabled_locales_keyboard_layout" msgid="3939886151098958639">"Indeling"</string>
    <string name="gadget_picker_title" msgid="7615902510050731400">"Gadget kiezen"</string>
    <string name="widget_picker_title" msgid="7641298325488989676">"Widget kiezen"</string>
    <string name="allow_bind_app_widget_activity_allow_bind_title" msgid="3537968409832846255">"Widget maken en toegang toestaan?"</string>
    <string name="allow_bind_app_widget_activity_allow_bind" msgid="5825298768068148804">"Nadat je de widget hebt gemaakt, heeft de app toegang tot alle gegevens die worden getoond.\n\nApp: <xliff:g id="WIDGET_HOST_NAME">%1$s</xliff:g>\nWidget: <xliff:g id="WIDGET_LABEL">%2$s</xliff:g>\n"</string>
    <string name="allow_bind_app_widget_activity_always_allow_bind" msgid="7268758525344468364">"<xliff:g id="WIDGET_HOST_NAME">%1$s</xliff:g> altijd toestaan widgets te maken en toegang tot de widgetgegevens geven"</string>
    <string name="testing_usage_stats" msgid="4660643799010906365">"Gebruiksstatistieken"</string>
    <string name="usage_stats_sort_by_usage_time" msgid="2927310334119998301">"Sorteren op gebruikstijd"</string>
    <string name="usage_stats_sort_by_last_time_used" msgid="7039213339779884017">"Sorteren op laatst gebruikt"</string>
    <string name="usage_stats_sort_by_app_name" msgid="4463833145514850478">"Sorteren op app-naam"</string>
    <string name="last_time_used_label" msgid="2639712813493534074">"Laatst gebruikt"</string>
    <string name="usage_time_label" msgid="9105343335151559883">"Gebruikstijd"</string>
    <string name="accessibility_settings" msgid="4713215774904704682">"Toegankelijkheid"</string>
    <string name="accessibility_settings_title" msgid="6739115703615065716">"Instellingen voor toegankelijkheid"</string>
    <string name="accessibility_settings_summary" msgid="2366627644570558503">"Scherm, interactie, audio"</string>
    <string name="vision_settings_title" msgid="8919983801864103069">"Visuele instellingen"</string>
    <string name="vision_settings_description" msgid="7614894785054441991">"Pas dit apparaat aan je behoeften aan. Je kunt de toegankelijkheidsfuncties later altijd veranderen in de Instellingen."</string>
    <string name="vision_settings_suggestion_title" msgid="4689275412658803919">"Lettergrootte wijzigen"</string>
    <string name="screen_reader_category_title" msgid="5825700839731107803">"Schermlezer"</string>
    <string name="captions_category_title" msgid="574490148949400274">"Ondertiteling"</string>
    <string name="audio_category_title" msgid="5283853679967605826">"Audio"</string>
    <string name="general_category_title" msgid="6298579528716834157">"Algemeen"</string>
    <string name="display_category_title" msgid="6638191682294461408">"Scherm"</string>
    <string name="accessibility_color_and_motion_title" msgid="2323301706545305874">"Kleur en beweging"</string>
    <string name="accessibility_turn_screen_darker_title" msgid="5986223133285858349">"Scherm donkerder maken"</string>
    <string name="interaction_control_category_title" msgid="2696474616743882372">"Interactieopties"</string>
    <string name="accessibility_tap_assistance_title" msgid="1058913033421048284">"Bedienings­elementen voor timing"</string>
    <string name="accessibility_system_controls_title" msgid="6403287349518987624">"Systeemopties"</string>
    <string name="user_installed_services_category_title" msgid="2639470729311439731">"Gedownloade apps"</string>
    <string name="experimental_category_title" msgid="898904396646344152">"Experimenteel"</string>
    <string name="feature_flags_dashboard_title" msgid="348990373716658289">"Functievlaggen"</string>
    <string name="bt_hci_snoop_log_filters_dashboard_title" msgid="401330708633716596">"Filter voor snoop-logbestand voor bluetooth-HCI"</string>
    <string name="bt_hci_snoop_log_filters_dashboard_summary" msgid="1319792184194176235">"Filters instellen"</string>
    <string name="bt_hci_snoop_log_filters_dashboard_footer" msgid="4158945851818483666">"Zet bluetooth aan en uit om de wijzigingen door te voeren"</string>
    <string name="bt_hci_snoop_log_filter_pbap_title" msgid="1735427364451634823">"PBAP-filter voor snoop-logbestand voor bluetooth-HCI"</string>
    <string name="bt_hci_snoop_log_filter_map_title" msgid="180092480793945544">"MAP-filter voor snoop-logbestand voor bluetooth-HCI"</string>
    <string name="bt_hci_snoop_log_filter_summary" msgid="7217091930762522599">"Filtermodus instellen. (Zet bluetooth aan en uit om de wijzigingen door te voeren)"</string>
    <string name="bt_hci_snoop_log_filtered_mode_disabled_summary" msgid="8824952559433361848">"Zet de modus van het snoop-logbestand voor bluetooth-HCI op Gefilterd staat aan om deze optie te wijzigen"</string>
    <string name="talkback_title" msgid="8756080454514251327">"TalkBack"</string>
    <string name="talkback_summary" msgid="5820927220378864281">"Schermlezer voornamelijk voor blinden en slechtzienden"</string>
    <string name="select_to_speak_summary" msgid="1995285446766920925">"Tik op items op je scherm om ze hardop te laten voorlezen"</string>
    <string name="accessibility_captioning_title" msgid="4561871958958925225">"Voorkeuren voor ondertiteling"</string>
    <string name="accessibility_captioning_about_title" msgid="3542171637334191563">"Over ondertitelingsvoorkeuren"</string>
    <string name="accessibility_captioning_footer_learn_more_content_description" msgid="5730040700677017706">"Meer informatie over ondertitelingsvoorkeuren"</string>
    <string name="accessibility_screen_magnification_title" msgid="1211169976144629087">"Vergroting"</string>
    <string name="accessibility_screen_magnification_shortcut_title" msgid="2387963646377987780">"Snelkoppeling voor vergroting"</string>
    <string name="accessibility_screen_magnification_follow_typing_title" msgid="6379517513916651560">"Vergrootglas bij typen"</string>
    <string name="accessibility_screen_magnification_follow_typing_summary" msgid="2882250257391761678">"Een vergrootglas volgt de tekst terwijl je typt"</string>
    <string name="accessibility_screen_magnification_always_on_title" msgid="3814297443759580936">"Aan laten bij wisselen van apps"</string>
    <string name="accessibility_screen_magnification_always_on_summary" msgid="306908451430863049">"Vergrootglas blijft aan en zoomt uit als je van app wisselt"</string>
    <string name="accessibility_screen_magnification_joystick_title" msgid="1803769708582404964">"Joystick"</string>
    <string name="accessibility_screen_magnification_joystick_summary" msgid="4640300148573982720">"Activeer en verplaats het vergrootglas met een joystick op het scherm. Houd ingedrukt en sleep met de joystick om het vergrootglas te bedienen. Tik en sleep om de joystick zelf te verplaatsen."</string>
    <string name="accessibility_screen_magnification_about_title" msgid="8857919020223505415">"Over vergroting"</string>
    <string name="accessibility_screen_magnification_footer_learn_more_content_description" msgid="924848332575978463">"Meer informatie over vergroting"</string>
    <string name="accessibility_magnification_mode_title" msgid="8446475127807168063">"Type vergroting"</string>
    <string name="accessibility_magnification_area_settings_message" msgid="8498648925928109462">"Vergroot je hele scherm of een specifiek deel ervan, of schakel tussen beide opties"</string>
    <string name="accessibility_magnification_area_settings_full_screen_summary" msgid="2728962784113713010">"Volledig scherm"</string>
    <string name="accessibility_magnification_area_settings_window_screen_summary" msgid="9191632962955877019">"Gedeeltelijk scherm"</string>
    <string name="accessibility_magnification_area_settings_all_summary" msgid="8107511976748799455">"Schakel tussen volledig en gedeeltelijk scherm"</string>
    <string name="accessibility_magnification_mode_dialog_title" msgid="9151027667059878578">"Kiezen hoe je wilt vergroten"</string>
    <string name="accessibility_magnification_mode_dialog_option_full_screen" msgid="4892487869954032029">"Volledig scherm vergroten"</string>
    <string name="accessibility_magnification_mode_dialog_option_window" msgid="4492443201099153362">"Deel van het scherm vergroten"</string>
    <string name="accessibility_magnification_mode_dialog_option_switch" msgid="561043521011229424">"Schakelen tussen volledig en gedeeltelijk scherm"</string>
    <string name="accessibility_magnification_area_settings_mode_switch_summary" msgid="2885238806099080966">"Tik op de schakelknop om tussen beide opties te schakelen"</string>
    <string name="accessibility_magnification_switch_shortcut_title" msgid="3671432048806533079">"Overschakelen naar knop Toegankelijkheid?"</string>
    <string name="accessibility_magnification_switch_shortcut_message" msgid="7718653917415163833">"Als je 3 keer tikken gebruikt om een gedeelte van je scherm te vergroten, worden typen en andere acties vertraagd.\n\nJe ziet de knop Toegankelijkheid vóór andere apps op het scherm. Tik op de knop om te vergroten."</string>
    <string name="accessibility_magnification_switch_shortcut_positive_button" msgid="2446942190957296957">"Overschakelen naar knop Toegankelijkheid"</string>
    <string name="accessibility_magnification_switch_shortcut_negative_button" msgid="7115794462123071594">"3 keer tikken gebruiken"</string>
    <string name="accessibility_magnification_triple_tap_warning_title" msgid="8484669851397296597">"Dit kan je toetsenbord langzamer maken"</string>
    <string name="accessibility_magnification_triple_tap_warning_message" msgid="2008671502848936410">"Als je 3 keer tikken gebruikt om een deel van het scherm te vergroten, kun je problemen met het toetsenbord krijgen.\n\nJe kunt dit voorkomen door een ander gebaar in te stellen als je snelkoppeling voor vergroting.\n"<annotation id="link">"Instelling wijzigen"</annotation></string>
    <string name="accessibility_magnification_triple_tap_warning_positive_button" msgid="8712304035901450010">"Toch doorgaan"</string>
    <string name="accessibility_magnification_triple_tap_warning_negative_button" msgid="2028849736366584733">"Annuleren"</string>
    <string name="accessibility_magnification_service_settings_title" msgid="3531350704632316017">"Instellingen voor vergroting"</string>
    <string name="accessibility_screen_magnification_navbar_title" msgid="480853328665484528">"Vergroten met sneltoets"</string>
    <string name="accessibility_screen_magnification_state_navbar_gesture" msgid="8067042663897802231">"Vergroten met sneltoets en drie keer tikken"</string>
    <string name="accessibility_introduction_title" msgid="8834950581512452348">"Over <xliff:g id="SERVICE">%1$s</xliff:g>"</string>
    <string name="accessibility_text_reading_options_title" msgid="3224648909213325563">"Weergavegrootte en tekst"</string>
    <string name="accessibility_text_reading_options_suggestion_title" msgid="2492155642665312733">"Wijzigen hoe tekst wordt getoond"</string>
    <string name="accessibility_text_reading_preview_mail_subject" msgid="4597374768612733616">"Onderwerp: Ontwerpen voor heteluchtballonnen"</string>
    <string name="accessibility_text_reading_preview_mail_from" msgid="1797499780365288020">"Van: Bill"</string>
    <string name="accessibility_text_reading_preview_mail_content" msgid="8078152365771951802">"Goeiemorgen!\n\nIk wilde even vragen hoe het met de ontwerpen gaat. Zijn ze klaar voordat we de nieuwe ballonnen gaan maken?"</string>
    <string name="accessibility_text_reading_reset_button_title" msgid="5960753279788187669">"Instellingen resetten"</string>
    <string name="accessibility_text_reading_reset_message" msgid="824644303661026712">"Instellingen voor weergavegrootte en tekst zijn gereset"</string>
    <string name="accessibility_text_reading_confirm_dialog_title" msgid="2865331351355690389">"Weergavegrootte en tekst resetten?"</string>
    <string name="accessibility_text_reading_confirm_dialog_reset_button" msgid="8215800137850243736">"Resetten"</string>
    <string name="accessibility_text_reading_conversation_message_1" msgid="7883952203831957831">"Heb je plannen voor het weekend?"</string>
    <string name="accessibility_text_reading_conversation_message_2" msgid="8112160435318635856">"Ik ga naar het strand. Ga je mee?"</string>
    <string name="accessibility_screen_option" msgid="8465307075278878145">"Opties"</string>
    <string name="accessibility_preference_magnification_summary" msgid="2875518904115896888">"Inzoomen op scherm"</string>
    <string name="accessibility_screen_magnification_short_summary" msgid="2207048420669939150">"Tik drie keer om te zoomen"</string>
    <string name="accessibility_screen_magnification_navbar_short_summary" msgid="4885018322430052037">"Zoomen door te tikken op een knop"</string>
    <string name="accessibility_screen_magnification_intro_text" msgid="3856180549393526339">"Zoom snel in op het scherm om content groter te maken"</string>
    <string name="accessibility_screen_magnification_summary" msgid="8267672508057326959">"&lt;b&gt;Zo zoom je in:&lt;/b&gt;&lt;br/&gt; {0,number,integer}. Gebruik de snelkoppeling om de vergroting te starten.&lt;br/&gt; {1,number,integer}. Tik op het scherm.&lt;br/&gt; {2,number,integer}. Sleep met 2 vingers om te navigeren op het scherm.&lt;br/&gt; {3,number,integer}. Knijp met 2 vingers om het zoomniveau aan te passen.&lt;br/&gt; {4,number,integer}. Gebruik de snelkoppeling om de vergroting te stoppen.&lt;br/&gt;&lt;br/&gt; &lt;b&gt;Zo zoom je tijdelijk in:&lt;/b&gt;&lt;br/&gt; {0,number,integer}. Zorg dat je vergrotingstype is ingesteld op volledig scherm.&lt;br/&gt; {1,number,integer}. Gebruik de snelkoppeling om de vergroting te starten.&lt;br/&gt; {2,number,integer}. Houd je vinger op het scherm.&lt;br/&gt; {3,number,integer}. Sleep met een vinger om te navigeren op het scherm.&lt;br/&gt; {4,number,integer}. Haal je vinger van het scherm om de vergroting te stoppen."</string>
    <string name="accessibility_screen_magnification_navbar_summary" msgid="807985499898802296">"Als vergroting aanstaat, kun je op je scherm het beeld vergroten.\n\n"<b>"Als je wilt inzoomen"</b>", start je de vergroting en tik je waar dan ook op het scherm.\n"<ul><li>"Veeg met 2 of meer vingers om te scrollen."</li>\n<li>"Knijp 2 of meer vingers samen om de zoom aan te passen."</li></ul>\n\n<b>"Als je tijdelijk wilt zoomen"</b>", start je de vergroting, waarna je ergens op het scherm tikt en vasthoudt.\n"<ul><li>"Sleep om een ander deel van het scherm weer te geven."</li>\n<li>"Haal je vinger van het scherm om uit te zoomen."</li></ul>\n\n"Je kunt niet inzoomen op het toetsenbord of de navigatiebalk."</string>
    <string name="accessibility_tutorial_pager" msgid="8461939455728454061">"Pagina <xliff:g id="CURRENT_PAGE">%1$d</xliff:g> van <xliff:g id="NUM_PAGES">%2$d</xliff:g>"</string>
    <string name="accessibility_tutorial_dialog_title_button" msgid="4681164949716215131">"Knop Toegankelijkheid gebruiken om te openen"</string>
    <string name="accessibility_tutorial_dialog_title_volume" msgid="494810949830845234">"Houd de volumetoetsen ingedrukt om te openen"</string>
    <string name="accessibility_tutorial_dialog_title_triple" msgid="7089562919284464400">"Tik 3 keer op het scherm om te openen"</string>
    <string name="accessibility_tutorial_dialog_title_gesture" msgid="4965810097646659332">"Gebaar gebruiken om te openen"</string>
    <string name="accessibility_tutorial_dialog_title_gesture_settings" msgid="6800684770875867559">"Toegankelijkheidsgebaar gebruiken"</string>
    <string name="accessibility_tutorial_dialog_message_button" msgid="7002398857479782303">"Als je deze functie wilt gebruiken, tik je onderaan het scherm op de knop Toegankelijkheid <xliff:g id="ACCESSIBILITY_ICON">%s</xliff:g>.\n\nTik op de knop Toegankelijkheid en houd deze vast om tussen functies te schakelen."</string>
    <string name="accessibility_tutorial_dialog_message_floating_button" msgid="2551777208185138391">"Tik op de knop Toegankelijkheid op het scherm om deze functie te gebruiken."</string>
    <string name="accessibility_tutorial_dialog_message_volume" msgid="5033080515460519183">"Als je deze functie wilt gebruiken, houd je beide volumetoetsen ingedrukt."</string>
    <string name="accessibility_tutorial_dialog_message_triple" msgid="5219991116201165146">"Tik ergens op je scherm om de vergroting te starten of te stoppen."</string>
    <string name="accessibility_tutorial_dialog_message_gesture" msgid="4148062210755434854">"Als je deze functie wilt gebruiken, swipe je met twee vingers omhoog vanaf de onderkant van het scherm.\n\nSwipe met twee vingers omhoog en houd vast om tussen functies te schakelen."</string>
    <string name="accessibility_tutorial_dialog_message_gesture_talkback" msgid="8142847782708562793">"Als je deze functie wilt gebruiken, swipe je met 3 vingers omhoog vanaf de onderkant van het scherm.\n\nSwipe met 3 vingers omhoog en houd vast om tussen functies te schakelen."</string>
    <string name="accessibility_tutorial_dialog_message_gesture_settings" msgid="40769674586981429">"Als je een toegankelijkheidsfunctie wilt gebruiken, swipe je met twee vingers omhoog vanaf de onderkant van het scherm.\n\nSwipe met twee vingers omhoog en houd vast om tussen functies te schakelen."</string>
    <string name="accessibility_tutorial_dialog_message_gesture_settings_talkback" msgid="7292969929578621958">"Als je een toegankelijkheidsfunctie wilt gebruiken, swipe je met 3 vingers omhoog vanaf de onderkant van het scherm.\n\nSwipe met 3 vingers omhoog en houd vast om tussen functies te schakelen."</string>
    <string name="accessibility_tutorial_dialog_button" msgid="2031773187678948436">"OK"</string>
    <!-- no translation found for accessibility_tutorial_dialog_link_button (6797349445794031781) -->
    <skip />
    <string name="accessibility_shortcut_title" msgid="8125867833704517463">"Snelkoppeling voor <xliff:g id="SERVICE">%1$s</xliff:g>"</string>
    <string name="accessibility_shortcut_edit_summary_software" msgid="6405629977940618205">"Knop Toegankelijkheid"</string>
    <string name="accessibility_shortcut_edit_summary_software_gesture" msgid="5489284264414421286">"Toegankelijkheidsgebaar"</string>
    <string name="accessibility_shortcut_edit_dialog_title_software_gesture" msgid="8078659880723370597">"Met twee vingers omhoog swipen"</string>
    <string name="accessibility_shortcut_edit_dialog_title_software_gesture_talkback" msgid="7422753388389160524">"Met 3 vingers omhoog swipen"</string>
    <string name="accessibility_shortcut_edit_dialog_title_software" msgid="4796192466943479849">"Op de knop Toegankelijkheid tikken"</string>
    <string name="accessibility_shortcut_edit_dialog_title_software_by_gesture" msgid="3981188764050497346">"Toegankelijkheidsgebaar gebruiken"</string>
    <string name="accessibility_shortcut_edit_dialog_summary_software" msgid="5606196352833449600">"Tik op de knop Toegankelijkheid <xliff:g id="ACCESSIBILITY_ICON">%s</xliff:g> onderaan je scherm.\n\nTik op de knop Toegankelijkheid en houd vast om tussen functies te schakelen."</string>
    <string name="accessibility_shortcut_edit_dialog_summary_software_gesture" msgid="8292555254353761635">"Swipe met twee vingers omhoog vanaf de onderkant van het scherm.\n\nSwipe met twee vingers omhoog en houd vast om tussen functies te schakelen."</string>
    <string name="accessibility_shortcut_edit_dialog_summary_software_gesture_talkback" msgid="84483464524360845">"Swipe met 3 vingers omhoog vanaf de onderkant van het scherm.\n\nSwipe met 3 vingers omhoog en houd vast om tussen functies te schakelen."</string>
    <string name="accessibility_shortcut_edit_dialog_summary_software_floating" msgid="4459254227203203324"><annotation id="link">"Meer opties"</annotation></string>
    <string name="footer_learn_more_content_description" msgid="8843798273152131341">"Meer informatie over <xliff:g id="SERVICE">%1$s</xliff:g>"</string>
    <string name="accessibility_shortcut_edit_dialog_title_hardware" msgid="2356853121810443026">"Volumetoetsen ingedrukt houden"</string>
    <string name="accessibility_shortcut_hardware_keyword" msgid="3921915304537166064">"volumetoetsen ingedrukt houden"</string>
    <string name="accessibility_shortcut_edit_dialog_summary_hardware" msgid="2503134386397991634">"Houd beide volumetoetsen ingedrukt"</string>
    <string name="accessibility_shortcut_edit_dialog_title_triple_tap" msgid="6672798007229795841">"3 keer op het scherm tikken"</string>
    <string name="accessibility_shortcut_triple_tap_keyword" msgid="6863958573135995927">"drie keer op het scherm tikken"</string>
    <string name="accessibility_shortcut_edit_dialog_summary_triple_tap" msgid="2102327956423320536">"Tik snel {0,number,integer} keer op het scherm. Deze snelkoppeling kan je apparaat vertragen."</string>
    <string name="accessibility_shortcut_edit_dialog_title_advance" msgid="4567868630655591506">"Geavanceerd"</string>
    <string name="accessibility_screen_magnification_navbar_configuration_warning" msgid="266736851606791552">"Toegankelijkheid is ingesteld op <xliff:g id="SERVICE">%1$s</xliff:g>. Als je vergroting wilt gebruiken, tik je op de knop Toegankelijkheid, houd je deze vast en selecteer je Vergroting."</string>
    <string name="accessibility_screen_magnification_gesture_navigation_warning" msgid="991017769735632046">"Het toegankelijkheidsgebaar is ingesteld op <xliff:g id="SERVICE">%1$s</xliff:g>. Als je vergroting wilt gebruiken, swipe je met twee vingers omhoog vanaf het onderkant van het scherm en houd je vast. Selecteer vervolgens Vergroting."</string>
    <string name="accessibility_global_gesture_preference_title" msgid="3713636732641882959">"Sneltoets via volumeknop"</string>
    <string name="accessibility_shortcut_settings" msgid="836783442658447995">"Instellingen voor snelkoppelingen"</string>
    <string name="accessibility_shortcut_service_on_lock_screen_title" msgid="3923122834058574478">"Snelkoppeling vanaf vergrendelscherm"</string>
    <string name="accessibility_shortcut_description" msgid="2184693606202133549">"Sta toe dat de functiesnelkoppeling wordt aangezet vanaf het vergrendelscherm. Houd beide volumetoetsen een paar seconden ingedrukt."</string>
    <string name="accessibility_button_title" msgid="5251235485581552614">"Knop Toegankelijkheid"</string>
    <string name="accessibility_button_gesture_title" msgid="3573456209050374139">"Knop Toegankelijkheid en gebaar"</string>
    <string name="accessibility_button_intro_text" msgid="80993874471745687">"Krijg snel vanaf elk scherm toegang tot toegankelijkheidsfuncties"</string>
    <string name="accessibility_button_about_title" msgid="3581116105084067926">"Over de knop Toegankelijkheid"</string>
    <string name="accessibility_button_gesture_about_title" msgid="8468987303602865536">"Over de knop en het gebaar voor toegankelijkheid"</string>
    <string name="accessibility_button_gesture_footer_learn_more_content_description" msgid="4144803517680297869">"Meer informatie over de knop Toegankelijkheid en het toegankelijkheidsgebaar"</string>
    <string name="accessibility_button_intro" msgid="2601976470525277903">"De toegankelijkheidsknop gebruiken. Het gebaar is niet beschikbaar bij navigatie met 3 knoppen."</string>
    <string name="accessibility_button_summary" msgid="8510939012631455831">"Krijg snel toegang tot toegankelijkheidsfuncties"</string>
    <string name="accessibility_button_gesture_description" msgid="7507097717493960397"><b>"Aan de slag"</b>\n"1. Ga naar de toegankelijkheidsinstellingen.\n2. Selecteer een functie en tik op de snelkoppeling.\n3. Kies of je een knop of gebaar wilt gebruiken om de functie te openen."</string>
    <string name="accessibility_button_description" msgid="1261273371298608222"><b>"Aan de slag"</b>\n"1. Ga naar de toegankelijkheidsinstellingen.\n2. Selecteer een functie en tik op de snelkoppeling.\n3. Kies de knop waarmee je de functie wilt openen."</string>
    <string name="accessibility_button_or_gesture_title" msgid="3510075963401163529">"Knop of gebaar gebruiken"</string>
    <string name="accessibility_button_location_title" msgid="7182107846092304942">"Locatie"</string>
    <string name="accessibility_button_size_title" msgid="5785110470538960881">"Formaat"</string>
    <string name="accessibility_button_fade_title" msgid="8081993897680588829">"Vervagen indien niet in gebruik"</string>
    <string name="accessibility_button_fade_summary" msgid="7865950833524973709">"Vervaagt na een paar seconden zodat je je scherm beter kunt zien"</string>
    <string name="accessibility_button_opacity_title" msgid="4727355657530362289">"Transparantie indien niet in gebruik"</string>
    <string name="accessibility_button_low_label" msgid="4193015407828927741">"Transparant"</string>
    <string name="accessibility_button_high_label" msgid="9138077512008190896">"Niet-transparant"</string>
    <string name="accessibility_toggle_high_text_contrast_preference_title" msgid="1830189632458752698">"Tekst met hoog contrast"</string>
    <string name="accessibility_toggle_high_text_contrast_preference_summary" msgid="5286411556836346180">"Wijzig de tekstkleur in zwart of wit. Zo maximaliseer je het contrast met de achtergrond."</string>
    <string name="accessibility_toggle_screen_magnification_auto_update_preference_title" msgid="4987009529235165664">"Schermvergroting automatisch updaten"</string>
    <string name="accessibility_toggle_screen_magnification_auto_update_preference_summary" msgid="9034532513972547720">"Schermvergroting updaten bij app-overgangen"</string>
    <string name="accessibility_power_button_ends_call_prerefence_title" msgid="8187306131979612144">"Aan/uit-knop beëindigt gesprek"</string>
    <string name="accessibility_toggle_large_pointer_icon_title" msgid="5508351959249876801">"Grote muisaanwijzer"</string>
    <string name="accessibility_toggle_large_pointer_icon_summary" msgid="1480527946039237705">"Maak de muisaanwijzer duidelijker"</string>
    <string name="accessibility_disable_animations" msgid="2993529829457179058">"Animaties verwijderen"</string>
    <string name="accessibility_disable_animations_summary" msgid="5828228669556554565">"Minder beweging op het scherm"</string>
    <string name="accessibility_toggle_primary_mono_title" msgid="7587152099472946571">"Monogeluid"</string>
    <string name="accessibility_toggle_primary_mono_summary" msgid="1935283927319407303">"Combineer kanalen bij het afspelen van geluid"</string>
    <string name="accessibility_toggle_primary_balance_title" msgid="7332275200153366714">"Audiobalans"</string>
    <string name="accessibility_toggle_primary_balance_left_label" msgid="6415750010517682014">"Links"</string>
    <string name="accessibility_toggle_primary_balance_right_label" msgid="2987443495390104935">"Rechts"</string>
    <string name="accessibility_timeout_default" msgid="1033702739376842824">"Standaard"</string>
    <string name="accessibility_timeout_10secs" msgid="5072577454521239794">"10 seconden"</string>
    <string name="accessibility_timeout_30secs" msgid="7814673496724760684">"30 seconden"</string>
    <string name="accessibility_timeout_1min" msgid="4804644263166961262">"1 minuut"</string>
    <string name="accessibility_timeout_2mins" msgid="7901692984522708679">"2 minuten"</string>
    <string name="accessibility_setting_item_control_timeout_title" msgid="1600516937989217899">"Tijd voor actie (time-out voor toegankelijkheid)"</string>
    <string name="accessibility_control_timeout_about_title" msgid="813588002683460837">"Over Tijd voor actie (time-out voor toegankelijkheid)"</string>
    <string name="accessibility_control_timeout_footer_learn_more_content_description" msgid="8118584413220542193">"Meer informatie over Tijd voor actie (time-out voor toegankelijkheid)"</string>
    <string name="accessibility_control_timeout_preference_title" msgid="1443940538597464758">"Tijd om actie te ondernemen"</string>
    <string name="accessibility_control_timeout_preference_summary" msgid="4037051091059316310">"Niet alle apps ondersteunen deze voorkeur voor timing."</string>
    <string name="accessibility_control_timeout_preference_intro_text" msgid="1398116710556762245">"Kies hoelang je tijdelijke berichten wilt zien die je vragen om actie te ondernemen"</string>
    <string name="accessibility_long_press_timeout_preference_title" msgid="5237764682976688855">"Vertraging voor blijven aanraken"</string>
    <string name="accessibility_display_inversion_preference_title" msgid="5476133104746207952">"Kleurinversie"</string>
    <string name="accessibility_display_inversion_switch_title" msgid="7458595722552743503">"Kleurinversie gebruiken"</string>
    <string name="accessibility_display_inversion_shortcut_title" msgid="6889624526691513462">"Snelkoppeling voor kleurinversie"</string>
    <string name="accessibility_display_inversion_preference_intro_text" msgid="1159663288481145318">"Met Kleurinversie worden lichte schermen donker en donkere schermen licht"</string>
    <string name="accessibility_display_inversion_preference_subtitle" msgid="4494767676482389509">"&lt;b&gt;Houd rekening met het volgende:&lt;/b&gt;&lt;br/&gt; &lt;ol&gt; &lt;li&gt; Kleuren in media en afbeeldingen veranderen.&lt;/li&gt; &lt;li&gt; Kleurinversie werkt voor alle apps.&lt;/li&gt; &lt;li&gt; Als je een donkere achtergrond wilt hebben, kun je in plaats daarvan het donkere thema gebruiken.&lt;/li&gt; &lt;/ol&gt;"</string>
    <string name="accessibility_autoclick_preference_title" msgid="2703143361605555752">"Automatisch klikken (rusttijd)"</string>
    <string name="accessibility_autoclick_about_title" msgid="152923024405552594">"Over automatisch klikken (rusttijd)"</string>
    <string name="accessibility_autoclick_footer_learn_more_content_description" msgid="7056189627042350691">"Meer informatie over automatisch klikken (rusttijd)"</string>
    <string name="accessibility_autoclick_intro_text" msgid="8959680635470639347">"Je kunt instellen dat een verbonden muis automatisch klikt als de cursor gedurende een bepaalde tijd niet beweegt"</string>
    <string name="accessibility_autoclick_description" msgid="6695732131412361101">"Automatisch klikken kan handig zijn als klikken met de muis moeilijk voor je is."</string>
    <string name="accessibility_autoclick_default_title" msgid="2024730028293793490">"Automatisch klikken uit"</string>
    <string name="accessibility_autoclick_short_title" msgid="7938302504358912984">"Kort"</string>
    <string name="accessibility_autoclick_short_summary" msgid="4106953930081213514">"0,2 seconden"</string>
    <string name="accessibility_autoclick_medium_title" msgid="3134175117576834320">"Gemiddeld"</string>
    <string name="accessibility_autoclick_medium_summary" msgid="1343390686514222871">"0,6 seconden"</string>
    <string name="accessibility_autoclick_long_title" msgid="6799311820641687735">"Lang"</string>
    <string name="accessibility_autoclick_long_summary" msgid="3747153151313563637">"1 seconde"</string>
    <string name="accessibility_autoclick_custom_title" msgid="4597792235546232038">"Aangepast"</string>
    <string name="accessibility_autoclick_shorter_desc" msgid="7631013255724544348">"Korter"</string>
    <string name="accessibility_autoclick_longer_desc" msgid="2566025502981487443">"Langer"</string>
    <string name="accessibility_autoclick_seekbar_desc" msgid="8363959277814621118">"Tijd voor automatisch klikken"</string>
    <string name="accessibility_vibration_settings_title" msgid="936301142478631993">"Trillen en haptische technologie"</string>
    <string name="accessibility_vibration_settings_summary" msgid="3690308537483465527">"De trillingssterkte beheren voor verschillende typen gebruik"</string>
    <string name="accessibility_vibration_settings_state_on" msgid="5566026932372832502">"Aan"</string>
    <string name="accessibility_vibration_settings_state_off" msgid="7946588741954981703">"Uit"</string>
    <string name="accessibility_vibration_setting_disabled_for_silent_mode_summary" msgid="3982701772953323190">"Instelling staat uit omdat het apparaat op stil staat"</string>
    <string name="accessibility_call_vibration_category_title" msgid="2545607568768192318">"Gesprekken"</string>
    <string name="accessibility_notification_alarm_vibration_category_title" msgid="2683635252414849417">"Meldingen en wekkers"</string>
    <string name="accessibility_interactive_haptics_category_title" msgid="3162855291184592021">"Interactieve haptische technologie"</string>
    <string name="accessibility_vibration_primary_switch_title" msgid="6162579254864450592">"Trillen en haptische technologie gebruiken"</string>
    <string name="accessibility_alarm_vibration_title" msgid="4661294337828522745">"Trilling bij wekker"</string>
    <string name="accessibility_media_vibration_title" msgid="1372073715403945428">"Trilling bij media"</string>
    <string name="accessibility_ring_vibration_title" msgid="4689811297654320885">"Trilling bij bellen"</string>
    <string name="accessibility_notification_vibration_title" msgid="6205679908785776478">"Trilling bij melding"</string>
    <string name="accessibility_touch_vibration_title" msgid="533931451319110741">"Tikfeedback"</string>
    <string name="accessibility_service_primary_switch_title" msgid="437610853412159406">"<xliff:g id="ACCESSIBILITY_APP_NAME">%1$s</xliff:g> gebruiken"</string>
    <string name="accessibility_service_primary_open_title" msgid="8655108684769091154">"<xliff:g id="ACCESSIBILITY_APP_NAME">%1$s</xliff:g> openen"</string>
    <string name="accessibility_service_auto_added_qs_tooltip_content" msgid="2941824314912928072">"<xliff:g id="ACCESSIBILITY_APP_NAME">%1$s</xliff:g> is toegevoegd aan Snelle instellingen. Swipe omlaag om deze functie op elk moment aan of uit te zetten."</string>
    <string name="accessibility_service_qs_tooltip_content" msgid="6002493441414967868">"Je kunt <xliff:g id="ACCESSIBILITY_APP_NAME">%1$s</xliff:g> ook aan Snelle instellingen toevoegen vanaf de bovenkant van het scherm"</string>
    <string name="accessibility_color_correction_auto_added_qs_tooltip_content" msgid="9092661358437404374">"Kleurcorrectie is toegevoegd aan Snelle instellingen. Swipe omlaag om deze functie op elk moment aan of uit te zetten."</string>
    <string name="accessibility_color_correction_qs_tooltip_content" msgid="3258628434235475205">"Je kunt kleurcorrectie ook aan Snelle instellingen toevoegen vanaf de bovenkant van het scherm"</string>
    <string name="accessibility_color_inversion_auto_added_qs_tooltip_content" msgid="7267618234972101725">"Kleurinversie is toegevoegd aan Snelle instellingen. Swipe omlaag om deze functie op elk moment aan of uit te zetten."</string>
    <string name="accessibility_color_inversion_qs_tooltip_content" msgid="5046332142185711869">"Je kunt kleurinversie ook aan Snelle instellingen toevoegen vanaf de bovenkant van het scherm"</string>
    <string name="accessibility_reduce_bright_colors_auto_added_qs_tooltip_content" msgid="1906588335786328512">"Extra dimmen is toegevoegd aan Snelle instellingen. Swipe omlaag om deze functie op elk moment aan of uit te zetten."</string>
    <string name="accessibility_reduce_bright_colors_qs_tooltip_content" msgid="7522121299176176785">"Je kunt extra dimmen ook aan Snelle instellingen toevoegen vanaf de bovenkant van het scherm"</string>
    <string name="accessibility_one_handed_mode_auto_added_qs_tooltip_content" msgid="7914554254280416532">"Bediening met 1 hand is toegevoegd aan Snelle instellingen. Swipe omlaag om deze functie op elk moment aan of uit te zetten."</string>
    <string name="accessibility_one_handed_mode_qs_tooltip_content" msgid="2754332083184384603">"Je kunt bediening met 1 hand ook aan Snelle instellingen toevoegen vanaf de bovenkant van het scherm"</string>
    <string name="accessibility_font_scaling_auto_added_qs_tooltip_content" msgid="7229921960884718332">"Lettergrootte toegevoegd aan Snelle instellingen. Swipe omlaag om de lettergrootte te wijzigen wanneer je wilt."</string>
    <string name="accessibility_quick_settings_tooltip_dismiss" msgid="3269120277643884190">"Sluiten"</string>
    <string name="accessibility_daltonizer_primary_switch_title" msgid="32064721588910540">"Kleurcorrectie gebruiken"</string>
    <string name="accessibility_daltonizer_shortcut_title" msgid="7480360363995502369">"Snelkoppeling voor kleurcorrectie"</string>
    <string name="accessibility_daltonizer_about_title" msgid="6063650804116981287">"Over kleurcorrectie"</string>
    <string name="accessibility_daltonizer_footer_learn_more_content_description" msgid="2091679253892040910">"Meer informatie over kleurcorrectie"</string>
    <string name="accessibility_color_inversion_about_title" msgid="8275754480247040136">"Over kleurinversie"</string>
    <string name="accessibility_color_inversion_footer_learn_more_content_description" msgid="5382579548498952445">"Meer informatie over kleurinversie"</string>
    <string name="accessibility_captioning_primary_switch_title" msgid="3663677340286206100">"Ondertiteling tonen"</string>
    <string name="accessibility_captioning_primary_switch_summary" msgid="2544094070306830218">"Alleen voor ondersteunde apps"</string>
    <string name="captioning_appearance_title" msgid="3128792092290011408">"Grootte en stijl van ondertiteling"</string>
    <string name="captioning_appearance_summary" msgid="4620682807315588019">"Tekstgrootte <xliff:g id="ACCESSIBILITY_FONT_SIZE">%1$s</xliff:g>"</string>
    <string name="captioning_more_options_title" msgid="3484496882942539652">"Meer opties"</string>
    <string name="accessibility_captioning_preference_intro" msgid="8995427146374031134">"Pas de grootte en stijl van de ondertiteling aan zodat je deze makkelijker kunt lezen"</string>
    <string name="accessibility_captioning_preference_summary" msgid="8335768472978374255">"Niet alle media-apps ondersteunen deze voorkeuren voor de ondertiteling"</string>
    <string name="accessibility_shortcut_type_software" msgid="2552732582767687515">"Knop Toegankelijkheid"</string>
    <string name="accessibility_shortcut_type_software_gesture" msgid="5608959693931019059">"Omhoog swipen met twee vingers"</string>
    <string name="accessibility_shortcut_type_hardware" msgid="4834144210432451916">"Houd de volumetoetsen ingedrukt"</string>
    <string name="accessibility_shortcut_type_triple_tap" msgid="7717524216825494543">"Tik 3 keer op het scherm"</string>
    <string name="accessibility_hearingaid_instruction_continue_button" msgid="3367260988024430722">"Doorgaan"</string>
    <string name="accessibility_hearingaid_title" msgid="1263619711863375614">"Hoortoestellen"</string>
    <string name="accessibility_hearingaid_intro" msgid="5856992709195963850">"Je kunt hoortoestellen, cochleaire implantaten en andere versterkingsapparaten gebruiken met je telefoon"</string>
    <string name="accessibility_hearingaid_not_connected_summary" msgid="7438018718889849521">"Geen verbonden hoortoestellen"</string>
    <string name="accessibility_hearingaid_adding_summary" msgid="999051610528600783">"Hoortoestellen toevoegen"</string>
    <string name="accessibility_hearingaid_pair_instructions_title" msgid="2357706801112207624">"Hoortoestellen koppelen"</string>
    <string name="accessibility_hearingaid_pair_instructions_message" msgid="581652489109350119">"Tik op het volgende scherm op je hoortoestellen. Je moet je linker- en rechteroordopje misschien afzonderlijk koppelen.\n\nZorg dat je hoortoestellen aanstaan en klaar zijn voor koppelen."</string>
    <string name="accessibility_hearingaid_active_device_summary" msgid="509703438222873967">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g> actief"</string>
    <string name="accessibility_hearingaid_left_side_device_summary" msgid="1907302799168261001">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g>, alleen links"</string>
    <string name="accessibility_hearingaid_right_side_device_summary" msgid="148257064855054376">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g>, alleen rechts"</string>
    <string name="accessibility_hearingaid_left_and_right_side_device_summary" msgid="4268221140368164452">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g>, links en rechts"</string>
    <string name="accessibility_hearingaid_more_device_summary" msgid="8092641784056942546">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g> en nog 1 andere"</string>
    <string name="accessibility_hearing_device_pairing_title" msgid="2701812183769537320">"Nieuw apparaat koppelen"</string>
    <string name="accessibility_pair_hearing_device_about_title" msgid="5870335480815052755">"Over Nieuw apparaat koppelen"</string>
    <string name="accessibility_hearing_device_connected_title" msgid="3785140037249487287">"Hoortoestellen"</string>
    <string name="accessibility_hearing_device_saved_title" msgid="7573926212664909296">"Opgeslagen apparaten"</string>
    <string name="accessibility_hearing_device_control" msgid="2661965917013100611">"Bediening van hoortoestel"</string>
    <string name="accessibility_hearing_device_shortcut_title" msgid="7645100199603031360">"Snelkoppeling voor hoortoestel"</string>
    <string name="accessibility_hac_mode_title" msgid="2037950424429555652">"Geschiktheid voor hoortoestellen"</string>
    <string name="accessibility_hac_mode_summary" msgid="5198760061256669067">"Verbetert de compatibiliteit met luisterspoelen en beperkt ongewenst geluid"</string>
    <string name="accessibility_hearing_device_about_title" msgid="7883758309646288250">"Over hoortoestellen"</string>
    <string name="accessibility_hearing_device_footer_summary" msgid="7451899224828040581">"Zorg dat je hoortoestel aanstaat en klaar is voor koppelen"</string>
    <string name="accessibility_hearing_device_pairing_page_title" msgid="6608901091770850295">"Hoortoestel koppelen"</string>
    <string name="accessibility_found_hearing_devices" msgid="637407580358386553">"Beschikbare hoortoestellen"</string>
    <string name="accessibility_found_all_devices" msgid="7817834722148556520">"Zie je je hoortoestel niet?"</string>
    <string name="accessibility_list_all_devices_title" msgid="161495343959211216">"Meer apparaten zien"</string>
    <string name="accessibility_audio_adjustment_title" msgid="1332113739136802997">"Audioaanpassing"</string>
    <string name="accessibility_toggle_audio_description_preference_title" msgid="8916473886256061220">"Audiobeschrijving"</string>
    <string name="accessibility_audio_description_summary" msgid="2554789094873781056">"Hoor een beschrijving van wat er op het scherm gebeurt in ondersteunde films en series"</string>
    <string name="keywords_audio_description" msgid="6202816411593281252">"audiobeschrijving, audio, beschrijving, slechtziend"</string>
    <string name="accessibility_summary_shortcut_enabled" msgid="4030427268146752644">"Snelkoppeling aan"</string>
    <string name="accessibility_summary_shortcut_disabled" msgid="564005462092499068">"Uit"</string>
    <string name="accessibility_summary_state_enabled" msgid="1065431632216039369">"Aan"</string>
    <string name="accessibility_summary_state_disabled" msgid="9173234532752799694">"Uit"</string>
    <string name="accessibility_summary_state_stopped" msgid="2343602489802623424">"Werkt niet. Tik voor informatie."</string>
    <string name="accessibility_description_state_stopped" msgid="5364752492861199133">"Deze service werkt niet goed."</string>
    <string name="accessibility_shortcuts_settings_title" msgid="974740249671825145">"Snelkoppelingen voor toegankelijkheid"</string>
    <string name="enable_quick_setting" msgid="6648073323202243604">"Tonen in Snelle instellingen"</string>
    <string name="daltonizer_mode_deuteranomaly_title" msgid="4210949400493358650">"Rood-groen"</string>
    <string name="daltonizer_mode_protanomaly_title" msgid="6392456967103014723">"Rood-groen"</string>
    <string name="daltonizer_mode_tritanomaly_title" msgid="2278786218762602022">"Blauw-geel"</string>
    <string name="daltonizer_mode_grayscale_title" msgid="152005391387952588">"Grijstinten"</string>
    <string name="daltonizer_mode_deuteranomaly_summary" msgid="2117727423019598455">"Groen zwak, deuteranomalie"</string>
    <string name="daltonizer_mode_protanomaly_summary" msgid="4617032854982040748">"Rood zwak, protanomalie"</string>
    <string name="daltonizer_mode_tritanomaly_summary" msgid="2428218320118180070">"Tritanomalie"</string>
    <string name="reduce_bright_colors_preference_title" msgid="2249314004651574997">"Extra dimmen"</string>
    <string name="reduce_bright_colors_switch_title" msgid="1751678397884065312">"Scherm extra dimmen"</string>
    <string name="reduce_bright_colors_shortcut_title" msgid="495648157059202745">"Snelkoppeling voor extra dimmen"</string>
    <string name="reduce_bright_colors_about_title" msgid="503655452544934393">"Over extra dimmen"</string>
    <string name="reduce_bright_colors_preference_intro_text" msgid="3502290826747650566">"Zet de helderheid van je scherm lager zodat je prettiger kunt lezen"</string>
    <string name="reduce_bright_colors_intensity_preference_title" msgid="7455443033955118267">"Intensiteit"</string>
    <string name="reduce_bright_colors_intensity_start_label" msgid="930387498396426039">"Minder helder"</string>
    <string name="reduce_bright_colors_intensity_end_label" msgid="1422600205484299860">"Helderder"</string>
    <string name="reduce_bright_colors_persist_preference_title" msgid="4368829654993343354">"Aanhouden nadat het apparaat opnieuw is opgestart"</string>
    <string name="accessibilty_autoclick_preference_subtitle_short_delay" msgid="2981206111858937724">"{count,plural, =1{Kort ({time} seconde)}other{Kort ({time} seconden)}}"</string>
    <string name="accessibilty_autoclick_preference_subtitle_medium_delay" msgid="6867395206533459204">"{count,plural, =1{Gemiddeld ({time} seconde)}other{Gemiddeld ({time} seconden)}}"</string>
    <string name="accessibilty_autoclick_preference_subtitle_long_delay" msgid="4079139970819335593">"{count,plural, =1{Lang ({time} seconde)}other{Lang ({time} seconden)}}"</string>
    <string name="accessibilty_autoclick_delay_unit_second" msgid="5979297390686370567">"{count,plural, =1{{time} seconde}other{{time} seconden}}"</string>
    <string name="accessibility_menu_item_settings" msgid="2652637954865389271">"Instellingen"</string>
    <string name="accessibility_feature_state_on" msgid="1777344331063467511">"Aan"</string>
    <string name="accessibility_feature_state_off" msgid="169119895905460512">"Uit"</string>
    <string name="captioning_preview_title" msgid="2888561631323180535">"Voorbeeld"</string>
    <string name="captioning_standard_options_title" msgid="5360264497750980205">"Standaardopties"</string>
    <string name="captioning_locale" msgid="5533303294290661590">"Taal"</string>
    <string name="captioning_text_size" msgid="8039448543171463017">"Lettergrootte"</string>
    <string name="captioning_preset" msgid="4174276086501638524">"Ondertitelstijl"</string>
    <string name="captioning_custom_options_title" msgid="3858866498893566351">"Aangepaste opties"</string>
    <string name="captioning_background_color" msgid="5231412761368883107">"Achtergrondkleur"</string>
    <string name="captioning_background_opacity" msgid="6453738649182382614">"Ondoorzichtigheid van achtergrond"</string>
    <string name="captioning_window_color" msgid="1406167274530183119">"Kleur ondertitelingsvenster"</string>
    <string name="captioning_window_opacity" msgid="4031752812991199525">"Ondoorzichtigheid ondertitelingsvenster"</string>
    <string name="captioning_foreground_color" msgid="9057327228286129232">"Tekstkleur"</string>
    <string name="captioning_foreground_opacity" msgid="1395843080697567189">"Ondoorzichtigheid van tekst"</string>
    <string name="captioning_edge_color" msgid="6035818279902597518">"Randkleur"</string>
    <string name="captioning_edge_type" msgid="5281259280060811506">"Randtype"</string>
    <string name="captioning_typeface" msgid="285325623518361407">"Lettertypefamilie"</string>
    <string name="captioning_preview_text" msgid="4973475065545995704">"Ondertiteling ziet er zo uit"</string>
    <string name="captioning_preview_characters" msgid="7854812443613580460">"Aa"</string>
    <string name="locale_default" msgid="8948077172250925164">"Standaard"</string>
    <string name="color_title" msgid="2511586788643787427">"Kleur"</string>
    <string name="color_unspecified" msgid="4102176222255378320">"Standaard"</string>
    <string name="color_none" msgid="3703632796520710651">"Geen"</string>
    <string name="color_white" msgid="1896703263492828323">"Wit"</string>
    <string name="color_gray" msgid="8554077329905747877">"Grijs"</string>
    <string name="color_black" msgid="9006830401670410387">"Zwart"</string>
    <string name="color_red" msgid="5210756997426500693">"Rood"</string>
    <string name="color_green" msgid="4400462091250882271">"Groen"</string>
    <string name="color_blue" msgid="4997784644979140261">"Blauw"</string>
    <string name="color_cyan" msgid="4341758639597035927">"Cyaan"</string>
    <string name="color_yellow" msgid="5957551912912679058">"Geel"</string>
    <string name="color_magenta" msgid="8943538189219528423">"Magenta"</string>
    <string name="enable_service_title" msgid="7231533866953706788">"Toestaan dat <xliff:g id="SERVICE">%1$s</xliff:g> volledige controle over je apparaat heeft?"</string>
    <string name="capabilities_list_title" msgid="1225853611983394386">"\'<xliff:g id="SERVICE">%1$s</xliff:g>\' moet het volgende kunnen:"</string>
    <string name="touch_filtered_warning" msgid="4225815157460318241">"Aangezien een app een rechtenverzoek afdekt, kan Instellingen je reactie niet verifiëren."</string>
    <string name="accessibility_service_warning" msgid="6779187188736432618">"<xliff:g id="SERVICE">%1$s</xliff:g> vraagt om volledig beheer voor dit apparaat. De service kan het scherm lezen en handelen namens gebruikers met toegankelijkheidsbehoeften. Dit beheerniveau is voor de meeste apps niet gepast."</string>
    <string name="accessibility_service_warning_description" msgid="6573203795976134751">"Volledige controle is gepast voor apps die je helpen met toegankelijkheid, maar niet voor de meeste andere apps."</string>
    <string name="accessibility_service_screen_control_title" msgid="324795030658109870">"Scherm bekijken en bedienen"</string>
    <string name="accessibility_service_screen_control_description" msgid="8431940515157990426">"De functie kan alle content op het scherm lezen en content bovenop andere apps weergeven."</string>
    <string name="accessibility_service_action_perform_title" msgid="1449360056585337833">"Acties bekijken en uitvoeren"</string>
    <string name="accessibility_service_action_perform_description" msgid="7807832069800034738">"De functie kan je interacties met een app of een hardwaresensor bijhouden en namens jou met apps communiceren."</string>
    <string name="accessibility_dialog_button_allow" msgid="8274918676473216697">"Toestaan"</string>
    <string name="accessibility_dialog_button_deny" msgid="2037249860078259284">"Weigeren"</string>
    <string name="accessibility_dialog_button_stop" msgid="7295448112784528196">"Stoppen"</string>
    <string name="accessibility_dialog_button_cancel" msgid="4813234247237851121">"Annuleren"</string>
    <string name="disable_service_title" msgid="2909108731776956167">"<xliff:g id="SERVICE">%1$s</xliff:g> beëindigen?"</string>
    <string name="disable_service_message" msgid="4814173941688548016">"Als je op <xliff:g id="STOP">%1$s</xliff:g> tikt, wordt <xliff:g id="SERVICE">%2$s</xliff:g> gestopt."</string>
    <string name="accessibility_no_services_installed" msgid="3725569493860028593">"Geen services geïnstalleerd"</string>
    <string name="accessibility_no_service_selected" msgid="1310596127128379897">"Geen service geselecteerd"</string>
    <string name="accessibility_service_default_description" msgid="7801435825448138526">"Geen beschrijving opgegeven."</string>
    <string name="settings_button" msgid="2195468788019730377">"Instellingen"</string>
    <string name="keywords_reduce_bright_colors" msgid="1683190961013139183">"lichtgevoeligheid, fotofobie, donker thema, migraine, hoofdpijn, leesstand, nachtstand, helderheid verlagen, witpunt"</string>
    <string name="keywords_accessibility" msgid="4263443239404659143">"gebruiksgemak, makkelijke toegang, ondersteuning, ondersteunend"</string>
    <string name="keywords_magnification" msgid="3908145308269840862">"venstervergroting, zoom, vergroting, slechtziend, vergroten, groter maken"</string>
    <string name="keywords_talkback" msgid="2816435437095102527"></string>
    <string name="keywords_live_caption" msgid="1667203998080567556">"ondertiteling, ondertiteling voor doven en slechthorenden, CC, Live transcriptie, slechthorend, gehoorverlies, CART, spraak naar tekst, ondertitels"</string>
    <string name="keywords_live_transcribe" msgid="3226990195174890997"></string>
    <string name="keywords_sound_notifications" msgid="8183107485754075413"></string>
    <string name="keywords_sound_amplifier" msgid="939404835256246663"></string>
    <string name="keywords_display_size" msgid="5286419615221231518">"schermgrootte, groot scherm"</string>
    <string name="keywords_bold_text" msgid="6257418169207099589">"hoog contrast, slechtziend, vetgedrukt lettertype, vetgedrukte tekst"</string>
    <string name="keywords_select_to_speak" msgid="2872704811610888719"></string>
    <string name="keywords_color_correction" msgid="8540442886990423681">"kleuren aanpassen"</string>
    <string name="keywords_color_inversion" msgid="4291058365873221962">"scherm donker maken, scherm licht maken"</string>
    <string name="keywords_contrast" msgid="4668393735398949873">"kleurcontrast"</string>
    <string name="keywords_accessibility_menu" msgid="4300579436464706608"></string>
    <string name="keywords_switch_access" msgid="5813094504384313402"></string>
    <string name="keywords_auto_click" msgid="7151756353013736931">"motorisch, muis"</string>
    <string name="keywords_hearing_aids" msgid="4550504337687223314">"hoortoestellen, slechthorend, gehoorverlies, cochleaire implantaten, versterkingsapparaten, geluidsprocessors"</string>
    <string name="keywords_rtt" msgid="2429130928152514402">"slechthorend, gehoorverlies, ondertiteling, teletype, TTY"</string>
    <string name="keywords_voice_access" msgid="7807335263195876454"></string>
    <string name="print_settings" msgid="8519810615863882491">"Afdrukken"</string>
    <string name="print_settings_summary_no_service" msgid="6721731154917653862">"Uit"</string>
    <string name="print_settings_summary" msgid="1458773840720811915">"{count,plural, =1{1 afdrukservice aan}other{# afdrukservices aan}}"</string>
    <string name="print_jobs_summary" msgid="7040836482336577323">"{count,plural, =1{1 afdruktaak}other{# afdruktaken}}"</string>
    <string name="print_settings_title" msgid="7680498284751129935">"Afdrukservices"</string>
    <string name="print_no_services_installed" msgid="7554057966540602692">"Geen services geïnstalleerd"</string>
    <string name="print_no_printers_found" msgid="4833082484646109486">"Geen printers gevonden"</string>
    <string name="print_menu_item_settings" msgid="8202755044784599740">"Instellingen"</string>
    <string name="print_menu_item_add_printers" msgid="7958192149202584039">"Printers toevoegen"</string>
    <string name="print_feature_state_on" msgid="7132063461008624685">"Aan"</string>
    <string name="print_feature_state_off" msgid="1466195699995209446">"Uit"</string>
    <string name="print_menu_item_add_service" msgid="1549091062463044676">"Service toevoegen"</string>
    <string name="print_menu_item_add_printer" msgid="8711630848324870892">"Printer toevoegen"</string>
    <string name="print_menu_item_search" msgid="5989979785203603169">"Zoeken"</string>
    <string name="print_searching_for_printers" msgid="5401413178028348800">"Printers zoeken"</string>
    <string name="print_service_disabled" msgid="9185935228930987786">"Service staat uit"</string>
    <string name="print_print_jobs" msgid="2605944855933091183">"Afdruktaken"</string>
    <string name="print_print_job" msgid="8477859161886726608">"Afdruktaak"</string>
    <string name="print_restart" msgid="4424096106141083945">"Opnieuw starten"</string>
    <string name="print_cancel" msgid="7611266511967568501">"Annuleren"</string>
    <string name="print_job_summary" msgid="277210060872032969">"<xliff:g id="PRINTER">%1$s</xliff:g>\n<xliff:g id="TIME">%2$s</xliff:g>"</string>
    <string name="print_configuring_state_title_template" msgid="2887013172492183045">"<xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g> instellen"</string>
    <string name="print_printing_state_title_template" msgid="7367513245156603431">"<xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g> afdrukken"</string>
    <string name="print_cancelling_state_title_template" msgid="9094795458159980190">"<xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g> annuleren"</string>
    <string name="print_failed_state_title_template" msgid="4751695809935404505">"Printerfout <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_blocked_state_title_template" msgid="3134100215188411074">"<xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g> geblokkeerd door printer"</string>
    <string name="print_search_box_shown_utterance" msgid="6215002365360341961">"Zoekvak getoond"</string>
    <string name="print_search_box_hidden_utterance" msgid="5355387966141712567">"Zoekvak verborgen"</string>
    <string name="printer_info_desc" msgid="1206872325746154206">"Meer informatie over deze printer"</string>
    <string name="power_usage_summary_title" msgid="4198312848584882113">"Batterij"</string>
    <string name="power_usage_summary" msgid="6857382582534984531">"Waarvoor de batterij is gebruikt"</string>
    <string name="power_usage_level_and_status" msgid="821521456989429593">"<xliff:g id="LEVEL">%1$s</xliff:g> - <xliff:g id="STATUS">%2$s</xliff:g>"</string>
    <string name="power_discharge_remaining" msgid="6997529817917076536">"<xliff:g id="REMAIN">%1$s</xliff:g> tot batterij leeg is"</string>
    <string name="power_charge_remaining" msgid="7046064326172265116">"<xliff:g id="UNTIL_CHARGED">%1$s</xliff:g> tot batterij is opgeladen"</string>
    <string name="low_battery_summary" msgid="4458925347316501953">"Batterij bijna leeg"</string>
    <string name="background_activity_summary" msgid="3817376868497046016">"Toestaan dat de app wordt uitgevoerd op de achtergrond"</string>
    <string name="background_activity_warning_dialog_title" msgid="3449566823290744823">"Achtergrondactiviteit beperken?"</string>
    <string name="background_activity_warning_dialog_text" msgid="8202776985767701095">"Als je de achtergrondactiviteit voor een app beperkt, functioneert de app mogelijk niet meer correct"</string>
    <string name="background_activity_disabled_dialog_text" msgid="4053170297325882494">"Batterijoptimalisatie is niet ingesteld voor deze app. Je kunt de app dus niet beperken.\n\nZet eerst batterijoptimalisatie aan als je de app wilt beperken."</string>
    <string name="manager_battery_usage_unrestricted_title" msgid="2426486290463258032">"Onbeperkt"</string>
    <string name="manager_battery_usage_optimized_title" msgid="8080765739761921817">"Geoptimaliseerd"</string>
    <string name="manager_battery_usage_restricted_title" msgid="7702863764130323118">"Beperkt"</string>
    <string name="manager_battery_usage_unrestricted_summary" msgid="6819279865465667692">"Sta batterijgebruik op de achtergrond toe zonder beperkingen. Dit kan meer batterijlading verbruiken."</string>
    <string name="manager_battery_usage_optimized_summary" msgid="1332545476428039900">"Optimaliseer op basis van je gebruik. Aanbevolen voor de meeste apps."</string>
    <string name="manager_battery_usage_restricted_summary" msgid="8324695640704416905">"Beperk batterijgebruik op de achtergrond. De app werkt misschien niet zoals verwacht. Meldingen kunnen vertraagd zijn."</string>
    <string name="manager_battery_usage_footer" msgid="2635906573922553766">"Als je aanpast hoe een app de batterij kan gebruiken, kan dit de prestaties beïnvloeden."</string>
    <string name="manager_battery_usage_footer_limited" msgid="5180776148877306780">"Deze app vereist <xliff:g id="STATE">%1$s</xliff:g> batterijgebruik."</string>
    <string name="manager_battery_usage_unrestricted_only" msgid="3646162131339418216">"onbeperkt"</string>
    <string name="manager_battery_usage_optimized_only" msgid="7121785281913056432">"geoptimaliseerd"</string>
    <string name="manager_battery_usage_link_a11y" msgid="374918091821438564">"Meer informatie over opties voor batterijgebruik"</string>
    <string name="device_screen_usage" msgid="1011630249648289909">"Schermgebruik sinds volledige lading"</string>
    <string name="advanced_battery_title" msgid="3005993394776555079">"Batterijgebruik"</string>
    <string name="history_details_title" msgid="8628584613889559355">"Geschiedenisdetails"</string>
    <string name="advanced_battery_preference_title" msgid="3790901207877260883">"Batterijgebruik"</string>
    <string name="advanced_battery_preference_summary_with_hours" msgid="954091349133320955">"Bekijk gebruik voor afgelopen 24 uur"</string>
    <string name="advanced_battery_preference_summary" msgid="2372763700477268393">"Gebruik sinds laatste volledige lading"</string>
    <string name="battery_details_title" msgid="3289680399291090588">"Batterijgebruik voor app"</string>
    <string name="details_subtitle" msgid="2550872569652785527">"Gebruiksdetails"</string>
    <string name="controls_subtitle" msgid="3759606830916441564">"Energieverbruik aanpassen"</string>
    <string name="packages_subtitle" msgid="8687690644931499428">"Bijgeleverde pakketten"</string>
    <string name="battery_tip_summary_title" msgid="321127485145626939">"Apps worden normaal uitgevoerd"</string>
    <string name="battery_tip_low_battery_title" msgid="4155239078744100997">"Laag batterijniveau"</string>
    <string name="battery_tip_low_battery_summary" msgid="2629633757244297436">"Zet Batterijbesparing aan om de batterijduur te verlengen"</string>
    <string name="battery_tip_smart_battery_title" msgid="8925025450214912325">"De batterijduur verbeteren"</string>
    <string name="battery_tip_smart_battery_summary" msgid="3592965553502362965">"Batterijbeheer aanzetten"</string>
    <string name="battery_tip_early_heads_up_title" msgid="4411387863476629452">"Batterijbesparing aanzetten"</string>
    <string name="battery_tip_early_heads_up_summary" msgid="578523794827443977">"Batterij is mogelijk eerder leeg dan normaal"</string>
    <string name="battery_tip_early_heads_up_done_title" msgid="7705597228709143337">"Batterijbesparing aan"</string>
    <string name="battery_saver_link_a11y" msgid="6613079613524512257">"Meer informatie over Batterijbesparing"</string>
    <string name="battery_tip_early_heads_up_done_summary" msgid="7858923105760361208">"Sommige functies zijn mogelijk beperkt"</string>
    <string name="battery_tip_high_usage_title" msgid="9110720762506146697">"Hoger batterijverbruik"</string>
    <string name="battery_tip_high_usage_summary" msgid="3938999581403084551">"Apps met het hoogste verbruik bekijken"</string>
    <string name="battery_tip_limited_temporarily_title" msgid="6258554134146272311">"Opladen geoptimaliseerd om de batterij te beschermen"</string>
    <string name="battery_tip_limited_temporarily_summary" msgid="5107379280241187562">"Opladen is geoptimaliseerd om de levensduur van de batterij te verlengen"</string>
    <string name="battery_tip_dock_defender_future_bypass_title" msgid="4332616280495788195">"Opladen geoptimaliseerd om de batterij te beschermen"</string>
    <string name="battery_tip_dock_defender_future_bypass_summary" msgid="7870758621381307597">"Opladen is geoptimaliseerd als het apparaat is gedockt om de levensduur van de batterij te verlengen"</string>
    <string name="battery_tip_dock_defender_active_title" msgid="1414785238383255699">"Opladen geoptimaliseerd om de batterij te beschermen"</string>
    <string name="battery_tip_dock_defender_active_summary" msgid="3512082623718801459">"Opladen is geoptimaliseerd als het apparaat is gedockt om de levensduur van de batterij te verlengen"</string>
    <string name="battery_tip_dock_defender_temporarily_bypassed_title" msgid="1679449361090557201">"Volledig opladen"</string>
    <string name="battery_tip_dock_defender_temporarily_bypassed_summary" msgid="1099500476761333281">"De volgende keer dat je tablet is gedockt, wordt het opladen geoptimaliseerd om de batterij te beschermen"</string>
    <string name="battery_tip_limited_temporarily_sec_button_content_description" msgid="5648444926736883551">"Meer informatie over pauze tijdens opladen"</string>
    <string name="battery_tip_limited_temporarily_dialog_resume_charge" msgid="2302295458913832342">"Opladen hervatten"</string>
    <string name="battery_tip_dialog_message_footer" msgid="986542164372177504">"Omvat achtergrondactiviteit met hoog energieverbruik"</string>
    <string name="battery_tip_restrict_title" msgid="4537101947310626753">"{count,plural, =1{# app beperken}other{# apps beperken}}"</string>
    <string name="battery_tip_restrict_handled_title" msgid="7142074986508706853">"{count,plural, =1{{label} onlangs beperkt}other{# apps onlangs beperkt}}"</string>
    <string name="battery_tip_restrict_summary" msgid="7539469590829235277">"{count,plural, =1{{label} heeft een hoog batterijgebruik op de achtergrond}other{# apps hebben een hoog batterijgebruik op de achtergrond}}"</string>
    <string name="battery_tip_restrict_handled_summary" msgid="3535697154547199190">"{count,plural, =1{Deze app kan niet op de achtergrond worden uitgevoerd}other{Deze apps kunnen niet op de achtergrond worden uitgevoerd}}"</string>
    <string name="battery_tip_restrict_app_dialog_title" msgid="1649476357343160240">"{count,plural, =1{App beperken?}other{# apps beperken?}}"</string>
    <string name="battery_tip_restrict_app_dialog_message" msgid="137856003724730751">"Voorkom dat <xliff:g id="APP">%1$s</xliff:g> de batterij op de achtergrond gebruikt als je de batterij wilt sparen. Deze app werkt mogelijk niet goed en meldingen worden mogelijk vertraagd."</string>
    <string name="battery_tip_restrict_apps_less_than_5_dialog_message" msgid="5894648804112181324">"Voorkom dat deze apps de batterij op de achtergrond gebruiken om de batterij te sparen. Beperkte apps werken mogelijk niet goed en meldingen worden mogelijk vertraagd.\n\nApps:"</string>
    <string name="battery_tip_restrict_apps_more_than_5_dialog_message" msgid="4546838397423565138">"Voorkom dat deze apps de batterij op de achtergrond gebruiken om de batterij te sparen. Beperkte apps werken mogelijk niet goed en meldingen worden mogelijk vertraagd.\n\nApps:\n<xliff:g id="APP_LIST">%1$s</xliff:g>."</string>
    <string name="battery_tip_restrict_app_dialog_ok" msgid="7025027696689301916">"Beperken"</string>
    <string name="battery_tip_unrestrict_app_dialog_title" msgid="5501997201160532301">"Beperking verwijderen?"</string>
    <string name="battery_tip_unrestrict_app_dialog_message" msgid="215449637818582819">"Deze app kan de batterij op de achtergrond gebruiken. Je batterij is mogelijk eerder leeg dan verwacht."</string>
    <string name="battery_tip_unrestrict_app_dialog_ok" msgid="7940183167721998470">"Verwijderen"</string>
    <string name="battery_tip_unrestrict_app_dialog_cancel" msgid="4968135709160207507">"Annuleren"</string>
    <string name="battery_tip_charge_to_full_button" msgid="6701709034348116261">"Opladen tot vol"</string>
    <string name="battery_tip_incompatible_charging_title" msgid="5120763575150751300">"Probleem met oplaadaccessoire"</string>
    <string name="battery_tip_incompatible_charging_content_description" msgid="355668467640367701">"Meer informatie over opladen met een incompatibele oplader"</string>
    <string name="smart_battery_manager_title" msgid="3677620516657920364">"Batterijbeheer"</string>
    <string name="smart_battery_title" msgid="9095903608520254254">"Apps automatisch beheren"</string>
    <string name="smart_battery_footer" msgid="8407121907452993645">"Wanneer batterijbeheer detecteert dat apps de batterij snel leegmaken, heb je de optie om deze apps te beperken. Beperkte apps werken mogelijk niet goed en meldingen worden mogelijk vertraagd."</string>
    <string name="restricted_app_title" msgid="6585080822121007436">"Beperkte apps"</string>
    <string name="restricted_app_summary" msgid="1022307922754893997">"{count,plural, =1{Batterijgebruik beperken voor # app}other{Batterijgebruik beperken voor # apps}}"</string>
    <string name="restricted_app_time_summary" msgid="3097721884155913252">"<xliff:g id="TIME">%1$s</xliff:g> beperkt"</string>
    <string name="restricted_app_detail_footer" msgid="3495725286882138803">"Deze apps mogen de batterij niet op de achtergrond gebruiken. Ze werken misschien niet zoals verwacht en meldingen kunnen vertraagd binnenkomen."</string>
    <string name="battery_auto_restriction_title" msgid="827206218118093357">"Batterijbeheer gebruiken"</string>
    <string name="battery_auto_restriction_summary" msgid="2140896101984815711">"Detecteren wanneer apps de batterij snel leegmaken"</string>
    <string name="battery_manager_summary" msgid="255708681438809287">"Waarnemen wanneer apps veel batterijlading verbruiken"</string>
    <string name="battery_manager_summary_unsupported" msgid="7334173707292807964">"Waarnemen wanneer apps veel batterijlading verbruiken"</string>
    <string name="battery_manager_app_restricted" msgid="2583902700677009173">"{count,plural, =1{# app beperkt}other{# apps beperkt}}"</string>
    <string name="battery_header_title_alternate" msgid="8371821625994616659">"<xliff:g id="NUMBER">^1</xliff:g>"<small>" "<font size="20">"<xliff:g id="UNIT">%</xliff:g>"</font></small>""</string>
    <string name="battery_missing_message" msgid="400958471814422770">"Probleem bij het lezen van de batterijmeter."</string>
    <string name="battery_missing_link_message" msgid="6021565067124898074"></string>
    <string name="battery_missing_link_a11y_message" msgid="3310971406602316323">"Tik voor meer informatie over deze fout"</string>
    <string name="power_screen" msgid="4596900105850963806">"Scherm"</string>
    <string name="power_cpu" msgid="1820472721627148746">"CPU"</string>
    <string name="power_flashlight" msgid="8993388636332573202">"Zaklamp"</string>
    <string name="power_camera" msgid="4778315081581293923">"Camera"</string>
    <string name="power_gps" msgid="6352380895542498164">"Gps"</string>
    <string name="power_wifi" msgid="4614007837288250325">"Wifi"</string>
    <string name="power_bluetooth" msgid="5085900180846238196">"Bluetooth"</string>
    <string name="power_cell" msgid="7793805106954398186">"Mobiel netwerk"</string>
    <string name="power_phone" msgid="2768396619208561670">"Audiogesprekken"</string>
    <string name="battery_screen_usage" msgid="90008745183187461">"Schermgebruik <xliff:g id="TIME">^1</xliff:g>"</string>
    <string name="battery_used_by" msgid="6457305178016189330">"<xliff:g id="PERCENT">%1$s</xliff:g> gebruikt door <xliff:g id="APP">%2$s</xliff:g>"</string>
    <string name="battery_overall_usage" msgid="8940140259734182014">"<xliff:g id="PERCENT">%1$s</xliff:g> van batterij"</string>
    <string name="battery_detail_since_full_charge" msgid="5650946565524184582">"Uitsplitsing sinds laatste volledige lading"</string>
    <string name="battery_last_full_charge" msgid="8308424441475063956">"Laatste volledige lading"</string>
    <string name="battery_full_charge_last" msgid="465146408601016923">"Geschatte gebruikstijd na volledige lading"</string>
    <string name="battery_footer_summary" msgid="6753248007004259000">"Resterende batterijtijd is een schatting en hangt af van het gebruik"</string>
    <string name="battery_detail_power_usage" msgid="1492926471397355477">"Batterijgebruik"</string>
    <string name="battery_not_usage" msgid="3851536644733662392">"Geen gebruik sinds laatste volledige lading"</string>
    <string name="battery_not_usage_24hr" msgid="8397519536160741248">"Geen gebruik in de afgelopen 24 u"</string>
    <string name="battery_usage_without_time" msgid="1346894834339420538"></string>
    <string name="battery_usage_since_last_full_charge" msgid="3488425008925924769">"sinds laatste volledige lading"</string>
    <string name="battery_usage_system_apps" msgid="8659537819731575299">"Systeem-apps"</string>
    <string name="battery_usage_others" msgid="311793281613609986">"Anders"</string>
    <string name="estimated_time_left" msgid="948717045180211777">"Geschatte resterende tijd"</string>
    <string name="estimated_charging_time_left" msgid="2287135413363961246">"Tot volledige lading"</string>
    <string name="estimated_time_description" msgid="211058785418596009">"Schatting kan afwijken afhankelijk van gebruik"</string>
    <string name="process_mediaserver_label" msgid="6135260215912215092">"Mediaserver"</string>
    <string name="process_dex2oat_label" msgid="1190208677726583153">"App-optimalisatie"</string>
    <string name="process_network_tethering" msgid="6822671758152900766">"Tethering"</string>
    <string name="process_removed_apps" msgid="6544406592678476902">"Verwijderde apps"</string>
    <string name="battery_saver" msgid="7737147344510595864">"Batterijbesparing"</string>
    <string name="battery_saver_auto_title" msgid="6789753787070176144">"Automatisch aanzetten"</string>
    <string name="battery_saver_auto_no_schedule" msgid="5123639867350138893">"Geen planning"</string>
    <string name="battery_saver_auto_routine" msgid="4656495097900848608">"Gebaseerd op je routine"</string>
    <string name="battery_saver_pref_auto_routine_summary" msgid="4739240095966241508">"Wordt aangezet op basis van je routine"</string>
    <string name="battery_saver_auto_percentage" msgid="558533724806281980">"Gebaseerd op percentage"</string>
    <string name="battery_saver_auto_routine_summary" msgid="3913145448299472628">"Batterijbesparing wordt aangezet als de batterij waarschijnlijk leeg raakt vóór de volgende verwachte keer dat je oplaadt."</string>
    <string name="battery_saver_auto_percentage_summary" msgid="6190884450723824287">"Wordt aangezet bij <xliff:g id="PERCENT">%1$s</xliff:g>"</string>
    <string name="battery_saver_schedule_settings_title" msgid="3688019979950082237">"Planning instellen"</string>
    <string name="battery_saver_turn_on_summary" msgid="1433919417587171160">"Gebruiksduur van de batterij verlengen"</string>
    <string name="battery_saver_sticky_title_new" msgid="5942813274115684599">"Uitzetten na opladen"</string>
    <string name="battery_saver_sticky_title_percentage" msgid="1178162022087559148">"Uitzetten bij <xliff:g id="BATTERY_PERCENTAGE">%1$s</xliff:g>"</string>
    <string name="battery_saver_sticky_description_new" msgid="6472610662679038342">"Batterijbesparing gaat uit als de batterij <xliff:g id="BATTERY_PERCENTAGE">%1$s</xliff:g> lading heeft"</string>
    <!-- no translation found for battery_saver_seekbar_title (3712266470054006641) -->
    <skip />
    <string name="battery_saver_seekbar_title_placeholder" msgid="7141264642540687540">"Aanzetten"</string>
    <string name="battery_saver_master_switch_title" msgid="3474312070095834915">"Batterijbesparing gebruiken"</string>
    <string name="battery_saver_turn_on_automatically_title" msgid="7857393318205740864">"Automatisch aanzetten"</string>
    <string name="battery_saver_turn_on_automatically_never" msgid="6194649389871448663">"Nooit"</string>
    <string name="battery_saver_turn_on_automatically_pct" msgid="4294335680892392449">"bij <xliff:g id="PERCENT">%1$s</xliff:g> batterijlading"</string>
    <string name="battery_percentage" msgid="1779934245963043490">"Batterijpercentage"</string>
    <string name="battery_percentage_description" msgid="2321465139126125541">"Toon batterijpercentage in statusbalk"</string>
    <string name="battery_usage_chart_graph_hint_last_full_charge" msgid="6570336408060566877">"Batterijniveau sinds de laatste keer dat de batterij volledig werd opgeladen"</string>
    <string name="battery_usage_chart_graph_hint" msgid="9182079098173323005">"Batterijniveau voor afgelopen 24 uur"</string>
    <string name="battery_app_usage" msgid="8976453608783133770">"App-gebruik sinds de laatste keer dat de batterij volledig werd opgeladen"</string>
    <string name="battery_app_usage_for_past_24" msgid="1234770810563940656">"App-gebruik voor afgelopen 24 uur"</string>
    <string name="battery_system_usage" msgid="1395943945140097585">"Systeemgebruik sinds de laatste volledige lading"</string>
    <string name="battery_system_usage_for_past_24" msgid="3341520273114616263">"Systeemgebruik voor afgelopen 24 uur"</string>
    <string name="battery_system_usage_for" msgid="3248552137819897140">"Systeemgebruik voor <xliff:g id="SLOT">%s</xliff:g>"</string>
    <string name="battery_app_usage_for" msgid="7309909074935858949">"App-gebruik voor <xliff:g id="SLOT">%s</xliff:g>"</string>
    <string name="battery_system_usage_since_last_full_charge_to" msgid="4196795733829841971">"Systeemgebruik sinds de laatste keer volledig opladen tot <xliff:g id="SLOT_TIMESTAMP">%s</xliff:g>"</string>
    <string name="battery_app_usage_since_last_full_charge_to" msgid="4339201995118102114">"App-gebruik sinds de laatste keer volledig opladen tot <xliff:g id="SLOT_TIMESTAMP">%s</xliff:g>"</string>
    <string name="battery_usage_total_less_than_one_minute" msgid="1035425863251685509">"Totaal: minder dan een minuut"</string>
    <string name="battery_usage_background_less_than_one_minute" msgid="3957971442554437909">"Achtergrond: minder dan een minuut"</string>
    <string name="battery_usage_screen_time_less_than_one_minute" msgid="2911989465891679033">"Schermtijd: minder dan een minuut"</string>
    <string name="battery_usage_for_total_time" msgid="8402254046930910905">"Totaal: <xliff:g id="TIME">%s</xliff:g>"</string>
    <string name="battery_usage_for_background_time" msgid="9109637210617095188">"Achtergrond: <xliff:g id="TIME">%s</xliff:g>"</string>
    <string name="battery_usage_screen_time" msgid="3973865893520804115">"Schermtijd: <xliff:g id="TIME">%s</xliff:g>"</string>
    <string name="battery_usage_screen_footer_empty" msgid="3301144846133808193">"Batterijgebruikgegevens komen een paar uur na volledig opladen beschikbaar"</string>
    <string name="battery_usage_chart_label_now" msgid="4598282721949430165">"nu"</string>
    <string name="battery_usage_timestamps_hyphen" msgid="7401188432989043905">"<xliff:g id="FROM_TIMESTAMP">%1$s</xliff:g> - <xliff:g id="TO_TIMESTAMP">%2$s</xliff:g>"</string>
    <string name="battery_usage_day_and_hour" msgid="1417890420844950881">"<xliff:g id="DAY">%1$s</xliff:g> <xliff:g id="HOUR">%2$s</xliff:g>"</string>
    <string name="battery_usage_chart" msgid="4114747521432440017">"Diagram voor batterijgebruik"</string>
    <string name="daily_battery_usage_chart" msgid="4176059567682992686">"Diagram van batterijgebruik per dag"</string>
    <string name="hourly_battery_usage_chart" msgid="3098314511076561272">"Diagram van batterijgebruik per uur"</string>
    <string name="battery_usage_breakdown_title_since_last_full_charge" msgid="435006273323199906">"Batterijgebruik sinds de laatste keer dat de batterij volledig werd opgeladen"</string>
    <string name="battery_usage_breakdown_title_for_slot" msgid="4823179483667671406">"Batterijgebruik voor <xliff:g id="SLOT">%s</xliff:g>"</string>
    <string name="screen_time_category_last_full_charge" msgid="8856908320256057753">"Schermtijd sinds laatste keer dat de batterij volledig werd opgeladen"</string>
    <string name="screen_time_category_for_slot" msgid="8287722270554654959">"Schermtijd voor <xliff:g id="SLOT">%s</xliff:g>"</string>
    <string name="battery_usage_spinner_view_by_apps" msgid="8769276544072098082">"Bekijken per app"</string>
    <string name="battery_usage_spinner_view_by_systems" msgid="7904104223212160541">"Bekijken per systeem"</string>
    <string name="battery_usage_less_than_percent" msgid="5873099028895001082">"&amp;lt, <xliff:g id="PERCENTAGE">%1$s</xliff:g>"</string>
    <!-- no translation found for battery_cycle_count_footer (3642121059800373545) -->
    <skip />
    <string name="process_stats_summary_title" msgid="502683176231281732">"Processtatistieken"</string>
    <string name="process_stats_summary" msgid="522842188571764699">"Statistieken voor nerds over actieve processen"</string>
    <string name="app_memory_use" msgid="7559666138324410666">"Geheugengebruik"</string>
    <string name="process_stats_total_duration" msgid="3898635541254636618">"<xliff:g id="USEDRAM">%1$s</xliff:g> van <xliff:g id="TOTALRAM">%2$s</xliff:g> gebruikt gedurende laatste <xliff:g id="TIMEDURATION">%3$s</xliff:g>"</string>
    <string name="process_stats_total_duration_percentage" msgid="4391502694312709148">"<xliff:g id="PERCENT">%1$s</xliff:g> van RAM gebruikt gedurende <xliff:g id="TIMEDURATION">%2$s</xliff:g>"</string>
    <string name="process_stats_type_background" msgid="4094034441562453522">"Achtergrond"</string>
    <string name="process_stats_type_foreground" msgid="5043049335546793803">"Voorgrond"</string>
    <string name="process_stats_type_cached" msgid="129788969589599563">"In cache"</string>
    <string name="process_stats_os_label" msgid="2096501347732184886">"Android-besturingssysteem"</string>
    <string name="process_stats_os_native" msgid="794547105037548539">"Systeemeigen"</string>
    <string name="process_stats_os_kernel" msgid="5626269994512354996">"Kernel"</string>
    <string name="process_stats_os_zram" msgid="3067278664868354143">"Z-Ram"</string>
    <string name="process_stats_os_cache" msgid="4753163023524305711">"Caches"</string>
    <string name="process_stats_ram_use" msgid="5966645638783509937">"RAM-gebruik"</string>
    <string name="process_stats_bg_ram_use" msgid="3572439697306771461">"RAM-gebruik (achtergrond)"</string>
    <string name="process_stats_run_time" msgid="8631920944819076418">"Uitvoeringstijd"</string>
    <string name="processes_subtitle" msgid="5791138718719605724">"Processen"</string>
    <string name="services_subtitle" msgid="9136741140730524046">"Services"</string>
    <string name="menu_proc_stats_duration" msgid="1249684566371309908">"Duur"</string>
    <string name="mem_details_title" msgid="8064756349669711949">"Geheugendetails"</string>
    <string name="menu_duration_3h" msgid="9202635114831885878">"3 uur"</string>
    <string name="menu_duration_6h" msgid="2843895006519153126">"6 uur"</string>
    <string name="menu_duration_12h" msgid="9206922888181602565">"12 uur"</string>
    <string name="menu_duration_1d" msgid="8538390358158862330">"1 dag"</string>
    <string name="menu_show_system" msgid="3780310384799907818">"Systeem-apps tonen"</string>
    <string name="menu_hide_system" msgid="5197937451381420622">"Systeem verbergen"</string>
    <string name="menu_show_percentage" msgid="6143205879027928330">"Percentages tonen"</string>
    <string name="menu_use_uss" msgid="1663914348353623749">"USS gebruiken"</string>
    <string name="menu_proc_stats_type" msgid="5048575824389855689">"Statistiektype"</string>
    <string name="menu_proc_stats_type_background" msgid="6796434633192284607">"Achtergrond"</string>
    <string name="menu_proc_stats_type_foreground" msgid="9011432748521890803">"Voorgrond"</string>
    <string name="menu_proc_stats_type_cached" msgid="1351321959600144622">"In cache"</string>
    <string name="voice_input_output_settings" msgid="1055497319048272051">"Spraakinvoer en -uitvoer"</string>
    <string name="voice_input_output_settings_title" msgid="6449454483955543064">"Instellingen voor spraakinvoer en -uitvoer"</string>
    <string name="voice_search_settings_title" msgid="228743187532160069">"Spraakgestuurd zoeken"</string>
    <string name="keyboard_settings_title" msgid="2199286020368890114">"Android-toetsenbord"</string>
    <string name="voice_input_settings" msgid="105821652985768064">"Instellingen voor spraakinvoer"</string>
    <string name="voice_input_settings_title" msgid="3708147270767296322">"Spraakinvoer"</string>
    <string name="voice_service_preference_section_title" msgid="4807795449147187497">"Spraakinvoerservices"</string>
    <string name="voice_interactor_preference_summary" msgid="3942881638813452880">"Volledige hotword- en interactieservice"</string>
    <string name="voice_recognizer_preference_summary" msgid="9195427725367463336">"Eenvoudige spraak-naar-tekst"</string>
    <string name="voice_interaction_security_warning" msgid="7962884055885987671">"Deze spraakinvoerservice kan doorlopend de spraakinvoer volgen en namens jou spraakgestuurde apps bedienen. De service wordt geleverd door de <xliff:g id="VOICE_INPUT_SERVICE_APP_NAME">%s</xliff:g>. Wil je het gebruik van deze service aanzetten?"</string>
    <string name="on_device_recognition_settings" msgid="6503160369314598069">"Instellingen voor herkenning op het apparaat"</string>
    <string name="on_device_recognition_settings_title" msgid="7137599722039096545">"Herkenning op het apparaat"</string>
    <string name="on_device_recognition_settings_summary" msgid="3292736423223499348">"Spraakherkenning op het apparaat"</string>
    <string name="tts_engine_preference_title" msgid="7808775764174571132">"Voorkeursengine"</string>
    <string name="tts_engine_settings_title" msgid="1298093555056321577">"Engine-instellingen"</string>
    <string name="tts_sliders_title" msgid="6901146958648426181">"Spreeksnelheid en toonhoogte"</string>
    <string name="tts_engine_section_title" msgid="5115035218089228451">"Engine"</string>
    <string name="tts_install_voice_title" msgid="5133545696447933812">"Stemmen"</string>
    <string name="tts_spoken_language" msgid="4652894245474520872">"Gesproken taal"</string>
    <string name="tts_install_voices_title" msgid="6505257816336165782">"Stemmen installeren"</string>
    <string name="tts_install_voices_text" msgid="902408506519246362">"Doorgaan naar de app <xliff:g id="TTS_APP_NAME">%s</xliff:g> om stemmen te installeren"</string>
    <string name="tts_install_voices_open" msgid="919034855418197668">"App openen"</string>
    <string name="tts_install_voices_cancel" msgid="5179154684379560628">"Annuleren"</string>
    <string name="tts_reset" msgid="9047681050813970031">"Resetten"</string>
    <string name="tts_play" msgid="2945513377250757221">"Afspelen"</string>
    <string name="vpn_settings_title" msgid="9131315656202257272">"VPN"</string>
    <string name="vpn_settings_insecure_single" msgid="9012504179995045195">"Niet beveiligd"</string>
    <string name="vpn_settings_single_insecure_multiple_total" msgid="6107225844641301139">"<xliff:g id="VPN_COUNT">%d</xliff:g> niet beveiligd"</string>
    <string name="vpn_settings_multiple_insecure_multiple_total" msgid="1706236062478680488">"<xliff:g id="VPN_COUNT">%d</xliff:g> niet beveiligd"</string>
    <string name="adaptive_connectivity_title" msgid="7464959640138428192">"Aanpasbare connectiviteit"</string>
    <string name="adaptive_connectivity_summary" msgid="3648731530666326885">"Verlengt de batterijduur en verbetert de prestaties van het apparaat door de netwerkverbindingen automatisch te beheren"</string>
    <string name="adaptive_connectivity_switch_on" msgid="3653067561620745493">"Aan"</string>
    <string name="adaptive_connectivity_switch_off" msgid="5076172560836115265">"Uit"</string>
    <string name="adaptive_connectivity_main_switch_title" msgid="261045483524512420">"Aanpasbare connectiviteit gebruiken"</string>
    <string name="credentials_title" msgid="7535942196886123656">"Opslag van inloggegevens"</string>
    <string name="credentials_install" msgid="3933218407598415827">"Certificaat installeren"</string>
    <string name="credentials_reset" msgid="4246628389366452655">"Inloggegevens wissen"</string>
    <string name="credentials_reset_summary" msgid="5400585520572874255">"Verwijder alle certificaten"</string>
    <string name="trusted_credentials" msgid="2522784976058244683">"Vertrouwde inloggegevens"</string>
    <string name="trusted_credentials_summary" msgid="345822338358409468">"Toon vertrouwde CA-certificaten"</string>
    <string name="user_credentials" msgid="4044405430790970775">"Inloggegevens van gebruiker"</string>
    <string name="user_credentials_summary" msgid="686471637627271856">"Bekijk opgeslagen inloggegevens en pas ze aan"</string>
    <string name="advanced_security_title" msgid="7117581975877192652">"Geavanceerd"</string>
    <string name="credentials_settings_not_available" msgid="7433088409177429600">"Er zijn geen inloggegevens beschikbaar voor deze gebruiker"</string>
    <string name="credential_for_vpn_and_apps" msgid="2208229692860871136">"Geïnstalleerd voor VPN en apps"</string>
    <string name="credential_for_wifi" msgid="2286560570630763556">"Geïnstalleerd voor wifi"</string>
    <string name="credential_for_wifi_in_use" msgid="7276290656840986618">"Geïnstalleerd voor wifi (in gebruik)"</string>
    <string name="credentials_reset_hint" msgid="4054601857203464867">"Alle content verwijderen?"</string>
    <string name="credentials_erased" msgid="9121052044566053345">"Certificaten gewist."</string>
    <string name="credentials_not_erased" msgid="3611058412683184031">"Kan certificaten niet wissen."</string>
    <string name="usage_access_title" msgid="1580006124578134850">"Apps met gebruikstoegang"</string>
    <string name="ca_certificate" msgid="3076484307693855611">"CA-certificaat"</string>
    <string name="user_certificate" msgid="6897024598058566466">"VPN- en app-gebruikerscertificaat"</string>
    <string name="wifi_certificate" msgid="8461905432409380387">"Wifi-certificaat"</string>
    <string name="ca_certificate_warning_title" msgid="7951148441028692619">"Je gegevens zijn niet privé"</string>
    <string name="ca_certificate_warning_description" msgid="8409850109551028774">"CA-certificaten worden gebruikt door websites, apps en VPN\'s voor versleuteling. Installeer alleen CA-certificaten van organisaties die je vertrouwt. \n\nAls je een CA-certificaat installeert, kan de eigenaar van het certificaat toegang krijgen tot je gegevens (zoals wachtwoorden of creditcardgegevens) van websites die je bezoekt of apps die je gebruikt, zelfs als je gegevens zijn versleuteld."</string>
    <string name="certificate_warning_dont_install" msgid="3794366420884560605">"Niet installeren"</string>
    <string name="certificate_warning_install_anyway" msgid="4633118283407228740">"Toch installeren"</string>
    <string name="cert_not_installed" msgid="6725137773549974522">"Certificaat niet geïnstalleerd"</string>
    <string name="request_manage_credentials_title" msgid="596805634568013413">"Toestaan dat "<b>"<xliff:g id="APP_NAME">^1</xliff:g>"</b>" certificaten installeert op dit apparaat?"</string>
    <string name="request_manage_credentials_description" msgid="8044839857171509619">"Aan de hand van deze certificaten word je geverifieerd door de unieke ID van je apparaat te delen met de onderstaande apps en URL\'s"</string>
    <string name="request_manage_credentials_dont_allow" msgid="3630610197644877809">"Niet toestaan"</string>
    <string name="request_manage_credentials_allow" msgid="4910940118408348245">"Toestaan"</string>
    <string name="request_manage_credentials_more" msgid="6101210283534101582">"Meer tonen"</string>
    <string name="certificate_management_app" msgid="8086699498358080826">"App voor certificaatbeheer"</string>
    <string name="no_certificate_management_app" msgid="3025739370424406717">"Geen"</string>
    <string name="certificate_management_app_description" msgid="8507306554200869005">"Aan de hand van de certificaten word je geverifieerd als je de onderstaande apps en URL\'s gebruikt"</string>
    <string name="uninstall_certs_credential_management_app" msgid="4945883254446077354">"Certificaten verwijderen"</string>
    <string name="remove_credential_management_app" msgid="6089291496976812786">"App verwijderen"</string>
    <string name="remove_credential_management_app_dialog_title" msgid="5713525435104706772">"Deze app verwijderen?"</string>
    <string name="remove_credential_management_app_dialog_message" msgid="7739474298063646935">"Deze app beheert geen certificaten, maar blijft op je apparaat staan. Certificaten die zijn geïnstalleerd door de app, worden verwijderd."</string>
    <string name="number_of_urls" msgid="1128699121050872188">"{count,plural, =1{# URL}other{# URL\'s}}"</string>
    <string name="emergency_tone_title" msgid="6673118505206685168">"Noodoproepsignaal"</string>
    <string name="emergency_tone_summary" msgid="2519776254708767388">"Gedrag bij noodoproepen instellen"</string>
    <string name="privacy_settings_title" msgid="6437057228255974577">"Back-up"</string>
    <string name="backup_summary_state_on" msgid="9018954639693085240">"Aan"</string>
    <string name="backup_summary_state_off" msgid="5341339397224835909">"Uit"</string>
    <string name="backup_section_title" msgid="6539706829848457794">"Back-up en herstel"</string>
    <string name="personal_data_section_title" msgid="6368610168625722682">"Persoonsgegevens"</string>
    <string name="backup_data_title" msgid="507663517227498525">"Back-up maken van mijn gegevens"</string>
    <string name="backup_data_summary" msgid="8054551085241427531">"Een back-up van app-gegevens, wifi-wachtwoorden en andere instellingen maken op de Google-servers"</string>
    <string name="backup_configure_account_title" msgid="8574055186903658842">"Back-upaccount"</string>
    <string name="backup_data_management_title" msgid="6596830198441939702">"Back-upaccount beheren"</string>
    <string name="include_app_data_title" msgid="2969603876620594523">"Appgegevens opnemen"</string>
    <string name="auto_restore_title" msgid="4124345897936637561">"Automatisch terugzetten"</string>
    <string name="auto_restore_summary" msgid="6830198851045584001">"In een back-up opgeslagen instellingen of andere gegevens herstellen bij het opnieuw installeren van een app"</string>
    <string name="backup_inactive_title" msgid="6753265378043349277">"Back-upservice is niet actief"</string>
    <string name="backup_configure_account_default_summary" msgid="5323225330966306690">"Er is momenteel geen account ingesteld voor het opslaan van back-upgegevens"</string>
    <string name="backup_erase_dialog_title" msgid="5892431263348766484"></string>
    <string name="backup_erase_dialog_message" msgid="2250872501409574331">"Weet je zeker dat je het maken van back-ups van je wifi-wachtwoorden, bookmarks, andere instellingen en app-gegevens wilt stoppen en alle kopieën op Google-servers wilt wissen?"</string>
    <string name="fullbackup_erase_dialog_message" msgid="2379053988557486162">"Wil je stoppen met het maken van back-ups van apparaatgegevens (zoals wifi-wachtwoorden en gespreksgeschiedenis) en app-gegevens (zoals instellingen en bestanden opgeslagen door apps), en alle kopieën op externe servers wissen?"</string>
    <string name="fullbackup_data_summary" msgid="971587401251601473">"Automatisch op afstand een back-up maken van apparaatgegevens (zoals wifi-wachtwoorden en gespreksgeschiedenis) en app-gegevens (zoals instellingen en bestanden opgeslagen door apps).\n\nAls je de functie voor automatische back-ups aanzet, worden apparaat- en app-gegevens periodiek op afstand opgeslagen. App-gegevens kunnen gegevens omvatten die een app heeft opgeslagen (op basis van de instellingen van de ontwikkelaar), waaronder potentieel gevoelige gegevens als contacten, berichten en foto\'s."</string>
    <string name="device_admin_settings_title" msgid="31392408594557070">"Instellingen voor apparaatbeheer"</string>
    <string name="active_device_admin_msg" msgid="7744106305636543184">"Apparaatbeheer-app"</string>
    <string name="remove_device_admin" msgid="3143059558744287259">"Deze apparaatbeheer-app uitzetten"</string>
    <string name="uninstall_device_admin" msgid="4481095209503956916">"App verwijderen"</string>
    <string name="remove_and_uninstall_device_admin" msgid="707912012681691559">"Uitzetten en verwijderen"</string>
    <string name="select_device_admin_msg" msgid="5501360309040114486">"Apparaatbeheer-apps"</string>
    <string name="no_device_admins" msgid="8888779888103079854">"Geen apparaatbeheer-apps beschikbaar"</string>
    <string name="no_trust_agents" msgid="8659098725864191600">"Geen beschikbare trust-agents"</string>
    <string name="add_device_admin_msg" msgid="7730006568970042119">"Apparaatbeheer-app activeren?"</string>
    <string name="add_device_admin" msgid="6252128813507932519">"Deze apparaatbeheer-app activeren"</string>
    <string name="device_admin_add_title" msgid="6087481040932322289">"Apparaatbeheer"</string>
    <string name="device_admin_warning" msgid="1889160106787280321">"Als je deze beheer-app activeert, sta je de app <xliff:g id="APP_NAME">%1$s</xliff:g> toe de volgende bewerkingen uit te voeren:"</string>
    <string name="device_admin_warning_simplified" msgid="2715756519899116115">"Dit apparaat wordt beheerd en gecontroleerd door <xliff:g id="APP_NAME">%1$s</xliff:g>."</string>
    <string name="device_admin_status" msgid="6332571781623084064">"Deze beheer-app is actief en staat toe dat de app <xliff:g id="APP_NAME">%1$s</xliff:g> de volgende bewerkingen uitvoert:"</string>
    <string name="profile_owner_add_title" msgid="2774489881662331549">"Profielbeheerder activeren?"</string>
    <string name="profile_owner_add_title_simplified" msgid="2320828996993774182">"Toezicht toestaan?"</string>
    <string name="adding_profile_owner_warning" msgid="6868275476058020513">"Als je doorgaat, wordt je gebruiker beheerd door je beheerder, die ook de bijbehorende gegevens en persoonsgegevens kan opslaan.\n\nJe beheerder kan instellingen, toegang, apps en gegevens van deze gebruiker bijhouden en beheren, waaronder netwerkactiviteit en de locatiegegevens van je apparaat."</string>
    <string name="admin_disabled_other_options" msgid="8122039047419172139">"Andere opties zijn uitgezet door je beheerder"</string>
    <string name="admin_more_details" msgid="4928985331640193758">"Meer informatie"</string>
    <string name="notification_log_title" msgid="2812594935014664891">"Meldingenlogboek"</string>
    <string name="notification_history_title" msgid="8821060912502593309">"Meldings­geschiedenis"</string>
    <string name="notification_history_today" msgid="6081829638548808795">"Afgelopen %d uur"</string>
    <string name="notification_history_snooze" msgid="3980568893290512257">"Gesnoozed"</string>
    <string name="notification_history_dismiss" msgid="6180321217375722918">"Onlangs gesloten"</string>
    <string name="notification_history_count" msgid="885305572972482838">"{count,plural, =1{# melding}other{# meldingen}}"</string>
    <string name="sound_category_call_ringtone_vibrate_title" msgid="9090693401915654528">"Ringtone en trillen"</string>
    <string name="wifi_setup_detail" msgid="2012898800571616422">"Netwerk­gegevens"</string>
    <string name="accessibility_sync_enabled" msgid="5308864640407050209">"Synchronisatie staat aan"</string>
    <string name="accessibility_sync_disabled" msgid="5507600126380593611">"Synchronisatie staat uit"</string>
    <string name="accessibility_sync_in_progress" msgid="3229428197779196660">"Nu synchroniseren"</string>
    <string name="accessibility_sync_error" msgid="7248490045013170437">"Synchronisatiefout."</string>
    <string name="sync_failed" msgid="3806495232114684984">"Synchroniseren mislukt"</string>
    <string name="sync_active" msgid="5787407579281739975">"Synchronisatie actief"</string>
    <string name="account_sync_settings_title" msgid="2684888109902800966">"Synchroniseren"</string>
    <string name="sync_is_failing" msgid="6738004111400633331">"Er zijn momenteel problemen met de synchronisatie. Synchronisatie wordt snel opnieuw uitgevoerd."</string>
    <string name="add_account_label" msgid="7134707140831385869">"Account toevoegen"</string>
    <string name="managed_profile_not_available_label" msgid="7500578232182547365">"Werkprofiel is nog niet beschikbaar"</string>
    <string name="work_mode_label" msgid="4687734487641548872">"Werk-apps"</string>
    <string name="remove_managed_profile_label" msgid="1294933737673830431">"Werkprofiel verwijderen"</string>
    <string name="background_data" msgid="321903213000101158">"Achtergrondgegevens"</string>
    <string name="background_data_summary" msgid="6572245922513522466">"Onbeperkt gegevens synchroniseren, verzenden en ontvangen"</string>
    <string name="background_data_dialog_title" msgid="1692005302993229867">"Achtergrondgegevens uitzetten?"</string>
    <string name="background_data_dialog_message" msgid="7760280837612824670">"Als je achtergrondgegevens uitzet, bespaar je batterij en wordt het datagebruik verlaagd. Sommige apps maken mogelijk nog steeds gebruik van de verbinding voor achtergrondgegevens."</string>
    <string name="sync_enabled" msgid="5794103781356455043">"Synchroniseren AAN"</string>
    <string name="sync_disabled" msgid="1636223106968593391">"Synchroniseren UIT"</string>
    <string name="sync_error" msgid="846923369794727644">"Synchronisatiefout"</string>
    <string name="last_synced" msgid="1527008461298110443">"Laatst gesynchroniseerd: <xliff:g id="LAST_SYNC_TIME">%1$s</xliff:g>"</string>
    <string name="sync_in_progress" msgid="6200093151211458977">"Nu synchroniseren…"</string>
    <string name="settings_backup" msgid="5357973563989458049">"Back-up van instellingen maken"</string>
    <string name="settings_backup_summary" msgid="6803046376335724034">"Back-up maken van mijn instellingen"</string>
    <string name="sync_menu_sync_now" msgid="3948443642329221882">"Nu synchroniseren"</string>
    <string name="sync_menu_sync_cancel" msgid="2422994461106269813">"Synchronisatie annuleren"</string>
    <string name="sync_one_time_sync" msgid="8114337154112057462">"Tik om nu te synchroniseren<xliff:g id="LAST_SYNC_TIME">
%1$s</xliff:g>"</string>
    <string name="sync_gmail" msgid="228561698646018808">"Gmail"</string>
    <string name="sync_calendar" msgid="4603704438090387251">"Agenda"</string>
    <string name="sync_contacts" msgid="2376465611511325472">"Contacten"</string>
    <string name="header_application_sync_settings" msgid="7427706834875419243">"Synchronisatie-instellingen van de app"</string>
    <string name="header_data_and_synchronization" msgid="453920312552838939">"Gegevens en synchronisatie"</string>
    <string name="preference_change_password_title" msgid="5465821666939825972">"Wachtwoord wijzigen"</string>
    <string name="header_account_settings" msgid="1189339410278750008">"Accountinstellingen"</string>
    <string name="remove_account_label" msgid="4169490568375358010">"Account verwijderen"</string>
    <string name="header_add_an_account" msgid="3919151542338822661">"Account toevoegen"</string>
    <string name="really_remove_account_title" msgid="253097435885652310">"Account verwijderen?"</string>
    <string name="remove_account_failed" msgid="3709502163548900644">"Deze wijziging is niet toegestaan door je beheerder"</string>
    <string name="cant_sync_dialog_title" msgid="2613000568881139517">"Kan niet handmatig synchroniseren"</string>
    <string name="cant_sync_dialog_message" msgid="7612557105054568581">"Synchronisatie staat op dit moment uit voor dit item. Als je deze instelling wilt wijzigen, zet je achtergrondgegevens en automatisch synchroniseren tijdelijk aan."</string>
    <string name="delete" msgid="8330605554706263775">"Verwijderen"</string>
    <string name="select_all" msgid="7898929601615536401">"Alles selecteren"</string>
    <string name="data_usage_summary_title" msgid="394067070764360142">"Datagebruik"</string>
    <string name="data_usage_app_summary_title" msgid="4933742247928064178">"Mobiele data en wifi"</string>
    <string name="account_settings_menu_auto_sync_personal" msgid="2905595464540145671">"Persoonsgegevens autom. synchr."</string>
    <string name="account_settings_menu_auto_sync_work" msgid="8561102487795657789">"Werkgegevens autom. synchr."</string>
    <string name="data_usage_change_cycle" msgid="4501026427365283899">"Cyclus aanpassen..."</string>
    <string name="data_usage_pick_cycle_day" msgid="3548922497494790123">"Dag van maand voor resetten van datagebruikscyclus:"</string>
    <string name="data_usage_empty" msgid="5619908658853726866">"Geen gegevens gebruikt tijdens deze periode."</string>
    <string name="data_usage_label_foreground" msgid="8782117644558473624">"Voorgrond"</string>
    <string name="data_usage_label_background" msgid="8862781660427421859">"Achtergrond"</string>
    <string name="data_usage_app_restricted" msgid="312065316274378518">"beperkt"</string>
    <string name="data_usage_disable_mobile" msgid="6183809500102606801">"Mobiele data uitzetten?"</string>
    <string name="data_usage_disable_mobile_limit" msgid="1370147078938479538">"Mobiele-datalimiet instellen"</string>
    <string name="data_usage_disable_4g_limit" msgid="3084868504051520840">"4G-gegevenslimiet instellen"</string>
    <string name="data_usage_disable_3g_limit" msgid="8867555130268898044">"2G-3G-gegevenslimiet instellen"</string>
    <string name="data_usage_disable_wifi_limit" msgid="7222459951785404241">"Wifi-datalimiet instellen"</string>
    <string name="data_usage_tab_wifi" msgid="801667863336456787">"Wifi"</string>
    <string name="data_usage_tab_ethernet" msgid="2951873059375493878">"Ethernet"</string>
    <string name="data_usage_tab_mobile" msgid="952231704205870928">"Mobiel"</string>
    <string name="data_usage_tab_4g" msgid="3265237821331861756">"4G"</string>
    <string name="data_usage_tab_3g" msgid="6111070409752123049">"2G-3G"</string>
    <string name="data_usage_list_mobile" msgid="3738130489722964291">"Mobiel"</string>
    <string name="data_usage_list_none" msgid="2091924522549134855">"Geen"</string>
    <string name="data_usage_enable_mobile" msgid="1996943748103310201">"Mobiele data"</string>
    <string name="data_usage_enable_3g" msgid="2818189799905446932">"2G-/3G-gegevens"</string>
    <string name="data_usage_enable_4g" msgid="1526584080251993023">"4G-gegevens"</string>
    <string name="data_roaming_enable_mobile" msgid="5745287603577995977">"Roaming"</string>
    <string name="data_usage_forground_label" msgid="5762048187044975428">"Voorgrond:"</string>
    <string name="data_usage_background_label" msgid="5363718469293175279">"Achtergrond:"</string>
    <string name="data_usage_app_settings" msgid="5693524672522122485">"App-instellingen"</string>
    <string name="data_usage_app_restrict_background" msgid="5728840276368097276">"Achtergrondgegevens"</string>
    <string name="data_usage_app_restrict_background_summary" msgid="2997942775999602794">"Sta gebruik van mobiele data op de achtergrond toe"</string>
    <string name="data_usage_app_restrict_background_summary_disabled" msgid="8213268097024597864">"Als je achtergrondgegevens wilt beperken voor deze app, moet je eerst een mobiele-datalimiet instellen."</string>
    <string name="data_usage_app_restrict_dialog_title" msgid="5383874438677899255">"Achtergrondgegevens beperken?"</string>
    <string name="data_usage_app_restrict_dialog" msgid="5534272311979978297">"Deze functie kan ervoor zorgen dat een app die afhankelijk is van achtergrondgegevens, stopt als er alleen mobiele netwerken beschikbaar zijn.\n\nJe kunt meer geschikte besturingselementen voor datagebruik vinden in de instellingen van de app."</string>
    <string name="data_usage_restrict_denied_dialog" msgid="8599940395497268584">"Je kunt achtergrondgegevens alleen beperken als je een limiet voor mobiele data hebt ingesteld."</string>
    <string name="data_usage_auto_sync_on_dialog_title" msgid="2048411447974361181">"Auto-synchronisatie aanzetten?"</string>
    <string name="data_usage_auto_sync_off_dialog_title" msgid="1783917145440587470">"Auto-synchronisatie uitzetten?"</string>
    <string name="data_usage_auto_sync_off_dialog" msgid="6523112583569674837">"Hiermee beperk je data- en batterijgebruik. Je moet wel elk account handmatig synchroniseren om recente informatie te verzamelen. Je ontvangt geen meldingen wanneer er updates zijn."</string>
    <string name="data_usage_cycle_editor_title" msgid="2019035830921480941">"Gebruikscyclus resetten op:"</string>
    <string name="data_usage_cycle_editor_subtitle" msgid="1026234456777365545">"Dag van elke maand:"</string>
    <string name="data_usage_cycle_editor_positive" msgid="6110165528024717527">"Instellen"</string>
    <string name="data_usage_warning_editor_title" msgid="5252748452973120016">"Waarschuwing voor datagebruik instellen"</string>
    <string name="data_usage_limit_editor_title" msgid="8826855902435008518">"Limiet voor datagebruik instellen"</string>
    <string name="data_usage_limit_dialog_title" msgid="2053134451707801439">"Datagebruik beperken"</string>
    <string name="data_usage_sweep_warning" msgid="2072854703184614828"><font size="18">"<xliff:g id="NUMBER">^1</xliff:g>"</font>" "<font size="9">"<xliff:g id="UNIT">^2</xliff:g>"</font>\n<font size="12">"waar­schuwing"</font></string>
    <string name="data_usage_sweep_limit" msgid="6947019190890086284"><font size="18">"<xliff:g id="NUMBER">^1</xliff:g>"</font>" "<font size="9">"<xliff:g id="UNIT">^2</xliff:g>"</font>\n<font size="12">"limiet"</font></string>
    <string name="data_usage_uninstalled_apps" msgid="9065885396147675694">"Verwijderde apps"</string>
    <string name="data_usage_uninstalled_apps_users" msgid="1262228664057122983">"Verwijderde apps en gebruikers"</string>
    <string name="wifi_metered_title" msgid="6623732965268033931">"Netwerkgebruik"</string>
    <string name="data_usage_metered_yes" msgid="4262598072030135223">"Met datalimiet"</string>
    <string name="vpn_name" msgid="3806456074909253262">"Naam"</string>
    <string name="vpn_type" msgid="5533202873260826663">"Type"</string>
    <string name="vpn_server" msgid="2908816134941973935">"Serveradres"</string>
    <string name="vpn_mppe" msgid="7366657055055114239">"PPP-versleuteling (MPPE)"</string>
    <string name="vpn_l2tp_secret" msgid="2356744369959140121">"L2TP-geheim"</string>
    <string name="vpn_ipsec_identifier" msgid="8511842694369254801">"IPSec-ID"</string>
    <string name="vpn_ipsec_secret" msgid="532007567355505963">"Van tevoren gedeelde IPSec-sleutel"</string>
    <string name="vpn_ipsec_user_cert" msgid="2714372103705048405">"IPSec-gebruikerscertificaat"</string>
    <string name="vpn_ipsec_ca_cert" msgid="5558498943577474987">"CA-certificaat voor IPSec"</string>
    <string name="vpn_ipsec_server_cert" msgid="1411390470454731396">"IPSec-servercertificaat"</string>
    <string name="vpn_show_options" msgid="6105437733943318667">"Geavanceerde opties tonen"</string>
    <string name="vpn_search_domains" msgid="1973799969613962440">"DNS-zoekdomeinen"</string>
    <string name="vpn_dns_servers" msgid="6505263074417737107">"DNS-servers (bijv. 8.8.8.8)"</string>
    <string name="vpn_routes" msgid="1218707725375594862">"Doorstuurroutes (bijv. 10.0.0.0/8)"</string>
    <string name="vpn_username" msgid="8671768183475960068">"Gebruikersnaam"</string>
    <string name="vpn_password" msgid="1183746907642628127">"Wachtwoord"</string>
    <string name="vpn_save_login" msgid="5986762519977472618">"Accountgegevens opslaan"</string>
    <string name="vpn_not_used" msgid="7229312881336083354">"(niet gebruikt)"</string>
    <string name="vpn_no_ca_cert" msgid="3687379414088677735">"(server niet verifiëren)"</string>
    <string name="vpn_no_server_cert" msgid="8106540968643125407">"(ontvangen van server)"</string>
    <string name="vpn_always_on_invalid_reason_type" msgid="4699113710248872972">"Dit type VPN kan niet continu verbonden blijven"</string>
    <string name="vpn_always_on_invalid_reason_server" msgid="2635347740046212693">"Always-on VPN ondersteunt alleen numerieke serveradressen"</string>
    <string name="vpn_always_on_invalid_reason_no_dns" msgid="3980357762395272467">"Er moet een DNS-server worden ingesteld voor Always-on VPN"</string>
    <string name="vpn_always_on_invalid_reason_dns" msgid="3934369594591801587">"Adressen van DNS-servers moeten numeriek zijn voor Always-on VPN"</string>
    <string name="vpn_always_on_invalid_reason_other" msgid="4571905303713233321">"De opgegeven informatie is niet geschikt voor Always-on VPN"</string>
    <string name="vpn_cancel" msgid="5929410618112404383">"Annuleren"</string>
    <string name="vpn_done" msgid="5137858784289564985">"Sluiten"</string>
    <string name="vpn_save" msgid="683868204634860888">"Opslaan"</string>
    <string name="vpn_connect" msgid="7102335248484045354">"Verbinding maken"</string>
    <string name="vpn_replace" msgid="1533147558671640341">"Vervangen"</string>
    <string name="vpn_edit" msgid="5862301148429324911">"VPN-profiel bewerken"</string>
    <string name="vpn_forget" msgid="2913950864877236737">"Vergeten"</string>
    <string name="vpn_connect_to" msgid="216709261691085594">"Verbinding maken met <xliff:g id="PROFILE">%s</xliff:g>"</string>
    <string name="vpn_disconnect_confirm" msgid="6356789348816854539">"Verbinding met dit VPN verbreken?"</string>
    <string name="vpn_disconnect" msgid="7753808961085867345">"Verbinding verbreken"</string>
    <string name="vpn_version" msgid="6344167191984400976">"Versie"</string>
    <string name="vpn_forget_long" msgid="729132269203870205">"VPN vergeten"</string>
    <string name="vpn_replace_vpn_title" msgid="3994226561866340280">"Bestaande VPN vervangen?"</string>
    <string name="vpn_set_vpn_title" msgid="1667539483005810682">"Always-on VPN instellen?"</string>
    <string name="vpn_first_always_on_vpn_message" msgid="2769478310633047870">"Als deze instelling aanstaat, wordt de internetverbinding verbroken totdat de VPN-verbinding is gemaakt"</string>
    <string name="vpn_replace_always_on_vpn_enable_message" msgid="9154843462740876652">"Je bestaande VPN wordt vervangen en je hebt pas weer internetverbinding nadat het VPN verbinding heeft gemaakt"</string>
    <string name="vpn_replace_always_on_vpn_disable_message" msgid="4299175336198481106">"Je bent al verbonden met een Always-on VPN. Als je verbinding maakt met een ander VPN, wordt je bestaande VPN vervangen en wordt de Always-on-modus uitgezet."</string>
    <string name="vpn_replace_vpn_message" msgid="1094297700371463386">"Je hebt al verbinding met een VPN. Als je verbinding met een ander VPN maakt, wordt je bestaande VPN vervangen."</string>
    <string name="vpn_turn_on" msgid="3568307071295211187">"Aanzetten"</string>
    <string name="vpn_cant_connect_title" msgid="5670787575925519386">"<xliff:g id="VPN_NAME">%1$s</xliff:g> kan geen verbinding maken"</string>
    <string name="vpn_cant_connect_message" msgid="2139148820719163694">"Deze app biedt geen ondersteuning voor Always-on VPN"</string>
    <string name="vpn_title" msgid="3068868814145870274">"VPN"</string>
    <string name="vpn_create" msgid="7546073242936894638">"VPN-profiel toevoegen"</string>
    <string name="vpn_menu_edit" msgid="5100387853773792379">"Profiel bewerken"</string>
    <string name="vpn_menu_delete" msgid="4455966182219039928">"Profiel verwijderen"</string>
    <string name="vpn_menu_lockdown" msgid="5284041663859541007">"Always-on VPN"</string>
    <string name="vpn_no_vpns_added" msgid="7387080769821533728">"Geen VPN\'s toegevoegd"</string>
    <string name="vpn_always_on_summary" msgid="2171252372476858166">"Continu verbonden blijven met VPN"</string>
    <string name="vpn_always_on_summary_not_supported" msgid="9084872130449368437">"Niet ondersteund door deze app"</string>
    <string name="vpn_always_on_summary_active" msgid="175877594406330387">"Altijd aan"</string>
    <string name="vpn_insecure_summary" msgid="4450920215186742859">"Niet beveiligd"</string>
    <string name="vpn_require_connection" msgid="1027347404470060998">"Verbindingen zonder VPN blokkeren"</string>
    <string name="vpn_require_connection_title" msgid="4186758487822779039">"VPN-verbinding vereisen?"</string>
    <string name="vpn_insecure_dialog_subtitle" msgid="1857621742868835300">"Niet beveiligd. Update naar een IKEv2 VPN"</string>
    <string name="vpn_lockdown_summary" msgid="4700625960550559029">"Selecteer een VPN-profiel waarmee je altijd verbonden wilt blijven. Netwerkverkeer wordt alleen toegestaan bij verbinding met dit VPN."</string>
    <string name="vpn_lockdown_none" msgid="455915403560910517">"Geen"</string>
    <string name="vpn_lockdown_config_error" msgid="1992071316416371316">"Voor Always-on VPN is een IP-adres voor zowel de server als DNS vereist."</string>
    <string name="vpn_no_network" msgid="7187593680049843763">"Er is geen netwerkverbinding. Probeer het later opnieuw."</string>
    <string name="vpn_disconnected" msgid="7694522069957717501">"Verbinding met VPN verbroken"</string>
    <string name="vpn_disconnected_summary" msgid="721699709491697712">"Geen"</string>
    <string name="vpn_missing_cert" msgid="5397309964971068272">"Er ontbreekt een certificaat. Bewerk het profiel."</string>
    <string name="trusted_credentials_system_tab" msgid="675362923690364722">"Systeem"</string>
    <string name="trusted_credentials_user_tab" msgid="4978365619630094339">"Gebruiker"</string>
    <string name="trusted_credentials_disable_label" msgid="6649583220519447947">"Uitzetten"</string>
    <string name="trusted_credentials_enable_label" msgid="5551204878588237991">"Aanzetten"</string>
    <string name="trusted_credentials_remove_label" msgid="8296330919329489422">"Verwijderen"</string>
    <string name="trusted_credentials_trust_label" msgid="4841047312274452474">"Vertrouwen"</string>
    <string name="trusted_credentials_enable_confirmation" msgid="6686528499458144754">"Het CA-certificaat voor het systeem aanzetten?"</string>
    <string name="trusted_credentials_disable_confirmation" msgid="5131642563381656676">"CA-certificaat voor systeem uitzetten?"</string>
    <string name="trusted_credentials_remove_confirmation" msgid="3420345440353248381">"CA-certificaat van gebruiker permanent verwijderen?"</string>
    <string name="credential_being_used_by" msgid="3682869943025283499">"Wordt gebruikt door"</string>
    <string name="credential_contains" msgid="3146519680449595771">"Dit inlogitem bevat"</string>
    <string name="one_userkey" msgid="6363426728683951234">"1 gebruikerssleutel"</string>
    <string name="one_usercrt" msgid="2097644070227688983">"1 gebruikerscertificaat"</string>
    <string name="one_cacrt" msgid="982242103604501559">"1 CA-certificaat"</string>
    <string name="n_cacrts" msgid="5886462550192731627">"%d CA-certificaten"</string>
    <string name="user_credential_title" msgid="4686178602575567298">"Inloggegevens"</string>
    <string name="user_credential_removed" msgid="4087675887725394743">"Inlog-item verwijderd: <xliff:g id="CREDENTIAL_NAME">%s</xliff:g>"</string>
    <string name="user_credential_none_installed" msgid="918620912366836994">"Geen inloggegevens van gebruiker geïnstalleerd"</string>
    <string name="spellcheckers_settings_title" msgid="2799021700580591443">"Spellingcontrole"</string>
    <string name="spellcheckers_settings_for_work_title" msgid="6471603934176062893">"Spellingcontrole voor werk"</string>
    <string name="current_backup_pw_prompt" msgid="4962276598546381140">"Typ hier je huidige wachtwoord voor volledige back-up"</string>
    <string name="new_backup_pw_prompt" msgid="4884439230209419503">"Typ hier je nieuwe wachtwoord voor volledige back-up"</string>
    <string name="confirm_new_backup_pw_prompt" msgid="5753796799743881356">"Typ hier nogmaals je nieuwe wachtwoord voor volledige back-up"</string>
    <string name="backup_pw_set_button_text" msgid="8892357974661340070">"Wachtwoord voor back-up instellen"</string>
    <string name="backup_pw_cancel_button_text" msgid="2244399819018756323">"Annuleren"</string>
    <string name="additional_system_update_settings_list_item_title" msgid="7230385345152138051">"Aanvullende systeemupdates"</string>
    <string name="ssl_ca_cert_warning" msgid="3898387588657346106">"Netwerk kan worden gemonitord"</string>
    <string name="done_button" msgid="6269449526248267">"Klaar"</string>
    <string name="ssl_ca_cert_dialog_title" msgid="1032088078702042090">"{count,plural, =1{Certificaat vertrouwen of verwijderen}other{Certificaten vertrouwen of verwijderen}}"</string>
    <string name="ssl_ca_cert_info_message_device_owner" msgid="7528581447864707873">"{numberOfCertificates,plural, =1{{orgName} heeft een certificeringsinstantie (CA) op je apparaat geïnstalleerd, waardoor dit domein de netwerkactiviteit van je apparaat kan bijhouden, waaronder e-mails, apps en beveiligde websites.\n\nNeem contact op met je beheerder voor meer informatie.}other{{orgName} heeft certificeringsinstanties (CA\'s) op je apparaat geïnstalleerd, waardoor dit domein de netwerkactiviteit van je apparaat kan bijhouden, waaronder e-mails, apps en beveiligde websites.\n\nNeem contact op met je beheerder voor meer informatie.}}"</string>
    <string name="ssl_ca_cert_info_message" msgid="3111724430981667845">"{numberOfCertificates,plural, =1{{orgName} heeft een certificeringsinstantie (CA) voor je werkprofiel geïnstalleerd, waardoor dit domein activiteit in het werknetwerk kan bijhouden, waaronder e-mails, apps en beveiligde websites.\n\nNeem contact op met je beheerder voor meer informatie.}other{{orgName} heeft certificeringsinstanties (CA\'s) voor je werkprofiel geïnstalleerd, waardoor dit domein activiteit in het werknetwerk kan bijhouden, waaronder e-mails, apps en beveiligde websites.\n\nNeem contact op met je beheerder voor meer informatie.}}"</string>
    <string name="ssl_ca_cert_warning_message" msgid="4374052724815563051">"Een derde partij kan je netwerkactiviteit, waaronder e-mails, apps en beveiligde websites, bijhouden.\n\nDit is mogelijk omdat je een vertrouwd certificaat op je apparaat hebt opgeslagen."</string>
    <string name="ssl_ca_cert_settings_button" msgid="2044927302268394991">"{count,plural, =1{Certificaat checken}other{Certificaten checken}}"</string>
    <string name="user_settings_title" msgid="6550866465409807877">"Meerdere gebruikers"</string>
    <string name="user_list_title" msgid="1387379079186123404">"Gebruikers en profielen"</string>
    <string name="user_add_user_or_profile_menu" msgid="305851380425838287">"Gebruiker of profiel toevoegen"</string>
    <string name="user_summary_restricted_profile" msgid="451650609582185813">"Beperkt profiel"</string>
    <string name="user_summary_not_set_up" msgid="4602868481732886115">"Niet ingesteld"</string>
    <string name="user_summary_restricted_not_set_up" msgid="1658946988920104613">"Niet ingesteld - Beperkt profiel"</string>
    <string name="user_summary_managed_profile_not_set_up" msgid="5739207307082458746">"Niet ingesteld - Werkprofiel"</string>
    <string name="user_admin" msgid="4024553191395768119">"Beheerder"</string>
    <string name="user_you" msgid="3070562015202859996">"Jij (<xliff:g id="NAME">%s</xliff:g>)"</string>
    <string name="user_add_max_count" msgid="3328539978480663740">"Je kunt geen gebruikers meer toevoegen. Verwijder een gebruiker om een nieuwe toe te voegen."</string>
    <string name="user_cannot_add_accounts_message" msgid="2351326078338805337">"Beperkte profielen kunnen geen accounts toevoegen"</string>
    <string name="user_remove_user_menu" msgid="2183714948094429367">"<xliff:g id="USER_NAME">%1$s</xliff:g> verwijderen van dit apparaat"</string>
    <string name="user_lockscreen_settings" msgid="4596612658981942092">"Instellingen voor vergrendelscherm"</string>
    <string name="user_add_on_lockscreen_menu" msgid="2539059062034644966">"Gebruikers toevoegen vanaf vergrendelscherm"</string>
    <string name="switch_to_dock_user_when_docked" msgid="2324395443311905635">"Overschakelen naar beheerder indien gedockt"</string>
    <string name="user_confirm_remove_self_title" msgid="926265330805361832">"Wil je jezelf verwijderen?"</string>
    <string name="user_confirm_remove_title" msgid="3626559103278006002">"Gebruiker verwijderen?"</string>
    <string name="user_profile_confirm_remove_title" msgid="3131574314149375354">"Dit profiel verwijderen?"</string>
    <string name="work_profile_confirm_remove_title" msgid="6229618888167176036">"Werkprofiel verwijderen?"</string>
    <string name="user_confirm_remove_message" msgid="362545924965977597">"Alle apps en gegevens worden verwijderd."</string>
    <string name="work_profile_confirm_remove_message" msgid="1037294114103024478">"Alle apps en gegevens in dit profiel worden verwijderd als je doorgaat."</string>
    <string name="user_profile_confirm_remove_message" msgid="3641289528179850718">"Alle apps en gegevens worden verwijderd."</string>
    <string name="user_adding_new_user" msgid="7439602720177181412">"Nieuwe gebruiker toevoegen…"</string>
    <string name="user_delete_user_description" msgid="7764153465503821011">"Gebruiker verwijderen"</string>
    <string name="user_delete_button" msgid="3833498650182594653">"Verwijderen"</string>
    <string name="user_exit_guest_confirm_message" msgid="8995296853928816554">"Alle apps en gegevens in deze sessie worden verwijderd."</string>
    <string name="user_exit_guest_dialog_remove" msgid="7067727314172605181">"Verwijderen"</string>
    <string name="guest_category_title" msgid="5562663588315329152">"Gast (jij)"</string>
    <string name="user_category_title" msgid="4368580529662699083">"Gebruikers"</string>
    <string name="other_user_category_title" msgid="7089976887307643217">"Andere gebruikers"</string>
    <string name="remove_guest_on_exit" msgid="8202972371459611066">"Gastactiviteit verwijderen"</string>
    <string name="remove_guest_on_exit_summary" msgid="3969962695703280353">"Verwijder alle gast-apps en -gegevens bij het afsluiten van de gastmodus"</string>
    <string name="remove_guest_on_exit_dialog_title" msgid="2310442892536079416">"Gastactiviteit verwijderen?"</string>
    <string name="remove_guest_on_exit_dialog_message" msgid="8112409834021851883">"Apps en gegevens van deze gastsessie worden nu verwijderd en alle toekomstige gastactiviteit wordt verwijderd telkens wanneer je de gastmodus afsluit"</string>
    <string name="remove_guest_on_exit_keywords" msgid="4961310523576166193">"verwijderen, gast, activiteit, wissen, gegevens, bezoeker, weggooien"</string>
    <string name="enable_guest_calling" msgid="8300355036005240911">"Gast toestaan telefoon te gebruiken"</string>
    <string name="enable_guest_calling_summary" msgid="4748224917641204782">"De gespreksgeschiedenis wordt met de gastgebruiker gedeeld"</string>
    <string name="user_enable_calling_sms" msgid="8546430559552381324">"Telefoonoproepen en sms aanzetten"</string>
    <string name="user_grant_admin" msgid="5942118263054572074">"Deze gebruiker beheerder maken"</string>
    <string name="user_remove_user" msgid="8468203789739693845">"Gebruiker verwijderen"</string>
    <string name="user_enable_calling_and_sms_confirm_title" msgid="4041510268838725520">"Telefoonoproepen en sms aanzetten?"</string>
    <string name="user_enable_calling_and_sms_confirm_message" msgid="367792286597449922">"De gespreks- en sms-geschiedenis wordt gedeeld met deze gebruiker."</string>
    <string name="user_revoke_admin_confirm_title" msgid="3057842401861731863">"Beheerdersrechten verwijderen?"</string>
    <string name="user_revoke_admin_confirm_message" msgid="9207187319308572958">"Als je de beheerdersrechten voor deze gebruiker verwijdert, kunnen jij of een andere beheerder deze later weer teruggeven."</string>
    <string name="emergency_info_title" msgid="8233682750953695582">"Noodinformatie"</string>
    <string name="emergency_info_summary" msgid="8463622253016757697">"Informatie en contacten voor <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="open_app_button" msgid="5025229765547191710">"<xliff:g id="APP_NAME">%1$s</xliff:g> openen"</string>
    <string name="application_restrictions" msgid="276179173572729205">"Apps en content toestaan"</string>
    <string name="apps_with_restrictions_header" msgid="5277698582872267931">"Apps met beperkingen"</string>
    <string name="apps_with_restrictions_settings_button" msgid="2648355133416902221">"Inst. uitbreiden voor app"</string>
    <string name="user_choose_copy_apps_to_another_user" msgid="5914037067347012870">"Apps kiezen om te installeren"</string>
    <string name="user_copy_apps_menu_title" msgid="5354300105759670300">"Beschikbare apps installeren"</string>
    <string name="nfc_payment_settings_title" msgid="2043139180030485500">"Contactloze betalingen"</string>
    <string name="nfc_default_payment_settings_title" msgid="2150504446774382261">"Standaard betalingsapp"</string>
    <string name="nfc_default_payment_footer" msgid="978535088340021360">"Als je een betaling wilt doen via een betalingsapp, houd je de achterkant van je apparaat tegen een betaalautomaat."</string>
    <string name="nfc_more_details" msgid="1700713533074275233">"Meer informatie"</string>
    <string name="nfc_default_payment_workapp_confirmation_title" msgid="746921251872504687">"Werk-app instellen als standaard betalingsapp?"</string>
    <string name="nfc_default_payment_workapp_confirmation_message_title" msgid="1533022606333010329">"Voor een betaling via een werk-app:"</string>
    <string name="nfc_default_payment_workapp_confirmation_message_1" msgid="2917430119080702912">"moet je werkprofiel aanstaan, en"</string>
    <string name="nfc_default_payment_workapp_confirmation_message_2" msgid="8161184137833245628">"moet je je werkpincode, -patroon of -wachtwoord opgeven als je die hebt."</string>
    <string name="nfc_payment_how_it_works" msgid="3658253265242662010">"Hoe het werkt"</string>
    <string name="nfc_payment_no_apps" msgid="6840001883471438798">"Betaal met je telefoon in winkels"</string>
    <string name="nfc_payment_default" msgid="3769788268378614608">"Standaard betaal-app"</string>
    <string name="nfc_payment_default_not_set" msgid="6471905683119084622">"Niet ingesteld"</string>
    <string name="nfc_payment_app_and_desc" msgid="2607417639227030398">"<xliff:g id="APP">%1$s</xliff:g> - <xliff:g id="DESCRIPTION">%2$s</xliff:g>"</string>
    <string name="nfc_payment_use_default" msgid="6127665705799658860">"Standaard betalingsapp gebruiken"</string>
    <string name="nfc_payment_use_default_dialog" msgid="8556328090777785383">"Standaard betalingsapp gebruiken"</string>
    <string name="nfc_payment_favor_default" msgid="4508491832174644772">"Altijd"</string>
    <string name="nfc_payment_favor_open" msgid="8554643344050373346">"Behalve als een andere betaal-app is geopend"</string>
    <string name="nfc_payment_pay_with" msgid="3001320460566523453">"Bij een contactloze betaalautomaat betalen met:"</string>
    <string name="nfc_how_it_works_title" msgid="1363791241625771084">"Betalen bij de betaalautomaat"</string>
    <string name="nfc_how_it_works_content" msgid="1141382684788210772">"Stel een betalings-app in. Houd de achterzijde van je telefoon tegen een terminal met het logo voor contactloos betalen."</string>
    <string name="nfc_how_it_works_got_it" msgid="4717868843368296630">"Ik snap het"</string>
    <string name="nfc_more_title" msgid="1041094244767216498">"Meer…"</string>
    <string name="nfc_payment_set_default_label" msgid="7395939287766230293">"Standaard betaal-app instellen"</string>
    <string name="nfc_payment_update_default_label" msgid="8201975914337221246">"Standaard betaal-app updaten"</string>
    <string name="nfc_payment_set_default" msgid="4101484767872365195">"Bij een contactloze betaalautomaat betalen met <xliff:g id="APP">%1$s</xliff:g>"</string>
    <string name="nfc_payment_set_default_instead_of" msgid="565237441045013280">"Bij een contactloze betaalautomaat betalen met <xliff:g id="APP_0">%1$s</xliff:g>.\n\nDeze app vervangt <xliff:g id="APP_1">%2$s</xliff:g> als standaard betaal-app."</string>
    <string name="nfc_payment_btn_text_set_deault" msgid="1821065137209590196">"Instellen als standaard"</string>
    <string name="nfc_payment_btn_text_update" msgid="5159700960497443832">"Updaten"</string>
    <string name="nfc_work_text" msgid="2496515165821504077">"Werk"</string>
    <string name="restriction_settings_title" msgid="4293731103465972557">"Beperkingen"</string>
    <string name="restriction_menu_reset" msgid="92859464456364092">"Beperkingen verwijderen"</string>
    <string name="restriction_menu_change_pin" msgid="2505923323199003718">"Pincode wijzigen"</string>
    <string name="help_label" msgid="2896538416436125883">"Hulp en feedback"</string>
    <string name="user_account_title" msgid="6389636876210834864">"Account voor content"</string>
    <string name="user_picture_title" msgid="7176437495107563321">"Foto-ID"</string>
    <string name="extreme_threats_title" msgid="1098958631519213856">"Groot gevaar"</string>
    <string name="extreme_threats_summary" msgid="3560742429496902008">"Meldingen over groot gevaar voor levens en eigendommen"</string>
    <string name="severe_threats_title" msgid="8962959394373974324">"Groot gevaar"</string>
    <string name="severe_threats_summary" msgid="4982256198071601484">"Meldingen ontv. bij groot gevaar voor levens en eigendommen"</string>
    <string name="amber_alerts_title" msgid="5238275758191804575">"AMBER Alerts"</string>
    <string name="amber_alerts_summary" msgid="5755221775246075883">"Berichten ontvangen over ontvoerde kinderen"</string>
    <string name="repeat_title" msgid="8676570486899483606">"Herhalen"</string>
    <string name="call_manager_enable_title" msgid="1214301265395158720">"Oproepbeheer aanzetten"</string>
    <string name="call_manager_enable_summary" msgid="7362506369604163030">"Deze service toestaan te beheren hoe je gesprekken worden uitgevoerd."</string>
    <string name="call_manager_title" msgid="3397433159509629466">"Oproepbeheer"</string>
    <!-- no translation found for call_manager_summary (2558839230880919191) -->
    <skip />
    <string name="cell_broadcast_settings" msgid="2416980110093867199">"Noodmeldingen"</string>
    <string name="network_operators_settings" msgid="5105453353329748954">"Netwerkproviders"</string>
    <string name="access_point_names" msgid="5768430498022188057">"Namen van toegangspunten"</string>
    <string name="enhanced_4g_lte_mode_title" msgid="6624700245232361149">"VoLTE"</string>
    <string name="enhanced_4g_lte_mode_title_advanced_calling" msgid="7066009898031465265">"Geavanceerd bellen"</string>
    <string name="enhanced_4g_lte_mode_title_4g_calling" msgid="7445853566718786195">"Bellen via 4G"</string>
    <string name="enhanced_4g_lte_mode_summary" msgid="1067066329756036427">"LTE-services gebruiken voor betere audiogesprekken (aanbevolen)"</string>
    <string name="enhanced_4g_lte_mode_summary_4g_calling" msgid="2575004054914178405">"4G-services gebruiken voor betere audiogesprekken (aanbevolen)"</string>
    <string name="nr_advanced_calling_title" msgid="6106286679535355939">"Vo5G"</string>
    <string name="nr_advanced_calling_summary" msgid="6926192539172030330">"5G gebruiken voor audiogesprekken"</string>
    <string name="contact_discovery_opt_in_title" msgid="8708034790649773814">"Contacten naar provider sturen"</string>
    <string name="contact_discovery_opt_in_summary" msgid="6539010458256667300">"Telefoonnummers van je contacten sturen om geavanceerde functies te bieden"</string>
    <string name="contact_discovery_opt_in_dialog_title" msgid="2230536282911854114">"Contacten naar <xliff:g id="CARRIER">%1$s</xliff:g> sturen?"</string>
    <string name="contact_discovery_opt_in_dialog_title_no_carrier_defined" msgid="2028983133745990320">"Contacten naar je provider sturen?"</string>
    <string name="contact_discovery_opt_in_dialog_message" msgid="8818310894782757538">"De telefoonnummers van je contacten worden periodiek naar <xliff:g id="CARRIER">%1$s</xliff:g> gestuurd.<xliff:g id="EMPTY_LINE">

</xliff:g>Aan de hand van deze informatie wordt vastgesteld of je contacten bepaalde functies kunnen gebruiken, zoals videogesprekken of bepaalde berichtfuncties."</string>
    <string name="contact_discovery_opt_in_dialog_message_no_carrier_defined" msgid="1914894516552445911">"De telefoonnummers van je contacten worden periodiek naar je provider gestuurd.<xliff:g id="EMPTY_LINE">

</xliff:g>Aan de hand van deze informatie wordt vastgesteld of je contacten bepaalde functies kunnen gebruiken, zoals videogesprekken of bepaalde berichtfuncties."</string>
    <string name="preferred_network_type_title" msgid="812509938714590857">"Voorkeursnetwerktype"</string>
    <string name="preferred_network_type_summary" msgid="8786291927331323061">"LTE (aanbevolen)"</string>
    <string name="mms_message_title" msgid="6624505196063391964">"Mms-berichten"</string>
    <string name="mms_message_summary" msgid="2855847140141698341">"Sturen en ontvangen als mobiele data uitstaan"</string>
    <string name="auto_data_switch_title" msgid="5862200603753603464">"Automatisch mobiele data wisselen"</string>
    <string name="auto_data_switch_summary" msgid="1934340931995429057">"Dit netwerk gebruiken als de beschikbaarheid beter is"</string>
    <string name="work_sim_title" msgid="8999872928646924429">"Simkaart voor werk"</string>
    <string name="user_restrictions_title" msgid="4068914244980335993">"Toegang tot apps en content"</string>
    <string name="user_rename" msgid="8735940847878484249">"NAAM WIJZIGEN"</string>
    <string name="app_restrictions_custom_label" msgid="6949268049087435132">"App-beperkingen instellen"</string>
    <string name="user_restrictions_controlled_by" msgid="2821526006742851624">"Beheerd door <xliff:g id="APP">%1$s</xliff:g>"</string>
    <string name="app_sees_restricted_accounts" msgid="3526008344222566318">"Deze app heeft toegang tot je accounts"</string>
    <string name="app_sees_restricted_accounts_and_controlled_by" msgid="8338520379923447143">"Deze app kan toegang krijgen tot je accounts. Beheerd door <xliff:g id="APP">%1$s</xliff:g>"</string>
    <string name="restriction_wifi_config_title" msgid="2630656989926554685">"Wifi en mobiel"</string>
    <string name="restriction_wifi_config_summary" msgid="920419010472168694">"Aanpassing van mobiele en wifi-instellingen toestaan"</string>
    <string name="restriction_bluetooth_config_title" msgid="220586273589093821">"Bluetooth"</string>
    <string name="restriction_bluetooth_config_summary" msgid="7558879931011271603">"Aanpassing van Bluetooth-koppelingen en -instellingen toestaan"</string>
    <string name="restriction_location_enable_title" msgid="4872281754836538066">"Locatie"</string>
    <string name="restriction_location_enable_summary" msgid="7139292323897390221">"Apps je locatiegegevens laten gebruiken"</string>
    <string name="wizard_back" msgid="8257697435061870191">"Terug"</string>
    <string name="wizard_next" msgid="3884832431439072471">"Volgende"</string>
    <string name="wizard_back_adoptable" msgid="1447814356855134183">"Op een andere manier formatteren"</string>
    <string name="regulatory_info_text" msgid="1154461023369976667"></string>
    <string name="sim_settings_title" msgid="2254609719033946272">"Simkaarten"</string>
    <string name="sim_cellular_data_unavailable" msgid="4653591727755387534">"Mobiele data niet beschikbaar"</string>
    <string name="sim_cellular_data_unavailable_summary" msgid="6505871722911347881">"Tik om een simkaart voor gegevens te selecteren"</string>
    <string name="sim_calls_always_use" msgid="967857230039768111">"Altijd gebruiken voor gesprekken"</string>
    <string name="select_sim_for_data" msgid="2642305487659432499">"Simkaart voor mobiele data kiezen"</string>
    <string name="select_sim_for_sms" msgid="5335510076282673497">"Selecteer een simkaart voor sms"</string>
    <string name="data_switch_started" msgid="6292759843974720112">"Schakelen naar simkaart voor mobiele data, dit kan even duren…"</string>
    <string name="select_specific_sim_for_data_title" msgid="5851980301321577985">"<xliff:g id="NEW_SIM">%1$s</xliff:g> gebruiken voor mobiele data?"</string>
    <string name="select_specific_sim_for_data_msg" msgid="7401698123430573637">"Als je overschakelt naar <xliff:g id="NEW_SIM">%1$s</xliff:g>, wordt <xliff:g id="OLD_SIM">%2$s</xliff:g> niet meer gebruikt voor mobiele data."</string>
    <string name="select_specific_sim_for_data_button" msgid="6571935548920603512">"<xliff:g id="NEW_SIM">%1$s</xliff:g> gebruiken"</string>
    <string name="select_sim_for_calls" msgid="7843107015635189868">"Bellen met"</string>
    <string name="sim_name_hint" msgid="8231524869124193119">"Voer de sim-naam in"</string>
    <string name="sim_editor_title" msgid="918655391915256859">"Simkaartsleuf %1$d"</string>
    <string name="color_orange" msgid="216547825489739010">"Oranje"</string>
    <string name="color_purple" msgid="6603701972079904843">"Paars"</string>
    <string name="sim_status_title" msgid="6188770698037109774">"Simkaartstatus"</string>
    <string name="sim_status_title_sim_slot" msgid="4932996839194493313">"Simkaartstatus (simkaartsleuf %1$d)"</string>
    <string name="sim_signal_strength" msgid="6351052821700294501">"<xliff:g id="DBM">%1$d</xliff:g> dBm <xliff:g id="ASU">%2$d</xliff:g> asu"</string>
    <string name="sim_notification_title" msgid="2819551384383504031">"Simkaarten gewijzigd."</string>
    <string name="sim_notification_summary" msgid="5593339846307029991">"Tik om in te stellen"</string>
    <string name="sim_calls_ask_first_prefs_title" msgid="3077694594349657933">"Elke keer vragen"</string>
    <string name="sim_selection_required_pref" msgid="231437651041498359">"Selectie vereist"</string>
    <string name="sim_selection_channel_title" msgid="3193666315607572484">"Simkaartselectie"</string>
    <string name="dashboard_title" msgid="5660733037244683387">"Instellingen"</string>
    <string name="network_dashboard_title" msgid="788543070557731240">"Netwerk en internet"</string>
    <string name="network_dashboard_summary_mobile" msgid="7750924671970583670">"Mobiel, wifi, hotspot"</string>
    <string name="network_dashboard_summary_no_mobile" msgid="4022575916334910790">"Wifi, hotspot"</string>
    <string name="connected_devices_dashboard_title" msgid="19868275519754895">"Verbonden apparaten"</string>
    <string name="connected_devices_dashboard_default_summary" msgid="7211769956193710397">"Bluetooth, koppelen"</string>
    <string name="connected_devices_dashboard_summary" msgid="6927727617078296491">"Bluetooth, rijstand, NFC"</string>
    <string name="connected_devices_dashboard_no_nfc_summary" msgid="8424794257586524040">"Bluetooth, rijstand"</string>
    <string name="connected_devices_dashboard_no_driving_mode_summary" msgid="7155882619333726331">"Bluetooth, NFC"</string>
    <string name="connected_devices_dashboard_no_driving_mode_no_nfc_summary" msgid="1175254057213044560">"Bluetooth"</string>
    <string name="connected_devices_dashboard_android_auto_summary" msgid="8179090809275818804">"Bluetooth, Android Auto, rijstand, NFC"</string>
    <string name="connected_devices_dashboard_android_auto_no_nfc_summary" msgid="2532811870469405527">"Bluetooth, Android Auto, rijstand"</string>
    <string name="connected_devices_dashboard_android_auto_no_driving_mode_summary" msgid="6426996842202276640">"Bluetooth, Android Auto, NFC"</string>
    <string name="connected_devices_dashboard_android_auto_no_nfc_no_driving_mode" msgid="1672426693308438634">"Bluetooth, Android Auto"</string>
    <string name="nfc_and_payment_settings_payment_off_nfc_off_summary" msgid="7132040463607801625">"Niet beschikbaar omdat NFC uitstaat"</string>
    <string name="nfc_and_payment_settings_no_payment_installed_summary" msgid="4879818114908207465">"Als je dit wilt gebruiken, installeer je eerst een betaal-app"</string>
    <string name="app_and_notification_dashboard_summary" msgid="8047683010984186106">"Recente apps, standaard-apps"</string>
    <string name="notification_settings_work_profile" msgid="6076211850526353975">"Toegang tot meldingen is niet beschikbaar voor apps in het werkprofiel."</string>
    <string name="account_dashboard_title" msgid="8228773251948253914">"Wachtwoorden en accounts"</string>
    <string name="account_dashboard_default_summary" msgid="1730719656099599488">"Opgeslagen wachtwoorden, automatisch invullen, gesynchroniseerde accounts"</string>
    <string name="app_default_dashboard_title" msgid="4071015747629103216">"Standaard-apps"</string>
    <string name="cloned_apps_dashboard_title" msgid="5542076801222950921">"Gekloonde apps"</string>
    <string name="desc_cloned_apps_intro_text" msgid="1369621522882622476">"Maak een tweede instantie van een app zodat je 2 accounts tegelijk kunt gebruiken."</string>
    <string name="desc_cloneable_app_list_text" msgid="3354586725814708688">"Gekloonde apps."</string>
    <string name="cloned_apps_summary" msgid="8805362440770795709">"<xliff:g id="CLONED_APPS_COUNT">%1$s</xliff:g> gekloond, <xliff:g id="ALLOWED_APPS_COUNT">%2$d</xliff:g> beschikbaar om te klonen"</string>
    <string name="delete_all_app_clones" msgid="3489053361980624999">"Alle app-klonen verwijderen"</string>
    <string name="delete_all_app_clones_failure" msgid="6821033414547132335">"Alle app-klonen verwijderen mislukt"</string>
    <string name="cloned_app_creation_summary" msgid="4642627294993918502">"Maken…"</string>
    <string name="cloned_app_created_summary" msgid="7277912971544890710">"Gekloond"</string>
    <string name="cloned_app_creation_toast_summary" msgid="3854494347144867870">"Kloon van <xliff:g id="PACKAGE_LABEL">%1$s</xliff:g> wordt gemaakt"</string>
    <string name="cloned_app_created_toast_summary" msgid="755225403495544163">"Kloon van <xliff:g id="PACKAGE_LABEL">%1$s</xliff:g> is gemaakt"</string>
    <string name="system_dashboard_summary" msgid="7400745270362833832">"Talen, gebaren, tijd, back-up"</string>
    <string name="languages_setting_summary" msgid="7963053736715746726">"Systeemtalen, app-talen, spraak"</string>
    <string name="keywords_wifi" msgid="8156528242318351490">"wifi, wifi-netwerk, netwerkverbinding, internet, draadloos, gegevens, wifi-verbinding"</string>
    <string name="keywords_wifi_notify_open_networks" msgid="6580896556389306636">"Wifimelding, wifi-melding"</string>
    <string name="keywords_wifi_data_usage" msgid="4718555409695862085">"datagebruik"</string>
    <string name="keywords_time_format" msgid="5384803098766166820">"24-uurs klok gebruiken"</string>
    <string name="keywords_app_default" msgid="8977706259156428770">"Openen met"</string>
    <string name="keywords_applications_settings" msgid="999926810912037792">"Apps"</string>
    <string name="keywords_time_zone" msgid="6402919157244589055">"tijdzone"</string>
    <string name="keywords_draw_overlay" msgid="3170036145197260392">"Chathead, systeem, melding, venster, dialoogvenster, weergeven, over andere apps, tekenen"</string>
    <string name="keywords_flashlight" msgid="2133079265697578183">"Zaklamp, lamp, licht, lampje"</string>
    <string name="keywords_change_wifi_state" msgid="7573039644328488165">"wifi, wi-fi, schakelen, aanzetten, uitzetten, beheren"</string>
    <string name="keywords_more_mobile_networks" msgid="5041272719326831744">"mobiel, gsm, provider, draadloos, gegevens, data, 4g, 3g, 2g, lte"</string>
    <string name="keywords_wifi_calling" msgid="4319184318421027136">"wifi, wi-fi, gesprek, gesprek, bellen, gebeld"</string>
    <string name="keywords_display" msgid="874738809280751745">"scherm, touchscreen"</string>
    <string name="keywords_display_brightness_level" msgid="850742707616318056">"scherm dimmen, touchscreen, batterij, helder"</string>
    <string name="keywords_display_night_display" msgid="4711054330804250058">"scherm dimmen, nacht, tint, nachtdienst, helderheid, schermkleur, kleur, kleurstelling"</string>
    <string name="keywords_display_wallpaper" msgid="8478137541939526564">"achtergrond, personaliseren, weergave aanpassen"</string>
    <string name="keywords_display_font_size" msgid="3593317215149813183">"tekstgrootte"</string>
    <string name="keywords_display_cast_screen" msgid="2572331770299149370">"projecteren, casten, scherm mirroren, scherm delen, mirroring, delen van scherm, scherm casten"</string>
    <string name="keywords_storage" msgid="3004667910133021783">"ruimte, schijf, harde schijf, apparaatgebruik"</string>
    <string name="keywords_battery" msgid="7040323668283600530">"stroomverbruik, opladen"</string>
    <string name="keywords_battery_usage" msgid="1763573071014260220">"batterijgebruik bekijken, batterijgebruik, energiegebruik"</string>
    <string name="keywords_battery_saver" msgid="6289682844453234359">"batterijbesparing, energiebesparing, besparing"</string>
    <string name="keywords_battery_adaptive_preferences" msgid="1774870663426502938">"aangepaste voorkeuren, aangepast batterijgebruik"</string>
    <string name="keywords_spell_checker" msgid="5148906820603481657">"spelling, woordenboek, spellingcontrole, automatisch corrigeren"</string>
    <string name="keywords_voice_input" msgid="7534900094659358971">"herkenning, invoer, spraak, spreken, taal, handsfree, hands free, herkenning, aanstootgevend, woord, audio, geschiedenis, bluetooth-headset"</string>
    <string name="keywords_text_to_speech_output" msgid="6728080502619011668">"snelheid, taal, standaard, spreek, spreken, spraak, tts, toegankelijkheid, schermlezer, blind"</string>
    <string name="keywords_date_and_time" msgid="4402136313104901312">"klok, militair"</string>
    <string name="keywords_network_reset" msgid="4075670452112218042">"resetten, herstellen, terugzetten naar fabrieksinstellingen"</string>
    <string name="keywords_factory_data_reset" msgid="4979623326958976773">"wissen, verwijderen, legen, herstellen, schoonmaken, fabrieksinstellingen terugzetten"</string>
    <string name="keywords_printing" msgid="3528250034669909466">"printer"</string>
    <string name="keywords_sounds" msgid="187191900698371911">"speakerpiep, speaker, luidspreker, volume, dempen, geluid uitzetten, stil, audio, muziek, haptisch, trilling, trillen"</string>
    <string name="keywords_sounds_and_notifications_interruptions" msgid="1500312884808362467">"niet storen, verstoren, onderbreking, storing"</string>
    <string name="keywords_app" msgid="7983814237980258061">"RAM"</string>
    <string name="keywords_location" msgid="8016374808099706213">"in de buurt, locatie, geschiedenis, rapportage, gps"</string>
    <string name="keywords_accounts" msgid="3013897982630845506">"account, een account toevoegen, werkprofiel, account toevoegen, verwijderen, wissen"</string>
    <string name="keywords_users" msgid="3497517660077620843">"beperking, beperken, beperkt"</string>
    <string name="keywords_keyboard_and_ime" msgid="4741098648730042570">"tekstcorrectie, corrigeren, geluid, trillen, automatisch, taal, gebaar, voorstellen, suggestie, thema, aanstootgevend, woord, typen, emoji, internationaal"</string>
    <string name="keywords_reset_apps" msgid="8254315757754930862">"resetten, herstellen, voorkeuren, standaard"</string>
    <string name="keywords_all_apps" msgid="9016323378609007166">"apps, download, downloaden, applicaties, systeem"</string>
    <string name="keywords_app_permissions" msgid="2061773665663541610">"apps, rechten, beveiliging"</string>
    <string name="keywords_default_apps" msgid="4601664230800605416">"apps, standaard"</string>
    <string name="keywords_ignore_optimizations" msgid="8967142288569785145">"optimalisaties negeren, sluimeren, stand-by voor apps"</string>
    <string name="keywords_color_mode" msgid="1193896024705705826">"levendig, RGB, sRGB, kleur, natuurlijk, standaard"</string>
    <string name="keywords_screen_resolution" msgid="6652125115386722875">"FHD, QHD, resolutie, 1080p, 1440p"</string>
    <string name="keywords_color_temperature" msgid="8159539138837118453">"kleur, temperatuur, D65, D73, wit, geel, blauw, warm, koel"</string>
    <string name="keywords_lockscreen" msgid="3656926961043485797">"schuiven om te ontgrendelen, wachtwoord, patroon, pincode"</string>
    <string name="keywords_app_pinning" msgid="1564144561464945019">"scherm vastzetten"</string>
    <string name="keywords_profile_challenge" msgid="5135555521652143612">"werkuitdaging, werk, profiel"</string>
    <string name="keywords_unification" msgid="2677472004971453468">"werkprofiel, beheerd profiel, gelijkschakelen, unificatie, werk, profiel"</string>
    <string name="keywords_gesture" msgid="3456930847450080520">"gebaren"</string>
    <string name="keywords_wallet" msgid="3757421969956996972">"portemonnee"</string>
    <string name="keywords_payment_settings" msgid="6268791289277000043">"betalen, tikken, betalingen"</string>
    <string name="keywords_backup" msgid="707735920706667685">"back-up, back-up maken, back-uppen"</string>
    <string name="keywords_assist_gesture_launch" msgid="7710762655355161924">"gebaar"</string>
    <string name="keywords_face_unlock" msgid="545338452730885392">"gezicht, ontgrendelen, auth, inloggen"</string>
    <string name="keywords_biometric_unlock" msgid="8569545388717753692">"gezicht, ontgrendelen, verificatie, inloggen, vingerafdruk, biometrisch"</string>
    <string name="keywords_imei_info" msgid="8848791606402333514">"imei, meid, min, prl-versie, imei-softwareversie"</string>
    <string name="keywords_sim_status" msgid="4221401945956122228">"netwerk, status mobiel netwerk, servicestatus, signaalsterkte, type mobiel netwerk, roaming"</string>
    <string name="keywords_sim_status_esim" msgid="3338719238556853609">"netwerk, status mobiel netwerk, servicestatus, signaalsterkte, type mobiel netwerk, roaming, eid"</string>
    <string name="keywords_sim_status_iccid" msgid="4775398796251969759">"netwerk, status mobiel netwerk, servicestatus, signaalsterkte, type mobiel netwerk, roaming, iccid"</string>
    <string name="keywords_sim_status_iccid_esim" msgid="4634015619840979184">"netwerk, status mobiel netwerk, servicestatus, signaalsterkte, type mobiel netwerk, roaming, iccid, eid"</string>
    <string name="keywords_esim_eid" msgid="8128175058237372457">"eid"</string>
    <string name="keywords_model_and_hardware" msgid="4723665865709965044">"serienummer, hardwareversie"</string>
    <string name="keywords_battery_info" msgid="3319796850366687033">"batterij-informatie, productiedatum, aantal cyclussen, eerste gebruik"</string>
    <string name="keywords_android_version" msgid="1629882125290323070">"niveau van android-beveiligingspatch, smalbandversie, kernel-versie"</string>
    <string name="keywords_dark_ui_mode" msgid="6373999418195344014">"thema, licht, donker, modus, lichtgevoeligheid, fotofobie, donkerder maken, donkerder, donkere modus, migraine"</string>
    <string name="keywords_systemui_theme" msgid="6341194275296707801">"donker thema"</string>
    <string name="keywords_device_feedback" msgid="5489930491636300027">"bug"</string>
    <string name="keywords_ambient_display_screen" msgid="661492302323274647">"Inactief scherm, vergrendelscherm"</string>
    <string name="keywords_lock_screen_notif" msgid="6363144436467429932">"melding, meldingen op vergrendelscherm"</string>
    <string name="keywords_face_settings" msgid="1360447094486865058">"gezicht"</string>
    <string name="keywords_fingerprint_settings" msgid="7345121109302813358">"vingerafdruk, vingerafdruk toevoegen"</string>
    <string name="keywords_biometric_settings" msgid="2173605297939326549">"gezicht, vingerafdruk, vingerafdruk toevoegen"</string>
    <string name="keywords_active_unlock_settings" msgid="4511320720304388889">"ontgrendelen via smartwatch, ontgrendelen via smartwatch toevoegen"</string>
    <string name="keywords_display_auto_brightness" msgid="7162942396941827998">"scherm dimmen, touchscreen, batterij, slimme helderheid, dynamische helderheid, automatische helderheid"</string>
    <string name="keywords_display_adaptive_sleep" msgid="4905300860114643966">"smart, scherm dimmen, slaap, batterij, time-out, aandacht, display, scherm, inactiviteit"</string>
    <string name="keywords_auto_rotate" msgid="7288697525101837071">"camera, smart, automatisch draaien, automatisch roteren, draaien, omdraaien, rotatie, staand, liggend, stand, verticaal, horizontaal"</string>
    <string name="keywords_system_update_settings" msgid="5769003488814164931">"upgrade, android"</string>
    <string name="keywords_zen_mode_settings" msgid="7810203406522669584">"dnd, schema, meldingen, blokkeren, stil, trillen, slapen, werken, focus, geluid, dempen, dag, weekdag, weekend, doordeweekse avond, evenement, afspraak, geluid uitzetten, niet storen"</string>
    <string name="keywords_screen_timeout" msgid="8921857020437540572">"scherm, vergrendelingstijd, time-out, vergrendelscherm"</string>
    <string name="keywords_storage_settings" msgid="6018856193950281898">"geheugen, cache, gegevens, wissen, verwijderen, vrij, vrijmaken, ruimte"</string>
    <string name="keywords_bluetooth_settings" msgid="2588159530959868188">"verbonden, apparaat, hoofdtelefoon, koptelefoon, headset, speaker, luidspreker, draadloos, koppelen, oordoppen, oordopjes, muziek, media"</string>
    <string name="keywords_wallpaper" msgid="7332890404629446192">"achtergrond, thema, raster, aanpassen, personaliseren"</string>
    <string name="keywords_styles" msgid="5291614313348476068">"icoon, accent, kleur"</string>
    <string name="keywords_assist_input" msgid="3086289530227075593">"standaard, assistent"</string>
    <string name="keywords_default_payment_app" msgid="5162298193637362104">"betaling, standaard"</string>
    <string name="keywords_ambient_display" msgid="3149287105145443697">"binnenkomende melding"</string>
    <string name="keywords_hotspot_tethering" msgid="3688439689671232627">"usb-tether, bluetooth-tether, wifi-hotspot"</string>
    <string name="keywords_accessibility_vibration_primary_switch" msgid="730692154347231253">"haptisch, trillen, trilstand"</string>
    <string name="keywords_touch_vibration" msgid="1125291201902251273">"haptische technologie, trillen, scherm, gevoeligheid"</string>
    <string name="keywords_ring_vibration" msgid="1736301626537417541">"haptische feedback, trillen, telefoon, gesprek, gevoeligheid, bellen"</string>
    <string name="keywords_ramping_ringer_vibration" msgid="3678966746742257366">"haptische feedback, trillen, telefoon, bellen, gesprek, overgaan, geleidelijk"</string>
    <string name="keywords_notification_vibration" msgid="2620799301276142183">"haptische technologie, trillen, gevoeligheid, melding"</string>
    <string name="keywords_alarm_vibration" msgid="4833220371621521817">"haptische technologie, trillen, gevoeligheid, wekker"</string>
    <string name="keywords_media_vibration" msgid="723896490102792327">"haptische technologie, trillen, gevoeligheid, media"</string>
    <string name="keywords_vibration" msgid="670455132028025952">"haptisch, trillen, trilstand"</string>
    <string name="keywords_battery_saver_sticky" msgid="1646191718840975110">"batterijbesparing, sticky, actief blijven, energiebesparing, batterij"</string>
    <string name="keywords_battery_saver_schedule" msgid="8240483934368455930">"routine, planning, batterijbesparing, energiebesparing, batterij, automatisch, procent"</string>
    <string name="keywords_enhance_4g_lte" msgid="658889360486800978">"volte, geavanceerd bellen, bellen via 4G"</string>
    <string name="keywords_nr_advanced_calling" msgid="4157823099610141014">"vo5g, vonr, geavanceerd bellen, 5g-bellen, bellen via 5g"</string>
    <string name="keywords_add_language" msgid="1882751300359939436">"taal toevoegen, een taal toevoegen"</string>
    <string name="keywords_font_size" msgid="1643198841815006447">"tekstgrootte, grote letters, groot lettertype, grote tekst, slechtziend, tekst groter maken, lettertype vergroten, vergroting van lettertype"</string>
    <string name="keywords_always_show_time_info" msgid="1066752498285497595">"inactief scherm altijd aan, AOD"</string>
    <string name="keywords_change_nfc_tag_apps_state" msgid="9032287964590554366">"nfc, tag, lezer"</string>
    <string name="sound_dashboard_summary" msgid="6574444810552643312">"Volume, trillen, niet storen"</string>
    <string name="media_volume_option_title" msgid="5966569685119475630">"Mediavolume"</string>
    <string name="remote_media_volume_option_title" msgid="8760846743943305764">"Castvolume"</string>
    <string name="call_volume_option_title" msgid="1461105986437268924">"Gespreksvolume"</string>
    <string name="alarm_volume_option_title" msgid="6398641749273697140">"Wekkervolume"</string>
    <string name="ring_volume_option_title" msgid="1520802026403038560">"Volume ringtone en meldingen"</string>
    <string name="separate_ring_volume_option_title" msgid="2212910223857375951">"Ringtonevolume"</string>
    <string name="notification_volume_option_title" msgid="4838818791683615978">"Meldingsvolume"</string>
    <string name="notification_volume_disabled_summary" msgid="8679988555852056079">"Niet beschikbaar, omdat het belgeluid uitstaat"</string>
    <string name="ringtone_title" msgid="3271453110387368088">"Ringtone"</string>
    <string name="notification_ringtone_title" msgid="6924501621312095512">"Standaard meldingsgeluid"</string>
    <string name="notification_unknown_sound_title" msgid="1319708450698738980">"Door app geleverd geluid"</string>
    <string name="notification_sound_default" msgid="8630353701915294299">"Standaard meldingsgeluid"</string>
    <string name="alarm_ringtone_title" msgid="6680761007731764726">"Standaard alarmgeluid"</string>
    <string name="vibrate_when_ringing_option_ramping_ringer" msgid="2798848945803840348">"Eerst trillen en dan geleidelijk bellen"</string>
    <string name="spatial_audio_title" msgid="6591051622375191603">"Ruimtelijke audio"</string>
    <string name="dial_pad_tones_title" msgid="3536945335367914892">"Toetsenbloktonen"</string>
    <string name="screen_locking_sounds_title" msgid="5695030983872787321">"Geluid schermvergrendeling"</string>
    <string name="charging_sounds_title" msgid="5261683808537783668">"Oplaadgeluiden en -trillingen"</string>
    <string name="docking_sounds_title" msgid="5341616179210436159">"Dockinggeluiden"</string>
    <string name="touch_sounds_title" msgid="826964355109667449">"Tik- en klikgeluiden"</string>
    <string name="vibrate_icon_title" msgid="1281100105045362530">"Icoon altijd tonen in trilmodus"</string>
    <string name="dock_audio_media_title" msgid="6474579339356398330">"Afspelen op dockluidspreker"</string>
    <string name="dock_audio_media_disabled" msgid="8499927008999532341">"Alle audio"</string>
    <string name="dock_audio_media_enabled" msgid="4039126523653131281">"Alleen media-audio"</string>
    <string name="emergency_tone_silent" msgid="5048069815418450902">"Stilte"</string>
    <string name="emergency_tone_alert" msgid="1977698889522966589">"Tonen"</string>
    <string name="emergency_tone_vibrate" msgid="6282296789406984698">"Trillingen"</string>
    <string name="boot_sounds_title" msgid="5033062848948884111">"Opstartgeluiden"</string>
    <string name="live_caption_title" msgid="8617086825712756983">"Live ondertiteling"</string>
    <string name="live_caption_summary" msgid="2898451867595161809">"Ondertitel media automatisch"</string>
    <string name="spatial_audio_speaker" msgid="9145233652433523302">"Telefoonspeaker"</string>
    <string name="spatial_audio_wired_headphones" msgid="2237355789145828648">"Bedrade hoofdtelefoon"</string>
    <string name="spatial_audio_text" msgid="8201387855375146000">"Compatibele media leveren een royaler geluid"</string>
    <string name="spatial_summary_off" msgid="8272678804629774378">"Uit"</string>
    <string name="spatial_summary_on_one" msgid="6239933399496282994">"Aan: <xliff:g id="OUTPUT_DEVICE">%1$s</xliff:g>"</string>
    <string name="spatial_summary_on_two" msgid="4526919818832483883">"Aan: <xliff:g id="OUTPUT_DEVICE_0">%1$s</xliff:g> en <xliff:g id="OUTPUT_DEVICE_1">%2$s</xliff:g>"</string>
    <string name="spatial_audio_footer_title" msgid="8775010547623606088">"Je kunt ook ruimtelijke audio voor bluetooth-apparaten aanzetten."</string>
    <string name="spatial_audio_footer_learn_more_text" msgid="3826811708094366301">"Instellingen voor verbonden apparaten"</string>
    <string name="zen_mode_settings_schedules_summary" msgid="2047688589286811617">"{count,plural, =0{Geen}=1{1 planning ingesteld}other{# planningen ingesteld}}"</string>
    <string name="zen_mode_settings_title" msgid="682676757791334259">"Niet storen"</string>
    <string name="zen_mode_settings_summary" msgid="6040862775514495191">"Krijg alleen meldingen van belangrijke mensen en apps"</string>
    <string name="zen_mode_slice_subtitle" msgid="6849372107272604160">"Onderbrekingen beperken"</string>
    <string name="zen_mode_settings_turn_on_dialog_title" msgid="7500702838426404527">"Zet Niet storen aan."</string>
    <string name="zen_mode_behavior_alarms_only" msgid="2956938533859578315">"Wekkers en mediageluiden mogen onderbreken"</string>
    <string name="zen_mode_automation_settings_title" msgid="3709324184191870926">"Planningen"</string>
    <string name="zen_mode_delete_automatic_rules" msgid="5020468289267191765">"Planningen verwijderen"</string>
    <string name="zen_mode_schedule_delete" msgid="5383420576833765114">"Verwijderen"</string>
    <string name="zen_mode_rule_name_edit" msgid="1053237022416700481">"Bewerken"</string>
    <string name="zen_mode_automation_settings_page_title" msgid="6217433860514433311">"Planningen"</string>
    <string name="zen_mode_automatic_rule_settings_page_title" msgid="5264835276518295033">"Schema"</string>
    <string name="zen_mode_schedule_category_title" msgid="1381879916197350988">"Schema"</string>
    <string name="zen_mode_automation_suggestion_title" msgid="7776129050500707960">"Telefoongeluid uitzetten op bepaalde tijdstippen"</string>
    <string name="zen_mode_automation_suggestion_summary" msgid="1946750790084170826">"Regels voor \'Niet storen\' instellen"</string>
    <string name="zen_mode_schedule_title" msgid="7064866561892906613">"Schema"</string>
    <string name="zen_mode_use_automatic_rule" msgid="733850322530002484">"Planning gebruiken"</string>
    <string name="zen_mode_summary_combination" msgid="5944689309915947828">"<xliff:g id="MODE">%1$s</xliff:g>: <xliff:g id="EXIT_CONDITION">%2$s</xliff:g>"</string>
    <string name="zen_mode_settings_category" msgid="3794956668816783447">"Onderbrekingen toestaan die een geluid laten horen"</string>
    <string name="zen_mode_visual_interruptions_settings_title" msgid="7806181124566937214">"Blokkeer visuele onderbreking"</string>
    <string name="zen_mode_visual_signals_settings_subtitle" msgid="7433077540895876672">"Visuele signalen toestaan"</string>
    <string name="zen_mode_restrict_notifications_title" msgid="4169952466106040297">"Weergaveopties voor verborgen meldingen"</string>
    <string name="zen_mode_restrict_notifications_category" msgid="5870944770935394566">"Als Niet storen aanstaat"</string>
    <string name="zen_mode_restrict_notifications_mute" msgid="6692072837485018287">"Geen geluid van meldingen"</string>
    <string name="zen_mode_restrict_notifications_mute_summary" msgid="966597459849580949">"Je ziet meldingen op je scherm"</string>
    <string name="zen_mode_restrict_notifications_mute_footer" msgid="2152115038156049608">"Wanneer er meldingen binnenkomen, laat je telefoon geen geluid horen en trilt deze niet"</string>
    <string name="zen_mode_restrict_notifications_hide" msgid="5997930361607752541">"Geen zichtbare of hoorbare meldingen"</string>
    <string name="zen_mode_restrict_notifications_hide_summary" msgid="6005445725686969583">"Je ziet of hoort geen meldingen"</string>
    <string name="zen_mode_restrict_notifications_hide_footer" msgid="3761837271201073330">"Je telefoon trilt niet en maakt geen geluid voor nieuwe of bestaande meldingen. Ook laat je telefoon deze niet zien. Belangrijke meldingen over je apparaatactiviteit en -status blijven echter wel verschijnen.\n\nAls je \'Niet storen\' uitschakelt, kun je de gemiste meldingen zien door van boven naar beneden te swipen op je scherm."</string>
    <string name="zen_mode_restrict_notifications_custom" msgid="5469078057954463796">"Aangepast"</string>
    <string name="zen_mode_restrict_notifications_enable_custom" msgid="4303255634151330401">"Aangepaste instelling aanzetten"</string>
    <string name="zen_mode_restrict_notifications_disable_custom" msgid="5062332754972217218">"Aangepaste instelling verwijderen"</string>
    <string name="zen_mode_restrict_notifications_summary_muted" msgid="4750213316794189968">"Geen geluid van meldingen"</string>
    <string name="zen_mode_restrict_notifications_summary_custom" msgid="3918461289557316364">"Gedeeltelijk verborgen"</string>
    <string name="zen_mode_restrict_notifications_summary_hidden" msgid="636494600775773296">"Geen zichtbare of hoorbare meldingen"</string>
    <string name="zen_mode_what_to_block_title" msgid="5692710098205334164">"Aangepaste beperkingen"</string>
    <string name="zen_mode_block_effects_screen_on" msgid="8780668375194500987">"Als het scherm aanstaat"</string>
    <string name="zen_mode_block_effects_screen_off" msgid="2291988790355612826">"Als het scherm uitstaat"</string>
    <string name="zen_mode_block_effect_sound" msgid="7929909410442858327">"Geluid en trillen uitzetten"</string>
    <string name="zen_mode_block_effect_intent" msgid="7621578645742903531">"Scherm niet aanzetten"</string>
    <string name="zen_mode_block_effect_light" msgid="1997222991427784993">"Lampje niet laten knipperen"</string>
    <string name="zen_mode_block_effect_peek" msgid="2525844009475266022">"Geen meldingen op het scherm"</string>
    <string name="zen_mode_block_effect_status" msgid="5765965061064691918">"Statussen bovenaan scherm verbergen"</string>
    <string name="zen_mode_block_effect_badge" msgid="332151258515152429">"Meldingsstipjes op apps verbergen"</string>
    <string name="zen_mode_block_effect_ambient" msgid="1247740599476031543">"Niet activeren voor meldingen"</string>
    <string name="zen_mode_block_effect_list" msgid="7549367848660137118">"Verbergen in pull-downvenster"</string>
    <string name="zen_mode_block_effect_summary_none" msgid="6688519142395714659">"Nooit"</string>
    <string name="zen_mode_block_effect_summary_screen_off" msgid="6989818116297061488">"Als scherm uit is"</string>
    <string name="zen_mode_block_effect_summary_screen_on" msgid="4876016548834916087">"Als scherm aan is"</string>
    <string name="zen_mode_block_effect_summary_sound" msgid="1559968890497946901">"Geluid en trillen"</string>
    <string name="zen_mode_block_effect_summary_some" msgid="2730383453754229650">"Geluid, trillen en enkele visuele tekenen van meldingen"</string>
    <string name="zen_mode_block_effect_summary_all" msgid="3131918059492425222">"Geluid, trillen en visuele tekenen van meldingen"</string>
    <string name="zen_mode_blocked_effects_footer" msgid="6403365663466620328">"Meldingen die nodig zijn voor de basisactiviteit en -status van je apparaat worden nooit verborgen."</string>
    <string name="zen_mode_no_exceptions" msgid="1580136061336585873">"Geen"</string>
    <string name="zen_mode_other_options" msgid="3399967231522580421">"andere opties"</string>
    <string name="zen_mode_add" msgid="8789024026733232566">"Toevoegen"</string>
    <string name="zen_mode_enable_dialog_turn_on" msgid="1971034397501675078">"Aanzetten"</string>
    <string name="zen_mode_button_turn_on" msgid="6583862599681052347">"Nu aanzetten"</string>
    <string name="zen_mode_button_turn_off" msgid="2060862413234857296">"Nu uitzetten"</string>
    <string name="zen_mode_settings_dnd_manual_end_time" msgid="8251503918238985549">"Niet storen staat aan tot <xliff:g id="FORMATTED_TIME">%s</xliff:g>"</string>
    <string name="zen_mode_settings_dnd_manual_indefinite" msgid="1436568478062106132">"Niet storen blijft aan totdat je deze functie uitzet"</string>
    <string name="zen_mode_settings_dnd_automatic_rule" msgid="1958092329238152236">"Niet storen is automatisch aangezet door een planning (<xliff:g id="RULE_NAME">%s</xliff:g>)"</string>
    <string name="zen_mode_settings_dnd_automatic_rule_app" msgid="3401685760954156067">"Niet storen is automatisch aangezet door een app (<xliff:g id="APP_NAME">%s</xliff:g>)"</string>
    <string name="zen_mode_settings_dnd_custom_settings_footer" msgid="6566115866660865385">"Niet storen staat aan voor <xliff:g id="RULE_NAMES">%s</xliff:g> met aangepaste instellingen."</string>
    <string name="zen_mode_settings_dnd_custom_settings_footer_link" msgid="8255159194653341835">" "<annotation id="link">"Aangepaste instellingen bekijken"</annotation></string>
    <string name="zen_interruption_level_priority" msgid="4854123502362861192">"Alleen prioriteit"</string>
    <string name="zen_mode_and_condition" msgid="8580896862841920031">"<xliff:g id="ZEN_MODE">%1$s</xliff:g>. <xliff:g id="EXIT_CONDITION">%2$s</xliff:g>"</string>
    <string name="zen_mode_sound_summary_on_with_info" msgid="4803606180235742003">"Aan: <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="zen_mode_sound_summary_on" msgid="9077659040104989899">"Aan"</string>
    <string name="zen_mode_duration_summary_always_prompt" msgid="7658172853423383037">"Altijd vragen"</string>
    <string name="zen_mode_duration_summary_forever" msgid="5551992961329998606">"Totdat je uitzet"</string>
    <string name="zen_mode_duration_summary_time_hours" msgid="2602655749780428308">"{count,plural, =1{1 uur}other{# uur}}"</string>
    <string name="zen_mode_duration_summary_time_minutes" msgid="5755536844016835693">"{count,plural, =1{1 minuut}other{# minuten}}"</string>
    <string name="zen_mode_sound_summary_off" msgid="7350437977839985836">"{count,plural, =0{Uit}=1{Uit: 1 planning kan automatisch worden aangezet}other{Uit: # planningen kunnen automatisch worden aangezet}}"</string>
    <string name="zen_category_behavior" msgid="3214056473947178507">"Waardoor Niet storen mag worden onderbroken"</string>
    <string name="zen_category_people" msgid="8252926021894933047">"Mensen"</string>
    <string name="zen_category_apps" msgid="1167374545618451925">"Apps"</string>
    <string name="zen_category_exceptions" msgid="1316097981052752811">"Wekkers en andere onderbrekingen"</string>
    <string name="zen_category_schedule" msgid="2003707171924226212">"Planningen"</string>
    <string name="zen_category_duration" msgid="7515850842082631460">"Duur voor Snelle instellingen"</string>
    <string name="zen_settings_general" msgid="2704932194620124153">"Algemeen"</string>
    <string name="zen_sound_footer" msgid="4090291351903631977">"Als \'Niet storen\' aanstaat, staan geluiden en trillingen uit, behalve als je ze hierboven toestaat."</string>
    <string name="zen_custom_settings_dialog_title" msgid="4613603772432720380">"Aangepaste instellingen"</string>
    <string name="zen_custom_settings_dialog_review_schedule" msgid="4674671820584759928">"Planning controleren"</string>
    <string name="zen_custom_settings_dialog_ok" msgid="8842373418878278246">"OK"</string>
    <string name="zen_custom_settings_notifications_header" msgid="7635280645171095398">"Meldingen"</string>
    <string name="zen_custom_settings_duration_header" msgid="5065987827522064943">"Duur"</string>
    <string name="zen_msg_event_reminder_title" msgid="5362025129007417554">"Meldingen, afspraken en herinneringen"</string>
    <string name="zen_msg_event_reminder_footer" msgid="2700459146293750387">"Als \'Niet storen\' aanstaat, wordt het geluid van berichten, herinneringen en afspraken uitgezet, behalve als je ze hierboven toestaat. Je kunt de instellingen aanpassen zodat je vrienden, gezinsleden of andere contacten je nog wel kunnen bereiken."</string>
    <string name="zen_onboarding_ok" msgid="8764248406533833392">"Klaar"</string>
    <string name="zen_onboarding_settings" msgid="2815839576245114342">"Instellingen"</string>
    <string name="zen_onboarding_new_setting_title" msgid="8813308612916316657">"Geen zichtbare of hoorbare meldingen"</string>
    <string name="zen_onboarding_current_setting_title" msgid="5024603685220407195">"Geen geluid van meldingen"</string>
    <string name="zen_onboarding_new_setting_summary" msgid="7695808354942143707">"Je ziet of hoort geen meldingen. Gesprekken met contacten met ster en terugkerende bellers zijn toegestaan."</string>
    <string name="zen_onboarding_current_setting_summary" msgid="8864567406905990095">"(Huidige instelling)"</string>
    <string name="zen_onboarding_dnd_visual_disturbances_header" msgid="8639698336231314609">"Instellingen voor meldingen in modus \'Niet storen\' wijzigen?"</string>
    <string name="sound_work_settings" msgid="752627453846309092">"Geluiden voor werkprofiel"</string>
    <string name="work_use_personal_sounds_title" msgid="7729428677919173609">"Geluid persoonlijk profiel gebruiken"</string>
    <string name="work_use_personal_sounds_summary" msgid="608061627969077231">"Gebruik dezelfde geluiden als voor je persoonlijke profiel"</string>
    <string name="work_ringtone_title" msgid="4810802758746102589">"Ringtone voor werktelefoon"</string>
    <string name="work_notification_ringtone_title" msgid="2955312017013255515">"Standaardmeldingsgeluid voor werk"</string>
    <string name="work_alarm_ringtone_title" msgid="3369293796769537392">"Standaard alarmgeluid voor werk"</string>
    <string name="work_sound_same_as_personal" msgid="1836913235401642334">"Hetzelfde als persoonlijk profiel"</string>
    <string name="work_sync_dialog_title" msgid="7810248132303515469">"Geluiden van persoonlijk profiel gebruiken?"</string>
    <string name="work_sync_dialog_yes" msgid="5785488304957707534">"Bevestigen"</string>
    <string name="work_sync_dialog_message" msgid="5066178064994040223">"Voor je werkprofiel worden dezelfde geluiden gebruikt als voor je persoonlijke profiel"</string>
    <string name="configure_notification_settings" msgid="1492820231694314376">"Meldingen"</string>
    <string name="notification_dashboard_summary" msgid="7530169251902320652">"Meldingsgeschiedenis, gesprekken"</string>
    <string name="conversation_notifs_category" msgid="2549844862379963273">"Gesprek"</string>
    <string name="general_notification_header" msgid="3669031068980713359">"Beheren"</string>
    <string name="app_notification_field" msgid="3208079070539894909">"App-meldingen"</string>
    <string name="app_notification_field_summary" msgid="5981393613897713471">"Beheer meldingen van afzonderlijke apps"</string>
    <string name="advanced_section_header" msgid="6478709678084326738">"Algemeen"</string>
    <string name="profile_section_header" msgid="4970209372372610799">"Werkmeldingen"</string>
    <string name="profile_section_header_for_advanced_privacy" msgid="8385775428904838579">"Werkprofiel"</string>
    <string name="asst_capability_prioritizer_title" msgid="1181272430009156556">"Aanpasbare meldingsprioriteit"</string>
    <string name="asst_capability_prioritizer_summary" msgid="954988212366568737">"Meldingen met lagere prioriteit automatisch instellen op Subtiel"</string>
    <string name="asst_capability_ranking_title" msgid="312998580233257581">"Aanpasbare rangschikking van meldingen"</string>
    <string name="asst_capability_ranking_summary" msgid="2293524677144599450">"Meldingen automatisch rangschikken op relevantie"</string>
    <string name="asst_feedback_indicator_title" msgid="5169801869752395354">"Aanpasbare meldingsfeedback"</string>
    <string name="asst_feedback_indicator_summary" msgid="5862082842073307900">"Aanpassingen aan meldingen aangeven en de optie tonen om feedback te geven aan het systeem"</string>
    <string name="asst_importance_reset_title" msgid="6191265591976440115">"Belang van meldingen resetten"</string>
    <string name="asst_importance_reset_summary" msgid="684794589254282667">"Door de gebruiker gewijzigde instellingen voor belang resetten en de meldingenassistent toestaan om de prioriteit te bepalen"</string>
    <string name="asst_capabilities_actions_replies_title" msgid="4392470465646394289">"Voorgestelde acties en antwoorden"</string>
    <string name="asst_capabilities_actions_replies_summary" msgid="416234323365645871">"Voorgestelde acties en antwoorden automatisch tonen"</string>
    <string name="notification_history_summary" msgid="5434741516307706892">"Toon recente en gesnoozede meldingen"</string>
    <string name="notification_history" msgid="8663811361243456201">"Meldings­geschiedenis"</string>
    <string name="notification_history_toggle" msgid="9093762294928569030">"Meldingsgeschiedenis gebruiken"</string>
    <string name="notification_history_off_title_extended" msgid="853807652537281601">"Meldingsgeschiedenis staat uit"</string>
    <string name="notification_history_off_summary" msgid="671359587084797617">"Zet de meldingsgeschiedenis aan om recente meldingen en gesnoozede meldingen te bekijken"</string>
    <string name="history_toggled_on_title" msgid="4518001110492652830">"Geen recente meldingen"</string>
    <string name="history_toggled_on_summary" msgid="9034278971358282728">"Je recente en gesnoozede meldingen zie je hier"</string>
    <string name="notification_history_view_settings" msgid="5269317798670449002">"instellingen voor meldingen bekijken"</string>
    <string name="notification_history_open_notification" msgid="2655071846911258371">"melding openen"</string>
    <string name="snooze_options_title" msgid="2109795569568344617">"Snoozen van meldingen toestaan"</string>
    <string name="notification_badging_title" msgid="5469616894819568917">"Meldingsstipje op app-icoon"</string>
    <string name="notification_bubbles_title" msgid="5681506665322329301">"Bubbels"</string>
    <string name="bubbles_app_toggle_title" msgid="5319021259954576150">"Bubbels"</string>
    <string name="bubbles_conversation_toggle_title" msgid="5225039214083311316">"Dit gesprek als bubbel tonen"</string>
    <string name="bubbles_conversation_toggle_summary" msgid="720229032254323578">"Toon zwevend icoon vóór apps"</string>
    <string name="bubbles_feature_disabled_dialog_title" msgid="1794193899792284007">"Bubbels voor apparaat aanzetten?"</string>
    <string name="bubbles_feature_disabled_dialog_text" msgid="5275666953364031055">"Als je bubbels gebruikt voor deze app, worden bubbels ook gebruikt voor je apparaat.\n\nDit is van invloed op andere apps of gesprekken die als bubbel mogen worden getoond."</string>
    <string name="bubbles_feature_disabled_button_approve" msgid="2042628067101419871">"Aanzetten"</string>
    <string name="bubbles_feature_disabled_button_cancel" msgid="8963409459448350600">"Annuleren"</string>
    <string name="notifications_bubble_setting_on_summary" msgid="4641572377430901196">"Aan: gesprekken kunnen als zwevende iconen worden getoond"</string>
    <string name="notifications_bubble_setting_title" msgid="8287649393774855268">"Toestaan dat apps bubbels tonen"</string>
    <string name="notifications_bubble_setting_description" msgid="7336770088735025981">"Sommige gesprekken worden vóór andere apps weergegeven als zwevende iconen"</string>
    <string name="bubble_app_setting_all" msgid="312524752846978277">"Alle gesprekken kunnen als bubbel worden getoond"</string>
    <string name="bubble_app_setting_selected" msgid="4324386074198040675">"Geselecteerde gesprekken kunnen als bubbel worden getoond"</string>
    <string name="bubble_app_setting_none" msgid="8643594711863996418">"Niets kan als bubbel worden getoond"</string>
    <string name="bubble_app_setting_selected_conversation_title" msgid="3060958976857529933">"Gesprekken"</string>
    <string name="bubble_app_setting_excluded_conversation_title" msgid="324818960338773945">"Alle gesprekken kunnen als bubbel worden getoond, behalve"</string>
    <string name="bubble_app_setting_unbubble_conversation" msgid="1769789500566080427">"Bubbels voor dit gesprek uitzetten"</string>
    <string name="bubble_app_setting_bubble_conversation" msgid="1461981680982964285">"Bubbels aanzetten voor dit gesprek"</string>
    <string name="swipe_direction_ltr" msgid="5137180130142633085">"Swipe naar rechts om te sluiten of naar links voor het menu"</string>
    <string name="swipe_direction_rtl" msgid="1707391213940663992">"Swipe naar links om te sluiten of naar rechts voor het menu"</string>
    <string name="silent_notifications_status_bar" msgid="6113307620588767516">"Stille meldingen in statusbalk verbergen"</string>
    <string name="notification_pulse_title" msgid="8013178454646671529">"Knipperlicht"</string>
    <string name="lock_screen_notifications_title" msgid="2876323153692406203">"Privacy"</string>
    <string name="lockscreen_bypass_title" msgid="6519964196744088573">"Vergrendelscherm overslaan"</string>
    <string name="lockscreen_bypass_summary" msgid="4578154430436224161">"Ga na ontgrendeling meteen naar het laatst gebruikte scherm. Meldingen worden niet op het vergrendelscherm getoond. Swipe omlaag om ze te zien."</string>
    <string name="keywords_lockscreen_bypass" msgid="41035425468915498">"Scherm vergrendelen, vergrendelscherm, overslaan"</string>
    <string name="locked_work_profile_notification_title" msgid="279367321791301499">"Als werkprofiel is vergrendeld"</string>
    <string name="unseen_notifs_lock_screen" msgid="6910701117021324612">"Alleen nieuwe meldingen tonen op vergrendelscherm"</string>
    <string name="unseen_notifs_lock_screen_summary" msgid="5996722793868021391">"Eerder bekeken meldingen automatisch verwijderen van het vergrendelscherm"</string>
    <string name="lock_screen_notifs_title" msgid="3412042692317304449">"Meldingen op vergrendelscherm"</string>
    <string name="lock_screen_notifs_show_all_summary" msgid="4226586018375762117">"Gesprekken tonen (standaard en stil)"</string>
    <string name="lock_screen_notifs_show_all" msgid="1300418674456749664">"Toon gesprekken (standaard en stil)"</string>
    <string name="lock_screen_notifs_show_alerting" msgid="6584682657382684566">"Verberg stille gesprekken en meldingen"</string>
    <string name="lock_screen_notifs_show_none" msgid="1941044980403067101">"Toon geen meldingen"</string>
    <string name="lock_screen_notifs_redact" msgid="9024158855454642296">"Gevoelige meldingen"</string>
    <string name="lock_screen_notifs_redact_summary" msgid="1395483766035470612">"Toon gevoelige content op vergrendelscherm"</string>
    <string name="lock_screen_notifs_redact_work" msgid="3833920196569208430">"Gevoelige werkprofielmeldingen"</string>
    <string name="lock_screen_notifs_redact_work_summary" msgid="3238238380405430156">"Toon gevoelige werkprofielcontent op vergrendelscherm"</string>
    <string name="lock_screen_notifications_summary_show" msgid="6540443483088311328">"Toon alle content van meldingen"</string>
    <string name="lock_screen_notifications_summary_hide" msgid="7837303171531166789">"Toon gevoelige content alleen als ontgrendeld"</string>
    <string name="lock_screen_notifications_summary_disable" msgid="3388290397947365744">"Toon helemaal geen meldingen"</string>
    <string name="lock_screen_notifications_interstitial_message" msgid="4688399629301178487">"Hoe wil je dat het vergrendelscherm wordt weergegeven?"</string>
    <string name="lock_screen_notifications_interstitial_title" msgid="1360388192096354315">"Vergrendelscherm"</string>
    <string name="lock_screen_notifications_summary_show_profile" msgid="8373401288962523946">"Content van alle werkmeldingen tonen"</string>
    <string name="lock_screen_notifications_summary_hide_profile" msgid="2183455323048921579">"Gevoelige werkcontent verbergen"</string>
    <string name="lock_screen_notifications_interstitial_message_profile" msgid="1456262034599029028">"Hoe moeten profielmeldingen worden getoond als je apparaat is vergrendeld?"</string>
    <string name="lock_screen_notifications_interstitial_title_profile" msgid="6950124772255324448">"Profielmeldingen"</string>
    <string name="notifications_title" msgid="4221655533193721131">"Meldingen"</string>
    <string name="app_notifications_title" msgid="248374669037385148">"App-meldingen"</string>
    <string name="notification_channel_title" msgid="8859880871692797611">"Meldingscategorie"</string>
    <string name="notification_importance_title" msgid="1545158655988342703">"Gedrag"</string>
    <string name="conversations_category_title" msgid="5586541340846847798">"Gesprekken"</string>
    <string name="conversation_section_switch_title" msgid="3332885377659473775">"Gespreksgedeelte"</string>
    <string name="conversation_section_switch_summary" msgid="6123587625929439674">"Sta toen dat de app het gedeelte voor gesprekken gebruikt."</string>
    <string name="demote_conversation_title" msgid="6355383023376508485">"Geen gesprek"</string>
    <string name="demote_conversation_summary" msgid="4319929331165604112">"Verwijder uit het gedeelte met gesprekken"</string>
    <string name="promote_conversation_title" msgid="4731148769888238722">"Dit is een gesprek"</string>
    <string name="promote_conversation_summary" msgid="3890724115743515035">"Toevoegen aan het gedeelte met gesprekken"</string>
    <string name="priority_conversation_count_zero" msgid="3862289535537564713">"Geen prioriteitsgesprekken"</string>
    <string name="priority_conversation_count" msgid="7291234530844412077">"{count,plural, =1{# prioriteitsgesprek}other{# prioriteitsgesprekken}}"</string>
    <string name="important_conversations" msgid="1233893707189659401">"Prioriteitsgesprekken"</string>
    <string name="important_conversations_summary_bubbles" msgid="614327166808117644">"Toon als zwevende bubbels bovenaan het gespreksgedeelte"</string>
    <string name="important_conversations_summary" msgid="3184022761562676418">"Bovenaan het gespreksgedeelte tonen"</string>
    <string name="other_conversations" msgid="551178916855139870">"Niet-prioriteitsgesprekken"</string>
    <string name="other_conversations_summary" msgid="3487426787901236273">"Gesprekken waarin je wijzigingen hebt aangebracht"</string>
    <string name="recent_conversations" msgid="471678228756995274">"Recente gesprekken"</string>
    <string name="conversation_settings_clear_recents" msgid="8940398397663307054">"Recente gesprekken wissen"</string>
    <string name="recent_convos_removed" msgid="2122932798895714203">"Recente gesprekken verwijderd"</string>
    <string name="recent_convo_removed" msgid="8686414146325958281">"Gesprek verwijderd"</string>
    <string name="clear" msgid="5092178335409471100">"Wissen"</string>
    <string name="conversation_onboarding_title" msgid="5194559958353468484">"Prioriteitsgesprekken en gewijzigde gesprekken zie je hier"</string>
    <string name="conversation_onboarding_summary" msgid="2484845363368486941">"Zodra je een gesprek als prioriteitsgesprek markeert of wijzigingen in gesprekken aanbrengt, zie je ze hier. \n\nZo wijzig je gespreksinstellingen: \nswipe omlaag vanaf de bovenkant van het scherm om het pull-downvenster te openen, tik op een gesprek en houd het vast."</string>
    <string name="notification_importance_min_title" msgid="7676541266705442501">"Minimaliseren"</string>
    <string name="notification_importance_high_title" msgid="394129291760607808">"Tonen op scherm"</string>
    <string name="notification_silence_title" msgid="4085829874452944989">"Stil"</string>
    <string name="notification_alert_title" msgid="1632401211722199217">"Standaard"</string>
    <string name="allow_interruption" msgid="5237201780159482716">"Onderbrekingen toestaan"</string>
    <string name="allow_interruption_summary" msgid="9044131663518112543">"De app geluid laten maken, laten trillen en/of meldingen laten tonen op het scherm"</string>
    <string name="notification_priority_title" msgid="5554834239080425229">"Prioriteit"</string>
    <string name="notification_channel_summary_priority" msgid="7225362351439076913">"Verschijnt als zwevende bubbel bovenaan het gespreksgedeelte en toont profielfoto op vergrendelscherm"</string>
    <string name="convo_not_supported_summary" msgid="4285471045268268048">"<xliff:g id="APP_NAME">%1$s</xliff:g> ondersteunt de meeste gespreksfuncties niet. Je kunt niet instellen dat een gesprek prioriteit heeft en gesprekken worden niet getoond als zwevende bubbels."</string>
    <string name="notification_channel_summary_min" msgid="8823399508450176842">"Vouw meldingen in het pull-downvenster samen tot één regel"</string>
    <string name="notification_channel_summary_low" msgid="5549662596677692000">"Geen geluid of trilling"</string>
    <string name="notification_conversation_summary_low" msgid="6352818857388412326">"Geen geluid of trilling en wordt lager in het gedeelte met gesprekken getoond"</string>
    <string name="notification_channel_summary_default" msgid="3674057458265438896">"Kan overgaan of trillen op basis van de telefooninstellingen"</string>
    <string name="notification_channel_summary_high" msgid="3411637309360617621">"Toon meldingen als banner bovenaan het scherm wanneer het apparaat is ontgrendeld"</string>
    <string name="notification_switch_label" msgid="8029371325967501557">"Alle meldingen van <xliff:g id="APP_NAME">%1$s</xliff:g>"</string>
    <string name="notification_app_switch_label" msgid="4422902423925084193">"Alle meldingen van <xliff:g id="APP_NAME">%1$s</xliff:g>"</string>
    <string name="notifications_sent_daily" msgid="10274479224185437">"{count,plural, =1{Ongeveer # melding per dag}other{Ongeveer # meldingen per dag}}"</string>
    <string name="notifications_sent_weekly" msgid="7895656213187555346">"{count,plural, =1{Ongeveer # melding per week}other{Ongeveer # meldingen per week}}"</string>
    <string name="notifications_sent_never" msgid="9081278709126812062">"Nooit"</string>
    <string name="manage_notification_access_title" msgid="6481256069087219982">"Apparaat- en app-meldingen"</string>
    <string name="manage_notification_access_summary" msgid="2907135226478903997">"Beheer welke apps en apparaten meldingen kunnen lezen"</string>
    <string name="work_profile_notification_access_blocked_summary" msgid="8643809206612366067">"Toegang tot werkprofielmeldingen is geblokkeerd"</string>
    <string name="notification_assistant_title" msgid="5889201903272393099">"Verbeterde meldingen"</string>
    <string name="notification_assistant_summary" msgid="1957783114840908887">"Krijg voorgestelde acties, antwoorden en meer"</string>
    <string name="no_notification_assistant" msgid="2533323397091834096">"Geen"</string>
    <string name="no_notification_listeners" msgid="2839354157349636000">"Er zijn geen geïnstalleerde apps die toegang tot meldingen hebben aangevraagd."</string>
    <string name="notification_access_detail_switch" msgid="46386786409608330">"Toegang tot meldingen toestaan"</string>
    <string name="notification_assistant_security_warning_summary" msgid="4846559755787348129">"In Android 12 hebben verbeterde meldingen aanpasbare Android-meldingen vervangen. Deze functie toont voorgestelde acties en antwoorden, en ordent je meldingen. \n\nVerbeterde meldingen hebben toegang tot meldingsinhoud, waaronder persoonlijke informatie zoals contactnamen en berichten. Deze functie kan ook meldingen sluiten of erop reageren, zoals telefoongesprekken aannemen, en Niet storen beheren."</string>
    <string name="notification_listener_security_warning_title" msgid="5791700876622858363">"Toegang tot meldingen toestaan voor <xliff:g id="SERVICE">%1$s</xliff:g>?"</string>
    <string name="notification_listener_security_warning_summary" msgid="1131986567509818121">"De <xliff:g id="NOTIFICATION_LISTENER_NAME">%1$s</xliff:g>-app kan alle meldingen lezen, waaronder persoonlijke informatie zoals contactnamen, foto\'s en de tekst van berichten die je krijgt. Deze app kan deze meldingen ook snoozen of sluiten of acties uitvoeren voor knoppen in meldingen, waaronder het beantwoorden van gesprekken. \n\nHierdoor kan de app ook Niet storen aan- of uitzetten en gerelateerde instellingen wijzigen."</string>
    <string name="nls_warning_prompt" msgid="1486887096703743841">"De <xliff:g id="NOTIFICATION_LISTENER_NAME">%1$s</xliff:g>-app kan:"</string>
    <string name="nls_feature_read_title" msgid="7629713268744220437">"Je meldingen lezen"</string>
    <string name="nls_feature_read_summary" msgid="1064698238110273593">"De app kan je meldingen lezen, waaronder persoonlijke informatie zoals contacten, berichten en foto\'s"</string>
    <string name="nls_feature_reply_title" msgid="7925455553821362039">"Berichten beantwoorden"</string>
    <string name="nls_feature_reply_summary" msgid="4492543411395565556">"De app kan berichten beantwoorden, meldingen snoozen of sluiten en gesprekken beantwoorden."</string>
    <string name="nls_feature_settings_title" msgid="8208164329853194414">"Instellingen wijzigen"</string>
    <string name="nls_feature_settings_summary" msgid="3770028705648985689">"De app kan Niet storen aan- of uitzetten en gerelateerde instellingen wijzigen"</string>
    <string name="notification_listener_disable_warning_summary" msgid="8373396293802088961">"Als je <xliff:g id="NOTIFICATION_LISTENER_NAME">%1$s</xliff:g> geen toegang tot meldingen geeft, krijgt Niet storen mogelijk ook geen toegang."</string>
    <string name="notification_listener_disable_warning_confirm" msgid="841492108402184976">"Uitzetten"</string>
    <string name="notification_listener_disable_warning_cancel" msgid="8802784105045594324">"Annuleren"</string>
    <string name="notif_type_ongoing" msgid="135675014223627555">"Realtime"</string>
    <string name="notif_type_ongoing_summary" msgid="2348867528527573574">"Lopende communicatie van gebruikte apps, navigatie, telefoongesprekken en meer"</string>
    <string name="notif_type_conversation" msgid="4383931408641374979">"Gesprekken"</string>
    <string name="notif_type_conversation_summary" msgid="179142405410217101">"Sms en andere communicatie"</string>
    <string name="notif_type_alerting" msgid="4713073696855718576">"Meldingen"</string>
    <string name="notif_type_alerting_summary" msgid="4681068287836313604">"Kan overgaan of trillen op basis van de instellingen"</string>
    <string name="notif_type_silent" msgid="6273951794420331010">"Stil"</string>
    <string name="notif_type_silent_summary" msgid="7820923063105060844">"Meldingen die nooit een geluid laten horen of trillen"</string>
    <string name="notification_listener_allowed" msgid="5536962633536318551">"Toegestaan"</string>
    <string name="notification_listener_not_allowed" msgid="3352962779597846538">"Niet toegestaan"</string>
    <string name="notif_listener_excluded_app_title" msgid="6679316209330349730">"Alle apps bekijken"</string>
    <string name="notif_listener_excluded_app_summary" msgid="2914567678047195396">"Verander de instellingen voor elke app die meldingen stuurt"</string>
    <string name="notif_listener_excluded_app_screen_title" msgid="8636196723227432994">"Apps getoond op apparaat"</string>
    <string name="notif_listener_not_migrated" msgid="6265206376374278226">"Deze app ondersteunt geen uitgebreide instellingen"</string>
    <string name="notif_listener_more_settings" msgid="1348409392307208921">"Meer instellingen"</string>
    <string name="notif_listener_more_settings_desc" msgid="7995492074281663658">"Er zijn meer instellingen beschikbaar in deze app"</string>
    <string name="vr_listeners_title" msgid="4960357292472540964">"VR-helperservices"</string>
    <string name="no_vr_listeners" msgid="8442646085375949755">"Er zijn geen geïnstalleerde apps die hebben gevraagd om te worden uitgevoerd als VR-helperservices."</string>
    <string name="vr_listener_security_warning_title" msgid="7026351795627615177">"VR-servicetoegang toestaan voor <xliff:g id="SERVICE">%1$s</xliff:g>?"</string>
    <string name="vr_listener_security_warning_summary" msgid="1888843557687017791">"<xliff:g id="VR_LISTENER_NAME">%1$s</xliff:g> kan worden uitgevoerd wanneer je apps in de virtual reality-modus gebruikt."</string>
    <string name="display_vr_pref_title" msgid="4850474436291113569">"In VR-modus"</string>
    <string name="display_vr_pref_low_persistence" msgid="7039841277157739871">"Vervaging beperken (aanbevolen)"</string>
    <string name="display_vr_pref_off" msgid="4008841566387432721">"Flikkering beperken"</string>
    <string name="picture_in_picture_title" msgid="9001594281840542493">"Scherm-in-scherm"</string>
    <string name="picture_in_picture_empty_text" msgid="9123600661268731579">"Geen geïnstalleerde apps die Scherm-in-scherm ondersteunen"</string>
    <string name="picture_in_picture_keywords" msgid="3605379820551656253">"pip picture beeld in"</string>
    <string name="picture_in_picture_app_detail_title" msgid="4442235098255164650">"Scherm-in-scherm"</string>
    <string name="picture_in_picture_app_detail_switch" msgid="8544190716075624017">"Scherm-in-scherm toestaan"</string>
    <string name="picture_in_picture_app_detail_summary" msgid="2503211101305358849">"Geef deze app toestemming om een scherm-in-scherm-venster te maken als de app open is of als je de app verlaat (bijvoorbeeld om een video te blijven kijken). Dit venster wordt weergegeven vóór andere apps die je gebruikt."</string>
    <string name="interact_across_profiles_title" msgid="7285906999927669971">"Gekoppelde werk- en privé-apps"</string>
    <string name="interact_across_profiles_summary_allowed" msgid="1365881452153799092">"Gekoppeld"</string>
    <string name="interact_across_profiles_summary_not_allowed" msgid="5802674212788171790">"Niet gekoppeld"</string>
    <string name="interact_across_profiles_empty_text" msgid="419061031064397168">"Geen gekoppelde apps"</string>
    <string name="interact_across_profiles_keywords" msgid="5996472773111665049">"voor meerdere profielen gekoppelde app apps werk en persoonlijk"</string>
    <string name="interact_across_profiles_switch_enabled" msgid="7294719120282287495">"Gekoppeld"</string>
    <string name="interact_across_profiles_switch_disabled" msgid="4312196170211463988">"Deze apps koppelen"</string>
    <string name="interact_across_profiles_summary_1" msgid="6093976896137600231">"Gekoppelde apps delen rechten en hebben toegang tot elkaars gegevens."</string>
    <string name="interact_across_profiles_summary_2" msgid="505748305453633885">"Koppel apps alleen als je erop vertrouwt dat ze geen persoonsgegevens met je IT-beheerder delen."</string>
    <string name="interact_across_profiles_summary_3" msgid="444428694843299854">"Je kunt apps op elk moment ontkoppelen via de privacyinstellingen van je apparaat."</string>
    <string name="interact_across_profiles_consent_dialog_title" msgid="8530621211216508681">"<xliff:g id="NAME">%1$s</xliff:g> voor het werk vertrouwen met je persoonsgegevens?"</string>
    <string name="interact_across_profiles_consent_dialog_summary" msgid="3949870271562055048">"Koppel apps alleen als je erop vertrouwt dat ze geen persoonsgegevens met je IT-beheerder delen."</string>
    <string name="interact_across_profiles_consent_dialog_app_data_title" msgid="8436318876213958940">"App-gegevens"</string>
    <string name="interact_across_profiles_consent_dialog_app_data_summary" msgid="6057019384328088311">"Deze app heeft altijd toegang tot je persoonlijke <xliff:g id="NAME">%1$s</xliff:g>-app."</string>
    <string name="interact_across_profiles_consent_dialog_permissions_title" msgid="2316852600280487055">"Rechten"</string>
    <string name="interact_across_profiles_consent_dialog_permissions_summary" msgid="995051542847604039">"Deze app kan de rechten van je persoonlijke <xliff:g id="NAME">%1$s</xliff:g>-app gebruiken, zoals toegang tot locatie, opslag of contacten."</string>
    <string name="interact_across_profiles_number_of_connected_apps_none" msgid="8573289199942092964">"Geen apps gekoppeld"</string>
    <string name="interact_across_profiles_number_of_connected_apps" msgid="4000424798291479207">"{count,plural, =1{# app gekoppeld}other{# apps gekoppeld}}"</string>
    <string name="interact_across_profiles_install_work_app_title" msgid="2821669067014436056">"Installeer <xliff:g id="NAME">%1$s</xliff:g> in je werkprofiel om deze apps te koppelen"</string>
    <string name="interact_across_profiles_install_personal_app_title" msgid="4790651223324866344">"Installeer <xliff:g id="NAME">%1$s</xliff:g> in je persoonlijke profiel om deze apps te koppelen"</string>
    <string name="interact_across_profiles_install_app_summary" msgid="7715324358034968657">"Tik om de app te installeren"</string>
    <string name="manage_zen_access_title" msgid="1562322900340107269">"Toegang tot Niet storen"</string>
    <string name="zen_access_detail_switch" msgid="4183681772666138993">"Niet storen toestaan"</string>
    <string name="zen_access_empty_text" msgid="3779921853282293080">"Er zijn geen geïnstalleerde apps die toegang tot \'Niet storen\' hebben aangevraagd"</string>
    <string name="app_notifications_off_desc" msgid="2484843759466874201">"Je hebt meldingen van deze app niet toegestaan"</string>
    <string name="channel_notifications_off_desc" msgid="6202042207121633488">"Op jouw verzoek toont Android geen meldingen van deze categorie op dit apparaat"</string>
    <string name="channel_group_notifications_off_desc" msgid="9096417708500595424">"Op jouw verzoek toont Android deze groep meldingen niet op dit apparaat"</string>
    <string name="app_notifications_not_send_desc" msgid="5683060986735070528">"Deze app stuurt geen meldingen"</string>
    <string name="notification_channels" msgid="1502969522886493799">"Categorieën"</string>
    <string name="notification_channels_other" msgid="18159805343647908">"Anders"</string>
    <string name="no_channels" msgid="4716199078612071915">"Deze app heeft geen meldingen geplaatst"</string>
    <string name="app_settings_link" msgid="6725453466705333311">"Extra instellingen in de app"</string>
    <string name="deleted_channels" msgid="8489800381509312964">"{count,plural, =1{# categorie verwijderd}other{# categorieën verwijderd}}"</string>
    <string name="app_notification_block_title" msgid="3880322745749900296">"Alles blokkeren"</string>
    <string name="app_notification_block_summary" msgid="1804611676339341551">"Deze meldingen nooit tonen"</string>
    <string name="notification_content_block_title" msgid="6689085826061361351">"Meldingen tonen"</string>
    <string name="notification_content_block_summary" msgid="329171999992248925">"Nooit meldingen tonen in het meldingenpaneel of op randapparaten"</string>
    <string name="app_notification_fsi_permission_title" msgid="5424116606034705020">"Meldingen op volledig scherm toestaan"</string>
    <string name="app_notification_fsi_permission_summary" msgid="7673487977631068039">"Meldingen op volledig scherm toestaan als het apparaat is vergrendeld"</string>
    <string name="notification_badge_title" msgid="6854537463548411313">"Meldingsstipje toestaan"</string>
    <string name="notification_channel_badge_title" msgid="6505542437385640049">"Meldingsstipje tonen"</string>
    <string name="app_notification_override_dnd_title" msgid="3769539356442226691">"Niet storen negeren"</string>
    <string name="app_notification_override_dnd_summary" msgid="4894641191397562920">"Blijf deze meldingen krijgen, ook als Niet storen aanstaat"</string>
    <string name="app_notification_visibility_override_title" msgid="7778628150022065920">"Vergrendelscherm"</string>
    <string name="app_notifications_dialog_done" msgid="573716608705273004">"Klaar"</string>
    <string name="notification_show_lights_title" msgid="5564315979007438583">"Knipperlicht"</string>
    <string name="notification_vibrate_title" msgid="1422330728336623351">"Trillen"</string>
    <string name="notification_channel_sound_title" msgid="9018031231387273476">"Geluid"</string>
    <string name="notification_conversation_important" msgid="4365437037763608045">"Prioriteit"</string>
    <string name="zen_mode_rule_name" msgid="7303080427006917702">"Naam van planning"</string>
    <string name="zen_mode_rule_name_hint" msgid="7029432803855827697">"Geef naam planning op"</string>
    <string name="zen_mode_rule_name_warning" msgid="1244435780807634954">"Naam van planning wordt al gebruikt"</string>
    <string name="zen_mode_add_rule" msgid="4217731747959400770">"Meer toevoegen"</string>
    <string name="zen_mode_add_event_rule" msgid="9179404395950854471">"Afsprakenplanning toevoegen"</string>
    <string name="zen_mode_add_time_rule" msgid="2621320450155364432">"Tijdsplanning toevoegen"</string>
    <string name="zen_mode_choose_rule_type" msgid="7656308563653982975">"Planningstype kiezen"</string>
    <string name="zen_mode_delete_rule_confirmation" msgid="6195069346439736688">"Regel <xliff:g id="RULE">%1$s</xliff:g> verwijderen?"</string>
    <string name="zen_mode_delete_rule_button" msgid="8328729110756882244">"Verwijderen"</string>
    <string name="zen_mode_app_set_behavior" msgid="4319517270279704677">"Deze instellingen kunnen nu niet worden gewijzigd. Een app (<xliff:g id="APP_NAME">%1$s</xliff:g>) heeft Niet storen automatisch aangezet met aangepast gedrag."</string>
    <string name="zen_mode_unknown_app_set_behavior" msgid="8544413884273894104">"Deze instellingen kunnen nu niet worden gewijzigd. Een app heeft Niet storen automatisch aangezet met aangepast gedrag."</string>
    <string name="zen_mode_qs_set_behavior" msgid="3805244555649172848">"Deze instellingen kunnen nu niet worden gewijzigd. Niet storen is handmatig aangezet met aangepast gedrag."</string>
    <string name="zen_schedule_rule_type_name" msgid="8071428540221112090">"Tijd"</string>
    <string name="zen_event_rule_type_name" msgid="1921166617081971754">"Afspraken"</string>
    <string name="zen_mode_event_rule_calendar" msgid="6279460374929508907">"Tijdens afspraken voor"</string>
    <string name="zen_mode_event_rule_calendar_any" msgid="5152139705998281205">"Elke agenda"</string>
    <string name="zen_mode_event_rule_reply" msgid="6099405414361340225">"Bij antwoord:"</string>
    <string name="zen_mode_event_rule_reply_any_except_no" msgid="4672746760505346596">"Ja, Misschien of Niet gereageerd"</string>
    <string name="zen_mode_event_rule_reply_yes_or_maybe" msgid="6584448788100186574">"Ja of Misschien"</string>
    <string name="zen_mode_event_rule_reply_yes" msgid="7812120982734551236">"Ja"</string>
    <string name="zen_mode_rule_not_found_text" msgid="5303667326973891036">"Regel niet gevonden."</string>
    <string name="zen_mode_rule_summary_enabled_combination" msgid="1183604368083885789">"Aan: <xliff:g id="MODE">%1$s</xliff:g>"</string>
    <string name="zen_mode_rule_summary_provider_combination" msgid="785343032708491365">"<xliff:g id="PACKAGE">%1$s</xliff:g>\n<xliff:g id="SUMMARY">%2$s</xliff:g>"</string>
    <string name="zen_mode_schedule_rule_days" msgid="8633770815307716351">"Dagen"</string>
    <string name="zen_mode_schedule_rule_days_none" msgid="5636604196262227070">"Geen"</string>
    <string name="zen_mode_schedule_alarm_title" msgid="305237266064819345">"Wekker kan eindtijd negeren"</string>
    <string name="zen_mode_schedule_alarm_summary" msgid="9162760856136645133">"De planning wordt uitgezet als een wekker afgaat"</string>
    <string name="zen_mode_custom_behavior_title" msgid="92525364576358085">"Gedrag van Niet storen"</string>
    <string name="zen_mode_custom_behavior_summary_default" msgid="3259312823717839148">"Gebruik standaardinstellingen"</string>
    <string name="zen_mode_custom_behavior_summary" msgid="5390522750884328843">"Instellingen voor deze planning aanpassen"</string>
    <string name="zen_mode_custom_behavior_category_title" msgid="7815612569425733764">"Voor <xliff:g id="SCHEDULE_NAME">%1$s</xliff:g>"</string>
    <string name="summary_divider_text" msgid="8836285171484563986">", "</string>
    <string name="summary_range_symbol_combination" msgid="8447490077794415525">"<xliff:g id="START">%1$s</xliff:g> - <xliff:g id="END">%2$s</xliff:g>"</string>
    <string name="zen_mode_conversations_title" msgid="5491912973456026379">"Gesprekken"</string>
    <string name="zen_mode_from_all_conversations" msgid="3447000451361857061">"Alle gesprekken"</string>
    <string name="zen_mode_from_important_conversations" msgid="528050873364229253">"Prioriteitsgesprekken"</string>
    <string name="zen_mode_from_important_conversations_second" msgid="7588299891972136599">"prioriteitsgesprekken"</string>
    <string name="zen_mode_from_no_conversations" msgid="3924593219855567165">"Geen"</string>
    <string name="zen_mode_conversations_count" msgid="3199310723073707153">"{count,plural, =0{Geen}=1{1 gesprek}other{# gesprekken}}"</string>
    <string name="zen_mode_people_calls_messages_section_title" msgid="6815202112413762206">"Wie mag onderbreken"</string>
    <string name="zen_mode_people_footer" msgid="7710707353004137431">"Zelfs als berichten- of bel-apps je niet op de hoogte kunnen stellen, kunnen mensen die je hier kiest je nog steeds bereiken via die apps"</string>
    <string name="zen_mode_calls_title" msgid="2078578043677037740">"Oproepen"</string>
    <string name="zen_mode_calls" msgid="7653245854493631095">"Oproepen"</string>
    <string name="zen_mode_calls_list" msgid="5044730950895749093">"gesprekken"</string>
    <string name="zen_mode_calls_header" msgid="8379225445095856726">"Oproepen die mogen onderbreken"</string>
    <string name="zen_mode_calls_footer" msgid="2008079711083701243">"Zorg dat je apparaat niet in de stille modus staat, zodat je zeker weet dat het hoorbaar overgaat bij toegestane gesprekken"</string>
    <string name="zen_mode_custom_calls_footer" msgid="6521283204577441053">"Voor <xliff:g id="SCHEDULE_NAME">%1$s</xliff:g> worden inkomende gesprekken geblokkeerd. Je kunt de instellingen aanpassen zodat je vrienden, gezinsleden of andere contacten je kunnen bereiken."</string>
    <string name="zen_mode_starred_contacts_title" msgid="630299631659575589">"Contacten met ster"</string>
    <string name="zen_mode_starred_contacts_summary_contacts" msgid="1629467178444895094">"{count,plural,offset:2 =0{Geen}=1{{contact_1}}=2{{contact_1} en {contact_2}}=3{{contact_1}, {contact_2} en {contact_3}}other{{contact_1}, {contact_2} en nog # anderen}}"</string>
    <string name="zen_mode_starred_contacts_empty_name" msgid="2906404745550293688">"(Geen naam)"</string>
    <string name="zen_mode_messages" msgid="7315084748885170585">"Berichten"</string>
    <string name="zen_mode_messages_list" msgid="5431014101342361882">"berichten"</string>
    <string name="zen_mode_messages_title" msgid="1777598523485334405">"Berichten"</string>
    <string name="zen_mode_messages_header" msgid="253721635061451577">"Berichten die mogen onderbreken"</string>
    <string name="zen_mode_messages_footer" msgid="6002468050854126331">"Zorg dat je apparaat niet in de stille modus staat, zodat je zeker weet dat je een geluidsmelding krijgt bij toegestane berichten"</string>
    <string name="zen_mode_custom_messages_footer" msgid="7545180036949550830">"Voor \'<xliff:g id="SCHEDULE_NAME">%1$s</xliff:g>\' worden inkomende berichten geblokkeerd. Je kunt de instellingen aanpassen zodat je vrienden, gezinsleden of andere contacten je kunnen bereiken."</string>
    <string name="zen_mode_all_messages_summary" msgid="3756267858343104554">"Je ontvangt alle berichten"</string>
    <string name="zen_mode_all_calls_summary" msgid="7337907849083824698">"Je ontvangt alle oproepen"</string>
    <string name="zen_mode_contacts_count" msgid="6568631261119795799">"{count,plural, =0{Geen}=1{1 contact}other{# contacten}}"</string>
    <string name="zen_mode_from_anyone" msgid="6027004263046694174">"Iedereen"</string>
    <string name="zen_mode_from_contacts" msgid="2989933306317064818">"Contacten"</string>
    <string name="zen_mode_from_starred" msgid="8616516644241652287">"Contacten met ster"</string>
    <string name="zen_mode_none_calls" msgid="2047166006414016327">"Geen"</string>
    <string name="zen_mode_none_messages" msgid="1386626352943268342">"Geen"</string>
    <string name="zen_mode_alarms" msgid="5989343060100771099">"Wekkers"</string>
    <string name="zen_mode_alarms_summary" msgid="3388679177457223967">"Van timers, wekkers, beveiligingssystemen en andere apps"</string>
    <string name="zen_mode_alarms_list" msgid="334782233067365405">"wekkers"</string>
    <string name="zen_mode_alarms_list_first" msgid="2780418316613576610">"Wekkers"</string>
    <string name="zen_mode_media" msgid="885017672250984735">"Mediageluiden"</string>
    <string name="zen_mode_media_summary" msgid="7174081803853351461">"Geluiden van video\'s, games en andere media"</string>
    <string name="zen_mode_media_list" msgid="2006413476596092020">"media"</string>
    <string name="zen_mode_media_list_first" msgid="7824427062528618442">"Media"</string>
    <string name="zen_mode_system" msgid="7301665021634204942">"Aanraakgeluiden"</string>
    <string name="zen_mode_system_summary" msgid="7225581762792177522">"Geluiden van je toetsenbord en andere knoppen"</string>
    <string name="zen_mode_system_list" msgid="2256218792042306434">"aanraakgeluiden"</string>
    <string name="zen_mode_system_list_first" msgid="8590078626001067855">"Aanraakgeluiden"</string>
    <string name="zen_mode_reminders" msgid="1970224691551417906">"Herinneringen"</string>
    <string name="zen_mode_reminders_summary" msgid="3961627037429412382">"Van taken en herinneringen"</string>
    <string name="zen_mode_reminders_list" msgid="3133513621980999858">"herinneringen"</string>
    <string name="zen_mode_reminders_list_first" msgid="1130470396012190814">"Herinneringen"</string>
    <string name="zen_mode_events" msgid="7425795679353531794">"Agenda-afspraken"</string>
    <string name="zen_mode_events_summary" msgid="3241903481309766428">"Van aankomende agenda-afspraken"</string>
    <string name="zen_mode_events_list" msgid="7191316245742097229">"afspraken"</string>
    <string name="zen_mode_events_list_first" msgid="7425369082835214361">"Afspraken"</string>
    <string name="zen_mode_bypassing_apps" msgid="625309443389126481">"Apps toestaan dit te negeren"</string>
    <string name="zen_mode_bypassing_apps_header" msgid="60083006963906906">"Apps die mogen onderbreken"</string>
    <string name="zen_mode_bypassing_apps_add_header" msgid="3201829605075172536">"Meer apps selecteren"</string>
    <string name="zen_mode_bypassing_apps_none" msgid="7944221631721778096">"Geen apps geselecteerd"</string>
    <string name="zen_mode_bypassing_apps_subtext_none" msgid="5128770411598722200">"Geen apps mogen onderbreken"</string>
    <string name="zen_mode_bypassing_apps_add" msgid="5031919618521327102">"Apps toevoegen"</string>
    <string name="zen_mode_bypassing_apps_summary_all" msgid="4684544706511555744">"Alle meldingen"</string>
    <string name="zen_mode_bypassing_apps_summary_some" msgid="5315750826830358230">"Bepaalde meldingen"</string>
    <string name="zen_mode_bypassing_apps_footer" msgid="1454862989340760124">"Geselecteerde mensen kunnen je nog steeds bereiken, ook als je niet toestaat dat apps je onderbreken"</string>
    <string name="zen_mode_bypassing_apps_subtext" msgid="5258652366929842710">"{count,plural,offset:2 =0{Geen apps mogen onderbreken}=1{{app_1} mag onderbreken}=2{{app_1} en {app_2} mogen onderbreken}=3{{app_1}, {app_2} en {app_3} mogen onderbreken}other{{app_1}, {app_2} en nog # mogen onderbreken}}"</string>
    <string name="zen_mode_bypassing_apps_title" msgid="371050263563164059">"Apps"</string>
    <string name="zen_mode_bypassing_app_channels_header" msgid="4011017798712587373">"Meldingen die mogen onderbreken"</string>
    <string name="zen_mode_bypassing_app_channels_toggle_all" msgid="1449462656358219116">"Alle meldingen toestaan"</string>
    <string name="zen_mode_other_sounds_summary" msgid="8784400697494837032">"{count,plural,offset:2 =0{Niets mag onderbreken}=1{{sound_category_1} mag onderbreken}=2{{sound_category_1} en {sound_category_2} mogen onderbreken}=3{{sound_category_1}, {sound_category_2} en {sound_category_3} mogen onderbreken}other{{sound_category_1}, {sound_category_2} en nog # mogen onderbreken}}"</string>
    <string name="zen_mode_sounds_none" msgid="6557474361948269420">"Niets mag onderbreken"</string>
    <string name="zen_mode_people_none" msgid="4613147461974255046">"Niemand mag onderbreken"</string>
    <string name="zen_mode_people_some" msgid="9101872681298810281">"Bepaalde mensen mogen onderbreken"</string>
    <string name="zen_mode_people_all" msgid="311036110283015205">"Alle mensen mogen onderbreken"</string>
    <string name="zen_mode_repeat_callers" msgid="2270356100287792138">"Terugkerende bellers"</string>
    <string name="zen_mode_repeat_callers_title" msgid="8016699240338264781">"Terugkerende bellers toestaan"</string>
    <string name="zen_mode_all_callers" msgid="8104755389401941875">"iedereen"</string>
    <string name="zen_mode_contacts_callers" msgid="5429267704011896833">"contacten"</string>
    <string name="zen_mode_starred_callers" msgid="1002370699564211178">"contacten met ster"</string>
    <string name="zen_mode_repeat_callers_list" msgid="181819778783743847">"terugkerende bellers"</string>
    <!-- no translation found for zen_mode_calls_summary_one (1928015516061784276) -->
    <skip />
    <string name="zen_mode_calls_summary_two" msgid="6351563496898410742">"<xliff:g id="CALLER_TYPE_0">%1$s</xliff:g> en <xliff:g id="CALLER_TYPE_1">%2$s</xliff:g>"</string>
    <string name="zen_mode_repeat_callers_summary" msgid="4121054819936083025">"Als dezelfde persoon binnen <xliff:g id="MINUTES">%d</xliff:g> minuten een 2e keer belt"</string>
    <string name="zen_mode_start_time" msgid="1252665038977523332">"Starttijd"</string>
    <string name="zen_mode_end_time" msgid="223502560367331706">"Eindtijd"</string>
    <string name="zen_mode_end_time_next_day_summary_format" msgid="419683704068360804">"<xliff:g id="FORMATTED_TIME">%s</xliff:g> de volgende dag"</string>
    <string name="zen_mode_summary_alarms_only_indefinite" msgid="910047326128154945">"Wijzigen in \'Alleen wekkers\' voor onbepaalde tijd"</string>
    <string name="zen_mode_summary_alarms_only_by_minute" msgid="6673649005494939311">"{count,plural, =1{Wijzigen in alleen alarmen gedurende 1 minuut tot {time}}other{Wijzigen in alleen alarmen gedurende # minuten tot {time}}}"</string>
    <string name="zen_mode_summary_alarms_only_by_hour" msgid="7400910210950788163">"{count,plural, =1{Wijzigen in alleen alarmen gedurende 1 uur tot {time}}other{Wijzigen in alleen alarmen gedurende # uur tot {time}}}"</string>
    <string name="zen_mode_summary_alarms_only_by_time" msgid="8140619669703968810">"Wijzigen in \'Alleen wekkers\' tot <xliff:g id="FORMATTEDTIME">%1$s</xliff:g>"</string>
    <string name="zen_mode_summary_always" msgid="722093064250082317">"Wijzigen in \'Altijd onderbreken\'"</string>
    <string name="warning_button_text" msgid="1274234338874005639">"Waarschuwing"</string>
    <string name="suggestion_button_close" msgid="6865170855573283759">"Sluiten"</string>
    <string name="device_feedback" msgid="5351614458411688608">"Feedback sturen over dit apparaat"</string>
    <string name="restr_pin_enter_admin_pin" msgid="4435410646541671918">"Beheerderspincode invoeren"</string>
    <string name="switch_on_text" msgid="5664542327776075105">"Aan"</string>
    <string name="switch_off_text" msgid="1315547447393646667">"Uit"</string>
    <string name="nfc_setting_on" msgid="7701896496026725772">"Aan"</string>
    <string name="nfc_setting_off" msgid="7142103438532732309">"Uit"</string>
    <string name="screen_pinning_switch_on_text" msgid="6971386830247542552">"Aan"</string>
    <string name="screen_pinning_switch_off_text" msgid="5032105155623003875">"Uit"</string>
    <string name="screen_pinning_title" msgid="6927227272780208966">"App vastzetten"</string>
    <string name="app_pinning_intro" msgid="6409063008733004245">"Als je een app vastzet, kun je de huidige app in beeld houden totdat je deze losmaakt. Je kunt deze functie bijvoorbeeld gebruiken om een vriend die je vertrouwt, een specifieke game te laten spelen."</string>
    <string name="screen_pinning_description" msgid="4305370471370474846">"Als je een app hebt vastgezet, kan de vastgezette app mogelijk andere apps openen en zijn er misschien persoonsgegevens toegankelijk. \n\nZo zet je een app vast: 	\n1. Zet App vastzetten aan. 	\n2. Open Overzicht. 	\n3. Tik bovenaan het scherm op het app-icoon en daarna op Vastzetten."</string>
    <string name="screen_pinning_guest_user_description" msgid="2465729370037556955">"Als je een app hebt vastgezet, kan de vastgezette app mogelijk andere apps openen en zijn er misschien persoonsgegevens toegankelijk. \n\nAls je je apparaat beveiligd met iemand wilt delen, probeer je een gastgebruiker. \n\nZo zet je een app vast: 	\n1. Zet App vastzetten aan. 	\n2. Open Overzicht. 	\n3. Tik bovenaan het scherm op het app-icoon en daarna op Vastzetten."</string>
    <string name="screen_pinning_dialog_message" msgid="8144925258679476654">"Als een app is vastgezet: \n\n•	 Persoonsgegevens kunnen toegankelijk zijn (zoals contacten en e-mails).\n \n•	 De vastgezette app kan mogelijk andere apps openen. \n\nGebruik deze functie alleen met mensen die je vertrouwt."</string>
    <string name="screen_pinning_unlock_pattern" msgid="1345877794180829153">"Vraag om ontgrendelingspatroon voor losmaken"</string>
    <string name="screen_pinning_unlock_pin" msgid="8716638956097417023">"Vraag pin voor losmaken"</string>
    <string name="screen_pinning_unlock_password" msgid="4957969621904790573">"Vraag wachtwoord voor losmaken"</string>
    <string name="screen_pinning_unlock_none" msgid="2474959642431856316">"Apparaat vergrendelen wanneer items worden losgemaakt"</string>
    <string name="confirm_sim_deletion_title" msgid="9199369003530237871">"Verwijdering van simkaart bevestigen"</string>
    <string name="confirm_sim_deletion_description" msgid="4439657901673639063">"Bevestigen dat jij het bent voordat een e-simkaart wordt gewist"</string>
    <string name="memtag_title" msgid="5096176296797727201">"Geavanceerde geheugenbescherming (bèta)"</string>
    <string name="memtag_toggle" msgid="8695028758462939212">"Geavanceerde geheugenbescherming"</string>
    <string name="memtag_intro" msgid="579408691329568953">"Met deze bètafunctie kun je je apparaat beschermen tegen bugs die de beveiliging kunnen aantasten."</string>
    <string name="memtag_on" msgid="824938319141503923">"Aan"</string>
    <string name="memtag_off" msgid="4835589640091709019">"Uit"</string>
    <string name="memtag_on_pending" msgid="1592053425431532361">"Gaat aan na opnieuw opstarten"</string>
    <string name="memtag_off_pending" msgid="1543177181383593726">"Gaat uit na opnieuw opstarten"</string>
    <string name="memtag_force_off" msgid="1143468955988138470">"Nu niet beschikbaar voor je apparaat"</string>
    <string name="memtag_force_on" msgid="3254349938627883664">"Altijd aan voor je apparaat"</string>
    <string name="memtag_footer" msgid="8480784485124271376">"Start je apparaat opnieuw op om Geavanceerde geheugenbescherming aan of uit te zetten. Als de functie aanstaat, werkt het apparaat misschien trager."</string>
    <string name="memtag_reboot_title" msgid="1413471876903578769">"Apparaat opnieuw opstarten?"</string>
    <string name="memtag_reboot_message_on" msgid="3270256606602439418">"Start je apparaat opnieuw op om Geavanceerde geheugenbescherming aan te zetten."</string>
    <string name="memtag_reboot_message_off" msgid="2567062468140476451">"Start je apparaat opnieuw op om Geavanceerde geheugenbescherming uit te zetten."</string>
    <string name="memtag_reboot_yes" msgid="5788896350697141429">"Opnieuw opstarten"</string>
    <string name="memtag_reboot_no" msgid="2860671356184849330">"Niet nu"</string>
    <string name="memtag_learn_more" msgid="1596145970669119776">"Bekijk meer informatie over Geavanceerde geheugenbescherming."</string>
    <string name="opening_paragraph_delete_profile_unknown_company" msgid="2951348192319498135">"Dit werkprofiel wordt beheerd door:"</string>
    <string name="managing_admin" msgid="2633920317425356619">"Beheerd door <xliff:g id="ADMIN_APP_LABEL">%s</xliff:g>"</string>
    <string name="launch_by_default" msgid="892824422067985734">"Standaard openen"</string>
    <string name="app_launch_open_domain_urls_title" msgid="4805388403977096285">"Ondersteunde links openen"</string>
    <string name="app_launch_top_intro_message" msgid="137370923637482459">"Sta toe dat weblinks in deze app worden geopend"</string>
    <string name="app_launch_links_category" msgid="2380467163878760037">"Links om te openen in deze app"</string>
    <string name="app_launch_supported_domain_urls_title" msgid="5088779668667217369">"Ondersteunde links"</string>
    <string name="app_launch_other_defaults_title" msgid="5674385877838735586">"Andere standaardvoorkeuren"</string>
    <string name="app_launch_add_link" msgid="8622558044530305811">"Link toevoegen"</string>
    <string name="app_launch_footer" msgid="4521865035105622557">"Een app kan links verifiëren om ze automatisch te openen in de app."</string>
    <string name="app_launch_verified_links_title" msgid="621908751569155356">"{count,plural, =1{# geverifieerde link}other{# geverifieerde links}}"</string>
    <string name="app_launch_verified_links_message" msgid="190871133877476176">"{count,plural, =1{Deze link is geverifieerd en wordt automatisch geopend in deze app.}other{Deze links zijn geverifieerd en worden automatisch geopend in deze app.}}"</string>
    <string name="app_launch_dialog_ok" msgid="1446157681861409861">"OK"</string>
    <string name="app_launch_verified_links_info_description" msgid="7514750232467132117">"Lijst met geverifieerde links bekijken"</string>
    <string name="app_launch_checking_links_title" msgid="6119228853554114201">"Controleren op andere ondersteunde links…"</string>
    <string name="app_launch_dialog_cancel" msgid="6961071841814898663">"Annuleren"</string>
    <string name="app_launch_supported_links_title" msgid="2457931321701095763">"{count,plural, =1{# ondersteunde link}other{# ondersteunde links}}"</string>
    <string name="app_launch_supported_links_add" msgid="3271247750388016131">"Toevoegen"</string>
    <string name="app_launch_supported_links_subtext" msgid="4268004019469184113">"Wordt geopend in <xliff:g id="APP_LABEL">%s</xliff:g>"</string>
    <string name="storage_summary_format" msgid="5721782272185284276">"<xliff:g id="SIZE">%1$s</xliff:g> gebruikt in <xliff:g id="STORAGE_TYPE">%2$s</xliff:g>"</string>
    <string name="storage_type_internal" msgid="979243131665635278">"interne opslag"</string>
    <string name="storage_type_external" msgid="125078274000280821">"externe opslag"</string>
    <string name="data_summary_format" msgid="8802057788950096650">"<xliff:g id="SIZE">%1$s</xliff:g> gebr. sinds <xliff:g id="DATE">%2$s</xliff:g>"</string>
    <string name="storage_used" msgid="2591194906751432725">"Gebruikte opslag"</string>
    <string name="change" msgid="273206077375322595">"Wijzigen"</string>
    <string name="change_storage" msgid="8773820275624113401">"Opslag wijzigen"</string>
    <string name="notifications_label" msgid="8471624476040164538">"Meldingen"</string>
    <string name="notifications_enabled" msgid="7743168481579361019">"Aan"</string>
    <string name="notifications_enabled_with_info" msgid="1808946629277684308">"<xliff:g id="NOTIFICATIONS_SENT">%1$s</xliff:g>/<xliff:g id="NOTIFICATIONS_CATEGORIES_OFF">%2$s</xliff:g>"</string>
    <string name="notifications_disabled" msgid="5603160425378437143">"Uit"</string>
    <string name="notifications_categories_off" msgid="7712037485557237328">"{count,plural, =1{# categorie uitgezet}other{# categorieën uitgezet}}"</string>
    <string name="runtime_permissions_additional_count" msgid="6071909675951786523">"{count,plural, =1{# aanvullend recht}other{# aanvullende rechten}}"</string>
    <string name="runtime_permissions_summary_no_permissions_granted" msgid="7456745929035665029">"Geen rechten verleend"</string>
    <string name="runtime_permissions_summary_no_permissions_requested" msgid="7174876170116073356">"Geen rechten aangevraagd"</string>
    <string name="runtime_permissions_summary_control_app_access" msgid="3744591396348990500">"Beheer de toegang van apps tot je gegevens"</string>
    <string name="permissions_usage_title" msgid="2942741460679049132">"Privacydashboard"</string>
    <string name="permissions_usage_summary" msgid="6784310472062516454">"Toon welke apps onlangs rechten hebben gebruikt"</string>
    <string name="unused_apps" msgid="4566272194756830656">"Niet-gebruikte apps"</string>
    <string name="unused_apps_summary" msgid="4236371818881973021">"{count,plural, =1{# niet-gebruikte app}other{# niet-gebruikte apps}}"</string>
    <string name="unused_apps_category" msgid="8954930958175500851">"Niet-gebruikte app-instellingen"</string>
    <string name="unused_apps_switch" msgid="7595419855882245772">"Onderbreken indien niet gebruikt"</string>
    <string name="unused_apps_switch_summary" msgid="2171098908014596802">"Verwijder rechten en tijdelijke bestanden, en stop meldingen"</string>
    <string name="filter_all_apps" msgid="6645539744080251371">"Alle apps"</string>
    <string name="filter_enabled_apps" msgid="8868356616126759124">"Geïnstalleerde apps"</string>
    <string name="filter_instant_apps" msgid="2292108467020380068">"Instant-apps"</string>
    <string name="filter_notif_blocked_apps" msgid="1065653868850012325">"Uitgezet"</string>
    <string name="advanced_apps" msgid="7643010673326578815">"Geavanceerd"</string>
    <string name="app_permissions" msgid="8666537659217653626">"Rechten­beheer"</string>
    <string name="app_data_sharing_updates_title" msgid="1694297952320402788">"Updates voor het delen van locatiegegevens"</string>
    <string name="app_data_sharing_updates_summary" msgid="4465929918457739443">"Check apps die de manier veranderen waarop je locatiegegevens worden gedeeld"</string>
    <string name="tap_to_wake" msgid="3313433536261440068">"Tikken om te activeren"</string>
    <string name="tap_to_wake_summary" msgid="6641039858241611072">"Dubbeltikken op het scherm om het apparaat te activeren"</string>
    <string name="domain_urls_title" msgid="7012209752049678876">"Links openen"</string>
    <string name="domain_urls_summary_none" msgid="1132578967643384733">"Ondersteunde links niet openen"</string>
    <string name="domain_urls_summary_one" msgid="3312008753802762892">"<xliff:g id="DOMAIN">%s</xliff:g> openen"</string>
    <string name="domain_urls_summary_some" msgid="1197692164421314523">"<xliff:g id="DOMAIN">%s</xliff:g> en andere URL\'s openen"</string>
    <string name="app_link_open_always" msgid="9167065494930657503">"Sta toe dat app ondersteunde links opent"</string>
    <string name="app_link_open_ask" msgid="2422450109908936371">"Elke keer vragen"</string>
    <string name="app_link_open_never" msgid="5299808605386052350">"Niet toestaan dat app links opent"</string>
    <string name="app_link_open_always_summary" msgid="4524005594295855117">"{count,plural, =1{App claimt # link te verwerken}other{App claimt # links te verwerken}}"</string>
    <string name="open_supported_links_footer" msgid="3188808142432787933">"App claimt de volgende links te verwerken:"</string>
    <string name="assist_and_voice_input_title" msgid="6317935163145135914">"Assistentie en spraakinvoer"</string>
    <string name="default_assist_title" msgid="1182435129627493758">"Digitale-assistent-app"</string>
    <string name="default_digital_assistant_title" msgid="5654663086385490838">"Standaard digitale-assistent-app"</string>
    <string name="assistant_security_warning_agree" msgid="9013334158753473359">"Akkoord"</string>
    <string name="default_browser_title" msgid="8342074390782390458">"Browser-app"</string>
    <string name="default_phone_title" msgid="7616730756650803827">"Telefoon-app"</string>
    <string name="system_app" msgid="1863291702508355041">"(Systeem)"</string>
    <string name="apps_storage" msgid="643866814746927111">"App-opslag"</string>
    <string name="usage_access" msgid="5487993885373893282">"Gebruikstoegang"</string>
    <string name="permit_usage_access" msgid="179630895262172674">"Gebruikstoegang toestaan"</string>
    <string name="time_spent_in_app_pref_title" msgid="25327097913383330">"Schermtijd"</string>
    <string name="usage_access_description" msgid="8547716253713890707">"Met gebruikstoegang kan een app bijhouden welke andere apps je gebruikt (en hoe vaak), welke provider je hebt, je taalinstellingen en andere details."</string>
    <string name="memory_settings_title" msgid="6582588646363308430">"Geheugen"</string>
    <string name="always_running" msgid="9012705720688200252">"Altijd actief (<xliff:g id="PERCENTAGE">%s</xliff:g>)"</string>
    <string name="sometimes_running" msgid="7954947311082655448">"Soms actief (<xliff:g id="PERCENTAGE">%s</xliff:g>)"</string>
    <string name="rarely_running" msgid="2704869567353196798">"Zelden actief (<xliff:g id="PERCENTAGE">%s</xliff:g>)"</string>
    <string name="memory_use_running_format" msgid="4376086847362492613">"<xliff:g id="MEMORY">%1$s</xliff:g>/<xliff:g id="RUNNING">%2$s</xliff:g>"</string>
    <string name="high_power_apps" msgid="5623152700992102510">"Batterijoptimalisatie"</string>
    <string name="high_power_filter_on" msgid="447849271630431531">"Niet geoptimaliseerd"</string>
    <string name="high_power_on" msgid="8778058701270819268">"Niet geoptimaliseerd"</string>
    <string name="high_power_off" msgid="317000444619279018">"Batterijverbruik optimaliseren"</string>
    <string name="high_power_system" msgid="3966701453644915787">"Batterijoptimalisatie niet beschikbaar"</string>
    <string name="high_power_prompt_title" msgid="2574478825228409124">"App altijd uitvoeren op de achtergrond?"</string>
    <string name="high_power_prompt_body" msgid="6029266540782139941">"Als je toestaat dat <xliff:g id="APP_NAME">%1$s</xliff:g> altijd op de achtergrond wordt uitgevoerd, kan de batterij sneller leeg raken. \n\nJe kunt dit later wijzigen via Instellingen &gt; Apps."</string>
    <string name="battery_summary" msgid="2491764359695671207">"<xliff:g id="PERCENTAGE">%1$s</xliff:g> gebruik sinds laatste volledige lading"</string>
    <string name="battery_summary_24hr" msgid="7656033283282656551">"<xliff:g id="PERCENTAGE">%1$s</xliff:g> gebruik in de afgelopen 24 uur"</string>
    <string name="no_battery_summary" msgid="5769159953384122003">"Geen accugebruik sinds laatste volledige lading"</string>
    <string name="share_remote_bugreport_dialog_title" msgid="1575283098565582433">"Bugrapport delen?"</string>
    <string name="share_remote_bugreport_dialog_message_finished" msgid="4869053468609007680">"Je IT-beheerder heeft een bugrapport aangevraagd om problemen met dit apparaat op te lossen. Apps en gegevens kunnen worden gedeeld."</string>
    <string name="share_remote_bugreport_dialog_message" msgid="8714439220818865391">"Je IT-beheerder heeft een bugrapport aangevraagd om problemen met dit apparaat op te lossen. Apps en gegevens kunnen worden gedeeld en je apparaat kan hierdoor tijdelijk worden vertraagd."</string>
    <string name="sharing_remote_bugreport_dialog_message" msgid="3523877008096439251">"Dit bugrapport wordt gedeeld met je IT-beheerder. Neem contact met deze persoon op voor meer informatie."</string>
    <string name="share_remote_bugreport_action" msgid="7173093464692893276">"Delen"</string>
    <string name="decline_remote_bugreport_action" msgid="1276509879613158895">"Weigeren"</string>
    <string name="usb_use_charging_only" msgid="1743303747327057947">"Geen gegevensoverdracht"</string>
    <string name="usb_use_power_only" msgid="3408055485802114621">"Verbonden apparaat opladen"</string>
    <string name="usb_use_file_transfers" msgid="483915710802018503">"Bestandsoverdracht"</string>
    <string name="usb_use_photo_transfers" msgid="4641181628966036093">"PTP"</string>
    <string name="usb_use_uvc_webcam" msgid="6595429508472038732">"Webcam"</string>
    <string name="usb_transcode_files" msgid="2441954752105119109">"Video\'s converteren naar AVC"</string>
    <string name="usb_transcode_files_summary" msgid="307102635711961513">"Video\'s kunnen worden afgespeeld in meer mediaspelers, maar de kwaliteit kan afnemen"</string>
    <string name="usb_use_tethering" msgid="2897063414491670531">"USB-tethering"</string>
    <string name="usb_use_MIDI" msgid="8621338227628859789">"MIDI"</string>
    <string name="usb_use" msgid="6783183432648438528">"USB gebruiken voor"</string>
    <string name="usb_default_label" msgid="3372838450371060750">"Standaard USB-instellingen"</string>
    <string name="usb_default_info" msgid="167172599497085266">"Wanneer er een ander apparaat is verbonden en je telefoon is ontgrendeld, worden deze instellingen toegepast. Maak alleen verbinding met vertrouwde apparaten."</string>
    <string name="usb_power_title" msgid="5602112548385798646">"Voedingsopties"</string>
    <string name="usb_file_transfer_title" msgid="2261577861371481478">"Opties voor bestandsoverdracht"</string>
    <string name="usb_pref" msgid="8521832005703261700">"USB"</string>
    <string name="usb_preference" msgid="5084550082591493765">"USB-voorkeuren"</string>
    <string name="usb_control_title" msgid="1946791559052157693">"USB beheerd door"</string>
    <string name="usb_control_host" msgid="7404215921555021871">"Verbonden apparaat"</string>
    <string name="usb_control_device" msgid="527916783743021577">"Dit apparaat"</string>
    <string name="usb_switching" msgid="3654709188596609354">"Overschakelen…"</string>
    <string name="usb_switching_failed" msgid="5721262697715454137">"Kan niet schakelen"</string>
    <string name="usb_summary_charging_only" msgid="678095599403565146">"Dit apparaat wordt opgeladen"</string>
    <string name="usb_summary_power_only" msgid="4901734938857822887">"Verbonden apparaat wordt opgeladen"</string>
    <string name="usb_summary_file_transfers" msgid="5498487271972556431">"Bestandsoverdracht"</string>
    <string name="usb_summary_tether" msgid="2554569836525075702">"USB-tethering"</string>
    <string name="usb_summary_photo_transfers" msgid="7331503733435780492">"PTP"</string>
    <string name="usb_summary_MIDI" msgid="2372443732675899571">"MIDI"</string>
    <string name="usb_summary_UVC" msgid="8733131110899174299">"Webcam"</string>
    <string name="usb_summary_file_transfers_power" msgid="2788374660532868630">"Bestandsoverdracht en stroomtoevoer"</string>
    <string name="usb_summary_tether_power" msgid="4853034392919904792">"USB-tethering en stroomtoevoer"</string>
    <string name="usb_summary_photo_transfers_power" msgid="9077173567697482239">"PTP en stroomtoevoer"</string>
    <string name="usb_summary_MIDI_power" msgid="1184681982025435815">"MIDI en stroomtoevoer"</string>
    <string name="usb_summary_UVC_power" msgid="226810354412154061">"Webcam en stroomvoorziening"</string>
    <string name="background_check_pref" msgid="5304564658578987535">"Achtergrondcontrole"</string>
    <string name="assist_access_context_title" msgid="5201495523514096201">"Tekst van scherm gebruiken"</string>
    <string name="assist_access_context_summary" msgid="6951814413185646275">"Sta toe dat de assistentie-app toegang krijgt tot de scherminhoud als tekst"</string>
    <string name="assist_access_screenshot_title" msgid="4395902231753643633">"Screenshot gebruiken"</string>
    <string name="assist_access_screenshot_summary" msgid="5276593070956201863">"Sta toe dat de assistentie-app toegang krijgt tot een afbeelding van het scherm"</string>
    <string name="assist_flash_title" msgid="5449512572885550108">"Scherm laten knipperen"</string>
    <string name="assist_flash_summary" msgid="3032289860177784594">"Laat schermranden knipperen wanneer de assistentie-app toegang verkrijgt tot tekst op scherm of screenshot"</string>
    <string name="assist_footer" msgid="8248015363806299068">"Assistentie-apps kunnen je helpen op basis van de informatie op het scherm dat je bekijkt. Bepaalde apps ondersteunen launcher- en spraakinvoerservices voor geïntegreerde support."</string>
    <string name="average_memory_use" msgid="717313706368825388">"Gemiddeld geheugengebruik"</string>
    <string name="maximum_memory_use" msgid="2171779724001152933">"Maximaal geheugengebruik"</string>
    <string name="memory_usage" msgid="5594133403819880617">"Geheugengebruik"</string>
    <string name="app_list_memory_use" msgid="3178720339027577869">"Appgebruik"</string>
    <string name="memory_details" msgid="6133226869214421347">"Details"</string>
    <string name="memory_use_summary" msgid="3915964794146424142">"Gem. <xliff:g id="SIZE">%1$s</xliff:g> geheugen gebruikt in de afgelopen drie uur"</string>
    <string name="no_memory_use_summary" msgid="6708111974923274436">"Geen geheugen gebruikt in de afgelopen drie uur"</string>
    <string name="sort_avg_use" msgid="4416841047669186903">"Sorteren op gem. gebruik"</string>
    <string name="sort_max_use" msgid="3370552820889448484">"Sorteren op max. gebruik"</string>
    <string name="memory_performance" msgid="5448274293336927570">"Prestaties"</string>
    <string name="total_memory" msgid="5244174393008910567">"Totaal geheugen"</string>
    <string name="average_used" msgid="690235917394070169">"Gemiddeld gebruikt (%)"</string>
    <string name="free_memory" msgid="439783742246854785">"Vrij"</string>
    <string name="memory_usage_apps" msgid="5776108502569850579">"Geheugen gebruikt door apps"</string>
    <string name="memory_usage_apps_summary" msgid="7168292864155527974">"{count,plural, =1{1 app heeft geheugen gebruikt in de afgelopen {time}}other{# apps hebben geheugen gebruikt in de afgelopen {time}}}"</string>
    <string name="running_frequency" msgid="7260225121706316639">"Frequentie"</string>
    <string name="memory_maximum_usage" msgid="2047013391595835607">"Maximaal gebruik"</string>
    <string name="no_data_usage" msgid="4665617440434654132">"Geen data gebruikt"</string>
    <string name="zen_access_warning_dialog_title" msgid="6323325813123130154">"Toegang tot \'Niet storen\' toestaan voor <xliff:g id="APP">%1$s</xliff:g>?"</string>
    <string name="zen_access_warning_dialog_summary" msgid="8468714854067428987">"De app kan de functie Niet storen aan- of uitzetten en gerelateerde instellingen wijzigen."</string>
    <string name="zen_access_disabled_package_warning" msgid="6565908224294537889">"Moet aan blijven omdat toegang tot meldingen is gegeven"</string>
    <string name="zen_access_revoke_warning_dialog_title" msgid="7377261509261811449">"Toegang tot \'Niet storen\' intrekken voor <xliff:g id="APP">%1$s</xliff:g>?"</string>
    <string name="zen_access_revoke_warning_dialog_summary" msgid="8689801842914183595">"Alle \'Niet storen\'-regels die door deze app zijn gemaakt, worden verwijderd."</string>
    <string name="ignore_optimizations_on" msgid="6865583039303804932">"Niet optimaliseren"</string>
    <string name="ignore_optimizations_off" msgid="9186557038453586295">"Optimaliseren"</string>
    <string name="ignore_optimizations_on_desc" msgid="1280043916460939932">"Hierdoor kan de batterij sneller leegraken. Batterijverbruik op de achtergrond door de app wordt niet meer beperkt."</string>
    <string name="ignore_optimizations_off_desc" msgid="3324571675983286177">"Aanbevolen voor een langere accuduur"</string>
    <string name="app_list_preference_none" msgid="1635406344616653756">"Geen"</string>
    <string name="work_profile_usage_access_warning" msgid="3477719910927319122">"Als je deze app geen gebruikstoegang geeft, wordt niet voorkomen dat je beheerder datagebruik voor apps in je werkprofiel bijhoudt"</string>
    <string name="draw_overlay" msgid="7902083260500573027">"Weergeven vóór andere apps"</string>
    <string name="system_alert_window_settings" msgid="6458633954424862521">"Weergeven vóór andere apps"</string>
    <string name="permit_draw_overlay" msgid="4468994037192804075">"Weergeven vóór andere apps toestaan"</string>
    <string name="allow_overlay_description" msgid="1607235723669496298">"Sta toe dat deze app op de voorgrond wordt weergegeven vóór andere apps die je gebruikt. Deze app kan zien waar je tikt of wijzigen wat op het scherm wordt weergegeven."</string>
    <string name="manage_external_storage_title" msgid="8024521099838816100">"Toegang tot alle bestanden"</string>
    <string name="permit_manage_external_storage" msgid="6928847280689401761">"Toegang geven om alle bestanden te beheren"</string>
    <string name="allow_manage_external_storage_description" msgid="5707948153603253225">"Sta toe dat deze app alle bestanden op dit apparaat of gekoppelde opslagvolumes kan lezen, aanpassen of verwijderen. Als je dit toestaat, kan de app zonder jouw medeweten toegang tot bestanden krijgen."</string>
    <string name="filter_manage_external_storage" msgid="6751640571715343804">"Mag toegang tot alle bestanden hebben"</string>
    <string name="full_screen_intent_title" msgid="747270185715224130">"Meldingen op volledig scherm"</string>
    <string name="permit_full_screen_intent" msgid="9035367640019960861">"Meldingen op volledig scherm van deze app toestaan"</string>
    <string name="footer_description_full_screen_intent" msgid="7716518411349225528">"Toestaan dat deze app meldingen op het volledige scherm toont als het apparaat is vergrendeld. Apps kunnen zo alarmen, inkomende gesprekken of andere urgente meldingen onder de aandacht brengen."</string>
    <string name="media_management_apps_title" msgid="8222942355578724582">"Apps voor mediabeheer"</string>
    <string name="media_management_apps_toggle_label" msgid="166724270857067456">"App toestaan om media te beheren"</string>
    <string name="media_management_apps_description" msgid="8000565658455268524">"Als je dit toestaat, kan deze app ongevraagd mediabestanden bewerken of verwijderen die met andere apps zijn gemaakt. De app heeft toegangsrechten nodig voor bestanden en media."</string>
    <string name="keywords_media_management_apps" msgid="7499959607583088690">"Media, bestand, beheer, beheerder, beheren, bewerken, bewerker, app, applicatie, programma"</string>
    <string name="keywords_vr_listener" msgid="902737490270081131">"vr virtual reality listener stereo helperservice"</string>
    <string name="overlay_settings" msgid="2030836934139139469">"Weergeven vóór andere apps"</string>
    <string name="filter_overlay_apps" msgid="2483998217116789206">"Apps met rechten"</string>
    <string name="app_permission_summary_allowed" msgid="1155115629167757278">"Toegestaan"</string>
    <string name="app_permission_summary_not_allowed" msgid="2673793662439097900">"Niet toegestaan"</string>
    <string name="keywords_install_other_apps" msgid="563895867658775580">"apps installeren via onbekende bronnen"</string>
    <string name="write_settings" msgid="6864794401614425894">"Systeem­instellingen aanpassen"</string>
    <string name="keywords_write_settings" msgid="6908708078855507813">"schrijven aanpassen systeeminstellingen"</string>
    <string name="filter_install_sources_apps" msgid="6930762738519588431">"Kunnen andere apps installeren"</string>
    <string name="filter_write_settings_apps" msgid="4754994984909024093">"Kan systeeminstellingen aanpassen"</string>
    <string name="write_settings_title" msgid="3011034187823288557">"Kan systeeminstellingen aanpassen"</string>
    <string name="write_system_settings" msgid="5555707701419757421">"Systeem­instellingen aanpassen"</string>
    <string name="permit_write_settings" msgid="3113056800709924871">"Aanpassen van systeeminstellingen toestaan"</string>
    <string name="write_settings_description" msgid="1474881759793261146">"Met deze rechten kan een app de systeeminstellingen aanpassen."</string>
    <string name="external_source_switch_title" msgid="101571983954849473">"Toestaan van deze bron"</string>
    <string name="camera_gesture_title" msgid="5559439253128696180">"Twee keer draaien voor camera"</string>
    <string name="camera_gesture_desc" msgid="7557645057320805328">"Open de camera-app door je pols twee keer te draaien"</string>
    <string name="screen_zoom_title" msgid="6928045302654960559">"Weergavegrootte"</string>
    <string name="screen_zoom_short_summary" msgid="756254364808639194">"Maak alles groter of kleiner"</string>
    <string name="screen_zoom_keywords" msgid="5964023524422386592">"weergavedichtheid, scherm zoomen, schaal, schalen"</string>
    <string name="screen_zoom_preview_title" msgid="5288355628444562735">"Voorbeeld"</string>
    <string name="screen_zoom_make_smaller_desc" msgid="2628662648068995971">"Verkleinen"</string>
    <string name="screen_zoom_make_larger_desc" msgid="7268794713428853139">"Vergroten"</string>
    <string name="disconnected" msgid="3469373726996129247">"Niet verbonden"</string>
    <string name="keyboard_disconnected" msgid="796053864561894531">"Niet verbonden"</string>
    <string name="apps_summary" msgid="4007416751775414252">"<xliff:g id="COUNT">%1$d</xliff:g> apps geïnstalleerd"</string>
    <string name="storage_summary" msgid="5903562203143572768">"<xliff:g id="PERCENTAGE">%1$s</xliff:g> in gebruik, <xliff:g id="FREE_SPACE">%2$s</xliff:g> beschikbaar"</string>
    <string name="display_dashboard_summary" msgid="1599453894989339454">"Donker thema, lettergrootte, helderheid"</string>
    <string name="memory_summary" msgid="8221954450951651735">"Gem. <xliff:g id="USED_MEMORY">%1$s</xliff:g> van <xliff:g id="TOTAL_MEMORY">%2$s</xliff:g> geheugen gebruikt"</string>
    <string name="users_summary" msgid="8473589474976307510">"Ingelogd als <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="android_version_summary" msgid="7818952662015042768">"Geüpdatet naar Android <xliff:g id="VERSION">%1$s</xliff:g>"</string>
    <string name="android_version_pending_update_summary" msgid="5404532347171027730">"Update beschikbaar"</string>
    <string name="disabled_by_policy_title" msgid="6852347040813204503">"Geblokkeerd door werkbeleid"</string>
    <string name="disabled_by_policy_title_adjust_volume" msgid="1669689058213728099">"Kan het volume niet wijzigen"</string>
    <string name="disabled_by_policy_title_outgoing_calls" msgid="400089720689494562">"Kan niet bellen"</string>
    <string name="disabled_by_policy_title_sms" msgid="8951840850778406831">"Kan geen sms-berichten sturen"</string>
    <string name="disabled_by_policy_title_camera" msgid="6616508876399613773">"Kan de camera niet gebruiken"</string>
    <string name="disabled_by_policy_title_screen_capture" msgid="6085100101044105811">"Kan geen screenshots maken"</string>
    <string name="disabled_by_policy_title_suspend_packages" msgid="4223983156635729793">"Kan deze app niet openen"</string>
    <string name="disabled_by_policy_title_financed_device" msgid="2328740314082888228">"Geblokkeerd door je kredietverstrekker"</string>
    <string name="disabled_by_policy_title_biometric_parental_consent" msgid="2463673997797134678">"Ouder nodig"</string>
    <string name="disabled_by_policy_content_biometric_parental_consent" msgid="7124116806784305206">"Geef de telefoon aan je ouder om dit in te stellen"</string>
    <string name="disabled_by_policy_parental_consent" msgid="9166060049019018978">"Geef de telefoon aan je ouder zodat die deze instelling kan wijzigen."</string>
    <string name="default_admin_support_msg" msgid="8816296554831532033">"Neem voor meer informatie contact op met je IT-beheerder"</string>
    <string name="admin_support_more_info" msgid="8407433155725898290">"Meer informatie"</string>
    <string name="admin_profile_owner_message" msgid="8860709969532649195">"Je beheerder kan apps en gegevens bijhouden en beheren die aan je werkprofiel zijn gekoppeld (waaronder instellingen, rechten, zakelijke toegang, netwerkactiviteit en locatiegegevens van het apparaat)."</string>
    <string name="admin_profile_owner_user_message" msgid="4929926887231544950">"Je beheerder kan apps en gegevens bijhouden en beheren die aan deze gebruiker zijn gekoppeld (waaronder instellingen, rechten, zakelijke toegang, netwerkactiviteit en locatiegegevens van het apparaat)."</string>
    <string name="admin_device_owner_message" msgid="5503131744126520590">"Je beheerder kan apps en gegevens bijhouden en beheren die aan dit apparaat zijn gekoppeld (waaronder instellingen, rechten, zakelijke toegang, netwerkactiviteit en locatiegegevens van het apparaat)."</string>
    <string name="admin_financed_message" msgid="1156197630834947884">"Je apparaatbeheerder kan mogelijk toegang krijgen tot gegevens die aan dit apparaat zijn gekoppeld, apps beheren en de instellingen van dit apparaat wijzigen."</string>
    <string name="condition_turn_off" msgid="402707350778441939">"Uitzetten"</string>
    <string name="condition_turn_on" msgid="3911077299444314791">"Aanzetten"</string>
    <string name="condition_expand_show" msgid="1501084007540953213">"Tonen"</string>
    <string name="condition_expand_hide" msgid="8347564076209121058">"Verbergen"</string>
    <string name="condition_hotspot_title" msgid="7903918338790641071">"Hotspot is actief"</string>
    <string name="condition_airplane_title" msgid="5847967403687381705">"Vliegtuigmodus staat aan"</string>
    <string name="condition_airplane_summary" msgid="1964500689287879888">"Netwerken niet beschikbaar"</string>
    <string name="condition_zen_title" msgid="7674761111934567490">"Niet storen staat aan"</string>
    <string name="condition_zen_summary_phone_muted" msgid="6516753722927681820">"Telefoongeluid staat uit"</string>
    <string name="condition_zen_summary_with_exceptions" msgid="9019937492602199663">"Met uitzonderingen"</string>
    <string name="condition_battery_title" msgid="6395113995454385248">"Batterijbesparing aan"</string>
    <string name="condition_battery_summary" msgid="8436806157833107886">"Functies zijn beperkt"</string>
    <string name="condition_cellular_title" msgid="155474690792125747">"Mobiele data staan uit"</string>
    <string name="condition_cellular_summary" msgid="1678098728303268851">"Internet alleen beschikbaar via wifi"</string>
    <string name="condition_bg_data_title" msgid="2719263664589753094">"Databesparing"</string>
    <string name="condition_bg_data_summary" msgid="1736255283216193834">"Functies zijn beperkt"</string>
    <string name="condition_work_title" msgid="174326145616998813">"Werkprofiel staat uit"</string>
    <string name="condition_work_summary" msgid="7113473121312772398">"Voor apps en meldingen"</string>
    <string name="condition_device_muted_action_turn_on_sound" msgid="4078406807327674934">"Geluid aanzetten"</string>
    <string name="condition_device_muted_title" msgid="2446306263428466378">"Ringtone staat uit"</string>
    <string name="condition_device_muted_summary" msgid="3772178424510397327">"Voor gesprekken en meldingen"</string>
    <string name="condition_device_vibrate_title" msgid="9058943409545158583">"Alleen trillen"</string>
    <string name="condition_device_vibrate_summary" msgid="7537724181691903202">"Voor gesprekken en meldingen"</string>
    <string name="night_display_suggestion_title" msgid="5418911386429667704">"Planning van Nachtverlichting instellen"</string>
    <string name="night_display_suggestion_summary" msgid="4218017907425509769">"Scherm elke avond automatisch een tint geven"</string>
    <string name="condition_night_display_title" msgid="1072880897812554421">"Nachtverlichting staat aan"</string>
    <string name="condition_night_display_summary" msgid="3278349775875166984">"Scherm heeft een oranje tint"</string>
    <string name="condition_grayscale_title" msgid="9029271080007984542">"Grijstinten"</string>
    <string name="condition_grayscale_summary" msgid="1306034149271251292">"Alleen in grijstinten weergeven"</string>
    <string name="homepage_condition_footer_content_description" msgid="1568313430995646108">"Samenvouwen"</string>
    <string name="color_temperature" msgid="8256912135746305176">"Koele kleurtemperatuur"</string>
    <string name="color_temperature_desc" msgid="6713259535885669622">"Koelere weergavekleuren gebruiken"</string>
    <string name="color_temperature_toast" msgid="7611532183532407342">"Zet het scherm uit om de kleurwijziging toe te passen"</string>
    <string name="camera_laser_sensor_switch" msgid="7097842750947187671">"Cameralasersensor"</string>
    <string name="ota_disable_automatic_update" msgid="1953894421412420231">"Automatische systeemupdates"</string>
    <string name="ota_disable_automatic_update_summary" msgid="7803279951533276841">"Pas updates toe wanneer apparaat opnieuw wordt opgestart"</string>
    <string name="usage" msgid="287782903846013936">"Gebruik"</string>
    <string name="cellular_data_usage" msgid="5874156338825285334">"Gebruik van mobiele data"</string>
    <string name="app_cellular_data_usage" msgid="7603292978956033926">"Datagebruik van app"</string>
    <string name="wifi_data_usage" msgid="6868503699134605707">"Wifi-datagebruik"</string>
    <string name="non_carrier_data_usage" msgid="6494603202578414755">"Ander datagebruik dan van providers"</string>
    <string name="ethernet_data_usage" msgid="4552227880905679761">"Ethernetdatagebruik"</string>
    <string name="wifi" msgid="2932584495223243842">"Wifi"</string>
    <string name="ethernet" msgid="4665162609974492983">"Ethernet"</string>
    <string name="cell_data_template" msgid="6077963976103260821">"<xliff:g id="AMOUNT">^1</xliff:g> mobiele data"</string>
    <string name="wifi_data_template" msgid="935934798340307438">"<xliff:g id="AMOUNT">^1</xliff:g> wifi-data"</string>
    <string name="ethernet_data_template" msgid="1429173767445201145">"<xliff:g id="AMOUNT">^1</xliff:g> ethernetdata"</string>
    <string name="billing_cycle" msgid="6618424022653876279">"Datawaarschuwing en -limiet"</string>
    <string name="app_usage_cycle" msgid="341009528778520583">"Gebruikscyclus voor mobiele data"</string>
    <string name="cell_data_warning" msgid="5664921950473359634">"<xliff:g id="ID_1">^1</xliff:g> datawaarschuwing"</string>
    <string name="cell_data_limit" msgid="256855024790622112">"<xliff:g id="ID_1">^1</xliff:g> datalimiet"</string>
    <string name="cell_data_warning_and_limit" msgid="8393200831986035724">"<xliff:g id="ID_1">^1</xliff:g> datawaarschuwing/<xliff:g id="ID_2">^2</xliff:g> datalimiet"</string>
    <string name="operator_warning" msgid="5672761970087591211">"Het door de provider berekende dataverbruik kan afwijken van de berekening van het apparaat"</string>
    <string name="non_carrier_data_usage_warning" msgid="4707184871368847697">"Toont geen data die door providernetwerken worden gebruikt"</string>
    <string name="data_used_template" msgid="8229342096562327646">"<xliff:g id="ID_1">%1$s</xliff:g> gebruikt"</string>
    <string name="set_data_warning" msgid="1685771882794205462">"Datawaarschuwing instellen"</string>
    <string name="data_warning" msgid="2925054658166062884">"Datawaarschuwing"</string>
    <string name="data_warning_footnote" msgid="5991901765915710592">"Datawaarschuwing en datalimiet worden gemeten door je apparaat. De gegevens kunnen afwijken van de informatie van je provider."</string>
    <string name="set_data_limit" msgid="9010326815874642680">"Datalimiet instellen"</string>
    <string name="data_limit" msgid="8731731657513652363">"Datalimiet"</string>
    <string name="data_usage_template" msgid="3822452362629968010">"<xliff:g id="ID_1">%1$s</xliff:g> gebruikt in de periode <xliff:g id="ID_2">%2$s</xliff:g>"</string>
    <string name="configure" msgid="1499586749829665889">"Instellen"</string>
    <string name="data_usage_other_apps" msgid="5649047093607329537">"Andere apps opgenomen in gebruik"</string>
    <string name="data_saver_unrestricted_summary" msgid="7343571401172437542">"{count,plural, =1{1 app toegestaan om onbeperkt data te gebruiken als Databesparing aanstaat}other{# apps toegestaan om onbeperkt data te gebruiken als Databesparing aanstaat}}"</string>
    <string name="data_usage_title" msgid="4039024073687469094">"Primaire data"</string>
    <string name="data_usage_wifi_title" msgid="1060495519280456926">"Wifi-gegevens"</string>
    <string name="data_used_formatted" msgid="7913920278059077938">"<xliff:g id="ID_1">^1</xliff:g> <xliff:g id="ID_2">^2</xliff:g> gebruikt"</string>
    <string name="data_overusage" msgid="3680477320458707259">"Nog <xliff:g id="ID_1">^1</xliff:g>"</string>
    <string name="data_remaining" msgid="6316251496381922837">"Nog <xliff:g id="ID_1">^1</xliff:g>"</string>
    <string name="data_usage_chart_brief_content_description" msgid="5548074070258881530">"Diagram met datagebruik tussen <xliff:g id="START_DATE">%1$s</xliff:g> en <xliff:g id="END_DATE">%2$s</xliff:g>."</string>
    <string name="data_usage_chart_no_data_content_description" msgid="5481968839079467231">"Geen gegevens in deze periode"</string>
    <string name="billing_cycle_days_left" msgid="174337287346866400">"{count,plural, =1{Nog # dag}other{Nog # dagen}}"</string>
    <string name="billing_cycle_none_left" msgid="1694844019159277504">"Geen tijd resterend"</string>
    <string name="billing_cycle_less_than_one_day_left" msgid="1210202399053992163">"Nog minder dan 1 dag"</string>
    <string name="carrier_and_update_text" msgid="5363656651921656280">"<xliff:g id="ID_2">^2</xliff:g> geleden geüpdatet door <xliff:g id="ID_1">^1</xliff:g>"</string>
    <string name="no_carrier_update_text" msgid="5432798085593055966">"<xliff:g id="ID_1">^2</xliff:g> geleden geüpdatet"</string>
    <string name="carrier_and_update_now_text" msgid="5075861262344398849">"Zojuist geüpdatet door <xliff:g id="ID_1">^1</xliff:g>"</string>
    <string name="no_carrier_update_now_text" msgid="7898004907837200752">"Zojuist geüpdatet"</string>
    <string name="launch_mdp_app_text" msgid="8791816789749304897">"Abonnement bekijken"</string>
    <string name="launch_wifi_text" msgid="976421974332512894">"Details bekijken"</string>
    <string name="data_saver_title" msgid="2593804270788863815">"Databesparing"</string>
    <string name="unrestricted_data_saver" msgid="7922563266857367495">"Onbeperkte data"</string>
    <string name="restrict_background_blocklisted" msgid="2308345280442438232">"Achtergrondgegevens staan uit"</string>
    <string name="data_saver_on" msgid="7848893946018448793">"Aan"</string>
    <string name="data_saver_off" msgid="5891210864117269045">"Uit"</string>
    <string name="data_saver_switch_title" msgid="7111538580123722959">"Databesparing gebruiken"</string>
    <string name="unrestricted_app_title" msgid="7117585996574329284">"Onbeperkt datagebruik toestaan"</string>
    <string name="unrestricted_app_summary" msgid="282698963532000403">"Sta onbeperkte datatoegang toe als databesparing aanstaat"</string>
    <string name="home_app" msgid="6056850504746902747">"Startscherm-app"</string>
    <string name="suggestion_additional_fingerprints" msgid="4726777300101156208">"Nog een vingerafdruk toevoegen"</string>
    <string name="suggestion_additional_fingerprints_summary" msgid="2825364645039666674">"Ontgrendelen met een andere vinger"</string>
    <string name="battery_saver_on_summary" msgid="4605146593966255848">"Aan"</string>
    <string name="battery_saver_off_scheduled_summary" msgid="2193875981740829819">"Batterijbesparing wordt aangezet bij <xliff:g id="BATTERY_PERCENTAGE">%1$s</xliff:g>"</string>
    <string name="battery_saver_off_summary" msgid="4411561435493109261">"Uit"</string>
    <string name="app_battery_usage_title" msgid="346558380609793334">"Batterijgebruik voor app"</string>
    <string name="app_battery_usage_summary" msgid="6349965904306339539">"Batterijgebruik instellen voor apps"</string>
    <string name="filter_battery_unrestricted_title" msgid="821027369424198223">"Onbeperkt"</string>
    <string name="filter_battery_optimized_title" msgid="8236647176487754796">"Geoptimaliseerd"</string>
    <string name="filter_battery_restricted_title" msgid="5886859505802563232">"Beperkt"</string>
    <string name="default_spell_checker" msgid="7108373288347014351">"Standaard spellingcontrole"</string>
    <string name="choose_spell_checker" msgid="7402513404783243675">"Spellingcontrole kiezen"</string>
    <string name="spell_checker_primary_switch_title" msgid="529240542284039243">"Spellingcontrole gebruiken"</string>
    <string name="spell_checker_not_selected" msgid="8818618543474481451">"Niet geselecteerd"</string>
    <string name="notification_log_details_delimiter" msgid="2475986465985309821">": "</string>
    <string name="notification_log_details_package" msgid="3205243985502010202">"pkt"</string>
    <string name="notification_log_details_key" msgid="2690467272328709046">"sleutel"</string>
    <string name="notification_log_details_group" msgid="1765952974599794393">"groep"</string>
    <string name="notification_log_details_group_summary" msgid="4364622087007803822">"(overzicht)"</string>
    <string name="notification_log_details_public_version" msgid="3057653571018432759">"publicVersion"</string>
    <string name="notification_log_details_importance" msgid="8516198274667183446">"belang"</string>
    <string name="notification_log_details_explanation" msgid="6966274549873070059">"uitleg"</string>
    <string name="notification_log_details_badge" msgid="648647240928645446">"kan badge tonen"</string>
    <string name="notification_log_details_content_intent" msgid="2768423554375629089">"intentie"</string>
    <string name="notification_log_details_delete_intent" msgid="8296434571041573503">"intentie verwijderen"</string>
    <string name="notification_log_details_full_screen_intent" msgid="4151243693072002296">"intentie voor volledig scherm"</string>
    <string name="notification_log_details_actions" msgid="2269605330470905236">"acties"</string>
    <string name="notification_log_details_title" msgid="8365761340979164197">"titel"</string>
    <string name="notification_log_details_remoteinput" msgid="264204203044885921">"externe invoer"</string>
    <string name="notification_log_details_content_view" msgid="7193602999512479112">"aangepaste weergave"</string>
    <string name="notification_log_details_extras" msgid="8602887256103970989">"extra\'s"</string>
    <string name="notification_log_details_icon" msgid="6728710746466389675">"icoon"</string>
    <string name="notification_log_details_parcel" msgid="2098454650154230531">"pakketgrootte"</string>
    <string name="notification_log_details_ashmem" msgid="6163312898302809015">"ashmem"</string>
    <string name="notification_log_details_alerted" msgid="5285078967825048406">"waarschuwing voor melding getoond"</string>
    <string name="notification_log_channel" msgid="3406738695621767204">"kanaal"</string>
    <string name="notification_log_details_ranking_null" msgid="6607596177723101524">"Rangschikkingsobject ontbreekt"</string>
    <string name="notification_log_details_ranking_none" msgid="2484105338466675261">"Rangschikkingsobject bevat deze sleutel niet."</string>
    <string name="display_cutout_emulation" msgid="1421648375408281244">"Display-cutout"</string>
    <string name="display_cutout_emulation_keywords" msgid="4506580703807358127">"display-cutout, inkeping"</string>
    <string name="overlay_option_device_default" msgid="7986355499809313848">"Apparaatstandaard"</string>
    <string name="overlay_toast_failed_to_apply" msgid="4839587811338164960">"Toepassen van overlay mislukt"</string>
    <string name="special_access" msgid="1767980727423395147">"Speciale app-toegang"</string>
    <string name="special_access_more" msgid="132919514147475846">"Meer tonen"</string>
    <string name="long_background_tasks_label" msgid="3169590134850226687">"Lange achtergrondtaken"</string>
    <string name="long_background_tasks_switch_title" msgid="2491623894899492543">"Uitvoeren van lange achtergrondtaken toestaan"</string>
    <string name="long_background_tasks_title" msgid="3272230637974707490">"Lange achtergrondtaken"</string>
    <string name="long_background_tasks_footer_title" msgid="9117342254914743097">"Toestaan dat deze app lange achtergrondtaken uitvoert. Hiermee kan de app taken uitvoeren die langer duren dan een paar minuten, zoals downloads en uploads. \n\nAls dit recht niet wordt toegekend, beperkt het systeem hoelang de app dit soort taken op de achtergrond mag uitvoeren."</string>
    <string name="keywords_long_background_tasks" msgid="5788956269136054574">"lange taken, gegevensoverdracht, achtergrondtaken"</string>
    <string name="reset_shortcut_manager_throttling" msgid="2183940254903144298">"Rate limiting van ShortcutManager resetten"</string>
    <string name="reset_shortcut_manager_throttling_complete" msgid="8949943009096885470">"De rate limiting van ShortcutManager is gereset."</string>
    <string name="notification_suggestion_title" msgid="6309263655965785411">"Informatie op vergrendelscherm beheren"</string>
    <string name="notification_suggestion_summary" msgid="7615611244249276113">"Content van meldingen tonen of verbergen"</string>
    <string name="page_tab_title_support" msgid="3235725053332345773">"Tips en support"</string>
    <string name="developer_smallest_width" msgid="632354817870920911">"Kleinste breedte"</string>
    <string name="premium_sms_none" msgid="8737045049886416739">"Er zijn geen geïnstalleerde apps die premium sms-toegang hebben aangevraagd"</string>
    <string name="premium_sms_warning" msgid="2192300872411073324">"Premium sms\'jes kunnen je geld kosten en worden toegevoegd aan de facturen van je provider. Als je rechten aan een app verleent, kun je premium sms\'jes verzenden met die app."</string>
    <string name="premium_sms_access" msgid="5605970342699013212">"Premium sms-toegang"</string>
    <string name="bluetooth_disabled" msgid="835838280837359514">"Uit"</string>
    <string name="bluetooth_connected_summary" msgid="8043167194934315712">"Verbonden met <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="bluetooth_connected_multiple_devices_summary" msgid="2294954614327771844">"Verbonden met meerdere apparaten"</string>
    <string name="demo_mode" msgid="6566167465451386728">"Demomodus voor systeemgebruikersinterface"</string>
    <string name="dark_ui_mode" msgid="898146394425795281">"Donker thema"</string>
    <string name="dark_ui_mode_disabled_summary_dark_theme_on" msgid="4554134480159161533">"Tijdelijk uit vanwege Batterijbesparing"</string>
    <string name="ambient_camera_summary_battery_saver_on" msgid="1787784892047029560">"Tijdelijk uit vanwege Batterijbesparing"</string>
    <string name="ambient_camera_battery_saver_off" msgid="689825730569761613">"Batterijbesparing uitzetten"</string>
    <string name="dark_ui_mode_disabled_summary_dark_theme_off" msgid="4154227921313505702">"Tijdelijk aangezet vanwege Batterijbesparing"</string>
    <string name="dark_theme_slice_title" msgid="4684222119481114062">"Probeer \'Donker thema\'"</string>
    <string name="dark_theme_slice_subtitle" msgid="5555724345330434268">"Helpt de batterijduur te verlengen"</string>
    <string name="quick_settings_developer_tiles" msgid="7336007844525766623">"Ontwikkelaarstegels voor Snelle instellingen"</string>
    <string name="adb_authorization_timeout_title" msgid="6996844506783749754">"Time-out voor uitzetten ADB-machtiging"</string>
    <string name="adb_authorization_timeout_summary" msgid="409931540424019778">"Zet het automatisch intrekken van ADB-rechten uit voor systemen die niet binnen de standaardperiode (7 dagen) of de door de gebruiker ingestelde periode (minimaal 1 dag) opnieuw verbinding hebben gemaakt"</string>
    <string name="winscope_trace_quick_settings_title" msgid="4104768565053226689">"Winscope-tracering"</string>
    <string name="sensors_off_quick_settings_title" msgid="8472151847125917167">"Sensoren uit"</string>
    <string name="managed_profile_settings_title" msgid="3400923723423564217">"Instellingen voor werkprofiel"</string>
    <string name="managed_profile_contact_search_title" msgid="6562061740814513737">"Zoeken naar contacten in zakelijke telefoongids in persoonlijke apps"</string>
    <string name="managed_profile_contact_search_summary" msgid="4974727886709219105">"Je zoekopdrachten en inkomende gesprekken zijn misschien zichtbaar voor je IT-beheerder"</string>
    <string name="cross_profile_calendar_title" msgid="7570277841490216947">"Agenda voor meerdere profielen"</string>
    <string name="cross_profile_calendar_summary" msgid="8856185206722860069">"Werkafspraken tonen in je persoonlijke agenda"</string>
    <string name="managed_profile_settings_footer" msgid="996500759305118103">"Als werk-apps uitstaan, zijn ze gepauzeerd en kun je ze niet openen. Ook kunnen ze je geen meldingen sturen."</string>
    <string name="automatic_storage_manager_settings" msgid="519158151463974656">"Opslagruimte beheren"</string>
    <string name="automatic_storage_manager_text" msgid="6900593059927987273">"Opslagbeheer verwijdert foto\'s en video\'s waarvan een back-up is gemaakt, van je apparaat om opslagruimte vrij te maken."</string>
    <string name="automatic_storage_manager_days_title" msgid="5077286114860539367">"Foto\'s en video\'s verwijderen"</string>
    <string name="automatic_storage_manager_preference_title" msgid="3483357910142595444">"Opslagbeheer"</string>
    <string name="automatic_storage_manager_primary_switch_title" msgid="9131959126462101994">"Opslagbeheer gebruiken"</string>
    <string name="gesture_preference_title" msgid="8291899281322647187">"Gebaren"</string>
    <string name="double_tap_power_for_camera_title" msgid="7982364144330923683">"Camera snel openen"</string>
    <string name="double_tap_power_for_camera_summary" msgid="1100926048598415509">"Druk 2 keer op de aan/uit-knop om de camera snel te openen. Werkt vanuit elk scherm"</string>
    <string name="double_twist_for_camera_mode_title" msgid="472455236910935684">"Camera omdraaien voor selfie"</string>
    <string name="double_twist_for_camera_mode_summary" msgid="592503740044744951"></string>
    <string name="system_navigation_title" msgid="4890381153527184636">"Navigatiemodus"</string>
    <string name="swipe_up_to_switch_apps_title" msgid="6677266952021118342">"Navigatie met 2 knoppen"</string>
    <string name="swipe_up_to_switch_apps_summary" msgid="1415457307836359560">"Om tussen apps te schakelen, swipe je omhoog op de startknop. Om alle apps te bekijken swipe je nogmaals omhoog. Om terug te gaan tik je op de knop Terug."</string>
    <string name="emergency_settings_preference_title" msgid="6183455153241187148">"Veiligheid en noodgevallen"</string>
    <string name="emergency_dashboard_summary" msgid="401033951074039302">"SOS, medische info, waarschuwingen"</string>
    <string name="edge_to_edge_navigation_title" msgid="714427081306043819">"Navigatie met gebaren"</string>
    <string name="edge_to_edge_navigation_summary" msgid="8497033810637690561">"Als je naar het startscherm wilt gaan, swipe je omhoog vanaf de onderkant van het scherm. Om tussen apps te schakelen, swipe je omhoog vanaf de onderkant, houd je het scherm vast en laat je het los. Om terug te gaan, swipe je vanaf de linker- of rechterrand."</string>
    <string name="legacy_navigation_title" msgid="7877402855994423727">"Navigatie met 3 knoppen"</string>
    <string name="legacy_navigation_summary" msgid="5905301067778326433">"Met de knoppen onderaan je scherm kun je teruggaan, naar het startscherm gaan en tussen apps schakelen."</string>
    <string name="keywords_system_navigation" msgid="3131782378486554934">"systeemnavigatie, navigatie met 2 knoppen, navigatie met 3 knoppen, navigatie met gebaren, swipen, vegen"</string>
    <string name="assistant_gesture_category_title" msgid="2478251256585807920">"Digitale assistent"</string>
    <string name="assistant_corner_gesture_title" msgid="1895061522687002106">"Swipen om assistent aan te roepen"</string>
    <string name="assistant_corner_gesture_summary" msgid="7279576276455168075">"Swipe omhoog vanuit een benedenhoek om de digitale assistent-app aan te roepen"</string>
    <string name="assistant_long_press_home_gesture_title" msgid="4865972278738178753">"Startknop vasthouden voor de Assistent"</string>
    <string name="assistant_long_press_home_gesture_summary" msgid="592882226105081447">"Tik op de startknop en houd vast om de app voor de digitale assistent te starten"</string>
    <string name="low_label" msgid="6525629096999711220">"Laag"</string>
    <string name="high_label" msgid="357503396626018487">"Hoog"</string>
    <string name="left_edge" msgid="1513576842959071849">"Linkerrand"</string>
    <string name="right_edge" msgid="1505309103265829121">"Rechterrand"</string>
    <string name="back_sensitivity_dialog_message" msgid="6638367716784103306">"Een hogere gevoeligheid kan conflicteren met app-gebaren langs de randen van het scherm."</string>
    <string name="back_sensitivity_dialog_title" msgid="6153608904168908264">"Gevoeligheid van gebaar voor teruggaan"</string>
    <string name="gesture_settings_activity_title" msgid="2025828425762595733">"Gevoeligheid voor navigatie met gebaren"</string>
    <string name="button_navigation_settings_activity_title" msgid="7335636045504461813">"Navigatie met knoppen"</string>
    <string name="keywords_gesture_navigation_settings" msgid="667561222717238931">"navigatie met gebaren, gevoeligheid voor terug, gebaar voor terug"</string>
    <string name="keywords_button_navigation_settings" msgid="7888812253110553920">"navigatie, startknop"</string>
    <string name="one_handed_title" msgid="2584414010282746195">"Bediening met 1 hand"</string>
    <string name="one_handed_mode_enabled" msgid="3396864848786359651">"Bediening met 1 hand gebruiken"</string>
    <string name="one_handed_mode_shortcut_title" msgid="1847871530184067369">"Snelkoppeling voor bediening met 1 hand"</string>
    <string name="keywords_one_handed" msgid="969440592493034101">"bediening met 1 hand"</string>
    <string name="one_handed_mode_swipe_down_category" msgid="110178629274462484">"Omlaag swipen voor"</string>
    <string name="one_handed_mode_use_shortcut_category" msgid="1414714099339147711">"Gebruik de snelkoppeling voor"</string>
    <string name="one_handed_mode_intro_text" msgid="7921988617828924342">"Swipe de bovenste helft van je scherm omlaag zodat je het makkelijker met 1 hand kunt bedienen"</string>
    <string name="one_handed_mode_footer_text" msgid="6336209800330679840">" "<b>"Bediening met 1 hand gebruiken"</b>\n" • Check of navigatie met gebaren is geselecteerd in de navigatie-instellingen van het systeem \n • Swipe omlaag bij de onderrand van het scherm"</string>
    <string name="one_handed_action_pull_down_screen_title" msgid="9187194533815438150">"Scherm binnen bereik swipen"</string>
    <string name="one_handed_action_pull_down_screen_summary" msgid="7582432473450036628">"De bovenkant van het scherm komt binnen bereik van je duim"</string>
    <string name="one_handed_action_show_notification_title" msgid="8789305491485437130">"Meldingen tonen"</string>
    <string name="one_handed_action_show_notification_summary" msgid="8281689861222000436">"Je ziet meldingen en instellingen"</string>
    <string name="ambient_display_summary" msgid="2650326740502690434">"Dubbeltik op je scherm om de tijd, meldingen en andere informatie te bekijken."</string>
    <string name="ambient_display_wake_screen_title" msgid="7637678749035378085">"Scherm activeren"</string>
    <string name="ambient_display_tap_screen_summary" msgid="4480489179996521405">"Tik op je scherm om de tijd, meldingen en andere informatie te bekijken"</string>
    <string name="emergency_gesture_screen_title" msgid="3280543310204360902">"SOS"</string>
    <string name="emergency_gesture_switchbar_title" msgid="7421353963329899514">"SOS gebruiken"</string>
    <string name="emergency_gesture_screen_summary" msgid="6640521030845132507">"Druk snel minstens 5 keer op de aan/uit-knop om de onderstaande acties te activeren"</string>
    <string name="emergency_gesture_sound_setting_title" msgid="7153948164862156536">"Aftelalarm afspelen"</string>
    <string name="emergency_gesture_sound_setting_summary" msgid="6573377104470235173">"Speel een hard geluid af als SOS wordt gestart"</string>
    <string name="emergency_gesture_category_call_for_help_title" msgid="1680040129478289510">"Melding sturen voor hulp"</string>
    <string name="emergency_gesture_call_for_help_title" msgid="4969340870836239982">"Bellen voor hulp"</string>
    <string name="emergency_gesture_call_for_help_dialog_title" msgid="8901271205171421201">"Nummer om te bellen voor hulp"</string>
    <string name="emergency_gesture_call_for_help_summary" msgid="6552830427932669221">"<xliff:g id="PHONE_NUMBER">%1$s</xliff:g>. Tik om te wijzigen"</string>
    <string name="emergency_gesture_number_override_notes" msgid="233018570696200402">"Als je een niet-alarmnummer opgeeft:\n • Je apparaat moet ontgrendeld zijn om SOS te gebruiken.\n • Je gesprek wordt misschien niet beantwoord."</string>
    <string name="fingerprint_swipe_for_notifications_title" msgid="2271217256447175017">"Over vingerafdruksensor swipen voor meldingen"</string>
    <string name="fingerprint_gesture_screen_title" msgid="9086261338232806522">"Over vingerafdruk swipen"</string>
    <string name="fingerprint_swipe_for_notifications_suggestion_title" msgid="2956636269742745449">"Snel meldingen bekijken"</string>
    <string name="gesture_setting_on" msgid="3223448394997988591">"Aan"</string>
    <string name="gesture_setting_off" msgid="3444029475726294919">"Uit"</string>
    <string name="oem_unlock_enable_disabled_summary_bootloader_unlocked" msgid="65713754674288193">"Bootloader is al ontgrendeld"</string>
    <string name="oem_unlock_enable_disabled_summary_connectivity_or_locked" msgid="7425519481227423860">"Verbind met internet of neem contact op met je provider"</string>
    <string name="oem_unlock_enable_disabled_summary_sim_locked_device" msgid="168124660162907358">"Niet beschikbaar op door provider vergrendelde apparaten"</string>
    <string name="oem_lock_info_message" msgid="8843145669619429197">"Start het apparaat opnieuw op om de apparaatbeveiliging aan te zetten."</string>
    <string name="automatic_storage_manager_freed_bytes" msgid="706230592123831676">"<xliff:g id="SIZE">%1$s</xliff:g> in totaal beschikbaar gemaakt\n\nLaatst uitgevoerd op <xliff:g id="DATE">%2$s</xliff:g>"</string>
    <string name="web_action_enable_title" msgid="6654581786741216382">"Instant-apps"</string>
    <string name="web_action_enable_summary" msgid="2658930257777545990">"Open links in apps, zelfs als deze niet zijn geïnstalleerd"</string>
    <string name="web_action_section_title" msgid="994717569424234098">"Instant-apps"</string>
    <string name="instant_apps_settings" msgid="4280942494969957858">"Voorkeuren Instant-apps"</string>
    <string name="domain_url_section_title" msgid="9028890472923474958">"Geïnstalleerde apps"</string>
    <string name="automatic_storage_manager_activation_warning" msgid="170508173207142665">"Je opslag wordt nu beheerd door de opslagbeheerder"</string>
    <string name="account_for_section_header" msgid="7466759342105251096">"Accounts voor <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="auto_sync_account_title" msgid="1070908045600374254">"App-gegevens automatisch synchroniseren"</string>
    <string name="auto_sync_account_summary" msgid="7580352130028957346">"Laat apps automatisch gegevens vernieuwen"</string>
    <string name="account_sync_title" msgid="7036067017433297574">"Accountsynchronisatie"</string>
    <string name="account_sync_summary_some_on" msgid="911460286297968724">"Synchronisatie staat aan voor <xliff:g id="ID_1">%1$d</xliff:g> van de <xliff:g id="ID_2">%2$d</xliff:g> items"</string>
    <string name="account_sync_summary_all_on" msgid="2953682111836599841">"Synchronisatie staat aan voor alle items"</string>
    <string name="account_sync_summary_all_off" msgid="6378301874540507884">"Synchronisatie staat uit voor alle items"</string>
    <string name="enterprise_privacy_settings" msgid="786350385374794180">"Informatie over beheerd apparaat"</string>
    <string name="enterprise_privacy_settings_summary_generic" msgid="5471858290610344646">"Wijzigingen en instellingen beheerd door je organisatie"</string>
    <string name="enterprise_privacy_settings_summary_with_name" msgid="1315413275836515937">"Wijzigingen en instellingen beheerd door <xliff:g id="ORGANIZATION_NAME">%s</xliff:g>"</string>
    <string name="enterprise_privacy_header" msgid="4626225398848641603">"Je organisatie kan instellingen wijzigen en software installeren op je apparaat om toegang te bieden tot je werkgegevens.\n\nNeem contact op met de beheerder van je organisatie voor meer informatie."</string>
    <string name="enterprise_privacy_exposure_category" msgid="2507761423540037308">"Typen gegevens die je organisatie kan zien"</string>
    <string name="enterprise_privacy_exposure_changes_category" msgid="5459989751333816587">"Wijzigingen door de beheerder van je organisatie"</string>
    <string name="enterprise_privacy_device_access_category" msgid="140157499478630004">"Je toegang tot dit apparaat"</string>
    <string name="enterprise_privacy_enterprise_data" msgid="3963070078195245028">"Gegevens die zijn gekoppeld aan je werkaccount, zoals e-mail en agenda"</string>
    <string name="enterprise_privacy_installed_packages" msgid="6707006112254572820">"Lijst met apps op je apparaat"</string>
    <string name="enterprise_privacy_usage_stats" msgid="6328506963853465534">"Tijd en data besteed aan elke app"</string>
    <string name="enterprise_privacy_network_logs" msgid="3081744541193695887">"Logboek van het meest recente netwerkverkeer"</string>
    <string name="enterprise_privacy_bug_reports" msgid="2635897583413134123">"Recentste bugrapport"</string>
    <string name="enterprise_privacy_security_logs" msgid="8494681624247959075">"Recentste beveiligingslogboek"</string>
    <string name="enterprise_privacy_none" msgid="6026527690979756431">"Geen"</string>
    <string name="enterprise_privacy_enterprise_installed_packages" msgid="9114143640515900082">"Geïnstalleerde apps"</string>
    <string name="enterprise_privacy_apps_count_estimation_info" msgid="7959907857710107792">"Het aantal apps is een schatting die mogelijk geen apps omvat die zijn geïnstalleerd buiten de Play Store om."</string>
    <string name="enterprise_privacy_number_packages_lower_bound" msgid="5317634640873658149">"{count,plural, =1{Minimaal # app}other{Minimaal # apps}}"</string>
    <string name="enterprise_privacy_location_access" msgid="8023838718108456971">"Toegang tot locatie"</string>
    <string name="enterprise_privacy_microphone_access" msgid="7242958026470143653">"Toegang tot microfoon"</string>
    <string name="enterprise_privacy_camera_access" msgid="7685460535880069016">"Toegang tot camera"</string>
    <string name="enterprise_privacy_enterprise_set_default_apps" msgid="7498546659083996300">"Standaard-apps"</string>
    <string name="enterprise_privacy_number_packages" msgid="5294444005035188274">"{count,plural, =1{# app}other{# apps}}"</string>
    <string name="enterprise_privacy_input_method" msgid="3278314982700662246">"Standaardtoetsenbord"</string>
    <string name="enterprise_privacy_input_method_name" msgid="2974859490559054584">"Ingesteld op <xliff:g id="APP_LABEL">%s</xliff:g>"</string>
    <string name="enterprise_privacy_always_on_vpn_device" msgid="1735829327405126695">"Always-on VPN staat aan"</string>
    <string name="enterprise_privacy_always_on_vpn_personal" msgid="8395903360175064841">"Always-on VPN staat aan in je persoonlijke profiel"</string>
    <string name="enterprise_privacy_always_on_vpn_work" msgid="2496961514592522377">"Always-on VPN staat aan in je werkprofiel"</string>
    <string name="enterprise_privacy_global_http_proxy" msgid="4350347418068037051">"Algemene HTTP-proxy ingesteld"</string>
    <string name="enterprise_privacy_ca_certs_device" msgid="1816495877258727663">"Vertrouwde inloggegevens"</string>
    <string name="enterprise_privacy_ca_certs_personal" msgid="1516422660828485795">"Vertrouwde certificaatgegevens in je persoonlijke profiel"</string>
    <string name="enterprise_privacy_ca_certs_work" msgid="4318941788592655561">"Vertrouwde certificaatgegevens in je werkprofiel"</string>
    <string name="enterprise_privacy_number_ca_certs" msgid="4540897122831942658">"{count,plural, =1{Minimaal # CA-certificaat}other{Minimaal # CA-certificaten}}"</string>
    <string name="enterprise_privacy_lock_device" msgid="464054894363899866">"Beheerder kan het apparaat vergrendelen en het wachtwoord resetten"</string>
    <string name="enterprise_privacy_wipe_device" msgid="869589182352244591">"Beheerder kan alle apparaatgegevens verwijderen"</string>
    <string name="enterprise_privacy_failed_password_wipe_device" msgid="7045164901334821226">"Aantal mislukte wachtwoordpogingen voordat alle apparaatgegevens worden verwijderd"</string>
    <string name="enterprise_privacy_failed_password_wipe_work" msgid="2537582942554484170">"Aantal mislukte wachtwoordpogingen voordat de gegevens van het werkprofiel worden verwijderd"</string>
    <string name="enterprise_privacy_number_failed_password_wipe" msgid="2695842143305867642">"{count,plural, =1{# poging}other{# pogingen}}"</string>
    <string name="do_disclosure_generic" msgid="3067459392402324538">"Dit apparaat wordt beheerd door je organisatie."</string>
    <string name="do_disclosure_with_name" msgid="867544298924410766">"Dit apparaat wordt beheerd door <xliff:g id="ORGANIZATION_NAME">%s</xliff:g>."</string>
    <string name="do_disclosure_learn_more_separator" msgid="5714364437437041671">" "</string>
    <string name="learn_more" msgid="3534519107947510952">"Meer informatie"</string>
    <string name="blocked_by_restricted_settings_title" msgid="7334715011474037399">"Beperkte instelling"</string>
    <string name="toast_allows_restricted_settings_successfully" msgid="1219116121291466102">"Beperkte instellingen toegestaan voor <xliff:g id="APP_NAME">%s</xliff:g>"</string>
    <string name="blocked_by_restricted_settings_content" msgid="3628660029601161080">"Ter beveiliging is deze instelling op dit moment niet beschikbaar."</string>
    <string name="financed_privacy_settings" msgid="2575114436197204145">"Informatie over gefinancierd apparaat"</string>
    <string name="financed_privacy_intro" msgid="7836497475568741579">"Je kredietverstrekker kan instellingen wijzigen en software installeren op dit apparaat tijdens het instellen.\n\nAls je een betaling mist, kan je kredietverstrekker je apparaat vergrendelen en de apparaatinstellingen wijzigen.\n\nNeem contact op met je kredietverstrekker voor meer informatie."</string>
    <string name="financed_privacy_restrictions_category" msgid="2472659467919651602">"Als je apparaat wordt gefinancierd, kun je het volgende niet doen:"</string>
    <string name="financed_privacy_install_apps" msgid="7381718005710210851">"Apps installeren van buiten de Play Store"</string>
    <string name="financed_privacy_safe_mode" msgid="5362149445732602578">"Je apparaat opnieuw opstarten in de veilige modus"</string>
    <string name="financed_privacy_multi_users" msgid="1727194928477613081">"Meerdere gebruikers toevoegen aan je apparaat"</string>
    <string name="financed_privacy_config_date_time" msgid="8567370445374984365">"Datum, tijd en tijdzones wijzigen"</string>
    <string name="financed_privacy_developer_options" msgid="7602001474669831672">"Ontwikkelaarsopties gebruiken"</string>
    <string name="financed_privacy_credit_provider_capabilities_category" msgid="8737902277892987998">"Je kredietverstrekker kan:"</string>
    <string name="financed_privacy_IMEI" msgid="1852413860963824799">"Toegang krijgen tot je IMEI-nummer"</string>
    <string name="financed_privacy_factory_reset" msgid="5505016667590160732">"Je apparaat terugzetten naar de fabrieksinstellingen als er iets misgaat"</string>
    <string name="financed_privacy_locked_mode_category" msgid="3708288398912647751">"Als je apparaat is vergrendeld, kun je dit alleen gebruiken voor:"</string>
    <string name="financed_privacy_emergency_calls" msgid="1108183987142736497">"Noodoproepen plaatsen"</string>
    <string name="financed_privacy_system_info" msgid="4158031444108708927">"Systeemgegevens bekijken, zoals datum, tijd, netwerkstatus en batterij"</string>
    <string name="financed_privacy_turn_on_off_device" msgid="3331566753152790571">"Je apparaat aan- of uitzetten"</string>
    <string name="financed_privacy_notifications" msgid="5932303271274089968">"Meldingen en sms-berichten bekijken"</string>
    <string name="financed_privacy_allowlisted_apps" msgid="8333040812194879963">"Toegang krijgen tot apps die zijn toegestaan door de kredietverstrekker"</string>
    <string name="financed_privacy_fully_paid_category" msgid="9221763928564246923">"Nadat je het volledige bedrag hebt betaald:"</string>
    <string name="financed_privacy_restrictions_removed" msgid="3182636815294595072">"worden alle beperkingen voor het apparaat ingetrokken."</string>
    <string name="financed_privacy_uninstall_creditor_app" msgid="6339004120497310705">"kun je de app van de kredietverstrekker verwijderen."</string>
    <string name="device_lock_info" msgid="1628142032642755537">"Apparaatvergrendeling"</string>
    <string name="default_camera_app_title" msgid="6546248868519965998">"{count,plural, =1{Camera-app}other{Camera-apps}}"</string>
    <string name="default_calendar_app_title" msgid="1870095225089706093">"Agenda-app"</string>
    <string name="default_contacts_app_title" msgid="7740028900741944569">"Contacten-app"</string>
    <string name="default_email_app_title" msgid="5411280873093244250">"{count,plural, =1{E-mailclient-app}other{E-mailclient-apps}}"</string>
    <string name="default_map_app_title" msgid="7569231732944853320">"Kaart-app"</string>
    <string name="default_phone_app_title" msgid="795025972645464135">"{count,plural, =1{Telefoon-app}other{Telefoon-apps}}"</string>
    <string name="app_names_concatenation_template_2" msgid="8320181646458855457">"<xliff:g id="FIRST_APP_NAME">%1$s</xliff:g>, <xliff:g id="SECOND_APP_NAME">%2$s</xliff:g>"</string>
    <string name="app_names_concatenation_template_3" msgid="7019703249717854148">"<xliff:g id="FIRST_APP_NAME">%1$s</xliff:g>, <xliff:g id="SECOND_APP_NAME">%2$s</xliff:g>, <xliff:g id="THIRD_APP_NAME">%3$s</xliff:g>"</string>
    <string name="storage_default_internal_storage" msgid="4055660218818688131">"Dit apparaat"</string>
    <string name="storage_games" msgid="1176568610086802469">"Games"</string>
    <string name="storage_files" msgid="7968460921272772299">"Bestanden"</string>
    <string name="storage_images" msgid="2055893015567979387">"Afbeeldingen"</string>
    <string name="storage_videos" msgid="6117698226447251033">"Video\'s"</string>
    <string name="storage_audio" msgid="5994664984472140386">"Audio"</string>
    <string name="storage_apps" msgid="3564291603258795216">"Apps"</string>
    <string name="storage_documents_and_other" msgid="3293689243732236480">"Documenten en andere bestanden"</string>
    <string name="storage_system" msgid="8472410119822911844">"Systeem"</string>
    <string name="storage_trash" msgid="2807138998886084856">"Prullenbak"</string>
    <string name="storage_trash_dialog_title" msgid="2296169576049935200">"Prullenbak leegmaken?"</string>
    <string name="storage_trash_dialog_ask_message" msgid="8982602137242358798">"Er staan <xliff:g id="TOTAL">%1$s</xliff:g> bestanden in de prullenbak. Alle items worden definitief verwijderd en je kunt ze niet meer herstellen."</string>
    <string name="storage_trash_dialog_empty_message" msgid="7334670765528691400">"De prullenbak is leeg"</string>
    <string name="storage_trash_dialog_confirm" msgid="1707723334982760436">"Prullenbak leegmaken"</string>
    <string name="storage_usage_summary" msgid="4591121727356723463">"<xliff:g id="NUMBER">%1$s</xliff:g> <xliff:g id="UNIT">%2$s</xliff:g> gebruikt"</string>
    <string name="storage_total_summary" msgid="7163360249534964272">"<xliff:g id="NUMBER">%1$s</xliff:g> <xliff:g id="UNIT">%2$s</xliff:g> in totaal"</string>
    <string name="clear_instant_app_data" msgid="5951258323364386357">"Gegevens van app wissen"</string>
    <string name="clear_instant_app_confirmation" msgid="3964731334459209482">"Wil je deze instant-app verwijderen?"</string>
    <string name="launch_instant_app" msgid="8503927414339606561">"Openen"</string>
    <string name="game_storage_settings" msgid="2521393115726178837">"Games"</string>
    <string name="app_info_storage_title" msgid="4076977173803093808">"Gebruikte ruimte"</string>
    <string name="webview_uninstalled_for_user" msgid="627352948986275488">"(verwijderd voor gebruiker <xliff:g id="USER">%s</xliff:g>)"</string>
    <string name="webview_disabled_for_user" msgid="5809886172032644498">"(uitgezet voor gebruiker <xliff:g id="USER">%s</xliff:g>)"</string>
    <string name="autofill_app" msgid="7595308061826307921">"Service voor automatisch invullen"</string>
    <string name="default_autofill_app" msgid="372234803718251606">"Standaardservice voor automatisch invullen"</string>
    <string name="autofill_passwords" msgid="6708057251459761083">"Wachtwoorden"</string>
    <string name="credman_chosen_app_title" msgid="4547405511458518096">"Wachtwoorden, toegangssleutels en gegevensservices"</string>
    <string name="credman_credentials" msgid="4931371941253324143">"Aanvullende providers"</string>
    <string name="autofill_passwords_count" msgid="6359289285822955973">"{count,plural, =1{# wachtwoord}other{# wachtwoorden}}"</string>
    <string name="autofill_keywords" msgid="8598763328489346438">"automatisch, invullen, automatisch invullen, wachtwoord"</string>
    <string name="credman_keywords" msgid="8305600680836806170">"gegevens, toegangssleutel, wachtwoord"</string>
    <string name="credman_autofill_keywords" msgid="701180623776848914">"automatisch, invullen, automatisch invullen, gegevens, toegangssleutel, wachtwoord"</string>
    <string name="autofill_confirmation_message" msgid="4888767934273494272">"&lt;b&gt;Zorg dat je deze app vertrouwt&lt;/b&gt; &lt;br/&gt; &lt;br/&gt; &lt;xliff:g id=app_name example=Google Autofill&gt;%1$s&lt;/xliff:g&gt; maakt gebruik van de content op je scherm om te bepalen wat automatisch kan worden aangevuld."</string>
    <string name="credman_autofill_confirmation_message" msgid="4951846866327737417">"&lt;b&gt;&lt;xliff:g id=app_name example=Provider&gt;%1$s&lt;/xliff:g&gt; gebruiken?&lt;/b&gt; &lt;br/&gt; &lt;br/&gt; &lt;xliff:g id=app_name example=Provider&gt;%1$s&lt;/xliff:g&gt; gebruikt wat er op je scherm staat om te bepalen wat automatisch kan worden ingevuld. Nieuwe wachtwoorden, toegangssleutels en andere informatie worden vanaf nu hier opgeslagen."</string>
    <string name="credman_picker_title" msgid="2642776965060619988">"Wachtwoorden, toegangssleutels en gegevensservices"</string>
    <string name="credman_confirmation_message_title" msgid="8847900085593880729">"%1$s uitzetten?"</string>
    <string name="credman_confirmation_message" msgid="2357324543658635239">"&lt;b&gt;Deze service uitzetten?&lt;/b&gt; &lt;br/&gt; &lt;br/&gt; Opgeslagen informatie zoals wachtwoorden, toegangssleutels, betaalmethoden en andere informatie wordt niet automatisch ingevuld als je inlogt. Kies een wachtwoord, toegangssleutel of gegevensservice om je opgeslagen informatie te gebruiken."</string>
    <string name="credman_enable_confirmation_message_title" msgid="1037501792652277829">"%1$s gebruiken?"</string>
    <string name="credman_enable_confirmation_message" msgid="8407841892310870169">"%1$s gebruikt wat er op je scherm staat om te bepalen wat automatisch kan worden ingevuld."</string>
    <string name="credman_error_message_title" msgid="4741457523969373713">"Limiet voor wachtwoorden, toegangssleutels en gegevensservices"</string>
    <string name="credman_error_message" msgid="6793314648458925172">"Je kunt maximaal 5 wachtwoorden, toegangssleutels en gegevensservices tegelijk hebben. Zet een service uit om meer toe te voegen."</string>
    <string name="credman_confirmation_message_positive_button" msgid="2812613187691345361">"Uitzetten"</string>
    <string name="debug_autofill_category" msgid="5998163555428196185">"Automatisch invullen"</string>
    <string name="autofill_logging_level_title" msgid="3733958845861098307">"Logniveau"</string>
    <string name="autofill_max_partitions" msgid="7342195529574406366">"Max. aantal verzoeken per sessie"</string>
    <string name="autofill_max_visible_datasets" msgid="4970201981694392229">"Max. zichtbare gegevenssets"</string>
    <string name="autofill_reset_developer_options" msgid="6425613608979498608">"Resetten naar standaardwaarden"</string>
    <string name="autofill_reset_developer_options_complete" msgid="1276741935956594965">"Ontwikkelaarsopties voor automatisch invullen zijn gereset"</string>
    <string name="location_category" msgid="3496759112306219062">"Locatie"</string>
    <string name="location_indicator_settings_title" msgid="6655916258720093451">"Locatie-indicator in statusbalk"</string>
    <string name="location_indicator_settings_description" msgid="2888022085372804021">"Tonen voor alle locaties, inclusief netwerk en connectiviteit"</string>
    <string name="enable_gnss_raw_meas_full_tracking" msgid="1206679951510243341">"Volledige GNSS-metingen afdwingen"</string>
    <string name="enable_gnss_raw_meas_full_tracking_summary" msgid="3841463141138247167">"Houd alle GNSS-constellaties en -frequenties bij zonder duty cycling"</string>
    <string name="input_method_category" msgid="2252659253631639005">"Invoermethode"</string>
    <string name="stylus_handwriting" msgid="2154591374132794563">"Stylushandschrift"</string>
    <string name="stylus_handwriting_summary" msgid="6333425895172696950">"Als deze optie aanstaat, krijgt de huidige invoermethode de MotionEvent van de stylus als er een editor actief is"</string>
    <string name="device_theme" msgid="5027604586494772471">"Apparaatthema"</string>
    <string name="default_theme" msgid="4815428567082263639">"Standaard"</string>
    <string name="show_operator_name_title" msgid="3355910331531144028">"Netwerknaam"</string>
    <string name="show_operator_name_summary" msgid="5352696579216501773">"Netwerknaam weergeven in statusbalk"</string>
    <string name="install_type_instant" msgid="7685381859060486009">"Instant-app"</string>
    <string name="automatic_storage_manager_deactivation_warning" msgid="4905106133215702099">"Opslagbeheer uitzetten?"</string>
    <string name="zen_suggestion_title" msgid="4555260320474465668">"\'Niet storen\' updaten"</string>
    <string name="zen_suggestion_summary" msgid="1984990920503217">"Meldingen onderbreken om gefocust te blijven"</string>
    <string name="disabled_feature" msgid="7151433782819744211">"De functie is niet beschikbaar"</string>
    <string name="disabled_feature_reason_slow_down_phone" msgid="5743569256308510404">"Deze functie is uitgezet omdat je telefoon erdoor wordt vertraagd"</string>
    <string name="show_first_crash_dialog" msgid="1696584857732637389">"Altijd een crashvenster tonen"</string>
    <string name="show_first_crash_dialog_summary" msgid="4692334286984681111">"Toon altijd een venster bij gecrashte apps"</string>
    <string name="angle_enabled_app" msgid="6044941043384239076">"App met ANGLE-functionaliteit selecteren"</string>
    <string name="angle_enabled_app_not_set" msgid="4472572224881726067">"Geen app met ANGLE-functionaliteit ingesteld"</string>
    <string name="angle_enabled_app_set" msgid="7811829383833353021">"App met ANGLE-functionaliteit: <xliff:g id="APP_NAME">%1$s</xliff:g>"</string>
    <string name="graphics_driver_dashboard_title" msgid="5661084817492587796">"Voorkeuren voor grafisch stuurprogramma"</string>
    <string name="graphics_driver_dashboard_summary" msgid="6348759885315793654">"Pas instellingen grafisch stuurprogramma aan"</string>
    <string name="graphics_driver_footer_text" msgid="5123754522284046790">"Als er meerdere grafische stuurprogramma\'s zijn, kun je kiezen om het geüpdatete grafische stuurprogramma te gebruiken voor apps die zijn geïnstalleerd op het apparaat."</string>
    <string name="graphics_driver_all_apps_preference_title" msgid="1343065382898127360">"Aanzetten voor alle apps"</string>
    <string name="graphics_driver_app_preference_title" msgid="3133255818657706857">"Grafisch stuurprogramma selecteren"</string>
    <string name="graphics_driver_app_preference_default" msgid="764432460281859855">"Standaard"</string>
    <string name="graphics_driver_app_preference_production_driver" msgid="1515874802568434915">"Game Driver"</string>
    <string name="graphics_driver_app_preference_prerelease_driver" msgid="7355929161805829480">"Stuurprogramma voor ontwikkelaars"</string>
    <string name="graphics_driver_app_preference_system" msgid="3754748149113184126">"Grafisch stuurprogramma voor systeem"</string>
    <!-- no translation found for graphics_driver_all_apps_preference_values:0 (8039644515855740879) -->
    <!-- no translation found for graphics_driver_all_apps_preference_values:1 (157748136905839375) -->
    <!-- no translation found for graphics_driver_all_apps_preference_values:2 (8104576549429294026) -->
    <!-- no translation found for graphics_driver_app_preference_values:0 (6403705826179314116) -->
    <!-- no translation found for graphics_driver_app_preference_values:1 (485288770206606512) -->
    <!-- no translation found for graphics_driver_app_preference_values:2 (5391218026495225599) -->
    <!-- no translation found for graphics_driver_app_preference_values:3 (2586045835780389650) -->
    <string name="enable_angle_as_system_driver" msgid="3985105681812713612">"ANGLE aanzetten"</string>
    <string name="enable_angle_as_system_driver_summary" msgid="4173041926052925436">"ANGLE aanzetten als OpenGL ES-stuurprogramma van het systeem"</string>
    <string name="reboot_dialog_enable_angle_as_system_driver" msgid="2619263039763150810">"Je moet opnieuw opstarten om het OpenGL ES-stuurprogramma van het systeem te wijzigen"</string>
    <string name="platform_compat_dashboard_title" msgid="1323980546791790236">"App-compatibiliteitswijzigingen"</string>
    <string name="platform_compat_dashboard_summary" msgid="4036546607938791337">"Zet app-compatibiliteitswijzigingen aan/uit"</string>
    <string name="platform_compat_default_enabled_title" msgid="8973137337738388024">"Standaard aangezette wijzigingen"</string>
    <string name="platform_compat_default_disabled_title" msgid="3975847180953793602">"Standaard uitgezette wijzigingen"</string>
    <string name="platform_compat_dialog_title_no_apps" msgid="4387656000745989506">"Geen apps"</string>
    <string name="platform_compat_dialog_text_no_apps" msgid="5715226015751055812">"Wijzigingen in app-compatibiliteit kunnen alleen worden aangepast voor apps waarin fouten kunnen worden opgespoord. Installeer een app waarin fouten kunnen worden opgespoord en probeer het opnieuw."</string>
    <string name="disabled_dependent_setting_summary" msgid="4508635725315852504">"Is afhankelijk van een andere instelling"</string>
    <string name="my_device_info_account_preference_title" msgid="9197139254007133175">"Account"</string>
    <string name="my_device_info_device_name_preference_title" msgid="8053298498727237971">"Apparaatnaam"</string>
    <string name="my_device_info_basic_info_category_title" msgid="381963187269356548">"Basisinformatie"</string>
    <string name="my_device_info_legal_category_title" msgid="7732792841537995127">"Juridisch en regelgeving"</string>
    <string name="my_device_info_device_details_category_title" msgid="4848438695638348680">"Apparaatgegevens"</string>
    <string name="my_device_info_device_identifiers_category_title" msgid="2197063484127704153">"Apparaat-ID\'s"</string>
    <string name="change_wifi_state_title" msgid="5629648102837821525">"Wifi-beheer"</string>
    <string name="change_wifi_state_app_detail_switch" msgid="1385358508267180745">"App toestaan om wifi te beheren"</string>
    <string name="change_wifi_state_app_detail_summary" msgid="8230854855584217111">"Sta deze app toe om wifi aan of uit te zetten, wifi-netwerken te scannen en er verbinding mee te maken, netwerken toe te voegen of te verwijderen of een hotspot alleen lokaal te starten."</string>
    <string name="change_nfc_tag_apps_title" msgid="91514009058149617">"Starten via NFC"</string>
    <string name="change_nfc_tag_apps_detail_switch" msgid="240286205725043561">"Lancering bij NFC-scan toestaan"</string>
    <string name="change_nfc_tag_apps_detail_summary" msgid="7083666814715607078">"Sta toe dat deze app wordt gestart als een NFC-tag wordt gescand.\nAls dit recht aanstaat, is de app beschikbaar als optie wanneer er een tag wordt waargenomen."</string>
    <string name="media_output_title" msgid="8283629315159510680">"Media afspelen naar"</string>
    <string name="media_output_label_title" msgid="4139048973886819148">"<xliff:g id="LABEL">%s</xliff:g> afspelen op"</string>
    <string name="media_output_default_summary" msgid="4200343059396412376">"Dit apparaat"</string>
    <string name="media_out_summary_ongoing_call_state" msgid="475188726850090363">"Niet beschikbaar tijdens gesprekken"</string>
    <string name="take_call_on_title" msgid="1159417893879946757">"Opnemen op"</string>
    <string name="cannot_change_apn_toast" msgid="296540724089240405">"Deze APN kan niet worden gewijzigd."</string>
    <string name="gesture_prevent_ringing_screen_title" msgid="8293094715267769349">"Ringtone uitzetten"</string>
    <string name="gesture_prevent_ringing_title" msgid="5978577898997523581">"Druk tegelijkertijd op de aan/uit-knop en de knop Volume omhoog voor"</string>
    <string name="gesture_prevent_ringing_sound_title" msgid="4529077822282099235">"Snelkoppeling om ringtone uit te zetten"</string>
    <string name="prevent_ringing_option_vibrate" msgid="5456962289649581737">"Trillen"</string>
    <string name="prevent_ringing_option_mute" msgid="7446121133560945051">"Geluid uitzetten"</string>
    <string name="prevent_ringing_option_vibrate_summary" msgid="3435299885425754304">"Trillen"</string>
    <string name="prevent_ringing_option_mute_summary" msgid="3939350522269337013">"Geluid uit"</string>
    <string name="prevent_ringing_option_unavailable_lpp_summary" msgid="8070356204398144241">"Als je dit wilt aanzetten, wijzig je eerst \'Aan/uit-knop ingedrukt houden\' in het aan/uit-menu."</string>
    <string name="pref_title_network_details" msgid="7329759534269363308">"Netwerk­gegevens"</string>
    <string name="about_phone_device_name_warning" msgid="1938930553285875166">"Je apparaatnaam is zichtbaar voor apps op je telefoon. De apparaatnaam kan ook door andere mensen worden gezien als je verbinding maakt met bluetooth-apparaten of een wifi-netwerk, of als je een wifi-hotspot instelt."</string>
    <string name="devices_title" msgid="649715719278562515">"Apparaten"</string>
    <string name="choose_network_title" msgid="5355609223363859430">"Netwerk kiezen"</string>
    <string name="network_disconnected" msgid="8281188173486212661">"Verbinding verbroken"</string>
    <string name="network_connected" msgid="7637745547242487795">"Verbonden"</string>
    <string name="network_connecting" msgid="6856124847029124041">"Verbinding maken…"</string>
    <string name="network_could_not_connect" msgid="676574629319069922">"Kan geen verbinding maken"</string>
    <string name="empty_networks_list" msgid="6519489879480673428">"Geen netwerken gevonden."</string>
    <string name="network_query_error" msgid="6406348372070035274">"Kan geen netwerken vinden. Probeer het opnieuw."</string>
    <string name="forbidden_network" msgid="7404863971282262991">"(niet toegestaan)"</string>
    <string name="sim_card" msgid="6381158752066377709">"Simkaart"</string>
    <string name="wifi_no_sim_card" msgid="7144290066491585672">"Geen simkaart"</string>
    <string name="wifi_no_related_sim_card" msgid="3568255415415630510">"Geen"</string>
    <string name="wifi_require_sim_card_to_connect" msgid="1524984445750423666">"Simkaart vereist voor verbinding"</string>
    <string name="wifi_require_specific_sim_card_to_connect" msgid="8136020469861668506">"Simkaart van <xliff:g id="WIRELESS_CARRIER">%s</xliff:g> vereist voor verbinding"</string>
    <string name="preferred_network_mode_wcdma_perf_summary" msgid="230527592752934655">"Voorkeursnetwerkmodus: voorkeur voor WCDMA"</string>
    <string name="preferred_network_mode_gsm_only_summary" msgid="2936969642076535162">"Voorkeursnetwerkmodus: alleen GSM"</string>
    <string name="preferred_network_mode_wcdma_only_summary" msgid="632816273979433076">"Voorkeursnetwerkmodus: alleen WCDMA"</string>
    <string name="preferred_network_mode_gsm_wcdma_summary" msgid="6419309630040697488">"Voorkeursnetwerkmodus: GSM/WCDMA"</string>
    <string name="preferred_network_mode_cdma_summary" msgid="5735467143380764681">"Voorkeursnetwerkmodus: CDMA"</string>
    <string name="preferred_network_mode_cdma_evdo_summary" msgid="1667358006735235626">"Voorkeursnetwerkmodus: CDMA/EvDo"</string>
    <string name="preferred_network_mode_cdma_only_summary" msgid="6305930965673800101">"Voorkeursnetwerkmodus: alleen CDMA"</string>
    <string name="preferred_network_mode_evdo_only_summary" msgid="613903666107299289">"Voorkeursnetwerkmodus: alleen EvDo"</string>
    <string name="preferred_network_mode_cdma_evdo_gsm_wcdma_summary" msgid="5643603478619124717">"Voorkeursnetwerkmodus: CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_lte_summary" msgid="4236015557975544307">"Voorkeursnetwerkmodus: LTE"</string>
    <string name="preferred_network_mode_lte_gsm_wcdma_summary" msgid="1377100995001285751">"Voorkeursnetwerkmodus: GSM/WCDMA/LTE"</string>
    <string name="preferred_network_mode_lte_cdma_evdo_summary" msgid="1221806410911793222">"Voorkeursnetwerkmodus: CDMA+LTE/EVDO"</string>
    <string name="preferred_network_mode_lte_cdma_evdo_gsm_wcdma_summary" msgid="8974263692041299883">"Voorkeursnetwerkmodus: LTE/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_global_summary" msgid="817118763629102239">"Voorkeursnetwerkmodus: Wereldwijd"</string>
    <string name="preferred_network_mode_lte_wcdma_summary" msgid="7326137039981934928">"Voorkeursnetwerkmodus: LTE / WCDMA"</string>
    <string name="preferred_network_mode_lte_gsm_umts_summary" msgid="5105989927899481131">"Voorkeursmodus voor netwerk: LTE/GSM/UMTS"</string>
    <string name="preferred_network_mode_lte_cdma_summary" msgid="2364210682008525703">"Voorkeursnetwerkmodus: LTE/CDMA"</string>
    <string name="preferred_network_mode_tdscdma_summary" msgid="796303916110624922">"Voorkeursnetwerkmodus: TDSCDMA"</string>
    <string name="preferred_network_mode_tdscdma_wcdma_summary" msgid="1465990745594594173">"Voorkeursnetwerkmodus: TDSCDMA/WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_summary" msgid="3771917510642642724">"Voorkeursnetwerkmodus: LTE/TDSCDMA"</string>
    <string name="preferred_network_mode_tdscdma_gsm_summary" msgid="8906951876805688851">"Voorkeursnetwerkmodus: TDSCDMA/GSM"</string>
    <string name="preferred_network_mode_lte_tdscdma_gsm_summary" msgid="2264537129425897267">"Voorkeursnetwerkmodus: LTE/GSM/TDSCDMA"</string>
    <string name="preferred_network_mode_tdscdma_gsm_wcdma_summary" msgid="2469046704847661521">"Voorkeursnetwerkmodus: TDSCDMA/GSM/WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_wcdma_summary" msgid="2276439307637315057">"Voorkeursnetwerkmodus: LTE/TDSCDMA/WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_gsm_wcdma_summary" msgid="1640309016390119366">"Voorkeursnetwerkmodus: LTE/TDSCDMA/GSM/WCDMA"</string>
    <string name="preferred_network_mode_tdscdma_cdma_evdo_gsm_wcdma_summary" msgid="8918066490624875671">"Voorkeursnetwerkmodus: TDSCDMA/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_cdma_evdo_gsm_wcdma_summary" msgid="1059705864131001171">"Voorkeursnetwerkmodus: LTE/TDSCDMA/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_nr_only_summary" msgid="9153575102136218656">"Voorkeursnetwerkmodus: alleen NR"</string>
    <string name="preferred_network_mode_nr_lte_summary" msgid="4326679533556458480">"Voorkeursnetwerkmodus: NR/LTE"</string>
    <string name="preferred_network_mode_nr_lte_cdma_evdo_summary" msgid="4030662583832600005">"Voorkeursnetwerkmodus: NR/LTE/CDMA/EvDo"</string>
    <string name="preferred_network_mode_nr_lte_gsm_wcdma_summary" msgid="8327982533965785835">"Voorkeursnetwerkmodus: NR/LTE/GSM/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_cdma_evdo_gsm_wcdma_summary" msgid="7892233480076496041">"Voorkeursnetwerkmodus: NR/LTE/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_wcdma_summary" msgid="5762334298562095421">"Voorkeursnetwerkmodus: NR/LTE/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_summary" msgid="2356681171665091175">"Voorkeursnetwerkmodus: NR/LTE/TDSCDMA"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_gsm_summary" msgid="8889597344872814893">"Voorkeursnetwerkmodus: NR/LTE/TDSCDMA/GSM"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_wcdma_summary" msgid="506057560516483258">"Voorkeursnetwerkmodus: NR/LTE/TDSCDMA/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_gsm_wcdma_summary" msgid="4337061745216872524">"Voorkeursnetwerkmodus: NR/LTE/TDSCDMA/GSM/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_cdma_evdo_gsm_wcdma_summary" msgid="3396717432149544381">"Voorkeursnetwerkmodus: NR/LTE/TDSCDMA/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="network_5G_recommended" msgid="4769018972369031538">"5G (aanbevolen)"</string>
    <string name="network_lte" msgid="2449425437381668780">"LTE (aanbevolen)"</string>
    <string name="network_4G" msgid="9018841362928321047">"4G (aanbevolen)"</string>
    <string name="select_automatically" msgid="2419752566747259155">"Netwerk automatisch selecteren"</string>
    <string name="carrier_settings_title" msgid="6959295328730560529">"Providerinstellingen"</string>
    <string name="cdma_lte_data_service" msgid="6937443423651347345">"Gegevensservice instellen"</string>
    <string name="mobile_data_settings_title" msgid="3927524078598009792">"Mobiele data"</string>
    <string name="mobile_data_settings_summary" msgid="7323978798199919063">"Datatoegang via mobiel netwerk"</string>
    <string name="mobile_data_settings_summary_auto_switch" msgid="7851549787645698945">"Telefoon schakelt automatisch over naar deze provider als deze binnen bereik is"</string>
    <string name="mobile_data_settings_summary_unavailable" msgid="9176513507571883986">"Geen simkaart beschikbaar"</string>
    <string name="calls_preference" msgid="2166481296066890129">"Voorkeur voor gesprekken"</string>
    <string name="sms_preference" msgid="7742964962568219351">"Voorkeur voor sms\'jes"</string>
    <string name="calls_and_sms_ask_every_time" msgid="3178743088737726677">"Altijd vragen"</string>
    <string name="mobile_network_summary_add_a_network" msgid="9079866102827526779">"Voeg een netwerk toe"</string>
    <string name="default_for_calls" msgid="2788950217176988034">"Standaard voor gesprekken"</string>
    <string name="default_for_sms" msgid="1316988329407434771">"Standaard voor sms"</string>
    <string name="default_for_calls_and_sms" msgid="8223971369339958151">"Standaard voor gesprekken en sms"</string>
    <string name="default_for_mobile_data" msgid="3725773640392315626">"Standaard voor mobiele data"</string>
    <string name="mobile_data_active" msgid="8683694456401350210">"Mobiele data actief"</string>
    <string name="mobile_data_off" msgid="2702029611959308269">"Mobiele data uit"</string>
    <string name="subscription_available" msgid="2659722770210403365">"Beschikbaar"</string>
    <string name="mobile_network_list_add_more" msgid="5076722903436552813">"Simkaart toevoegen"</string>
    <string name="mobile_network_active_sim" msgid="6397581267971410039">"Actief/simkaart"</string>
    <string name="mobile_network_inactive_sim" msgid="5829757490580409899">"Inactief/simkaart"</string>
    <string name="mobile_network_active_esim" msgid="3984452275968408382">"Actief/e-simkaart"</string>
    <string name="mobile_network_inactive_esim" msgid="8777415108263057939">"Inactief/e-simkaart"</string>
    <string name="mobile_network_sim_name" msgid="3187192894150386537">"Naam en kleur van simkaart"</string>
    <string name="mobile_network_sim_name_label" msgid="1452440641628369625">"Naam"</string>
    <string name="mobile_network_sim_color_label" msgid="5293944087609632340">"Kleur (gebruikt door geschikte apps)"</string>
    <string name="mobile_network_sim_name_rename" msgid="5967588549571582924">"Opslaan"</string>
    <string name="mobile_network_use_sim_on" msgid="7298332437547707908">"Simkaart gebruiken"</string>
    <string name="mobile_network_use_sim_off" msgid="6303281166199670639">"Uit"</string>
    <string name="mobile_network_disable_sim_explanation" msgid="2851862257846773796">"Verwijder de simkaart om deze simkaart uit te zetten"</string>
    <string name="mobile_network_tap_to_activate" msgid="4139979375717958102">"Tik om <xliff:g id="CARRIER">%1$s</xliff:g> te activeren"</string>
    <string name="mobile_network_erase_sim" msgid="4629071168032714930">"Simkaart wissen"</string>
    <string name="preferred_network_mode_title" msgid="3083431168988535628">"Voorkeursnetwerktype"</string>
    <string name="preferred_network_mode_summary" msgid="537577807865497546">"De netwerkgebruiksmodus wijzigen"</string>
    <string name="preferred_network_mode_dialogtitle" msgid="4179420486180351631">"Voorkeursnetwerktype"</string>
    <string name="carrier_settings_version" msgid="3364919669057317776">"Versie van providerinstellingen"</string>
    <string name="call_category" msgid="641461844504128789">"Bellen"</string>
    <string name="video_calling_settings_title" msgid="5490466306783552190">"Provider videogesprekken"</string>
    <string name="cdma_system_select_title" msgid="8261408056382123386">"Systeem selecteren"</string>
    <string name="cdma_system_select_summary" msgid="384128007068464145">"De CDMA-roamingmodus wijzigen"</string>
    <string name="cdma_system_select_dialogtitle" msgid="6143586810486936984">"Systeem selecteren"</string>
    <string name="network_operator_category" msgid="5309383730335681395">"Netwerk"</string>
    <string name="cdma_subscription_title" msgid="3107207913315872336">"CDMA-abonnement"</string>
    <string name="cdma_subscription_summary" msgid="7134032708555561334">"Schakelen tussen RUIM/SIM en NV"</string>
    <string name="cdma_subscription_dialogtitle" msgid="555971296756231647">"abonnement"</string>
    <string name="register_automatically" msgid="5208258089316657167">"Automatische registratie…"</string>
    <string name="roaming_alert_title" msgid="9052791521868787985">"Dataroaming toestaan?"</string>
    <string name="roaming_check_price_warning" msgid="5876977438036791361">"Neem contact op met je netwerkprovider over de prijzen."</string>
    <string name="mobile_data_usage_title" msgid="2047864499317759728">"Datagebruik van app"</string>
    <string name="mobile_network_mode_error" msgid="9222056129897416074">"Ongeldige netwerkmodus <xliff:g id="NETWORKMODEID">%1$d</xliff:g>. Negeren."</string>
    <string name="mobile_network_apn_title" msgid="5582995550142073054">"Toegangspuntnamen"</string>
    <string name="keywords_access_point_names" msgid="8174967126858505945">"apn"</string>
    <string name="manual_mode_disallowed_summary" msgid="4243142645520152175">"Niet beschikbaar wanneer verbonden met <xliff:g id="CARRIER">%1$s</xliff:g>"</string>
    <string name="see_more" msgid="7499355691042812723">"Meer bekijken"</string>
    <string name="sim_action_enable_sub_dialog_title" msgid="4003377033815971802">"<xliff:g id="CARRIER_NAME">%1$s</xliff:g> aanzetten?"</string>
    <string name="sim_action_enable_sub_dialog_title_without_carrier_name" msgid="4842051610633654278">"Simkaart aanzetten?"</string>
    <string name="sim_action_switch_sub_dialog_title" msgid="9180969453358718635">"Overschakelen naar <xliff:g id="CARRIER_NAME">%1$s</xliff:g>?"</string>
    <string name="sim_action_switch_psim_dialog_title" msgid="5613177333235213024">"Overschakelen naar simkaart?"</string>
    <string name="sim_action_switch_sub_dialog_mep_title" msgid="933856847099933004">"<xliff:g id="CARRIER_NAME">%1$s</xliff:g> gebruiken?"</string>
    <string name="sim_action_switch_sub_dialog_text" msgid="2091834911153293004">"Er kan maar 1 simkaart tegelijk actief zijn.\n\nAls je overschakelt naar <xliff:g id="TO_CARRIER_NAME">%1$s</xliff:g>, wordt de service van <xliff:g id="FROM_CARRIER_NAME">%2$s</xliff:g> niet geannuleerd."</string>
    <string name="sim_action_switch_sub_dialog_text_downloaded" msgid="8977951796005849471">"Er kan maar 1 e-simkaart tegelijk actief zijn.\n\nAls je overschakelt naar <xliff:g id="TO_CARRIER_NAME">%1$s</xliff:g>, wordt de service van <xliff:g id="FROM_CARRIER_NAME">%2$s</xliff:g> niet opgezegd."</string>
    <string name="sim_action_switch_sub_dialog_text_single_sim" msgid="6188750682431170845">"Er kan maar 1 simkaart tegelijk actief zijn.\n\nAls je overschakelt, wordt de service van <xliff:g id="TO_CARRIER_NAME">%1$s</xliff:g> niet geannuleerd."</string>
    <string name="sim_action_switch_sub_dialog_mep_text" msgid="8348764755143679582">"Je kunt 2 simkaarten tegelijk gebruiken. Als je <xliff:g id="CARRIER_NAME">%1$s</xliff:g> wilt gebruiken, zet je de andere simkaart uit."</string>
    <string name="sim_action_switch_sub_dialog_confirm" msgid="1901181581944638961">"Overschakelen naar <xliff:g id="CARRIER_NAME">%1$s</xliff:g>"</string>
    <string name="sim_action_switch_sub_dialog_carrier_list_item_for_turning_off" msgid="5392037608705799522">"<xliff:g id="CARRIER_NAME">%1$s</xliff:g> uitzetten"</string>
    <string name="sim_action_switch_sub_dialog_info_outline_for_turning_off" msgid="1617619100229136888">"Als je een simkaart uitzet, wordt de service niet opgezegd"</string>
    <string name="sim_action_enabling_sim_without_carrier_name" msgid="2706862823501979981">"Verbinding maken met netwerk…"</string>
    <string name="sim_action_switch_sub_dialog_progress" msgid="4718412054243793310">"Overschakelen naar <xliff:g id="CARRIER_NAME">%1$s</xliff:g> voor gesprekken en berichten…"</string>
    <string name="sim_action_enable_sim_fail_title" msgid="1765646238941015899">"Kan provider niet wijzigen"</string>
    <string name="sim_action_enable_sim_fail_text" msgid="4781863235721417544">"De provider kan niet worden gewijzigd vanwege een fout."</string>
    <string name="privileged_action_disable_sub_dialog_title" msgid="3298942357601334418">"<xliff:g id="CARRIER_NAME">%1$s</xliff:g> uitzetten?"</string>
    <string name="privileged_action_disable_sub_dialog_title_without_carrier" msgid="6518373229436331608">"Simkaart uitzetten?"</string>
    <string name="privileged_action_disable_sub_dialog_progress" msgid="5900243067681478102">"Simkaart uitzetten<xliff:g id="ELLIPSIS">…</xliff:g>"</string>
    <string name="privileged_action_disable_fail_title" msgid="6689494935697043555">"Kan provider niet uitzetten"</string>
    <string name="privileged_action_disable_fail_text" msgid="8404023523406091819">"Er is iets misgegaan. Je provider kan niet worden uitgezet."</string>
    <string name="sim_action_enable_dsds_title" msgid="226508711751577169">"2 simkaarten gebruiken?"</string>
    <string name="sim_action_enable_dsds_text" msgid="970986559326263949">"Op dit apparaat kunnen 2 simkaarten tegelijk actief zijn. Tik op Nee, bedankt als je 1 simkaart wilt blijven gebruiken."</string>
    <string name="sim_action_restart_title" msgid="7054617569121993825">"Apparaat opnieuw opstarten?"</string>
    <string name="sim_action_yes" msgid="8076556020131395515">"Ja"</string>
    <string name="sim_action_reboot" msgid="3508948833333441538">"Opnieuw opstarten"</string>
    <string name="sim_action_no_thanks" msgid="435717748384544195">"Nee, bedankt"</string>
    <string name="sim_action_cancel" msgid="2668099867029610910">"Annuleren"</string>
    <string name="sim_switch_button" msgid="1405772571706095387">"Overschakelen"</string>
    <string name="dsds_activation_failure_title" msgid="4467364110584914794">"Kan simkaart niet activeren"</string>
    <string name="dsds_activation_failure_body_msg2" msgid="73044349546544410">"Probeer de simkaart weer aan te zetten. Als het probleem blijft optreden, start je het apparaat opnieuw op."</string>
    <string name="sim_setup_channel_id" msgid="8797972565087458515">"Netwerkactivering"</string>
    <string name="sim_switch_channel_id" msgid="4927038626791837861">"Wijziging van provider"</string>
    <string name="post_dsds_reboot_notification_title_with_carrier" msgid="3308827462185135307">"<xliff:g id="CARRIER_NAME">%1$s</xliff:g> is actief"</string>
    <string name="post_dsds_reboot_notification_text" msgid="7533428378211541410">"Tik om de instellingen voor de simkaart te updaten"</string>
    <string name="switch_to_removable_notification" msgid="7640342063449806296">"Overgeschakeld naar <xliff:g id="CARRIER_NAME">%1$s</xliff:g>"</string>
    <string name="switch_to_removable_notification_no_carrier_name" msgid="7384856964036215338">"Overgeschakeld naar een andere provider"</string>
    <string name="network_changed_notification_text" msgid="2407908598496951243">"Je mobiele netwerk is gewijzigd"</string>
    <string name="dsds_notification_after_suw_title" msgid="3738898232310273982">"Je andere simkaart instellen"</string>
    <string name="dsds_notification_after_suw_text" msgid="1287357774676361084">"Kies je actieve simkaart of gebruik 2 simkaarten tegelijk"</string>
    <string name="choose_sim_title" msgid="4804689675237716286">"Kies een nummer om te gebruiken"</string>
    <string name="choose_sim_text" msgid="4356662002583501647">"{count,plural, =1{Er is 1 nummer beschikbaar op dit apparaat, maar er kan er maar 1 tegelijk worden gebruikt}=2{Er zijn 2 nummers beschikbaar op dit apparaat, maar er kan maar 1 tegelijk worden gebruikt}other{Er zijn # nummers beschikbaar op dit apparaat, maar er kan maar 1 tegelijk worden gebruikt}}"</string>
    <string name="choose_sim_activating" msgid="9035902671985449448">"Activeren<xliff:g id="ELLIPSIS">…</xliff:g>"</string>
    <string name="choose_sim_could_not_activate" msgid="2154564459842291617">"Kan nu niet worden geactiveerd"</string>
    <string name="switch_sim_dialog_title" msgid="5407316878973237773">"<xliff:g id="CARRIER_NAME">%1$s</xliff:g> gebruiken?"</string>
    <string name="switch_sim_dialog_text" msgid="7530186862171635464">"<xliff:g id="CARRIER_NAME">%1$s</xliff:g> wordt gebruikt voor mobiele data, gesprekken en sms\'jes."</string>
    <string name="switch_sim_dialog_no_switch_title" msgid="809763410787744247">"Geen actieve simkaarten beschikbaar"</string>
    <string name="switch_sim_dialog_no_switch_text" msgid="7053939850026876088">"Als je mobiele data, gespreksfuncties en sms later wilt gebruiken, ga je naar de netwerkinstellingen"</string>
    <string name="sim_card_label" msgid="6263064316075963775">"Simkaart"</string>
    <string name="erase_sim_dialog_title" msgid="4742077437653028326">"Deze e-simkaart wissen?"</string>
    <string name="erase_sim_dialog_text" msgid="753031064269699885">"Als je deze simkaart wist, wordt de <xliff:g id="CARRIER_NAME_A">%1$s</xliff:g>-service van dit apparaat verwijderd.\n\nDe service voor <xliff:g id="CARRIER_NAME_B">%1$s</xliff:g> wordt niet geannuleerd."</string>
    <string name="erase_sim_confirm_button" msgid="8309115684335320541">"Wissen"</string>
    <string name="erasing_sim" msgid="7877703231075699139">"Simkaart wissen…"</string>
    <string name="erase_sim_fail_title" msgid="2024446702985862427">"Kan simkaart niet wissen"</string>
    <string name="erase_sim_fail_text" msgid="7870804401227483131">"Door een fout kan deze simkaart niet worden gewist.\n\nStart je apparaat opnieuw op en probeer het nogmaals."</string>
    <string name="network_connection_request_dialog_title" msgid="1896186380874289434">"Verbinding maken met apparaat"</string>
    <string name="network_connection_request_dialog_summary" msgid="7693038309792726170">"De app <xliff:g id="APPNAME">%1$s</xliff:g> wil een tijdelijk wifi-netwerk gebruiken om verbinding te maken met je apparaat."</string>
    <string name="network_connection_timeout_dialog_message" msgid="598509083077743772">"Geen apparaten gevonden. Zorg dat de apparaten aanstaan en verbinding kunnen maken."</string>
    <string name="network_connection_timeout_dialog_ok" msgid="6022675321823723755">"Opnieuw proberen"</string>
    <string name="network_connection_errorstate_dialog_message" msgid="3360714322047603239">"Er is een probleem opgetreden. De app heeft het verzoek om een apparaat te kiezen geannuleerd."</string>
    <string name="network_connection_connect_successful" msgid="2587314077675642476">"Verbinding gemaakt"</string>
    <string name="network_connection_connect_failure" msgid="6803313816657494319">"Verbinding mislukt"</string>
    <string name="network_connection_request_dialog_showall" msgid="6392059758456994944">"Alles tonen"</string>
    <string name="network_connection_searching_message" msgid="8521819623516926482">"Zoeken naar apparaat…"</string>
    <string name="network_connection_connecting_message" msgid="433189540877274889">"Verbinding maken met apparaat…"</string>
    <string name="bluetooth_left_name" msgid="7440064067910080502">"Links"</string>
    <string name="bluetooth_right_name" msgid="7588088072444124949">"Rechts"</string>
    <string name="bluetooth_middle_name" msgid="3909371955137442319">"Case"</string>
    <string name="settings_panel_title" msgid="346363079938069215">"Instellingenvenster"</string>
    <string name="force_desktop_mode" msgid="1336913605091334238">"Desktopmodus afdwingen"</string>
    <string name="force_desktop_mode_summary" msgid="4587416867846930479">"Dwing experimentele desktopmodus af op secundaire schermen"</string>
    <string name="enable_non_resizable_multi_window" msgid="6832903754625404477">"Apps met niet-aanpasbaar formaat aanzetten in meerdere vensters"</string>
    <string name="enable_non_resizable_multi_window_summary" msgid="3275763753261901999">"Dit staat apps met een niet-aanpasbaar formaat toe in meerdere vensters"</string>
    <string name="hwui_force_dark_title" msgid="4256904905631994219">"Gedwongen donker maken negeren"</string>
    <string name="hwui_force_dark_summary" msgid="6515748781487952769">"Overschrijft de functie voor gedwongen donker maken zodat deze altijd aanstaat"</string>
    <string name="privacy_dashboard_title" msgid="6845403825611829558">"Privacy"</string>
    <string name="privacy_dashboard_summary" msgid="5775090172422786808">"Rechten, accountactiviteit, persoonsgegevens"</string>
    <string name="privacy_controls_title" msgid="1383047169455206604">"Opties"</string>
    <string name="contextual_card_dismiss_remove" msgid="8636557343011606722">"Verwijderen"</string>
    <string name="contextual_card_dismiss_keep" msgid="440516181066490747">"Behouden"</string>
    <string name="contextual_card_dismiss_confirm_message" msgid="6434344989238055188">"Deze suggestie verwijderen?"</string>
    <string name="low_storage_summary" msgid="1979492757417779718">"Opslag is bijna vol. <xliff:g id="PERCENTAGE">%1$s</xliff:g> gebruikt - <xliff:g id="FREE_SPACE">%2$s</xliff:g> vrij"</string>
    <string name="contextual_card_feedback_send" msgid="7409408664417908922">"Feedback sturen"</string>
    <string name="contextual_card_feedback_confirm_message" msgid="3186334562157665381">"Wil je ons feedback geven over deze suggestie?"</string>
    <string name="copyable_slice_toast" msgid="1008251852798990606">"<xliff:g id="COPY_CONTENT">%1$s</xliff:g> gekopieerd naar klembord."</string>
    <string name="search_bar_account_avatar_content_description" msgid="880523277036898350"></string>
    <string name="accessibility_usage_title" msgid="9190967143518779145">"Toegankelijkheidsgebruik"</string>
    <string name="accessibility_usage_summary" msgid="4348285359995227813">"{count,plural, =1{1 app heeft volledige toegang tot je apparaat}other{# apps hebben volledige toegang tot je apparaat}}"</string>
    <string name="wfc_disclaimer_title_text" msgid="4617195934203523503">"Belangrijke informatie"</string>
    <string name="wfc_disclaimer_agree_button_text" msgid="4082872292910770344">"DOORGAAN"</string>
    <string name="wfc_disclaimer_disagree_text" msgid="8424457394700137703">"NEE, BEDANKT"</string>
    <string name="wfc_disclaimer_location_title_text" msgid="7913919887475418423">"Locatie"</string>
    <string name="wfc_disclaimer_location_desc_text" msgid="1417004513415772582">"Je provider kan je locatie verzamelen als je deze service gebruikt voor noodoproepen.\n\nLees het Privacybeleid van je provider voor meer informatie."</string>
    <string name="forget_passpoint_dialog_message" msgid="2433875063907365760">"Je hebt mogelijk geen toegang meer tot resterende tijd of gegevens. Neem contact op met je provider voordat je doorgaat met verwijderen."</string>
    <string name="content_capture" msgid="868372905432812238">"App-content"</string>
    <string name="content_capture_summary" msgid="49720773699715531">"Sta toe dat apps content naar het Android-systeem sturen"</string>
    <string name="capture_system_heap_dump_title" msgid="9210974110606886455">"Heap dump van systeem vastleggen"</string>
    <string name="development_memtag_page_title" msgid="3546667618748029188">"Memory Tagging Extension"</string>
    <string name="development_memtag_intro" msgid="8032596625527637164">"Memory Tagging Extension (MTE) maakt het makkelijker om problemen met geheugenbeveiliging in je app te vinden en de native code daarin beter te beveiligen."</string>
    <string name="development_memtag_footer" msgid="5681925148773626562">"Als je MTE aanzet, kan je apparaat langzamer worden."</string>
    <string name="development_memtag_learn_more" msgid="8961984806973926704">"Meer informatie over MTE"</string>
    <string name="development_memtag_toggle" msgid="2474420239518386894">"MTE aanzetten totdat je dit uitzet"</string>
    <string name="development_memtag_reboot_message_on" msgid="8100075676107327847">"Je moet je apparaat opnieuw opstarten om MTE aan te zetten."</string>
    <string name="development_memtag_reboot_message_off" msgid="3703925647922079456">"Je moet je apparaat opnieuw opstarten om MTE uit te zetten."</string>
    <string name="reboot_with_mte_title" msgid="2320125810211279">"MTE aanzetten voor een eenmalige sessie"</string>
    <string name="reboot_with_mte_message" msgid="1232881567956207641">"Het systeem start opnieuw op, zodat je kunt experimenteren met de Memory Tagging Extension (MTE). MTE kan een negatieve invloed hebben op de prestaties en stabiliteit van het systeem. Wordt gereset bij de volgende keer opnieuw opstarten."</string>
    <string name="reboot_with_mte_summary" msgid="3896537791216432882">"Start opnieuw op voor een eenmalige sessie waarbij MTE aanstaat"</string>
    <string name="reboot_with_mte_already_enabled" msgid="4439168867613407167">"MTE staat al aan"</string>
    <string name="capturing_system_heap_dump_message" msgid="8410503247477360622">"Heap dump van systeem vastleggen"</string>
    <string name="error_capturing_system_heap_dump_message" msgid="2352983250048200052">"Kan heap dump van systeem niet vastleggen"</string>
    <string name="automatic_system_heap_dump_title" msgid="4093306504711109479">"Heap dumps van systeem automatisch vastleggen"</string>
    <string name="automatic_system_heap_dump_summary" msgid="4060846186592886986">"Automatisch een heap dump vastleggen voor het Android-systeem wanneer het te veel geheugen gebruikt"</string>
    <string name="wifi_disconnect_button_text" msgid="5698154296678571998">"Verbinding verbreken"</string>
    <string name="wfc_disclaimer_emergency_limitation_title_text" msgid="8276287227589397162">"Noodoproepen"</string>
    <string name="wfc_disclaimer_emergency_limitation_desc_text" msgid="5503902001191552196">"Noodoproepen via wifi worden niet ondersteund door je provider.\nHet apparaat schakelt automatisch over naar een mobiel netwerk om een noodoproep te plaatsen.\nNoodoproepen zijn alleen mogelijk in gebieden met mobiele dekking."</string>
    <string name="wifi_calling_summary" msgid="8566648389959032967">"Wifi gebruiken voor gesprekken om de kwaliteit te verbeteren"</string>
    <string name="backup_calling_settings_title" msgid="519714752900364326">"Reserveoptie voor bellen"</string>
    <string name="backup_calling_setting_summary" msgid="599493254305348733">"Als <xliff:g id="BACKUP_CALLING_OPERATOR_TEXT">%1$s</xliff:g> niet beschikbaar is of roaming actief is, kun je bellen via <xliff:g id="BACKUP_CALLING_CARRIER_TEXT">%1$s</xliff:g> met je simkaart voor mobiele data."</string>
    <string name="keywords_backup_calling" msgid="8592800915478816800">"reserveoptie voor bellen"</string>
    <string name="enable_receiving_mms_notification_title" msgid="6465218559386990248">"Inkomende mms"</string>
    <string name="enable_sending_mms_notification_title" msgid="7120641300854953375">"Kan mms niet verzenden"</string>
    <string name="enable_mms_notification_summary" msgid="6432752438276672500">"Tik om mms-berichten via <xliff:g id="OPERATOR_NAME">%1$s</xliff:g> toe te staan als mobiele data uitstaan"</string>
    <string name="enable_mms_notification_channel_title" msgid="1798206332620642108">"Mms"</string>
    <string name="sim_combination_warning_notification_title" msgid="1365401631492986487">"Problemen met sim-combinatie"</string>
    <string name="dual_cdma_sim_warning_notification_summary" msgid="2826474790710586487">"Als je <xliff:g id="OPERATOR_NAMES">%1$s</xliff:g> gebruikt, kan de functionaliteit worden beperkt. Tik voor meer informatie."</string>
    <string name="dual_cdma_sim_warning_notification_channel_title" msgid="1049161096896074364">"Sim-combinatie"</string>
    <string name="work_policy_privacy_settings" msgid="2702644843505242596">"Informatie over je werkbeleid"</string>
    <string name="work_policy_privacy_settings_summary" msgid="690118670737638405">"Instellingen beheerd door je IT-beheerder"</string>
    <string name="track_frame_time_keywords" msgid="7885340257945922239">"GPU"</string>
    <string name="bug_report_handler_title" msgid="713439959113250125">"App voor verwerking bugrapport"</string>
    <string name="bug_report_handler_picker_footer_text" msgid="4935758328366585673">"Hierdoor wordt bepaald welke app de snelkoppeling voor het bugrapport verwerkt op je apparaat."</string>
    <string name="personal_profile_app_subtext" msgid="5586060806997067676">"Privé"</string>
    <string name="work_profile_app_subtext" msgid="5043419461440127879">"Werk"</string>
    <string name="system_default_app_subtext" msgid="5212055189703164839">"Systeemstandaard"</string>
    <string name="default_app_none" msgid="5420632042222036264">"Geen"</string>
    <string name="select_invalid_bug_report_handler_toast_text" msgid="8857326334015386692">"Deze keuze is niet meer geldig. Probeer het opnieuw."</string>
    <string name="power_menu_setting_name" msgid="2394440932633137229">"Aan/uit-knop ingedrukt houden"</string>
    <string name="power_menu_long_press_category_title" msgid="1051146091093775002">"Aan/uit-knop ingedrukt houden voor toegang tot"</string>
    <string name="power_menu_long_press_for_power_menu_title" msgid="477584639843663599">"Aan/uit-menu"</string>
    <string name="power_menu_long_press_for_assistant_title" msgid="6557738348262616455">"Digitale assistent"</string>
    <string name="power_menu_summary_long_press_for_assistant" msgid="32706459458422952">"Digitale assistent openen"</string>
    <string name="power_menu_summary_long_press_for_power_menu" msgid="7617247135239683710">"Aan/uit-menu openen"</string>
    <string name="lockscreen_privacy_not_secure" msgid="3251276389681975912">"Stel voor gebruik eerst een schermvergrendeling in"</string>
    <string name="power_menu_power_volume_up_hint" msgid="5619917593676125759">"Aan/uit-menu:\nDruk tegelijkertijd op de aan/uit-knop en de knop Volume omhoog"</string>
    <string name="power_menu_power_prevent_ringing_hint" msgid="1169955014711158873">"Ringtone uitzetten:\nDruk op een volumeknop voor de sneltoets"</string>
    <string name="power_menu_long_press_for_assist_sensitivity_title" msgid="1626808509158422185">"Duur van ingedrukt houden"</string>
    <string name="power_menu_long_press_for_assist_sensitivity_summary" msgid="7550610071666801935">"Pas de gevoeligheid aan door te kiezen hoelang je de aan/uit-knop ingedrukt moet houden"</string>
    <string name="power_menu_long_press_for_assist_sensitivity_low_label" msgid="3430099983480845635">"Kort"</string>
    <string name="power_menu_long_press_for_assist_sensitivity_high_label" msgid="2059686170350829156">"Lang"</string>
    <string name="lockscreen_privacy_wallet_setting_toggle" msgid="4188327143734192000">"Wallet tonen"</string>
    <string name="lockscreen_privacy_wallet_summary" msgid="3984851951621168573">"Sta toegang tot Wallet toe vanaf vergrendelscherm"</string>
    <string name="lockscreen_privacy_qr_code_scanner_setting_toggle" msgid="1856477548806618829">"QR-codescanner tonen"</string>
    <string name="lockscreen_privacy_qr_code_scanner_summary" msgid="4577409244972250235">"Toegang tot QR-codescanner toestaan vanaf vergrendelscherm"</string>
    <string name="lockscreen_privacy_controls_setting_toggle" msgid="7445725343949588613">"Apparaatbediening tonen"</string>
    <string name="lockscreen_privacy_controls_summary" msgid="7522918441738915364">"Vanuit het vergrendelscherm"</string>
    <string name="lockscreen_trivial_controls_setting_toggle" msgid="2174300719855112358">"Apparaatbediening gebruiken"</string>
    <string name="lockscreen_trivial_disabled_controls_summary" msgid="7593626010580689155">"Als je dit wilt gebruiken, zet je eerst Apparaatbediening tonen aan"</string>
    <string name="lockscreen_double_line_clock_summary" msgid="2916159550425093703">"Klok met 2 regels laten zien als die beschikbaar is"</string>
    <string name="lockscreen_double_line_clock_setting_toggle" msgid="3408639316001688529">"Klok met 2 regels"</string>
    <string name="lockscreen_quick_affordances_title" msgid="8615741551327565793">"Snelkoppelingen"</string>
    <plurals name="lockscreen_quick_affordances_summary" formatted="false" msgid="4225396036524703997">
      <item quantity="other"><xliff:g id="FIRST_1">%1$s</xliff:g>, <xliff:g id="SECOND">%2$s</xliff:g></item>
      <item quantity="one"><xliff:g id="FIRST_0">%1$s</xliff:g></item>
    </plurals>
    <string name="rtt_settings_title" msgid="7049259598645966354"></string>
    <string name="rtt_settings_no_visible" msgid="7440356831140948382"></string>
    <string name="rtt_settings_visible_during_call" msgid="7866181103286073700"></string>
    <string name="rtt_settings_always_visible" msgid="2364173070088756238"></string>
    <string name="volte_5G_limited_title" msgid="5908052268836750629">"VoLTE uitzetten?"</string>
    <string name="volte_5G_limited_text" msgid="7150583768725182345">"Hiermee wordt ook de 5G-verbinding uitgezet.\nTijdens een audiogesprek kun je internet niet gebruiken en werken bepaalde apps mogelijk niet."</string>
    <string name="cached_apps_freezer" msgid="1057519579761550350">"Uitvoering opschorten voor gecachte apps"</string>
    <string name="blob_never_expires_text" msgid="7293376386620106623">"Verloopt nooit."</string>
    <string name="accessor_never_expires_text" msgid="4647624492147788340">"Toegangsperiode verloopt nooit."</string>
    <string name="overlay_settings_title" msgid="1032863083496396365">"Schermoverlays toestaan voor Instellingen"</string>
    <string name="overlay_settings_summary" msgid="2745336273786148166">"Sta toe dat apps met schermoverlay vóór instellingsschermen worden getoond"</string>
    <string name="allow_mock_modem" msgid="3832264806530479214">"Nepmodem toestaan"</string>
    <string name="allow_mock_modem_summary" msgid="9097416612748005374">"Sta toe dat dit apparaat de nepmodemservice uitvoert voor instrumentatietests. Zet dit niet aan tijdens normaal gebruik van de telefoon"</string>
    <string name="media_controls_title" msgid="403271085636252597">"Media"</string>
    <string name="media_controls_resume_title" msgid="855076860336652370">"Mediaspeler vastzetten"</string>
    <string name="media_controls_resume_description" msgid="3163482266454802097">"De mediaspeler blijft open staan in Snelle instellingen, zodat je snel kunt verdergaan met afspelen"</string>
    <string name="media_controls_lockscreen_title" msgid="2188311721857512510">"Media tonen op vergrendelscherm"</string>
    <string name="media_controls_lockscreen_description" msgid="3320333660404439510">"De mediaspeler blijft open staan op het vergrendelscherm, zodat je snel kunt doorgaan met afspelen"</string>
    <string name="media_controls_recommendations_title" msgid="184225835236807677">"Media-aanbevelingen laten zien"</string>
    <string name="media_controls_recommendations_description" msgid="7596498733126824030">"Op basis van je activiteit"</string>
    <string name="media_controls_hide_player" msgid="2751439192580884015">"Speler verbergen"</string>
    <string name="media_controls_show_player" msgid="8504571042365814021">"Toon speler"</string>
    <string name="keywords_media_controls" msgid="8345490568291778638">"media"</string>
    <string name="connected_device_see_all_summary" msgid="2056010318537268108">"Bluetooth wordt aangezet"</string>
    <string name="provider_internet_settings" msgid="3831259474776313323">"Internet"</string>
    <string name="provider_network_settings_title" msgid="2624756136016346774">"Simkaarten"</string>
    <string name="calls_and_sms" msgid="1931855083959003306">"Gesprekken en sms\'jes"</string>
    <string name="calls_and_sms_category" msgid="3788238090898237767">"Bellen via wifi"</string>
    <string name="calls_sms_wfc_summary" msgid="3940529919408667336">"Bellen en gebeld worden via wifi"</string>
    <string name="calls_preference_title" msgid="7536882032182563800">"Gesprekken"</string>
    <string name="sms_preference_title" msgid="8392745501754864395">"Sms"</string>
    <string name="calls_sms_preferred" msgid="6016477652522583496">"voorkeur"</string>
    <string name="calls_sms_calls_preferred" msgid="9004261125829377885">"voorkeur voor bellen"</string>
    <string name="calls_sms_sms_preferred" msgid="3855778890660922711">"voorkeur voor sms\'en"</string>
    <string name="calls_sms_unavailable" msgid="4055729705246556529">"niet beschikbaar"</string>
    <string name="calls_sms_temp_unavailable" msgid="8602291749338757424">"Tijdelijk niet beschikbaar"</string>
    <string name="calls_sms_no_sim" msgid="2336377399761819718">"Geen simkaart"</string>
    <string name="network_and_internet_preferences_title" msgid="8635896466814033405">"Netwerkvoorkeuren"</string>
    <string name="keywords_internet" msgid="7674082764898690310">"netwerkverbinding, internet, draadloos, data, wifi, wi-fi, wi fi, mobiel, mobiele provider, 4g, 3g, 2g, lte"</string>
    <string name="reset_your_internet_title" msgid="4856899004343241310">"Wil je je internet resetten?"</string>
    <string name="resetting_internet_text" msgid="6696779371800051806">"Je internet resetten…"</string>
    <string name="fix_connectivity" msgid="2781433603228089501">"Connectiviteitsproblemen oplossen"</string>
    <string name="networks_available" msgid="3299512933684383474">"Netwerken beschikbaar"</string>
    <string name="to_switch_networks_disconnect_ethernet" msgid="6615374552827587197">"Verbreek de ethernetverbinding om van netwerk te wisselen"</string>
    <string name="carrier_wifi_offload_title" msgid="7263365988016247722">"W+ verbindingen"</string>
    <string name="carrier_wifi_offload_summary" msgid="2980563718888371142">"Toestaan dat Google Fi W+ netwerken gebruikt om de snelheid en dekking te verbeteren"</string>
    <string name="carrier_wifi_network_title" msgid="5461382943873831770">"W+ netwerk"</string>
    <string name="sim_category_title" msgid="2341314000964710495">"Simkaart"</string>
    <string name="downloaded_sim_category_title" msgid="2876988650413179752">"E-simkaart"</string>
    <string name="downloaded_sims_category_title" msgid="487799905978489922">"E-simkaarten"</string>
    <string name="sim_category_active_sim" msgid="1503823567818544012">"Actief"</string>
    <string name="sim_category_inactive_sim" msgid="4068899490133820881">"Inactief"</string>
    <string name="sim_category_default_active_sim" msgid="1208194173387987231">" / Standaard voor <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="default_active_sim_calls" msgid="2390973682556353558">"gesprekken"</string>
    <string name="default_active_sim_sms" msgid="8041498593025994921">"sms"</string>
    <string name="default_active_sim_mobile_data" msgid="6798083892814045301">"mobiele data"</string>
    <string name="wifi_scan_notify_message" msgid="1331238142061476869">"Om de apparaatfunctionaliteit te verbeteren, kunnen apps en services nog steeds op elk moment scannen op wifi-netwerken, zelfs als wifi uitstaat. Dit kan worden gebruikt om bijvoorbeeld locatiegebaseerde functies en services te verbeteren. Je kunt dit wijzigen in de instellingen voor wifi-scannen."</string>
    <string name="wifi_scan_change" msgid="8438320311511852918">"Wijzigen"</string>
    <string name="preference_summary_default_combination" msgid="4643585915107796253">"<xliff:g id="STATE">%1$s</xliff:g>: <xliff:g id="NETWORKMODE">%2$s</xliff:g>"</string>
    <string name="mobile_data_connection_active" msgid="2422223108911581552">"Verbonden"</string>
    <string name="mobile_data_temp_connection_active" msgid="3430470299756236413">"Tijdelijk verbonden"</string>
    <string name="mobile_data_temp_using" msgid="5211002380149434155">"<xliff:g id="SUBNAME">%1$s</xliff:g> wordt tijdelijk gebruikt"</string>
    <string name="mobile_data_no_connection" msgid="905897142426974030">"Geen verbinding"</string>
    <string name="mobile_data_off_summary" msgid="1884248776904165539">"Mobiele data maakt niet automatisch verbinding"</string>
    <string name="mobile_data_disable_title" msgid="8438714772256088913">"Mobiele data uitzetten?"</string>
    <string name="mobile_data_disable_message" msgid="7829414836454769970">"Je hebt dan geen toegang meer tot data of internet via <xliff:g id="CARRIER">%s</xliff:g>. Internet is alleen nog beschikbaar via wifi."</string>
    <string name="mobile_data_disable_message_default_carrier" msgid="4449469407705838612">"je provider"</string>
    <string name="not_allowed_by_ent" msgid="1958611623122304411">"Niet toegestaan door je organisatie"</string>
    <string name="aware_summary_when_bedtime_on" msgid="2063856008597376344">"Niet beschikbaar omdat de bedtijdstand aanstaat"</string>
    <string name="reset_importance_completed" msgid="3595536767426097205">"Belang van meldingen is gereset."</string>
    <string name="apps_dashboard_title" msgid="3269953499954393706">"Apps"</string>
    <string name="bluetooth_message_access_notification_content" msgid="5111712860712823893">"Een apparaat wil toegang tot je berichten. Tik voor details."</string>
    <string name="bluetooth_message_access_dialog_title" msgid="9009836130395061579">"Toegang tot berichten toestaan?"</string>
    <string name="bluetooth_message_access_dialog_content" msgid="7186694737578788487">"Een bluetooth-apparaat (<xliff:g id="DEVICE_NAME_0">%1$s</xliff:g>) wil toegang tot je berichten.\n\nJe hebt niet eerder verbinding gemaakt met <xliff:g id="DEVICE_NAME_1">%2$s</xliff:g>."</string>
    <string name="bluetooth_phonebook_access_notification_content" msgid="9175220052703433637">"Een apparaat wil toegang tot je contacten en gesprekslijst. Tik voor details."</string>
    <string name="bluetooth_phonebook_access_dialog_title" msgid="7624607995928968721">"Toegang tot contacten en gesprekslijst toestaan?"</string>
    <string name="bluetooth_phonebook_access_dialog_content" msgid="959658135522249170">"Een bluetooth-apparaat (<xliff:g id="DEVICE_NAME_0">%1$s</xliff:g>) wil toegang tot je contacten en gesprekslijst. Dit omvat gegevens over inkomende en uitgaande gesprekken.\n\nJe hebt niet eerder verbinding gemaakt met <xliff:g id="DEVICE_NAME_1">%2$s</xliff:g>."</string>
    <string name="category_name_brightness" msgid="8520372392029305084">"Helderheid"</string>
    <string name="category_name_lock_display" msgid="8310402558217129670">"Schermvergrendeling"</string>
    <string name="category_name_appearance" msgid="8287486771764166805">"Weergave"</string>
    <string name="category_name_color" msgid="937514550918977151">"Kleur"</string>
    <string name="category_name_display_controls" msgid="7046581691184725216">"Andere bedieningsopties voor weergave"</string>
    <string name="category_name_general" msgid="7737273712848115886">"Algemeen"</string>
    <string name="dark_theme_main_switch_title" msgid="4045147031947562280">"Donker thema gebruiken"</string>
    <string name="bluetooth_main_switch_title" msgid="8409835540311309632">"Bluetooth gebruiken"</string>
    <string name="prevent_ringing_main_switch_title" msgid="4726252811262086643">"Ringtone uitzetten gebruiken"</string>
    <string name="use_wifi_hotsopt_main_switch_title" msgid="3909731167290690539">"Wifi-hotspot gebruiken"</string>
    <string name="app_pinning_main_switch_title" msgid="5465506660064032876">"App vastzetten gebruiken"</string>
    <string name="developer_options_main_switch_title" msgid="1720074589554152501">"Ontwikkelaarsopties gebruiken"</string>
    <string name="default_print_service_main_switch_title" msgid="4697133737128324036">"Afdrukservice gebruiken"</string>
    <string name="multiple_users_main_switch_title" msgid="6686858308083037810">"Meerdere gebruikers toestaan"</string>
    <string name="multiple_users_main_switch_keywords" msgid="4845954458094134356">"toestaan, meerdere, gebruiker, toestemming, veel"</string>
    <string name="wireless_debugging_main_switch_title" msgid="8463499572781441719">"Draadloze foutopsporing gebruiken"</string>
    <string name="graphics_driver_main_switch_title" msgid="6125172901855813790">"Voorkeuren voor grafisch stuurprogramma gebruiken"</string>
    <string name="night_light_main_switch_title" msgid="3428298022467805219">"Nachtverlichting gebruiken"</string>
    <string name="nfc_main_switch_title" msgid="6295839988954817432">"NFC gebruiken"</string>
    <string name="adaptive_brightness_main_switch_title" msgid="2681666805191642737">"Aanpasbare helderheid gebruiken"</string>
    <string name="wifi_calling_main_switch_title" msgid="4070224008346815634">"Bellen via wifi gebruiken"</string>
    <string name="default_see_all_apps_title" msgid="7481113230662612178">"Alle apps bekijken"</string>
    <string name="smart_forwarding_title" msgid="8368634861971949799">"Slim doorschakelen"</string>
    <string name="smart_forwarding_summary_enabled" msgid="3341062878373185604">"Slim doorschakelen staat aan"</string>
    <string name="smart_forwarding_summary_disabled" msgid="5033880700091914809">"Slim doorschakelen staat uit"</string>
    <string name="smart_forwarding_ongoing_title" msgid="962226849074401228">"Gespreksinstellingen"</string>
    <string name="smart_forwarding_ongoing_text" msgid="2189209372407117114">"Instellingen updaten..."</string>
    <string name="smart_forwarding_failed_title" msgid="1859891191023516080">"Fout met gespreksinstellingen"</string>
    <string name="smart_forwarding_failed_text" msgid="8682640643264071789">"Netwerk- of simkaartfout."</string>
    <string name="smart_forwarding_failed_not_activated_text" msgid="997396203001257904">"Simkaart is niet geactiveerd."</string>
    <string name="smart_forwarding_input_mdn_title" msgid="5105463748849841763">"Telefoonnummers opgeven"</string>
    <string name="smart_forwarding_input_mdn_dialog_title" msgid="7542216086697868415">"Telefoonnummer opgeven"</string>
    <string name="smart_forwarding_missing_mdn_text" msgid="2907314684242542226">"Telefoonnummer ontbreekt."</string>
    <string name="smart_forwarding_missing_alert_dialog_text" msgid="7870419247987316112">"OK"</string>
    <string name="enable_2g_title" msgid="8184757884636162942">"2G toestaan"</string>
    <string name="enable_2g_summary" msgid="2794534052372565914">"2G is minder veilig, maar kan op bepaalde locaties zorgen voor een betere verbinding. Voor noodoproepen is 2G altijd toegestaan."</string>
    <string name="enable_2g_summary_disabled_carrier" msgid="8141118453219482762">"<xliff:g id="CARRIER_NAME_2G">%1$s</xliff:g> vereist dat 2G beschikbaar is"</string>
    <string name="require_cellular_encryption_title" msgid="7516008146269371585">"Versleuteling vereisen"</string>
    <string name="require_cellular_encryption_summary" msgid="4813823321032908641">"Versleuteling is veiliger, maar op sommige locaties kun je misschien geen verbinding maken. Voor noodoproepen is nooit versleuteling vereist."</string>
    <string name="app_info_all_services_label" msgid="1487070364839071105">"Alle services"</string>
    <string name="show_clip_access_notification" msgid="7782300987639778542">"Toegang tot klembord tonen"</string>
    <string name="show_clip_access_notification_summary" msgid="474090757777203207">"Toon een bericht als apps toegang hebben tot tekst, afbeeldingen of andere content die je hebt gekopieerd"</string>
    <string name="all_apps" msgid="3054120149509114789">"Alle apps"</string>
    <string name="request_manage_bluetooth_permission_dont_allow" msgid="8798061333407581300">"Niet toestaan"</string>
    <string name="uwb_settings_title" msgid="8578498712312002231">"Ultra-WideBand (UWB)"</string>
    <string name="uwb_settings_summary" msgid="3074271396764672268">"Helpt bij het identificeren van de relatieve positie van apparaten in de buurt die UWB hebben"</string>
    <string name="uwb_settings_summary_airplane_mode" msgid="1328864888135086484">"Zet de vliegtuigmodus uit om UWB te gebruiken"</string>
    <string name="uwb_settings_summary_no_uwb_regulatory" msgid="3465456428217979428">"UWB is niet beschikbaar op je huidige locatie"</string>
    <string name="camera_toggle_title" msgid="8952668677727244992">"Cameratoegang"</string>
    <string name="mic_toggle_title" msgid="265145278323852547">"Microfoontoegang"</string>
    <string name="perm_toggle_description" msgid="5754629581767319022">"Voor apps en services"</string>
    <string name="mic_toggle_description" msgid="484139688645092237">"Voor apps en services. Als deze instelling uitstaat, kunnen microfoongegevens nog altijd worden gedeeld als je een alarmnummer belt."</string>
    <string name="previous_page_content_description" msgid="6438292457923282991">"Vorige"</string>
    <string name="next_page_content_description" msgid="1641835099813416294">"Volgende"</string>
    <string name="colors_viewpager_content_description" msgid="2591751086138259565">"Kleurvoorbeeld"</string>
    <string name="bluetooth_sim_card_access_notification_title" msgid="7351015416346359536">"Toegangsverzoek voor simkaart"</string>
    <string name="bluetooth_sim_card_access_notification_content" msgid="8685623260103018309">"Een apparaat wil toegang tot je simkaart. Tik voor details."</string>
    <string name="bluetooth_sim_card_access_dialog_title" msgid="5616323725563125179">"Toegang geven tot simkaart?"</string>
    <string name="bluetooth_sim_card_access_dialog_content" msgid="6281997628405909566">"Een bluetooth-apparaat (<xliff:g id="DEVICE_NAME_0">%1$s</xliff:g>) wil toegang tot gegevens op je simkaart. Dit zijn onder andere je contacten.\n\nTerwijl <xliff:g id="DEVICE_NAME_1">%2$s</xliff:g> is verbonden, ontvangt dit apparaat alle gesprekken naar <xliff:g id="PHONE_NUMBER">%3$s</xliff:g>."</string>
    <string name="bluetooth_connect_access_notification_title" msgid="2573547043170883947">"Bluetooth-apparaat beschikbaar"</string>
    <string name="bluetooth_connect_access_notification_content" msgid="1328465545685433304">"Een apparaat wil verbinding maken. Tik voor informatie."</string>
    <string name="bluetooth_connect_access_dialog_title" msgid="1948056782712451381">"Verbinding maken met bluetooth-apparaat?"</string>
    <string name="bluetooth_connect_access_dialog_content" msgid="4336436466468405850">"<xliff:g id="DEVICE_NAME_0">%1$s</xliff:g> wil verbinding maken met deze telefoon.\n\nJe hebt nog niet eerder verbinding gemaakt met <xliff:g id="DEVICE_NAME_1">%2$s</xliff:g>."</string>
    <string name="bluetooth_connect_access_dialog_negative" msgid="4944672755226375059">"Geen verbinding maken"</string>
    <string name="bluetooth_connect_access_dialog_positive" msgid="3630561675207269710">"Verbinding maken"</string>
    <string name="tare_settings" msgid="3788654800004869077">"TARE-instellingen"</string>
    <string name="tare_on" msgid="2386073225978684535">"Aan"</string>
    <string name="tare_off" msgid="6305694402929756726">"Uit"</string>
    <string name="tare_revert" msgid="3855325741125236638">"Standaardinstellingen herstellen"</string>
    <string name="tare_settings_reverted_toast" msgid="8189887409285176731">"Standaardinstellingen hersteld."</string>
    <string name="tare_max_satiated_balance" msgid="3914973999573150340">"Maximale balans als volledig opgeladen"</string>
    <string name="tare_balances" msgid="731881382594747961">"Saldo\'s"</string>
    <string name="tare_consumption_limits" msgid="3230949387874396382">"Verbruikslimieten"</string>
    <string name="tare_initial_consumption_limit" msgid="2921646306374048384">"Initiële verbruikslimiet"</string>
    <string name="tare_min_consumption_limit" msgid="3293145670921755789">"Minimale verbruikslimiet"</string>
    <string name="tare_max_consumption_limit" msgid="8335700580111808823">"Maximale verbruikslimiet"</string>
    <string name="tare_modifiers" msgid="8919975635360280820">"Modifiers"</string>
    <string name="tare_actions_ctp" msgid="5110104015354916401">"Acties (productiekosten)"</string>
    <string name="tare_actions_base_price" msgid="3300967942666376589">"Acties (basisprijs)"</string>
    <string name="tare_rewards_instantaneous" msgid="8358683519945340874">"Beloningen per afzonderlijk evenement"</string>
    <string name="tare_rewards_ongoing" msgid="7657030286658143416">"Beloningen per seconde van gebeurtenisduur"</string>
    <string name="tare_rewards_max" msgid="5283055625642837010">"Maximumaantal beloningen per dag"</string>
    <string name="tare_app_install" msgid="7955806910408116882">"App-installatie"</string>
    <string name="tare_top_activity" msgid="7266560655483385757">"Topactiviteit"</string>
    <string name="tare_notification_seen" msgid="7829963536020087742">"Melding gezien"</string>
    <string name="tare_notification_seen_15_min" msgid="832174185809497764">"Melding gezien binnen 15 minuten"</string>
    <string name="tare_notification_interaction" msgid="3806204222322830129">"Meldingsinteractie"</string>
    <string name="tare_widget_interaction" msgid="2260701564089214184">"Widgetinteractie"</string>
    <string name="tare_other_interaction" msgid="8069163421115212751">"Andere gebruikersinteractie"</string>
    <string name="tare_job_max_start" msgid="1586399578665940836">"Starten: taak (maximale prioriteit)"</string>
    <string name="tare_job_max_running" msgid="2897217372986518495">"Actief: taak (maximale prioriteit)"</string>
    <string name="tare_job_high_start" msgid="7464143754932031022">"Starten: taak (hoge prioriteit)"</string>
    <string name="tare_job_high_running" msgid="6541171046405088669">"Actief: taak (hoge prioriteit)"</string>
    <string name="tare_job_default_start" msgid="6744427210148953151">"Starten: taak (standaardprioriteit)"</string>
    <string name="tare_job_default_running" msgid="8429081804128945217">"Actief: taak (standaardprioriteit)"</string>
    <string name="tare_job_low_start" msgid="4605440035856891746">"Starten: taak (lage prioriteit)"</string>
    <string name="tare_job_low_running" msgid="831668616902849604">"Actief: taak (lage prioriteit)"</string>
    <string name="tare_job_min_start" msgid="6508233901992538188">"Starten: taak (minimale prioriteit)"</string>
    <string name="tare_job_min_running" msgid="6167128996320622604">"Actief: taak (minimale prioriteit)"</string>
    <string name="tare_job_timeout_penalty" msgid="7644332836795492506">"Time-outpenalty voor taak"</string>
    <string name="tare_min_balance_exempted" msgid="6693710075762973485">"Minimaal verzadigd saldo (vrijgesteld)"</string>
    <string name="tare_min_balance_headless_app" msgid="6906353766678577244">"Minimaal verzadigd saldo (systeem-app zonder interface)"</string>
    <string name="tare_min_balance_other_app" msgid="3404774196832506476">"Minimaal verzadigd saldo (resterende apps)"</string>
    <string name="tare_min_balance_addition_app_updater" msgid="5391956072471201269">"Aanvulling voor minimaal verzadigd saldo (app-updaters)"</string>
  <string-array name="tare_modifiers_subfactors">
    <item msgid="3325940509857535498">"Opladen"</item>
    <item msgid="658627268149681677">"Sluimeren"</item>
    <item msgid="1599558140284643834">"Energiebesparingsmodus"</item>
    <item msgid="588427840913221601">"Processtatus"</item>
  </string-array>
    <string name="tare_dialog_confirm_button_title" msgid="9179397559760203348">"Bevestigen"</string>
    <string name="dream_preview_button_title" msgid="6637456541851795952">"Voorbeeld"</string>
    <string name="dream_picker_category" msgid="7726447836872744867">"Screensaver kiezen"</string>
    <string name="dream_complications_toggle_title" msgid="4273232303027449163">"Extra informatie tonen"</string>
    <string name="dream_complications_toggle_summary" msgid="8088911054987524904">"Laat bijvoorbeeld de tijd, het weer of andere informatie op de screensaver zien"</string>
    <string name="dream_home_controls_toggle_title" msgid="706799741564479248">"Bediening voor in huis tonen"</string>
    <string name="dream_home_controls_toggle_summary" msgid="4102519907917430579">"Knop voor bediening voor in huis tonen op de screensaver"</string>
    <string name="dream_more_settings_category" msgid="3119192146760773748">"Meer instellingen"</string>
    <string name="dream_setup_title" msgid="2458303874255396142">"Je screensaver kiezen"</string>
    <string name="dream_setup_description" msgid="7508547154038580296">"Kies wat je ziet op je scherm als je tablet is gedockt. Je apparaat kan meer energie gebruiken als er een screensaver wordt gebruikt."</string>
    <string name="customize_button_title" msgid="1110284655990203359">"Aanpassen"</string>
    <string name="customize_button_description" msgid="7440248477266126231">"<xliff:g id="SCREENSAVER_NAME">%1$s</xliff:g> aanpassen"</string>
    <string name="reboot_dialog_enable_freeform_support" msgid="6412591361284929149">"Je moet opnieuw opstarten om ondersteuning voor vrije vorm aan te zetten."</string>
    <string name="reboot_dialog_force_desktop_mode" msgid="2021839270403432948">"Je moet opnieuw opstarten om de desktopmodus af te dwingen op secundaire schermen."</string>
    <string name="reboot_dialog_reboot_now" msgid="235616015988522355">"Nu opnieuw opstarten"</string>
    <string name="reboot_dialog_reboot_later" msgid="4261717094186904568">"Later opnieuw opstarten"</string>
    <string name="bluetooth_details_spatial_audio_title" msgid="1368071116994002707">"Ruimtelijke audio"</string>
    <string name="bluetooth_details_spatial_audio_summary" msgid="5026859623681482668">"Compatibele media leveren een royaler geluid"</string>
    <string name="bluetooth_details_head_tracking_title" msgid="5416972521040337799">"Bewegingen van het hoofd volgen"</string>
    <string name="bluetooth_details_head_tracking_summary" msgid="3942238746595985395">"De audio wordt aangepast als je je hoofd beweegt, voor een natuurlijker geluid"</string>
    <string name="ingress_rate_limit_title" msgid="2106694002836274350">"Limiet voor downloadsnelheid van netwerk"</string>
    <string name="ingress_rate_limit_summary" msgid="1097811019742438371">"Stel een limiet in voor inkomend verkeer voor de netwerkbandbreedte. Deze wordt toegepast op alle netwerken die internetconnectiviteit bieden"</string>
    <string name="ingress_rate_limit_dialog_title" msgid="5359461052422633789">"Limiet voor downloadsnelheid van netwerk instellen"</string>
    <string name="ingress_rate_limit_no_limit_entry" msgid="8741098826008012163">"Geen limiet"</string>
    <string name="disable_phantom_process_monitor_title" msgid="8348108346706188771">"Beperkingen voor onderliggende processen uitzetten"</string>
    <string name="disable_phantom_process_monitor_summary" msgid="3044464635550256985">"Zet beperkingen voor het gebruik van systeembronnen voor onderliggende app-processen uit"</string>
    <string name="enable_notes_role_title" msgid="7662702013496114763">"Aanzetten van de rol Notities afdwingen"</string>
    <string name="enable_notes_role_summary" msgid="136916915155048249">"Zet systeemintegraties voor notities maken aan via de rol Notities. Als de rol Notities al aanstaat, gebeurt er niets."</string>
    <string name="bluetooth_broadcast_dialog_title" msgid="9172775308463135884">"Uitzenden"</string>
    <string name="bluetooth_broadcast_dialog_broadcast_app" msgid="1016617579194329005">"<xliff:g id="CURRENTAPP">%1$s</xliff:g> uitzenden"</string>
    <string name="bluetooth_broadcast_dialog_find_message" msgid="6621660851669953883">"Luister naar uitzendingen die bij je in de buurt worden afgespeeld"</string>
    <string name="bluetooth_broadcast_dialog_broadcast_message" msgid="6198264676009094495">"Zend media uit naar apparaten in de buurt of luister naar iemands uitzending"</string>
    <string name="bluetooth_find_broadcast_title" msgid="5385985218699831970">"Uitzendingen"</string>
    <string name="bluetooth_find_broadcast_summary" msgid="3907899428626210673">"Luisteren naar"</string>
    <string name="bluetooth_find_broadcast" msgid="1768337775649457586">"Uitzendingen vinden"</string>
    <string name="bluetooth_find_broadcast_button_leave" msgid="7881206581147104908">"Uitzending verlaten"</string>
    <string name="bluetooth_find_broadcast_button_scan" msgid="3995664694641895189">"QR-code scannen"</string>
    <string name="find_broadcast_password_dialog_title" msgid="3176988702535737484">"Wachtwoord opgeven"</string>
    <string name="find_broadcast_password_dialog_connection_error" msgid="47873617983439400">"Kan geen verbinding maken. Probeer het opnieuw."</string>
    <string name="find_broadcast_password_dialog_password_error" msgid="243855327674765">"Onjuist wachtwoord"</string>
    <string name="find_broadcast_join_broadcast_error" msgid="5486980388774711346">"Kan niet deelnemen aan de transmissie"</string>
    <string name="bt_le_audio_scan_qr_code_scanner" msgid="7614569515419813053">"Centreer de onderstaande QR-code om te beginnen met luisteren"</string>
    <string name="bt_le_audio_qr_code_is_not_valid_format" msgid="7821837654128137901">"QR-code heeft geen geldige indeling"</string>
    <string name="convert_to_esim_title" msgid="71037864129009206">"Converteren naar e-simkaart"</string>
    <string name="transfer_esim_to_another_device_title" msgid="5286117866086383192">"E-simkaart overzetten naar ander apparaat"</string>
    <string name="background_install_preference_summary" msgid="3065219346519340364">"{count,plural, =1{# app}other{# apps}}"</string>
    <string name="background_install_title" msgid="607913515188276168">"Apps op de achtergrond geïnstalleerd"</string>
    <string name="background_install_summary" msgid="3890296129543309666">"De apparaatfabrikant kan op de achtergrond apps installeren op je apparaat of toestaan dat je provider en andere partners dat doen.\n\nApps die hier worden vermeld, zijn niet vereist voor een normale werking van je apparaat. Je kunt apps verwijderen die je niet wilt hebben."</string>
    <string name="background_install_feature_list_no_entry" msgid="2071343281272266154">"Geen apps op de achtergrond geïnstalleerd"</string>
    <string name="background_install_uninstall_button_description" msgid="1189649052911501249">"App verwijderen"</string>
    <string name="background_install_before" msgid="8608614957688912715">"{count,plural, =1{Apps in de afgelopen # maand geïnstalleerd}other{Apps in de afgelopen # maanden geïnstalleerd}}"</string>
    <string name="background_install_after" msgid="7983488897570908149">"{count,plural, =1{Apps meer dan # maand geleden geïnstalleerd}other{Apps meer dan # maanden geleden geïnstalleerd}}"</string>
    <string name="accessibility_fingerprint_label" msgid="5017431423168191733">"Vingerafdruksensor"</string>
    <string name="flash_notifications_title" msgid="4490438861180492311">"Meldingen met flits"</string>
    <string name="flash_notifications_about_title" msgid="9004351252928121214">"Over meldingen met flits"</string>
    <string name="flash_notifications_summary_off" msgid="6056282996770691461">"Uit"</string>
    <string name="flash_notifications_summary_on_camera" msgid="3286405833586333730">"Aan: cameraflits"</string>
    <string name="flash_notifications_summary_on_screen" msgid="9040640799633336219">"Aan: schermflits"</string>
    <string name="flash_notifications_summary_on_camera_and_screen" msgid="2326268141063768701">"Aan: camera- en schermflits"</string>
    <string name="flash_notifications_intro" msgid="8409873413480928249">"Laat het cameralampje of het scherm flitsen als je meldingen krijgt of als er alarmen afgaan"</string>
    <string name="flash_notifications_intro_without_camera_flash" msgid="6297337174487793891">"Laat het scherm flitsen als je meldingen krijgt of als er alarmen klinken"</string>
    <string name="flash_notifications_note" msgid="2426125248448055075">"Wees voorzichtig met het gebruik van meldingen met flits als je gevoelig bent voor licht"</string>
    <string name="flash_notifications_keywords" msgid="2458759275318514836">"flitsen, licht, slechthorend, gehoorverlies"</string>
    <string name="flash_notifications_preview" msgid="5320176885050440874">"Voorbeeld"</string>
    <string name="camera_flash_notification_title" msgid="2475084876382922732">"Cameraflits"</string>
    <string name="screen_flash_notification_title" msgid="3773100725793316708">"Schermflits"</string>
    <string name="screen_flash_notification_color_title" msgid="7213407653340970790">"Kleur van schermflits"</string>
    <string name="screen_flash_color_blue" msgid="3585766657607931371">"Blauw"</string>
    <string name="screen_flash_color_azure" msgid="8691198532944992243">"Azuur"</string>
    <string name="screen_flash_color_cyan" msgid="6878780006173747267">"Cyaan"</string>
    <string name="screen_flash_color_spring_green" msgid="4466548514738457815">"Lentegroen"</string>
    <string name="screen_flash_color_green" msgid="8418019648507964564">"Groen"</string>
    <string name="screen_flash_color_chartreuse_green" msgid="7456381649919010366">"Grijsgroen"</string>
    <string name="screen_flash_color_yellow" msgid="7413465411615454556">"Geel"</string>
    <string name="screen_flash_color_orange" msgid="979177126315557656">"Oranje"</string>
    <string name="screen_flash_color_red" msgid="8954162219886445491">"Rood"</string>
    <string name="screen_flash_color_rose" msgid="1216848195972231251">"Roze"</string>
    <string name="screen_flash_color_magenta" msgid="7726221666557102155">"Magenta"</string>
    <string name="screen_flash_color_violet" msgid="1279950780509029495">"Violet"</string>
    <string name="color_selector_dialog_done" msgid="121253968943363376">"Klaar"</string>
    <string name="color_selector_dialog_cancel" msgid="8667350644753900701">"Annuleren"</string>
    <string name="contrast_title" msgid="6885768151336508075">"Contrast"</string>
    <string name="contrast_standard" msgid="1097297089917185235">"Standaard"</string>
    <string name="contrast_medium" msgid="384414510709285811">"Gemiddeld"</string>
    <string name="contrast_high" msgid="3988567609694797696">"Hoog"</string>
    <string name="dock_multi_instances_not_supported_text" msgid="3513493664467667084">"Deze app kan maar in 1 venster worden geopend"</string>
    <!-- no translation found for accessibility_feature_full_state_summary (8747170258807179670) -->
    <skip />
    <!-- no translation found for generic_accessibility_service_on (2465820044606775562) -->
    <skip />
    <!-- no translation found for generic_accessibility_service_off (1752061696695346360) -->
    <skip />
    <!-- no translation found for generic_accessibility_feature_shortcut_off (3669343136122187913) -->
    <skip />
    <!-- no translation found for accessibility_shortcut_state_off (8158137799007601475) -->
    <skip />
    <!-- no translation found for daltonizer_state_on (131013270022603983) -->
    <skip />
    <!-- no translation found for daltonizer_state_off (1162285688069856179) -->
    <skip />
    <!-- no translation found for color_inversion_state_on (1160969033636440368) -->
    <skip />
    <!-- no translation found for color_inversion_state_off (6925638668080451724) -->
    <skip />
    <!-- no translation found for color_inversion_feature_summary (1199876648549627647) -->
    <skip />
    <!-- no translation found for magnification_feature_summary (641825267460247848) -->
    <skip />
    <!-- no translation found for autoclick_disabled (3213396804955002120) -->
    <skip />
    <!-- no translation found for show_captions_disabled (690650956523818755) -->
    <skip />
    <!-- no translation found for show_captions_enabled (7089043007924626) -->
    <skip />
    <!-- no translation found for live_caption_disabled (3562035026547887366) -->
    <skip />
    <!-- no translation found for live_caption_enabled (5269360946200718949) -->
    <skip />
</resources>
