<?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="4676390750360727396">"Oui"</string>
    <string name="no" msgid="6731231425810196216">"Non"</string>
    <string name="create" msgid="3578857613172647409">"Créer"</string>
    <string name="allow" msgid="3349662621170855910">"Autoriser"</string>
    <string name="deny" msgid="6947806159746484865">"Refuser"</string>
    <string name="device_info_default" msgid="7847265875578739287">"Inconnu"</string>
    <plurals name="show_dev_countdown" formatted="false" msgid="7201398282729229649">
      <item quantity="one">Plus qu’<xliff:g id="STEP_COUNT_1">%1$d</xliff:g> étape pour devenir un développeur.</item>
      <item quantity="other">Plus que <xliff:g id="STEP_COUNT_1">%1$d</xliff:g> étapes pour devenir un développeur.</item>
    </plurals>
    <string name="show_dev_on" msgid="1110711554982716293">"Vous êtes désormais un développeur!"</string>
    <string name="show_dev_already" msgid="2151632240145446227">"Inutile, vous êtes déjà un concepteur."</string>
    <string name="dev_settings_disabled_warning" msgid="4909448907673974370">"Veuillez d\'abord activer les options pour les concepteurs"</string>
    <string name="header_category_wireless_networks" msgid="5110914332313954940">"Sans fil et réseaux"</string>
    <string name="header_category_system" msgid="2816866961183068977">"Système"</string>
    <string name="radio_info_data_connection_enable" msgid="8656750679353982712">"Activer la connexion de données"</string>
    <string name="radio_info_data_connection_disable" msgid="8541302390883231216">"Désactiver la connexion de données"</string>
    <string name="volte_provisioned_switch_string" msgid="7979882929810283786">"Indicateur de configuration VoLTE activé"</string>
    <string name="vt_provisioned_switch_string" msgid="7876998291744854759">"Appel vidéo géré"</string>
    <string name="wfc_provisioned_switch_string" msgid="3985406545172898078">"Appel Wi-Fi géré"</string>
    <string name="eab_provisioned_switch_string" msgid="3482272907448592975">"Configuration EAB/Présence effectuée"</string>
    <string name="cbrs_data_switch_string" msgid="2811485394350106691">"Données CBRS"</string>
    <string name="dsds_switch_string" msgid="4832797810509029243">"Activer DSDS"</string>
    <string name="dsds_dialog_title" msgid="4031918551366689574">"Redémarrer l\'appareil?"</string>
    <string name="dsds_dialog_message" msgid="8593083316067158412">"Vous devez redémarrer votre appareil pour modifier ce paramètre."</string>
    <string name="dsds_dialog_confirm" msgid="2853118984344309612">"Redémarrer"</string>
    <string name="dsds_dialog_cancel" msgid="654653450305828711">"Annuler"</string>
    <string name="radio_info_radio_power" msgid="7187666084867419643">"Alimentation de radio cellulaire"</string>
    <string name="radioInfo_menu_viewADN" msgid="7069468158519465139">"Afficher le carnet d\'adresses de la carte SIM"</string>
    <string name="radioInfo_menu_viewFDN" msgid="7934301566925610318">"Afficher les numéros autorisés"</string>
    <string name="radioInfo_menu_viewSDN" msgid="7130280686244955669">"Afficher les numéros de service"</string>
    <string name="radioInfo_menu_getIMS" msgid="185171476413967831">"État du service IMS"</string>
    <string name="radio_info_ims_reg_status_title" msgid="16971785902696970">"État IMS"</string>
    <string name="radio_info_ims_reg_status_registered" msgid="5614116179751126247">"Enregistré"</string>
    <string name="radio_info_ims_reg_status_not_registered" msgid="4438054067642750717">"Non enregistré"</string>
    <string name="radio_info_ims_feature_status_available" msgid="3687807290327566879">"Accessible"</string>
    <string name="radio_info_ims_feature_status_unavailable" msgid="4606182208970114368">"Non accessible"</string>
    <string name="radio_info_ims_reg_status" msgid="7534612158445529715">"Enregistrement IMS : <xliff:g id="STATUS">%1$s</xliff:g>\nVoix sur LTE : <xliff:g id="AVAILABILITY_0">%2$s</xliff:g>\nVoix sur Wi-Fi : <xliff:g id="AVAILABILITY_1">%3$s</xliff:g>\nAppels vidéo : <xliff:g id="AVAILABILITY_2">%4$s</xliff:g>\nInterface UT : <xliff:g id="AVAILABILITY_3">%5$s</xliff:g>"</string>
    <string name="radioInfo_service_in" msgid="1697703164394784618">"En service"</string>
    <string name="radioInfo_service_out" msgid="7999094221728929681">"Hors service"</string>
    <string name="radioInfo_service_emergency" msgid="6274434235469661525">"Appels d\'urgence seulement"</string>
    <string name="radioInfo_service_off" msgid="7536423790014501173">"Signal radio désactivé"</string>
    <string name="radioInfo_roaming_in" msgid="9045363884600341051">"Itinérance"</string>
    <string name="radioInfo_roaming_not" msgid="4849214885629672819">"Pas en itinérance"</string>
    <string name="radioInfo_phone_idle" msgid="7489244938838742820">"Absent(e)"</string>
    <string name="radioInfo_phone_ringing" msgid="4883724645684297895">"Sonnerie"</string>
    <string name="radioInfo_phone_offhook" msgid="5873835692449118954">"Appel en cours"</string>
    <string name="radioInfo_data_disconnected" msgid="1959735267890719418">"Déconnecté"</string>
    <string name="radioInfo_data_connecting" msgid="8404571440697917823">"Connexion en cours…"</string>
    <string name="radioInfo_data_connected" msgid="7074301157399238697">"Connecté"</string>
    <string name="radioInfo_data_suspended" msgid="5315325487890334196">"Suspendu"</string>
    <string name="radioInfo_unknown" msgid="1476509178755955088">"Inconnu"</string>
    <string name="radioInfo_display_packets" msgid="8654359809877290639">"paquets"</string>
    <string name="radioInfo_display_bytes" msgid="4018206969492931883">"octets"</string>
    <string name="radioInfo_display_dbm" msgid="3621221793699882781">"dBm"</string>
    <string name="radioInfo_display_asu" msgid="1422248392727818082">"asu"</string>
    <string name="radioInfo_lac" msgid="8415219164758307156">"LAC"</string>
    <string name="radioInfo_cid" msgid="4362599198392643138">"CID ou IDC"</string>
    <string name="sdcard_unmount" product="nosdcard" msgid="6325292633327972272">"Désinstaller la mémoire de stockage USB"</string>
    <string name="sdcard_unmount" product="default" msgid="3364184561355611897">"Désinstaller la carte SD"</string>
    <string name="sdcard_format" product="nosdcard" msgid="6285310523155166716">"Effacer la mémoire de stockage USB"</string>
    <string name="sdcard_format" product="default" msgid="6713185532039187532">"Effacer la carte SD"</string>
    <string name="preview_pager_content_description" msgid="8926235999291761243">"Aperçu"</string>
    <string name="preview_page_indicator_content_description" msgid="4821343428913401264">"Aperçu : page <xliff:g id="CURRENT_PAGE">%1$d</xliff:g> sur <xliff:g id="NUM_PAGES">%2$d</xliff:g>"</string>
    <string name="font_size_summary" msgid="1690992332887488183">"Agrandissez ou réduisez le texte affiché."</string>
    <string name="font_size_make_smaller_desc" msgid="7919995133365371569">"Rapetisser"</string>
    <string name="font_size_make_larger_desc" msgid="4316986572233686061">"Agrandir"</string>
    <!-- no translation found for font_size_preview_text (4818424565068376732) -->
    <skip />
    <string name="font_size_preview_text_headline" msgid="7955317408475392247">"Exemple de texte"</string>
    <string name="font_size_preview_text_title" msgid="1310536233106975546">"Le Magicien d\'Oz"</string>
    <string name="font_size_preview_text_subtitle" msgid="4231671528173110093">"Chapitre 11 : La merveilleuse cité d\'émeraude d\'Oz"</string>
    <string name="font_size_preview_text_body" msgid="2846183528684496723">"Malgré leurs lunettes vertes, Dorothée et ses amis furent d’abord éblouis par l\'éclat de la cité merveilleuse. Les rues étaient bordées de maisons splendides, toutes faites de marbre vert et incrustées d\'étincelantes émeraudes. Ils marchaient sur une chaussée ornée du même marbre, et la jointure des dalles était sertie de rangs serrés d\'émeraudes qui resplendissaient sous le soleil. Les panneaux de verre des fenêtres étaient verts, le ciel au-dessus de la cité avait une teinte verte, et le soleil lui-même lançait des rayons verts. \n\nBeaucoup de gens déambulaient dans les rues, hommes, femmes et enfants. Tous étaient vêtus de vert et avaient un teint verdâtre. Étonnés, ils dévisageaient Dorothée et son étrange escorte. Les enfants couraient se cacher derrière leurs mères à la vue du lion, mais personne ne leur adressait la parole. Il y avait de nombreuses boutiques et Dorothée remarqua que tout y était vert à l\'intérieur. Tout ce qu\'on y vendait était vert : les bonbons et le maïs éclaté, les chaussures, les chapeaux et les vêtements. Dans un magasin, un homme vendait de la limonade verte, et Dorothée vit que les enfants payaient avec des sous verts. \n\nIl semblait n\'y avoir ni chevaux ni animaux d\'aucune espèce; les hommes transportaient diverses choses dans de petites charrettes vertes, qu\'ils poussaient devant eux. Tout le monde avait un air heureux et satisfait, et tous les habitants semblaient prospères."</string>
    <string name="font_size_save" msgid="3450855718056759095">"OK"</string>
    <string name="sdcard_setting" product="nosdcard" msgid="8281011784066476192">"Mémoire de stockage USB"</string>
    <string name="sdcard_setting" product="default" msgid="5922637503871474866">"Carte SD"</string>
    <string name="bluetooth" msgid="5549625000628014477">"Bluetooth"</string>
    <string name="bluetooth_is_discoverable" msgid="8373421452106840526">"Identifiable par tous appareils Bluetooth à proximité (<xliff:g id="DISCOVERABLE_TIME_PERIOD">%1$s</xliff:g>)"</string>
    <string name="bluetooth_is_discoverable_always" msgid="2849387702249327748">"Identifiable par appareils Bluetooth à proximité"</string>
    <string name="bluetooth_not_visible_to_other_devices" msgid="9120274591523391910">"Non identifiable par d\'autres appareils Bluetooth"</string>
    <string name="bluetooth_only_visible_to_paired_devices" msgid="2049983392373296028">"Identifiable uniquement par les appareils associés"</string>
    <string name="bluetooth_visibility_timeout" msgid="8002247464357005429">"Délai de visibilité"</string>
    <string name="bluetooth_lock_voice_dialing" msgid="3139322992062086225">"Bloquer les appels par reconnaissance vocale"</string>
    <string name="bluetooth_lock_voice_dialing_summary" msgid="4741338867496787042">"Désactiver les appels via Bluetooth lorsque l\'écran est verrouillé"</string>
    <string name="bluetooth_devices" msgid="1886018064039454227">"Appareils Bluetooth"</string>
    <string name="bluetooth_device_name" msgid="8415828355207423800">"Nom de l\'appareil"</string>
    <string name="bluetooth_device_details" msgid="4594773497930028085">"Paramètres de l\'appareil"</string>
    <string name="bluetooth_profile_details" msgid="6823621790324933337">"Paramètres du profil"</string>
    <string name="bluetooth_name_not_set" msgid="2653752006416027426">"Aucun nom n\'a été défini. Utilisation du nom du compte..."</string>
    <string name="bluetooth_scan_for_devices" msgid="9214184305566815727">"Recherche d\'appareils"</string>
    <string name="bluetooth_rename_device" msgid="4352483834491958740">"Renommer cet appareil"</string>
    <string name="bluetooth_rename_button" msgid="1648028693822994566">"Renommer"</string>
    <string name="bluetooth_disconnect_title" msgid="7830252930348734303">"Déconnecter l\'appareil?"</string>
    <string name="bluetooth_disconnect_all_profiles" product="default" msgid="8208712728668714199">"Votre téléphone se déconnectera de <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="bluetooth_disconnect_all_profiles" product="tablet" msgid="6611038575213485336">"Votre tablette se déconnectera de <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="bluetooth_disconnect_all_profiles" product="device" msgid="3995834526315103965">"Votre appareil se déconnectera de <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="bluetooth_disconnect_dialog_ok" msgid="3308586619539119106">"Déconnecter"</string>
    <string name="bluetooth_empty_list_user_restricted" msgid="603521233563983689">"Vous n\'êtes pas autorisé à modifier les paramètres Bluetooth."</string>
    <string name="bluetooth_pairing_pref_title" msgid="7429413067477968637">"Associer un appareil"</string>
    <string name="bluetooth_is_visible_message" msgid="6222396240776971862">"Lorsque le Bluetooth est activé, votre <xliff:g id="DEVICE_NAME">%1$s</xliff:g> est visible par les appareils à proximité."</string>
    <string name="bluetooth_footer_mac_message" product="default" msgid="1109366350000220283">"Adresse Bluetooth du téléphone : <xliff:g id="BLUETOOTH_MAC_ADDRESS">%1$s</xliff:g>"</string>
    <string name="bluetooth_footer_mac_message" product="tablet" msgid="6807634484499166486">"Adresse Bluetooth de la tablette : <xliff:g id="BLUETOOTH_MAC_ADDRESS">%1$s</xliff:g>"</string>
    <string name="bluetooth_footer_mac_message" product="device" msgid="8413944740341742061">"Adresse Bluetooth de l\'appareil : <xliff:g id="BLUETOOTH_MAC_ADDRESS">%1$s</xliff:g>"</string>
    <string name="bluetooth_is_disconnect_question" msgid="5334933802445256306">"Déconnecter <xliff:g id="DEVICE_NAME">%1$s</xliff:g>?"</string>
    <string name="bluetooth_broadcasting" msgid="16583128958125247">"Diffusion"</string>
    <string name="bluetooth_device" msgid="5291950341750186887">"Appareil Bluetooth sans nom"</string>
    <string name="progress_scanning" msgid="192587958424295789">"Recherche en cours…"</string>
    <string name="bluetooth_no_devices_found" msgid="1085232930277181436">"Aucun appareil Bluetooth détecté."</string>
    <string name="bluetooth_notif_ticker" msgid="4726721390078512173">"Demande d\'association Bluetooth"</string>
    <string name="bluetooth_notif_title" msgid="2485175521845371514">"Demande d\'association"</string>
    <string name="bluetooth_notif_message" msgid="5057417127600942904">"Touchez pour associer à <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="bluetooth_show_received_files" msgid="3144149432555230410">"Fichiers reçus"</string>
    <string name="bluetooth_show_files_received_via_bluetooth" msgid="5445105773989432594">"Fichiers reçus par Bluetooth"</string>
    <string name="device_picker" msgid="4978696506172252813">"Sélectionner un appareil Bluetooth"</string>
    <string name="bluetooth_ask_enablement" msgid="3387222809404177525">"<xliff:g id="APP_NAME">%1$s</xliff:g> souhaite activer le Bluetooth"</string>
    <string name="bluetooth_ask_disablement" msgid="5890386255790160573">"<xliff:g id="APP_NAME">%1$s</xliff:g> souhaite désactiver le Bluetooth"</string>
    <string name="bluetooth_ask_enablement_no_name" msgid="1644353686104482763">"Une application souhaite activer le Bluetooth."</string>
    <string name="bluetooth_ask_disablement_no_name" msgid="9218830122674868548">"Une application souhaite désactiver le Bluetooth"</string>
    <string name="bluetooth_ask_discovery" product="tablet" msgid="4791779658660357386">"<xliff:g id="APP_NAME">%1$s</xliff:g> souhaite rendre votre tablette visible à d\'autres appareils Bluetooth pendant <xliff:g id="TIMEOUT">%2$d</xliff:g> secondes."</string>
    <string name="bluetooth_ask_discovery" product="default" msgid="1308225382575535366">"<xliff:g id="APP_NAME">%1$s</xliff:g> souhaite rendre votre téléphone visible à d\'autres appareils Bluetooth pendant <xliff:g id="TIMEOUT">%2$d</xliff:g> secondes."</string>
    <string name="bluetooth_ask_discovery_no_name" product="tablet" msgid="225715443477752935">"Une application souhaite rendre votre tablette visible à d\'autres appareils Bluetooth pendant <xliff:g id="TIMEOUT">%1$d</xliff:g> secondes."</string>
    <string name="bluetooth_ask_discovery_no_name" product="default" msgid="4949152735544109994">"Une application souhaite rendre votre téléphone visible à d\'autres appareils Bluetooth pendant <xliff:g id="TIMEOUT">%1$d</xliff:g> secondes."</string>
    <string name="bluetooth_ask_lasting_discovery" product="tablet" msgid="8528329166577187961">"<xliff:g id="APP_NAME">%1$s</xliff:g> souhaite rendre votre tablette visible à d\'autres appareils Bluetooth. Vous pouvez modifier ce réglage plus tard dans les paramètres Bluetooth."</string>
    <string name="bluetooth_ask_lasting_discovery" product="default" msgid="4398738575307583138">"<xliff:g id="APP_NAME">%1$s</xliff:g> souhaite rendre votre téléphone visible à d\'autres appareils Bluetooth. Vous pouvez modifier ce paramètres plus tard dans les paramètres Bluetooth."</string>
    <string name="bluetooth_ask_lasting_discovery_no_name" product="tablet" msgid="1702590641426207062">"Une application souhaite rendre votre tablette visible à d\'autres appareils Bluetooth. Vous pouvez modifier ce réglage plus tard dans les paramètres Bluetooth."</string>
    <string name="bluetooth_ask_lasting_discovery_no_name" product="default" msgid="8549952177383992238">"Une application souhaite rendre votre téléphone visible à d\'autres appareils Bluetooth. Vous pouvez modifier ce réglage plus tard dans les paramètres Bluetooth."</string>
    <string name="bluetooth_ask_enablement_and_discovery" product="tablet" msgid="1141843490422565755">"<xliff:g id="APP_NAME">%1$s</xliff:g> souhaite activer le Bluetooth et rendre votre tablette visible à d\'autres appareils pendant <xliff:g id="TIMEOUT">%2$d</xliff:g> secondes."</string>
    <string name="bluetooth_ask_enablement_and_discovery" product="default" msgid="5195836980079191473">"<xliff:g id="APP_NAME">%1$s</xliff:g> souhaite activer le Bluetooth et rendre votre téléphone visible à d\'autres appareils pendant <xliff:g id="TIMEOUT">%2$d</xliff:g> secondes."</string>
    <string name="bluetooth_ask_enablement_and_discovery_no_name" product="tablet" msgid="7009338445281693765">"Une application souhaite activer le Bluetooth et rendre votre tablette visible à d\'autres appareils pendant <xliff:g id="TIMEOUT">%1$d</xliff:g> secondes."</string>
    <string name="bluetooth_ask_enablement_and_discovery_no_name" product="default" msgid="8386904242279878734">"Une application souhaite activer le Bluetooth et rendre votre téléphone visible à d\'autres appareils pendant <xliff:g id="TIMEOUT">%1$d</xliff:g> secondes."</string>
    <string name="bluetooth_ask_enablement_and_lasting_discovery" product="tablet" msgid="2279471426575892686">"<xliff:g id="APP_NAME">%1$s</xliff:g> souhaite activer le Bluetooth et rendre votre tablette visible à d\'autres appareils. Vous pouvez modifier ce réglage plus tard dans les paramètres Bluetooth."</string>
    <string name="bluetooth_ask_enablement_and_lasting_discovery" product="default" msgid="6961969825475461450">"<xliff:g id="APP_NAME">%1$s</xliff:g> souhaite activer le Bluetooth et rendre votre téléphone visible à d\'autres appareils. Vous pouvez modifier ce réglage plus tard dans les paramètres Bluetooth."</string>
    <string name="bluetooth_ask_enablement_and_lasting_discovery_no_name" product="tablet" msgid="692477613671555006">"Une application souhaite activer le Bluetooth et rendre votre tablette visible à d\'autres appareils. Vous pouvez modifier ce réglage plus tard dans les paramètres Bluetooth."</string>
    <string name="bluetooth_ask_enablement_and_lasting_discovery_no_name" product="default" msgid="6374480121751597648">"Une application souhaite activer le Bluetooth et rendre votre téléphone visible à d\'autres appareils. Vous pouvez modifier ce réglage plus tard dans les paramètres Bluetooth."</string>
    <string name="bluetooth_turning_on" msgid="4850574877288036646">"Activation du Bluetooth..."</string>
    <string name="bluetooth_turning_off" msgid="2337747302892025192">"Désactivation du Bluetooth..."</string>
    <string name="bluetooth_connection_permission_request" msgid="4747918249032890077">"Demande de connexion Bluetooth"</string>
    <string name="bluetooth_connection_notif_message" msgid="3603316575471431846">"Touchez ici pour vous connecter à « <xliff:g id="DEVICE_NAME">%1$s</xliff:g> »."</string>
    <string name="bluetooth_connection_dialog_text" msgid="8455427559949998023">"Voulez-vous vous connecter à « <xliff:g id="DEVICE_NAME">%1$s</xliff:g> »?"</string>
    <string name="bluetooth_phonebook_request" msgid="3951420080540915279">"Demande d\'accès au répertoire téléphonique"</string>
    <string name="bluetooth_pb_acceptance_dialog_text" msgid="8930347091018455505">"<xliff:g id="DEVICE_NAME_0">%1$s</xliff:g> demande l\'accès à vos contacts et à l\'historique de vos appels. Autoriser l\'accès à <xliff:g id="DEVICE_NAME_1">%2$s</xliff:g>?"</string>
    <string name="bluetooth_remember_choice" msgid="6919682671787049800">"Ne plus me demander"</string>
    <string name="bluetooth_pb_remember_choice" msgid="3622898084442402071">"Ne plus me demander"</string>
    <string name="bluetooth_map_request" msgid="4595727689513143902">"Demande d\'accès aux messages"</string>
    <string name="bluetooth_map_acceptance_dialog_text" msgid="8712508202081143737">"%1$s souhaite accéder à vos messages. Autoriser l\'accès à %2$s?"</string>
    <string name="bluetooth_sap_request" msgid="2669762224045354417">"Demande d\'accès à la carte SIM"</string>
    <string name="bluetooth_sap_acceptance_dialog_text" msgid="4414253873553608690">"<xliff:g id="DEVICE_NAME_0">%1$s</xliff:g> souhaite accéder à votre carte SIM. Le fait d\'accorder l\'accès à la carte SIM désactive la connectivité de données sur votre appareil pendant la durée de la connexion. Accorder l\'accès à <xliff:g id="DEVICE_NAME_1">%2$s?</xliff:g>."</string>
    <string name="bluetooth_device_name_summary" msgid="522235742194965734">"Visible comme « <xliff:g id="DEVICE_NAME">^1</xliff:g> » aux autres appareils"</string>
    <string name="bluetooth_off_footer" msgid="8406865700572772936">"Activez le Bluetooth pour vous connecter à d\'autres appareils."</string>
    <string name="bluetooth_paired_device_title" msgid="8638994696317952019">"Vos appareils"</string>
    <string name="bluetooth_pairing_page_title" msgid="7712127387361962608">"Associer un appareil"</string>
    <string name="bluetooth_pref_summary" product="tablet" msgid="3520035819421024105">"Permettre à votre tablette de communiquer avec les appareils Bluetooth à proximité"</string>
    <string name="bluetooth_pref_summary" product="device" msgid="2205100629387332862">"Permettre à votre appareil de communiquer avec les appareils Bluetooth à proximité"</string>
    <string name="bluetooth_pref_summary" product="default" msgid="782032074675157079">"Permettre à votre téléphone de communiquer avec les appareils Bluetooth à proximité"</string>
    <string name="bluetooth_disable_a2dp_hw_offload" msgid="4936610906348223810">"Désactiver déchargement Bluetooth A2DP"</string>
    <string name="bluetooth_disable_a2dp_hw_offload_dialog_title" msgid="4340101417209145308">"Redémarrer l\'appareil?"</string>
    <string name="bluetooth_disable_a2dp_hw_offload_dialog_message" msgid="8827019472003234568">"Vous devez redémarrer votre appareil pour modifier ce param."</string>
    <string name="bluetooth_disable_a2dp_hw_offload_dialog_confirm" msgid="2053793518537051975">"Redémarrer"</string>
    <string name="bluetooth_disable_a2dp_hw_offload_dialog_cancel" msgid="2382443064737856652">"Annuler"</string>
    <string name="connected_device_available_media_title" msgid="2560067541413280645">"Appareils multimédias disponibles"</string>
    <string name="connected_device_available_call_title" msgid="697154660967595684">"Appareils d\'appels accessibles"</string>
    <string name="connected_device_connected_title" msgid="5871712271201945606">"Actuellement connecté"</string>
    <string name="connected_device_saved_title" msgid="688364359746674536">"Appareils enregistrés"</string>
    <string name="connected_device_add_device_summary" msgid="4041865900298680338">"Le Bluetooth s\'activera pour l\'association"</string>
    <string name="connected_device_connections_title" msgid="5988939345181466770">"Préférences de connexion"</string>
    <string name="connected_device_previously_connected_title" msgid="491765792822244604">"Appareils précédemment connectés"</string>
    <string name="connected_device_previously_connected_screen_title" msgid="6196066429488377795">"Connecté précedemment"</string>
    <string name="connected_device_bluetooth_turned_on_toast" msgid="5683648191381637533">"Bluetooth activé"</string>
    <string name="previous_connected_see_all" msgid="3626779872898778415">"Tout afficher"</string>
    <string name="date_and_time" msgid="9062980487860757694">"Date et heure"</string>
    <string name="choose_timezone" msgid="1362834506479536274">"Sélectionner le fuseau horaire"</string>
    <!-- no translation found for intent_sender_data_label (6332324780477289261) -->
    <skip />
    <string name="intent_sender_sendbroadcast_text" msgid="1415735148895872715">"Envoyer <xliff:g id="BROADCAST">broadcast</xliff:g>"</string>
    <string name="intent_sender_action_label" msgid="616458370005452389">"<xliff:g id="ACTION">Action</xliff:g> :"</string>
    <string name="intent_sender_startactivity_text" msgid="5080516029580421895">"Démarrer <xliff:g id="ACTIVITY">activity</xliff:g>"</string>
    <string name="intent_sender_resource_label" msgid="6963659726895482829">"<xliff:g id="RESOURCE">Resource</xliff:g> :"</string>
    <string name="intent_sender_account_label" msgid="465210404475603404">"COMPTE"</string>
    <string name="proxy_settings_title" msgid="9049437837600320881">"Serveur mandataire"</string>
    <string name="proxy_clear_text" msgid="5555400754952012657">"Effacer"</string>
    <string name="proxy_port_label" msgid="5655276502233453400">"Port du serveur mandataire"</string>
    <string name="proxy_exclusionlist_label" msgid="7700491504623418701">"Ignorer le serveur mandataire pour"</string>
    <string name="proxy_defaultView_text" msgid="6387985519141433291">"Rétablir les paramètres par défaut"</string>
    <string name="proxy_action_text" msgid="2957063145357903951">"Terminé"</string>
    <string name="proxy_hostname_label" msgid="8490171412999373362">"Nom d\'hôte du serveur mandataire"</string>
    <string name="proxy_error" msgid="8926675299638611451">"Attention"</string>
    <string name="proxy_error_dismiss" msgid="4993171795485460060">"OK"</string>
    <string name="proxy_error_invalid_host" msgid="6865850167802455230">"Le nom d\'hôte saisi n\'est pas valide."</string>
    <string name="proxy_error_invalid_exclusion_list" msgid="678527645450894773">"Le format de la liste d\'exclusion spécifiée n\'est pas correct. Séparez les noms de domaine à exclure par une virgule."</string>
    <string name="proxy_error_empty_port" msgid="5539106187558215246">"Le champ « Port » est obligatoire."</string>
    <string name="proxy_error_empty_host_set_port" msgid="2451694104858226781">"Le champ Port doit rester vide si le champ Hôte n\'est pas renseigné."</string>
    <string name="proxy_error_invalid_port" msgid="5988270202074492710">"Le port indiqué n\'est pas valide."</string>
    <string name="proxy_warning_limited_support" msgid="7229337138062837422">"Le serveur mandataire HTTP est utilisé par le navigateur, mais ne peut pas l\'être par les autres applications."</string>
    <string name="proxy_url_title" msgid="7185282894936042359">"URL config. auto mand. : "</string>
    <string name="radio_info_subid" msgid="204582608052503412">"Sous-identifiant actuel :"</string>
    <string name="radio_info_dds" msgid="5471937791273237508">"Sous-identifiant de la carte SIM par défaut pour les données :"</string>
    <string name="radio_info_dl_kbps" msgid="6894556071523815984">"Bande passante de téléchargement (kb/s) :"</string>
    <string name="radio_info_ul_kbps" msgid="946464073571185678">"Bande passante de téléversement (kb/s) :"</string>
    <string name="radio_info_signal_location_label" msgid="3242990404410530456">"Données de la position de la cellule (discontinuées) :"</string>
    <string name="radio_info_phy_chan_config" msgid="7133247058801474028">"Configuration du canal physique LTE :"</string>
    <string name="radio_info_cell_info_refresh_rate" msgid="7062777594049622128">"Taux d\'actualisation des données de la cellule :"</string>
    <string name="radio_info_cellinfo_label" msgid="6213223844927623098">"Données des mesures de toutes les cellules :"</string>
    <string name="radio_info_gprs_service_label" msgid="4209624131644060517">"Service de données :"</string>
    <string name="radio_info_roaming_label" msgid="6141505430275138647">"Itinérance :"</string>
    <string name="radio_info_imei_label" msgid="1220524224732944192">"Code IIEM :"</string>
    <string name="radio_info_call_redirect_label" msgid="2743797189722106231">"Transfert d\'appel :"</string>
    <string name="radio_info_ppp_resets_label" msgid="3587319503902576102">"Nombre de réinitialisations PPP depuis le démarrage :"</string>
    <string name="radio_info_current_network_label" msgid="9151285540639134945">"Réseau actuel :"</string>
    <string name="radio_info_ppp_received_label" msgid="363579470428151850">"Données reçues :"</string>
    <string name="radio_info_gsm_service_label" msgid="1370863866816125489">"Service vocal :"</string>
    <string name="radio_info_signal_strength_label" msgid="5155734002519307416">"Force du signal :"</string>
    <string name="radio_info_call_status_label" msgid="2611065018172747413">"État de l\'appel vocal :"</string>
    <string name="radio_info_ppp_sent_label" msgid="7748668735880404586">"Données envoyées :"</string>
    <string name="radio_info_message_waiting_label" msgid="1037302619943328273">"Message en attente :"</string>
    <string name="radio_info_phone_number_label" msgid="7942153178953255231">"Numéro de téléphone :"</string>
    <string name="radio_info_band_mode_label" msgid="8730871744887454509">"Sélectionnez la bande radio"</string>
    <string name="radio_info_voice_network_type_label" msgid="1443496502370667071">"Type de réseau vocal :"</string>
    <string name="radio_info_data_network_type_label" msgid="7094323145105149312">"Type de réseau de données :"</string>
    <string name="phone_index_label" msgid="1934407597576454430">"Sélectionner un index téléphonique"</string>
    <string name="radio_info_set_perferred_label" msgid="3511830813500105512">"Définir le type de réseau préféré :"</string>
    <string name="radio_info_ping_hostname_v4" msgid="7045103377818314709">"Faire un ping de l\'IPv4 du nom d\'hôte (www.google.com) :"</string>
    <string name="radio_info_ping_hostname_v6" msgid="1130906124160553954">"Faire un ping de l\'IPv6 du nom d\'hôte (www.google.com) :"</string>
    <string name="radio_info_http_client_test" msgid="2382286093023138339">"Test du client HTTP :"</string>
    <string name="ping_test_label" msgid="579228584343892613">"Effectuer le test de ping"</string>
    <string name="radio_info_smsc_label" msgid="6399460520126501354">"SMSC :"</string>
    <string name="radio_info_smsc_update_label" msgid="7258686760358791539">"Mettre à jour"</string>
    <string name="radio_info_smsc_refresh_label" msgid="6902302130315125102">"Actualiser"</string>
    <string name="radio_info_toggle_dns_check_label" msgid="6625185764803245075">"Basculer la vérification DNS"</string>
    <string name="oem_radio_info_label" msgid="6163141792477958941">"Infos/paramètres OEM"</string>
    <string name="band_mode_title" msgid="4071411679019296568">"Définir le mode de bande radio"</string>
    <string name="band_mode_loading" msgid="3555063585133586152">"Chargement de la liste de bandes en cours..."</string>
    <string name="band_mode_set" msgid="5730560180249458484">"Définir"</string>
    <string name="band_mode_failed" msgid="1495968863884716379">"Échec"</string>
    <string name="band_mode_succeeded" msgid="2701016190055887575">"Opération effectuée"</string>
    <string name="sdcard_changes_instructions" msgid="4482324130377280131">"Les modifications prendront effet lors de la prochaine connexion du câble USB."</string>
    <string name="sdcard_settings_screen_mass_storage_text" msgid="3741220147296482474">"Activer la mémoire de stockage USB de masse"</string>
    <string name="sdcard_settings_total_bytes_label" msgid="9184160745785062144">"Nombre d\'octets au total :"</string>
    <string name="sdcard_settings_not_present_status" product="nosdcard" msgid="1636218515775929394">"Mémoire USB non installée"</string>
    <string name="sdcard_settings_not_present_status" product="default" msgid="2048419626134861599">"Aucune carte SD"</string>
    <string name="sdcard_settings_available_bytes_label" msgid="763232429899373001">"Octets disponibles :"</string>
    <string name="sdcard_settings_mass_storage_status" product="nosdcard" msgid="7993410985895217054">"Mémoire USB utilisée comme stockage de masse"</string>
    <string name="sdcard_settings_mass_storage_status" product="default" msgid="2742075324087038036">"La carte SD est utilisée comme périphérique de stockage."</string>
    <string name="sdcard_settings_unmounted_status" product="nosdcard" msgid="5128923500235719226">"Retirez mémoire USB en toute sécurité."</string>
    <string name="sdcard_settings_unmounted_status" product="default" msgid="666233604712540408">"Vous pouvez maintenant retirer la carte SD en toute sécurité."</string>
    <string name="sdcard_settings_bad_removal_status" product="nosdcard" msgid="7761390725880773697">"La mémoire USB a été retirée en cours d\'utilisation."</string>
    <string name="sdcard_settings_bad_removal_status" product="default" msgid="5145797653495907970">"La carte SD a été retirée pendant son utilisation."</string>
    <string name="sdcard_settings_used_bytes_label" msgid="8820289486001170836">"Octets utilisés :"</string>
    <string name="sdcard_settings_scanning_status" product="nosdcard" msgid="7503429447676219564">"Recherche de médias sur la mémoire de stockage USB…"</string>
    <string name="sdcard_settings_scanning_status" product="default" msgid="2763464949274455656">"Recherche de fichiers multimédia sur la carte SD…"</string>
    <string name="sdcard_settings_read_only_status" product="nosdcard" msgid="3624143937437417788">"Mémoire USB en lecture seule"</string>
    <string name="sdcard_settings_read_only_status" product="default" msgid="4518291824764698112">"Carte SD installée en lecture seule"</string>
    <string name="skip_label" msgid="47510779345218297">"Passer"</string>
    <string name="next_label" msgid="4693520878012668114">"SUIVANT"</string>
    <string name="language_picker_title" msgid="3596315202551687690">"Langues"</string>
    <string name="locale_remove_menu" msgid="7651301406723638854">"Supprimer"</string>
    <string name="add_a_language" msgid="2330538812283783022">"Ajouter une langue"</string>
    <plurals name="dlg_remove_locales_title" formatted="false" msgid="4276642359346122396">
      <item quantity="one">Supprimer la langue sélectionnée?</item>
      <item quantity="other">Supprimer les langues sélectionnées?</item>
    </plurals>
    <string name="dlg_remove_locales_message" msgid="1361354927342876114">"Le texte s\'affichera dans une autre langue."</string>
    <string name="dlg_remove_locales_error_title" msgid="2653242337224911425">"Impossible de supprimer toutes les langues"</string>
    <string name="dlg_remove_locales_error_message" msgid="6697381512654262821">"Conservez au moins une langue"</string>
    <string name="locale_not_translated" msgid="516862628177166755">"Il est possible que cette langue ne soit pas disponible dans certaines applis."</string>
    <string name="action_drag_label_move_up" msgid="9052210023727612540">"Déplacer vers le haut"</string>
    <string name="action_drag_label_move_down" msgid="7448713844582912157">"Déplacer vers le bas"</string>
    <string name="action_drag_label_move_top" msgid="557081389352288310">"Déplacer dans le haut"</string>
    <string name="action_drag_label_move_bottom" msgid="2468642142414126482">"Déplacer dans le bas"</string>
    <string name="action_drag_label_remove" msgid="2861038147166966206">"Supprimer la langue"</string>
    <string name="activity_picker_label" msgid="6295660302548177109">"Sélectionnez une activité"</string>
    <string name="device_info_label" msgid="6551553813651711205">"Informations sur l\'appareil"</string>
    <string name="display_label" msgid="8074070940506840792">"Écran"</string>
    <string name="phone_info_label" product="tablet" msgid="7820855350955963628">"Informations sur la tablette"</string>
    <string name="phone_info_label" product="default" msgid="2127552523124277664">"Informations sur le téléphone"</string>
    <string name="sd_card_settings_label" product="nosdcard" msgid="8101475181301178428">"Mémoire de stockage USB"</string>
    <string name="sd_card_settings_label" product="default" msgid="5743100901106177102">"Carte SD"</string>
    <string name="proxy_settings_label" msgid="3271174136184391743">"Paramètres du serveur mandataire"</string>
    <string name="cancel" msgid="6859253417269739139">"Annuler"</string>
    <string name="okay" msgid="1997666393121016642">"OK"</string>
    <string name="forget" msgid="1400428660472591263">"Supprimer"</string>
    <string name="save" msgid="879993180139353333">"Enregistrer"</string>
    <string name="done" msgid="6942539184162713160">"Terminé"</string>
    <string name="apply" msgid="1577045208487259229">"Appliquer"</string>
    <string name="share" msgid="6791534619806355910">"Partager"</string>
    <string name="add" msgid="3709942705501136412">"Ajouter"</string>
    <string name="settings_label" msgid="1626402585530130914">"Paramètres"</string>
    <string name="settings_label_launcher" msgid="8344735489639482340">"Paramètres"</string>
    <string name="settings_shortcut" msgid="3936651951364030415">"Raccourci vers les paramètres"</string>
    <string name="airplane_mode" msgid="8837269988154128601">"Mode avion"</string>
    <string name="wireless_networks_settings_title" msgid="3643009077742794212">"Sans fil et réseaux"</string>
    <string name="radio_controls_summary" msgid="1838624369870907268">"Gérer le Wi-Fi, le Bluetooth, le mode Avion, les réseaux mobiles et les RPV"</string>
    <string name="cellular_data_title" msgid="6835451574385496662">"Données cellulaires"</string>
    <string name="calls_title" msgid="1262096900483238572">"Autoriser les appels"</string>
    <string name="sms_messages_title" msgid="1778636286080572535">"Messages texte"</string>
    <string name="cellular_data_summary" msgid="4660351864416939504">"Auto. utilisation données sur réseau cell."</string>
    <string name="allow_data_usage_title" msgid="2238205944729213062">"Autor. util. données en itin."</string>
    <string name="roaming" msgid="2619521775007402005">"Itinérance"</string>
    <string name="roaming_enable" msgid="3737380951525303961">"Se connecter aux services de données lors de l\'itinérance"</string>
    <string name="roaming_disable" msgid="1295279574370898378">"Se connecter aux services de données lors de l\'itinérance"</string>
    <string name="roaming_reenable_message" msgid="9141007271031717369">"Vous avez été déconnecté, car vous avez quitté votre réseau domestique et l\'itinérance des données est désactivée."</string>
    <string name="roaming_turn_it_on_button" msgid="4387601818162120589">"Activer"</string>
    <string name="roaming_warning" msgid="4275443317524544705">"Des frais importants peuvent s\'appliquer."</string>
    <string name="roaming_warning_multiuser" product="tablet" msgid="6458990250829214777">"Lorsque vous autorisez l\'itinérance des données, des frais d\'itinérance importants peuvent s\'appliquer!\n\nCe paramètre affecte tous les utilisateurs de cette tablette."</string>
    <string name="roaming_warning_multiuser" product="default" msgid="6368421100292355440">"Lorsque vous autorisez l\'itinérance des données, des frais d\'itinérance importants peuvent s\'appliquer!\n\nCe paramètre affecte tous les utilisateurs de ce téléphone."</string>
    <string name="roaming_reenable_title" msgid="6068100976707316772">"Autoriser l\'itinérance des données?"</string>
    <string name="networks" msgid="6333316876545927039">"Sélection de l\'opérateur"</string>
    <string name="sum_carrier_select" msgid="3616956422251879163">"Sélectionner un opérateur réseau"</string>
    <string name="date_and_time_settings_title" msgid="3350640463596716780">"Date et heure"</string>
    <string name="date_and_time_settings_title_setup_wizard" msgid="2391530758339384324">"Régler la date et l\'heure"</string>
    <string name="date_and_time_settings_summary" msgid="7095318986757583584">"Configurer la date, l\'heure, le fuseau horaire et les formats"</string>
    <string name="date_time_auto" msgid="4290527098376721491">"Utiliser la date et l\'heure fournies par le réseau"</string>
    <string name="zone_auto_title" msgid="3217703906014135437">"Utiliser le fuseau horaire fourni par le réseau"</string>
    <string name="date_time_24hour_auto" msgid="6276269188890332084">"Utiliser les paramètres régionaux par défaut"</string>
    <string name="date_time_24hour_title" msgid="3203537578602803850">"Format 24 heures"</string>
    <string name="date_time_24hour" msgid="1193032284921000063">"Utiliser le format 24 h"</string>
    <string name="date_time_set_time_title" msgid="6296795651349047016">"Heure"</string>
    <string name="time_format_category_title" msgid="736190761036057769">"Format de l\'heure"</string>
    <string name="date_time_set_timezone_title" msgid="3047322337368233197">"Fuseau horaire"</string>
    <string name="date_time_set_timezone" msgid="5045627174274377814">"Sélectionner le fuseau horaire"</string>
    <string name="date_time_set_date_title" msgid="6928286765325608604">"Date"</string>
    <string name="date_time_search_region" msgid="2478334699004021972">"Rechercher une région"</string>
    <string name="date_time_select_region" msgid="5434001881313168586">"Région"</string>
    <string name="date_time_select_fixed_offset_time_zones" msgid="6084375085203448645">"Sélect. fuseau horaire (UTC)"</string>
    <string name="zone_change_to_from_dst" msgid="118656001224045590">"<xliff:g id="TIME_TYPE">%1$s</xliff:g> commence le <xliff:g id="TRANSITION_DATE">%2$s</xliff:g>."</string>
    <string name="zone_info_exemplar_location_and_offset" msgid="1359698475641349336">"<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="164876167707284017">"<xliff:g id="TIME_TYPE">%2$s</xliff:g> (<xliff:g id="OFFSET">%1$s</xliff:g>)"</string>
    <string name="zone_info_footer" msgid="4192803402331390389">"Fuseau horaire utilisé : <xliff:g id="OFFSET_AND_NAME">%1$s</xliff:g>. L\'<xliff:g id="DST_TIME_TYPE">%2$s</xliff:g> commence le <xliff:g id="TRANSITION_DATE">%3$s</xliff:g>."</string>
    <string name="zone_info_footer_no_dst" msgid="8652423870143056964">"Utilise <xliff:g id="OFFSET_AND_NAME">%1$s</xliff:g>. Pas d\'heure avancée."</string>
    <string name="zone_time_type_dst" msgid="8850494578766845276">"Heure avancée"</string>
    <string name="zone_time_type_standard" msgid="3462424485380376522">"Heure normale"</string>
    <string name="zone_menu_by_region" msgid="8370437123807764346">"Sélectionner par région"</string>
    <string name="zone_menu_by_offset" msgid="7161573994228041794">"Sélectionner par décalage UTC"</string>
    <string name="date_picker_title" msgid="1338210036394128512">"Date"</string>
    <string name="time_picker_title" msgid="483460752287255019">"Heures"</string>
    <string name="lock_after_timeout" msgid="3041497579354520533">"Verrouiller après la mise en veille de l\'écran"</string>
    <string name="lock_after_timeout_summary" msgid="6446294520193562658">"<xliff:g id="TIMEOUT_STRING">%1$s</xliff:g> après la mise en veille"</string>
    <string name="lock_immediately_summary_with_exception" msgid="4887058374400817711">"Immédiatement après la mise en veille, sauf lorsque l\'appareil est maintenu déverrouillé par <xliff:g id="TRUST_AGENT_NAME">%1$s</xliff:g>"</string>
    <string name="lock_after_timeout_summary_with_exception" msgid="5693037914721259546">"<xliff:g id="TIMEOUT_STRING">%1$s</xliff:g> après la mise en veille, sauf lorsque l\'appareil est maintenu déverrouillé par <xliff:g id="TRUST_AGENT_NAME">%2$s</xliff:g>"</string>
    <string name="show_owner_info_on_lockscreen_label" msgid="5074906168357568434">"Coordonnées du propriétaire sur l\'écran verrouillé"</string>
    <string name="owner_info_settings_title" msgid="5530285568897386122">"Message écran verrouillage"</string>
    <string name="security_enable_widgets_title" msgid="2754833397070967846">"Activer les widgets"</string>
    <string name="security_enable_widgets_disabled_summary" msgid="6392489775303464905">"Désactivé par l\'administrateur"</string>
    <string name="lockdown_settings_title" msgid="7393790212603280213">"Afficher l\'option de verrouillage"</string>
    <string name="lockdown_settings_summary" msgid="4359438673563318171">"Afficher l\'option de l\'interrupteur qui désactive Smart Lock, le déverrouillage biométrique et les notifications sur l\'écran de verrouillage"</string>
    <string name="trust_lost_locks_screen_title" msgid="2992742466966021682">"Verr. écran en cas de perte de confiance"</string>
    <string name="trust_lost_locks_screen_summary" msgid="693784434582021206">"Si cette fonction est activée, l\'appareil sera verrouillé lorsque le dernier agent de confiance perd sa marque de confiance"</string>
    <string name="owner_info_settings_summary" msgid="7472393443779227052">"Aucun"</string>
    <string name="owner_info_settings_status" msgid="120407527726476378">"<xliff:g id="COUNT_0">%1$d</xliff:g>/<xliff:g id="COUNT_1">%2$d</xliff:g>"</string>
    <string name="owner_info_settings_edit_text_hint" msgid="7591869574491036360">"Par exemple : Android de Jonathan"</string>
    <string name="user_info_settings_title" msgid="1195015434996724736">"Informations sur l\'utilisateur"</string>
    <string name="show_profile_info_on_lockscreen_label" msgid="2741208907263877990">"Afficher infos de profil sur écran de verrouillage"</string>
    <string name="profile_info_settings_title" msgid="3518603215935346604">"Informations de profil"</string>
    <string name="Accounts_settings_title" msgid="1643879107901699406">"Comptes"</string>
    <string name="location_settings_title" msgid="1369675479310751735">"Position"</string>
    <string name="location_settings_master_switch_title" msgid="3560242980335542411">"Utiliser ma position"</string>
    <string name="location_settings_summary_location_off" msgid="794370259612167176">"Désactivé"</string>
    <plurals name="location_settings_summary_location_on" formatted="false" msgid="5513447650619485188">
      <item quantity="one">Activé : <xliff:g id="COUNT_1">%1$d</xliff:g> application a accès à la position</item>
      <item quantity="other">Activé : <xliff:g id="COUNT_1">%1$d</xliff:g> applications ont accès à la position</item>
    </plurals>
    <string name="location_settings_loading_app_permission_stats" msgid="8523775367089431611">"Chargement en cours…"</string>
    <string name="account_settings_title" msgid="626177544686329806">"Comptes"</string>
    <string name="security_settings_title" msgid="7945465324818485460">"Sécurité"</string>
    <string name="encryption_and_credential_settings_title" msgid="6514904533438791561">"Chiffrement et authentifiants"</string>
    <string name="encryption_and_credential_settings_summary" product="default" msgid="8721883002237981248">"Téléphone chiffré"</string>
    <string name="decryption_settings_summary" product="default" msgid="5671817824042639849">"Téléphone non chiffré"</string>
    <string name="encryption_and_credential_settings_summary" product="tablet" msgid="7200428573872395685">"Appareil chiffré"</string>
    <string name="decryption_settings_summary" product="tablet" msgid="5794135636155570977">"Appareil non chiffré"</string>
    <string name="lockscreen_settings_title" msgid="1099738951060387656">"Affichage de l\'écran de verrouillage"</string>
    <string name="lockscreen_settings_what_to_show_category" msgid="278055252361575926">"Éléments affichés"</string>
    <string name="security_settings_summary" msgid="967393342537986570">"Définir les paramètres de l\'option Ma position et de verrouillage"</string>
    <string name="cdma_security_settings_summary" msgid="6068799952798901542">"Définir les paramètres de la fonction Ma position, de déverrouillage de l\'écran et de verrouillage du stockage des identifiants"</string>
    <string name="security_passwords_title" msgid="2881269890053568809">"Confidentialité"</string>
    <string name="disabled_by_administrator_summary" msgid="1601828700318996341">"Désactivé par l\'administrateur"</string>
    <string name="security_status_title" msgid="5848766673665944640">"État de la sécurité"</string>
    <string name="security_dashboard_summary_face" msgid="268234254306703218">"Verrouillage de l\'écran, déverrouillage par reconnaissance du visage"</string>
    <string name="security_dashboard_summary" msgid="6757421634477554939">"Verrouillage de l\'écran, empreintes digitales"</string>
    <string name="security_dashboard_summary_no_fingerprint" msgid="8129641548372335540">"Verrouillage de l\'écran"</string>
    <string name="security_settings_face_preference_summary" msgid="1290187225482642821">"Visage ajouté"</string>
    <string name="security_settings_face_preference_summary_none" msgid="5596571291522936724">"Configurer le déverrouillage par reconnaissance faciale"</string>
    <string name="security_settings_face_preference_title" msgid="5277300443693527785">"Déverrouill. par reconn. faciale"</string>
    <string name="security_settings_face_profile_preference_title" msgid="3906383224724942953">"Déverrouillage par reconn. faciale pour le travail"</string>
    <string name="security_settings_face_enroll_education_title" msgid="6027417312490791135">"Comment config. déverr. par reconn. faciale"</string>
    <string name="security_settings_face_enroll_education_title_accessibility" msgid="4233918594329755623">"Configurer le déverr. par reconn. faciale"</string>
    <string name="security_settings_face_enroll_education_title_unlock_disabled" msgid="4697363240703556987">"Utiliser son visage pour s\'authentifier"</string>
    <string name="security_settings_face_enroll_education_message" msgid="4401918487764636333"></string>
    <string name="security_settings_face_enroll_education_start" msgid="6186306855277346454">"Démarrer"</string>
    <string name="security_settings_face_enroll_introduction_accessibility" msgid="7784083491315229721">"Utiliser config. d\'accessibilité"</string>
    <string name="security_settings_face_enroll_introduction_accessibility_expanded" msgid="5924018301323255439"></string>
    <string name="security_settings_face_enroll_introduction_accessibility_diversity" msgid="4455532390587307262"></string>
    <string name="security_settings_face_enroll_introduction_accessibility_vision" msgid="7075186169796301461"></string>
    <string name="security_settings_face_enroll_introduction_cancel" msgid="4277182322482408514">"Annuler"</string>
    <string name="security_settings_face_enroll_introduction_title" msgid="2694505011712885439">"Déverrouiller avec votre visage"</string>
    <string name="security_settings_face_enroll_introduction_title_unlock_disabled" msgid="8180330567034286589">"Utiliser son visage pour s\'authentifier"</string>
    <string name="security_settings_face_enroll_introduction_message" msgid="6150611993438981458">"Utilisez votre visage pour déverrouiller votre téléphone, autoriser vos achats et vous connecter à des applications."</string>
    <string name="security_settings_face_enroll_introduction_message_unlock_disabled" msgid="6393270235632444857">"Utilisez votre visage pour déverrouiller votre téléphone ou autoriser des achats.\n\nRemarque : Vous ne pouvez pas utiliser votre visage pour déverrouiller cet appareil. Pour obtenir plus d\'information, communiquez avec l\'administrateur de votre organisation."</string>
    <string name="security_settings_face_enroll_introduction_message_setup" msgid="5704661081718707858">"Utilisez votre visage pour déverrouiller votre téléphone, autoriser vos achats et vous connecter à des applications"</string>
    <string name="security_settings_face_enroll_introduction_footer_part_0" msgid="3316520154949466889"></string>
    <string name="security_settings_face_enroll_introduction_footer_part_1" msgid="5594630288374571903"></string>
    <string name="security_settings_face_enroll_introduction_footer_part_2" msgid="7576241712527601978"></string>
    <string name="security_settings_face_enroll_introduction_footer_part_3" msgid="7355240941877607603"></string>
    <string name="security_settings_face_enroll_repeat_title" msgid="4019853239039918762">"Centrez votre visage dans le cercle"</string>
    <string name="security_settings_face_enroll_enrolling_skip" msgid="5808832403353263368">"Ignorer"</string>
    <string name="face_add_max" msgid="4408683751143942949">"Vous pouvez ajouter jusqu\'à <xliff:g id="COUNT">%d</xliff:g> visages"</string>
    <string name="face_intro_error_max" msgid="160022811747660581">"Vous avez ajouté le nombre maximal de visages"</string>
    <string name="face_intro_error_unknown" msgid="6367721696446677261">"Impossible d\'ajouter d\'autres visages"</string>
    <string name="security_settings_face_enroll_error_dialog_title" msgid="2869110702072655323">"L\'inscription n\'est pas terminée"</string>
    <string name="security_settings_face_enroll_dialog_ok" msgid="2980238861223265089">"OK"</string>
    <string name="security_settings_face_enroll_error_timeout_dialog_message" msgid="1701191960569185087">"Le temps attribué pour l\'inscription des visages est écoulé. Veuillez essayer de nouveau."</string>
    <string name="security_settings_face_enroll_error_generic_dialog_message" msgid="3825066262969499407">"L\'inscription du visage n\'a pas fonctionné."</string>
    <string name="security_settings_face_enroll_finish_title" msgid="8268014305067971249">"Tout est prêt et semble être en ordre."</string>
    <string name="security_settings_face_enroll_done" msgid="6670735678797960484">"Terminé"</string>
    <string name="security_settings_face_settings_use_face_category" msgid="4087133372842623883">"Util. Face Unlock pour"</string>
    <string name="security_settings_face_settings_use_face_unlock_phone" msgid="8780794239930621913">"Déverr. le téléphone"</string>
    <string name="security_settings_face_settings_use_face_for_apps" msgid="5751549943998662469">"Connex. et paiements dans applis"</string>
    <string name="security_settings_face_settings_require_category" msgid="2523822050054597822">"Exigences pour le déverrouillage par reconnaissance faciale"</string>
    <string name="security_settings_face_settings_require_attention" msgid="8523824066748480516">"Exiger que les yeux soient ouv."</string>
    <string name="security_settings_face_settings_require_attention_details" msgid="6595676992796133643">"Pour déverrouiller le téléphone, vos yeux doivent être ouverts"</string>
    <string name="security_settings_face_settings_require_confirmation" msgid="2559602923985027572">"Toujours demander une confirmation"</string>
    <string name="security_settings_face_settings_require_confirmation_details" msgid="6466094680756211420">"Toujours dem. une confirm. lors du déverr. par rec. faciale dans applis"</string>
    <string name="security_settings_face_settings_remove_face_data" msgid="304401377141467791">"Suppr. donn. visages"</string>
    <string name="security_settings_face_settings_enroll" msgid="495403103503629382">"Configurer le déverr. par reconn. faciale"</string>
    <string name="security_settings_face_settings_footer" msgid="6072833685685070967">"Servez-vous du déverrouillage par reconnaissance faciale pour déverrouiller votre appareil, vous connecter à des applications et confirmer des paiements.\n\nRemarque importante :\nLe fait de regarder le téléphone pourrait le déverrouiller même si vous ne cherchiez pas à le faire.\n\nUne autre personne pourrait déverrouiller votre téléphone en le tenant devant votre visage alors que vos yeux sont ouverts.\n\nVotre téléphone pourrait être déverrouillé par une personne qui vous ressemble beaucoup, par exemple un jumeau identique."</string>
    <string name="security_settings_face_settings_remove_dialog_title" msgid="4829278778459836075">"Supprimer les données des visages?"</string>
    <string name="security_settings_face_settings_remove_dialog_details" msgid="1959642447512807205">"Les images et les données biométriques utilisées pour le déverrouillage par reconnaissance faciale seront supprimées de manière permanente et sécuritaire. Après la suppression, vous aurez besoin de votre NIP, de votre schéma ou de votre mot de passe pour déverrouiller votre téléphone, vous connecter à des applications et confirmer les paiements."</string>
    <string name="security_settings_face_settings_context_subtitle" msgid="4381276009777294566">"Utiliser le déverrouillage par reconnaissance faciale pour déverrouiller votre téléphone"</string>
    <string name="security_settings_fingerprint_preference_title" msgid="2488725232406204350">"Lecteur d\'empreintes digitales"</string>
    <string name="fingerprint_manage_category_title" msgid="8293801041700001681">"Gérer les empreintes digitales"</string>
    <string name="fingerprint_usage_category_title" msgid="8438526918999536619">"Util. empr. dig. pour"</string>
    <string name="fingerprint_add_title" msgid="1926752654454033904">"Ajouter une empreinte digitale"</string>
    <string name="fingerprint_enable_keyguard_toggle_title" msgid="5078060939636911795">"verrouillage de l\'écran"</string>
    <plurals name="security_settings_fingerprint_preference_summary" formatted="false" msgid="624961700033979880">
      <item quantity="one"><xliff:g id="COUNT_1">%1$d</xliff:g> empreinte digitale configurée</item>
      <item quantity="other"><xliff:g id="COUNT_1">%1$d</xliff:g> empreintes digitales configurées</item>
    </plurals>
    <string name="security_settings_fingerprint_preference_summary_none" msgid="1507739327565151923"></string>
    <string name="security_settings_fingerprint_enroll_introduction_title" msgid="3201556857492526098">"Déverrouillage avec empreinte"</string>
    <string name="security_settings_fingerprint_enroll_introduction_title_unlock_disabled" msgid="7066417934622827305">"Utilisez empreinte digitale"</string>
    <string name="security_settings_fingerprint_enroll_introduction_message" msgid="3508870672887336095">"Il vous suffit de toucher le lecteur d\'empreintes digitales pour déverrouiller votre téléphone, autoriser des achats ou vous connecter à des applications. Toutes les personnes dont les empreintes digitales sont ajoutées sur votre téléphone peuvent effectuer ces opérations. Sélectionnez donc ces personnes avec soin.\n\nRemarque : Vos empreintes digitales peuvent être moins sécurisées qu\'un schéma ou un code fiables."</string>
    <string name="security_settings_fingerprint_enroll_introduction_message_unlock_disabled" msgid="1550756694054944874">"Utilisez votre empreinte digitale pour déverrouiller votre téléphone ou autoriser des achats.\n\nRemarque : Vous ne pouvez pas utiliser vos empreintes digitales pour déverrouiller cet appareil. Pour obtenir plus d\'information, communiquez avec l\'administrateur de votre organisation."</string>
    <string name="security_settings_fingerprint_enroll_introduction_message_setup" msgid="6817326798834882531">"Utilisez votre empreinte digitale pour déverrouiller votre téléphone ou autoriser des achats.\n\nRemarque : Vos empreintes digitales peuvent être moins sécurisées qu\'un schéma ou un NIP fiables."</string>
    <string name="security_settings_fingerprint_enroll_introduction_cancel" msgid="3199351118385606526">"Annuler"</string>
    <string name="security_settings_fingerprint_enroll_introduction_continue" msgid="7472492858148162530">"Continuer"</string>
    <string name="security_settings_fingerprint_enroll_introduction_cancel_setup" msgid="5021369420474432665">"Passer"</string>
    <string name="security_settings_fingerprint_enroll_introduction_continue_setup" msgid="1961957425135180242">"Suivant"</string>
    <string name="setup_fingerprint_enroll_skip_title" msgid="362050541117362034">"Ignorer l\'empreinte digitale?"</string>
    <string name="setup_fingerprint_enroll_skip_after_adding_lock_text" msgid="958990414356204763">"La configuration des empreintes digitales ne prend qu\'une minute ou deux. Si vous ignorez cette étape, vous pouvez ajouter votre empreinte digitale plus tard dans les paramètres."</string>
    <string name="lock_screen_intro_skip_title" msgid="4988210105913705679">"Ignorer verrouillage d\'écran?"</string>
    <string name="lock_screen_intro_skip_dialog_text_frp" product="tablet" msgid="1581834104051243425">"Les fonctionnalités de protection de l\'appareil ne seront pas activées. Vous ne pourrez pas empêcher d\'autres personnes d\'utiliser cette tablette en cas de perte, de vol ou de réinitialisation."</string>
    <string name="lock_screen_intro_skip_dialog_text_frp" product="device" msgid="4629503416877189572">"Les fonctionnalités de protection de l\'appareil ne seront pas activées. Vous ne pourrez pas empêcher d\'autres personnes d\'utiliser cet appareil en cas de perte, de vol ou de réinitialisation."</string>
    <string name="lock_screen_intro_skip_dialog_text_frp" product="default" msgid="2423428240245737909">"Les fonctionnalités de protection de l\'appareil ne seront pas activées. Vous ne pourrez pas empêcher d\'autres personnes d\'utiliser ce téléphone en cas de perte, de vol ou de réinitialisation."</string>
    <string name="lock_screen_intro_skip_dialog_text" product="tablet" msgid="5219287483885558525">"Les fonctionnalités de protection de l\'appareil ne seront pas activées. Vous ne pourrez pas empêcher d\'autres personnes d\'utiliser cette tablette en cas de perte ou de vol."</string>
    <string name="lock_screen_intro_skip_dialog_text" product="device" msgid="1466238255429527112">"Les fonctionnalités de protection de l\'appareil ne seront pas activées. Vous ne pourrez pas empêcher d\'autres personnes d\'utiliser cet appareil en cas de perte ou de vol."</string>
    <string name="lock_screen_intro_skip_dialog_text" product="default" msgid="3008526710555416125">"Les fonctionnalités de protection de l\'appareil ne seront pas activées. Vous ne pourrez pas empêcher d\'autres personnes d\'utiliser ce téléphone en cas de perte ou de vol."</string>
    <string name="skip_anyway_button_label" msgid="2323522873558834513">"Ignorer quand même"</string>
    <string name="go_back_button_label" msgid="4745265266186209467">"Retour"</string>
    <string name="skip_lock_screen_dialog_button_label" msgid="7478349557867790778">"Ignorer"</string>
    <string name="cancel_lock_screen_dialog_button_label" msgid="4525833484240246349">"Annuler"</string>
    <string name="security_settings_fingerprint_enroll_find_sensor_title" msgid="3051496861358227199">"Toucher le capteur"</string>
    <string name="security_settings_fingerprint_enroll_find_sensor_message" msgid="8793966374365960368">"Il se trouve à l\'arrière de votre téléphone. Utilisez votre index."</string>
    <string name="security_settings_fingerprint_enroll_find_sensor_content_description" msgid="2058830032070449160">"Illustration présentant l\'appareil et la position du capteur d\'empreinte digitale"</string>
    <string name="security_settings_fingerprint_enroll_dialog_name_label" msgid="7086763077909041106">"Nom"</string>
    <string name="security_settings_fingerprint_enroll_dialog_ok" msgid="4150384963879569750">"Ok"</string>
    <string name="security_settings_fingerprint_enroll_dialog_delete" msgid="4114615413240707936">"Supprimer"</string>
    <string name="security_settings_fingerprint_enroll_start_title" msgid="2068961812439460133">"Toucher le capteur"</string>
    <string name="security_settings_fingerprint_enroll_start_message" msgid="3909929328942564524">"Placez votre doigt sur le capteur, puis soulevez-le lorsque vous sentez une vibration"</string>
    <string name="security_settings_fingerprint_enroll_repeat_title" msgid="2819679722403209778">"Relever le doigt et toucher le capteur"</string>
    <string name="security_settings_fingerprint_enroll_repeat_message" msgid="6158989350522518586">"Déplacez légèrement votre doigt lorsque vous le relevez pour ajouter toutes les parties de votre empreinte digitale."</string>
    <string name="security_settings_fingerprint_enroll_finish_title" msgid="7567276170287972230">"Empreinte digitale ajoutée"</string>
    <string name="security_settings_fingerprint_enroll_finish_message" msgid="8970048776120548976">"Lorsque vous voyez cette icône, vous pouvez utiliser votre empreinte digitale pour vous identifier ou pour autoriser un achat"</string>
    <string name="security_settings_fingerprint_enroll_enrolling_skip" msgid="3710211704052369752">"Plus tard"</string>
    <string name="setup_fingerprint_enroll_enrolling_skip_title" msgid="6808422329107426923">"Ignorer config. empreintes digitales?"</string>
    <string name="setup_fingerprint_enroll_enrolling_skip_message" msgid="274849306857859783">"Vous avez choisi de déverrouiller votre téléphone à l\'aide de votre empreinte digitale. Si vous ignorez cette étape maintenant, vous devrez reprendre la configuration plus tard. L\'opération prend environ une minute."</string>
    <string name="fingerprint_lock_screen_setup_skip_dialog_text" product="tablet" msgid="7914950545902198894">"Protégez votre tablette avec une option de verrouillage de l\'écran afin que personne ne puisse l\'utiliser en cas de perte ou de vol. L\'option de verrouillage de l\'écran est également nécessaire pour configurer l\'authentification par empreinte digitale. Touchez Annuler, puis définissez un NIP, un schéma ou un mot de passe."</string>
    <string name="fingerprint_lock_screen_setup_skip_dialog_text" product="device" msgid="2300047476104528001">"Protégez votre appareil avec une option de verrouillage de l\'écran afin que personne ne puisse l\'utiliser en cas de perte ou de vol. L\'option de verrouillage de l\'écran est également nécessaire pour configurer l\'authentification par empreinte digitale. Touchez Annuler, puis définissez un NIP, un schéma ou un mot de passe."</string>
    <string name="fingerprint_lock_screen_setup_skip_dialog_text" product="default" msgid="5823994499768751994">"Protégez votre téléphone avec une option de verrouillage de l\'écran afin que personne ne puisse l\'utiliser en cas de perte ou de vol. L\'option de verrouillage de l\'écran est également nécessaire pour configurer l\'authentification par empreinte digitale. Touchez Annuler, puis définissez un NIP, un schéma ou un mot de passe."</string>
    <string name="face_lock_screen_setup_skip_dialog_text" product="tablet" msgid="2053646029913482047">"En protégeant votre tablette avec une option de verrouillage de l\'écran, personne ne pourra l\'utiliser en cas de perte ou de vol. Pour configurer le déverrouillage par reconnaissance faciale, vous devez aussi configurer une option de verrouillage de l\'écran. Pour revenir en arrière, touchez Annuler."</string>
    <string name="face_lock_screen_setup_skip_dialog_text" product="device" msgid="8884769457436280503">"En protégeant votre appareil avec une option de verrouillage de l\'écran, personne ne pourra l\'utiliser en cas de perte ou de vol. Pour configurer le déverrouillage par reconnaissance faciale, vous devez aussi configurer une option de verrouillage de l\'écran. Pour revenir en arrière, touchez Annuler."</string>
    <string name="face_lock_screen_setup_skip_dialog_text" product="default" msgid="1752907123591111728">"En protégeant votre téléphone avec une option de verrouillage de l\'écran, personne ne pourra l\'utiliser en cas de perte ou de vol. Pour configurer le déverrouillage par reconnaissance faciale, vous devez aussi configurer une option de verrouillage de l\'écran. Pour revenir en arrière, touchez Annuler."</string>
    <string name="lock_screen_pin_skip_title" msgid="8064328201816780457">"Ignorer la configuration du NIP?"</string>
    <string name="lock_screen_password_skip_title" msgid="4155009417576409182">"Ignorer la configuration du mot de passe?"</string>
    <string name="lock_screen_pattern_skip_title" msgid="6467327818577283960">"Ignorer la configuration du schéma?"</string>
    <string name="security_settings_fingerprint_enroll_setup_screen_lock" msgid="1195743489835505376">"Configurer le verrouil. de l\'écran"</string>
    <string name="security_settings_fingerprint_enroll_done" msgid="4014607378328187567">"Terminé"</string>
    <string name="security_settings_fingerprint_enroll_touch_dialog_title" msgid="1863561601428695160">"Oups, ce n\'est pas le capteur"</string>
    <string name="security_settings_fingerprint_enroll_touch_dialog_message" msgid="2989019978041986175">"Touchez le capteur à l\'arrière de votre téléphone. Utilisez votre index."</string>
    <string name="security_settings_fingerprint_enroll_error_dialog_title" msgid="3618021988442639280">"L\'enregistrement n\'est pas terminé"</string>
    <string name="security_settings_fingerprint_enroll_error_timeout_dialog_message" msgid="2942551158278899627">"Le temps attribué pour l\'enregistrement des empreintes digitales est écoulé. Veuillez essayer de nouveau."</string>
    <string name="security_settings_fingerprint_enroll_error_generic_dialog_message" msgid="3624760637222239293">"L\'enregistrement de l\'empreinte digitale n\'a pas fonctionné. Réessayez ou utilisez un autre doigt."</string>
    <string name="fingerprint_enroll_button_add" msgid="6317978977419045463">"Ajouter une empreinte"</string>
    <string name="fingerprint_enroll_button_next" msgid="6247009337616342759">"Suivant"</string>
    <string name="security_settings_fingerprint_enroll_disclaimer" msgid="2624905914239271751">"Votre empreinte digitale vous permet non seulement de déverrouiller votre téléphone, mais également d\'autoriser des achats et l\'accès à l\'application. "<annotation id="url">"En savoir plus"</annotation></string>
    <string name="security_settings_fingerprint_enroll_disclaimer_lockscreen_disabled" msgid="7846871823167357942">" L\'option de verrouillage de l\'écran est désactivée. Pour en savoir plus, communiquez avec l\'administrateur de votre organisation. "<annotation id="admin_details">"Plus de détails"</annotation>\n\n"Vous pouvez toujours utiliser votre empreinte digitale pour autoriser les achats et l\'accès aux applications. "<annotation id="url">"En savoir plus"</annotation></string>
    <string name="security_settings_fingerprint_enroll_lift_touch_again" msgid="1888772560642539718">"Relevez le doigt, puis touchez le capteur à nouveau"</string>
    <string name="fingerprint_add_max" msgid="1020927549936895822">"Vous pouvez ajouter jusqu\'à <xliff:g id="COUNT">%d</xliff:g> empreintes digitales"</string>
    <string name="fingerprint_intro_error_max" msgid="6864066984678078441">"Vous avez ajouté le nombre maximal d\'empreintes digitales"</string>
    <string name="fingerprint_intro_error_unknown" msgid="1905692132326523040">"Impossible d\'ajouter des empreintes digitales"</string>
    <string name="fingerprint_last_delete_title" msgid="6410310101247028988">"Supprimer toutes les empreintes digitales?"</string>
    <string name="fingerprint_delete_title" msgid="1368196182612202898">"Supprimer « <xliff:g id="FINGERPRINT_ID">%1$s</xliff:g> »"</string>
    <string name="fingerprint_delete_message" msgid="8597787803567398131">"Voulez-vous supprimer cette empreinte digitale?"</string>
    <string name="fingerprint_last_delete_message" msgid="7852321001254275878">"Vous ne pourrez pas utiliser vos empreintes digitales pour déverrouiller votre téléphone, autoriser vos achats ni vous connecter à des applications"</string>
    <string name="fingerprint_last_delete_message_profile_challenge" msgid="6521520787746771912">"Vous ne pourrez pas utiliser vos empreintes digitales pour déverrouiller votre profil professionnel, autoriser vos achats ni vous connecter à des applications professionnelles"</string>
    <string name="fingerprint_last_delete_confirm" msgid="2634726361059274289">"Oui, supprimer"</string>
    <string name="crypt_keeper_settings_title" msgid="4219233835490520414">"Cryptage"</string>
    <string name="crypt_keeper_encrypt_title" product="tablet" msgid="1060273569887301457">"Chiffrer la tablette"</string>
    <string name="crypt_keeper_encrypt_title" product="default" msgid="1878996487755806122">"Chiffrer le téléphone"</string>
    <string name="crypt_keeper_encrypted_summary" msgid="1868233637888132906">"Chiffré"</string>
    <string name="crypt_keeper_desc" product="tablet" msgid="503014594435731275">"Vous pouvez chiffrer vos comptes, vos paramètres, les applications téléchargées et les données associées, les contenus multimédias et d\'autres fichiers. Si vous avez chiffré votre tablette en définissant un verrouillage d\'écran (au moyen d\'un schéma, d\'un NIP ou d\'un mot de passe), vous devez déverrouiller l\'écran pour déchiffrer la tablette à chaque fois que vous l\'allumez. La seule autre manière de déchiffrer cette dernière consiste à rétablir la configuration d\'usine, ce qui entraîne la suppression de l\'ensemble de vos données.\n\nLa procédure de chiffrement dure au moins une heure. La pile de la tablette doit être chargée au départ, et la tablette doit rester branchée pendant tout le processus. Toute interruption entraîne la perte d\'une partie ou de la totalité des données."</string>
    <string name="crypt_keeper_desc" product="default" msgid="2579929266645543631">"Vous pouvez chiffrer vos comptes, vos paramètres, les applications téléchargées et les données associées, les contenus multimédias et d\'autres fichiers. Si vous avez chiffré votre téléphone en définissant un verrouillage d\'écran (au moyen d\'un schéma, d\'un NIP ou d\'un mot de passe), vous devez déverrouiller l\'écran pour déchiffrer le téléphone à chaque fois que vous l\'allumez. La seule autre manière de déchiffrer ce dernier consiste à rétablir la configuration d\'usine, ce qui entraîne la suppression de l\'ensemble de vos données.\n\nLa procédure de chiffrement dure au moins une heure. La pile du téléphone doit être chargée au départ, et le téléphone doit rester branché pendant tout le processus. Toute interruption entraîne la perte d\'une partie ou de la totalité des données."</string>
    <string name="crypt_keeper_button_text" product="tablet" msgid="1189623490604750854">"Chiffrer la tablette"</string>
    <string name="crypt_keeper_button_text" product="default" msgid="2008346408473255519">"Chiffrer le téléphone"</string>
    <string name="crypt_keeper_low_charge_text" msgid="2029407131227814893">"Veuillez charger votre batterie, puis réessayer."</string>
    <string name="crypt_keeper_unplugged_text" msgid="4785376766063053901">"Veuillez brancher votre chargeur, puis réessayer."</string>
    <string name="crypt_keeper_dialog_need_password_title" msgid="4058971800557767">"Aucun NIP ni mot de passe saisi pour le verrouillage de l\'écran"</string>
    <string name="crypt_keeper_dialog_need_password_message" msgid="4071395977297369642">"Vous devez définir un NIP ou un mot de passe pour le verrouillage de l\'écran avant de lancer le chiffrement."</string>
    <string name="crypt_keeper_confirm_title" msgid="5100339496381875522">"Chiffrer?"</string>
    <string name="crypt_keeper_final_desc" product="tablet" msgid="517662068757620756">"Le chiffrement est irréversible, et toute interruption du processus peut entraîner la perte de données. L\'opération peut prendre une heure, voire plus, au cours de laquelle la tablette sera redémarrée à plusieurs reprises."</string>
    <string name="crypt_keeper_final_desc" product="default" msgid="287503113671320916">"Le chiffrement est irréversible, et toute interruption du processus peut entraîner la perte de données. L\'opération peut prendre une heure, voire plus, au cours de laquelle le téléphone sera redémarré à plusieurs reprises."</string>
    <string name="crypt_keeper_setup_title" msgid="1783951453124244969">"Chiffrement en cours"</string>
    <string name="crypt_keeper_setup_description" product="tablet" msgid="6689952371032099350">"Veuillez patienter pendant le chiffrement de votre tablette. <xliff:g id="PERCENT">^1</xliff:g> % effectué(s)."</string>
    <string name="crypt_keeper_setup_description" product="default" msgid="951918761585534875">"Veuillez patienter pendant le chiffrement de votre téléphone. <xliff:g id="PERCENT">^1</xliff:g> % effectué(s)."</string>
    <string name="crypt_keeper_setup_time_remaining" product="tablet" msgid="1655047311546745695">"Veuillez patienter pendant le chiffrement de votre tablette. Temps restant : <xliff:g id="DURATION">^1</xliff:g>"</string>
    <string name="crypt_keeper_setup_time_remaining" product="default" msgid="1862964662304683072">"Veuillez patienter pendant le chiffrement de votre téléphone. Temps restant : <xliff:g id="DURATION">^1</xliff:g>"</string>
    <string name="crypt_keeper_force_power_cycle" product="tablet" msgid="556504311511212648">"Pour déverrouiller votre tablette, redémarrez-la."</string>
    <string name="crypt_keeper_force_power_cycle" product="default" msgid="1794353635603020327">"Pour déverrouiller votre téléphone, redémarrez-le."</string>
    <string name="crypt_keeper_warn_wipe" msgid="2738374897337991667">"Attention : Les données de votre appareil seront effacées si vous effectuez encore <xliff:g id="COUNT">^1</xliff:g> tentatives de déverrouillage infructueuses."</string>
    <string name="crypt_keeper_enter_password" msgid="2223340178473871064">"Saisissez votre mot de passe."</string>
    <string name="crypt_keeper_failed_title" msgid="7133499413023075961">"Échec du chiffrement"</string>
    <string name="crypt_keeper_failed_summary" product="tablet" msgid="8219375738445017266">"Impossible de terminer le chiffrement, car celui-ci a été interrompu. Par conséquent, les données de votre tablette ne sont plus accessibles.\n\nPour continuer d\'utiliser votre tablette, vous devez rétablir la configuration d\'usine. Une fois cette opération terminée, vous pourrez restaurer toutes les données sauvegardées sur votre compte Google lors de la nouvelle configuration de votre tablette."</string>
    <string name="crypt_keeper_failed_summary" product="default" msgid="3270131542549577953">"Impossible de terminer le chiffrement, car celui-ci a été interrompu. Par conséquent, les données de votre téléphone ne sont plus accessibles.\n\nPour continuer d\'utiliser votre téléphone, vous devez rétablir la configuration d\'usine. Une fois cette opération terminée, vous pourrez restaurer toutes les données sauvegardées sur votre compte Google lors de la nouvelle configuration de votre téléphone."</string>
    <string name="crypt_keeper_data_corrupt_title" msgid="8759119849089795751">"Échec du déchiffrement"</string>
    <string name="crypt_keeper_data_corrupt_summary" product="tablet" msgid="840107296925798402">"Le mot de passe entré est correct. Malheureusement, vos données sont corrompues.\n\nPour continuer d\'utiliser votre tablette, vous devez rétablir sa configuration d\'usine. Une fois cette opération terminée, vous pourrez restaurer toutes les données que vous aviez sauvegardées dans votre compte Google lors de la nouvelle configuration de votre tablette."</string>
    <string name="crypt_keeper_data_corrupt_summary" product="default" msgid="8843311420059663824">"Le mot de passe entré est correct. Malheureusement, vos données sont corrompues.\n\nPour continuer d\'utiliser votre téléphone, vous devez rétablir sa configuration d\'usine. Une fois cette opération terminée, vous pourrez restaurer toutes les données que vous aviez sauvegardées dans votre compte Google lors de la nouvelle configuration de votre téléphone."</string>
    <string name="crypt_keeper_switch_input_method" msgid="4168332125223483198">"Changer le mode de saisie"</string>
    <string name="suggested_lock_settings_title" msgid="8498743819223200961">"Sécurisez votre téléphone"</string>
    <string name="suggested_lock_settings_summary" product="tablet" msgid="2296800316150748710">"Définir un verr. de l\'écran pour protéger la tablette"</string>
    <string name="suggested_lock_settings_summary" product="device" msgid="7562847814806365373">"Définir un verr. de l\'écran pour protéger l\'appareil"</string>
    <string name="suggested_lock_settings_summary" product="default" msgid="1526355348444658181">"Définir un verr. de l\'écran pour protéger le téléphone"</string>
    <string name="suggested_fingerprint_lock_settings_title" msgid="2174553391551398081">"Ajouter empreinte digitale pour déverrouiller"</string>
    <string name="suggested_fingerprint_lock_settings_summary" product="tablet" msgid="5738274583658668124"></string>
    <string name="suggested_fingerprint_lock_settings_summary" product="device" msgid="5738274583658668124"></string>
    <string name="suggested_fingerprint_lock_settings_summary" product="default" msgid="5738274583658668124"></string>
    <string name="lock_settings_picker_title" msgid="1095755849152582712">"Verrouillage de l\'écran"</string>
    <string name="lock_settings_picker_title_profile" msgid="8822511284992306796">"Verrouill. profil pro"</string>
    <string name="setup_lock_settings_picker_title" product="tablet" msgid="90329443364067215">"Protégez votre tablette"</string>
    <string name="setup_lock_settings_picker_title" product="device" msgid="2399952075134938929">"Protégez votre appareil"</string>
    <string name="setup_lock_settings_picker_title" product="default" msgid="1572244299605153324">"Protégez votre téléphone"</string>
    <string name="lock_settings_picker_biometrics_added_security_message" msgid="1507307757032207572">"Pour plus de sécurité, configurez une méthode secondaire pour verrouiller l\'écran"</string>
    <string name="setup_lock_settings_picker_message" product="tablet" msgid="8919671129189936210">"Activez les fonctionnalités de protection de l\'appareil pour empêcher d\'autres personnes d\'utiliser cette tablette sans votre autorisation. Choisissez la méthode de verrouillage de l\'écran à utiliser."</string>
    <string name="setup_lock_settings_picker_message" product="device" msgid="3787276514406353777">"Activez les fonctionnalités de protection de l\'appareil pour empêcher d\'autres personnes d\'utiliser cet appareil sans votre autorisation. Choisissez la méthode de verrouillage de l\'écran à utiliser."</string>
    <string name="setup_lock_settings_picker_message" product="default" msgid="3692856437543730446">"Activez les fonctionnalités de protection de l\'appareil pour empêcher d\'autres personnes d\'utiliser ce téléphone sans votre autorisation. Choisissez la méthode de verrouillage de l\'écran à utiliser."</string>
    <string name="lock_settings_picker_fingerprint_message" msgid="4755230324778371292">"Choisissez votre méthode secondaire de verrouillage d\'écran"</string>
    <string name="lock_settings_picker_face_message" msgid="197106534637556054">"Choisissez votre méthode secondaire de verrouillage d\'écran"</string>
    <string name="setup_lock_settings_options_button_label" msgid="8511153243629402929">"Options de verrouillage de l\'écran"</string>
    <string name="setup_lock_settings_options_dialog_title" msgid="5058207955455973917">"Options de verrouillage de l\'écran"</string>
    <string name="unlock_set_unlock_launch_picker_title" msgid="2084576942666016993">"Verrouillage de l\'écran"</string>
    <string name="unlock_set_unlock_launch_picker_summary_lock_immediately" msgid="5967714169972542586">"<xliff:g id="UNLOCK_METHOD">%1$s</xliff:g> / immédiatement après la mise en veille"</string>
    <string name="unlock_set_unlock_launch_picker_summary_lock_after_timeout" msgid="4696710373399258413">"<xliff:g id="UNLOCK_METHOD">%1$s</xliff:g> / après <xliff:g id="TIMEOUT_STRING">%2$s</xliff:g> de veille"</string>
    <string name="unlock_set_unlock_launch_picker_title_profile" msgid="124176557311393483">"Verr. profil profess."</string>
    <string name="unlock_set_unlock_launch_picker_change_title" msgid="5045866882028324941">"Modifier écran verr."</string>
    <string name="unlock_set_unlock_launch_picker_change_summary" msgid="2790960639554590668">"Modifier ou désactiver la sécurité : schéma, NIP ou mot de passe"</string>
    <string name="unlock_set_unlock_launch_picker_enable_summary" msgid="4791110798817242301">"Choisir une méthode pour verrouiller l\'écran"</string>
    <string name="unlock_set_unlock_off_title" msgid="7117155352183088342">"Aucun"</string>
    <string name="unlock_set_unlock_off_summary" msgid="94361581669110415"></string>
    <string name="unlock_set_unlock_none_title" msgid="5679243878975864640">"Balayer l\'écran"</string>
    <string name="unlock_set_unlock_none_summary" msgid="8914673583104628191">"Aucune sécurité"</string>
    <string name="unlock_set_unlock_pattern_title" msgid="2912067603917311700">"Schéma"</string>
    <string name="unlock_set_unlock_pattern_summary" msgid="7062696666227725593">"Sécurité moyenne"</string>
    <string name="unlock_set_unlock_pin_title" msgid="5846029709462329515">"NIP"</string>
    <string name="unlock_set_unlock_pin_summary" msgid="907878650556383388">"Sécurité moyenne à élevée"</string>
    <string name="unlock_set_unlock_password_title" msgid="8775603825675090937">"Mot de passe"</string>
    <string name="unlock_set_unlock_password_summary" msgid="8856220848940929546">"Sécurité élevée"</string>
    <string name="unlock_set_do_later_title" msgid="4894767558414979243">"Pas maintenant"</string>
    <string name="current_screen_lock" msgid="4104091715420072219">"Verrouillage actuel de l\'écran"</string>
    <string name="fingerprint_unlock_set_unlock_pattern" msgid="4939057588092120368">"Empreinte digitale + schéma"</string>
    <string name="fingerprint_unlock_set_unlock_pin" msgid="8010746824051056986">"Empreinte digitale + NIP"</string>
    <string name="fingerprint_unlock_set_unlock_password" msgid="7351131075806338634">"Empreinte digitale + mot de passe"</string>
    <string name="fingerprint_unlock_skip_fingerprint" msgid="1441077909803666681">"Continuer sans empreintes digitales"</string>
    <string name="fingerprint_unlock_title" msgid="2826226740306003991">"Vous pouvez déverrouiller votre téléphone avec votre empreinte digitale. Pour plus de sécurité, cette option exige un verrouillage d\'écran secondaire."</string>
    <string name="face_unlock_set_unlock_pattern" msgid="4077659104229192018">"Déverrouillage par reconn. faciale + schéma"</string>
    <string name="face_unlock_set_unlock_pin" msgid="1359249613033276716">"Déverrouillage par reconn. faciale + NIP"</string>
    <string name="face_unlock_set_unlock_password" msgid="7135335310498158870">"Déverr. par reconn. faciale + mot de passe"</string>
    <string name="face_unlock_skip_face" msgid="3481956557015165094">"Continuer sans configurer le déverr. par reconn. faciale"</string>
    <string name="face_unlock_title" msgid="9042382084472444316">"Vous pouvez déverrouiller votre téléphone avec votre visage. Pour plus de sécurité, cette option exige un verrouillage d\'écran secondaire."</string>
    <string name="unlock_set_unlock_disabled_summary" msgid="2051593894736282302">"Désactivé par admin., politique cryptage, stock. authentifiants"</string>
    <string name="unlock_set_unlock_mode_off" msgid="5881952274566013651">"Aucun"</string>
    <string name="unlock_set_unlock_mode_none" msgid="8467360084676871617">"Balayer l\'écran"</string>
    <string name="unlock_set_unlock_mode_pattern" msgid="7837270780919299289">"Schéma"</string>
    <string name="unlock_set_unlock_mode_pin" msgid="3541326261341386690">"NIP"</string>
    <string name="unlock_set_unlock_mode_password" msgid="1203938057264146610">"Mot de passe"</string>
    <string name="unlock_setup_wizard_fingerprint_details" msgid="7893457665921363009">"Une fois que vous avez défini un verrouillage de l\'écran, vous pouvez également configurer une empreinte digitale dans le menu Paramètres &gt; Sécurité."</string>
    <string name="unlock_disable_lock_title" msgid="1427036227416979120">"Désactiver le verrouillage de l\'écran"</string>
    <string name="unlock_disable_frp_warning_title" msgid="264008934468492550">"Supprimer la protection de l\'appareil?"</string>
    <string name="unlock_disable_frp_warning_title_profile" msgid="5507136301904313583">"Supprimer la protection du profil?"</string>
    <string name="unlock_disable_frp_warning_content_pattern" msgid="8869767290771023461">"Les fonctions de protection de l\'appareil ne fonctionneront pas sans votre schéma."</string>
    <string name="unlock_disable_frp_warning_content_pattern_fingerprint" msgid="2986105377420905314">"Les fonctions de protection de l\'appareil ne fonctionneront pas sans votre schéma.<xliff:g id="EMPTY_LINE">

</xliff:g>Vos empreintes digitales enregistrées seront également supprimées de cet appareil et vous ne pourrez pas déverrouiller votre téléphone, autoriser des achats ni vous connecter à des applications avec celles-ci."</string>
    <string name="unlock_disable_frp_warning_content_pin" msgid="586996206210265131">"Les fonctions de protection de l\'appareil ne fonctionneront pas sans votre NIP."</string>
    <string name="unlock_disable_frp_warning_content_pin_fingerprint" msgid="3370462835533123695">"Les fonctions de protection de l\'appareil ne fonctionneront pas sans votre NIP.<xliff:g id="EMPTY_LINE">

</xliff:g>Vos empreintes digitales enregistrées seront également supprimées de cet appareil et vous ne pourrez pas déverrouiller votre téléphone, autoriser des achats ni vous connecter à des applications avec celles-ci."</string>
    <string name="unlock_disable_frp_warning_content_password" msgid="5420612686852555537">"Les fonctions de protection de l\'appareil ne fonctionneront pas sans votre mot de passe."</string>
    <string name="unlock_disable_frp_warning_content_password_fingerprint" msgid="3595476296430536798">"Les fonctions de protection de l\'appareil ne fonctionneront pas sans votre mot de passe. <xliff:g id="EMPTY_LINE">

</xliff:g>Vos empreintes digitales enregistrées seront également supprimées de cet appareil et vous ne pourrez pas déverrouiller votre téléphone, autoriser des achats ni vous connecter à des applications avec celles-ci."</string>
    <string name="unlock_disable_frp_warning_content_unknown" msgid="1550718040483548220">"Les fonctions de protection de l\'appareil ne fonctionneront pas sans votre verrouillage d\'écran."</string>
    <string name="unlock_disable_frp_warning_content_unknown_fingerprint" msgid="3679351662094349506">"Les fonctions de protection de l\'appareil ne fonctionneront pas sans votre verrouillage d\'écran.<xliff:g id="EMPTY_LINE">

</xliff:g>Vos empreintes digitales enregistrées seront également supprimées de cet appareil et vous ne pourrez pas déverrouiller votre téléphone, autoriser des achats ni vous connecter à des applications avec celles-ci."</string>
    <string name="unlock_disable_frp_warning_content_pattern_profile" msgid="8682200103576359918">"Les fonctions de protection du profil ne fonctionneront pas sans votre schéma."</string>
    <string name="unlock_disable_frp_warning_content_pattern_fingerprint_profile" msgid="6718155854303231675">"Les fonctions de protection du profil ne fonctionneront pas sans votre schéma.<xliff:g id="EMPTY_LINE">

</xliff:g>Vos empreintes digitales enregistrées seront également supprimées de ce profil et vous ne pourrez pas déverrouiller votre profil, autoriser des achats ni vous connecter à des applications avec celles-ci."</string>
    <string name="unlock_disable_frp_warning_content_pin_profile" msgid="7790688070593867767">"Les fonctions de protection du profil ne fonctionneront pas sans votre NIP."</string>
    <string name="unlock_disable_frp_warning_content_pin_fingerprint_profile" msgid="4209564603132870532">"Les fonctions de protection du profil ne fonctionneront pas sans votre NIP.<xliff:g id="EMPTY_LINE">

</xliff:g>Vos empreintes digitales enregistrées seront également supprimées de ce profil et vous ne pourrez pas déverrouiller votre profil, autoriser des achats ni vous connecter à des applications avec celles-ci."</string>
    <string name="unlock_disable_frp_warning_content_password_profile" msgid="7569285520567674461">"Les fonctions de protection du profil ne fonctionneront pas sans votre mot de passe."</string>
    <string name="unlock_disable_frp_warning_content_password_fingerprint_profile" msgid="2994300676764706047">"Les fonctions de protection de profil ne fonctionneront pas sans votre mot de passe. <xliff:g id="EMPTY_LINE">

</xliff:g>Vos empreintes digitales enregistrées seront également supprimées de ce profil et vous ne pourrez pas déverrouiller votre profil, autoriser des achats ni vous connecter à des applications avec celles-ci."</string>
    <string name="unlock_disable_frp_warning_content_unknown_profile" msgid="6984215718701688202">"Les fonctions de protection du profil ne fonctionneront pas sans votre verrouillage d\'écran."</string>
    <string name="unlock_disable_frp_warning_content_unknown_fingerprint_profile" msgid="4994062501123299418">"Les fonctions de protection du profil ne fonctionneront pas sans votre verrouillage d\'écran.<xliff:g id="EMPTY_LINE">

</xliff:g>Vos empreintes digitales enregistrées seront également supprimées de ce profil et vous ne pourrez pas déverrouiller votre téléphone, autoriser des achats ni vous connecter à des applications avec celles-ci."</string>
    <string name="unlock_disable_frp_warning_ok" msgid="7075138677177748705">"Oui, supprimer"</string>
    <string name="unlock_change_lock_pattern_title" msgid="2044092014872741130">"Modifier le schéma"</string>
    <string name="unlock_change_lock_pin_title" msgid="806629901095938484">"Modifier le NIP de déverrouillage"</string>
    <string name="unlock_change_lock_password_title" msgid="5606298470358768865">"Modifier le mot de passe de déverrouillage"</string>
    <string name="unlock_footer_high_complexity_requested" msgid="7529087063617325912">"<xliff:g id="APP_NAME">%1$s</xliff:g> recommande d\'utiliser un NIP ou un mot de passe robuste et risque de ne pas fonctionner comme prévu si vous n\'en définissez pas un"</string>
    <string name="unlock_footer_medium_complexity_requested" msgid="4195620619469851350">"<xliff:g id="APP_NAME">%1$s</xliff:g> recommande d\'utiliser un nouveau NIP ou mot de passe et risque de ne pas fonctionner comme prévu si vous n\'en définissez pas un"</string>
    <string name="unlock_footer_low_complexity_requested" msgid="428655972363263817">"<xliff:g id="APP_NAME">%1$s</xliff:g> recommande d\'utiliser un nouveau schéma, NIP ou mot de passe et risque de ne pas fonctionner comme prévu si vous n\'en définissez pas un"</string>
    <string name="unlock_footer_none_complexity_requested" msgid="6275441987228550440">"<xliff:g id="APP_NAME">%1$s</xliff:g> vous recommande d\'utiliser une nouveau mode verrouillage de l\'écran"</string>
    <string name="lock_failed_attempts_before_wipe" msgid="2219711062197089783">"Réessayez. Tentative <xliff:g id="CURRENT_ATTEMPTS">%1$d</xliff:g> sur <xliff:g id="TOTAL_ATTEMPTS">%2$d</xliff:g>."</string>
    <string name="lock_last_attempt_before_wipe_warning_title" msgid="4277765862798876826">"Vos données seront supprimées"</string>
    <string name="lock_last_pattern_attempt_before_wipe_device" msgid="1688030823464420974">"Si vous entrez un schéma incorrect à la prochaine tentative, les données de cet appareil seront supprimées."</string>
    <string name="lock_last_pin_attempt_before_wipe_device" msgid="5350785938296254352">"Si vous entrez un NIP incorrect à la prochaine tentative, les données de cet appareil seront supprimées."</string>
    <string name="lock_last_password_attempt_before_wipe_device" msgid="6208035114731421034">"Si vous entrez un mot de passe incorrect à la prochaine tentative, les données de cet appareil seront supprimées."</string>
    <string name="lock_last_pattern_attempt_before_wipe_user" msgid="7851504071368235547">"Si vous entrez un schéma incorrect à la prochaine tentative, cet utilisateur sera supprimé"</string>
    <string name="lock_last_pin_attempt_before_wipe_user" msgid="4049024921333961715">"Si vous entrez un NIP incorrect à la prochaine tentative, cet utilisateur sera supprimé"</string>
    <string name="lock_last_password_attempt_before_wipe_user" msgid="4660886542496781672">"Si vous entrez un mot de passe incorrect à la prochaine tentative, cet utilisateur sera supprimé"</string>
    <string name="lock_last_pattern_attempt_before_wipe_profile" msgid="2437716252059050291">"Si vous entrez un schéma incorrect à la prochaine tentative suivante, votre profil professionnel et ses données seront supprimés"</string>
    <string name="lock_last_pin_attempt_before_wipe_profile" msgid="5799931839127476913">"Si vous entrez un NIP incorrect à la prochaine tentative suivante, votre profil professionnel et ses données seront supprimés"</string>
    <string name="lock_last_password_attempt_before_wipe_profile" msgid="6786586046975042158">"Si vous entrez un mot de passe incorrect à la prochaine tentative suivante, votre profil professionnel et ses données seront supprimés"</string>
    <string name="lock_failed_attempts_now_wiping_device" msgid="5047439819181833824">"Trop de tentatives incorrectes. Les données de cet appareil seront supprimées."</string>
    <string name="lock_failed_attempts_now_wiping_user" msgid="6188180643494518001">"Trop de tentatives incorrectes. Cet utilisateur sera supprimé."</string>
    <string name="lock_failed_attempts_now_wiping_profile" msgid="1745475043685915442">"Trop de tentatives incorrectes. Ce profil professionnel et ses données seront supprimés."</string>
    <string name="lock_failed_attempts_now_wiping_dialog_dismiss" msgid="8246716090548717312">"Ignorer"</string>
    <plurals name="lockpassword_password_too_short" formatted="false" msgid="1957883871187697796">
      <item quantity="one">Doit contenir au moins <xliff:g id="COUNT_1">%d</xliff:g> caractère</item>
      <item quantity="other">Doit contenir au moins <xliff:g id="COUNT_1">%d</xliff:g> caractères</item>
    </plurals>
    <plurals name="lockpassword_pin_too_short" formatted="false" msgid="5019935246875659237">
      <item quantity="one">Le NIP doit contenir au moins <xliff:g id="COUNT_1">%d</xliff:g> chiffre</item>
      <item quantity="other">Le NIP doit contenir au moins <xliff:g id="COUNT_1">%d</xliff:g> chiffres</item>
    </plurals>
    <string name="lockpassword_continue_label" msgid="4602203784934526940">"Continuer"</string>
    <plurals name="lockpassword_password_too_long" formatted="false" msgid="4581209996591221075">
      <item quantity="one">Doit contenir moins de <xliff:g id="NUMBER_1">%d</xliff:g> caractère</item>
      <item quantity="other">Doit contenir moins de <xliff:g id="NUMBER_1">%d</xliff:g> caractères</item>
    </plurals>
    <plurals name="lockpassword_pin_too_long" formatted="false" msgid="185568652740755131">
      <item quantity="one">Doit contenir moins de <xliff:g id="NUMBER_1">%d</xliff:g> chiffre</item>
      <item quantity="other">Doit contenir moins de <xliff:g id="NUMBER_1">%d</xliff:g> chiffres</item>
    </plurals>
    <string name="lockpassword_pin_contains_non_digits" msgid="7284664023164191198">"Doit contenir uniquement des chiffres contenus entre 0 et 9"</string>
    <string name="lockpassword_pin_recently_used" msgid="1401569207976460727">"L\'administrateur de l\'appareil ne permet pas l\'utilisation d\'un NIP récent"</string>
    <string name="lockpassword_pin_blacklisted_by_admin" msgid="8563366383328811472">"Les NIP communs sont bloqués par l\'administrateur de votre service informatique. Essayez un NIP différent."</string>
    <string name="lockpassword_illegal_character" msgid="8049611046639943217">"Vous ne pouvez pas inclure de caractère non valide"</string>
    <string name="lockpassword_password_requires_alpha" msgid="3036589522150097731">"Doit contenir au moins une lettre"</string>
    <string name="lockpassword_password_requires_digit" msgid="5140062925787058765">"Doit contenir au moins un chiffre"</string>
    <string name="lockpassword_password_requires_symbol" msgid="5944350865681510893">"Doit contenir au moins un symbole"</string>
    <plurals name="lockpassword_password_requires_letters" formatted="false" msgid="9013132344745898400">
      <item quantity="one">Doit contenir au moins <xliff:g id="COUNT">%d</xliff:g> lettre</item>
      <item quantity="other">Doit contenir au moins <xliff:g id="COUNT">%d</xliff:g> lettres</item>
    </plurals>
    <plurals name="lockpassword_password_requires_lowercase" formatted="false" msgid="2626327674921055486">
      <item quantity="one">Doit contenir au moins <xliff:g id="COUNT">%d</xliff:g> lettre minuscule</item>
      <item quantity="other">Doit contenir au moins <xliff:g id="COUNT">%d</xliff:g> lettres minuscules</item>
    </plurals>
    <plurals name="lockpassword_password_requires_uppercase" formatted="false" msgid="7860796359913920356">
      <item quantity="one">Doit contenir au moins <xliff:g id="COUNT">%d</xliff:g> lettre majuscule</item>
      <item quantity="other">Doit contenir au moins <xliff:g id="COUNT">%d</xliff:g> lettres majuscules</item>
    </plurals>
    <plurals name="lockpassword_password_requires_numeric" formatted="false" msgid="1967587658356336828">
      <item quantity="one">Doit contenir au moins <xliff:g id="COUNT">%d</xliff:g> chiffre</item>
      <item quantity="other">Doit contenir au moins <xliff:g id="COUNT">%d</xliff:g> chiffres</item>
    </plurals>
    <plurals name="lockpassword_password_requires_symbols" formatted="false" msgid="6751305770863640574">
      <item quantity="one">Doit contenir au moins <xliff:g id="COUNT">%d</xliff:g> caractère spécial</item>
      <item quantity="other">Doit contenir au moins <xliff:g id="COUNT">%d</xliff:g> caractères spéciaux</item>
    </plurals>
    <plurals name="lockpassword_password_requires_nonletter" formatted="false" msgid="4440596998172043055">
      <item quantity="one">Doit contenir au moins <xliff:g id="COUNT">%d</xliff:g> caractère autre qu\'une lettre</item>
      <item quantity="other">Doit contenir au moins <xliff:g id="COUNT">%d</xliff:g> caractères autres qu\'une lettre</item>
    </plurals>
    <string name="lockpassword_password_recently_used" msgid="942665351220525547">"L\'administrateur de l\'appareil ne permet pas l\'utilisation d\'un mot de passe récent"</string>
    <string name="lockpassword_password_blacklisted_by_admin" msgid="9105101266246197027">"Les mots de passe communs sont bloqués par l\'administrateur de votre service informatique. Essayez un mot de passe différent."</string>
    <string name="lockpassword_pin_no_sequential_digits" msgid="680765285206990584">"Les suites croissantes, décroissantes ou répétitives de chiffres ne sont pas autorisées"</string>
    <string name="lockpassword_confirm_label" msgid="8176726201389902380">"Confirmer"</string>
    <string name="lockpassword_cancel_label" msgid="8818529276331121899">"Annuler"</string>
    <string name="lockpassword_clear_label" msgid="5724429464960458155">"Effacer"</string>
    <string name="lockpassword_credential_changed" msgid="581649578639853343">"Le verrouillage d\'écran a déjà été modifié. Réessayez avec le nouveau verrouillage d\'écran."</string>
    <string name="lockpattern_tutorial_cancel_label" msgid="6431583477570493261">"Annuler"</string>
    <string name="lockpattern_tutorial_continue_label" msgid="3559793618653400434">"Suivant"</string>
    <string name="lock_setup" msgid="3355847066343753943">"La configuration est terminée."</string>
    <string name="manage_device_admin" msgid="537804979483211453">"Applications d\'administration d\'appareils"</string>
    <string name="number_of_device_admins_none" msgid="7185056721919496069">"Aucune application active"</string>
    <plurals name="number_of_device_admins" formatted="false" msgid="3361891840111523393">
      <item quantity="one"><xliff:g id="COUNT_1">%d</xliff:g> application active</item>
      <item quantity="other"><xliff:g id="COUNT_1">%d</xliff:g> applications actives</item>
    </plurals>
    <string name="manage_trust_agents" msgid="4629279457536987768">"Agents de confiance"</string>
    <string name="disabled_because_no_backup_security" msgid="6877660253409580377">"Pour l\'utiliser, définir d\'abord un écran de verrouillage"</string>
    <string name="manage_trust_agents_summary" msgid="1475819820389620546">"Aucun"</string>
    <plurals name="manage_trust_agents_summary_on" formatted="false" msgid="3935182396726101824">
      <item quantity="one"><xliff:g id="COUNT">%d</xliff:g> agent de confiance actif</item>
      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> agent(s) de confiance actif(s)</item>
    </plurals>
    <string name="bluetooth_quick_toggle_title" msgid="1037056952714061893">"Bluetooth"</string>
    <string name="bluetooth_quick_toggle_summary" msgid="5293641680139873341">"Activer Bluetooth"</string>
    <string name="bluetooth_settings" msgid="1810521656168174329">"Bluetooth"</string>
    <string name="bluetooth_settings_title" msgid="1908745291161353016">"Bluetooth"</string>
    <string name="bluetooth_settings_summary" msgid="2091062709530570462">"Gérer les connexions, configurer le nom et l\'identification de l\'appareil"</string>
    <string name="bluetooth_pairing_request" msgid="2605098826364694673">"Associer avec « <xliff:g id="DEVICE_NAME">%1$s</xliff:g> »?"</string>
    <string name="bluetooth_pairing_key_msg" msgid="418124944140102021">"Code d\'association Bluetooth"</string>
    <string name="bluetooth_enter_passkey_msg" msgid="6813273136442138444">"Entrez le code d\'association, puis appuyez sur Retour ou Entrée"</string>
    <string name="bluetooth_enable_alphanumeric_pin" msgid="7222713483058171357">"Le NIP contient des lettres ou des symboles."</string>
    <string name="bluetooth_pin_values_hint" msgid="3815897557875873646">"Habituellement 0000 ou 1234"</string>
    <string name="bluetooth_pin_values_hint_16_digits" msgid="7849359451584101077">"Le numéro doit comporter 16 chiffres"</string>
    <string name="bluetooth_enter_pin_other_device" msgid="4637977124526813470">"Vous devrez peut-être également saisir ce NIP sur l\'autre appareil."</string>
    <string name="bluetooth_enter_passkey_other_device" msgid="2798719004030279602">"Vous devrez peut-être également saisir ce mot de passe sur l\'autre appareil."</string>
    <string name="bluetooth_confirm_passkey_msg" msgid="3708312912841950052">"Pour associer votre appareil à :&lt;br&gt;&lt;b&gt;<xliff:g id="DEVICE_NAME">%1$s</xliff:g>&lt;/b&gt;&lt;br&gt;&lt;br&gt;Assurez-vous que le mot de passe &lt;br&gt;&lt;b&gt;<xliff:g id="PASSKEY">%2$s</xliff:g>&lt;/b&gt; s\'affiche."</string>
    <string name="bluetooth_incoming_pairing_msg" msgid="1615930853859551491">"De :&lt;br&gt;&lt;b&gt;<xliff:g id="DEVICE_NAME">%1$s</xliff:g>&lt;/b&gt;&lt;br&gt;&lt;br&gt;Associer à cet appareil?"</string>
    <string name="bluetooth_display_passkey_pin_msg" msgid="2796550001376088433">"Pour l\'association à :<xliff:g id="BOLD1_0">&lt;br&gt;&lt;b&gt;</xliff:g><xliff:g id="DEVICE_NAME">%1$s</xliff:g><xliff:g id="END_BOLD1">&lt;/b&gt;&lt;br&gt;&lt;br&gt;</xliff:g>Saisissez <xliff:g id="BOLD2_1">&lt;br&gt;&lt;b&gt;</xliff:g><xliff:g id="PASSKEY">%2$s</xliff:g><xliff:g id="END_BOLD2">&lt;/b&gt;</xliff:g>, puis appuyez sur « Retour » ou sur « Entrée »."</string>
    <string name="bluetooth_pairing_shares_phonebook" msgid="9082518313285787097">"Autoriser l\'accès à vos contacts et à l\'historique des appels"</string>
    <string name="bluetooth_error_title" msgid="6850384073923533096"></string>
    <string name="bluetooth_connecting_error_message" msgid="1397388344342081090">"Impossible de se connecter à <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="bluetooth_preference_scan_title" msgid="2277464653118896016">"Recherche d\'appareils"</string>
    <string name="bluetooth_search_for_devices" msgid="2754007356491461674">"Actualiser"</string>
    <string name="bluetooth_searching_for_devices" msgid="9203739709307871727">"Recherche…"</string>
    <string name="bluetooth_preference_device_settings" msgid="907776049862799122">"Paramètres de l\'appareil"</string>
    <string name="bluetooth_preference_paired_dialog_title" msgid="8875124878198774180">"Appareil associé"</string>
    <string name="bluetooth_preference_paired_dialog_internet_option" msgid="7112953286863428412">"Connexion Internet"</string>
    <string name="bluetooth_preference_paired_dialog_keyboard_option" msgid="2271954176947879628">"Clavier"</string>
    <string name="bluetooth_preference_paired_dialog_contacts_option" msgid="7747163316331917594">"Contacts et historique des appels"</string>
    <string name="bluetooth_pairing_dialog_title" msgid="1417255032435317301">"Associer avec cet appareil?"</string>
    <string name="bluetooth_pairing_dialog_sharing_phonebook_title" msgid="7664141669886358618">"Partager le répertoire de contacts?"</string>
    <string name="bluetooth_pairing_dialog_contants_request" msgid="5531109163573611348">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g> veut accéder à vos contacts et à votre historique d\'appels."</string>
    <string name="bluetooth_pairing_dialog_paring_request" msgid="8451248193517851958">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g> demande une association par Bluetooth. Il aura alors accès aux contacts et à l\'histor. des appels."</string>
    <string name="bluetooth_preference_found_media_devices" msgid="1617401232446299411">"Appareils détectés"</string>
    <string name="bluetooth_preference_no_found_devices" msgid="7594339669961811591">"Aucun appareil à proximité"</string>
    <string name="bluetooth_device_context_connect" msgid="3997659895003244941">"Connexion"</string>
    <string name="bluetooth_device_context_disconnect" msgid="8220072022970148683">"Déconnecter"</string>
    <string name="bluetooth_device_context_pair_connect" msgid="7611522504813927727">"Associer et connecter"</string>
    <string name="bluetooth_device_context_unpair" msgid="662992425948536144">"Dissocier"</string>
    <string name="bluetooth_device_context_disconnect_unpair" msgid="7644014238070043798">"Déconnecter et dissocier"</string>
    <string name="bluetooth_device_context_connect_advanced" msgid="2643129703569788771">"Options…"</string>
    <string name="bluetooth_menu_advanced" msgid="8572178316357220524">"Options avancées"</string>
    <string name="bluetooth_advanced_titlebar" msgid="2142159726881547669">"Paramètres Bluetooth avancés"</string>
    <string name="bluetooth_empty_list_bluetooth_off" msgid="6351930724051893423">"Si la fonctionnalité Bluetooth est activée, l\'appareil peut communiquer avec les autres appareils Bluetooth à proximité."</string>
    <string name="bluetooth_scanning_on_info_message" msgid="824285504325592644">"Lorsque le Bluetooth est activé, votre appareil peut communiquer avec d\'autres appareils Bluetooth à proximité.\n\nPour améliorer l\'expérience d\'utilisation de l\'appareil, les applications et les services peuvent continuer de rechercher les appareils à proximité à tout moment, même si le Bluetooth est désactivé. Cette autorisation peut permettre, par exemple, d\'améliorer les fonctionnalités et les services basés sur la localisation. Vous pouvez modifier cette option dans les "<annotation id="link">"paramètres de recherche"</annotation>"."</string>
    <string name="ble_scan_notify_text" msgid="1295915006005700650">"Pour améliorer la précision de la localisation, les applications et les services système peuvent toujours détecter les appareils Bluetooth. Vous pouvez modifier ce paramètre dans les <xliff:g id="LINK_BEGIN_0">LINK_BEGIN</xliff:g>paramètres de recherche<xliff:g id="LINK_END_1">LINK_END</xliff:g>."</string>
    <string name="bluetooth_connect_failed" msgid="4500234659813241053">"Échec de la connexion. Réessayez."</string>
    <string name="device_details_title" msgid="6576953269221085300">"Détails de l\'appareil"</string>
    <string name="bluetooth_device_mac_address" msgid="2513724313558236181">"Adresse Bluetooth de l\'appareil : <xliff:g id="ADDRESS">%1$s</xliff:g>"</string>
    <string name="bluetooth_unpair_dialog_title" msgid="38467834196432400">"Oubliez l\'appareil?"</string>
    <string name="bluetooth_unpair_dialog_body" product="default" msgid="9087609557757135712">"Votre téléphone ne sera plus associé avec <xliff:g id="DEVICE_NAME">%1$s</xliff:g>"</string>
    <string name="bluetooth_unpair_dialog_body" product="tablet" msgid="7785695793007576501">"Votre tablette ne sera plus associée à <xliff:g id="DEVICE_NAME">%1$s</xliff:g>"</string>
    <string name="bluetooth_unpair_dialog_body" product="device" msgid="251257782642157557">"Votre appareil ne sera plus associé avec <xliff:g id="DEVICE_NAME">%1$s</xliff:g>"</string>
    <string name="bluetooth_untethered_unpair_dialog_body" msgid="5932168717642676140">"L\'appareil <xliff:g id="DEVICE_NAME">%1$s</xliff:g> ne sera plus associé avec les appareils liés à ce compte"</string>
    <string name="bluetooth_unpair_dialog_forget_confirm_button" msgid="3829370108973879006">"Oublier l\'appareil"</string>
    <string name="bluetooth_connect_specific_profiles_title" msgid="6952214406025825164">"Se connecter à…"</string>
    <string name="bluetooth_disconnect_a2dp_profile" msgid="3524648279150937177">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g> sera déconnecté de l\'audio du support."</string>
    <string name="bluetooth_disconnect_headset_profile" msgid="8635908811168780720">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g> sera déconnecté de l\'audio en mains libres."</string>
    <string name="bluetooth_disconnect_hid_profile" msgid="3282295189719352075">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g> sera déconnecté du périphérique d\'entrée"</string>
    <string name="bluetooth_disconnect_pan_user_profile" msgid="8037627994382458698">"L\'accès à Internet via <xliff:g id="DEVICE_NAME">%1$s</xliff:g> va être interrompu."</string>
    <string name="bluetooth_disconnect_pan_nap_profile" product="tablet" msgid="8355910926439312604">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g> ne partagera plus la connexion Internet de la tablette."</string>
    <string name="bluetooth_disconnect_pan_nap_profile" product="default" msgid="6251611115860359886">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g> ne partagera plus la connexion Internet du téléphone."</string>
    <string name="bluetooth_device_advanced_title" msgid="6066342531927499308">"Appareil Bluetooth associé"</string>
    <string name="bluetooth_device_advanced_online_mode_title" msgid="3689050071425683114">"Connexion"</string>
    <string name="bluetooth_device_advanced_online_mode_summary" msgid="1204424107263248336">"Connecter à un appareil Bluetooth"</string>
    <string name="bluetooth_device_advanced_profile_header_title" msgid="102745381968579605">"Utiliser pour"</string>
    <string name="bluetooth_device_advanced_rename_device" msgid="5148578059584955791">"Renommer"</string>
    <string name="bluetooth_device_advanced_enable_opp_title" msgid="8222550640371627365">"Autoriser le transfert de fichiers entrants"</string>
    <string name="bluetooth_pan_user_profile_summary_connected" msgid="6436258151814414028">"Connecté à l\'appareil pour accès Internet"</string>
    <string name="bluetooth_pan_nap_profile_summary_connected" msgid="1322694224800769308">"Connexion Internet locale partagée avec appareil"</string>
    <string name="bluetooth_dock_settings" msgid="3218335822716052885">"Paramètres station d\'accueil"</string>
    <string name="bluetooth_dock_settings_title" msgid="5543069893044375188">"Utiliser la station d’accueil pour l\'audio"</string>
    <string name="bluetooth_dock_settings_headset" msgid="1001821426078644650">"Comme téléphone à haut-parleur"</string>
    <string name="bluetooth_dock_settings_a2dp" msgid="8791004998846630574">"Pour la musique et le multimédia"</string>
    <string name="bluetooth_dock_settings_remember" msgid="5551459057010609115">"Mémoriser ces paramètres"</string>
    <string name="bluetooth_max_connected_audio_devices_string" msgid="6752690395207847881">"Maximum d\'appareils audio Bluetooth connectés"</string>
    <string name="bluetooth_max_connected_audio_devices_dialog_title" msgid="5936561749790095473">"Sélectionnez le nombre maximal d\'appareils Bluetooth connectés"</string>
    <string name="wifi_display_settings_title" msgid="8740852850033480136">"Cast"</string>
    <string name="wifi_display_enable_menu_item" msgid="4883036464138167674">"Activer l\'affichage sans fil"</string>
    <string name="wifi_display_no_devices_found" msgid="1382012407154143453">"Aucun appareil détecté à proximité."</string>
    <string name="wifi_display_status_connecting" msgid="5688608834000748607">"Connexion en cours…"</string>
    <string name="wifi_display_status_connected" msgid="8364125226376985558">"Connecté"</string>
    <string name="wifi_display_status_in_use" msgid="8556830875615434792">"En cours d\'utilisation"</string>
    <string name="wifi_display_status_not_available" msgid="5714978725794210102">"Non accessible"</string>
    <string name="wifi_display_details" msgid="7791118209992162698">"Paramètres d\'affichage"</string>
    <string name="wifi_display_options_title" msgid="5740656401635054838">"Options d\'affichage sans fil"</string>
    <string name="wifi_display_options_forget" msgid="9119048225398894580">"Supprimer"</string>
    <string name="wifi_display_options_done" msgid="5703116500357822557">"Terminé"</string>
    <string name="wifi_display_options_name" msgid="4756080222307467898">"Nom"</string>
    <string name="wifi_band_24ghz" msgid="852929254171856911">"2,4 GHz"</string>
    <string name="wifi_band_5ghz" msgid="6433822023268515117">"5 GHz"</string>
    <string name="wifi_sign_in_button_text" msgid="8404345621836792112">"Connexion"</string>
    <string name="wifi_tap_to_sign_in" msgid="6990161842394669054">"Touchez ici pour vous connecter au réseau"</string>
    <string name="tx_link_speed" msgid="6139577455916971837">"<xliff:g id="TRANSMIT_LINK_SPEED">%1$d</xliff:g> Mb/s"</string>
    <string name="rx_link_speed" msgid="5729003360923133988">"<xliff:g id="RECEIVE_LINK_SPEED">%1$d</xliff:g> Mb/s"</string>
    <string name="wifi_ask_enable" msgid="2795469717302060104">"<xliff:g id="REQUESTER">%s</xliff:g> souhaite activer le Wi-Fi"</string>
    <string name="wifi_ask_disable" msgid="728366570145493573">"<xliff:g id="REQUESTER">%s</xliff:g> souhaite désactiver le Wi-Fi"</string>
    <string name="art_verifier_for_debuggable_title" msgid="6029838014407791341">"Vérif. code à octets des applis déboguables"</string>
    <string name="art_verifier_for_debuggable_summary" msgid="2250352478065428399">"Autoriser ART à vérifier le code à octets pour les applications débogables"</string>
    <string name="nfc_quick_toggle_title" msgid="6769159366307299004">"NFC"</string>
    <string name="nfc_quick_toggle_summary" product="tablet" msgid="8302974395787498915">"Autoriser l\'échange de données lorsque la tablette est en contact avec un autre appareil"</string>
    <string name="nfc_quick_toggle_summary" product="default" msgid="5237208142892767592">"Autoriser l\'échange de données lorsque le téléphone est en contact avec un autre appareil"</string>
    <string name="nfc_disclaimer_title" msgid="4364003873202264039">"Activer la fonction NFC"</string>
    <string name="nfc_disclaimer_content" msgid="5566907911915158075">"La technologie NFC échange des données entre cet appareil et d\'autres appareils ou cibles à proximité, tels que les terminaux de paiement, les lecteurs d\'accès et les annonces ou les balises interactifs"</string>
    <string name="nfc_secure_settings_title" msgid="150400737244061585">"NFC sécurisée"</string>
    <string name="nfc_secure_toggle_summary" product="default" msgid="2135032222065627938">"Autoriser l\'utilisation de la technologie NFC pour les paiements et les transports en commun uniquement lorsque l\'écran est déverrouillé"</string>
    <string name="android_beam_settings_title" msgid="7832812974600338649">"Android Beam"</string>
    <string name="android_beam_on_summary" msgid="3618057099355636830">"Prêt à partager le contenu de l\'application par NFC"</string>
    <string name="android_beam_off_summary" msgid="4663095428454779138">"Désactivé"</string>
    <string name="nfc_disabled_summary" msgid="3507017304297395467">"Non accessible, car la NFC est désactivée"</string>
    <string name="android_beam_label" msgid="6257036050366775040">"Android Beam"</string>
    <string name="android_beam_explained" msgid="1810540319385192758">"Lorsque cette fonctionnalité est activée, vous pouvez partager le contenu d\'une application avec un appareil compatible NFC en rapprochant les appareils. Vous pouvez, par exemple, partager des pages Web, des vidéos YouTube, des contacts et plus encore.\n\nIl vous suffit de rapprocher les appareils (en les plaçant généralement dos à dos), puis de toucher votre écran. L\'application détermine le contenu à transférer."</string>
    <string name="wifi_quick_toggle_title" msgid="8850161330437693895">"Wi-Fi"</string>
    <string name="wifi_quick_toggle_summary" msgid="2696547080481267642">"Activer le Wi-Fi"</string>
    <string name="wifi_settings" msgid="29722149822540994">"Wi-Fi"</string>
    <string name="wifi_settings_master_switch_title" msgid="4746267967669683259">"Utiliser le Wi-Fi"</string>
    <string name="wifi_settings_category" msgid="8719175790520448014">"Paramètres Wi-Fi"</string>
    <string name="wifi_settings_title" msgid="3103415012485692233">"Wi-Fi"</string>
    <string name="wifi_settings_summary" msgid="668767638556052820">"Configurer et gérer les points d\'accès sans fil"</string>
    <string name="wifi_select_network" msgid="4210954938345463209">"Sélectionner le Wi-Fi"</string>
    <string name="wifi_starting" msgid="6732377932749942954">"Activation du Wi-Fi en cours…"</string>
    <string name="wifi_stopping" msgid="8952524572499500804">"Désactivation du Wi-Fi en cours…"</string>
    <string name="wifi_error" msgid="3207971103917128179">"Erreur"</string>
    <string name="wifi_sap_no_channel_error" msgid="3108445199311817111">"La bande de 5 GHz n\'est pas disponible dans ce pays"</string>
    <string name="wifi_in_airplane_mode" msgid="8652520421778203796">"En mode Avion"</string>
    <string name="wifi_notify_open_networks" msgid="76298880708051981">"Notifications de réseaux ouverts"</string>
    <string name="wifi_notify_open_networks_summary" msgid="2761326999921366960">"M\'informer quand un réseau public de haute qualité se trouve à proximité"</string>
    <string name="wifi_wakeup" msgid="8815640989361538036">"Activer le Wi-Fi automatiquement"</string>
    <string name="wifi_wakeup_summary" msgid="2530814331062997163">"Le Wi‑Fi se réactivera automatiquement à proximité des réseaux de haute qualité qui sont enregistrés, comme celui de votre domicile"</string>
    <string name="wifi_wakeup_summary_no_location" msgid="7494539594649967699">"Cette fonction n\'est pas accessible, car le service de localisation est désactivé. Activez la "<annotation id="link">"localisation"</annotation>"."</string>
    <string name="wifi_wakeup_summary_scanning_disabled" msgid="7247227922074840445">"Cette fonction n\'est pas accessible, car la recherche de réseaux Wi-Fi est désactivée"</string>
    <string name="wifi_wakeup_summary_scoring_disabled" msgid="108339002136866897">"Pour utiliser cette option, sélectionnez un fournisseur d\'avis sur le réseau"</string>
    <string name="wifi_poor_network_detection" msgid="4925789238170207169">"Éviter les connexions instables"</string>
    <string name="wifi_poor_network_detection_summary" msgid="7016103106105907127">"Ne pas utiliser de réseau Wi-Fi, sauf en cas de connexion Internet de bonne qualité"</string>
    <string name="wifi_avoid_poor_network_detection_summary" msgid="1644292503152790501">"N\'utiliser que réseaux offrant une connexion Internet stable"</string>
    <string name="use_open_wifi_automatically_title" msgid="6851951242903078588">"Se connecter auto. aux réseaux ouverts"</string>
    <string name="use_open_wifi_automatically_summary" msgid="2982091714252931713">"Se connecter automatiquement aux réseaux publics de haute qualité"</string>
    <string name="use_open_wifi_automatically_summary_scoring_disabled" msgid="593964217679325831">"Pour utiliser cette option, sélectionnez un fournisseur d\'avis sur le réseau"</string>
    <string name="use_open_wifi_automatically_summary_scorer_unsupported_disabled" msgid="8472122600853650258">"Pour utiliser cette option, sélectionnez un fournisseur d\'avis sur le réseau compatible"</string>
    <string name="wifi_install_credentials" msgid="3551143317298272860">"Installer les certificats"</string>
    <string name="wifi_scan_notify_text" msgid="5544778734762998889">"Pour améliorer la précision de la localisation, les applications et les services peuvent quand même rechercher des réseaux Wi‑Fi en tout temps, même lorsque le Wi‑Fi est désactivé. Cela pourrait être utilisé, par exemple, pour améliorer les fonctionnalités et les services qui utilisent la localisation. Vous pouvez modifier vos préférences dans les <xliff:g id="LINK_BEGIN_0">LINK_BEGIN</xliff:g>paramètres de recherche<xliff:g id="LINK_END_1">LINK_END</xliff:g>."</string>
    <string name="wifi_scan_notify_text_scanning_off" msgid="3426075479272242098">"Pour améliorer la précision de la localisation, activez la recherche de réseaux Wi-Fi dans les <xliff:g id="LINK_BEGIN_0">LINK_BEGIN</xliff:g>paramètres de recherche<xliff:g id="LINK_END_1">LINK_END</xliff:g>."</string>
    <string name="wifi_scan_notify_remember_choice" msgid="7104867814641144485">"Ne plus afficher"</string>
    <string name="wifi_setting_sleep_policy_title" msgid="5149574280392680092">"Wi-Fi actif en veille"</string>
    <string name="wifi_setting_on_during_sleep_title" msgid="8308975500029751565">"Wi‑Fi activé pendant la veille"</string>
    <string name="wifi_setting_sleep_policy_error" msgid="8174902072673071961">"Un problème est survenu lors de la modification des paramètres."</string>
    <string name="wifi_suspend_efficiency_title" msgid="2338325886934703895">"Améliorer l\'efficacité"</string>
    <string name="wifi_suspend_optimizations" msgid="1220174276403689487">"Optimisation du Wi-Fi"</string>
    <string name="wifi_suspend_optimizations_summary" msgid="4151428966089116856">"Minimiser la consommation de la batterie lorsque le Wi-Fi est activé"</string>
    <string name="wifi_limit_optimizations_summary" msgid="9000801068363468950">"Limiter énergie util. par Wi‑Fi"</string>
    <string name="wifi_switch_away_when_unvalidated" msgid="8593144541347373394">"Utiliser les données cellulaires si vous n\'avez plus accès à Internet par réseau Wi‑Fi."</string>
    <string name="wifi_cellular_data_fallback_title" msgid="8753386877755616476">"Passer automatiquement au réseau cellulaire"</string>
    <string name="wifi_cellular_data_fallback_summary" msgid="1403505355490119307">"Utiliser le réseau de données cellulaires lorsque le réseau Wi-Fi n\'a pas accès à Internet. Des frais d\'utilisation de données peuvent s\'appliquer."</string>
    <string name="wifi_add_network" msgid="6234851776910938957">"Ajouter un réseau"</string>
    <string name="wifi_configure_settings_preference_title" msgid="2913345003906899146">"Préférences Wi-Fi"</string>
    <string name="wifi_configure_settings_preference_summary_wakeup_on" msgid="646393113104367290">"Le Wi-Fi se réactive automatiquement"</string>
    <string name="wifi_configure_settings_preference_summary_wakeup_off" msgid="2782566279864356713">"Le Wi-Fi ne se réactive pas automatiquement"</string>
    <string name="wifi_access_points" msgid="7053990007031968609">"Réseaux Wi-Fi"</string>
    <string name="wifi_menu_more_options" msgid="2448097861752719396">"Plus d\'options"</string>
    <string name="wifi_menu_p2p" msgid="7619851399250896797">"Wi-Fi Direct"</string>
    <string name="wifi_menu_scan" msgid="1470911530412095868">"Scanner"</string>
    <string name="wifi_menu_advanced" msgid="7522252991919573664">"Options avancées"</string>
    <string name="wifi_menu_configure" msgid="6150926852602171938">"Configurer"</string>
    <string name="wifi_menu_connect" msgid="4996220309848349408">"Se connecter au réseau"</string>
    <string name="wifi_menu_remember" msgid="8814185749388713796">"Mémoriser ce réseau"</string>
    <string name="wifi_menu_forget" msgid="8736964302477327114">"Retirer le réseau"</string>
    <string name="wifi_menu_modify" msgid="2068554918652440105">"Modifier le réseau"</string>
    <string name="wifi_empty_list_wifi_off" msgid="8056223875951079463">"Activez le Wi-Fi pour voir les réseaux disponibles."</string>
    <string name="wifi_empty_list_wifi_on" msgid="8746108031587976356">"Recherche de réseaux Wi-Fi en cours…"</string>
    <string name="wifi_empty_list_user_restricted" msgid="7322372065475939129">"Vous n\'avez pas l\'autorisation de modifier le réseau Wi‑Fi."</string>
    <string name="wifi_more" msgid="3195296805089107950">"More"</string>
    <string name="wifi_setup_wps" msgid="8128702488486283957">"Configuration auto (WPS)"</string>
    <string name="wifi_settings_scanning_required_title" msgid="3815269816331500375">"Activer la recherche de réseaux Wi-Fi?"</string>
    <string name="wifi_settings_scanning_required_summary" msgid="6352918945128328916">"Pour activer automatiquement le Wi-Fi, vous devez d\'abord activer la recherche de réseaux Wi-Fi."</string>
    <string name="wifi_settings_scanning_required_info" msgid="3155631874578023647">"La recherche de réseaux Wi-Fi permet aux applications et aux services de rechercher les réseaux Wi-Fi en tout temps, même lorsque le Wi-Fi est désactivé. Cette autorisation peut permettre, par exemple, d\'améliorer les fonctionnalités et les services basés sur la localisation."</string>
    <string name="wifi_settings_scanning_required_turn_on" msgid="1364287182804820646">"Activer"</string>
    <string name="wifi_settings_scanning_required_enabled" msgid="5527653791584018157">"La recherche de réseaux Wi-Fi est activée"</string>
    <string name="wifi_show_advanced" msgid="3409422789616520979">"Options avancées"</string>
    <string name="wifi_advanced_toggle_description_expanded" msgid="2380600578544493084">"Liste déroulante Options avancées. Touchez deux fois pour la réduire."</string>
    <string name="wifi_advanced_toggle_description_collapsed" msgid="1463812308429197263">"Liste déroulante Options avancées. Touchez deux fois pour la développer."</string>
    <string name="wifi_ssid" msgid="5519636102673067319">"Nom du réseau"</string>
    <string name="wifi_ssid_hint" msgid="897593601067321355">"Entrez le SSID"</string>
    <string name="wifi_security" msgid="6603611185592956936">"Sécurité"</string>
    <string name="wifi_hidden_network" msgid="973162091800925000">"Réseau masqué"</string>
    <string name="wifi_hidden_network_warning" msgid="6674068093531603452">"Si votre routeur ne diffuse pas de nom de réseau, mais que vous souhaitez vous y connecter plus tard, vous pouvez configurer un réseau masqué.\n\nCette configuration peut présenter un risque de sécurité, car votre téléphone diffusera son signal régulièrement afin de détecter le réseau.\n\nLe fait de configurer un réseau masqué n’aura aucun impact sur les paramètres de votre routeur."</string>
    <string name="wifi_signal" msgid="5514120261628065287">"Intensité du signal"</string>
    <string name="wifi_status" msgid="4824568012414605414">"État"</string>
    <string name="tx_wifi_speed" msgid="2994278184097786511">"Vitesse du lien de transmission"</string>
    <string name="rx_wifi_speed" msgid="7206089638282839236">"Recevoir la vitesse du lien"</string>
    <string name="wifi_frequency" msgid="7791090119577812214">"Fréquence"</string>
    <string name="wifi_ip_address" msgid="1440054061044402918">"Adresse IP"</string>
    <string name="passpoint_label" msgid="6381371313076009926">"Enregistré par"</string>
    <string name="passpoint_content" msgid="8447207162397870483">"Données de connexion pour <xliff:g id="NAME">%1$s</xliff:g>"</string>
    <string name="wifi_eap_method" msgid="8529436133640730382">"Méthode EAP"</string>
    <string name="please_select_phase2" msgid="5231074529772044898">"Authentification de la phase 2"</string>
    <string name="wifi_eap_ca_cert" msgid="3521574865488892851">"Certificat CA"</string>
    <string name="wifi_eap_domain" msgid="8471124344218082064">"Domaine"</string>
    <string name="wifi_eap_user_cert" msgid="1291089413368160789">"Certificat utilisateur"</string>
    <string name="wifi_eap_identity" msgid="4359453783379679103">"Identité"</string>
    <string name="wifi_eap_anonymous" msgid="2989469344116577955">"Anonyme"</string>
    <string name="wifi_password" msgid="5948219759936151048">"Mot de passe"</string>
    <string name="wifi_show_password" msgid="6461249871236968884">"Afficher le mot de passe"</string>
    <string name="wifi_ap_band_config" msgid="1611826705989117930">"Sélectionner la bande du point d\'accès"</string>
    <string name="wifi_ap_choose_auto" msgid="2677800651271769965">"Auto"</string>
    <string name="wifi_ap_choose_2G" msgid="8724267386885036210">"Bande de 2,4 GHz"</string>
    <string name="wifi_ap_choose_5G" msgid="8813128641914385634">"Bande de 5 GHz"</string>
    <string name="wifi_ap_prefer_5G" msgid="2501070491623803139">"Préférer la bande de 5,0 GHz"</string>
    <string name="wifi_ap_2G" msgid="8378132945192979364">"2,4 GHz"</string>
    <string name="wifi_ap_5G" msgid="4020713496716329468">"5 GHz"</string>
    <string name="wifi_ap_band_select_one" msgid="3476254666116431650">"Choisissez au moins une bande pour le point d\'accès Wi-Fi :"</string>
    <string name="wifi_ip_settings" msgid="3359331401377059481">"Paramètres IP"</string>
    <string name="wifi_privacy_settings" msgid="5500777170960315928">"Confidentialité"</string>
    <string name="wifi_privacy_settings_ephemeral_summary" msgid="1539659414108891004">"Adresse MAC aléatoire"</string>
    <string name="wifi_dpp_add_device_to_network" msgid="8674936581557695411">"Ajouter un appareil"</string>
    <string name="wifi_dpp_center_qr_code" msgid="6244508369721032655">"Centrez le code QR ci-dessous pour ajouter l\'appareil à « <xliff:g id="SSID">%1$s</xliff:g> »"</string>
    <string name="wifi_dpp_scan_qr_code" msgid="4794621158747044107">"Numériser le code QR"</string>
    <string name="wifi_dpp_scan_qr_code_join_network" msgid="4371771604088014396">"Centrez le code QR ci-dessous pour vous connecter à « <xliff:g id="SSID">%1$s</xliff:g> »"</string>
    <string name="wifi_dpp_scan_qr_code_join_unknown_network" msgid="8096370383700478819">"Connectez-vous au Wi-Fi en numérisant un code QR"</string>
    <string name="wifi_dpp_share_wifi" msgid="9065890131734833809">"Partager le Wi‑Fi"</string>
    <string name="wifi_dpp_scan_qr_code_with_another_device" msgid="5854392840857123065">"Numérisez ce code QR pour établir la connexion au réseau « <xliff:g id="SSID">%1$s</xliff:g> » et partager le mot de passe"</string>
    <string name="wifi_dpp_scan_open_network_qr_code_with_another_device" msgid="4436318319178361543">"Numérisez ce code QR pour établir la connexion au réseau « <xliff:g id="SSID">%1$s</xliff:g> »"</string>
    <string name="wifi_dpp_failure_authentication_or_configuration" msgid="3372757783382381044">"Réessayez. Si le problème persiste, communiquez avec le fabricant de l\'appareil"</string>
    <string name="wifi_dpp_failure_not_compatible" msgid="2829930473520603740">"Un problème s\'est produit"</string>
    <string name="wifi_dpp_failure_timeout" msgid="5228320772245820458">"Assurez-vous que l\'appareil a été branché, chargé et allumé"</string>
    <string name="wifi_dpp_failure_generic" msgid="8030831192606098356">"Assurez-vous que l\'appareil a été branché, chargé et allumé. Si le problème persiste, communiquez avec le fabricant de l\'appareil"</string>
    <string name="wifi_dpp_failure_not_supported" msgid="2643768115109632725">"L\'ajout de « <xliff:g id="SSID">%1$s</xliff:g> » n\'est pas pris en charge sur cet appareil"</string>
    <string name="wifi_dpp_check_connection_try_again" msgid="2632966336733361805">"Vérifiez votre connexion et réessayez"</string>
    <string name="wifi_dpp_choose_network" msgid="7139308800110200281">"Choisir un réseau"</string>
    <string name="wifi_dpp_choose_network_to_connect_device" msgid="4025269026652486605">"Pour connecter votre appareil, choisissez un réseau"</string>
    <string name="wifi_dpp_add_device_to_wifi" msgid="5459084866460319042">"Ajouter cet appareil au réseau « <xliff:g id="SSID">%1$s</xliff:g> »?"</string>
    <string name="wifi_dpp_wifi_shared_with_device" msgid="7669684043486750097">"Wi‑Fi partagé avec cet appareil"</string>
    <string name="wifi_dpp_add_another_device" msgid="8415243205104666929">"Ajouter un appareil"</string>
    <string name="wifi_dpp_choose_different_network" msgid="4081965219206680361">"Choisir un réseau différent"</string>
    <string name="wifi_dpp_could_not_add_device" msgid="1598945041477461501">"Impossible d\'ajouter l\'appareil"</string>
    <string name="wifi_dpp_device_found" msgid="8618134150169810107">"Appareil trouvé"</string>
    <string name="wifi_dpp_sharing_wifi_with_this_device" msgid="5579154298588011712">"Partage du Wi‑Fi avec cet appareil en cours…"</string>
    <string name="wifi_dpp_connecting" msgid="7111851118215580428">"Connexion en cours…"</string>
    <string name="wifi_dpp_share_hotspot" msgid="762408459341741405">"Partager le point d\'accès"</string>
    <string name="wifi_dpp_lockscreen_title" msgid="8401802203867904622">"Confirmer que c\'est bien vous"</string>
    <string name="wifi_dpp_wifi_password" msgid="4938294574591503213">"Mot de passe Wi-Fi : <xliff:g id="PASSWORD">%1$s</xliff:g>"</string>
    <string name="wifi_dpp_hotspot_password" msgid="4120419278831581613">"Mot de passe du point d\'accès : <xliff:g id="PASSWORD">%1$s</xliff:g>"</string>
    <string name="wifi_dpp_add_device" msgid="4072206063308645677">"Ajouter un appareil"</string>
    <string name="wifi_dpp_connect_network_using_qr_code" msgid="3887335309163999665">"Utiliser un code QR pour ajouter un appareil à ce réseau"</string>
    <string name="wifi_dpp_qr_code_is_not_valid_format" msgid="3700087439867692944">"Le format du code QR est incorrect"</string>
    <string name="retry" msgid="6472609612090877557">"Réessayer"</string>
    <string name="wifi_shared" msgid="844142443226926070">"Partager avec d\'autres utilisateurs d\'appareils"</string>
    <string name="wifi_unchanged" msgid="3410422020930397102">"(aucune modification)"</string>
    <string name="wifi_unspecified" msgid="4917316464723064807">"Veuillez choisir"</string>
    <string name="wifi_multiple_cert_added" msgid="3240743501460165224">"(Certificats multiples ajoutés)"</string>
    <string name="wifi_use_system_certs" msgid="5270879895056893783">"Utiliser les certificats système"</string>
    <string name="wifi_do_not_provide_eap_user_cert" msgid="5160499244977160665">"Ne pas fournir"</string>
    <string name="wifi_do_not_validate_eap_server" msgid="4266754430576348471">"Ne pas valider"</string>
    <string name="wifi_do_not_validate_eap_server_warning" msgid="1787190245542586660">"Aucun certificat indiqué. Votre connexion ne sera pas privée."</string>
    <string name="wifi_ssid_too_long" msgid="3474753269579895244">"Le nom du réseau est trop long."</string>
    <string name="wifi_no_domain_warning" msgid="5223011964091727376">"Vous devez spécifier un domaine."</string>
    <string name="wifi_wps_available_first_item" msgid="4422547079984583502">"WPS disponible"</string>
    <string name="wifi_wps_available_second_item" msgid="8427520131718215301">" (WPS disponible)"</string>
    <string name="wifi_carrier_connect" msgid="8174696557882299911">"Réseau Wi-Fi du fournisseur de services"</string>
    <string name="wifi_carrier_content" msgid="4634077285415851933">"Se connecter au réseau de <xliff:g id="NAME">%1$s</xliff:g>"</string>
    <string name="wifi_scan_always_turnon_message" msgid="203123538572122989">"Pour améliorer la précision de la position et à d\'autres fins, <xliff:g id="APP_NAME">%1$s</xliff:g> souhaite activer la recherche de réseaux, même lorsque le Wi-Fi est désactivé.\n\nDonner cette autorisation à toutes les applications souhaitant activer la recherche de réseaux?"</string>
    <string name="wifi_scan_always_turn_on_message_unknown" msgid="6162424298483845679">"Pour améliorer la précision de la position, une appli inconnue souhaite activer la recherche de réseaux, même lorsque le Wi-Fi est désactivé.\n\nAutoriser toutes les applis qui le demandent?"</string>
    <string name="wifi_scan_always_turnoff_message" msgid="5538901671131941043">"Pour désactiver cette option, sélectionnez « Paramètres avancés » dans le menu à développer."</string>
    <string name="wifi_scan_always_confirm_allow" msgid="5355973075896817232">"Autoriser"</string>
    <string name="wifi_scan_always_confirm_deny" msgid="4463982053823520710">"Refuser"</string>
    <string name="wifi_hotspot_title" msgid="7726205804813286950">"Se connecter au point d\'accès pour la connexion?"</string>
    <string name="wifi_hotspot_message" msgid="3673833421453455747">"<xliff:g id="APP_NAME">%1$s</xliff:g> requiert connexion pour autoriser l\'accès réseau."</string>
    <string name="wifi_hotspot_connect" msgid="5065506390164939225">"CONNEXION"</string>
    <string name="no_internet_access_text" msgid="5926979351959279577">"Ce réseau ne dispose d\'aucun accès à Internet. Voulez-vous quand même l\'utiliser?"</string>
    <string name="partial_connectivity_text" msgid="1287030663891772340">"Connectivité limitée : certains services et applis pourraient ne pas fonctionner. Utiliser quand même?"</string>
    <string name="no_internet_access_remember" msgid="4697314331614625075">"Ne plus me demander pour ce réseau"</string>
    <string name="lost_internet_access_title" msgid="5779478650636392426">"Le Wi‑Fi n\'est pas connecté à Internet"</string>
    <string name="lost_internet_access_text" msgid="9029649339816197345">"Vous pouvez passer au réseau cellulaire lorsque la connexion Wi‑Fi est faible. Des frais de données peuvent s\'appliquer."</string>
    <string name="lost_internet_access_switch" msgid="2262459569601190039">"Passer au réseau cellulaire"</string>
    <string name="lost_internet_access_cancel" msgid="338273139419871110">"Rester connecté au Wi-Fi"</string>
    <string name="lost_internet_access_persist" msgid="7634876061262676255">"Ne plus afficher"</string>
    <string name="wifi_connect" msgid="1076622875777072845">"Connexion"</string>
    <string name="wifi_turned_on_message" msgid="4432839393213448846">"Wi-Fi activé"</string>
    <!-- no translation found for wifi_connected_to_message (2265022072754345638) -->
    <skip />
    <string name="wifi_connecting" msgid="8760426806460651215">"Connexion en cours…"</string>
    <!-- no translation found for wifi_disconnect (3445234285136039895) -->
    <skip />
    <string name="wifi_failed_connect_message" msgid="8491902558970292871">"Échec de la connexion au réseau."</string>
    <string name="wifi_not_in_range_message" msgid="6616864204007424228">"Réseau hors de portée"</string>
    <string name="wifi_forget" msgid="8168174695608386644">"Supprimer"</string>
    <string name="wifi_modify" msgid="6100248070440710782">"Modifier"</string>
    <string name="wifi_failed_forget_message" msgid="1348172929201654986">"Échec de la suppression du réseau."</string>
    <string name="wifi_save" msgid="3331121567988522826">"Enregistrer"</string>
    <string name="wifi_failed_save_message" msgid="6650004874143815692">"Échec de l\'enregistrement du réseau."</string>
    <string name="wifi_cancel" msgid="6763568902542968964">"Annuler"</string>
    <string name="wifi_forget_dialog_title" msgid="6224151903586192426">"Oublier le réseau?"</string>
    <string name="wifi_forget_dialog_message" msgid="2337060138532166680">"Tous les mots de passe de ce réseau seront supprimés"</string>
    <plurals name="wifi_saved_access_points_summary" formatted="false" msgid="6094679048871529675">
      <item quantity="one">%d réseau</item>
      <item quantity="other">%d réseaux</item>
    </plurals>
    <plurals name="wifi_saved_passpoint_access_points_summary" formatted="false" msgid="8256430439661111672">
      <item quantity="one">%d abonnement</item>
      <item quantity="other">%d abonnements</item>
    </plurals>
    <plurals name="wifi_saved_all_access_points_summary" formatted="false" msgid="2504425359919617586">
      <item quantity="one">%d réseau et abonnement</item>
      <item quantity="other">%d réseaux et abonnements</item>
    </plurals>
    <string name="wifi_advanced_titlebar" msgid="4485841401774142908">"Paramètres Wi-Fi avancés"</string>
    <string name="wifi_advanced_ssid_title" msgid="1552309166043760291">"SSID"</string>
    <string name="wifi_advanced_mac_address_title" msgid="6571335466330978393">"Adresse MAC"</string>
    <string name="wifi_advanced_ip_address_title" msgid="6215297094363164846">"Adresse IP"</string>
    <string name="wifi_details_title" msgid="8954667664081737098">"Détails du réseau"</string>
    <string name="wifi_details_subnet_mask" msgid="6720279144174924410">"Masque de sous-réseau"</string>
    <string name="wifi_details_dns" msgid="8648826607751830768">"DNS"</string>
    <string name="wifi_details_ipv6_address_header" msgid="6734119149106422148">"Adresses IPv6"</string>
    <string name="wifi_saved_access_points_label" msgid="2013409399392285262">"Réseaux enregistrés"</string>
    <string name="wifi_subscribed_access_points_tab" msgid="6480224551765489055">"Abonnements"</string>
    <!-- no translation found for wifi_saved_access_points_tab (2659675386657663705) -->
    <skip />
    <string name="wifi_advanced_settings_label" msgid="3654366894867838338">"Paramètres IP"</string>
    <string name="wifi_advanced_not_available" msgid="5823045095444154586">"Les paramètres Wi-Fi avancés ne sont pas accessibles pour cet utilisateur"</string>
    <string name="wifi_ip_settings_menu_save" msgid="7296724066102908366">"Enregistrer"</string>
    <string name="wifi_ip_settings_menu_cancel" msgid="6582567330136502340">"Annuler"</string>
    <string name="wifi_ip_settings_invalid_ip_address" msgid="2513142355364274970">"Saisissez une adresse IP valide."</string>
    <string name="wifi_ip_settings_invalid_gateway" msgid="8164264988361096450">"Saisissez une adresse de passerelle valide."</string>
    <string name="wifi_ip_settings_invalid_dns" msgid="8744583948328391047">"Saisissez une adresse DNS correcte."</string>
    <string name="wifi_ip_settings_invalid_network_prefix_length" msgid="40470058023181052">"Le préfixe réseau doit être compris entre 0 et 32."</string>
    <string name="wifi_dns1" msgid="7344118050720080045">"DNS 1"</string>
    <string name="wifi_dns2" msgid="1368601006824882659">"DNS 2"</string>
    <string name="wifi_gateway" msgid="163914742461092086">"Passerelle"</string>
    <string name="wifi_network_prefix_length" msgid="3028785234245085998">"Longueur préfixe réseau"</string>
    <string name="wifi_p2p_settings_title" msgid="5444461191435291082">"Wi-Fi Direct"</string>
    <string name="wifi_p2p_device_info" msgid="3191876744469364173">"Données relatives à l\'appareil utilisé"</string>
    <string name="wifi_p2p_persist_network" msgid="1646424791818168590">"Mémoriser cette connexion"</string>
    <string name="wifi_p2p_menu_search" msgid="3436429984738771974">"Rechercher des appareils"</string>
    <string name="wifi_p2p_menu_searching" msgid="2396704492143633876">"Recherche en cours…"</string>
    <string name="wifi_p2p_menu_rename" msgid="8448896306960060415">"Renommer l\'appareil"</string>
    <string name="wifi_p2p_peer_devices" msgid="299526878463303432">"Appareils associés"</string>
    <string name="wifi_p2p_remembered_groups" msgid="3847022927914068230">"Groupes mémorisés"</string>
    <string name="wifi_p2p_failed_connect_message" msgid="8491862096448192157">"Impossible de se connecter."</string>
    <string name="wifi_p2p_failed_rename_message" msgid="2562182284946936380">"Échec du changement de nom de l\'appareil."</string>
    <string name="wifi_p2p_disconnect_title" msgid="3216846049677448420">"Voulez-vous vraiment vous déconnecter?"</string>
    <string name="wifi_p2p_disconnect_message" msgid="8227342771610125771">"If you disconnect, your connection with <xliff:g id="PEER_NAME">%1$s</xliff:g> will end."</string>
    <string name="wifi_p2p_disconnect_multiple_message" msgid="3283805371034883105">"Si vous vous déconnectez, votre connexion avec <xliff:g id="PEER_NAME">%1$s</xliff:g> et <xliff:g id="PEER_COUNT">%2$s</xliff:g> autres appareils prendra fin."</string>
    <string name="wifi_p2p_cancel_connect_title" msgid="255267538099324413">"Annuler l\'invitation?"</string>
    <string name="wifi_p2p_cancel_connect_message" msgid="7477756213423749402">"Voulez-vous annuler l\'invitation à se connecter avec <xliff:g id="PEER_NAME">%1$s</xliff:g>?"</string>
    <string name="wifi_p2p_delete_group_message" msgid="834559380069647086">"Voulez-vous vraiment supprimer ce groupe?"</string>
    <string name="wifi_hotspot_checkbox_text" msgid="7763495093333664887">"Point d\'accès Wi‑Fi"</string>
    <string name="wifi_hotspot_off_subtext" msgid="2199911382555864644">"Connexion Internet ou contenu non partagés avec d\'autres appareils"</string>
    <string name="wifi_hotspot_tethering_on_subtext" product="tablet" msgid="5936710887156133458">"La connexion Internet de la tablette est partagée à l\'aide d\'un point d\'accès"</string>
    <string name="wifi_hotspot_tethering_on_subtext" product="default" msgid="5556202634866621632">"La connexion Internet du téléphone est partagée à l\'aide d\'un point d\'accès"</string>
    <string name="wifi_hotspot_on_local_only_subtext" msgid="5017191966153008">"L\'application partage du contenu. Pour partager la connexion Internet, désactivez puis réactivez le point d\'accès."</string>
    <string name="wifi_hotspot_no_password_subtext" msgid="353306131026431089">"Aucun mot de passe défini"</string>
    <string name="wifi_hotspot_name_title" msgid="8237000746618636778">"Nom du point d\'accès"</string>
    <string name="wifi_hotspot_name_summary_connecting" msgid="3378299995508671967">"Activation du point d\'accès <xliff:g id="WIFI_HOTSPOT_NAME">%1$s</xliff:g> en cours…"</string>
    <string name="wifi_hotspot_name_summary_connected" msgid="3888672084861445362">"D\'autres appareils peuvent se connecter à <xliff:g id="WIFI_HOTSPOT_NAME">%1$s</xliff:g>"</string>
    <string name="wifi_hotspot_password_title" msgid="8676859981917573801">"Mot de passe du point d\'accès"</string>
    <string name="wifi_hotspot_ap_band_title" msgid="1165801173359290681">"Bande du point d\'accès"</string>
    <string name="wifi_hotspot_footer_info_regular" msgid="4789553667374849566">"Un point d\'accès vous permet de créer un réseau Wi-Fi pour vos autres appareils. Il les connecte à Internet en utilisant votre connexion de données cellulaires. Des frais supplémentaires peuvent s\'appliquer."</string>
    <string name="wifi_hotspot_footer_info_local_only" msgid="857988412470694109">"Les applications peuvent créer un point d\'accès pour partager du contenu avec les appareils à proximité."</string>
    <string name="wifi_hotspot_auto_off_title" msgid="1590313508558948079">"Désactiver automatiquement le point d\'accès Wi‑Fi"</string>
    <string name="wifi_hotspot_auto_off_summary" msgid="5858098059725925084">"Le point d\'accès Wi‑Fi se désactive si aucun appareil n\'est connecté"</string>
    <string name="wifi_tether_starting" msgid="1322237938998639724">"Activation du point d\'accès Wi-Fi en cours…"</string>
    <string name="wifi_tether_stopping" msgid="4835852171686388107">"Désactivation du point d\'accès Wi-Fi en cours…"</string>
    <string name="wifi_tether_enabled_subtext" msgid="7842111748046063857">"<xliff:g id="NETWORK_SSID">%1$s</xliff:g> est actif"</string>
    <string name="wifi_tether_failed_subtext" msgid="1484941858530919002">"Erreur liée au point d\'accès Wi-Fi mobile."</string>
    <string name="wifi_tether_configure_ap_text" msgid="7974681394041609308">"Configurer le point d\'accès Wi-Fi"</string>
    <string name="wifi_hotspot_configure_ap_text" msgid="5478614731464220432">"Configuration point accès Wi‑Fi"</string>
    <string name="wifi_hotspot_configure_ap_text_summary" msgid="5560680057727007011">"Point d\'accès AndroidAP WPA2 PSK"</string>
    <string name="wifi_tether_configure_ssid_default" msgid="8467525402622138547">"AndroidHotspot"</string>
    <string name="wifi_calling_settings_title" msgid="4102921303993404577">"Appels Wi-Fi"</string>
    <string name="wifi_calling_suggestion_title" msgid="5702964371483390024">"Étendez la portée des appels avec le Wi-Fi"</string>
    <string name="wifi_calling_suggestion_summary" msgid="1331793267608673739">"Activez les appels Wi-Fi pour étendre la couverture"</string>
    <string name="wifi_calling_mode_title" msgid="2164073796253284289">"Préférences d\'appel"</string>
    <string name="wifi_calling_mode_dialog_title" msgid="7105195222267749226">"Préférences d\'appel"</string>
    <string name="wifi_calling_roaming_mode_title" msgid="1565039047187685115">"Préférences d\'itinérance"</string>
    <!-- no translation found for wifi_calling_roaming_mode_summary (8642014873060687717) -->
    <skip />
    <string name="wifi_calling_roaming_mode_dialog_title" msgid="7800926602662078576">"Préférences d\'itinérance"</string>
  <string-array name="wifi_calling_mode_choices_v2">
    <item msgid="742988808283756263">"Wi-Fi"</item>
    <item msgid="7715869266611010880">"Cellulaire"</item>
    <item msgid="2838022395783120596">"Wi-Fi seulement"</item>
  </string-array>
  <string-array name="wifi_calling_mode_choices_v2_without_wifi_only">
    <item msgid="6132150507201243768">"Wi-Fi"</item>
    <item msgid="1118703915148755405">"Cellulaire"</item>
  </string-array>
    <string name="wifi_calling_mode_wifi_preferred_summary" msgid="9092988115148569860">"Si aucun réseau Wi‑Fi n\'est accessible, utiliser le réseau cellulaire"</string>
    <string name="wifi_calling_mode_cellular_preferred_summary" msgid="240885549023046403">"Si le réseau cellulaire n\'est pas accessible, utiliser le Wi‑Fi"</string>
    <string name="wifi_calling_mode_wifi_only_summary" msgid="3688265826855460036">"Appeler sur réseau Wi‑Fi. Si le Wi‑Fi est interr., l\'appel prendra fin."</string>
    <string name="wifi_calling_off_explanation" msgid="564780186974911501">"Lorsque les appels Wi-Fi sont activés, votre téléphone peut transférer les appels par réseau Wi-Fi ou le réseau de votre fournisseur de services, en fonction de votre préférence et du signal le plus puissant. Avant d\'activer cette fonctionnalité, renseignez-vous auprès de votre fournisseur pour en savoir plus sur les frais et d\'autres détails pertinents.<xliff:g id="ADDITIONAL_TEXT">%1$s</xliff:g>"</string>
    <string name="wifi_calling_off_explanation_2" msgid="2329334487851497223"></string>
    <string name="emergency_address_title" msgid="932729250447887545">"Adresse d\'urgence"</string>
    <string name="emergency_address_summary" msgid="7751971156196115129">"Cette adresse sera définie comme votre position géographique lorsque vous effectuerez des appels d\'urgence par Wi-Fi"</string>
    <string name="private_dns_help_message" msgid="3299567069152568958"><annotation id="url">"En savoir plus"</annotation>" sur la fonctionnalité de DNS privé"</string>
    <string name="wifi_calling_pref_managed_by_carrier" msgid="6845711858866828986">"Ce paramètre est géré par votre fournisseur de services"</string>
    <string name="wifi_calling_settings_activation_instructions" msgid="7492509632478260955">"Activer les appels Wi-Fi"</string>
    <string name="wifi_calling_turn_on" msgid="1171403510313983983">"Activer les appels Wi-Fi"</string>
    <string name="wifi_calling_not_supported" msgid="7878640438907807754">"%1$s ne prend pas en charge les appels Wi-Fi"</string>
    <string name="carrier" msgid="5264014738689761132">"Fournisseur de service"</string>
    <string name="display_settings_title" msgid="1708697328627382561">"Affichage"</string>
    <string name="sound_settings" msgid="5534671337768745343">"Son"</string>
    <string name="all_volume_title" msgid="4296957391257836961">"Volume"</string>
    <string name="musicfx_title" msgid="3415566786340790345">"Effets musicaux"</string>
    <string name="ring_volume_title" msgid="5592466070832128777">"Volume de la sonnerie"</string>
    <string name="vibrate_in_silent_title" msgid="3897968069156767036">"Vibrer en mode silencieux"</string>
    <string name="notification_sound_title" msgid="5137483249425507572">"Son de notification par défaut"</string>
    <string name="incoming_call_volume_title" msgid="8073714801365904099">"Sonnerie"</string>
    <string name="notification_volume_title" msgid="2012640760341080408">"Notification"</string>
    <string name="checkbox_notification_same_as_incoming_call" msgid="1073644356290338921">"Utiliser le volume des appels entrants pour les notifications"</string>
    <string name="home_work_profile_not_supported" msgid="1357721012342357037">"Non compatible avec les profils professionnels"</string>
    <string name="notification_sound_dialog_title" msgid="3805140135741385667">"Son de notification par défaut"</string>
    <string name="media_volume_title" msgid="3576565767317118106">"Médias"</string>
    <string name="media_volume_summary" msgid="5363248930648849974">"Régler le volume pour la musique et les vidéos"</string>
    <string name="alarm_volume_title" msgid="2285597478377758706">"Alarme"</string>
    <string name="dock_settings_summary" msgid="455802113668982481">"Paramètres audio de la station d\'accueil associée"</string>
    <string name="dtmf_tone_enable_title" msgid="8533399267725365088">"Numérotation sonore"</string>
    <string name="sound_effects_enable_title" msgid="4429690369187229592">"Sons des touches"</string>
    <string name="lock_sounds_enable_title" msgid="450098505659399520">"Son au verrouillage écran"</string>
    <string name="audio_record_proc_title" msgid="4271091199976457534">"Suppression du bruit"</string>
    <string name="volume_media_description" msgid="7949355934788807863">"Musique, vidéo, jeux et autres fichiers multimédias"</string>
    <string name="volume_ring_description" msgid="5936851631698298989">"Sonnerie et notifications"</string>
    <string name="volume_notification_description" msgid="5810902320215328321">"Notifications"</string>
    <string name="volume_alarm_description" msgid="8322615148532654841">"Alarmes"</string>
    <string name="volume_ring_mute" msgid="3018992671608737202">"Couper la sonnerie et le son des notifications"</string>
    <string name="volume_media_mute" msgid="3399059928695998166">"Couper le son de la musique et des autres médias"</string>
    <string name="volume_notification_mute" msgid="7955193480006444159">"Désactiver les notifications"</string>
    <string name="volume_alarm_mute" msgid="4452239420351035936">"Couper le son des alarmes"</string>
    <string name="dock_settings" msgid="1820107306693002541">"Dock"</string>
    <string name="dock_settings_title" msgid="9161438664257429372">"Paramètres station d’accueil"</string>
    <string name="dock_audio_settings_title" msgid="3324750259959570305">"Audio"</string>
    <string name="dock_audio_summary_desk" msgid="6487784412371139335">"Paramètres de la station d\'accueil de bureau associée"</string>
    <string name="dock_audio_summary_car" msgid="6740897586006248450">"Paramètres du support voiture associé"</string>
    <string name="dock_audio_summary_none" product="tablet" msgid="8215337394914283607">"Tablette non insérée dans la station d\'accueil"</string>
    <string name="dock_audio_summary_none" product="default" msgid="289909253741048784">"Le téléphone n\'est pas sur sa base."</string>
    <string name="dock_audio_summary_unknown" msgid="4465059868974255693">"Paramètres de la station d’accueil associée"</string>
    <string name="dock_not_found_title" msgid="3290961741828952424">"Station d\'accueil introuvable"</string>
    <string name="dock_not_found_text" product="tablet" msgid="8405432495282299143">"Vous devez poser la tablette sur la station d\'accueil avant de configurer les paramètres audio de cette dernière."</string>
    <string name="dock_not_found_text" product="default" msgid="1460497923342627801">"Vous devez poser le téléphone sur la station d\'accueil avant de configurer les paramètres audio de celle-ci."</string>
    <string name="dock_sounds_enable_title" msgid="885839627097024110">"Son d\'insertion dans la station d\'accueil"</string>
    <string name="dock_sounds_enable_summary_on" product="tablet" msgid="838102386448981339">"Émettre un son lorsque la tablette est insérée dans la station d\'accueil ou retirée de celle-ci"</string>
    <string name="dock_sounds_enable_summary_on" product="default" msgid="8491180514199743771">"Émettre un son lorsque le téléphone est inséré dans la station d\'accueil ou retiré de celle-ci"</string>
    <string name="dock_sounds_enable_summary_off" product="tablet" msgid="4308252722466813560">"N\'émettre aucun son lorsque la tablette est insérée dans la station d\'accueil ou retirée de celle-ci"</string>
    <string name="dock_sounds_enable_summary_off" product="default" msgid="2034927992716667672">"N\'émettre aucun son lorsque le téléphone est inséré dans la station d\'accueil ou retiré de celle-ci"</string>
    <string name="account_settings" msgid="6403589284618783461">"Comptes"</string>
    <string name="accessibility_category_work" msgid="4339262969083355720">"Comptes de profil professionnel - <xliff:g id="MANAGED_BY">%s</xliff:g>"</string>
    <string name="accessibility_category_personal" msgid="1263518850905945594">"Comptes de profil personnel"</string>
    <string name="accessibility_work_account_title" msgid="1231830766637939527">"Compte professionnel - <xliff:g id="MANAGED_BY">%s</xliff:g>"</string>
    <string name="accessibility_personal_account_title" msgid="2169071663029067826">"Compte personnel - <xliff:g id="MANAGED_BY">%s</xliff:g>"</string>
    <string name="search_settings" msgid="1910951467596035063">"Rechercher"</string>
    <string name="display_settings" msgid="7965901687241669598">"Affichage"</string>
    <string name="accelerometer_title" msgid="7854608399547349157">"Rotation auto de l\'écran"</string>
    <string name="color_mode_title" msgid="9186249332902370471">"Couleurs"</string>
    <string name="color_mode_option_natural" msgid="5013837483986772758">"Naturelles"</string>
    <string name="color_mode_option_boosted" msgid="8588223970257287524">"Intenses"</string>
    <string name="color_mode_option_saturated" msgid="4569683960058798843">"Saturées"</string>
    <string name="color_mode_option_automatic" msgid="7996505473528529568">"Adaptatif"</string>
    <string name="color_mode_summary_natural" msgid="6624188642920403099">"Utiliser uniquement les couleurs précises"</string>
    <string name="color_mode_summary_automatic" msgid="4669516973360709431">"Ajuster entre les couleurs vives et précises"</string>
    <string name="accelerometer_summary_on" product="tablet" msgid="429982132339828942">"Changer automatiquement d\'orientation lors de la rotation de la tablette"</string>
    <string name="accelerometer_summary_on" product="default" msgid="1133737282813048021">"Changer automatiquement d\'orientation lors de la rotation"</string>
    <string name="accelerometer_summary_off" product="tablet" msgid="4781734213242521682">"Changer automatiquement d\'orientation lors de la rotation de la tablette"</string>
    <string name="accelerometer_summary_off" product="default" msgid="5485489363715740761">"Changer automatiquement d\'orientation lors de la rotation"</string>
    <string name="brightness" msgid="8480105032417444275">"Niveau de luminosité"</string>
    <string name="brightness_title" msgid="5746272622112982836">"Luminosité"</string>
    <string name="brightness_summary" msgid="838917350127550703">"Régler la luminosité de l\'écran"</string>
    <string name="auto_brightness_title" msgid="6341042882350279391">"Luminosité adaptative"</string>
    <string name="auto_brightness_summary" msgid="5652108419977937800">"La luminosité de l\'écran s\'ajuste en fonction de l\'environnement"</string>
    <string name="auto_brightness_summary_on" msgid="3519854265558828744">"Activé"</string>
    <string name="auto_brightness_summary_off" msgid="2802336459335410626">"Désactivée"</string>
    <string name="auto_brightness_summary_very_low" msgid="6483976609035853764">"La luminosité préférée est très faible"</string>
    <string name="auto_brightness_summary_low" msgid="5609877905833960427">"La luminosité préférée est faible"</string>
    <string name="auto_brightness_summary_default" msgid="7225666614394726845">"La luminosité préférée est sélectionnée comme valeur par défaut"</string>
    <string name="auto_brightness_summary_high" msgid="7172304165631136027">"La luminosité préférée est élevée"</string>
    <string name="auto_brightness_summary_very_high" msgid="979277812582279078">"La luminosité préférée est très élevée"</string>
    <string name="auto_brightness_off_title" msgid="2996864829946190795">"Désactivée"</string>
    <string name="auto_brightness_very_low_title" msgid="8252988638614126320">"Très faible"</string>
    <string name="auto_brightness_low_title" msgid="1632186441514863377">"Faible"</string>
    <string name="auto_brightness_default_title" msgid="936771997353506620">"Par défaut"</string>
    <string name="auto_brightness_high_title" msgid="2527853305981497345">"Élevée"</string>
    <string name="auto_brightness_very_high_title" msgid="8867164854439331022">"Très élevée"</string>
    <string name="auto_brightness_subtitle" msgid="6454652530864093466">"Votre niveau de luminosité préféré"</string>
    <string name="auto_brightness_off_summary" msgid="7629228736838155268">"Ne pas ajuster selon la lumière ambiante"</string>
    <string name="auto_brightness_very_high_summary" msgid="4551003097086220709">"Utilisation accrue de la pile"</string>
    <string name="auto_brightness_disclaimer" msgid="871436423746343406">"Optimiser lumin. selon lumière ambiante. Lorsque cette fonction est activée, vous pouvez ajuster lumin. temporairement."</string>
    <string name="auto_brightness_description" msgid="7310335517128283729">"La luminosité de votre écran s\'adapte automatiquement à votre environnement et à vos activités. Vous pouvez déplacer le curseur manuellement pour aider la luminosité adaptative à apprendre vos préférences."</string>
    <string name="display_white_balance_title" msgid="4093966473741329340">"Afficher la balance des blancs"</string>
    <string name="display_white_balance_summary" msgid="2432539678792029039"></string>
    <string name="adaptive_sleep_title" msgid="455088457232472047">"Écran attentif"</string>
    <string name="adaptive_sleep_summary_on" msgid="410222811715459549">"Activé : L\'écran ne s\'éteint pas pendant que vous le regardez"</string>
    <string name="adaptive_sleep_summary_off" msgid="3099674463517017514">"Désactivé"</string>
    <string name="adaptive_sleep_title_no_permission" msgid="7893003608238361004">"L\'accès à l\'appareil photo est requis"</string>
    <string name="adaptive_sleep_summary_no_permission" msgid="2875851728693203108">"Touchez pour gérer les services de personnalisation de l\'appareil"</string>
    <string name="adaptive_sleep_description" msgid="3741651460279997459">"Empêche l\'écran de s\'éteindre pendant que vous le regardez"</string>
    <string name="adaptive_sleep_privacy" msgid="5335695648960686765">"La fonctionnalité Écran attentif utilise l\'appareil photo frontal pour détecter si quelqu\'un regarde l\'écran. Elle fonctionne sur l\'appareil uniquement, et les images ne sont jamais enregistrées ni envoyées à Google."</string>
    <string name="adaptive_sleep_contextual_slice_summary" msgid="6922838078388927214">"Garder l\'écran allumé pendant que vous le regardez"</string>
    <string name="night_display_title" msgid="2626451512200357686">"Éclairage nocturne"</string>
    <string name="night_display_text" msgid="1837277457033025056">"Le mode Éclairage nocturne donne une teinte ambre à votre écran. Cela vous permet de le regarder plus facilement lorsque l\'éclairage est faible et peut vous aider à vous endormir plus facilement."</string>
    <string name="night_display_auto_mode_title" msgid="6574111412154833409">"Calendrier"</string>
    <string name="night_display_auto_mode_never" msgid="2483761922928753400">"Aucun"</string>
    <string name="night_display_auto_mode_custom" msgid="2379394568898721765">"S\'active à l\'heure de votre choix"</string>
    <string name="night_display_auto_mode_twilight" msgid="589042813708244059">"S\'active du coucher au lever du soleil"</string>
    <string name="night_display_start_time_title" msgid="8918016772613689584">"Heure de début"</string>
    <string name="night_display_end_time_title" msgid="8286061578083519350">"Heure de fin"</string>
    <string name="night_display_status_title" msgid="1784041143360286267">"État"</string>
    <string name="night_display_temperature_title" msgid="1435292789272017136">"Intensité"</string>
    <string name="night_display_summary_off" msgid="1792750041697946539">"Désactivé : <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="night_display_summary_off_auto_mode_never" msgid="3583590137322963513">"Ne s\'activera jamais automatiquement"</string>
    <string name="night_display_summary_off_auto_mode_custom" msgid="6365668239253173208">"S\'activera automatiquement à <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="night_display_summary_off_auto_mode_twilight" msgid="3596291693781757392">"S\'activera automatiquement au coucher du soleil."</string>
    <string name="night_display_summary_on" msgid="1355713529996456744">"Activé : <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="night_display_summary_on_auto_mode_never" msgid="9117830821363119835">"Ne se désactivera jamais automatiquement"</string>
    <string name="night_display_summary_on_auto_mode_custom" msgid="5510753572245577263">"Se désactivera automatiquement à <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="night_display_summary_on_auto_mode_twilight" msgid="852270120144683507">"Se désactivera automatiquement au lever du soleil"</string>
    <string name="night_display_activation_on_manual" msgid="277343561277625826">"Activer maintenant"</string>
    <string name="night_display_activation_off_manual" msgid="4074557720918572883">"Désactiver maintenant"</string>
    <string name="night_display_activation_on_twilight" msgid="6976051971534953845">"Activer jusqu\'au lever du soleil"</string>
    <string name="night_display_activation_off_twilight" msgid="7196227685059907233">"Désactiver jusqu\'au coucher du soleil"</string>
    <string name="night_display_activation_on_custom" msgid="5472029024427933598">"Activer jusqu\'à <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="night_display_activation_off_custom" msgid="6169984658293744715">"Désactiver jusqu\'à <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="night_display_not_currently_on" msgid="6273540991113206401">"Mode Écl. nocturne pas activé"</string>
    <string name="screen_timeout" msgid="4882669461447531301">"Mise en veille de l\'écran"</string>
    <string name="screen_timeout_title" msgid="5130038655092628247">"L\'écran s\'éteint"</string>
    <string name="screen_timeout_summary" msgid="327761329263064327">"Après <xliff:g id="TIMEOUT_DESCRIPTION">%1$s</xliff:g> d\'inactivité"</string>
    <string name="wallpaper_settings_title" msgid="5449180116365824625">"Fond d\'écran"</string>
    <string name="style_and_wallpaper_settings_title" msgid="3608097576881470764">"Styles et fonds d\'écran"</string>
    <string name="wallpaper_settings_summary_default" msgid="3395741565658711416">"Par défaut"</string>
    <string name="wallpaper_settings_summary_custom" msgid="515035303981687172">"Personnalisé"</string>
    <string name="wallpaper_suggestion_title" msgid="8583988696513822528">"Changer le fond d\'écran"</string>
    <string name="wallpaper_suggestion_summary" msgid="1579144009898110491">"Personnalisez votre écran"</string>
    <string name="wallpaper_settings_fragment_title" msgid="519078346877860129">"Sélectionner un fond d\'écran dans"</string>
    <string name="style_suggestion_title" msgid="4710867417147087928">"Personnaliser votre Pixel"</string>
    <string name="style_suggestion_summary" msgid="1811974280164432649">"Essayez différents styles, fonds d\'écran, etc."</string>
    <string name="screensaver_settings_title" msgid="1770575686476851778">"Écran de veille"</string>
    <string name="screensaver_settings_summary_either_long" msgid="7302740999250873332">"Pendant la charge ou sur la station d\'accueil"</string>
    <string name="screensaver_settings_summary_either_short" msgid="6140527286137331478">"Les deux"</string>
    <string name="screensaver_settings_summary_sleep" msgid="9086186698140423493">"Pendant la charge"</string>
    <string name="screensaver_settings_summary_dock" msgid="2072657401664633283">"Sur la station d\'accueil"</string>
    <string name="screensaver_settings_summary_never" msgid="5165622985174349585">"Jamais"</string>
    <string name="screensaver_settings_summary_off" msgid="2481581696365146473">"Désactivé"</string>
    <string name="screensaver_settings_disabled_prompt" msgid="1239088321034437608">"Pour déterminer le comportement du téléphone lorsqu\'il se trouve sur une station d\'accueil ou lorsqu\'il est en veille, activez l\'écran de veille."</string>
    <string name="screensaver_settings_when_to_dream" msgid="7262410541382890146">"Quand commencer"</string>
    <string name="screensaver_settings_current" msgid="4663846038247130023">"Écran de veille actuel"</string>
    <string name="screensaver_settings_dream_start" msgid="4998187847985120168">"Commencer"</string>
    <string name="screensaver_settings_button" msgid="7292214707625717013">"Paramètres"</string>
    <string name="automatic_brightness" msgid="5014143533884135461">"Ajuster automatiquement la luminosité"</string>
    <string name="lift_to_wake_title" msgid="4555378006856277635">"Soulever pour activer"</string>
    <string name="ambient_display_screen_title" msgid="4252755516328775766">"Affichage en mode Veille"</string>
    <string name="ambient_display_category_triggers" msgid="4359289754456268573">"Activation du mode Veille"</string>
    <string name="doze_title" msgid="2375510714460456687">"Nouvelles notifications"</string>
    <string name="doze_summary" msgid="3846219936142814032">"Activer l\'écran lorsque vous recevez des notifications"</string>
    <string name="doze_always_on_title" msgid="1046222370442629646">"Toujours activé"</string>
    <string name="doze_always_on_summary" msgid="6978257596231155345">"Afficher l\'heure, les icônes de notifications et d\'autres renseignements. Utilisation accrue de la pile."</string>
    <string name="title_font_size" msgid="4405544325522105222">"Taille de police"</string>
    <string name="short_summary_font_size" msgid="6819778801232989076">"Agrandissez ou réduisez le texte"</string>
    <string name="sim_lock_settings" msgid="3392331196873564292">"Paramètres de verrouillage SIM"</string>
    <string name="sim_lock_settings_category" msgid="6242052161214271091">"Verrouillage de la carte SIM"</string>
    <string name="sim_lock_settings_summary_off" msgid="8028944267104896401">"Désactivé"</string>
    <string name="sim_lock_settings_summary_on" msgid="39103355956342985">"Verrouillé"</string>
    <string name="sim_lock_settings_title" msgid="9018585580955414596">"Verrouillage de la carte SIM"</string>
    <string name="sim_pin_toggle" msgid="1742123478029451888">"Verrouiller la carte SIM"</string>
    <string name="sim_lock_on" product="tablet" msgid="5058355081270397764">"Demander le NIP pour utiliser la tablette"</string>
    <string name="sim_lock_on" product="default" msgid="2503536505568814324">"Demander le NIP pour utiliser le téléphone"</string>
    <string name="sim_lock_off" product="tablet" msgid="2813800553917012356">"Demander le NIP pour utiliser la tablette"</string>
    <string name="sim_lock_off" product="default" msgid="258981978215428916">"Demander le NIP pour utiliser le téléphone"</string>
    <string name="sim_pin_change" msgid="6311414184279932368">"Modifier le NIP de la carte SIM"</string>
    <string name="sim_enter_pin" msgid="6608715137008508432">"NIP de la carte SIM"</string>
    <string name="sim_enable_sim_lock" msgid="4517742794997166918">"Verrouiller la carte SIM"</string>
    <string name="sim_disable_sim_lock" msgid="7664729528754784824">"Déverrouiller la carte SIM"</string>
    <string name="sim_enter_old" msgid="6074196344494634348">"Ancien NIP de la carte SIM"</string>
    <string name="sim_enter_new" msgid="8742727032729243562">"Nouveau NIP de la carte SIM"</string>
    <string name="sim_reenter_new" msgid="6523819386793546888">"Confirmez le nouveau NIP"</string>
    <string name="sim_change_pin" msgid="7328607264898359112">"NIP de la carte SIM"</string>
    <string name="sim_bad_pin" msgid="2345230873496357977">"NIP incorrect."</string>
    <string name="sim_pins_dont_match" msgid="1695021563878890574">"Les NIP ne correspondent pas."</string>
    <string name="sim_change_failed" msgid="3602072380172511475">"Impossible de modifier le NIP.\nLe NIP est peut-être incorrect."</string>
    <string name="sim_change_succeeded" msgid="8556135413096489627">"Le NIP de la carte SIM a été modifié."</string>
    <string name="sim_lock_failed" msgid="2489611099235575984">"Impossible de changer l\'état de verrouillage de la carte SIM.\nLe NIP est peut-être incorrect."</string>
    <string name="sim_pin_disable_failed" msgid="7932981135799678220">"Impossible de désactiver le NIP."</string>
    <string name="sim_pin_enable_failed" msgid="3414621075632931753">"Impossible d\'activer le NIP."</string>
    <string name="sim_enter_ok" msgid="6475946836899218919">"OK"</string>
    <string name="sim_enter_cancel" msgid="6240422158517208036">"Annuler"</string>
    <string name="sim_multi_sims_title" msgid="9159427879911231239">"Plusieurs cartes SIM détectées"</string>
    <string name="sim_multi_sims_summary" msgid="2698176447067691396">"Sélectionnez la carte SIM que vous préférez utiliser pour les données cellulaires."</string>
    <string name="sim_change_data_title" msgid="5045967581557404143">"Utiliser <xliff:g id="CARRIER">%1$s</xliff:g> pour les donn. cell.?"</string>
    <string name="sim_change_data_message" msgid="4307243848083368600">"Vous utilisez le réseau de <xliff:g id="CARRIER2_0">%2$s</xliff:g> pour les données cellulaires. Si vous passez au réseau de <xliff:g id="CARRIER1">%1$s</xliff:g>, celui de <xliff:g id="CARRIER2_1">%2$s</xliff:g> ne sera plus utilisé pour les données cellulaires."</string>
    <string name="sim_change_data_ok" msgid="7929746101841679535">"Utiliser le réseau de <xliff:g id="CARRIER">%1$s</xliff:g>"</string>
    <string name="sim_preferred_title" msgid="5567909634636045268">"M. à jour la carte SIM préf.?"</string>
    <string name="sim_preferred_message" msgid="8466930554330635780">"La carte <xliff:g id="NEW_SIM">%1$s</xliff:g> est la seule carte SIM dans votre appareil. Voulez-vous l\'utiliser pour les données cellulaires, les appels et les messages texte?"</string>
    <string name="wrong_pin_code_pukked" msgid="4003655226832658066">"NIP de carte SIM incorrect. Vous devez maintenant communiquer avec votre fournisseur de services pour déverrouiller votre appareil."</string>
    <plurals name="wrong_pin_code" formatted="false" msgid="1582398808893048097">
      <item quantity="one">Le NIP de la carte SIM incorrect. Il vous reste <xliff:g id="NUMBER_1">%d</xliff:g> tentative.</item>
      <item quantity="other">Le NIP de la carte SIM incorrect. Il vous reste <xliff:g id="NUMBER_1">%d</xliff:g> tentatives.</item>
    </plurals>
    <string name="pin_failed" msgid="1848423634948587645">"Le déverrouillage par NIP de carte SIM a échoué."</string>
    <string name="system_update_settings_list_item_title" msgid="3342887311059985961">"Mises à jour du système"</string>
    <string name="system_update_settings_list_item_summary" msgid="3853057315907710747"></string>
    <string name="firmware_version" msgid="4801135784886859972">"Version d\'Android"</string>
    <string name="security_patch" msgid="8438384045870296634">"Niveau du correctif de sécurité Android"</string>
    <string name="model_info" msgid="1952009518045740889">"Modèle"</string>
    <string name="model_summary" msgid="8306235877567782987">"Modèle : %1$s"</string>
    <string name="hardware_info" msgid="2605080746512527805">"Modèle et matériel"</string>
    <string name="hardware_revision" msgid="8893547686367095527">"Version du matériel"</string>
    <string name="fcc_equipment_id" msgid="149114368246356737">"Equipment ID"</string>
    <string name="baseband_version" msgid="1848990160763524801">"Version de bande de base"</string>
    <string name="kernel_version" msgid="9192574954196167602">"Version du noyau"</string>
    <string name="build_number" msgid="3075795840572241758">"Numéro de version"</string>
    <string name="module_version" msgid="7329118610303805859">"Mise à jour du système Google Play"</string>
    <string name="device_info_not_available" msgid="8062521887156825182">"Non disponible"</string>
    <string name="device_status_activity_title" msgid="1411201799384697904">"État"</string>
    <string name="device_status" msgid="607405385799807324">"État"</string>
    <string name="device_status_summary" product="tablet" msgid="3292717754497039686">"État de la batterie, état du réseau et autres informations"</string>
    <string name="device_status_summary" product="default" msgid="2599162787451519618">"Numéro de téléphone, signal, etc."</string>
    <string name="storage_settings" msgid="4211799979832404953">"Stockage"</string>
    <string name="storage_settings_for_app" msgid="1922207623125501014">"Stockage et mise en cache"</string>
    <string name="storage_usb_settings" msgid="7293054033137078060">"Stockage"</string>
    <string name="storage_settings_title" msgid="8746016738388094064">"Paramètres de stockage"</string>
    <string name="storage_settings_summary" product="nosdcard" msgid="3543813623294870759">"Désinstaller la mémoire de stockage USB, afficher l\'espace disponible"</string>
    <string name="storage_settings_summary" product="default" msgid="9176693537325988610">"Désinstaller la carte SD, afficher la mémoire disponible"</string>
    <string name="imei_multi_sim" msgid="6387012961838800539">"Code IIEM (fente pour carte SIM n° %1$d)"</string>
    <string name="status_number" product="tablet" msgid="1138837891091222272">"MDN"</string>
    <string name="status_number" product="default" msgid="5948892105546651296">"Numéro de téléphone"</string>
    <string name="status_number_sim_slot" product="tablet" msgid="2755592991367858860">"MDN (fente carte SIM n° %1$d)"</string>
    <string name="status_number_sim_slot" product="default" msgid="1898212200138025729">"N° téléphone (fente SIM n° %1$d)"</string>
    <string name="status_number_sim_status" product="tablet" msgid="1367110147304523864">"NRM sur la carte SIM"</string>
    <string name="status_number_sim_status" product="default" msgid="9123351360569466330">"N° de tél. sur la carte SIM"</string>
    <string name="status_min_number" msgid="3519504522179420597">"MIN"</string>
    <string name="status_msid_number" msgid="909010114445780530">"MSID"</string>
    <string name="status_prl_version" msgid="1007470446618081441">"Version de la liste d\'itinérance préférée"</string>
    <string name="meid_multi_sim" msgid="748999971744491771">"Code IDEM (fente pour carte SIM n° %1$d)"</string>
    <string name="scanning_status_text_wifi_on_ble_on" msgid="5262263689045962681">"La recherche Wi‑Fi et la recherche Bluetooth sont activées"</string>
    <string name="scanning_status_text_wifi_on_ble_off" msgid="2115399719199757550">"La recherche de réseaux Wi‑Fi est activée, mais la recherche Bluetooth est désactivée"</string>
    <string name="scanning_status_text_wifi_off_ble_on" msgid="3212656150021004088">"La recherche Bluetooth est activée, la recherche Wi‑Fi est désactivée"</string>
    <string name="scanning_status_text_wifi_off_ble_off" msgid="6381094990708345188">"La recherche Wi‑Fi et la recherche Bluetooth sont désactivées"</string>
    <string name="status_meid_number" msgid="1751442889111731088">"MEID"</string>
    <string name="status_icc_id" msgid="943368755577172747">"ICCID"</string>
    <string name="status_data_network_type" msgid="7570837037428932780">"Type de réseau de données cellulaires"</string>
    <string name="status_voice_network_type" msgid="5663112239742353547">"Type de réseau vocal cellulaire"</string>
    <string name="status_latest_area_info" msgid="7222470836568238054">"Informations sur l\'opérateur"</string>
    <string name="status_data_state" msgid="5503181397066522950">"État du réseau mobile"</string>
    <string name="status_esim_id" msgid="6456255368300906317">"EID"</string>
    <string name="status_service_state" msgid="2323931627519429503">"État du service"</string>
    <string name="status_signal_strength" msgid="3732655254188304547">"Intensité du signal"</string>
    <string name="status_roaming" msgid="2638800467430913403">"Itinérance"</string>
    <string name="status_operator" msgid="2274875196954742087">"Réseau"</string>
    <string name="status_wifi_mac_address" msgid="2202206684020765378">"Adresse MAC Wi-Fi"</string>
    <string name="status_bt_address" msgid="4195174192087439720">"Adresse Bluetooth"</string>
    <string name="status_serial_number" msgid="2257111183374628137">"Numéro de série"</string>
    <string name="status_up_time" msgid="7294859476816760399">"Durée d\'activité"</string>
    <string name="status_awake_time" msgid="2393949909051183652">"Temps en activité"</string>
    <string name="internal_memory" msgid="9129595691484260784">"Mémoire de stockage interne"</string>
    <string name="sd_memory" product="nosdcard" msgid="2510246194083052841">"Mémoire de stockage USB"</string>
    <string name="sd_memory" product="default" msgid="151871913888051515">"Carte SD"</string>
    <string name="memory_available" msgid="5052397223077021181">"Disponible"</string>
    <string name="memory_available_read_only" msgid="6497534390167920206">"Disponible (en lecture seule)"</string>
    <string name="memory_size" msgid="6629067715017232195">"Espace total"</string>
    <string name="memory_calculating_size" msgid="2188358544203768588">"Calcul en cours"</string>
    <string name="memory_apps_usage" msgid="5128673488173839077">"Applications et données des applications"</string>
    <string name="memory_media_usage" msgid="3738830697707880405">"Médias"</string>
    <string name="memory_downloads_usage" msgid="3755173051677533027">"Téléchargements"</string>
    <string name="memory_dcim_usage" msgid="558887013613822577">"Images, vidéos"</string>
    <string name="memory_music_usage" msgid="1363785144783011606">"Audio (musique, sonneries, podcasts, etc.)"</string>
    <string name="memory_media_misc_usage" msgid="6094866738586451683">"Autres fichiers"</string>
    <string name="memory_media_cache_usage" msgid="6704293333141177910">"Données mises en cache"</string>
    <string name="sd_eject" product="nosdcard" msgid="4988563376492400073">"Démonter le stockage partagé"</string>
    <string name="sd_eject" product="default" msgid="6915293408836853020">"Désinstaller la carte SD"</string>
    <string name="sd_eject_summary" product="nosdcard" msgid="5009296896648072891">"Désinstaller la mémoire de stockage USB interne"</string>
    <string name="sd_eject_summary" product="default" msgid="3300599435073550246">"Désinstaller la carte SD pour la retirer en toute sécurité"</string>
    <string name="sd_insert_summary" product="nosdcard" msgid="5264016886409577313">"Insérer la mémoire de stockage USB à installer"</string>
    <string name="sd_insert_summary" product="default" msgid="2048640010381803841">"Insérer la carte SD à installer"</string>
    <string name="sd_mount" product="nosdcard" msgid="8966695015677343116">"Installer mémoire stockage USB"</string>
    <string name="sd_mount" product="default" msgid="5940523765187704135">"Installer la carte SD"</string>
    <string name="sd_mount_summary" product="nosdcard" msgid="4673411327373419641"></string>
    <string name="sd_mount_summary" product="default" msgid="4673411327373419641"></string>
    <string name="sd_format" product="nosdcard" msgid="2148179271623099054">"Effacer la mémoire de stockage USB"</string>
    <string name="sd_format" product="default" msgid="2576054280507119870">"Effacer la carte SD"</string>
    <string name="sd_format_summary" product="nosdcard" msgid="6331905044907914603">"Effacer les données de la mémoire de stockage USB interne (ex. : musique, photos)"</string>
    <string name="sd_format_summary" product="default" msgid="212703692181793109">"Effacer toutes les données de la carte SD, telles que la musique et les photos"</string>
    <string name="memory_clear_cache_title" msgid="5423840272171286191">"Effacer les données mises en cache?"</string>
    <string name="memory_clear_cache_message" msgid="4550262490807415948">"Les données en cache des applis seront effacées."</string>
    <string name="mtp_ptp_mode_summary" msgid="3710436114807789270">"La fonctionnalité MTP ou PTP est active."</string>
    <string name="dlg_confirm_unmount_title" product="nosdcard" msgid="3077285629197874055">"Désinstaller mémoire USB?"</string>
    <string name="dlg_confirm_unmount_title" product="default" msgid="3634502237262534381">"Désinstaller la carte SD?"</string>
    <string name="dlg_confirm_unmount_text" product="nosdcard" msgid="4322636662873269018">"Si vous désinstallez la mémoire de stockage USB, certaines applications en cours d\'utilisation seront fermées. Elles risquent de rester indisponibles jusqu\'à ce que la mémoire de stockage USB soit réinstallée."</string>
    <string name="dlg_confirm_unmount_text" product="default" msgid="6998379994779187692">"Si vous désinstallez la carte SD, certaines applications en cours d\'utilisation s\'arrêteront et risquent de ne plus être disponibles tant que vous n\'aurez pas réinstallé la carte SD."</string>
    <string name="dlg_error_unmount_title" product="nosdcard" msgid="4642742385125426529"></string>
    <string name="dlg_error_unmount_title" product="default" msgid="4642742385125426529"></string>
    <string name="dlg_error_unmount_text" product="nosdcard" msgid="9191518889746166147">"Impossible de désinstaller la mémoire de stockage USB. Réessayez plus tard."</string>
    <string name="dlg_error_unmount_text" product="default" msgid="3500976899159848422">"Impossible de désinstaller la carte SD. Réessayez plus tard."</string>
    <string name="unmount_inform_text" product="nosdcard" msgid="7120241136790744265">"La mémoire de stockage USB va être désinstallée."</string>
    <string name="unmount_inform_text" product="default" msgid="1904212716075458402">"La carte SD va être retirée."</string>
    <string name="sd_ejecting_title" msgid="8824572198034365468">"Désinstallation"</string>
    <string name="sd_ejecting_summary" msgid="2028753069184908491">"Désinstallation en cours"</string>
    <string name="storage_low_title" msgid="1388569749716225155">"Espace de stockage bientôt saturé"</string>
    <string name="storage_low_summary" msgid="7737465774892563129">"Il est possible que certaines fonctionnalités du système, comme la synchronisation, ne soient pas opérationnelles. Libérez de l\'espace en supprimant certains éléments (applications ou contenu multimédia, par exemple) ou en annulant leur épinglage."</string>
    <string name="storage_menu_rename" msgid="7141058657592615390">"Renommer"</string>
    <string name="storage_menu_mount" msgid="1014683672493425425">"Monter"</string>
    <string name="storage_menu_unmount" msgid="681485356885955898">"Éjecter"</string>
    <string name="storage_menu_format" msgid="7690626079653152152">"Formater"</string>
    <string name="storage_menu_format_public" msgid="7464714208010125682">"Formater comme mémoire externe"</string>
    <string name="storage_menu_format_private" msgid="546017531835902096">"Formater comme mémoire interne"</string>
    <string name="storage_menu_migrate" msgid="3969621494238154294">"Transférer les données"</string>
    <string name="storage_menu_forget" msgid="6305824238997983426">"Supprimer"</string>
    <string name="storage_menu_set_up" msgid="4263294929451685366">"Configurer"</string>
    <string name="storage_menu_explore" msgid="4637496051816521560">"Explorer"</string>
    <string name="storage_menu_free" msgid="6386070442027135427">"Libérer de l\'espace"</string>
    <string name="storage_menu_manage" msgid="5914482953856430780">"Gérer l\'espace de stockage"</string>
    <string name="storage_title_usb" msgid="679612779321689418">"Connexion USB à l\'ordinateur"</string>
    <string name="usb_connection_category" msgid="7805945595165422882">"Connecter en tant que"</string>
    <string name="usb_mtp_title" msgid="3399663424394065964">"Périphérique multimédia (MTP)"</string>
    <string name="usb_mtp_summary" msgid="4617321473211391236">"Permet de transférer des fichiers multimédias sous Windows ou à l\'aide de l\'application Android File Transfer pour Mac (voir www.android.com/filetransfer)"</string>
    <string name="usb_ptp_title" msgid="3852760810622389620">"Appareil photo (PTP)"</string>
    <string name="usb_ptp_summary" msgid="7406889433172511530">"Permet de transférer des photos à l\'aide du logiciel photo et de transférer des fichiers sur les ordinateurs non compatibles avec le protocole MTP."</string>
    <string name="usb_midi_title" msgid="3069990264258413994">"MIDI"</string>
    <string name="usb_midi_summary" msgid="539169474810956358">"Permettre aux applications compatibles avec le protocole MIDI de fonctionner par USB avec des logiciels MIDI sur votre ordinateur"</string>
    <string name="storage_other_users" msgid="808708845102611856">"Autres utilisateurs"</string>
    <string name="storage_internal_title" msgid="690771193137801021">"Mémoire interne de l\'appareil"</string>
    <string name="storage_external_title" msgid="3433462910096848696">"Mémoire de stockage externe"</string>
    <string name="storage_volume_summary" msgid="7023441974367853372">"<xliff:g id="USED">%1$s</xliff:g> utilisé(s) sur <xliff:g id="TOTAL">%2$s</xliff:g>"</string>
    <string name="storage_size_large" msgid="5691585991420946254">"<xliff:g id="NUMBER">^1</xliff:g>"<small><small>" <xliff:g id="UNIT">^2</xliff:g>"</small></small>""</string>
    <string name="storage_volume_used" msgid="1303803057698959872">"utilisé(s) sur <xliff:g id="TOTAL">%1$s</xliff:g>"</string>
    <string name="storage_volume_used_total" msgid="6113121714019000244">"utilisé(s) au total sur <xliff:g id="TOTAL">%1$s</xliff:g>"</string>
    <string name="storage_mount_success" msgid="687641090137253647">"<xliff:g id="NAME">%1$s</xliff:g> est monté"</string>
    <string name="storage_mount_failure" msgid="1042621107954547316">"Impossible de monter <xliff:g id="NAME">%1$s</xliff:g>"</string>
    <string name="storage_unmount_success" msgid="5737203344673441677">"<xliff:g id="NAME">%1$s</xliff:g> a été éjecté en toute sécurité"</string>
    <string name="storage_unmount_failure" msgid="5758387106579519489">"Impossible d\'éjecter <xliff:g id="NAME">%1$s</xliff:g> en toute sécurité"</string>
    <string name="storage_format_success" msgid="3023144070597190555">"<xliff:g id="NAME">%1$s</xliff:g> n\'est pas formaté"</string>
    <string name="storage_format_failure" msgid="6032640952779735766">"Impossible de formater <xliff:g id="NAME">%1$s</xliff:g>"</string>
    <string name="storage_rename_title" msgid="8242663969839491485">"Renommer le stockage"</string>
    <string name="storage_dialog_unmounted" msgid="6403320870103261477">"La mémoire de stockage « <xliff:g id="NAME_0">^1</xliff:g> » a été éjectée en toute sécurité, mais elle se trouve toujours dans la fente pour carte mémoire de l\'appareil.\n\n Pour utiliser la mémoire « <xliff:g id="NAME_1">^1</xliff:g> », vous devez d\'abord la monter."</string>
    <string name="storage_dialog_unmountable" msgid="3732209361668282254">"La mémoire de stockage « <xliff:g id="NAME_0">^1</xliff:g> » est corrompue. \n\nPour utiliser la mémoire « <xliff:g id="NAME_1">^1</xliff:g> », vous devez d\'abord la configurer."</string>
    <string name="storage_dialog_unsupported" msgid="4503128224360482228">"Cet appareil n\'est pas compatible avec la mémoire de stockage <xliff:g id="NAME_0">^1</xliff:g>. \n\nPour utiliser la mémoire « <xliff:g id="NAME_1">^1</xliff:g> », vous devez d\'abord la configurer."</string>
    <string name="storage_internal_format_details" msgid="4018647158382548820">"Après le formatage, vous pouvez utiliser la mémoire de stockage « <xliff:g id="NAME_0">^1</xliff:g> » avec d\'autres appareils. \n\nToutes les données enregistrées sur « <xliff:g id="NAME_1">^1</xliff:g> » seront effacées. Nous vous conseillons de sauvegarder vos données avant de continuer. \n\n"<b>"Sauvegardez vos photos et vos autres fichiers"</b>\n"Déplacez vos fichiers multimédias vers une autre mémoire de stockage sur cet appareil, ou transférez-les sur un ordinateur à l\'aide d\'un câble USB. \n\n"<b>"Sauvegardez vos applications"</b>\n"Toutes les applications enregistrées sur « <xliff:g id="NAME_6">^1</xliff:g> » seront désinstallées, et les données correspondantes seront effacées. Pour conserver ces applications, déplacez-les vers une autre mémoire de stockage sur cet appareil."</string>
    <string name="storage_internal_unmount_details" msgid="3582802571684490057"><b>"Lorsque vous éjectez la mémoire de stockage « <xliff:g id="NAME_0">^1</xliff:g> », les applications qui y sont enregistrées cessent de fonctionner, et les fichiers qu\'elle contient ne sont plus accessibles jusqu\'à ce que vous la réinsériez de nouveau."</b>\n\n"La mémoire de stockage « <xliff:g id="NAME_1">^1</xliff:g> » a été configurée pour ne fonctionner que sur cet appareil. Vous ne pouvez pas l\'utiliser sur d\'autres appareils."</string>
    <string name="storage_internal_forget_details" msgid="9028875424669047327">"Pour utiliser les applications, les photos ou les données que la mémoire de stockage « <xliff:g id="NAME">^1</xliff:g> » contient, insérez de nouveau celle-ci. \n\nVous pouvez également la supprimer de la liste des mémoires de stockage si elle n\'est pas disponible. \n\nSi vous la supprimez, toutes les données qu\'elle contient seront définitivement effacées. \n\nVous pouvez réinstaller les applications plus tard, mais les données correspondantes enregistrées sur cette mémoire seront perdues."</string>
    <string name="storage_internal_forget_confirm_title" msgid="1370847944388479245">"Oublier « <xliff:g id="NAME">^1</xliff:g> »?"</string>
    <string name="storage_internal_forget_confirm" msgid="1148446041396902905">"Toutes les applications, photos et données enregistrées sur la mémoire de stockage « <xliff:g id="NAME">^1</xliff:g> » seront perdues définitivement."</string>
    <string name="storage_detail_apps" msgid="6141154016753507490">"Applications"</string>
    <string name="storage_detail_images" msgid="6950678857740634769">"Images"</string>
    <string name="storage_detail_videos" msgid="2919743464827110953">"Vidéos"</string>
    <string name="storage_detail_audio" msgid="1197685141676483213">"Audio"</string>
    <string name="storage_detail_cached" msgid="8547136365247818567">"Données mises en cache"</string>
    <string name="storage_detail_other" msgid="8404938385075638238">"Autre"</string>
    <string name="storage_detail_system" msgid="4629506366064709687">"Système"</string>
    <string name="storage_detail_explore" msgid="7911344011431568294">"Explorer « <xliff:g id="NAME">^1</xliff:g> »"</string>
    <string name="storage_detail_dialog_other" msgid="8845766044697204852">"Les autres fichiers comprennent les fichiers partagés enregistrés par les applications, les fichiers téléchargés d\'Internet ou par Bluetooth, les fichiers systèmes d\'Android et ainsi de suite.\n\nPour voir le contenu visible de cet appareil <xliff:g id="NAME">^1</xliff:g>, touchez Explorer."</string>
    <string name="storage_detail_dialog_system" msgid="862835644848361569">"Le répertoire Système comprend des fichiers utilisés pour faire fonctionner Android version <xliff:g id="VERSION">%s</xliff:g>"</string>
    <string name="storage_detail_dialog_user" msgid="3267254783294197804">"L\'utilisateur « <xliff:g id="USER_0">^1</xliff:g> » a peut-être enregistré des photos, de la musique, des applications et d\'autres données qui occupent <xliff:g id="SIZE">^2</xliff:g> d\'espace. \n\nPour afficher des informations détaillées, utilisez le compte d\'utilisateur « <xliff:g id="USER_1">^1</xliff:g> »."</string>
    <string name="storage_wizard_init_title" msgid="5085400514028585772">"Configurer votre « <xliff:g id="NAME">^1</xliff:g> »"</string>
    <string name="storage_wizard_init_external_title" msgid="4867326438945303598">"Utiliser en tant que mémoire de stockage externe"</string>
    <string name="storage_wizard_init_external_summary" msgid="7476105886344565074">"Pour déplacer des photos et d\'autres fichiers entre différents appareils"</string>
    <string name="storage_wizard_init_internal_title" msgid="9100613534261408519">"Utiliser comme mémoire de stockage interne"</string>
    <string name="storage_wizard_init_internal_summary" msgid="6240417501036216410">"Pour enregistrer tout type de contenu, y compris des applications et des photos, sur cet appareil uniquement. Cette option nécessite de formater la mémoire de stockage pour l\'empêcher de fonctionner avec d\'autres appareils."</string>
    <string name="storage_wizard_format_confirm_title" msgid="2814021794538252546">"Formater comme mémoire interne"</string>
    <string name="storage_wizard_format_confirm_body" msgid="4401758710076806509">"Cette option nécessite de formater la mémoire de stockage « <xliff:g id="NAME_0">^1</xliff:g> » pour qu\'elle soit sécurisée. \n\nAprès le formatage, « <xliff:g id="NAME_1">^1</xliff:g> » ne fonctionnera que sur cet appareil. \n\n"<b>"Le formatage entraîne la suppression de toutes les données enregistrées sur « <xliff:g id="NAME_2">^1</xliff:g> »."</b>" Pour ne pas de perdre vos données, nous vous conseillons de les sauvegarder."</string>
    <string name="storage_wizard_format_confirm_public_title" msgid="4905690038882041566">"Formater comme mémoire externe"</string>
    <string name="storage_wizard_format_confirm_public_body" msgid="1516932692920060272">"Cette option nécessite de formater la mémoire de stockage « <xliff:g id="NAME_0">^1</xliff:g> ». \n\n"<b>"Le formatage entraîne la suppression de toutes les données enregistrées sur la mémoire « <xliff:g id="NAME_1">^1</xliff:g> »."</b>" Pour ne pas risquer de perdre vos données, nous vous conseillons de les sauvegarder."</string>
    <string name="storage_wizard_format_confirm_next" msgid="2774557300531702572">"Effacer et formater"</string>
    <string name="storage_wizard_format_progress_title" msgid="6487352396450582292">"Formatage de « <xliff:g id="NAME">^1</xliff:g> » en cours..."</string>
    <string name="storage_wizard_format_progress_body" msgid="3983764797223576658">"Ne retirez pas <xliff:g id="NAME">^1</xliff:g> durant le formatage."</string>
    <string name="storage_wizard_migrate_title" msgid="1363078147938160407">"Déplacer vers une autre mémoire"</string>
    <string name="storage_wizard_migrate_body" msgid="890751699549542345">"Vous pouvez déplacer vos photos, vos fichiers et certaines applications vers la nouvelle mémoire de stockage « <xliff:g id="NAME">^1</xliff:g> ». \n\nCette opération prend environ <xliff:g id="TIME">^2</xliff:g> et permet de libérer <xliff:g id="SIZE">^3</xliff:g> sur la mémoire de stockage interne. Certaines applications ne fonctionneront pas pendant l\'opération."</string>
    <string name="storage_wizard_migrate_now" msgid="4523444323744239143">"Déplacer maintenant"</string>
    <string name="storage_wizard_migrate_later" msgid="3173482328116026253">"Déplacer plus tard"</string>
    <string name="storage_wizard_migrate_confirm_title" msgid="8564833529613286965">"Déplacer les données maintenant"</string>
    <string name="storage_wizard_migrate_confirm_body" msgid="4212060581792135962"><b>"Le transfert des données dure <xliff:g id="TIME">^1</xliff:g> environ et permet de libérer <xliff:g id="SIZE">^2</xliff:g> sur la mémoire de stockage « <xliff:g id="NAME">^3</xliff:g> »."</b></string>
    <string name="storage_wizard_migrate_confirm_next" msgid="5509475628423823202">"Déplacer"</string>
    <string name="storage_wizard_migrate_progress_title" msgid="1665479429044202868">"Déplacement des données..."</string>
    <string name="storage_wizard_migrate_details" msgid="3709728824651136227">"Pendant le déplacement des données : \n• Ne retirez pas la mémoire de stockage « <xliff:g id="NAME">^1</xliff:g> ». \n• Certaines applications ne fonctionneront pas correctement. \n• Assurez-vous que l\'appareil reste chargé."</string>
    <string name="storage_wizard_ready_title" msgid="6553867088682695655">"Vous pouvez utiliser votre <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_ready_external_body" msgid="2879508114260597474">"Votre mémoire de stockage « <xliff:g id="NAME">^1</xliff:g> » est maintenant configurée pour que vous puissiez y enregistrer des photos et d\'autres fichiers."</string>
    <string name="storage_wizard_ready_internal_body" msgid="122532674037860197">"Votre nouvelle mémoire de stockage « <xliff:g id="NAME">^1</xliff:g> » fonctionne correctement. \n\nPour déplacer des photos, des fichiers et des données d\'application sur cet appareil, sélectionnez Paramètres &gt; Stockage."</string>
    <string name="storage_wizard_move_confirm_title" msgid="292782012677890250">"Déplacer <xliff:g id="APP">^1</xliff:g>"</string>
    <string name="storage_wizard_move_confirm_body" msgid="5176432115206478941">"Le déplacement de l\'application « <xliff:g id="APP">^1</xliff:g> » et des données correspondantes vers « <xliff:g id="NAME_0">^2</xliff:g> » ne prend que quelques minutes. Vous ne pourrez pas utiliser l\'application tant que l\'opération n\'est pas terminée. \n\nNe retirez pas la mémoire de stockage « <xliff:g id="NAME_1">^2</xliff:g> » pendant le déplacement."</string>
    <string name="storage_wizard_move_unlock" msgid="1526216561023200694">"Pour déplacer des données, vous devez déverrouiller l\'utilisateur <xliff:g id="APP">^1</xliff:g>."</string>
    <string name="storage_wizard_move_progress_title" msgid="4443920302548035674">"Déplacement de <xliff:g id="APP">^1</xliff:g> en cours..."</string>
    <string name="storage_wizard_move_progress_body" msgid="7802577486578105609">"Ne retirez pas la mémoire de stockage « <xliff:g id="NAME">^1</xliff:g> » pendant le déplacement. \n\nL\'application « <xliff:g id="APP">^2</xliff:g> » ne sera pas disponible tant que l\'opération n\'est pas terminée."</string>
    <string name="storage_wizard_move_progress_cancel" msgid="542047237524588792">"Annuler le déplacement"</string>
    <string name="storage_wizard_slow_body" msgid="8010127667184768025">"Ce <xliff:g id="NAME_0">^1</xliff:g> ne semble pas rapide. \n\nVous pouvez continuer, mais les applications déplacées vers cet endroit risquent de se bloquer et les transferts de données pourront prendre du temps.\n\nVeuillez utiliser un <xliff:g id="NAME_1">^1</xliff:g> plus rapide pour obtenir de meilleures performances."</string>
    <string name="storage_wizard_init_v2_title" msgid="8858395869710288372">"Comment utiliserez-vous ce périphérique <xliff:g id="NAME">^1</xliff:g>?"</string>
    <string name="storage_wizard_init_v2_internal_title" product="tablet" msgid="4315585580670552654">"Utiliser comme stockage tablette"</string>
    <string name="storage_wizard_init_v2_internal_summary" product="tablet" msgid="570443086512059390">"Pour les applications et les fichiers de cette tablette seulement"</string>
    <string name="storage_wizard_init_v2_internal_action" product="tablet" msgid="7760758592993284143">"Stockage pour la tablette"</string>
    <string name="storage_wizard_init_v2_internal_title" product="default" msgid="8373070138732653456">"Utiliser comme stockage téléphone"</string>
    <string name="storage_wizard_init_v2_internal_summary" product="default" msgid="685194340141573218">"Pour les applications et les fichiers de ce téléphone seulement"</string>
    <string name="storage_wizard_init_v2_internal_action" product="default" msgid="904425171564310150">"Stockage pour le téléphone"</string>
    <string name="storage_wizard_init_v2_or" msgid="1958295749349454436">"ou"</string>
    <string name="storage_wizard_init_v2_external_title" msgid="3565348221712759463">"Utiliser comme mémoire de stockage externe"</string>
    <string name="storage_wizard_init_v2_external_summary" msgid="801198071793584445">"Pour transférer des fichiers entre des appareils"</string>
    <string name="storage_wizard_init_v2_external_action" msgid="8662451480642784031">"Mémoire de stockage externe"</string>
    <string name="storage_wizard_init_v2_later" msgid="1080613420170749130">"Configurer plus tard"</string>
    <string name="storage_wizard_format_confirm_v2_title" msgid="5744790239994621663">"Formater le périphérique <xliff:g id="NAME">^1</xliff:g>?"</string>
    <string name="storage_wizard_format_confirm_v2_body" msgid="4614199613500900975">"Le périphérique <xliff:g id="NAME_0">^1</xliff:g> doit être formaté pour stocker des applications et des fichiers. \n\nLe formatage effacera le contenu existant du périphérique <xliff:g id="NAME_1">^2</xliff:g>. Pour éviter de perdre votre contenu, sauvegardez-le sur un autre périphérique <xliff:g id="NAME_2">^3</xliff:g> ou un autre appareil."</string>
    <string name="storage_wizard_format_confirm_v2_action" msgid="8258363472135537500">"Formater <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_migrate_v2_title" msgid="31406330052996898">"Déplacer le contenu vers <xliff:g id="NAME">^1</xliff:g>?"</string>
    <string name="storage_wizard_migrate_v2_body" product="tablet" msgid="4476553430145054781">"Vous pouvez déplacer vos fichiers et certaines applications sur le périphérique <xliff:g id="NAME">^1</xliff:g>. \n\nCe déplacement libérerait <xliff:g id="SIZE">^2</xliff:g> du stockage de votre tablette et prendrait environ <xliff:g id="DURATION">^3</xliff:g>."</string>
    <string name="storage_wizard_migrate_v2_body" product="default" msgid="744760728669284385">"Vous pouvez déplacer vos fichiers et certaines applications sur le périphérique <xliff:g id="NAME">^1</xliff:g>. \n\nCe déplacement libérerait <xliff:g id="SIZE">^2</xliff:g> du stockage de votre téléphone et prendrait environ <xliff:g id="DURATION">^3</xliff:g>."</string>
    <string name="storage_wizard_migrate_v2_checklist" msgid="1239103359606165360">"Pendant le déplacement :"</string>
    <string name="storage_wizard_migrate_v2_checklist_media" msgid="7176991995007075843">"Ne retirez pas le périphérique <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_migrate_v2_checklist_apps" msgid="3671266712947078734">"Certaines applications ne fonctionneront pas"</string>
    <string name="storage_wizard_migrate_v2_checklist_battery" product="tablet" msgid="346012901366624052">"Gardez cette tablette chargée"</string>
    <string name="storage_wizard_migrate_v2_checklist_battery" product="default" msgid="3061158350109289521">"Gardez ce téléphone chargé"</string>
    <string name="storage_wizard_migrate_v2_now" msgid="1279041707982039591">"Déplacer le contenu"</string>
    <string name="storage_wizard_migrate_v2_later" msgid="8201360307047198853">"Déplacer le contenu plus tard"</string>
    <string name="storage_wizard_migrate_progress_v2_title" msgid="1323344099111423785">"Déplacement du contenu en cours…"</string>
    <string name="storage_wizard_slow_v2_title" msgid="1318285829973607727">"Périphérique <xliff:g id="NAME">^1</xliff:g> lent"</string>
    <string name="storage_wizard_slow_v2_body" msgid="6897444467730463117">"Vous pouvez toujours utiliser le périphérique <xliff:g id="NAME_0">^1</xliff:g>, mais il peut être lent. \n\nLes applications stockées sur le périphérique <xliff:g id="NAME_1">^2</xliff:g> peuvent ne pas fonctionner correctement et les transferts de contenu peuvent prendre beaucoup de temps. \n\nEssayez d\'utiliser un autre périphérique <xliff:g id="NAME_2">^3</xliff:g>, ou utilisez plutôt le périphérique <xliff:g id="NAME_3">^4</xliff:g> comme mémoire de stockage externe."</string>
    <string name="storage_wizard_slow_v2_start_over" msgid="4126873669723115805">"Recommencer"</string>
    <string name="storage_wizard_slow_v2_continue" msgid="49399942893518218">"Continuer"</string>
    <string name="storage_wizard_ready_v2_external_body" msgid="11937346870534608">"Vous pouvez déplacer le contenu vers <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_ready_v2_internal_body" msgid="4658433206901211269">"Pour déplacer du contenu vers <xliff:g id="NAME">^1</xliff:g>, accédez à "<b>"Paramètres &gt; Stockage"</b></string>
    <string name="storage_wizard_ready_v2_internal_moved_body" msgid="6239886818487538806">"Votre contenu a été déplacé vers <xliff:g id="NAME_0">^1</xliff:g>. \n\nPour gérer ce (cette) <xliff:g id="NAME_1">^2</xliff:g>, accédez à "<b>"Paramètres &gt; Stockage"</b>"."</string>
    <string name="battery_status_title" msgid="9159414319574976203">"État de la batterie"</string>
    <string name="battery_level_title" msgid="2965679202786873272">"Niveau de la pile"</string>
    <string name="apn_settings" msgid="3743170484827528406">"Noms des points d\'accès"</string>
    <string name="apn_edit" msgid="1354715499708424718">"Modifier le point d\'accès"</string>
    <string name="apn_not_set" msgid="4974192007399968164">"Non défini"</string>
    <string name="apn_name" msgid="4115580098369824123">"Nom"</string>
    <string name="apn_apn" msgid="2479425126733513353">"Nom du point d\'accès"</string>
    <string name="apn_http_proxy" msgid="1826885957243696354">"Serveur mandataire"</string>
    <string name="apn_http_port" msgid="3763259523984976226">"Port"</string>
    <string name="apn_user" msgid="455637547356117761">"Nom d\'utilisateur"</string>
    <string name="apn_password" msgid="5412301994998250968">"Mot de passe"</string>
    <string name="apn_server" msgid="2436185314756372858">"Serveur"</string>
    <string name="apn_mmsc" msgid="3670124402105585737">"MMSC"</string>
    <string name="apn_mms_proxy" msgid="5374082621073999275">"Serveur mandataire MMS"</string>
    <string name="apn_mms_port" msgid="4074188088199243040">"Port MMS"</string>
    <string name="apn_mcc" msgid="4258628382260674636">"MCC"</string>
    <string name="apn_mnc" msgid="8629374076888809874">"MNC"</string>
    <string name="apn_auth_type" msgid="6167205395676037015">"Type d\'authentification"</string>
    <string name="apn_auth_type_none" msgid="5069592676845549926">"Aucun"</string>
    <string name="apn_auth_type_pap" msgid="1666934536996033383">"PAP"</string>
    <string name="apn_auth_type_chap" msgid="3369626283789068360">"CHAP"</string>
    <string name="apn_auth_type_pap_chap" msgid="9102343063036134541">"PAP ou CHAP"</string>
    <string name="apn_type" msgid="469613123902220544">"Type d\'APN"</string>
    <string name="apn_protocol" msgid="3272222921649348640">"Protocole de l\'APN"</string>
    <string name="apn_roaming_protocol" msgid="3386954381510788422">"Protocole APN en itinérance"</string>
    <string name="carrier_enabled" msgid="407655861175280806">"Activer/Désactiver l\'APN"</string>
    <string name="carrier_enabled_summaryOn" msgid="6338915271908057531">"APN activé"</string>
    <string name="carrier_enabled_summaryOff" msgid="4300790190221203756">"APN désactivé"</string>
    <string name="bearer" msgid="594270280031923558">"Réseau"</string>
    <string name="mvno_type" msgid="2543253857818336421">"Type MVNO"</string>
    <string name="mvno_match_data" msgid="4560671695220540466">"Valeur MVNO"</string>
    <string name="menu_delete" msgid="6981294422841124659">"Supprimer l\'APN"</string>
    <string name="menu_new" msgid="3014205883303921729">"Nouveau nom point d\'accès"</string>
    <string name="menu_save" msgid="8109345640668285399">"Enregistrer"</string>
    <string name="menu_cancel" msgid="2194502410474697474">"Annuler"</string>
    <string name="error_title" msgid="7631322303341024692"></string>
    <string name="error_name_empty" msgid="5508155943840201232">"Le champ « Nom » est obligatoire."</string>
    <string name="error_apn_empty" msgid="4932211013600863642">"L\'APN est obligatoire."</string>
    <string name="error_mcc_not3" msgid="4560171714156251661">"Le champ MCC doit contenir 3 chiffres."</string>
    <string name="error_mnc_not23" msgid="8418177072458379439">"Le champ MNC doit contenir 2 ou 3 chiffres."</string>
    <string name="error_adding_apn_type" msgid="4181334016628549645">"Le fournisseur de services n\'autorise pas l\'ajout de points d\'accès de type %s."</string>
    <string name="restore_default_apn" msgid="8178010218751639581">"Restauration des paramètres APN par défaut en cours..."</string>
    <string name="menu_restore" msgid="8260067415075573273">"Rétablir les valeurs par défaut"</string>
    <string name="restore_default_apn_completed" msgid="2824775307377604897">"La réinitialisation des paramètres APN par défaut est terminée."</string>
    <string name="reset_dashboard_title" msgid="6254873816990678620">"Options de réinitialisation"</string>
    <string name="reset_dashboard_summary" msgid="4851012632493522755">"Vous pouvez réinitialiser le réseau, les applications ou l\'appareil"</string>
    <string name="reset_network_title" msgid="6166025966016873843">"Réinitialiser les paramètres Wi-Fi, cellulaires et Bluetooth"</string>
    <string name="reset_network_desc" msgid="5547979398298881406">"Cette opération entraîne la réinitialisation de tous les paramètres réseau, y compris :\n\n"<li>"Le Wi‑Fi"</li>\n<li>"Les données cellulaires"</li>\n<li>"Le Bluetooth"</li></string>
    <string name="reset_esim_title" msgid="1979762943163078939">"Effacer cartes SIM téléchargées"</string>
    <string name="reset_esim_desc" msgid="5940105242448544634">"Pour télécharger une carte SIM de remplacement, communiquez avec votre fournisseur de services. Cela n\'annulera aucun forfait de services cellulaires."</string>
    <string name="reset_network_button_text" msgid="2035676527471089853">"Réinitialiser les paramètres"</string>
    <string name="reset_network_final_desc" msgid="4690205209934596665">"Réinitialiser tous les paramètres réseau? Cette action est irréversible."</string>
    <string name="reset_network_final_desc_esim" msgid="6641433458865914227">"Réinitialiser tous les paramètres réseau et effacer les cartes SIM téléchargées? Vous ne pouvez pas annuler cette action."</string>
    <string name="reset_network_final_button_text" msgid="1797434793741744635">"Réinitialiser les paramètres"</string>
    <string name="reset_network_confirm_title" msgid="1759888886976962773">"Réinitialiser?"</string>
    <string name="network_reset_not_available" msgid="7188610385577164676">"La réinitialisation du réseau n\'est pas disponible pour cet utilisateur."</string>
    <string name="reset_network_complete_toast" msgid="787829973559541880">"Les paramètres réseau ont été réinitialisés"</string>
    <string name="reset_esim_error_title" msgid="2679159494023044398">"Impossible d\'effacer les cartes SIM"</string>
    <string name="reset_esim_error_msg" msgid="1356899750645220749">"Les cartes SIM téléchargées ne peuvent pas être effacées en raison d\'une erreur.\n\nRedémarrez votre appareil et réessayez."</string>
    <string name="master_clear_title" msgid="3531267871084279512">"Effacer toutes les données (réinitialisation d\'usine)"</string>
    <string name="master_clear_short_title" msgid="8652450915870274285">"Effac. ttes données (réinit.)"</string>
    <string name="master_clear_desc" product="tablet" msgid="2314458161059569301">"Cette action effacera toutes les données de la "<b>"mémoire de stockage interne"</b>" de votre tablette, y compris :\n\n"<li>"Votre compte Google"</li>\n<li>"Les données et paramètres du système et de l\'application"</li>\n<li>"Les applications téléchargées"</li></string>
    <string name="master_clear_desc" product="default" msgid="7647628092266675099">"Cette action effacera toutes les données de la "<b>"mémoire de stockage interne"</b>" de votre téléphone, y compris :\n\n"<li>"Votre compte Google"</li>\n<li>"Les données et paramètres du système et de l\'application"</li>\n<li>"Les applications téléchargées"</li></string>
    <string name="master_clear_accounts" product="default" msgid="6412857499147999073">\n\n"Vous êtes actuellement connecté aux comptes suivants :\n"</string>
    <string name="master_clear_other_users_present" product="default" msgid="5161423070702470742">\n\n"D\'autres personnes utilisent cet appareil.\n"</string>
    <string name="master_clear_desc_also_erases_external" msgid="1903185203791274237"><li>"Musique"</li>\n<li>"Photos"</li>\n<li>"Autres données utilisateur"</li></string>
    <string name="master_clear_desc_also_erases_esim" msgid="6008213558725767177"><li>"Cartes eSIM"</li></string>
    <string name="master_clear_desc_no_cancel_mobile_plan" msgid="5460926449093211144">\n\n"Cela n\'annulera pas votre forfait de services cellulaires."</string>
    <string name="master_clear_desc_erase_external_storage" product="nosdcard" msgid="7744115866662613411">\n\n"Pour supprimer la musique, les photos et les autres données utilisateur, vous devez effacer la "<b>"mémoire de stockage USB"</b>"."</string>
    <string name="master_clear_desc_erase_external_storage" product="default" msgid="4801026652617377093">\n\n"Pour supprimer la musique, les photos et les autres données utilisateur, vous devez effacer la "<b>"carte SD"</b>"."</string>
    <string name="erase_external_storage" product="nosdcard" msgid="969364037450286809">"Effacer la mémoire de stockage USB"</string>
    <string name="erase_external_storage" product="default" msgid="1397239046334307625">"Effacer la carte SD"</string>
    <string name="erase_external_storage_description" product="nosdcard" msgid="4728558173931599429">"Effacer toutes les données de la mémoire de stockage USB interne, telles que la musique ou les photos"</string>
    <string name="erase_external_storage_description" product="default" msgid="1737638779582964966">"Effacer toutes les données de la carte SD, telles que la musique ou les photos"</string>
    <string name="master_clear_button_text" product="tablet" msgid="1893179883931194922">"Effacer toutes les données"</string>
    <string name="master_clear_button_text" product="default" msgid="1893179883931194922">"Effacer toutes les données"</string>
    <string name="master_clear_final_desc" msgid="8219087639717327355">"Tous vos renseignements personnels et les applications téléchargées seront supprimés. Vous ne pouvez pas annuler cette action."</string>
    <string name="master_clear_final_desc_esim" msgid="4580223096319568030">"Tous vos renseignements personnels, y compris les applications et les cartes SIM téléchargées, seront supprimées. Vous ne pouvez pas annuler cette action."</string>
    <string name="master_clear_final_button_text" msgid="5390908019019242910">"Tout effacer"</string>
    <string name="master_clear_failed" msgid="2503230016394586353">"Les données n\'ont pas été réinitialisées, car le service de nettoyage du système n\'est pas disponible."</string>
    <string name="master_clear_confirm_title" msgid="1134724452049918413">"Effacer toutes les données?"</string>
    <string name="master_clear_not_available" msgid="1000370707967468909">"Le rétablissement de la configuration d\'usine n\'est pas possible pour cet utilisateur"</string>
    <string name="master_clear_progress_title" msgid="5194793778701994634">"Suppression en cours..."</string>
    <string name="master_clear_progress_text" msgid="6559096229480527510">"Veuillez patienter..."</string>
    <string name="call_settings_title" msgid="5188713413939232801">"Paramètres d\'appel"</string>
    <string name="call_settings_summary" msgid="7291195704801002886">"Configurer la messagerie vocale, le transfert d\'appel, la mise en attente d\'appels, le numéro de l\'appelant"</string>
    <string name="tether_settings_title_usb" msgid="6688416425801386511">"Partage de connexion par USB"</string>
    <string name="tether_settings_title_wifi" msgid="3277144155960302049">"Point d\'accès Wi-Fi mobile"</string>
    <string name="tether_settings_title_bluetooth" msgid="355855408317564420">"Partage connexion Bluetooth"</string>
    <string name="tether_settings_title_usb_bluetooth" msgid="5355828977109785001">"Partage de connexion"</string>
    <string name="tether_settings_title_all" msgid="3058586928118801157">"Partage de connexion"</string>
    <string name="tether_settings_summary_hotspot_on_tether_on" msgid="930464462687425777">"Point d\'accès activé, partage de connexion"</string>
    <string name="tether_settings_summary_hotspot_on_tether_off" msgid="3473671453891735907">"Point d\'accès activé"</string>
    <string name="tether_settings_summary_hotspot_off_tether_on" msgid="1618256180720077354">"Partage de connexion"</string>
    <string name="tether_settings_disabled_on_data_saver" msgid="1576908608463904152">"Impossible de partager la connexion ou d\'utiliser des points d\'accès mobiles lorsque la fonction Économiseur de données est activée"</string>
    <string name="usb_title" msgid="7483344855356312510">"USB"</string>
    <string name="usb_tethering_button_text" msgid="585829947108007917">"Partage de connexion par USB"</string>
    <string name="usb_tethering_subtext" product="default" msgid="3711893746716442706">"Partager la connexion Internet du téléphone par connexion USB"</string>
    <string name="usb_tethering_subtext" product="tablet" msgid="2292916486612255069">"Partager la connexion Internet de la tablette par connexion USB"</string>
    <string name="bluetooth_tether_checkbox_text" msgid="2379175828878753652">"Partage de connexion par Bluetooth"</string>
    <string name="bluetooth_tethering_subtext" product="tablet" msgid="8828883800511737077">"Partager la connexion Internet de la tablette par Bluetooth"</string>
    <string name="bluetooth_tethering_subtext" product="default" msgid="1904667146601254812">"Partager la connexion Internet du téléphone par Bluetooth"</string>
    <string name="bluetooth_tethering_off_subtext_config" msgid="376389105752995580">"Partager la connexion Internet de <xliff:g id="DEVICE_NAME">%1$d</xliff:g> par Bluetooth"</string>
    <string name="bluetooth_tethering_overflow_error" msgid="2135590598511178690">"Partage connexion impossible au-delà de <xliff:g id="MAXCONNECTION">%1$d</xliff:g> appareils."</string>
    <string name="bluetooth_untether_blank" msgid="2871192409329334813">"Le partage de connexion avec <xliff:g id="DEVICE_NAME">%1$s</xliff:g> va être annulé."</string>
    <string name="tethering_footer_info" msgid="7112228674056306147">"Utilisez un point d\'accès et le partage de connexion pour fournir un accès Internet à d\'autres appareils par l\'intermédiaire de votre connexion cellulaire. Les applications peuvent aussi créer un point d\'accès pour partager du contenu avec d\'autres appareils à proximité."</string>
    <string name="tethering_help_button_text" msgid="656117495547173630">"Aide"</string>
    <string name="network_settings_title" msgid="2876509814832830757">"Réseau cellulaire"</string>
    <string name="manage_mobile_plan_title" msgid="7630170375010107744">"Forfait de données cellulaires"</string>
    <string name="sms_application_title" msgid="4903928270533250448">"Application de messagerie texte"</string>
    <string name="sms_change_default_dialog_title" msgid="1958688831875804286">"Modifier l\'application de messagerie texte?"</string>
    <string name="sms_change_default_dialog_text" msgid="1522783933230274787">"Utiliser <xliff:g id="NEW_APP">%1$s</xliff:g> au lieu de <xliff:g id="CURRENT_APP">%2$s</xliff:g> comme application de messagerie texte?"</string>
    <string name="sms_change_default_no_previous_dialog_text" msgid="602683880284921998">"Utiliser <xliff:g id="NEW_APP">%s</xliff:g> comme application de messagerie texte?"</string>
    <string name="network_scorer_picker_title" msgid="6383879578279046456">"Fournisseur d\'avis sur le réseau"</string>
    <string name="network_scorer_picker_none_preference" msgid="9028375117241790936">"Aucun"</string>
    <string name="network_scorer_change_active_dialog_title" msgid="3776301550387574975">"Changer d\'assistant Wi‑Fi?"</string>
    <string name="network_scorer_change_active_dialog_text" msgid="8035173880322990715">"Utilisez <xliff:g id="NEW_APP">%1$s</xliff:g> au lieu de <xliff:g id="CURRENT_APP">%2$s</xliff:g> pour gérer vos connexions réseau?"</string>
    <string name="network_scorer_change_active_no_previous_dialog_text" msgid="7444620909047611601">"Utiliser <xliff:g id="NEW_APP">%s</xliff:g> pour gérer vos connexions réseau?"</string>
    <string name="mobile_unknown_sim_operator" msgid="2156912373230276157">"Fournisseur de la carte SIM inconnu"</string>
    <string name="mobile_no_provisioning_url" msgid="9053814051811634125">"Aucun site Web de configuration connu pour <xliff:g id="OPERATOR">%1$s</xliff:g>"</string>
    <string name="mobile_insert_sim_card" msgid="9052590985784056395">"Insérez la carte SIM, puis redémarrez."</string>
    <string name="mobile_connect_to_internet" msgid="1733894125065249639">"Connectez-vous à Internet."</string>
    <string name="location_category_recent_location_requests" msgid="1938721350424447421">"Demandes de localisation récentes"</string>
    <string name="location_recent_location_requests_see_all" msgid="9063541547120162593">"Tout afficher"</string>
    <string name="location_category_location_services" msgid="7437150886946685979">"Services de localisation"</string>
    <string name="location_title" msgid="1029961368397484576">"My Location"</string>
    <string name="managed_profile_location_switch_title" msgid="6712332547063039683">"Position pour profil profess."</string>
    <string name="location_app_level_permissions" msgid="2777033567595680764">"Autorisations des applications"</string>
    <string name="location_app_permission_summary_location_off" msgid="2790918244874943070">"Le signalement de position est désactivé"</string>
    <plurals name="location_app_permission_summary_location_on" formatted="false" msgid="5336807018727349708">
      <item quantity="one"> <xliff:g id="PERMITTED_LOCATION_APP_COUNT_2">%1$d</xliff:g> application sur <xliff:g id="TOTAL_LOCATION_APP_COUNT_3">%2$d</xliff:g> a accès à la position</item>
      <item quantity="other"> <xliff:g id="PERMITTED_LOCATION_APP_COUNT_2">%1$d</xliff:g> applications sur <xliff:g id="TOTAL_LOCATION_APP_COUNT_3">%2$d</xliff:g> ont accès à la position</item>
    </plurals>
    <string name="location_category_recent_location_access" msgid="4911449278675337490">"Accès récents à la position"</string>
    <string name="location_recent_location_access_view_details" msgid="1955078513330927035">"Afficher les détails"</string>
    <string name="location_no_recent_apps" msgid="2800907699722178041">"Aucune application n\'a récemment demandé l\'accès à votre position"</string>
    <string name="location_no_recent_accesses" msgid="7489449862187886009">"Aucune application n\'a récemment accédé à la position"</string>
    <string name="location_high_battery_use" msgid="517199943258508020">"Forte utilisation de la pile"</string>
    <string name="location_low_battery_use" msgid="8602232529541903596">"Faible utilisation de la pile"</string>
    <string name="location_scanning_screen_title" msgid="2297479353298444503">"Recherche Wi‑Fi et Bluetooth"</string>
    <string name="location_scanning_wifi_always_scanning_title" msgid="6216705505621183645">"Recherche de réseaux Wi-Fi"</string>
    <string name="location_scanning_wifi_always_scanning_description" msgid="2691110218127379249">"Autoriser les applications et les services à rechercher les réseaux Wi-Fi en tout temps, même lorsque le Wi-Fi est désactivé. Cette autorisation peut permettre, par exemple, d\'améliorer les fonctionnalités et les services basés sur la localisation."</string>
    <string name="location_scanning_bluetooth_always_scanning_title" msgid="5444989508204520019">"Recherche d\'appareils Bluetooth"</string>
    <string name="location_scanning_bluetooth_always_scanning_description" msgid="1285526059945206128">"Autoriser les applications et les services à rechercher les appareils à proximité en tout temps, même lorsque le Bluetooth est désactivé. Cette autorisation peut permettre, par exemple, d\'améliorer les fonctionnalités et les services basés sur la localisation."</string>
    <string name="managed_profile_location_services" msgid="4723268446874715222">"Services de localisation pour le travail"</string>
    <string name="location_network_based" msgid="9134175479520582215">"Localis. via Wi-Fi et réseau mob."</string>
    <string name="location_neighborhood_level" msgid="5141318121229984788">"Autoriser applis à utiliser localisation Google pour estimer position plus rapidement. Infos localisation anonymes envoyées à Google."</string>
    <string name="location_neighborhood_level_wifi" msgid="4234820941954812210">"Position déterminée par le Wi-Fi"</string>
    <string name="location_gps" msgid="8392461023569708478">"Satellites GPS"</string>
    <string name="location_street_level" product="tablet" msgid="1669562198260860802">"Autoriser les applications à utiliser le GPS sur votre tablette pour vous localiser"</string>
    <string name="location_street_level" product="default" msgid="4617445745492014203">"Autoriser les applications à utiliser le GPS sur votre téléphone pour vous localiser"</string>
    <string name="assisted_gps" msgid="4649317129586736885">"Utiliser le GPS assisté"</string>
    <string name="assisted_gps_enabled" msgid="8751899609589792803">"Utiliser le serveur pour assister le GPS (désactiver pour réduire l\'utilisation du réseau)"</string>
    <string name="assisted_gps_disabled" msgid="6982698333968010748">"Utiliser le serveur pour assister le GPS (désactiver pour améliorer les performances du GPS)"</string>
    <string name="use_location_title" msgid="5206937465504979977">"Localisation/recherche Google"</string>
    <string name="use_location_summary" msgid="3978805802386162520">"Autoriser Google à utiliser votre position pour améliorer les résultats de recherche et les services"</string>
    <string name="location_access_title" msgid="7064108942964081243">"Accès à ma position"</string>
    <string name="location_access_summary" msgid="69031404093194341">"Permettre aux applis ayant demandé l\'autorisation d\'utiliser vos infos de localisation"</string>
    <string name="location_sources_heading" msgid="1278732419851088319">"Sources de localisation"</string>
    <string name="about_settings" product="tablet" msgid="593457295516533765">"À propos de la tablette"</string>
    <string name="about_settings" product="default" msgid="1743378368185371685">"À propos du téléphone"</string>
    <string name="about_settings" product="device" msgid="6717640957897546887">"À propos de l\'appareil"</string>
    <string name="about_settings" product="emulator" msgid="221313099578564438">"À propos de l\'appareil émulé"</string>
    <string name="about_settings_summary" msgid="3371517697156165959">"Informations légales, état et version du logiciel"</string>
    <string name="legal_information" msgid="5769301644270604095">"Renseignements juridiques"</string>
    <string name="contributors_title" msgid="5917703088825286504">"Contributeurs"</string>
    <string name="manual" msgid="3025943393642974445">"Manuel"</string>
    <string name="regulatory_labels" msgid="1293050314122427492">"Étiquettes réglementaires"</string>
    <string name="safety_and_regulatory_info" msgid="5103161279848427185">"Guide relatif à la sécurité et à la réglementation"</string>
    <string name="copyright_title" msgid="865906688917260647">"Droits d\'auteur"</string>
    <string name="license_title" msgid="1990487604356037871">"Licence"</string>
    <string name="module_license_title" msgid="258743239066841860">"Licences des mises à jour système pour Google Play"</string>
    <string name="terms_title" msgid="7697580845616764642">"Conditions d\'utilisation"</string>
    <string name="webview_license_title" msgid="2813507464175738967">"Licence WebView du système"</string>
    <string name="wallpaper_attributions" msgid="3645880512943433928">"Fonds d\'écran"</string>
    <string name="wallpaper_attributions_values" msgid="2996183537914690469">"Fournisseurs d\'images satellite :\n© CNES/Astrium, DigitalGlobe, Bluesky 2014"</string>
    <string name="settings_manual_activity_title" msgid="8133150693616006051">"Manuel"</string>
    <string name="settings_manual_activity_unavailable" msgid="4752403782883814898">"Problème lors du chargement du manuel."</string>
    <string name="settings_license_activity_title" msgid="8525014571806471216">"Licences tierces"</string>
    <string name="settings_license_activity_unavailable" msgid="4210539215951487627">"Un problème est survenu lors du chargement des licences."</string>
    <string name="settings_license_activity_loading" msgid="3337535809093591740">"Chargement en cours..."</string>
    <string name="settings_safetylegal_title" msgid="1289483965535937431">"Informations de sécurité"</string>
    <string name="settings_safetylegal_activity_title" msgid="6901214628496951727">"Informations de sécurité"</string>
    <string name="settings_safetylegal_activity_unreachable" msgid="142307697309858185">"Vous n\'avez pas de connexion Internet. Pour consulter ces renseignements maintenant, accédez à %s sur un ordinateur connecté à Internet."</string>
    <string name="settings_safetylegal_activity_loading" msgid="8059022597639516348">"Chargement en cours..."</string>
    <string name="confirm_device_credential_pin" msgid="5308435093406166355">"Utiliser un NIP"</string>
    <string name="confirm_device_credential_pattern" msgid="1350321840134412900">"Utiliser un schéma"</string>
    <string name="confirm_device_credential_password" msgid="2195705238498478704">"Utiliser un mot de passe"</string>
    <string name="lockpassword_choose_your_screen_lock_header" msgid="2942199737559900752">"Configurer le verrouillage de l\'écran"</string>
    <string name="lockpassword_choose_your_password_message" msgid="5377842480961577542">"Pour votre sécurité, définissez un mot de passe"</string>
    <string name="lockpassword_choose_your_password_header_for_fingerprint" msgid="6624409510609085450">"Pour util. empr. digit., config. m. de passe"</string>
    <string name="lockpassword_choose_your_pattern_header_for_fingerprint" msgid="5901096361617543819">"Pour utiliser empreinte digitale, configurer un schéma"</string>
    <string name="lockpassword_choose_your_pin_message" msgid="6658264750811929338">"Pour votre sécurité, définissez un NIP"</string>
    <string name="lockpassword_choose_your_pin_header_for_fingerprint" msgid="765344692615917183">"Pour util. empr. digit., config. NIP"</string>
    <string name="lockpassword_choose_your_pattern_message" msgid="8631545254345759087">"Pour votre sécurité, définissez un schéma de verrouillage"</string>
    <string name="lockpassword_confirm_your_password_header" msgid="1266027268220850931">"Entrez de nouveau votre mot de passe"</string>
    <string name="lockpassword_confirm_your_pattern_header" msgid="7543433733032330821">"Confirmez votre schéma"</string>
    <string name="lockpassword_confirm_your_pin_header" msgid="7744513791910572550">"Entrer de nouveau votre NIP"</string>
    <string name="lockpassword_confirm_passwords_dont_match" msgid="5140892109439191415">"Les mots de passe ne correspondent pas."</string>
    <string name="lockpassword_confirm_pins_dont_match" msgid="7226244811505606217">"Les NIP ne correspondent pas."</string>
    <string name="lockpassword_draw_your_pattern_again_header" msgid="2872194349688886781">"Tracer votre schéma à nouveau"</string>
    <string name="lockpassword_choose_lock_generic_header" msgid="3811438094903786145">"Mode de déverrouillage"</string>
    <string name="lockpassword_password_set_toast" msgid="4875050283108629383">"Le mot de passe a été défini."</string>
    <string name="lockpassword_pin_set_toast" msgid="6011826444725291475">"Le NIP a été défini."</string>
    <string name="lockpassword_pattern_set_toast" msgid="6867259621331406236">"Le schéma a été défini."</string>
    <string name="lockpassword_choose_your_password_header_for_face" msgid="6696331060928616331">"Pour util. dév. par rec. faciale, créez m.d.p."</string>
    <string name="lockpassword_choose_your_pattern_header_for_face" msgid="3981667199682290816">"Pour util. dév. par rec. faciale, config. schéma"</string>
    <string name="lockpassword_choose_your_pin_header_for_face" msgid="3692990199320431002">"Pour util. dév. par rec. faciale, config. NIP"</string>
    <string name="lockpassword_confirm_your_pattern_generic" msgid="2920960858283879113">"Entrez le schéma de l\'appareil pour continuer"</string>
    <string name="lockpassword_confirm_your_pin_generic" msgid="4062335874438910487">"Entrez le NIP de l\'appareil pour continuer."</string>
    <string name="lockpassword_confirm_your_password_generic" msgid="3976394862548354966">"Entrez le mot de passe de l\'appareil pour continuer."</string>
    <string name="lockpassword_confirm_your_pattern_generic_profile" msgid="4435638308193361861">"Entrez le schéma de votre profil professionnel pour continuer"</string>
    <string name="lockpassword_confirm_your_pin_generic_profile" msgid="3730141667547002246">"Entrez le NIP de votre profil professionnel pour continuer"</string>
    <string name="lockpassword_confirm_your_password_generic_profile" msgid="4250642723467019894">"Entrez le mot de passe de votre profil professionnel pour continuer"</string>
    <string name="lockpassword_strong_auth_required_device_pattern" msgid="530802132223800623">"Pour plus de sécurité, tracez le schéma de votre appareil"</string>
    <string name="lockpassword_strong_auth_required_device_pin" msgid="7829294830078036417">"Pour plus de sécurité, entrez le NIP de votre appareil"</string>
    <string name="lockpassword_strong_auth_required_device_password" msgid="3552644641574796973">"Pour plus de sécurité, entrez le mot de passe de votre appareil"</string>
    <string name="lockpassword_strong_auth_required_work_pattern" msgid="3003781907040522053">"Pour plus de sécurité, tracez votre schéma professionnel"</string>
    <string name="lockpassword_strong_auth_required_work_pin" msgid="3367491332598821552">"Pour plus de sécurité, entrez votre NIP professionnel"</string>
    <string name="lockpassword_strong_auth_required_work_password" msgid="8159775129968582940">"Pour plus de sécurité, entrez votre mot de passe professionnel"</string>
    <string name="lockpassword_confirm_your_pattern_details_frp" msgid="6757336656791723193">"La configuration d\'usine du téléphone a été rétablie. Pour l\'utiliser, entrez le schéma précédent."</string>
    <string name="lockpassword_confirm_your_pin_details_frp" msgid="826520613445990470">"La configuration d\'usine du téléphone a été rétablie. Pour l\'utiliser, entrez le NIP précédent."</string>
    <string name="lockpassword_confirm_your_password_details_frp" msgid="8944081074615739040">"La configuration d\'usine du téléphone a été rétablie. Pour l\'utiliser, entrez le mot passe précédent."</string>
    <string name="lockpassword_confirm_your_pattern_header_frp" msgid="2898036091609128286">"Vérifier le schéma"</string>
    <string name="lockpassword_confirm_your_pin_header_frp" msgid="4141601774778898803">"Vérifier le NIP"</string>
    <string name="lockpassword_confirm_your_password_header_frp" msgid="3762615419295360480">"Vérifier le mot de passe"</string>
    <string name="lockpassword_invalid_pin" msgid="15588049067548470">"NIP erroné"</string>
    <string name="lockpassword_invalid_password" msgid="4038507398784975200">"Mot de passe incorrect"</string>
    <string name="lockpattern_need_to_unlock_wrong" msgid="1745247595356012176">"Schéma erroné"</string>
    <string name="lock_settings_title" msgid="4213839087748988686">"Sécurité de l\'appareil"</string>
    <string name="lockpattern_change_lock_pattern_label" msgid="5679630792003440352">"Modifier le schéma"</string>
    <string name="lockpattern_change_lock_pin_label" msgid="266707138486731661">"Modifier le NIP de déverrouillage"</string>
    <string name="lockpattern_recording_intro_header" msgid="308287052221942814">"Dessinez un schéma de déverrouillage"</string>
    <string name="lockpattern_recording_intro_footer" msgid="1118579101409152113">"Appuyez sur Menu pour obtenir de l\'aide."</string>
    <string name="lockpattern_recording_inprogress" msgid="6667844062721656773">"Retirez le doigt lorsque vous avez terminé."</string>
    <string name="lockpattern_recording_incorrect_too_short" msgid="1348234155120957561">"Reliez au moins <xliff:g id="NUMBER">%d</xliff:g> points. Veuillez réessayer."</string>
    <string name="lockpattern_pattern_entered_header" msgid="4316818983675591604">"Schéma enregistré"</string>
    <string name="lockpattern_need_to_confirm" msgid="8054853451639221265">"Redessinez le schéma pour confirmer"</string>
    <string name="lockpattern_pattern_confirmed_header" msgid="8455614172231880211">"Votre nouveau schéma de déverrouillage est le suivant :"</string>
    <string name="lockpattern_confirm_button_text" msgid="1128204343957002841">"Confirmer"</string>
    <string name="lockpattern_restart_button_text" msgid="3337574403350953926">"Redessiner"</string>
    <string name="lockpattern_retry_button_text" msgid="3480423193273588166">"Effacer"</string>
    <string name="lockpattern_continue_button_text" msgid="4723771754714471410">"Continuer"</string>
    <string name="lockpattern_settings_title" msgid="3207750489460466680">"Schéma de déverrouillage"</string>
    <string name="lockpattern_settings_enable_title" msgid="6920616873671115281">"Schéma obligatoire"</string>
    <string name="lockpattern_settings_enable_summary" msgid="1165707416664252167">"Dessiner un schéma pour déverrouiller l\'écran"</string>
    <string name="lockpattern_settings_enable_visible_pattern_title" msgid="2615606088906120711">"Faire apparaître le schéma"</string>
    <string name="lockpattern_settings_enable_visible_pattern_title_profile" msgid="4864525074768391381">"Rendre visible le schéma du profil"</string>
    <string name="lockpattern_settings_enable_tactile_feedback_title" msgid="4389015658335522989">"Vibrer au toucher"</string>
    <string name="lockpattern_settings_enable_power_button_instantly_locks" msgid="5735444062633666327">"Verr. auto avec Marche/Arrêt"</string>
    <string name="lockpattern_settings_power_button_instantly_locks_summary" msgid="8196258755143711694">"Sauf lorsque l\'appareil est maintenu en activité par <xliff:g id="TRUST_AGENT_NAME">%1$s</xliff:g>"</string>
    <string name="lockpattern_settings_choose_lock_pattern" msgid="1652352830005653447">"Créer un schéma"</string>
    <string name="lockpattern_settings_change_lock_pattern" msgid="1123908306116495545">"Modifier le schéma"</string>
    <string name="lockpattern_settings_help_how_to_record" msgid="2614673439060830433">"Comment dessiner un schéma de déverrouillage :"</string>
    <string name="lockpattern_too_many_failed_confirmation_attempts" msgid="6909161623701848863">"Trop de tentatives incorrectes. Réessayez dans <xliff:g id="NUMBER">%d</xliff:g> secondes."</string>
    <string name="activity_not_found" msgid="5551664692991605325">"L\'application n\'est pas installée sur votre téléphone."</string>
    <string name="lock_settings_profile_title" msgid="2121876391814535295">"Sécurité du profil professionnel"</string>
    <string name="lock_settings_profile_screen_lock_title" msgid="3334747927367115256">"Verrouillage de l\'écran du profil professionnel"</string>
    <string name="lock_settings_profile_unification_title" msgid="4973102698492659123">"Utiliser un seul mode de verrouillage"</string>
    <string name="lock_settings_profile_unification_summary" msgid="7178299172998641303">"Utiliser un seul mode de verrouillage pour le profil professionnel et l\'écran de l\'appareil"</string>
    <string name="lock_settings_profile_unification_dialog_title" msgid="4824620230229285301">"Utiliser un seul mode de verrouillage?"</string>
    <string name="lock_settings_profile_unification_dialog_body" msgid="7128305504872026659">"Votre appareil utilisera l\'écran de verrouillage de votre profil professionnel. Les politiques du profil professionnel s\'appliqueront aux deux verrouillages."</string>
    <string name="lock_settings_profile_unification_dialog_uncompliant_body" msgid="3221303098797469900">"Le mode de verrouillage de votre profil professionnel ne correspond pas aux exigences de sécurité de votre organisation. Vous pouvez utiliser le même mode de verrouillage pour l\'écran de votre appareil et votre profil professionnel. Dans ce cas, les politiques de verrouillage du profil professionnel seront applicables."</string>
    <string name="lock_settings_profile_unification_dialog_confirm" msgid="8249970828159656518">"Utiliser un seul mode de verrouillage"</string>
    <string name="lock_settings_profile_unification_dialog_uncompliant_confirm" msgid="5943758576756482777">"Utiliser un seul mode de verrouillage"</string>
    <string name="lock_settings_profile_unified_summary" msgid="9008819078132993492">"Identique au verrouillage de l\'écran de l\'appareil"</string>
    <string name="manageapplications_settings_title" msgid="7041951105633616745">"Gérer les applications"</string>
    <string name="manageapplications_settings_summary" msgid="1794401500935451259">"Gérer et supprimer les applications installées"</string>
    <string name="applications_settings" msgid="5281808652705396152">"Détails de l\'application"</string>
    <string name="applications_settings_summary" msgid="6683465446264515367">"Gérer les applications, configurer des raccourcis de lancement rapide"</string>
    <string name="applications_settings_header" msgid="1014813055054356646">"Paramètres de l\'application"</string>
    <string name="install_applications" msgid="4872012136210802181">"Sources inconnues"</string>
    <string name="install_applications_title" msgid="4987712352256508946">"Autoriser toutes sources appli"</string>
    <string name="recent_app_category_title" msgid="6673071268966003928">"Applications récemment ouvertes"</string>
    <string name="see_all_apps_title" msgid="1317153498074308438">"Afficher les <xliff:g id="COUNT">%1$d</xliff:g> applications"</string>
    <string name="install_all_warning" product="tablet" msgid="8310489909586138165">"Votre tablette et vos données personnelles sont plus vulnérables aux attaques provenant d\'applications inconnues. En installant des applications provenant de cette source, vous acceptez d\'être le seul responsable de tout dommage causé à votre tablette ou de toute perte de données pouvant découler de l\'utilisation de telles applications."</string>
    <string name="install_all_warning" product="default" msgid="1952257127370115988">"Votre téléphone et vos données personnelles sont plus vulnérables aux attaques provenant d\'applications inconnues. En installant des applications provenant de cette source, vous acceptez d\'être le seul responsable de tout dommage causé à votre téléphone ou de toute perte de données pouvant découler de l\'utilisation de telles applications."</string>
    <string name="install_all_warning" product="device" msgid="3648003301476423145">"Votre appareil et vos données personnelles sont plus vulnérables aux attaques provenant d\'applications inconnues. En installant des applications provenant de cette source, vous acceptez d\'être responsable de tout dommage causé à votre appareil ou de toute perte de données pouvant découler de l\'utilisation de telles applications."</string>
    <string name="advanced_settings" msgid="1777249286757067969">"Paramètres avancés"</string>
    <string name="advanced_settings_summary" msgid="4016682978071086747">"Activer d\'autres paramètres"</string>
    <string name="application_info_label" msgid="5736524913065714880">"Infos sur l\'application"</string>
    <string name="storage_label" msgid="8700867073480107253">"Stockage"</string>
    <string name="auto_launch_label" msgid="2669236885531442195">"Ouvert par défaut"</string>
    <string name="auto_launch_label_generic" msgid="3230569852551968694">"Valeurs par défaut"</string>
    <string name="screen_compatibility_label" msgid="663250687205465394">"Compatibilité de l\'écran"</string>
    <string name="permissions_label" msgid="2605296874922726203">"Autorisations"</string>
    <string name="cache_header_label" msgid="1877197634162461830">"Cache"</string>
    <string name="clear_cache_btn_text" msgid="5756314834291116325">"Vider le cache"</string>
    <string name="cache_size_label" msgid="7505481393108282913">"Cache"</string>
    <plurals name="uri_permissions_text" formatted="false" msgid="3983110543017963732">
      <item quantity="one">%d élément</item>
      <item quantity="other">%d éléments</item>
    </plurals>
    <string name="clear_uri_btn_text" msgid="8575655132961012158">"Supprimer l\'accès"</string>
    <string name="controls_label" msgid="7611113077086853799">"Commandes"</string>
    <string name="force_stop" msgid="7435006169872876756">"Forcer l\'arrêt"</string>
    <string name="total_size_label" msgid="1048676419552557254">"Total"</string>
    <string name="application_size_label" msgid="7376689739076506885">"Taille de l\'application"</string>
    <string name="external_code_size_label" msgid="3459343140355961335">"Application sur USB"</string>
    <string name="data_size_label" msgid="6117971066063850416">"Données de l\'utilisateur"</string>
    <string name="external_data_size_label" product="nosdcard" msgid="7533821466482000453">"Données sur USB"</string>
    <string name="external_data_size_label" product="default" msgid="626414192825329708">"Carte SD"</string>
    <string name="uninstall_text" msgid="3644892466144802466">"Désinstaller"</string>
    <string name="uninstall_all_users_text" msgid="851857393177950340">"Uninstall for all users"</string>
    <string name="install_text" msgid="884360662922471113">"Installer"</string>
    <string name="disable_text" msgid="6544054052049395202">"Désactiver"</string>
    <string name="enable_text" msgid="9217362512327828987">"Activer"</string>
    <string name="clear_user_data_text" msgid="355574089263023363">"Effacer le stockage"</string>
    <string name="app_factory_reset" msgid="6635744722502563022">"Désinstaller mises à jour"</string>
    <string name="auto_launch_enable_text" msgid="4275746249511874845">"Vous avez choisi de lancer cette application par défaut pour certaines actions."</string>
    <string name="always_allow_bind_appwidgets_text" msgid="566822577792032925">"Vous avez choisi de permettre à cette application de créer des widgets et d\'accéder à leurs données."</string>
    <string name="auto_launch_disable_text" msgid="7800385822185540166">"Aucun paramètre par défaut défini"</string>
    <string name="clear_activities" msgid="7408923511535174430">"Effacer les actions par défaut"</string>
    <string name="screen_compatibility_text" msgid="1616155457673106022">"Cette application n\'est peut-être pas adaptée à votre écran. Vous pouvez modifier les paramètres d\'ajustement ici."</string>
    <string name="ask_compatibility" msgid="7225195569089607846">"Demander au moment du lancement"</string>
    <string name="enable_compatibility" msgid="5806819252068617811">"Mettre l\'application à l\'échelle"</string>
    <string name="unknown" msgid="1592123443519355854">"Inconnu"</string>
    <string name="sort_order_alpha" msgid="1410278099123670628">"Trier par nom"</string>
    <string name="sort_order_size" msgid="7024513286636502362">"Trier par taille"</string>
    <string name="sort_order_recent_notification" msgid="6064103501358974282">"Les plus récentes"</string>
    <string name="sort_order_frequent_notification" msgid="1733204081305830670">"Les plus fréquentes"</string>
    <string name="show_running_services" msgid="5736278767975544570">"Afficher les services en cours"</string>
    <string name="show_background_processes" msgid="2009840211972293429">"Afficher processus en cache"</string>
    <string name="default_emergency_app" msgid="1951760659640369980">"Application d\'urgence"</string>
    <string name="reset_app_preferences" msgid="1321050641018356925">"Réinitialiser préférences applis"</string>
    <string name="reset_app_preferences_title" msgid="6093179367325336662">"Réinitialiser préférences applis?"</string>
    <string name="reset_app_preferences_desc" msgid="731757609326016760">"Cette opération réinitialise toutes les préférences relatives aux éléments suivants :\n\n"<li>"Applications désactivées"</li>\n<li>"Notifications associées aux applications désactivées"</li>\n<li>"Applications par défaut pour les actions"</li>\n<li>"Restrictions de données en arrière-plan pour les applications"</li>\n<li>"Toutes les restrictions d\'autorisations"</li>\n\n"Vous ne perdrez aucune donnée liée aux applications."</string>
    <string name="reset_app_preferences_button" msgid="2559089511841281242">"Réinitialiser applis"</string>
    <string name="manage_space_text" msgid="8852711522447794676">"Gérer l\'espace"</string>
    <string name="filter" msgid="2018011724373033887">"Filtre"</string>
    <string name="filter_dlg_title" msgid="8693024463731076091">"Sélectionner les options du filtre"</string>
    <string name="filter_apps_all" msgid="8899612398848280352">"Toutes les applications"</string>
    <string name="filter_apps_disabled" msgid="5862632369555319938">"Applications désactivées"</string>
    <string name="filter_apps_third_party" msgid="7786348047690140979">"Téléchargée"</string>
    <string name="filter_apps_running" msgid="7767071454371350486">"Diffusion en cours"</string>
    <string name="filter_apps_onsdcard" product="nosdcard" msgid="4843063154701023349">"Mémoire de stockage USB"</string>
    <string name="filter_apps_onsdcard" product="default" msgid="1477351142334784771">"Sur la carte SD"</string>
    <string name="not_installed" msgid="2797554494953450291">"Pas installée pour cet utilisateur"</string>
    <string name="installed" msgid="3070865169422600098">"Installée"</string>
    <string name="no_applications" msgid="7336588977497084921">"Aucune application"</string>
    <string name="internal_storage" msgid="1584700623164275282">"Mémoire de stockage interne"</string>
    <string name="recompute_size" msgid="7722567982831691718">"Calcul de la taille..."</string>
    <string name="clear_data_dlg_title" msgid="5605258400134511197">"Supprimer les données de l\'application?"</string>
    <string name="clear_data_dlg_text" msgid="3951297329833822490">"Toutes les données de cette application seront supprimées définitivement, y compris tous les fichiers, les paramètres, les comptes, les bases de données, etc."</string>
    <string name="dlg_ok" msgid="2402639055725653590">"OK"</string>
    <string name="dlg_cancel" msgid="1674753358972975911">"Annuler"</string>
    <string name="app_not_found_dlg_title" msgid="3127123411738434964"></string>
    <string name="app_not_found_dlg_text" msgid="4893589904687340011">"L\'application ne figure pas dans la liste des applications installées."</string>
    <string name="clear_failed_dlg_text" msgid="8651231637137025815">"Impossible de supprimer l\'espace de stockage pour l\'application."</string>
    <string name="join_two_items" msgid="1336880355987539064">"<xliff:g id="FIRST_ITEM">%1$s</xliff:g> et <xliff:g id="SECOND_ITEM">%2$s</xliff:g>"</string>
    <string name="join_two_unrelated_items" msgid="1873827777191260824">"<xliff:g id="FIRST_ITEM">%1$s</xliff:g>, <xliff:g id="SECOND_ITEM">%2$s</xliff:g>"</string>
    <string name="computing_size" msgid="1599186977475211186">"Traitement..."</string>
    <string name="invalid_size_value" msgid="1582744272718752951">"Impossible de calculer la taille du package."</string>
    <string name="version_text" msgid="9189073826278676425">"version <xliff:g id="VERSION_NUM">%1$s</xliff:g>"</string>
    <string name="move_app" msgid="5042838441401731346">"Déplacer"</string>
    <string name="move_app_to_internal" product="tablet" msgid="2299714147283854957">"Déplacer vers la tablette"</string>
    <string name="move_app_to_internal" product="default" msgid="3895430471913858185">"Déplacer vers le téléphone"</string>
    <string name="move_app_to_sdcard" product="nosdcard" msgid="4350451696315265420">"Déplacer vers la mémoire de stockage USB"</string>
    <string name="move_app_to_sdcard" product="default" msgid="1143379049903056407">"Déplacer vers la carte SD"</string>
    <string name="another_migration_already_in_progress" msgid="7817354268848365487">"Un autre transfert est déjà en cours."</string>
    <string name="insufficient_storage" msgid="481763122991093080">"Espace de stockage insuffisant."</string>
    <string name="does_not_exist" msgid="1501243985586067053">"L\'application n\'existe pas."</string>
    <string name="invalid_location" msgid="4354595459063675191">"L\'emplacement d\'installation n\'est pas valide."</string>
    <string name="system_package" msgid="1352722848400644991">"Les mises à jour du système ne peuvent pas être installées sur des supports externes."</string>
    <string name="move_error_device_admin" msgid="8673026002690505763">"Les applications d\'administration d\'appareils ne peuvent pas être installées sur un support externe"</string>
    <string name="force_stop_dlg_title" msgid="977530651470711366">"Forcer l\'arrêt?"</string>
    <string name="force_stop_dlg_text" msgid="7208364204467835578">"Si vous forcez l\'arrêt d\'une application, son fonctionnement peut en être affecté."</string>
    <string name="app_install_location_title" msgid="2068975150026852168">"Emplacement d\'installation souhaité"</string>
    <string name="app_install_location_summary" msgid="5155453752692959098">"Modifier l\'emplacement d\'installation par défaut pour les nouvelles applications"</string>
    <string name="app_disable_dlg_positive" msgid="7375627244201714263">"Désactiver l\'application"</string>
    <string name="app_disable_dlg_text" msgid="1234624266290478136">"Si vous désactivez cette application, Android et d\'autres applications risquent de ne plus fonctionner correctement. Gardez à l\'esprit que vous ne pouvez pas supprimer cette application, étant donné qu\'elle était préinstallée sur votre appareil. En la désactivant, elle ne sera plus active et elle sera masquée sur votre appareil."</string>
    <string name="app_disable_notifications_dlg_title" msgid="7669264654851761857">"Désactiver les notifications?"</string>
    <string name="app_install_details_group_title" msgid="7084623031296083574">"Boutique d\'applications"</string>
    <string name="app_install_details_title" msgid="6905279702654975207">"Détails de l\'application"</string>
    <string name="app_install_details_summary" msgid="6464796332049327547">"Source de l\'application : <xliff:g id="APP_STORE">%1$s</xliff:g>"</string>
    <string name="instant_app_details_summary" msgid="4529934403276907045">"Plus d\'information sur <xliff:g id="APP_STORE">%1$s</xliff:g>"</string>
    <string name="app_ops_running" msgid="7706949900637284122">"En cours d\'exécution"</string>
    <string name="app_ops_never_used" msgid="9114608022906887802">"(Jamais utilisé)"</string>
    <string name="no_default_apps" msgid="2915315663141025400">"Pas d\'applications par défaut."</string>
    <string name="storageuse_settings_title" msgid="5657014373502630403">"Utilisation de la mémoire"</string>
    <string name="storageuse_settings_summary" msgid="3748286507165697834">"Afficher l\'espace de stockage utilisé par les applications"</string>
    <string name="service_restarting" msgid="2242747937372354306">"Redémarrage"</string>
    <string name="cached" msgid="1059590879740175019">"Processus d\'arrière-plan en cache"</string>
    <string name="no_running_services" msgid="2059536495597645347">"Aucun service en cours"</string>
    <string name="service_started_by_app" msgid="818675099014723551">"Démarré par l\'application"</string>
    <!-- no translation found for service_client_name (4037193625611815517) -->
    <skip />
    <string name="service_background_processes" msgid="6844156253576174488">"<xliff:g id="MEMORY">%1$s</xliff:g> disponible"</string>
    <string name="service_foreground_processes" msgid="7583975676795574276">"<xliff:g id="MEMORY">%1$s</xliff:g> utilisé(s)"</string>
    <string name="memory" msgid="6609961111091483458">"RAM"</string>
    <!-- no translation found for service_process_name (4098932168654826656) -->
    <skip />
    <string name="running_process_item_user_label" msgid="3129887865552025943">"Utilisateur : <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="running_process_item_removed_user_label" msgid="8250168004291472959">"Utilisateur supprimé"</string>
    <string name="running_processes_item_description_s_s" msgid="5790575965282023145">"<xliff:g id="NUMPROCESS">%1$d</xliff:g> processus et <xliff:g id="NUMSERVICES">%2$d</xliff:g> service"</string>
    <string name="running_processes_item_description_s_p" msgid="8019860457123222953">"<xliff:g id="NUMPROCESS">%1$d</xliff:g> processus et <xliff:g id="NUMSERVICES">%2$d</xliff:g> services"</string>
    <string name="running_processes_item_description_p_s" msgid="744424668287252915">"<xliff:g id="NUMPROCESS">%1$d</xliff:g> processus et <xliff:g id="NUMSERVICES">%2$d</xliff:g> service"</string>
    <string name="running_processes_item_description_p_p" msgid="1607384595790852782">"<xliff:g id="NUMPROCESS">%1$d</xliff:g> processus et <xliff:g id="NUMSERVICES">%2$d</xliff:g> services"</string>
    <string name="running_processes_header_title" msgid="6588371727640789560">"Mémoire de l\'appareil"</string>
    <string name="running_processes_header_footer" msgid="723908176275428442">"Utilisation de la mémoire vive par l\'application"</string>
    <string name="running_processes_header_system_prefix" msgid="6104153299581682047">"Système"</string>
    <string name="running_processes_header_apps_prefix" msgid="5787594452716832727">"Applications"</string>
    <string name="running_processes_header_free_prefix" msgid="4620613031737078415">"Disponible"</string>
    <string name="running_processes_header_used_prefix" msgid="5924288703085123978">"Utilisée"</string>
    <string name="running_processes_header_cached_prefix" msgid="7950853188089434987">"En cache"</string>
    <string name="running_processes_header_ram" msgid="996092388884426817">"<xliff:g id="RAM_0">%1$s</xliff:g> de mémoire vive"</string>
    <string name="runningservicedetails_settings_title" msgid="3224004818524731568">"Application en cours d\'exécution"</string>
    <string name="no_services" msgid="7133900764462288263">"Inactif"</string>
    <string name="runningservicedetails_services_title" msgid="391168243725357375">"Services"</string>
    <string name="runningservicedetails_processes_title" msgid="928115582044655268">"Processus"</string>
    <string name="service_stop" msgid="6369807553277527248">"Arrêter"</string>
    <string name="service_manage" msgid="1876642087421959194">"Paramètres"</string>
    <string name="service_stop_description" msgid="9146619928198961643">"Ce service a été démarré par son application. L\'application peut échouer si vous l\'arrêtez."</string>
    <string name="heavy_weight_stop_description" msgid="6050413065144035971">"Impossible d\'arrêter cette application en toute sécurité. Si vous l\'arrêtez, vous risquez de perdre une partie du travail en cours."</string>
    <string name="background_process_stop_description" msgid="3834163804031287685">"Ceci est un ancien processus d\'application qui peut toujours être exécuté en cas de besoin. Il n\'existe généralement aucune raison de l\'arrêter."</string>
    <string name="service_manage_description" msgid="479683614471552426">"En cours d\'utilisation : <xliff:g id="CLIENT_NAME">%1$s</xliff:g>. Touchez Paramètres pour contrôler ce client."</string>
    <string name="main_running_process_description" msgid="1130702347066340890">"Processus principal en cours d\'utilisation."</string>
    <string name="process_service_in_use_description" msgid="8993335064403217080">"Le service <xliff:g id="COMP_NAME">%1$s</xliff:g> est actuellement utilisé."</string>
    <string name="process_provider_in_use_description" msgid="5586603325677678940">"L\'opérateur <xliff:g id="COMP_NAME">%1$s</xliff:g> est actuellement utilisé."</string>
    <string name="runningservicedetails_stop_dlg_title" msgid="4253292537154337233">"Arrêter le service système?"</string>
    <string name="runningservicedetails_stop_dlg_text" product="tablet" msgid="3371302398335665793">"Si vous arrêtez ce service, certaines fonctionnalités de votre tablette peuvent cesser de fonctionner correctement jusqu\'à ce que vous ayez éteint, puis rallumé votre appareil."</string>
    <string name="runningservicedetails_stop_dlg_text" product="default" msgid="3920243762189484756">"Si vous arrêtez ce service, certaines fonctionnalités de votre téléphone peuvent cesser de fonctionner correctement jusqu\'à ce que vous ayez éteint, puis rallumé votre appareil."</string>
    <string name="language_input_gesture_title" msgid="8749227808244881255">"Langues, entrée et gestes"</string>
    <string name="language_input_gesture_summary_on_with_assist" msgid="7219895055450633449"></string>
    <string name="language_input_gesture_summary_on_non_assist" msgid="756147879200943161"></string>
    <string name="language_input_gesture_summary_off" msgid="4617198819416948217"></string>
    <string name="language_settings" msgid="8758655933029560944">"Langues et modes d\'entrée"</string>
    <string name="language_empty_list_user_restricted" msgid="5984015900102140696">"Vous n\'êtes pas autorisé à modifier la langue de l\'appareil."</string>
    <string name="language_keyboard_settings_title" msgid="3709159207482544398">"Langues et modes d\'entrée"</string>
    <string name="input_assistance" msgid="7392740255874966807">"Outils"</string>
    <string name="keyboard_settings_category" msgid="8275523930352487827">"Clavier et modes de saisie"</string>
    <string name="phone_language" msgid="7116581601133118044">"Langues"</string>
    <string name="phone_language_summary" msgid="3871309445655554211"></string>
    <string name="auto_replace" msgid="6199184757891937822">"Remplacement automatique"</string>
    <string name="auto_replace_summary" msgid="370288728200084466">"Corriger les mots mal saisis"</string>
    <string name="auto_caps" msgid="6379232078052591265">"Majuscules automatiques"</string>
    <string name="auto_caps_summary" msgid="6358102538315261466">"Mettre une majuscule en début de phrase"</string>
    <string name="auto_punctuate" msgid="4595367243950425833">"Ponctuation automatique"</string>
    <string name="hardkeyboard_category" msgid="5957168411305769899">"Paramètres du clavier physique"</string>
    <string name="auto_punctuate_summary" msgid="4372126865670574837">"Appuyez deux fois sur la touche Espace pour insérer « . »"</string>
    <string name="show_password" msgid="4837897357002495384">"Afficher les mots de passe"</string>
    <string name="show_password_summary" msgid="3365397574784829969">"Afficher les caractères brièvement lorsque que vous écrivez"</string>
    <string name="spellchecker_security_warning" msgid="9060897418527708922">"Ce correcteur orthographique peut recueillir l\'ensemble du texte saisi, y compris des données personnelles comme des mots de passe et des numéros de carte de paiement. Il provient de l\'application <xliff:g id="SPELLCHECKER_APPLICATION_NAME">%1$s</xliff:g>. Utiliser ce correcteur orthographique?"</string>
    <string name="spellchecker_quick_settings" msgid="246728645150092058">"Paramètres"</string>
    <string name="spellchecker_language" msgid="6041050114690541437">"Langue"</string>
    <string name="keyboard_and_input_methods_category" msgid="4580907662493721491">"Claviers"</string>
    <string name="virtual_keyboard_category" msgid="1012830752318677119">"Clavier virtuel"</string>
    <string name="available_virtual_keyboard_category" msgid="7645766574969139819">"Claviers virtuels proposés"</string>
    <string name="add_virtual_keyboard" msgid="3302152381456516928">"Gérer les claviers"</string>
    <string name="keyboard_assistance_category" msgid="5843634175231134014">"Aide du clavier"</string>
    <string name="physical_keyboard_title" msgid="8285149877925752042">"Clavier physique"</string>
    <string name="show_ime" msgid="2658582193437188227">"Afficher le clavier virtuel"</string>
    <string name="show_ime_summary" msgid="8164993045923240698">"Afficher lorsque le clavier physique est activé"</string>
    <string name="keyboard_shortcuts_helper" msgid="4839453720463798145">"Aide des raccourcis clavier"</string>
    <string name="keyboard_shortcuts_helper_summary" msgid="5871299901459743288">"Afficher les raccourcis"</string>
    <string name="language_and_input_for_work_category_title" msgid="3825906835886710498">"Claviers et outils pour le profil professionnel"</string>
    <string name="virtual_keyboards_for_work_title" msgid="2646946676585390499">"Clavier virtuel pour le travail"</string>
    <string name="default_keyboard_layout" msgid="4172606673510531271">"Par défaut"</string>
    <string name="pointer_speed" msgid="1221342330217861616">"Vitesse du pointeur"</string>
    <string name="game_controller_settings_category" msgid="8794508575329923718">"Manette de jeu"</string>
    <string name="vibrate_input_devices" msgid="421936611134697943">"Rediriger les vibrations"</string>
    <string name="vibrate_input_devices_summary" msgid="82093256723774584">"Rediriger les vibrations vers la manette de jeu lorsqu\'elle est connectée"</string>
    <string name="keyboard_layout_dialog_title" msgid="8030087214949381372">"Sélectionner disposition du clavier"</string>
    <string name="keyboard_layout_dialog_setup_button" msgid="8514583747236476384">"Configurer dispositions clavier"</string>
    <string name="keyboard_layout_dialog_switch_hint" msgid="3889961090676293795">"Appuyez sur Ctrl+Espace pour changer disposition"</string>
    <string name="keyboard_layout_default_label" msgid="2952672513543482165">"Par défaut"</string>
    <string name="keyboard_layout_picker_title" msgid="556081931972771610">"Dispositions du clavier"</string>
    <string name="user_dict_settings_title" msgid="3427169369758733521">"Dictionnaire personnel"</string>
    <string name="user_dict_settings_for_work_title" msgid="7634659414713254169">"Dictionnaire personnel pour le travail"</string>
    <string name="user_dict_settings_summary" msgid="7965571192902870454"></string>
    <string name="user_dict_settings_add_menu_title" msgid="4056762757149923551">"Add"</string>
    <string name="user_dict_settings_add_dialog_title" msgid="4702613990174126482">"Ajouter au dictionnaire"</string>
    <string name="user_dict_settings_add_screen_title" msgid="742580720124344291">"Expression"</string>
    <string name="user_dict_settings_add_dialog_more_options" msgid="8848798370746019825">"Plus d\'options"</string>
    <string name="user_dict_settings_add_dialog_less_options" msgid="2441785268726036101">"Moins d\'options"</string>
    <string name="user_dict_settings_add_dialog_confirm" msgid="6225823625332416144">"OK"</string>
    <string name="user_dict_settings_add_word_option_name" msgid="7868879174905963135">"Mot :"</string>
    <string name="user_dict_settings_add_shortcut_option_name" msgid="660089258866063925">"Raccourci :"</string>
    <string name="user_dict_settings_add_locale_option_name" msgid="5696358317061318532">"Langue :"</string>
    <string name="user_dict_settings_add_word_hint" msgid="5725254076556821247">"Entrez un mot"</string>
    <string name="user_dict_settings_add_shortcut_hint" msgid="7333763456561873445">"Raccourci facultatif"</string>
    <string name="user_dict_settings_edit_dialog_title" msgid="8967476444840548674">"Modifier le mot"</string>
    <string name="user_dict_settings_context_menu_edit_title" msgid="2210564879320004837">"Modifier"</string>
    <string name="user_dict_settings_context_menu_delete_title" msgid="9140703913776549054">"Supprimer"</string>
    <string name="user_dict_settings_empty_text" msgid="1971969756133074922">"Votre dictionnaire personnel ne contient aucun mot. Pour ajouter un mot, touchez le bouton d\'ajout (+)."</string>
    <string name="user_dict_settings_all_languages" msgid="6742000040975959247">"Pour toutes les langues"</string>
    <string name="user_dict_settings_more_languages" msgid="7316375944684977910">"Plus de langues…"</string>
    <string name="testing" msgid="6584352735303604146">"Tests"</string>
    <string name="testing_phone_info" product="tablet" msgid="193561832258534798">"Informations sur la tablette"</string>
    <string name="testing_phone_info" product="default" msgid="8656693364332840056">"Informations sur le téléphone"</string>
    <string name="input_methods_settings_title" msgid="6800066636850553887">"Saisie de texte"</string>
    <string name="input_method" msgid="5434026103176856164">"Mode de saisie"</string>
    <string name="current_input_method" msgid="2636466029213488159">"Clavier actuel"</string>
    <string name="input_method_selector" msgid="4311213129681430709">"Sélection du mode de saisie"</string>
    <string name="input_method_selector_show_automatically_title" msgid="1001612945471546158">"Automatique"</string>
    <string name="input_method_selector_always_show_title" msgid="3891824124222371634">"Toujours afficher"</string>
    <string name="input_method_selector_always_hide_title" msgid="7699647095118680424">"Toujours masquer"</string>
    <string name="configure_input_method" msgid="1317429869771850228">"Configurer les modes de saisie"</string>
    <string name="input_method_settings" msgid="5801295625486269553">"Paramètres"</string>
    <string name="input_method_settings_button" msgid="6778344383871619368">"Paramètres"</string>
    <string name="input_methods_settings_label_format" msgid="6002887604815693322">"Paramètres <xliff:g id="IME_NAME">%1$s</xliff:g>"</string>
    <string name="input_methods_and_subtype_enabler_title" msgid="4421813273170250462">"Sélectionner modes de saisie actifs"</string>
    <string name="onscreen_keyboard_settings_summary" msgid="5841558383556238653">"Paramètres du clavier à l\'écran"</string>
    <string name="builtin_keyboard_settings_title" msgid="7688732909551116798">"Clavier physique"</string>
    <string name="builtin_keyboard_settings_summary" msgid="2392531685358035899">"Paramètres du clavier physique"</string>
    <string name="gadget_picker_title" msgid="98374951396755811">"Choisir un gadget"</string>
    <string name="widget_picker_title" msgid="9130684134213467557">"Choisir un widget"</string>
    <string name="allow_bind_app_widget_activity_allow_bind_title" msgid="2538303018392590627">"Créer un widget et autoriser l\'accès?"</string>
    <string name="allow_bind_app_widget_activity_allow_bind" msgid="1584388129273282080">"Une fois le widget créé, <xliff:g id="WIDGET_HOST_NAME">%1$s</xliff:g> peut accéder à toutes les données qu\'il affiche."</string>
    <string name="allow_bind_app_widget_activity_always_allow_bind" msgid="7037503685859688034">"Toujours autoriser <xliff:g id="WIDGET_HOST_NAME">%1$s</xliff:g> à créer des widgets et accéder à leurs données"</string>
    <string name="usage_stats_label" msgid="5890846333487083609">"Données statistiques"</string>
    <string name="testing_usage_stats" msgid="7823048598893937339">"Données statistiques"</string>
    <string name="display_order_text" msgid="8592776965827565271">"Trier par :"</string>
    <string name="app_name_label" msgid="5440362857006046193">"Application"</string>
    <string name="last_time_used_label" msgid="8459441968795479307">"Dernière utilisation :"</string>
    <string name="usage_time_label" msgid="295954901452833058">"Temps d\'utilisation"</string>
    <string name="accessibility_settings" msgid="3975902491934816215">"Accessibilité"</string>
    <string name="accessibility_settings_title" msgid="2130492524656204459">"Paramètres d\'accessibilité"</string>
    <string name="accessibility_settings_summary" msgid="981260486011624939">"Lecteurs d\'écran, affichage, commandes interactives"</string>
    <string name="vision_settings_title" msgid="4204111425716868288">"Paramètres de visibilité"</string>
    <string name="vision_settings_description" msgid="5679491180156408260">"Vous pouvez personnaliser cet appareil en fonction de vos besoins. Il est possible de modifier ces fonctionnalités d\'accessibilité plus tard dans les paramètres."</string>
    <string name="vision_settings_suggestion_title" msgid="8058794060304707004">"Modifier la taille de la police"</string>
    <string name="screen_reader_category_title" msgid="7739154903913400641">"Lecteurs d\'écran"</string>
    <string name="audio_and_captions_category_title" msgid="3420727114421447524">"Audio et texte à l\'écran"</string>
    <string name="display_category_title" msgid="685461049938269166">"Affichage"</string>
    <string name="interaction_control_category_title" msgid="7836591031872839151">"Commandes d\'interaction"</string>
    <string name="user_installed_services_category_title" msgid="6426376488922158647">"Services téléchargés"</string>
    <string name="experimental_category_title" msgid="5272318666666893547">"Fonctions expérimentales"</string>
    <string name="feature_flags_dashboard_title" msgid="778619522682769966">"Indicateurs de fonctionnalité"</string>
    <string name="talkback_title" msgid="7912059827205988080">"TalkBack"</string>
    <string name="talkback_summary" msgid="8331244650729024963">"Le lecteur d\'écran est destiné principalement aux personnes atteintes de cécité et de troubles de la vue"</string>
    <string name="select_to_speak_summary" msgid="4282846695497544515">"Touchez les éléments à l\'écran pour les entendre à haute voix"</string>
    <string name="accessibility_captioning_title" msgid="8068289534732163115">"Préférences de sous-titres"</string>
    <string name="accessibility_screen_magnification_title" msgid="6001128808776506021">"Zoom"</string>
    <string name="accessibility_screen_magnification_gestures_title" msgid="3719929521571489913">"Agrandir en touchant 3 fois"</string>
    <string name="accessibility_screen_magnification_navbar_title" msgid="4203215572713684224">"Agrandir avec un raccourci"</string>
    <string name="accessibility_screen_magnification_state_navbar_gesture" msgid="8416035446297644642">"Agrandir avec le raccourci et en touchant trois fois"</string>
    <string name="accessibility_preference_magnification_summary" msgid="5867883657521404509">"Zoom avant sur l\'écran"</string>
    <string name="accessibility_screen_magnification_short_summary" msgid="3411979839172752057">"Touchez trois fois pour zoomer vers l\'avant"</string>
    <string name="accessibility_screen_magnification_navbar_short_summary" msgid="3693116360267980492">"Touchez un bouton pour zoomer"</string>
    <string name="accessibility_screen_magnification_summary" msgid="5258868553337478505"><b>"Pour zoomer,"</b>" touchez rapidement l\'écran trois fois.\n"<ul><li>"Glissez deux doigts ou plus sur l\'écran pour le faire défiler"</li>\n<li>"Pincez deux doigts ou plus pour ajuster le zoom"</li></ul>\n\n<b>"Pour zoomer temporairement,"</b>" touchez rapidement l\'écran trois fois et, au troisième toucher, laissez le doigt sur l\'écran\n"<ul><li>"Glissez votre doigt vous vous déplacer sur l\'écran."</li>\n<li>"Relevez le doigt pour zoomer vers l\'arrière"</li></ul>\n\n"On ne peut pas zoomer sur le clavier ou la barre de navigation."</string>
    <string name="accessibility_screen_magnification_navbar_summary" msgid="2272878354599332009">"Lorsque le zoom est activé, vous pouvez agrandir ce qui est affiché sur l\'écran.\n\n"<b>"Pour effectuer un zoom,"</b>" activez cette fonction, puis touchez une zone de l\'écran.\n"<ul><li>"• Glissez deux doigts ou plus pour faire défiler l\'écran"</li>\n<li>"• Pincez deux doigts ou plus pour ajuster le facteur de zoom"</li></ul>\n\n<b>"Pour effectuer un zoom temporaire,"</b>" activez cette fonction, puis laissez le doigt sur une zone de l\'écran.\n"<ul><li>"• Pour vous déplacer dans l\'écran, glissez le doigt"</li>\n<li>"• Pour rétablir le zoom par défaut, retirez le doigt de l\'écran"</li></ul>\n\n"On ne peut pas effectuer de zoom avant sur le clavier ni sur la barre de navigation."</string>
    <string name="accessibility_tutorial_dialog_title_button" msgid="3682222614034474845">"Utiliser le bouton d\'accessibilité pour ouvrir"</string>
    <string name="accessibility_tutorial_dialog_title_gesture" msgid="1342726230497913398">"Utiliser un geste pour activer le service"</string>
    <string name="accessibility_tutorial_dialog_title_gesture_settings" msgid="8539392614235820285">"Utiliser le nouveau geste d\'accessibilité"</string>
    <string name="accessibility_tutorial_dialog_message_button" msgid="4803108127318033537">"Pour activer ou désactiver ce service, touchez le bouton d\'accessibilité <xliff:g id="ACCESSIBILITY_ICON">%s</xliff:g> dans le bas de l\'écran.\n\nPour basculer entre les services, maintenez le doigt sur le bouton d\'accessibilité."</string>
    <string name="accessibility_tutorial_dialog_message_gesture_without_talkback" msgid="5331865763478710038">"Pour activer ou désactiver ce service, balayez deux doigts du bas de l\'écran vers le haut.\n\nPour basculer entre les services, balayez deux doigts vers le haut et maintenez-les sur l\'écran."</string>
    <string name="accessibility_tutorial_dialog_message_gesture_with_talkback" msgid="7656710338811226339">"Pour activer ou désactiver ce service, balayez trois doigts du bas de l\'écran vers le haut.\n\nPour basculer entre les services, balayez trois doigts vers le haut et maintenez-les sur l\'écran."</string>
    <string name="accessibility_tutorial_dialog_message_gesture_settings_without_talkback" msgid="3582632565941330367">"Pour activer ou désactiver le service d\'accessibilité, balayez deux doigts du bas de l\'écran vers le haut.\n\nPour basculer entre les services, balayez deux doigts vers le haut et maintenez-les sur l\'écran."</string>
    <string name="accessibility_tutorial_dialog_message_gesture_settings_with_talkback" msgid="8539343463529744661">"Pour activer ou désactiver le service d\'accessibilité, balayez trois doigts du bas de l\'écran vers le haut.\n\nPour basculer entre les services, balayez trois doigts vers le haut et maintenez-les sur l\'écran."</string>
    <string name="accessibility_tutorial_dialog_button" msgid="8530755446904847423">"OK"</string>
    <string name="accessibility_screen_magnification_navbar_configuration_warning" msgid="70533120652758190">"Le bouton d\'accessibilité est défini à <xliff:g id="SERVICE">%1$s</xliff:g>. Pour utiliser cette fonction, maintenez enfoncé le bouton d\'accessibilité, puis sélectionnez l\'agrandissement."</string>
    <string name="accessibility_screen_magnification_gesture_navigation_warning" msgid="5558685139615434791">"Le geste d\'accessibilité est défini pour <xliff:g id="SERVICE">%1$s</xliff:g>. Pour utiliser le zoom, balayez deux doigts du bas de l\'écran vers le haut, puis maintenez-les en place. Sélectionnez ensuite Zoom."</string>
    <string name="accessibility_global_gesture_preference_title" msgid="2048884356166982714">"Raccourci touches volume"</string>
    <string name="accessibility_shortcut_service_title" msgid="4779360749706905640">"Service de raccourcis"</string>
    <string name="accessibility_shortcut_service_on_lock_screen_title" msgid="5490636079625489534">"Autoriser à l\'écran de verrouillage"</string>
    <string name="accessibility_shortcut_description" msgid="1765853731190717372">"Lorsque le raccourci est activé, vous pouvez appuyer sur les deux boutons de volume pendant trois secondes pour démarrer une fonctionnalité d\'accessibilité."</string>
    <string name="accessibility_toggle_high_text_contrast_preference_title" msgid="2567402942683463779">"Texte de contraste élevé"</string>
    <string name="accessibility_toggle_screen_magnification_auto_update_preference_title" msgid="7218498768415430963">"Mise à jour auto de la loupe"</string>
    <string name="accessibility_toggle_screen_magnification_auto_update_preference_summary" msgid="4392059334816220155">"Mettre à jour la loupe si transition entre applis"</string>
    <string name="accessibility_power_button_ends_call_prerefence_title" msgid="6673851944175874235">"Interrupteur pour raccrocher"</string>
    <string name="accessibility_toggle_large_pointer_icon_title" msgid="535173100516295580">"Grand curseur de souris"</string>
    <string name="accessibility_disable_animations" msgid="5876035711526394795">"Supprimer les animations"</string>
    <string name="accessibility_toggle_master_mono_title" msgid="4363806997971905302">"Audio mono"</string>
    <string name="accessibility_toggle_master_mono_summary" msgid="5634277025251530927">"Combiner les chaînes lors de la lecture audio"</string>
    <string name="accessibility_toggle_master_balance_title" msgid="551441665399043471">"Équilibre sonore"</string>
    <string name="accessibility_toggle_master_balance_left_label" msgid="840973259765894310">"Gauche"</string>
    <string name="accessibility_toggle_master_balance_right_label" msgid="7349959407092157385">"Droite"</string>
    <string name="accessibility_timeout_default" msgid="8316215621219570607">"Par défaut"</string>
    <string name="accessibility_timeout_10secs" msgid="1976492627730727871">"10 secondes"</string>
    <string name="accessibility_timeout_30secs" msgid="8055710148052265579">"30 secondes"</string>
    <string name="accessibility_timeout_1min" msgid="6314276027668784112">"1 minute"</string>
    <string name="accessibility_timeout_2mins" msgid="9062685014853095180">"2 minutes"</string>
    <string name="accessibility_setting_item_control_timeout_title" msgid="870367947690762063">"Délai pour eff. une action (accessibilité)"</string>
    <string name="accessibility_control_timeout_preference_title" msgid="3076566452307147390">"Temps pour réagir"</string>
    <string name="accessibility_control_timeout_preference_summary" msgid="6557680564604287459">"Choisissez la durée d\'affichage des messages vous demandant d\'agir, mais qui ne sont visibles que temporairement.\n\nCe ne sont pas toutes les applications qui prennent en charge ce paramètre."</string>
    <string name="accessibility_long_press_timeout_preference_title" msgid="6708467774619266508">"Délai de pression"</string>
    <string name="accessibility_display_inversion_preference_title" msgid="2119647786141420802">"Inversion des couleurs"</string>
    <string name="accessibility_display_inversion_preference_subtitle" msgid="7052959202195368109">"Pourrait nuire aux performances"</string>
    <string name="accessibility_autoclick_preference_title" msgid="2434062071927416098">"Temps d\'arrêt"</string>
    <string name="accessibility_autoclick_description" msgid="4908960598910896933">"Si vous utilisez une souris, vous pouvez configurer votre appareil de façon à ce qu\'un clic s\'effectue automatiquement lorsque le curseur s\'immobilise pendant un certain temps."</string>
    <string name="accessibility_autoclick_delay_preference_title" msgid="3962261178385106006">"Délai précédant le clic"</string>
    <string name="accessibility_vibration_settings_title" msgid="3196059463767462026">"Vibrations et intensité du retour haptique"</string>
    <string name="accessibility_notification_vibration_title" msgid="3009997451790678444">"Vibration pour les notifications"</string>
    <string name="accessibility_ring_vibration_title" msgid="5369395955680650778">"Vibration pour la sonnerie"</string>
    <string name="accessibility_touch_vibration_title" msgid="3548641513105226156">"Retour tactile"</string>
    <string name="accessibility_service_master_switch_title" msgid="6835441300276358239">"Utiliser le service"</string>
    <string name="accessibility_daltonizer_master_switch_title" msgid="8655284637968823154">"Utiliser la correction des couleurs"</string>
    <string name="accessibility_caption_master_switch_title" msgid="4010227386676077826">"Utiliser les légendes"</string>
    <!-- no translation found for accessibility_caption_preference_summary (7898443636143430927) -->
    <skip />
    <string name="accessibility_hearingaid_instruction_continue_button" msgid="974461729380409972">"Continuer"</string>
    <string name="accessibility_hearingaid_title" msgid="8312145423610648518">"Prothèses auditives"</string>
    <string name="accessibility_hearingaid_not_connected_summary" msgid="6240237523789614599">"Aucune prothèse auditive connectée"</string>
    <string name="accessibility_hearingaid_adding_summary" msgid="2947474468412309778">"Ajouter des prothèses auditives"</string>
    <string name="accessibility_hearingaid_pair_instructions_message" msgid="3094382949733435414">"Pour associer votre prothèse auditive, trouvez-la dans la liste de l\'écran suivant et touchez-la. Assurez-vous que votre prothèse auditive est en mode d\'association."</string>
    <string name="accessibility_hearingaid_active_device_summary" msgid="3924362383258688984">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g> est actif"</string>
    <plurals name="show_number_hearingaid_count" formatted="false" msgid="3160782397139295486">
      <item quantity="one"><xliff:g id="NUMBER_DEVICE_COUNT_1">%1$d</xliff:g> prothèse auditive enregistrée</item>
      <item quantity="other"><xliff:g id="NUMBER_DEVICE_COUNT_1">%1$d</xliff:g> prothèses auditives enregistrées</item>
    </plurals>
    <string name="accessibility_summary_state_enabled" msgid="7914278500885887763">"Activé"</string>
    <string name="accessibility_summary_state_disabled" msgid="2984230257590246745">"Désactivé"</string>
    <string name="accessibility_summary_state_stopped" msgid="1144156815350270876">"Ne fonctionne pas. Touchez l\'écran pour obtenir plus d\'information."</string>
    <string name="accessibility_description_state_stopped" msgid="6953539746047006596">"Ce service est défectueux."</string>
    <string name="enable_quick_setting" msgid="2366999897816894536">"Afficher dans la fenêtre de configuration rapide"</string>
    <string name="daltonizer_type" msgid="1124178250809091080">"Mode de correction"</string>
    <plurals name="accessibilty_autoclick_preference_subtitle_extremely_short_delay" formatted="false" msgid="7340347830562315800">
      <item quantity="one">Délai extrêmement court (<xliff:g id="CLICK_DELAY_LABEL_1">%1$d</xliff:g> ms)</item>
      <item quantity="other">Délai extrêmement court (<xliff:g id="CLICK_DELAY_LABEL_1">%1$d</xliff:g> ms)</item>
    </plurals>
    <plurals name="accessibilty_autoclick_preference_subtitle_very_short_delay" formatted="false" msgid="5589565607652364932">
      <item quantity="one">Très court délai (<xliff:g id="CLICK_DELAY_LABEL_1">%1$d</xliff:g> ms)</item>
      <item quantity="other">Très court délai (<xliff:g id="CLICK_DELAY_LABEL_1">%1$d</xliff:g> ms)</item>
    </plurals>
    <plurals name="accessibilty_autoclick_preference_subtitle_short_delay" formatted="false" msgid="5887754135102768400">
      <item quantity="one">Court délai (<xliff:g id="CLICK_DELAY_LABEL_1">%1$d</xliff:g> ms)</item>
      <item quantity="other">Court délai (<xliff:g id="CLICK_DELAY_LABEL_1">%1$d</xliff:g> ms)</item>
    </plurals>
    <plurals name="accessibilty_autoclick_preference_subtitle_long_delay" formatted="false" msgid="6340683412750219405">
      <item quantity="one">Long délai (<xliff:g id="CLICK_DELAY_LABEL_1">%1$d</xliff:g> ms)</item>
      <item quantity="other">Long délai (<xliff:g id="CLICK_DELAY_LABEL_1">%1$d</xliff:g> ms)</item>
    </plurals>
    <plurals name="accessibilty_autoclick_preference_subtitle_very_long_delay" formatted="false" msgid="3503199424330634970">
      <item quantity="one">Très long délai (<xliff:g id="CLICK_DELAY_LABEL_1">%1$d</xliff:g> ms)</item>
      <item quantity="other">Très long délai (<xliff:g id="CLICK_DELAY_LABEL_1">%1$d</xliff:g> ms)</item>
    </plurals>
    <string name="accessibility_vibration_summary" msgid="4272038147476749536">"Sonnerie : <xliff:g id="SUMMARY_RING">%1$s</xliff:g>. Notifications : <xliff:g id="SUMMARY_NOTIFICATION">%2$s</xliff:g>. Toucher : <xliff:g id="SUMMARY_TOUCH">%3$s</xliff:g>."</string>
    <string name="accessibility_vibration_summary_off" msgid="1753566394591809629">"La vibration pour la sonnerie et les notifications est désactivée"</string>
    <string name="accessibility_vibration_summary_low" msgid="7628418309029013867">"La vibration pour la sonnerie et les notifications est réglée à Faible"</string>
    <string name="accessibility_vibration_summary_medium" msgid="3422136736880414093">"La vibration pour la sonnerie et les notifications est réglée à Moyenne"</string>
    <string name="accessibility_vibration_summary_high" msgid="3239807793182635729">"La vibration pour la sonnerie et les notifications est réglée à Élevée"</string>
    <string name="accessibility_vibration_intensity_off" msgid="4613890213008630847">"Désactivée"</string>
    <string name="accessibility_vibration_intensity_low" msgid="2017572546489862987">"Faible"</string>
    <string name="accessibility_vibration_intensity_medium" msgid="3782136025830279769">"Moyenne"</string>
    <string name="accessibility_vibration_intensity_high" msgid="2543921139337952491">"Élevée"</string>
    <string name="accessibility_menu_item_settings" msgid="3344942964710773365">"Paramètres"</string>
    <string name="accessibility_feature_state_on" msgid="2864292320042673806">"Activé"</string>
    <string name="accessibility_feature_state_off" msgid="4172584906487070211">"Désactivé"</string>
    <string name="captioning_preview_title" msgid="1234015253497016890">"Aperçu"</string>
    <string name="captioning_standard_options_title" msgid="3284211791180335844">"Options standards"</string>
    <string name="captioning_locale" msgid="4559155661018823503">"Langue"</string>
    <string name="captioning_text_size" msgid="6737002449104466028">"Taille de la police"</string>
    <string name="captioning_preset" msgid="8939737196538429044">"Style de sous-titres"</string>
    <string name="captioning_custom_options_title" msgid="5067500939930322405">"Options de personnalisation"</string>
    <string name="captioning_background_color" msgid="9053011212948992570">"Couleur de l\'arrière-plan"</string>
    <string name="captioning_background_opacity" msgid="6029993616419971202">"Opacité du fond"</string>
    <string name="captioning_window_color" msgid="6902052743419717394">"Couleur de la zone de sous-titres"</string>
    <string name="captioning_window_opacity" msgid="5041556024849862376">"Opacité de la zone de sous-titres"</string>
    <string name="captioning_foreground_color" msgid="85623486537640059">"Couleur du texte"</string>
    <string name="captioning_foreground_opacity" msgid="4370967856995419788">"Opacité du texte"</string>
    <string name="captioning_edge_color" msgid="3670094753735263238">"Couleur de la bordure"</string>
    <string name="captioning_edge_type" msgid="5997247394951682154">"Type de bordure"</string>
    <string name="captioning_typeface" msgid="1826169240566563259">"Famille de polices"</string>
    <string name="captioning_preview_text" msgid="4067935959797375065">"Les sous-titres ressembleront à ceci"</string>
    <string name="captioning_preview_characters" msgid="7105909138497851769">"Aa"</string>
    <string name="locale_default" msgid="2593883646136326969">"Par défaut"</string>
    <string name="color_title" msgid="4258931051732243983">"Couleur"</string>
    <string name="color_unspecified" msgid="5179683785413568326">"Par défaut"</string>
    <string name="color_none" msgid="3475640044925814795">"Aucune"</string>
    <string name="color_white" msgid="8045195170201590239">"Blanc"</string>
    <string name="color_gray" msgid="9192312087142726313">"Gris"</string>
    <string name="color_black" msgid="7517353520909872561">"Noir"</string>
    <string name="color_red" msgid="4949354900304125428">"Rouge"</string>
    <string name="color_green" msgid="5537717328428845841">"Vert"</string>
    <string name="color_blue" msgid="7731984529016953223">"Bleu"</string>
    <string name="color_cyan" msgid="7033027180641173211">"Cyan"</string>
    <string name="color_yellow" msgid="9112680561610873529">"Jaune"</string>
    <string name="color_magenta" msgid="5059212823607815549">"Magenta"</string>
    <string name="enable_service_title" msgid="2813477981936919847">"Permettre à <xliff:g id="SERVICE">%1$s</xliff:g> de commander complètement votre appareil?"</string>
    <string name="capabilities_list_title" msgid="86713361724771971">"<xliff:g id="SERVICE">%1$s</xliff:g> doit pouvoir :"</string>
    <string name="touch_filtered_warning" msgid="8644034725268915030">"Une application obscurcit une demande d\'autorisation, alors Paramètres ne peut pas vérifier votre réponse."</string>
    <string name="enable_service_encryption_warning" msgid="3064686622453974606">"Si vous activez <xliff:g id="SERVICE">%1$s</xliff:g>, votre appareil n\'utilisera pas le verrouillage de l\'écran pour améliorer le chiffrement des données."</string>
    <string name="secure_lock_encryption_warning" msgid="460911459695077779">"Vous avez activé un service d\'accessibilité. Votre appareil n\'utilisera donc pas le verrouillage de l\'écran pour améliorer le chiffrement des données."</string>
    <string name="enable_service_pattern_reason" msgid="777577618063306751">"Étant donné que l\'activation du service <xliff:g id="SERVICE">%1$s</xliff:g> touche le chiffrement de données, vous devez confirmer votre schéma."</string>
    <string name="enable_service_pin_reason" msgid="7882035264853248228">"Étant donné que l\'activation du service <xliff:g id="SERVICE">%1$s</xliff:g> touche le chiffrement de données, vous devez confirmer votre NIP."</string>
    <string name="enable_service_password_reason" msgid="1224075277603097951">"Étant donné que l\'activation du service <xliff:g id="SERVICE">%1$s</xliff:g> touche le chiffrement de données, vous devez confirmer votre mot de passe."</string>
    <string name="accessibility_service_warning" msgid="846312597054899472">"<xliff:g id="SERVICE">%1$s</xliff:g> demande l\'autorisation de contrôler cet appareil. Le service peut lire l\'écran et agir pour les utilisateurs qui font appels aux fonctions d\'accessibilité. Ce niveau de contrôle ne convient pas à la majorité des applications."</string>
    <string name="accessibility_service_warning_description" msgid="5678294638592090340">"Le contrôle total convient aux applications qui répondent à vos besoins d\'accessibilité. Il ne convient pas à la plupart des applications."</string>
    <string name="accessibility_service_screen_control_title" msgid="1262218781398117580">"Afficher et commander l\'écran"</string>
    <string name="accessibility_service_screen_control_description" msgid="5263900135083661468">"Cette fonctionnalité peut lire tout le contenu à l\'écran et afficher du contenu par-dessus d\'autres applications."</string>
    <string name="accessibility_service_action_perform_title" msgid="3591350033271419253">"Afficher et effectuer des actions"</string>
    <string name="accessibility_service_action_perform_description" msgid="2402904134246069476">"Cette fonctionnalité peut faire le suivi de vos interactions avec une application ou un capteur matériel, et interagir avec des applications en votre nom."</string>
    <string name="accessibility_dialog_button_allow" msgid="8427955451281232788">"Autoriser"</string>
    <string name="accessibility_dialog_button_deny" msgid="4307331121783796869">"Refuser"</string>
    <string name="accessibility_dialog_button_stop" msgid="7861331860214808622">"Arrêter"</string>
    <string name="accessibility_dialog_button_cancel" msgid="5006357240387387028">"Annuler"</string>
    <string name="disable_service_title" msgid="3624005212728512896">"Arrêter <xliff:g id="SERVICE">%1$s</xliff:g>?"</string>
    <string name="disable_service_message" msgid="4593387199926310801">"Touchez <xliff:g id="STOP">%1$s</xliff:g> pour arrêter le service <xliff:g id="SERVICE">%2$s</xliff:g>."</string>
    <string name="accessibility_no_services_installed" msgid="7200948194639038807">"Aucun service installé"</string>
    <string name="accessibility_no_service_selected" msgid="2840969718780083998">"Aucun service sélectionné"</string>
    <string name="accessibility_service_default_description" msgid="1072730037861494125">"Aucune description fournie"</string>
    <string name="settings_button" msgid="3006713718908152930">"Paramètres"</string>
    <string name="print_settings" msgid="4742428530112487843">"Impression"</string>
    <string name="print_settings_summary_no_service" msgid="6354322414246865875">"Désactivé"</string>
    <plurals name="print_settings_summary" formatted="false" msgid="6005468025646083029">
      <item quantity="one"><xliff:g id="COUNT">%1$d</xliff:g> service d\'impression actif</item>
      <item quantity="other"><xliff:g id="COUNT">%1$d</xliff:g> services d\'impression actifs</item>
    </plurals>
    <plurals name="print_jobs_summary" formatted="false" msgid="5810106725778525400">
      <item quantity="one"><xliff:g id="COUNT">%1$d</xliff:g> tâche d\'impression</item>
      <item quantity="other"><xliff:g id="COUNT">%1$d</xliff:g> tâches d\'impression</item>
    </plurals>
    <string name="print_settings_title" msgid="3685449667822217816">"Services d\'impression"</string>
    <string name="print_no_services_installed" msgid="8443039625463872294">"Aucun service installé"</string>
    <string name="print_no_printers_found" msgid="989018646884973683">"Aucune imprimante trouvée"</string>
    <string name="print_menu_item_settings" msgid="6591330373682227082">"Paramètres"</string>
    <string name="print_menu_item_add_printers" msgid="2890738028215834012">"Ajouter des imprimantes"</string>
    <string name="print_feature_state_on" msgid="8098901852502441048">"Activé"</string>
    <string name="print_feature_state_off" msgid="7294876968403966040">"Désactivé"</string>
    <string name="print_menu_item_add_service" msgid="3811645167869797802">"Ajouter un service"</string>
    <string name="print_menu_item_add_printer" msgid="8251218970577291032">"Ajouter une imprimante"</string>
    <string name="print_menu_item_search" msgid="7025589328240514553">"Rechercher"</string>
    <string name="print_searching_for_printers" msgid="4680248496457576358">"Recherche d\'imprimantes en cours..."</string>
    <string name="print_service_disabled" msgid="7739452396114245222">"Service désactivé"</string>
    <string name="print_print_jobs" msgid="3582094777756968793">"Tâches d\'impression"</string>
    <string name="print_print_job" msgid="7563741676053287211">"Tâches d\'impression"</string>
    <string name="print_restart" msgid="8373999687329384202">"Redémarrer"</string>
    <string name="print_cancel" msgid="3621199386568672235">"Annuler"</string>
    <string name="print_job_summary" msgid="8472427347192930694">"<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="1228890182762324249">"Configuration de <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_printing_state_title_template" msgid="5736107667714582025">"Impression de <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g> en cours…"</string>
    <string name="print_cancelling_state_title_template" msgid="7102968925358219875">"Annulation de « <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g> »…"</string>
    <string name="print_failed_state_title_template" msgid="1436099128973357969">"Erreur d\'impression : <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_blocked_state_title_template" msgid="9065391617425962424">"<xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g> bloquée par l\'imprimante"</string>
    <string name="print_search_box_shown_utterance" msgid="7730361832020726951">"Champ de recherche affiché"</string>
    <string name="print_search_box_hidden_utterance" msgid="7980832833405818400">"Champ de recherche masqué"</string>
    <string name="printer_info_desc" msgid="5824995108703060003">"Plus d\'information sur cette imprimante"</string>
    <string name="power_usage_summary_title" msgid="7190304207330319919">"Pile"</string>
    <string name="power_usage_summary" msgid="7237084831082848168">"Répartition·de·l\'utilisation·de·la·batterie"</string>
    <string name="power_usage_not_available" msgid="3109326074656512387">"Info d\'utilisation de la pile non disponible."</string>
    <string name="power_usage_level_and_status" msgid="7449847570973811784">"<xliff:g id="LEVEL">%1$s</xliff:g> – <xliff:g id="STATUS">%2$s</xliff:g>"</string>
    <string name="power_discharge_remaining" msgid="4925678997049911808">"Temps restant : <xliff:g id="REMAIN">%1$s</xliff:g>"</string>
    <string name="power_charge_remaining" msgid="6132074970943913135">"<xliff:g id="UNTIL_CHARGED">%1$s</xliff:g> avant le chargement complet"</string>
    <string name="background_activity_title" msgid="8482171736539410135">"Restriction de l\'utilisation en arrière-plan"</string>
    <string name="background_activity_summary" msgid="8140094430510517362">"Autoriser l\'application à fonctionner en arrière-plan"</string>
    <string name="background_activity_summary_disabled" msgid="3710669050484599847">"L\'application n\'est pas autorisée à fonctionner en arrière-plan"</string>
    <string name="background_activity_summary_whitelisted" msgid="1079899502347973947">"Impossible de restreindre l\'utilisation en arrière-plan"</string>
    <string name="background_activity_warning_dialog_title" msgid="2216249969149568871">"Limiter l\'activité en arrière-plan?"</string>
    <string name="background_activity_warning_dialog_text" msgid="7049624449246121981">"Si vous limitez l\'activité en arrière-plan d\'une application, cela peut provoquer un fonctionnement instable"</string>
    <string name="background_activity_disabled_dialog_text" msgid="6133420589651880824">"Comme cette appli n\'est pas config. pour optim. la pile, vous ne pouvez pas la restr.\n\nPour la restr., activez l\'optim. de pile."</string>
    <string name="device_screen_usage" msgid="3386088035570409683">"Utilisation de l\'écran depuis la charge complète"</string>
    <string name="power_usage_list_summary" msgid="5584049564906462506">"Utilisation de la pile depuis la charge complète"</string>
    <string name="screen_usage_summary" msgid="6687403051423153550">"Durée que l\'écran a été actif depuis la dernière charge complète"</string>
    <string name="device_usage_list_summary" msgid="5623036661468763251">"Utilisation de l\'appareil depuis la charge complète"</string>
    <string name="battery_since_unplugged" msgid="338073389740738437">"Utilisation de la batterie depuis le débranchement"</string>
    <string name="battery_since_reset" msgid="7464546661121187045">"Utilisation de la batterie depuis la dernière réinitialisation"</string>
    <string name="battery_stats_on_battery" msgid="4970762168505236033">"<xliff:g id="TIME">%1$s</xliff:g> de la batterie"</string>
    <string name="battery_stats_duration" msgid="7464501326709469282">"Débranché depuis <xliff:g id="TIME">%1$s</xliff:g>"</string>
    <string name="battery_stats_charging_label" msgid="4223311142875178785">"Charge en cours…"</string>
    <string name="battery_stats_screen_on_label" msgid="7150221809877509708">"Écran activé"</string>
    <string name="battery_stats_gps_on_label" msgid="1193657533641951256">"GPS activé"</string>
    <string name="battery_stats_camera_on_label" msgid="4935637383628414968">"Appareil photo actif"</string>
    <string name="battery_stats_flashlight_on_label" msgid="4319637669889411307">"Lampe de poche activée"</string>
    <string name="battery_stats_wifi_running_label" msgid="1845839195549226252">"Wi-Fi"</string>
    <string name="battery_stats_wake_lock_label" msgid="1908942681902324095">"En activité"</string>
    <string name="battery_stats_phone_signal_label" msgid="4137799310329041341">"Signal du réseau mobile"</string>
    <!-- no translation found for battery_stats_last_duration (1535831453827905957) -->
    <skip />
    <string name="awake" msgid="387122265874485088">"Durée de fonctionnement de l\'appareil"</string>
    <string name="wifi_on_time" msgid="3208518458663637035">"Wi-Fi/temps"</string>
    <string name="bluetooth_on_time" msgid="3056108148042308690">"Wi-Fi/temps"</string>
    <string name="advanced_battery_title" msgid="6768618303037280828">"Utilisation de la pile"</string>
    <string name="history_details_title" msgid="3608240585315506067">"Détails de l\'historique"</string>
    <string name="battery_details_title" msgid="6101394441569858580">"Utilisation de la pile"</string>
    <string name="details_subtitle" msgid="32593908269911734">"Détails d\'utilisation"</string>
    <string name="controls_subtitle" msgid="390468421138288702">"Ajuster la consommation"</string>
    <string name="packages_subtitle" msgid="4736416171658062768">"Modules inclus"</string>
    <string name="battery_tip_summary_title" msgid="368729969313047399">"Les applications fonctionnent normalement"</string>
    <string name="battery_tip_summary_summary" product="default" msgid="2198778125778121221">"Le téléphone utilise une quantité normale d\'énergie en arrière-plan"</string>
    <string name="battery_tip_summary_summary" product="tablet" msgid="1183976728682325345">"La tablette utilise une quantité normale d\'énergie en arrière-plan"</string>
    <string name="battery_tip_summary_summary" product="device" msgid="363718204492523920">"L\'appareil utilise une quantité normale d\'énergie en arrière-plan"</string>
    <string name="battery_tip_low_battery_title" msgid="5103420355109677385">"Pile faible"</string>
    <string name="battery_tip_low_battery_summary" msgid="4702986182940709150">"La pile ne peut pas fournir une autonomie suffisante"</string>
    <string name="battery_tip_smart_battery_title" product="default" msgid="2542822112725248683">"Améliorer l\'autonomie du téléphone"</string>
    <string name="battery_tip_smart_battery_title" product="tablet" msgid="6452567046912954866">"Améliorer l\'autonomie de la tablette"</string>
    <string name="battery_tip_smart_battery_title" product="device" msgid="4445149029390556382">"Améliorer l\'autonomie de l\'appareil"</string>
    <string name="battery_tip_smart_battery_summary" msgid="2326809294592208069">"Activer le gestionnaire de pile"</string>
    <string name="battery_tip_early_heads_up_title" msgid="5788492366387119807">"Activer la fonction Économie d\'énergie"</string>
    <string name="battery_tip_early_heads_up_summary" msgid="1639271439914224547">"La pile pourrait s\'épuiser plus tôt que d\'habitude"</string>
    <string name="battery_tip_early_heads_up_done_title" msgid="4294083319255926811">"La fonction Économie d\'énergie est activée"</string>
    <string name="battery_tip_early_heads_up_done_summary" msgid="7054036010928794364">"Certaines fonctionnalités pourraient être limitées"</string>
    <string name="battery_tip_high_usage_title" product="default" msgid="1282187115295901930">"Le téléphone a été sollicité plus que d\'habitude"</string>
    <string name="battery_tip_high_usage_title" product="tablet" msgid="7422137233845959351">"La tablette a été sollicitée plus que d\'habitude"</string>
    <string name="battery_tip_high_usage_title" product="device" msgid="5483320224273724068">"L\'appareil a été sollicité plus que d\'habitude"</string>
    <string name="battery_tip_high_usage_summary" msgid="5343363604280323738">"La pile pourrait s\'épuiser plus tôt que d\'habitude"</string>
    <string name="battery_tip_dialog_message" product="default" msgid="797225122502556066">"Votre téléphone a été sollicité plus que d\'habitude. Sa pile pourrait s\'épuiser plus rapidement que prévu.\n\nVoici les applications qui ont utilisé le plus d\'énergie :"</string>
    <string name="battery_tip_dialog_message" product="tablet" msgid="49788591262480482">"Votre tablette a été sollicitée plus que d\'habitude. Sa pile pourrait s\'épuiser plus rapidement que prévu.\n\nVoici les applications qui ont utilisé le plus d\'énergie :"</string>
    <string name="battery_tip_dialog_message" product="device" msgid="7959652003221931962">"Votre appareil a été sollicité plus que d\'habitude. Sa pile pourrait s\'épuiser plus rapidement que prévu.\n\nVoici les applications qui ont utilisé le plus d\'énergie :"</string>
    <string name="battery_tip_dialog_message_footer" msgid="2560019187096011163">"Inclut les activités énergivores en arrière-plan"</string>
    <plurals name="battery_tip_restrict_title" formatted="false" msgid="467228882789275512">
      <item quantity="one">Restreindre %1$d application</item>
      <item quantity="other">Restreindre %1$d applications</item>
    </plurals>
    <plurals name="battery_tip_restrict_handled_title" formatted="false" msgid="2996094393897875408">
      <item quantity="one">%2$d application récemment restreinte</item>
      <item quantity="other">%2$d applications récemment restreintes</item>
    </plurals>
    <plurals name="battery_tip_restrict_summary" formatted="false" msgid="5768962491638423979">
      <item quantity="one">%2$d application sollicite beaucoup la pile en arrière-plan</item>
      <item quantity="other">%2$d applications sollicitent beaucoup la pile en arrière-plan</item>
    </plurals>
    <plurals name="battery_tip_restrict_handled_summary" formatted="false" msgid="1040488674178753191">
      <item quantity="one">Cette application ne peut pas fonctionner en arrière-plan</item>
      <item quantity="other">Ces applications ne peuvent pas fonctionner en arrière-plan</item>
    </plurals>
    <plurals name="battery_tip_restrict_app_dialog_title" formatted="false" msgid="8130618585820429591">
      <item quantity="one">Restreindre %1$d application?</item>
      <item quantity="other">Restreindre %1$d applications?</item>
    </plurals>
    <string name="battery_tip_restrict_app_dialog_message" msgid="7271391929137806299">"Pour économiser la pile, empêchez <xliff:g id="APP">%1$s</xliff:g> de l\'utiliser en arrière-plan. Il se peut que cette application ne fonctionne pas correctement et que les notifications soient retardées."</string>
    <string name="battery_tip_restrict_apps_less_than_5_dialog_message" msgid="3175700359860699627">"Pour économiser la pile, empêchez ces applications de l\'utiliser en arrière-plan. Il se peut que les applications restreintes ne fonctionnent pas correctement et que les notifications soient retardées.\n\nApplications :"</string>
    <string name="battery_tip_restrict_apps_more_than_5_dialog_message" msgid="582641081128076191">"Pour économiser la pile, empêchez ces applications de l\'utiliser en arrière-plan. Il se peut que les applications restreintes ne fonctionnent pas correctement et que les notifications soient retardées.\n\nApplications :\n<xliff:g id="APP_LIST">%1$s</xliff:g>."</string>
    <string name="battery_tip_restrict_app_dialog_ok" msgid="8291115820018013353">"Restreindre"</string>
    <string name="battery_tip_unrestrict_app_dialog_title" msgid="4321334634106715162">"Supprimer la restriction?"</string>
    <string name="battery_tip_unrestrict_app_dialog_message" msgid="6537761705584610231">"Cette application pourra utiliser la pile en arrière-plan. Cela pourrait épuiser la pile plus rapidement."</string>
    <string name="battery_tip_unrestrict_app_dialog_ok" msgid="6022058431218137646">"Supprimer"</string>
    <string name="battery_tip_unrestrict_app_dialog_cancel" msgid="3058235875830858902">"Annuler"</string>
    <string name="battery_tip_dialog_summary_message" product="default" msgid="4628448253185085796">"Vos applications utilisent une quantité normale d\'énergie. Si les applications utilisent trop d\'énergie, votre téléphone vous suggérera des actions à essayer.\n\nVous pouvez toujours activer la fonction Économie d\'énergie si la pile est trop faible."</string>
    <string name="battery_tip_dialog_summary_message" product="tablet" msgid="8327950887399420971">"Vos applications utilisent une quantité normale d\'énergie. Si les applications utilisent trop d\'énergie, votre tablette vous suggérera des actions à essayer.\n\nVous pouvez toujours activer la fonction Économie d\'énergie si la pile est trop faible."</string>
    <string name="battery_tip_dialog_summary_message" product="device" msgid="6753742263807939789">"Vos applications utilisent une quantité normale d\'énergie. Si les applications utilisent trop d\'énergie, votre appareil vous suggérera des actions à essayer.\n\nVous pouvez toujours activer la fonction Économie d\'énergie si la pile est trop faible."</string>
    <string name="smart_battery_manager_title" msgid="870632749556793417">"Gestionnaire de pile"</string>
    <string name="smart_battery_title" msgid="6218785691872466076">"Gérer les applications automatiquement"</string>
    <string name="smart_battery_summary" msgid="1339184602000004058">"Restreindre l\'usage de la pile pour les applications que vous n\'utilisez pas souvent"</string>
    <string name="smart_battery_footer" product="default" msgid="5555604955956219544">"Lorsque le gestionnaire de pile détecte que des applications drainent la pile, il vous offrira la possibilité de les restreindre. Il se peut que les applications restreintes ne fonctionnent pas correctement et que les notifications soient retardées."</string>
    <string name="smart_battery_footer" product="tablet" msgid="5555604955956219544">"Lorsque le gestionnaire de pile détecte que des applications drainent la pile, il vous offrira la possibilité de les restreindre. Il se peut que les applications restreintes ne fonctionnent pas correctement et que les notifications soient retardées."</string>
    <string name="smart_battery_footer" product="device" msgid="5555604955956219544">"Lorsque le gestionnaire de pile détecte que des applications drainent la pile, il vous offrira la possibilité de les restreindre. Il se peut que les applications restreintes ne fonctionnent pas correctement et que les notifications soient retardées."</string>
    <string name="restricted_app_title" msgid="8982477293044330653">"Applications restreintes"</string>
    <plurals name="restricted_app_summary" formatted="false" msgid="7355687633914223530">
      <item quantity="one">Limitation de l\'utilisation de la pile pour %1$d application</item>
      <item quantity="other">Limitation de l\'utilisation de la pile pour %1$d applications</item>
    </plurals>
    <string name="restricted_app_time_summary" msgid="6983512391277778623">"Application restreinte : <xliff:g id="TIME">%1$s</xliff:g>"</string>
    <string name="restricted_app_detail_footer" msgid="6739863162364046859">"Ces applications ont utilisé la pile en arrière-plan. Il se peut que les applications restreintes ne fonctionnent pas correctement et que les notifications soient retardées."</string>
    <string name="battery_auto_restriction_title" msgid="6553271897488963709">"Utiliser le gestionnaire de pile"</string>
    <string name="battery_auto_restriction_summary" msgid="8561335400991281062">"Détecter quand les applications drainent la pile"</string>
    <string name="battery_manager_on" msgid="8643310865054362396">"Activé : détecte quand les applications drainent la pile"</string>
    <string name="battery_manager_off" msgid="5473135235710343576">"Désactivé"</string>
    <plurals name="battery_manager_app_restricted" formatted="false" msgid="1026141135861471129">
      <item quantity="one">%1$d application restreinte</item>
      <item quantity="other">%1$d applications restreintes</item>
    </plurals>
    <string name="battery_header_title_alternate" msgid="1766047545950757380">"<xliff:g id="NUMBER">^1</xliff:g>"<small>" "<font size="20">"<xliff:g id="UNIT">%</xliff:g>"</font></small>""</string>
    <string name="dialog_stop_title" msgid="6395127715596746479">"Arrêter l\'application?"</string>
    <string name="dialog_stop_message" product="default" msgid="4006631636646776488">"Votre téléphone n\'arrive pas à gérer sa pile normalement, car l\'application <xliff:g id="APP">%1$s</xliff:g> le maintient activé.\n\nPour y remédier, vous pouvez arrêter l\'application.\n\nSi le problème persiste, vous devrez peut-être désinstaller l\'application pour améliorer les performances de la pile."</string>
    <string name="dialog_stop_message" product="tablet" msgid="2369957934555162428">"Votre tablette n\'arrive pas à gérer sa pile normalement, car l\'application <xliff:g id="APP">%1$s</xliff:g> la maintient activée.\n\nPour y remédier, vous pouvez arrêter l\'application.\n\nSi le problème persiste, vous devrez peut-être désinstaller l\'application pour améliorer les performances de la pile."</string>
    <string name="dialog_stop_message" product="device" msgid="6195430620406365292">"Votre appareil n\'arrive pas à gérer sa pile normalement, car l\'application <xliff:g id="APP">%1$s</xliff:g> le maintient activé.\n\nPour y remédier, vous pouvez arrêter l\'application.\n\nSi le problème persiste, vous devrez peut-être désinstaller l\'application pour améliorer les performances de la pile."</string>
    <string name="dialog_stop_message_wakeup_alarm" product="default" msgid="1638726742782558262">"Votre téléphone n\'arrive pas à gérer sa pile normalement, car l\'application <xliff:g id="APP_0">%1$s</xliff:g> le maintient activé.\n\nPour y remédier, vous pouvez arrêter <xliff:g id="APP_1">%1$s</xliff:g>.\n\nSi le problème persiste, vous devrez peut-être désinstaller l\'application pour améliorer les performances de la pile."</string>
    <string name="dialog_stop_message_wakeup_alarm" product="tablet" msgid="8771690983566539742">"Votre tablette n\'arrive pas à gérer sa pile normalement, car l\'application <xliff:g id="APP_0">%1$s</xliff:g> la maintient activée.\n\nPour y remédier, vous pouvez arrêter <xliff:g id="APP_1">%1$s</xliff:g>.\n\nSi le problème persiste, vous devrez peut-être désinstaller l\'application pour améliorer les performances de la pile."</string>
    <string name="dialog_stop_message_wakeup_alarm" product="device" msgid="2854944538238649520">"Votre appareil n\'arrive pas à gérer sa pile normalement, car l\'application <xliff:g id="APP_0">%1$s</xliff:g> le maintient activé.\n\nPour y remédier, vous pouvez arrêter <xliff:g id="APP_1">%1$s</xliff:g>.\n\nSi le problème persiste, vous devrez peut-être désinstaller l\'application pour améliorer les performances de la pile."</string>
    <string name="dialog_stop_ok" msgid="2319777211264004900">"Arrêter l\'application"</string>
    <string name="dialog_background_check_title" msgid="6936542136153283692">"Désactiver l\'utilisation en arrière-plan et arrêter l\'application?"</string>
    <string name="dialog_background_check_message" product="default" msgid="4045827746349279563">"Votre téléphone n\'arrive pas à gérer sa pile normalement, car <xliff:g id="APP_0">%1$s</xliff:g> le maintient activé.\n\nPour résoudre le problème, vous pouvez arrêter <xliff:g id="APP_1">%1$s</xliff:g> et l\'empêcher de s\'exécuter en arrière-plan."</string>
    <string name="dialog_background_check_message" product="tablet" msgid="8348214419901788270">"Votre tablette n\'arrive pas à gérer sa pile normalement, car <xliff:g id="APP_0">%1$s</xliff:g> la maintient activée.\n\nPour résoudre le problème, vous pouvez arrêter <xliff:g id="APP_1">%1$s</xliff:g> et l\'empêcher de s\'exécuter en arrière-plan."</string>
    <string name="dialog_background_check_message" product="device" msgid="5847977433118915863">"Votre appareil n\'arrive pas à gérer sa pile normalement, car <xliff:g id="APP_0">%1$s</xliff:g> le maintient activé.\n\nPour résoudre le problème, vous pouvez arrêter <xliff:g id="APP_1">%1$s</xliff:g> et l\'empêcher de s\'exécuter en arrière-plan."</string>
    <string name="dialog_background_check_ok" msgid="412876934682899659">"Désactiver"</string>
    <string name="dialog_location_title" msgid="5888917530725874727">"Désactiver la localisation?"</string>
    <string name="dialog_location_message" product="default" msgid="7774807745601479888">"Votre téléphone n\'arrive pas à gérer sa pile normalement, car <xliff:g id="APP">%1$s</xliff:g> demande constamment votre position lorsque vous n\'utilisez pas l\'application.\n\nPour résoudre ce problème, vous pouvez désactiver l\'accès à la localisation pour cette application."</string>
    <string name="dialog_location_message" product="tablet" msgid="118745801732181618">"Votre tablette n\'arrive pas à gérer sa pile normalement, car <xliff:g id="APP">%1$s</xliff:g> demande constamment votre position lorsque vous n\'utilisez pas l\'application.\n\nPour résoudre ce problème, vous pouvez désactiver l\'accès à la localisation pour cette application."</string>
    <string name="dialog_location_message" product="device" msgid="6783678153382298295">"Votre appareil n\'arrive pas à gérer sa pile normalement, car <xliff:g id="APP">%1$s</xliff:g> demande constamment votre position lorsque vous n\'utilisez pas l\'application.\n\nPour résoudre ce problème, vous pouvez désactiver l\'accès à la localisation pour cette application."</string>
    <string name="dialog_location_ok" msgid="4572391197601313986">"Désactiver"</string>
    <string name="power_screen" msgid="3023346080675904613">"Écran"</string>
    <string name="power_flashlight" msgid="7794409781003567614">"Lampe de poche"</string>
    <string name="power_camera" msgid="4976286950934622605">"Appareil photo"</string>
    <string name="power_wifi" msgid="1135085252964054957">"Wi-Fi"</string>
    <string name="power_bluetooth" msgid="4373329044379008289">"Bluetooth"</string>
    <string name="power_cell" msgid="3392999761958982492">"Réseau cellulaire en veille"</string>
    <string name="power_phone" msgid="5392641106474567277">"Appels vocaux"</string>
    <string name="power_idle" product="tablet" msgid="4612478572401640759">"Tablette inactive"</string>
    <string name="power_idle" product="default" msgid="9055659695602194990">"Téléphone inactif"</string>
    <string name="power_unaccounted" msgid="709925017022660740">"Divers"</string>
    <string name="power_overcounted" msgid="2762354976171358445">"Surestimée"</string>
    <string name="usage_type_cpu" msgid="715162150698338714">"Durée d\'utilisation totale de l\'UC"</string>
    <string name="usage_type_cpu_foreground" msgid="6500579611933211831">"UC - Premier plan"</string>
    <string name="usage_type_wake_lock" msgid="5125438890233677880">"Maintenir activé"</string>
    <string name="usage_type_gps" msgid="7989688715128160790">"GPS"</string>
    <string name="usage_type_wifi_running" msgid="3134357198266380400">"Wi-Fi actif"</string>
    <string name="usage_type_phone" product="tablet" msgid="262638572890253393">"Tablette"</string>
    <string name="usage_type_phone" product="default" msgid="9108247984998041853">"Téléphone"</string>
    <string name="usage_type_data_send" msgid="8971710128438365919">"Paquets mobiles envoyés"</string>
    <string name="usage_type_data_recv" msgid="5468564329333954445">"Paquets mobiles reçus"</string>
    <string name="usage_type_radio_active" msgid="1732647857619420121">"Radio mobile active"</string>
    <string name="usage_type_data_wifi_send" msgid="1847552143597396162">"Paquets Wi-Fi envoyés"</string>
    <string name="usage_type_data_wifi_recv" msgid="5678475911549183829">"Paquets Wi-Fi reçus"</string>
    <string name="usage_type_audio" msgid="6957269406840886290">"Audio"</string>
    <string name="usage_type_video" msgid="4295357792078579944">"Vidéo"</string>
    <string name="usage_type_camera" msgid="8299433109956769757">"Appareil photo"</string>
    <string name="usage_type_flashlight" msgid="1516392356962208230">"Lampe de poche"</string>
    <string name="usage_type_on_time" msgid="3351200096173733159">"Durée d\'activation"</string>
    <string name="usage_type_no_coverage" msgid="3797004252954385053">"Durée sans signal"</string>
    <string name="usage_type_total_battery_capacity" msgid="3798285287848675346">"Capacité totale de la pile"</string>
    <string name="usage_type_computed_power" msgid="5862792259009981479">"Consommation d\'énergie calculée"</string>
    <string name="usage_type_actual_power" msgid="7047814738685578335">"Consommation d\'énergie observée"</string>
    <string name="battery_action_stop" msgid="649958863744041872">"Forcer l\'arrêt"</string>
    <string name="battery_action_app_details" msgid="7861051816778419018">"Informations sur l\'application"</string>
    <string name="battery_action_app_settings" msgid="4570481408106287454">"Paramètres de l\'application"</string>
    <string name="battery_action_display" msgid="7338551244519110831">"Paramètres de l\'écran"</string>
    <string name="battery_action_wifi" msgid="8181553479021841207">"Paramètres Wi-Fi"</string>
    <string name="battery_action_bluetooth" msgid="8374789049507723142">"Paramètres Bluetooth"</string>
    <string name="battery_desc_voice" msgid="8980322055722959211">"Batterie utilisée par les appels vocaux"</string>
    <string name="battery_desc_standby" product="tablet" msgid="6284747418668280364">"Batterie utilisée lorsque la tablette est inactive"</string>
    <string name="battery_desc_standby" product="default" msgid="3009080001948091424">"Batterie utilisée lorsque le téléphone est inactif"</string>
    <string name="battery_desc_radio" msgid="5479196477223185367">"Batterie utilisée par le signal radio cellulaire"</string>
    <string name="battery_sugg_radio" msgid="8211336978326295047">"Passez en mode Avion pour économiser la batterie dans les zones sans couverture cellulaire."</string>
    <string name="battery_desc_flashlight" msgid="2908579430841025494">"Énergie utilisée par la lampe de poche"</string>
    <string name="battery_desc_camera" msgid="7375389919760613499">"Pile utilisée par l\'appareil photo"</string>
    <string name="battery_desc_display" msgid="5432795282958076557">"Batterie utilisée par l\'affichage et le rétro-éclairage"</string>
    <string name="battery_sugg_display" msgid="3370202402045141760">"Réduire la luminosité et/ou le délai de mise en veille de l\'écran"</string>
    <string name="battery_desc_wifi" msgid="2375567464707394131">"Batterie utilisée par le Wi-Fi"</string>
    <string name="battery_sugg_wifi" msgid="7776093125855397043">"Désactivez le Wi-Fi lorsque vous ne l\'utilisez pas ou qu\'il n\'est pas disponible."</string>
    <string name="battery_desc_bluetooth" msgid="8069070756186680367">"Batterie utilisée par Bluetooth"</string>
    <string name="battery_sugg_bluetooth_basic" msgid="4565141162650835009">"Désactivez Bluetooth lorsque vous ne l\'utilisez pas."</string>
    <string name="battery_sugg_bluetooth_headset" msgid="4071352514714259230">"Essayez de vous connecter à un autre appareil Bluetooth."</string>
    <string name="battery_desc_apps" msgid="8530418792605735226">"Batterie utilisée par l\'application"</string>
    <string name="battery_sugg_apps_info" msgid="6907588126789841231">"Arrêter ou désinstaller l\'application"</string>
    <string name="battery_sugg_apps_gps" msgid="5959067516281866135">"Sélectionnez le mode Économie de la pile"</string>
    <string name="battery_sugg_apps_settings" msgid="3974902365643634514">"L\'application dispose peut-être de paramètres permettant de réduire l\'utilisation de la batterie."</string>
    <string name="battery_desc_users" msgid="7682989161885027823">"Batterie utilisée par l\'utilisateur"</string>
    <string name="battery_desc_unaccounted" msgid="7404256448541818019">"Consommation d\'énergie diverse"</string>
    <string name="battery_msg_unaccounted" msgid="1963583522633067961">"L\'utilisation de la pile est une approximation de la consommation d\'énergie de l\'appareil; cela ne comprend pas toutes les sources qui puisent de l\'énergie. Le champ « Divers » représente la différence entre la consommation approximative calculée et la consommation réelle observée."</string>
    <string name="battery_desc_overcounted" msgid="5481865509489228603">"Utilisation surestimée de la pile"</string>
    <string name="mah" msgid="95245196971239711">"<xliff:g id="NUMBER">%d</xliff:g> mAh"</string>
    <string name="battery_used_for" msgid="2690821851327075443">"Temps d\'utilisation : <xliff:g id="TIME">^1</xliff:g>"</string>
    <string name="battery_active_for" msgid="2964359540508103032">"Actif pendant <xliff:g id="TIME">^1</xliff:g>"</string>
    <string name="battery_screen_usage" msgid="6537658662149713585">"Utilisation de l\'écran : <xliff:g id="TIME">^1</xliff:g>"</string>
    <string name="battery_used_by" msgid="1135316757755282999">"<xliff:g id="PERCENT">%1$s</xliff:g> utilisé(s) par <xliff:g id="APP">%2$s</xliff:g>"</string>
    <string name="battery_overall_usage" msgid="2093409063297375436">"<xliff:g id="PERCENT">%1$s</xliff:g> de l\'utilisation totale de la pile"</string>
    <string name="battery_detail_since_full_charge" msgid="7515347842046955855">"Répartition depuis la dernière charge complète"</string>
    <string name="battery_last_full_charge" msgid="7151251641099019361">"Dernière charge complète"</string>
    <string name="battery_full_charge_last" msgid="8892335687734288031">"La charge complète dure environ"</string>
    <string name="battery_footer_summary" msgid="67169726550144016">"Les données d\'utilisation de la pile sont approximatives et peuvent changer en fonction de l\'utilisation"</string>
    <string name="battery_detail_foreground" msgid="3350401514602032183">"En utilisation active"</string>
    <string name="battery_detail_background" msgid="1929644393553768999">"En arrière-plan"</string>
    <string name="battery_detail_power_usage" msgid="6485766868610469101">"Utilisation de la pile"</string>
    <string name="battery_detail_info_title" msgid="8227822131405620369">"Depuis la charge complète"</string>
    <string name="battery_detail_manage_title" msgid="9094314252105828014">"Gérer l\'utilisation de la pile"</string>
    <string name="advanced_battery_graph_subtext" msgid="5621073891377915877">"L\'estimation de l\'autonomie restante est basée sur l\'utilisation de l\'appareil"</string>
    <string name="estimated_time_left" msgid="7514194472683370877">"Temps restant estimé"</string>
    <string name="estimated_charging_time_left" msgid="5614442409326164691">"Jusqu\'à la charge complète"</string>
    <string name="estimated_time_description" msgid="8760210909000037089">"La durée estimée peut changer en fonction de l\'utilisation"</string>
    <string name="menu_stats_unplugged" msgid="8296577130840261624">"Débranché depuis <xliff:g id="UNPLUGGED">%1$s</xliff:g>"</string>
    <string name="menu_stats_last_unplugged" msgid="5922246077592434526">"Depuis le dernier débranchement (<xliff:g id="UNPLUGGED">%1$s</xliff:g>)"</string>
    <string name="menu_stats_total" msgid="8973377864854807854">"Utilisation totale"</string>
    <string name="menu_stats_refresh" msgid="1676215433344981075">"Actualiser"</string>
    <string name="process_kernel_label" msgid="3916858646836739323">"Système d\'exploitation Android"</string>
    <string name="process_mediaserver_label" msgid="6500382062945689285">"Serveur multimédia"</string>
    <string name="process_dex2oat_label" msgid="2592408651060518226">"Optimisation des applications"</string>
    <string name="battery_saver" msgid="8172485772238572153">"Économie d\'énergie"</string>
    <string name="battery_saver_auto_title" msgid="8368709389419695611">"Activer automatiquement"</string>
    <string name="battery_saver_auto_no_schedule" msgid="632243833320671052">"Aucun horaire"</string>
    <string name="battery_saver_auto_routine" msgid="8076053160450346731">"Selon votre routine"</string>
    <string name="battery_saver_auto_percentage" msgid="9000542338151528905">"Selon le pourcentage"</string>
    <string name="battery_saver_auto_routine_summary" msgid="3030089882678228374">"La fonction Économiseur de pile s\'active si la pile est susceptible de s\'épuiser totalement avant l\'heure de recharge habituelle"</string>
    <string name="battery_saver_auto_percentage_summary" msgid="3653601117764171846">"S\'active lorsque la pile atteint <xliff:g id="PERCENT">%1$s</xliff:g>"</string>
    <string name="battery_saver_schedule_settings_title" msgid="6000660866895036589">"Configurer un horaire"</string>
    <string name="battery_saver_turn_on_summary" msgid="5552800757174173459">"Prolonger l\'autonomie de la pile"</string>
    <string name="battery_saver_sticky_title_new" msgid="613272902035943099">"Éteindre une fois la recharge terminée"</string>
    <string name="battery_saver_sticky_description_new" product="default" msgid="6659545534053937371">"Le mode Économiseur de pile se désactive lorsque le niveau de charge de la pile atteint <xliff:g id="PERCENT">%1$s</xliff:g>"</string>
    <string name="battery_saver_sticky_description_new" product="tablet" msgid="6537930800784858686">"Le mode Économiseur de pile se désactive lorsque le niveau de charge de la pile atteint <xliff:g id="PERCENT">%1$s</xliff:g>"</string>
    <string name="battery_saver_sticky_description_new" product="device" msgid="8309483774864505603">"Le mode Économiseur de pile se désactive lorsque le niveau de charge de la pile atteint <xliff:g id="PERCENT">%1$s</xliff:g>"</string>
    <!-- no translation found for battery_saver_seekbar_title (3795833548145424276) -->
    <skip />
    <string name="battery_saver_seekbar_title_placeholder" msgid="1138980155985636295">"Activer"</string>
    <string name="battery_saver_master_switch_title" msgid="622539414546588436">"Utiliser le mode Économiseur de pile"</string>
    <string name="battery_saver_turn_on_automatically_title" msgid="9023847300114669426">"Activer automatiquement"</string>
    <string name="battery_saver_turn_on_automatically_never" msgid="6610846456314373">"Jamais"</string>
    <string name="battery_saver_turn_on_automatically_pct" msgid="8665950426992057191">"à <xliff:g id="PERCENT">%1$s</xliff:g> d\'autonomie restante"</string>
    <string name="battery_percentage" msgid="723291197508049369">"Pourcentage de charge de la pile"</string>
    <string name="battery_percentage_description" msgid="8511658577507384014">"Afficher le pourcentage de charge de la pile dans la barre d\'état"</string>
    <string name="process_stats_summary_title" msgid="1144688045609771677">"Statistiques des processus"</string>
    <string name="process_stats_summary" msgid="109387941605607762">"Statistiques détaillées sur les processus en cours d\'exécution"</string>
    <string name="app_memory_use" msgid="7849258480392171939">"Mémoire utilisée"</string>
    <string name="process_stats_total_duration" msgid="7417201400853728029">"Utilisation de <xliff:g id="USEDRAM">%1$s</xliff:g> sur <xliff:g id="TOTALRAM">%2$s</xliff:g> en <xliff:g id="TIMEDURATION">%3$s</xliff:g>"</string>
    <string name="process_stats_total_duration_percentage" msgid="6522457033380025618">"Utilisation de <xliff:g id="PERCENT">%1$s</xliff:g> de mémoire vive en <xliff:g id="TIMEDURATION">%2$s</xliff:g>"</string>
    <string name="process_stats_type_background" msgid="3934992858120683459">"Arrière-plan"</string>
    <string name="process_stats_type_foreground" msgid="7713118254089580536">"Avant-plan"</string>
    <string name="process_stats_type_cached" msgid="6314925846944806511">"En cache"</string>
    <string name="process_stats_os_label" msgid="4813434110442733392">"Système d\'exploitation Android"</string>
    <string name="process_stats_os_native" msgid="5322428494231768472">"Natif"</string>
    <string name="process_stats_os_kernel" msgid="1938523592369780924">"Noyau"</string>
    <string name="process_stats_os_zram" msgid="677138324651671575">"Z-RAM"</string>
    <string name="process_stats_os_cache" msgid="6432533624875078233">"Caches"</string>
    <string name="process_stats_ram_use" msgid="976912589127397307">"Utilisation de mémoire vive"</string>
    <string name="process_stats_bg_ram_use" msgid="5398191511030462404">"Utilisation de mémoire vive (en arrière-plan)"</string>
    <string name="process_stats_run_time" msgid="6520628955709369115">"Durée d\'exécution"</string>
    <string name="processes_subtitle" msgid="6827502409379462438">"Processus"</string>
    <string name="services_subtitle" msgid="4296402367067266425">"Services"</string>
    <string name="menu_proc_stats_duration" msgid="2323483592994720196">"Durée"</string>
    <string name="mem_details_title" msgid="6548392825497290498">"Détails de la mémoire"</string>
    <string name="menu_duration_3h" msgid="4714866438374738385">"3 heures"</string>
    <string name="menu_duration_6h" msgid="1940846763432184132">"6 heures"</string>
    <string name="menu_duration_12h" msgid="7890465404584356294">"12 heures"</string>
    <string name="menu_duration_1d" msgid="3393631127622285458">"1 jour"</string>
    <string name="menu_show_system" msgid="8864603400415567635">"Afficher le système"</string>
    <string name="menu_hide_system" msgid="4106826741703745733">"Masquer le système"</string>
    <string name="menu_show_percentage" msgid="4717204046118199806">"Afficher les pourcentages"</string>
    <string name="menu_use_uss" msgid="467765290771543089">"Utiliser USS"</string>
    <string name="menu_proc_stats_type" msgid="4700209061072120948">"Type de statistiques"</string>
    <string name="menu_proc_stats_type_background" msgid="2236161340134898852">"Arrière-plan"</string>
    <string name="menu_proc_stats_type_foreground" msgid="2286182659954958586">"Avant-plan"</string>
    <string name="menu_proc_stats_type_cached" msgid="5084272779786820693">"En cache"</string>
    <string name="voice_input_output_settings" msgid="1336135218350444783">"Saisie et sortie vocales"</string>
    <string name="voice_input_output_settings_title" msgid="2442850635048676991">"Paramètres de saisie et de sortie vocales"</string>
    <string name="voice_search_settings_title" msgid="2775469246913196536">"Recherche vocale"</string>
    <string name="keyboard_settings_title" msgid="5080115226780201234">"Clavier Android"</string>
    <string name="voice_input_settings" msgid="1099937800539324567">"Paramètres d\'entrée vocale"</string>
    <string name="voice_input_settings_title" msgid="2676028028084981891">"Entrée vocale"</string>
    <string name="voice_service_preference_section_title" msgid="3778706644257601021">"Services d\'entrée vocale"</string>
    <string name="voice_interactor_preference_summary" msgid="1801414022026937190">"Détection de mot clé et interaction totales"</string>
    <string name="voice_recognizer_preference_summary" msgid="669880813593690527">"Synthèse vocale simple"</string>
    <string name="voice_interaction_security_warning" msgid="6378608263983737325">"Ce service d\'entrée vocale pourra contrôler en permanence les fonctionnalités vocales et utiliser en votre nom les applications commandées par la voix. Il provient de l\'application <xliff:g id="VOICE_INPUT_SERVICE_APP_NAME">%s</xliff:g>. Autoriser l\'utilisation de ce service?"</string>
    <string name="tts_engine_preference_title" msgid="1578826947311494239">"Moteur préféré"</string>
    <string name="tts_engine_settings_title" msgid="6886964122861384818">"Paramètres du moteur"</string>
    <string name="tts_sliders_title" msgid="992059150784095263">"Cadence et ton"</string>
    <string name="tts_engine_section_title" msgid="6289240207677024034">"Moteur"</string>
    <string name="tts_install_voice_title" msgid="6275828614052514320">"Voix"</string>
    <string name="tts_spoken_language" msgid="5542499183472504027">"Langue parlée"</string>
    <string name="tts_install_voices_title" msgid="8808823756936022641">"installer des voix"</string>
    <string name="tts_install_voices_text" msgid="5292606786380069134">"Continuer vers l\'application <xliff:g id="TTS_APP_NAME">%s</xliff:g> pour installer des voix"</string>
    <string name="tts_install_voices_open" msgid="667467793360277465">"Ouvrir l\'application"</string>
    <string name="tts_install_voices_cancel" msgid="4711492804851107459">"Annuler"</string>
    <string name="tts_reset" msgid="2661752909256313270">"Réinitialiser"</string>
    <string name="tts_play" msgid="2628469503798633884">"Lire"</string>
    <string name="vpn_settings_title" msgid="5662579425832406705">"RPV"</string>
    <string name="credentials_title" msgid="4446234003860769883">"Stockage des identifiants"</string>
    <string name="credentials_install" product="nosdcard" msgid="466093273825150847">"Installer à partir de la mémoire"</string>
    <string name="credentials_install" product="default" msgid="953914549998062317">"Installer à partir de la carte SD"</string>
    <string name="credentials_install_summary" product="nosdcard" msgid="4220422806818210676">"Installer les certificats à partir de la mémoire de stockage"</string>
    <string name="credentials_install_summary" product="default" msgid="5737658257407822713">"Installer les certificats à partir de la carte SD"</string>
    <string name="credentials_reset" msgid="3239382277144980418">"Effacer les identifiants"</string>
    <string name="credentials_reset_summary" msgid="3369361230171260282">"Supprimer tous les certificats"</string>
    <string name="trusted_credentials" msgid="4266945289534242402">"Certificats de confiance"</string>
    <string name="trusted_credentials_summary" msgid="6735221351155686632">"Afficher les certificats d\'autorité de confiance"</string>
    <string name="user_credentials" msgid="3719013347787187083">"Authentifiants d\'utilisateur"</string>
    <string name="user_credentials_summary" msgid="7271228342106080167">"Afficher et modifier les authentifiants stockés"</string>
    <string name="advanced_security_title" msgid="2434776238010578865">"Avancés"</string>
    <string name="credential_storage_type" msgid="8629968543494001364">"Type de stockage"</string>
    <string name="credential_storage_type_hardware" msgid="6077193544333904427">"Intégré au matériel"</string>
    <string name="credential_storage_type_software" msgid="4403117271207715378">"Uniquement logiciel"</string>
    <string name="credentials_settings_not_available" msgid="7968275634486624215">"Les identifiants ne sont pas accessibles pour cet utilisateur"</string>
    <string name="credential_for_vpn_and_apps" msgid="4168197158768443365">"Installé pour le RPV et les applications"</string>
    <string name="credential_for_wifi" msgid="6228425986551591864">"Installé pour le Wi-Fi"</string>
    <string name="credentials_reset_hint" msgid="6297256880896133631">"Supprimer l\'intégralité du contenu?"</string>
    <string name="credentials_erased" msgid="2907836028586342969">"Les identifiants sont effacés."</string>
    <string name="credentials_not_erased" msgid="7685932772284216097">"Impossible eff. stockage identifiants."</string>
    <string name="usage_access_title" msgid="332333405495457839">"Applis avec accès données"</string>
    <string name="emergency_tone_title" msgid="254495218194925271">"Signal de composition d\'urgence"</string>
    <string name="emergency_tone_summary" msgid="722259232924572153">"Définir le comportement en cas d\'appel d\'urgence"</string>
    <string name="privacy_settings_title" msgid="2978878794187459190">"Sauvegarde"</string>
    <string name="backup_summary_state_on" msgid="6407084627816231202">"Activé"</string>
    <string name="backup_summary_state_off" msgid="7388321532624105594">"Désactivé"</string>
    <string name="backup_section_title" msgid="7952232291452882740">"Sauvegarde et restauration"</string>
    <string name="personal_data_section_title" msgid="7815209034443782061">"Données personnelles"</string>
    <string name="backup_data_title" msgid="1239105919852668016">"Sauvegarder mes données"</string>
    <string name="backup_data_summary" msgid="708773323451655666">"Sauvegarder les données d\'applications, les mots de passe Wi-Fi et d\'autres paramètres sur les serveurs Google"</string>
    <string name="backup_configure_account_title" msgid="3790872965773196615">"Compte de sauvegarde"</string>
    <string name="backup_data_management_title" msgid="4059093462647090064">"Gérer le compte de sauvegarde"</string>
    <string name="include_app_data_title" msgid="2829970132260278394">"Inclure données applications"</string>
    <string name="auto_restore_title" msgid="5397528966329126506">"Restauration automatique"</string>
    <string name="auto_restore_summary" msgid="4235615056371993807">"Lors de la réinstallation d\'une application, restaurer les paramètres et les données sauvegardées"</string>
    <string name="backup_inactive_title" msgid="685838037986644604">"Le service de sauvegarde n\'est pas actif"</string>
    <string name="backup_configure_account_default_summary" msgid="2436933224764745553">"Actuellement, aucun compte n\'enregistre de données de sauvegarde"</string>
    <string name="backup_erase_dialog_title" msgid="1027640829482174106"></string>
    <string name="backup_erase_dialog_message" msgid="5221011285568343155">"Voulez-vous vraiment arrêter de sauvegarder vos mots de passe Wi-Fi, vos favoris, ainsi que d\'autres paramètres et données d\'applications, et en effacer toutes les copies des serveurs Google?"</string>
    <string name="fullbackup_erase_dialog_message" msgid="694766389396659626">"Voulez-vous vraiment arrêter de sauvegarder les données de l\'appareil (comme les mots de passe Wi-Fi et l\'historique des appels) et celles des applications (telles que les paramètres et les fichiers enregistrés par ces applications), et en effacer toutes les copies sur les serveurs distants?"</string>
    <string name="fullbackup_data_summary" msgid="960850365007767734">"Sauvegardez automatiquement les données de l\'appareil (comme les mots de passe Wi-Fi et l\'historique des appels) et celles des applications (telles que les paramètres et les fichiers enregistrés par ces applications) à distance.\n\nLorsque vous activez la sauvegarde automatique, les données de l\'appareil et des applications sont enregistrées régulièrement à distance. Les données d\'applications correspondent à toutes les données enregistrées par une application (en fonction des paramètres que le développeur définit), y compris les données potentiellement confidentielles comme les contacts, les messages et les photos."</string>
    <string name="device_admin_settings_title" msgid="4960761799560705902">"Paramètres d\'administration de l\'appareil"</string>
    <string name="active_device_admin_msg" msgid="578748451637360192">"Appli d\'administration de l\'appareil"</string>
    <string name="remove_device_admin" msgid="9207368982033308173">"Désactiver cette application d\'administration d\'appareil"</string>
    <string name="uninstall_device_admin" msgid="271120195128542165">"Désinstaller l\'application"</string>
    <string name="remove_and_uninstall_device_admin" msgid="3837625952436169878">"Désactiver et désinstaller"</string>
    <string name="select_device_admin_msg" msgid="7347389359013278077">"Applications d\'administration d\'appareils"</string>
    <string name="no_device_admins" msgid="4846602835339095768">"Il n\'y a aucune application d\'administration d\'appareil"</string>
    <string name="personal_device_admin_title" msgid="2849617316347669861">"Personnel"</string>
    <string name="managed_device_admin_title" msgid="7853955652864478435">"Travail"</string>
    <string name="sms_access_restriction_enabled" msgid="7054488078710530278">"Restreindre accès aux journaux mess. texte et appels"</string>
    <string name="sms_access_restriction_enabled_summary" msgid="6851339654677842328">"Seules les applications de téléphonie et de messagerie par défaut sont accès aux journaux des appels et des messages texte"</string>
    <string name="no_trust_agents" msgid="7450273545568977523">"Aucun agent de confiance disponible"</string>
    <string name="add_device_admin_msg" msgid="1501847129819382149">"Activer l\'appli d\'admin de l\'appareil?"</string>
    <string name="add_device_admin" msgid="4192055385312215731">"Activer l\'application d\'administration de l\'appareil"</string>
    <string name="device_admin_add_title" msgid="3140663753671809044">"Administrateur de l\'appareil"</string>
    <string name="device_admin_warning" msgid="7482834776510188134">"L\'activation de cette application d\'administration permettra à <xliff:g id="APP_NAME">%1$s</xliff:g> d\'effectuer les opérations suivantes :"</string>
    <string name="device_admin_warning_simplified" msgid="8085544856342321981">"Cet appareil sera géré et surveillé par <xliff:g id="APP_NAME">%1$s</xliff:g>."</string>
    <string name="device_admin_status" msgid="7234814785374977990">"Cette application d\'administration est active et permet à l\'application <xliff:g id="APP_NAME">%1$s</xliff:g> d\'effectuer les opérations suivantes :"</string>
    <string name="profile_owner_add_title" msgid="6249331160676175009">"Activer le gestionnaire de profil?"</string>
    <string name="profile_owner_add_title_simplified" msgid="6856400286736117006">"Autoriser la supervision?"</string>
    <string name="adding_profile_owner_warning" msgid="1354474524852805802">"En continuant, votre utilisateur sera géré par votre administrateur, qui pourra aussi stocker des données associées en plus de vos données personnelles.\n\nVotre administrateur peut surveiller et gérer les paramètres, l\'accès, les applications et les données associées à cet utilisateur, y compris l\'activité réseau et les données de localisation de votre appareil."</string>
    <string name="admin_disabled_other_options" msgid="7712694507069054530">"D\'autres options sont désactivées par votre administrateur"</string>
    <string name="admin_more_details" msgid="7901420667346456102">"Détails supplémentaires"</string>
    <string name="notification_log_title" msgid="3766148588239398464">"Journal des notifications"</string>
    <string name="sound_category_call_ringtone_vibrate_title" msgid="1543777228646645163">"Sonnerie et vibreur pour les appels"</string>
    <string name="wifi_setup_detail" msgid="2336990478140503605">"Informations sur le réseau"</string>
    <string name="accessibility_sync_enabled" msgid="558480439730263116">"Synchronisation activée"</string>
    <string name="accessibility_sync_disabled" msgid="1741194106479011384">"Synchronisation désactivée"</string>
    <string name="accessibility_sync_in_progress" msgid="4501160520879902723">"Synchronisation en cours…"</string>
    <string name="accessibility_sync_error" msgid="8703299118794272041">"Erreur de synchronisation."</string>
    <string name="sync_failed" msgid="1696499856374109647">"Échec de la synchronisation"</string>
    <string name="sync_active" msgid="8476943765960863040">"Synchronisation activée"</string>
    <string name="account_sync_settings_title" msgid="5131314922423053588">"Synchroniser"</string>
    <string name="sync_is_failing" msgid="1591561768344128377">"La synchronisation rencontre actuellement des problèmes. Elle sera rétablie sous peu."</string>
    <string name="add_account_label" msgid="7811707265834013767">"Ajouter un compte"</string>
    <string name="managed_profile_not_available_label" msgid="852263300911325904">"Le profil professionnel n\'est pas encore disponible"</string>
    <string name="work_mode_label" msgid="7157582467956920750">"Profil professionnel"</string>
    <string name="work_mode_on_summary" msgid="3628349169847990263">"Géré par votre organisation"</string>
    <string name="work_mode_off_summary" msgid="2657138190560082508">"Les applications et les notifications sont désactivées"</string>
    <string name="remove_managed_profile_label" msgid="3856519337797285325">"Supprimer le profil professionnel"</string>
    <string name="background_data" msgid="5779592891375473817">"Données en arrière-plan"</string>
    <string name="background_data_summary" msgid="8328521479872763452">"Synchronisation, envoi et réception de données à tout moment"</string>
    <string name="background_data_dialog_title" msgid="6059217698124786537">"Dés. données arr.-plan?"</string>
    <string name="background_data_dialog_message" msgid="6981661606680941633">"La désactivation des données en arrière-plan économise la batterie et réduit l\'utilisation des données. Certaines applications peuvent continuer d\'utiliser la connexion Internet en arrière-plan."</string>
    <string name="sync_automatically" msgid="1682730255435062059">"Synchro auto des données des applis"</string>
    <string name="sync_enabled" msgid="4551148952179416813">"Synchronisation activée"</string>
    <string name="sync_disabled" msgid="8511659877596511991">"Synchronisation désactivée"</string>
    <string name="sync_error" msgid="5060969083117872149">"Erreur de synchronisation"</string>
    <string name="last_synced" msgid="4242919465367022234">"Dernière synchronisation : <xliff:g id="LAST_SYNC_TIME">%1$s</xliff:g>"</string>
    <string name="sync_in_progress" msgid="5151314196536070569">"Synchronisation en cours…"</string>
    <string name="settings_backup" msgid="2274732978260797031">"Sauvegarder les paramètres"</string>
    <string name="settings_backup_summary" msgid="7916877705938054035">"Sauvegarder mes paramètres"</string>
    <string name="sync_menu_sync_now" msgid="6154608350395805683">"Synchroniser"</string>
    <string name="sync_menu_sync_cancel" msgid="8292379009626966949">"Annuler la synchronisation"</string>
    <string name="sync_one_time_sync" msgid="3733796114909082260">"Touchez ici pour lancer la synchronisation<xliff:g id="LAST_SYNC_TIME">
%1$s</xliff:g>"</string>
    <string name="sync_gmail" msgid="714886122098006477">"Gmail"</string>
    <string name="sync_calendar" msgid="9056527206714733735">"# CALENDAR:"</string>
    <string name="sync_contacts" msgid="9174914394377828043">"Contacts"</string>
    <string name="sync_plug" msgid="3905078969081888738"><font fgcolor="#ffffffff">"Bienvenue sur Google Sync!"</font>\n"Une solution Google pour synchroniser vos données et vous permettre d\'accéder à vos contacts, vos rendez-vous et plus, où que vous soyez."</string>
    <string name="header_application_sync_settings" msgid="6205903695598000286">"Paramètres de synchronisation de l\'application"</string>
    <string name="header_data_and_synchronization" msgid="5165024023936509896">"Données et synchronisation"</string>
    <string name="preference_change_password_title" msgid="8955581790270130056">"Modifier le mot de passe"</string>
    <string name="header_account_settings" msgid="5382475087121880626">"Paramètres de compte"</string>
    <string name="remove_account_label" msgid="5921986026504804119">"Supprimer le compte"</string>
    <string name="header_add_an_account" msgid="756108499532023798">"Ajouter un compte"</string>
    <string name="really_remove_account_title" msgid="8800653398717172460">"Supprimer le compte?"</string>
    <string name="really_remove_account_message" product="tablet" msgid="1936147502815641161">"La suppression de ce compte entraînera la suppression de tous les messages, contacts et autres données de la tablette."</string>
    <string name="really_remove_account_message" product="default" msgid="3483528757922948356">"La suppression de ce compte entraînera la suppression de tous les messages, contacts et autres données du téléphone."</string>
    <string name="really_remove_account_message" product="device" msgid="7507474724882080166">"La suppression de ce compte entraînera la suppression de tous les messages, les contacts et les autres données de l\'appareil."</string>
    <string name="remove_account_failed" msgid="3901397272647112455">"Cette modification n\'est pas autorisée par votre administrateur"</string>
    <string name="cant_sync_dialog_title" msgid="2777238588398046285">"Impossible de procéder à la synchronisation manuelle."</string>
    <string name="cant_sync_dialog_message" msgid="1938380442159016449">"La synchronisation de cet élément est actuellement désactivée. Pour modifier ce paramètre, activez temporairement les données en arrière-plan et la synchronisation automatique."</string>
    <string name="enter_password" msgid="8035706727471334122">"Pour lancer Android, entrez votre mot de passe"</string>
    <string name="enter_pin" msgid="5305333588093263790">"Pour lancer Android, entrez votre NIP"</string>
    <string name="enter_pattern" msgid="4187435713036808566">"Pour lancer Android, dessinez votre schéma."</string>
    <string name="cryptkeeper_wrong_pattern" msgid="8423835922362956999">"Schéma erroné"</string>
    <string name="cryptkeeper_wrong_password" msgid="5200857195368904047">"Mot de passe incorrect"</string>
    <string name="cryptkeeper_wrong_pin" msgid="755720788765259382">"NIP erroné"</string>
    <string name="checking_decryption" msgid="8287458611802609493">"Vérification en cours…"</string>
    <string name="starting_android" msgid="4001324195902252681">"Démarrage d\'Android en cours..."</string>
    <string name="delete" msgid="4219243412325163003">"Supprimer"</string>
    <string name="misc_files" msgid="6720680815969643497">"Fichiers divers"</string>
    <string name="misc_files_selected_count" msgid="4647048020823912088">"<xliff:g id="NUMBER">%1$d</xliff:g> fichiers sélectionnés sur <xliff:g id="TOTAL">%2$d</xliff:g>"</string>
    <string name="misc_files_selected_count_bytes" msgid="2876232009069114352">"<xliff:g id="NUMBER">%1$s</xliff:g> sur <xliff:g id="TOTAL">%2$s</xliff:g>"</string>
    <string name="select_all" msgid="1562774643280376715">"Tout sélectionner"</string>
    <string name="data_usage_summary_title" msgid="3804110657238092929">"Utilisation de données"</string>
    <string name="data_usage_app_summary_title" msgid="5571051159374290375">"Données cell. et Wi-Fi"</string>
    <string name="data_usage_accounting" msgid="7170028915873577387">"La manière dont le fournisseur de services effectue les calcul des données peut être différente."</string>
    <string name="data_usage_app" msgid="4970478397515423303">"Utilisation de l\'appli"</string>
    <string name="data_usage_app_info_label" msgid="3409931235687866706">"DÉTAILS DE L\'APPLICATION"</string>
    <string name="data_usage_cellular_data" msgid="9168928285122125137">"Données cellulaires"</string>
    <string name="data_usage_data_limit" msgid="1193930999713192703">"Définir limite consommation de données"</string>
    <string name="data_usage_cycle" msgid="5652529796195787949">"Cycle de consommation"</string>
    <string name="data_usage_app_items_header_text" msgid="5017850810459372828">"Utilisation de l\'application"</string>
    <string name="data_usage_menu_roaming" msgid="8042359966835203296">"Itinérance des données"</string>
    <string name="data_usage_menu_restrict_background" msgid="1989394568592253331">"Limiter données en arrière-plan"</string>
    <string name="data_usage_menu_allow_background" msgid="2694761978633359223">"Autor. données arrière-plan"</string>
    <string name="data_usage_menu_split_4g" msgid="5322857680792601899">"Utilisation 4G séparée"</string>
    <string name="data_usage_menu_show_wifi" msgid="2296217964873872571">"Afficher le Wi‑Fi"</string>
    <string name="data_usage_menu_hide_wifi" msgid="7290056718050186769">"Masquer consom. Wi‑Fi"</string>
    <string name="data_usage_menu_show_ethernet" msgid="5181361208532314097">"Afficher l\'utilisation Ethernet"</string>
    <string name="data_usage_menu_hide_ethernet" msgid="3326702187179943681">"Masquer consom. Ethernet"</string>
    <string name="data_usage_menu_metered" msgid="6235119991372755026">"Restrictions réseau"</string>
    <string name="data_usage_menu_auto_sync" msgid="8203999775948778560">"Synchronisation automatique des données"</string>
    <string name="data_usage_menu_sim_cards" msgid="6410498422797244073">"Cartes SIM"</string>
    <string name="data_usage_cellular_data_summary" msgid="8413357481361268285">"Interrompues à la limite"</string>
    <string name="account_settings_menu_auto_sync" msgid="6243013719753700377">"Synchronisation auto données"</string>
    <string name="account_settings_menu_auto_sync_personal" msgid="785541379617346438">"Synchro auto des données perso"</string>
    <string name="account_settings_menu_auto_sync_work" msgid="329565580969147026">"Synchro auto données profess."</string>
    <string name="data_usage_change_cycle" msgid="7776556448920114866">"Changer le cycle..."</string>
    <string name="data_usage_pick_cycle_day" msgid="4470796861757050966">"Jour du mois de réinitialisation du cycle utilisation données :"</string>
    <string name="data_usage_empty" msgid="8621855507876539282">"Aucune donnée utilisée par les applications pendant cette période."</string>
    <string name="data_usage_label_foreground" msgid="4938034231928628164">"Avant-plan"</string>
    <string name="data_usage_label_background" msgid="3225844085975764519">"Arrière-plan"</string>
    <string name="data_usage_app_restricted" msgid="3568465218866589705">"limitée"</string>
    <string name="data_usage_disable_mobile" msgid="8656552431969276305">"Désactiver les données cellulaires?"</string>
    <string name="data_usage_disable_mobile_limit" msgid="4644364396844393848">"Définir un plafond"</string>
    <string name="data_usage_disable_4g_limit" msgid="6233554774946681175">"Définir le quota de données 4G"</string>
    <string name="data_usage_disable_3g_limit" msgid="2558557840444266906">"Définir quota de données 2G-3G"</string>
    <string name="data_usage_disable_wifi_limit" msgid="1394901415264660888">"Définir quota données Wi-Fi"</string>
    <string name="data_usage_tab_wifi" msgid="481146038146585749">"Wi-Fi"</string>
    <string name="data_usage_tab_ethernet" msgid="7298064366282319911">"Ethernet"</string>
    <string name="data_usage_tab_mobile" msgid="454140350007299045">"Cellulaire"</string>
    <string name="data_usage_tab_4g" msgid="1301978716067512235">"4G"</string>
    <string name="data_usage_tab_3g" msgid="6092169523081538718">"2G-3G"</string>
    <string name="data_usage_list_mobile" msgid="5588685410495019866">"Cellulaire"</string>
    <string name="data_usage_list_none" msgid="3933892774251050735">"Aucun"</string>
    <string name="data_usage_enable_mobile" msgid="986782622560157977">"Données cellulaires"</string>
    <string name="data_usage_enable_3g" msgid="6304006671869578254">"Données 2G-3G"</string>
    <string name="data_usage_enable_4g" msgid="3635854097335036738">"Données 4G"</string>
    <string name="data_roaming_enable_mobile" msgid="1523331545457578362">"Itinérance"</string>
    <string name="data_usage_forground_label" msgid="7654319010655983591">"Premier plan :"</string>
    <string name="data_usage_background_label" msgid="2722008379947694926">"Arrière-plan :"</string>
    <string name="data_usage_app_settings" msgid="2279171379771253165">"Paramètres de l\'application"</string>
    <string name="data_usage_app_restrict_background" msgid="7359227831562303223">"Données en arrière-plan"</string>
    <string name="data_usage_app_restrict_background_summary" msgid="5853552187570622572">"Activer l\'utilisation de données cellulaires en arrière-plan"</string>
    <string name="data_usage_app_restrict_background_summary_disabled" msgid="7401927377070755054">"Pour restreindre les données en arrière-plan, définissez un quota de données cellulaires."</string>
    <string name="data_usage_app_restrict_dialog_title" msgid="1613108390242737923">"Limiter les données en arrière-plan?"</string>
    <string name="data_usage_app_restrict_dialog" msgid="1466689968707308512">"Cette fonctionnalité peut empêcher certaines applications de s\'exécuter lorsque celles-ci sont dépendantes des données en arrière-plan et que seuls des réseaux mobiles sont disponibles.\n\nVous trouverez des options plus adaptées en matière de contrôle de la consommation des données dans les paramètres de l\'application."</string>
    <string name="data_usage_restrict_denied_dialog" msgid="55012417305745608">"La limitation des données en arrière-plan n\'est possible que si vous avez défini un plafond d\'utilisation pour les données cellulaires."</string>
    <string name="data_usage_auto_sync_on_dialog_title" msgid="2438617846762244389">"Activer synchro auto données?"</string>
    <string name="data_usage_auto_sync_on_dialog" product="tablet" msgid="8581983093524041669">"Toutes les modifications que vous apportez à vos comptes sur le Web sont automatiquement copiées sur votre tablette.\n\nCertains comptes peuvent également copier automatiquement sur le Web toutes les modifications que vous apportez sur la tablette. Les comptes Google fonctionnent de cette façon."</string>
    <string name="data_usage_auto_sync_on_dialog" product="default" msgid="8651376294887142858">"Toutes les modifications que vous apportez à vos comptes sur le Web sont automatiquement copiées sur votre téléphone.\n\nCertains comptes peuvent également copier automatiquement sur le Web toutes les modifications que vous apportez sur le téléphone. Les comptes Google fonctionnent de cette façon."</string>
    <string name="data_usage_auto_sync_off_dialog_title" msgid="9013139130490125793">"Désactiver synchro auto données?"</string>
    <string name="data_usage_auto_sync_off_dialog" msgid="4025938250775413864">"Cette action limite la consommation de données et l\'utilisation de la pile, mais vous devrez synchroniser manuellement chaque compte pour recueillir les informations récentes. Par ailleurs, vous ne recevrez pas de notifications en cas de mise à jour."</string>
    <string name="data_usage_cycle_editor_title" msgid="1373797281540188533">"Date de réinitialisation du cycle de consommation"</string>
    <string name="data_usage_cycle_editor_subtitle" msgid="5512903797979928416">"Jour du mois :"</string>
    <string name="data_usage_cycle_editor_positive" msgid="8821760330497941117">"Définir"</string>
    <string name="data_usage_warning_editor_title" msgid="3704136912240060339">"Définir avertissement d\'utilisation des données"</string>
    <string name="data_usage_limit_editor_title" msgid="9153595142385030015">"Définir la limite de consommation des données"</string>
    <string name="data_usage_limit_dialog_title" msgid="3023111643632996097">"Limitation de la consommation de données cellulaires"</string>
    <string name="data_usage_limit_dialog_mobile" product="tablet" msgid="4983487893343645667">"Votre tablette désactivera les données cellulaires lorsqu\'elle atteindra la limite que vous définissez.\n\nComme c\'est votre tablette qui mesure la consommation des données, et que votre fournisseur de services peut utiliser un système de mesure différent, nous vous conseillons d\'utiliser une limite plus basse."</string>
    <string name="data_usage_limit_dialog_mobile" product="default" msgid="3926320594049434225">"Votre téléphone désactivera les données cellulaires lorsqu\'il atteindra la limite que vous définissez.\n\nComme c\'est votre téléphone qui mesure la consommation des données, et que votre fournisseur de services peut utiliser un système de mesure différent, nous vous conseillons de définir une limite plus basse."</string>
    <string name="data_usage_restrict_background_title" msgid="2201315502223035062">"Limiter les données en arrière-plan?"</string>
    <string name="data_usage_restrict_background" msgid="434093644726734586">"Si vous limitez les données cellulaires en arrière-plan, certains services et applications ne fonctionneront que si vous êtes connecté au réseau Wi‑Fi."</string>
    <string name="data_usage_restrict_background_multiuser" product="tablet" msgid="7096707497743363380">"Si vous limitez les données cellulaires en arrière-plan, certains services et applications ne fonctionneront que si vous êtes connecté au réseau Wi‑Fi.\n\nCe réglage s\'applique à tous les utilisateurs définis sur cette tablette."</string>
    <string name="data_usage_restrict_background_multiuser" product="default" msgid="7910798414964288424">"Si vous limitez les données cellulaires en arrière-plan, certains services et applications ne fonctionneront que si vous êtes connecté au réseau Wi‑Fi.\n\nCe réglage s\'applique à tous les utilisateurs définis sur ce téléphone."</string>
    <string name="data_usage_sweep_warning" msgid="6387081852568846982"><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">"alerte"</font></string>
    <string name="data_usage_sweep_limit" msgid="860566507375933039"><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">"limite"</font></string>
    <string name="data_usage_uninstalled_apps" msgid="614263770923231598">"Applications supprimées"</string>
    <string name="data_usage_uninstalled_apps_users" msgid="7986294489899813194">"Applications et utilisateurs supprimés"</string>
    <string name="data_usage_received_sent" msgid="5039699009276621757">"<xliff:g id="RECEIVED">%1$s</xliff:g> reçus, <xliff:g id="SENT">%2$s</xliff:g> envoyés"</string>
    <string name="data_usage_total_during_range" msgid="4091294280619255237">"<xliff:g id="RANGE">%2$s</xliff:g> : environ <xliff:g id="TOTAL">%1$s</xliff:g> utilisés"</string>
    <string name="data_usage_total_during_range_mobile" product="tablet" msgid="1925687342154538972">"<xliff:g id="RANGE">%2$s</xliff:g> : env. <xliff:g id="TOTAL">%1$s</xliff:g> utilisés,  selon votre tablette. Le suivi conso de votre opérateur peut différer."</string>
    <string name="data_usage_total_during_range_mobile" product="default" msgid="5063981061103812900">"<xliff:g id="RANGE">%2$s</xliff:g> : env. <xliff:g id="TOTAL">%1$s</xliff:g> utilisés, selon votre téléphone. Le suivi conso de votre opérateur peut différer."</string>
    <string name="data_usage_metered_title" msgid="7383175371006596441">"Restrictions réseau"</string>
    <string name="data_usage_metered_body" msgid="7655851702771342507">"Les réseaux mesurés sont considérés comme des réseaux cellulaires lorsque les données en arrière-plan sont limitées. Les applications peuvent émettre un avertissement avant d\'utiliser ces réseaux pour les téléchargements volumineux."</string>
    <string name="data_usage_metered_mobile" msgid="5423305619126978393">"Réseaux mobiles"</string>
    <string name="data_usage_metered_wifi" msgid="1761738002328299714">"Réseaux Wi-Fi mesurés"</string>
    <string name="data_usage_metered_wifi_disabled" msgid="727808462375941567">"Pour sélectionner les réseaux mesurés, activez le Wi‑Fi."</string>
    <string name="data_usage_metered_auto" msgid="1262028400911918865">"Automatique"</string>
    <string name="wifi_metered_title" msgid="5536703738895222444">"Utilisation du réseau"</string>
    <string name="data_usage_metered_yes" msgid="9217539611385225894">"Facturé à l\'usage"</string>
    <string name="data_usage_metered_no" msgid="4025232961929071789">"Non mesuré"</string>
    <string name="data_usage_disclaimer" msgid="6887858149980673444">"Le suivi de consommation du fournisseur de service peut différer de celui de l\'appareil."</string>
    <string name="cryptkeeper_emergency_call" msgid="198578731586097145">"Appel d\'urgence"</string>
    <string name="cryptkeeper_return_to_call" msgid="5613717339452772491">"Retour à l\'appel"</string>
    <string name="vpn_name" msgid="4689699885361002297">"Nom"</string>
    <string name="vpn_type" msgid="5435733139514388070">"Type"</string>
    <string name="vpn_server" msgid="2123096727287421913">"Adresse du serveur"</string>
    <string name="vpn_mppe" msgid="6639001940500288972">"Chiffrement PPP (MPPE)"</string>
    <string name="vpn_l2tp_secret" msgid="529359749677142076">"Secret L2TP"</string>
    <string name="vpn_ipsec_identifier" msgid="4098175859460006296">"Identifiant IPSec"</string>
    <string name="vpn_ipsec_secret" msgid="4526453255704888704">"Clé pré-partagée IPSec"</string>
    <string name="vpn_ipsec_user_cert" msgid="6880651510020187230">"Certificat utilisateur IPSec"</string>
    <string name="vpn_ipsec_ca_cert" msgid="91338213449148229">"Certificat d\'autorité IPSec"</string>
    <string name="vpn_ipsec_server_cert" msgid="6599276718456935010">"Certificat de serveur IPSec"</string>
    <string name="vpn_show_options" msgid="7182688955890457003">"Afficher les options avancées"</string>
    <string name="vpn_search_domains" msgid="5391995501541199624">"Domaines de recherche DNS"</string>
    <string name="vpn_dns_servers" msgid="5570715561245741829">"Serveurs DNS (Ex. 8.8.8.8)"</string>
    <string name="vpn_routes" msgid="3818655448226312232">"Itinéraires transfert (Ex. 10.0.0.0/8)"</string>
    <string name="vpn_username" msgid="1863901629860867849">"Nom d\'utilisateur"</string>
    <string name="vpn_password" msgid="6756043647233596772">"Mot de passe"</string>
    <string name="vpn_save_login" msgid="6350322456427484881">"Enregistrer les informations de compte"</string>
    <string name="vpn_not_used" msgid="9094191054524660891">"(non utilisé)"</string>
    <string name="vpn_no_ca_cert" msgid="8776029412793353361">"(ne pas valider le serveur)"</string>
    <string name="vpn_no_server_cert" msgid="2167487440231913330">"(certificat reçu du serveur)"</string>
    <string name="vpn_always_on_invalid_reason_type" msgid="7574518311224455825">"Ce type de RPV ne peut pas rester connecté en permanence"</string>
    <string name="vpn_always_on_invalid_reason_server" msgid="477304620899799383">"Le RPV permanent n\'accepte que les adresses de serveur en format numérique"</string>
    <string name="vpn_always_on_invalid_reason_no_dns" msgid="2226648961940273294">"Un serveur DNS doit être spécifié pour le RPV permanent"</string>
    <string name="vpn_always_on_invalid_reason_dns" msgid="3551394495620249972">"Les adresses de serveur DNS doivent être numériques pour le RPV permanent"</string>
    <string name="vpn_always_on_invalid_reason_other" msgid="5959352052515258208">"Les données entrées ne sont pas compatibles avec le RPV permanent"</string>
    <string name="vpn_cancel" msgid="1979937976123659332">"Annuler"</string>
    <string name="vpn_done" msgid="8678655203910995914">"Ignorer"</string>
    <string name="vpn_save" msgid="4233484051644764510">"Enregistrer"</string>
    <string name="vpn_connect" msgid="8469608541746132301">"Connexion"</string>
    <string name="vpn_replace" msgid="5442836256121957861">"Remplacer"</string>
    <string name="vpn_edit" msgid="8647191407179996943">"Modifier le profil RPV"</string>
    <string name="vpn_forget" msgid="3684651372749415446">"Supprimer"</string>
    <string name="vpn_connect_to" msgid="5965299358485793260">"Se connecter à <xliff:g id="PROFILE">%s</xliff:g>"</string>
    <string name="vpn_disconnect_confirm" msgid="3743970132487505659">"Déconnecter ce RPV?"</string>
    <string name="vpn_disconnect" msgid="7426570492642111171">"Déconnecter"</string>
    <string name="vpn_version" msgid="1939804054179766249">"Version <xliff:g id="VERSION">%s</xliff:g>"</string>
    <string name="vpn_forget_long" msgid="2232239391189465752">"Oublier le profil RPV"</string>
    <string name="vpn_replace_vpn_title" msgid="2963898301277610248">"Remplacer le RPV existant?"</string>
    <string name="vpn_set_vpn_title" msgid="4009987321156037267">"Définir le RPV permanent?"</string>
    <string name="vpn_first_always_on_vpn_message" msgid="7144543717673197102">"Si vous activez ce paramètre, vous ne disposerez d\'aucune connexion Internet jusqu\'à ce que le RPV parvienne à se connecter"</string>
    <string name="vpn_replace_always_on_vpn_enable_message" msgid="798121133114824006">"Votre RPV existant sera remplacé, et vous ne disposerez d\'aucune connexion Internet jusqu\'à ce que le RPV parvienne à se connecter"</string>
    <string name="vpn_replace_always_on_vpn_disable_message" msgid="3011818750025879902">"Vous êtes déjà connecté à un RPV permanent. Si vous vous connectez à un autre RPV, le RPV actuel sera remplacé et le mode permanent sera désactivé."</string>
    <string name="vpn_replace_vpn_message" msgid="5611635724578812860">"Vous êtes déjà connecté à un RPV. Si vous vous connectez à un RPV différent, votre RPV actuel sera remplacé."</string>
    <string name="vpn_turn_on" msgid="2363136869284273872">"Activer"</string>
    <string name="vpn_cant_connect_title" msgid="4517706987875907511">"<xliff:g id="VPN_NAME">%1$s</xliff:g> n\'est pas en mesure de se connecter"</string>
    <string name="vpn_cant_connect_message" msgid="1352832123114214283">"Cette application ne prend pas en charge le RPV permanent"</string>
    <string name="vpn_title" msgid="6317731879966640551">"RPV"</string>
    <string name="vpn_create" msgid="5628219087569761496">"Ajouter un profil RPV"</string>
    <string name="vpn_menu_edit" msgid="408275284159243490">"Modifier le profil"</string>
    <string name="vpn_menu_delete" msgid="8098021690546891414">"Supprimer le profil"</string>
    <string name="vpn_menu_lockdown" msgid="7863024538064268139">"RPV permanent"</string>
    <string name="vpn_no_vpns_added" msgid="5002741367858707244">"Aucun RPV ajouté"</string>
    <string name="vpn_always_on_summary" msgid="2821344524094363617">"Rester connecté au RPV en permanence"</string>
    <string name="vpn_always_on_summary_not_supported" msgid="592304911378771510">"Non compatible avec cette application"</string>
    <string name="vpn_always_on_summary_active" msgid="8800736191241875669">"RPV toujours actif : activé"</string>
    <string name="vpn_require_connection" msgid="8388183166574269666">"Bloquer les connexions sans RPV"</string>
    <string name="vpn_require_connection_title" msgid="159053539340576331">"Exiger une connexion RPV?"</string>
    <string name="vpn_lockdown_summary" msgid="2200032066376720339">"Sélectionnez un profil RPV auquel rester connecté en permanence. Le trafic réseau ne sera autorisé que lorsque vous serez connecté à ce RPV."</string>
    <string name="vpn_lockdown_none" msgid="9214462857336483711">"Aucun"</string>
    <string name="vpn_lockdown_config_error" msgid="3898576754914217248">"Le RPV permanent nécessite une adresse IP pour le serveur et le DNS."</string>
    <string name="vpn_no_network" msgid="3050233675132726155">"Aucune connexion réseau. Veuillez réessayer plus tard."</string>
    <string name="vpn_disconnected" msgid="280531508768927471">"Déconnecté du RPV"</string>
    <string name="vpn_disconnected_summary" msgid="3082851661207900606">"Aucun"</string>
    <string name="vpn_missing_cert" msgid="5357192202207234745">"Certificat manquant. Essayez de modifier le profil."</string>
    <string name="trusted_credentials_system_tab" msgid="3984284264816924534">"Système"</string>
    <string name="trusted_credentials_user_tab" msgid="2244732111398939475">"Utilisateur"</string>
    <string name="trusted_credentials_disable_label" msgid="3864493185845818506">"Désactiver"</string>
    <string name="trusted_credentials_enable_label" msgid="2498444573635146913">"activer"</string>
    <string name="trusted_credentials_remove_label" msgid="3633691709300260836">"Supprimer"</string>
    <string name="trusted_credentials_trust_label" msgid="8003264222650785429">"Faire confiance"</string>
    <string name="trusted_credentials_enable_confirmation" msgid="83215982842660869">"Activer le certificat d\'autorité du système?"</string>
    <string name="trusted_credentials_disable_confirmation" msgid="8199697813361646792">"Désactiver le certificat d\'autorité du système?"</string>
    <string name="trusted_credentials_remove_confirmation" msgid="443561923016852941">"Supprimer définitivement le certificat d\'autorité utilisateur?"</string>
    <string name="credential_contains" msgid="3984922924723974084">"Cette entrée contient :"</string>
    <string name="one_userkey" msgid="6034020579534914349">"une clé d\'utilisateur"</string>
    <string name="one_usercrt" msgid="2150319011101639509">"un certificat d\'utilisateur"</string>
    <string name="one_cacrt" msgid="6844397037970164809">"un certificat CA"</string>
    <string name="n_cacrts" msgid="5979300323482053820">"%d certificats CA"</string>
    <string name="user_credential_title" msgid="1954061209643070652">"Détails de l\'authentifiant"</string>
    <string name="user_credential_removed" msgid="6514189495799401838">"L\'identifiant suivant a été supprimé : <xliff:g id="CREDENTIAL_NAME">%s</xliff:g>"</string>
    <string name="user_credential_none_installed" msgid="3729607560420971841">"Aucun authentifiant d\'utilisateur installé"</string>
    <string name="spellcheckers_settings_title" msgid="399981228588011501">"Correcteur orthographique"</string>
    <string name="spellcheckers_settings_for_work_title" msgid="4114555511355171248">"Correcteur orthographique pour le travail"</string>
    <string name="current_backup_pw_prompt" msgid="7735254412051914576">"Saisissez votre mot de passe actuel pour les sauvegardes complètes."</string>
    <string name="new_backup_pw_prompt" msgid="8755501377391998428">"Saisissez votre nouveau mot de passe pour les sauvegardes complètes."</string>
    <string name="confirm_new_backup_pw_prompt" msgid="3238728882512787864">"Confirmez votre nouveau mot de passe pour les sauvegardes complètes."</string>
    <string name="backup_pw_set_button_text" msgid="2387480910044648795">"Définir le mot de passe de sauvegarde"</string>
    <string name="backup_pw_cancel_button_text" msgid="8845630125391744615">"Annuler"</string>
    <string name="additional_system_update_settings_list_item_title" msgid="214987609894661992">"Mises à jour supplémentaires du système"</string>
    <string name="ssl_ca_cert_warning" msgid="2045866713601984673">"Le réseau peut être surveillé"</string>
    <string name="done_button" msgid="1991471253042622230">"Terminé"</string>
    <plurals name="ssl_ca_cert_dialog_title" formatted="false" msgid="7145092748045794650">
      <item quantity="one">Faire confiance au certificat ou le supprimer</item>
      <item quantity="other">Faire confiance aux certificats ou les supprimer</item>
    </plurals>
    <plurals name="ssl_ca_cert_info_message_device_owner" formatted="false" msgid="1489335297837656666">
      <item quantity="one"><xliff:g id="MANAGING_DOMAIN_1">%s</xliff:g> a installé une autorité de certification sur votre appareil, ce qui peut leur permettre de surveiller son activité réseau, y compris les courriels, les applications et les sites Web sécurisés.\n\nPour en savoir plus sur ce certificat, communiquez avec votre administrateur.</item>
      <item quantity="other"><xliff:g id="MANAGING_DOMAIN_1">%s</xliff:g> a installé des autorités de certification sur votre appareil, ce qui peut leur permettre de surveiller son activité réseau, y compris les courriels, les applications et les sites Web sécurisés.\n\nPour en savoir plus sur ces certificats, communiquez avec votre administrateur.</item>
    </plurals>
    <plurals name="ssl_ca_cert_info_message" formatted="false" msgid="30645643499556573">
      <item quantity="one"><xliff:g id="MANAGING_DOMAIN_1">%s</xliff:g> a installé une autorité de certification pour votre profil professionnel, ce qui peut leur permettre de surveiller l\'activité du réseau, y compris les courriels, les applications et les sites Web sécurisés.\n\nPour en savoir plus sur ce certificat, communiquez avec votre administrateur.</item>
      <item quantity="other"><xliff:g id="MANAGING_DOMAIN_1">%s</xliff:g> a installé des autorités de certification pour votre profil professionnel, ce qui peut leur permettre de surveiller l\'activité du réseau, y compris les courriels, les applications et les sites Web sécurisés.\n\nPour en savoir plus sur ces certificats, communiquez avec votre administrateur.</item>
    </plurals>
    <string name="ssl_ca_cert_warning_message" msgid="8216218659139190498">"Un tiers peut surveiller votre activité réseau, y compris les courriels, les applications et les sites Web sécurisés. \n\nUn certificat de confiance installé sur votre appareil rend cela possible."</string>
    <plurals name="ssl_ca_cert_settings_button" formatted="false" msgid="2426799352517325228">
      <item quantity="one">Vérifier le certificat</item>
      <item quantity="other">Vérifier les certificats</item>
    </plurals>
    <string name="user_settings_title" msgid="3493908927709169019">"Plusieurs utilisateurs"</string>
    <string name="user_settings_footer_text" product="device" msgid="5947601460660791129">"Partagez votre appareil en ajoutant des utilisateurs. Chaque utilisateur dispose d\'un espace personnel sur votre appareil pour ses écrans d\'accueil personnalisés, ses comptes, ses applications, ses paramètres et plus encore."</string>
    <string name="user_settings_footer_text" product="tablet" msgid="2153761434649733502">"Partagez votre tablette en ajoutant des utilisateurs. Chaque utilisateur dispose d\'un espace personnel sur votre tablette pour ses écrans d\'accueil personnalisés, ses comptes, ses applications, ses paramètres et plus encore."</string>
    <string name="user_settings_footer_text" product="default" msgid="2844602828189838075">"Partagez votre téléphone en ajoutant des utilisateurs. Chaque utilisateur dispose d\'un espace personnel sur votre téléphone pour ses écrans d\'accueil personnalisés, ses comptes, ses applications, ses paramètres et plus encore."</string>
    <string name="user_list_title" msgid="7937158411137563543">"Utilisateurs et profils"</string>
    <string name="user_add_user_or_profile_menu" msgid="6923838875175259418">"Ajouter un utilisateur ou un profil"</string>
    <string name="user_add_user_menu" msgid="1675956975014862382">"Ajouter un utilisateur"</string>
    <string name="user_summary_restricted_profile" msgid="6354966213806839107">"Profil limité"</string>
    <string name="user_need_lock_message" msgid="5879715064416886811">"Avant de créer un profil limité, vous devez définir un écran de verrouillage pour protéger vos applications et vos données personnelles."</string>
    <string name="user_set_lock_button" msgid="8311219392856626841">"Définir verrouillage écran"</string>
    <string name="user_summary_not_set_up" msgid="8778205026866794909">"Non configuré"</string>
    <string name="user_summary_restricted_not_set_up" msgid="1628116001964325544">"Non configuré : profil limité"</string>
    <string name="user_summary_managed_profile_not_set_up" msgid="1659125858619760573">"Non configuré : profil professionnel"</string>
    <string name="user_admin" msgid="993402590002400782">"Admin"</string>
    <string name="user_you" msgid="1639158809315025986">"Vous (<xliff:g id="NAME">%s</xliff:g>)"</string>
    <string name="user_nickname" msgid="5148818000228994488">"Pseudonyme"</string>
    <string name="user_add_user_type_title" msgid="2146438670792322349">"Ajouter"</string>
    <string name="user_add_max_count" msgid="5405885348463433157">"Vous pouvez ajouter jusqu\'à <xliff:g id="USER_COUNT">%1$d</xliff:g> utilisateurs"</string>
    <string name="user_add_user_item_summary" msgid="4702776187132008661">"Les utilisateurs disposent de leurs propres applications et de leur propre contenu."</string>
    <string name="user_add_profile_item_summary" msgid="5931663986889138941">"Vous pouvez limiter l\'accès aux applications et au contenu depuis votre compte."</string>
    <string name="user_add_user_item_title" msgid="8212199632466198969">"Utilisateur"</string>
    <string name="user_add_profile_item_title" msgid="8353515490730363621">"Profil limité"</string>
    <string name="user_add_user_title" msgid="2108112641783146007">"Ajouter un utilisateur?"</string>
    <string name="user_add_user_message_long" msgid="6768718238082929201">"Vous pouvez partager cet appareil avec d\'autres personnes en ajoutant des utilisateurs. Chaque utilisateur dispose de son propre espace, où il peut personnaliser, entre autres, ses applications et son fond d\'écran. Chacun peut également modifier les paramètres de l\'appareil, comme les réseaux Wi-Fi, qui touchent tous les utilisateurs.\n\nLorsque vous ajoutez un utilisateur, celui-ci doit configurer son propre espace.\n\nTout utilisateur peut mettre à jour les applications pour les autres utilisateurs. Il se peut que les paramètres et les services d\'accessibilité ne soient pas transférés aux nouveaux utilisateurs."</string>
    <string name="user_add_user_message_short" msgid="1511354412249044381">"Lorsque vous ajoutez un utilisateur, celui-ci doit configurer son espace.\n\nTout utilisateur peut mettre à jour les applications pour tous les autres utilisateurs."</string>
    <string name="user_setup_dialog_title" msgid="1765794166801864563">"Configurer l\'utilisateur?"</string>
    <string name="user_setup_dialog_message" msgid="1004068621380867148">"Assurez-vous que la personne est disponible et qu\'elle peut utiliser l\'appareil pour configurer son espace."</string>
    <string name="user_setup_profile_dialog_message" msgid="3896568553327558731">"Configurer le profil maintenant?"</string>
    <string name="user_setup_button_setup_now" msgid="3391388430158437629">"Configurer maintenant"</string>
    <string name="user_setup_button_setup_later" msgid="3068729597269172401">"Pas maintenant"</string>
    <string name="user_cannot_manage_message" product="tablet" msgid="7153048188252553320">"Seul le propriétaire de la tablette peut gérer les utilisateurs."</string>
    <string name="user_cannot_manage_message" product="default" msgid="959315813089950649">"Seul le propriétaire de la tablette peut gérer les utilisateurs."</string>
    <string name="user_cannot_add_accounts_message" msgid="5116692653439737050">"Les profils limités ne peuvent pas ajouter de compte."</string>
    <string name="user_remove_user_menu" msgid="6897150520686691355">"Supp. <xliff:g id="USER_NAME">%1$s</xliff:g> de l\'appareil"</string>
    <string name="user_lockscreen_settings" msgid="4965661345247084878">"Paramètres de l\'écran de verrouillage"</string>
    <string name="user_add_on_lockscreen_menu" msgid="9072312646546364619">"Ajouter des utilisateurs à partir de l\'écran de verrouillage"</string>
    <string name="user_new_user_name" msgid="369856859816028856">"Nouvel utilisateur"</string>
    <string name="user_new_profile_name" msgid="2632088404952119900">"Nouveau profil"</string>
    <string name="user_confirm_remove_self_title" msgid="8432050170899479556">"Vous supprimer?"</string>
    <string name="user_confirm_remove_title" msgid="8068422695175097315">"Supprimer cet utilisateur?"</string>
    <string name="user_profile_confirm_remove_title" msgid="5573161550669867342">"Supprimer ce profil?"</string>
    <string name="work_profile_confirm_remove_title" msgid="2017323555783522213">"Supprimer le profil professionnel?"</string>
    <string name="user_confirm_remove_self_message" product="tablet" msgid="2391372805233812410">"Votre espace et vos données vont disparaître de cette tablette. Cette action est irréversible."</string>
    <string name="user_confirm_remove_self_message" product="default" msgid="7943645442479360048">"Votre espace et vos données vont être supprimés de ce téléphone. Cette action est irréversible."</string>
    <string name="user_confirm_remove_message" msgid="1020629390993095037">"L\'ensemble des applications et des données seront supprimées."</string>
    <string name="work_profile_confirm_remove_message" msgid="323856589749078140">"Toutes les applications et les données de ce profil seront supprimées si vous continuez."</string>
    <string name="user_profile_confirm_remove_message" msgid="7373754145959298522">"L\'ensemble des applications et des données seront supprimées."</string>
    <string name="user_adding_new_user" msgid="1521674650874241407">"Ajout de l\'utilisateur…"</string>
    <string name="user_delete_user_description" msgid="3158592592118767056">"Supprimer l\'utilisateur"</string>
    <string name="user_delete_button" msgid="5131259553799403201">"Supprimer"</string>
    <string name="user_guest" msgid="8475274842845401871">"Invité"</string>
    <string name="user_exit_guest_title" msgid="5613997155527410675">"Supprimer l\'invité"</string>
    <string name="user_exit_guest_confirm_title" msgid="3405527634738147409">"Supprimer l\'invité?"</string>
    <string name="user_exit_guest_confirm_message" msgid="2194459201944413257">"Toutes les applications et les données de cette session seront supprimées."</string>
    <string name="user_exit_guest_dialog_remove" msgid="6351370829952745350">"Supprimer"</string>
    <string name="user_enable_calling" msgid="5128605672081602348">"Activer les appels téléphoniques"</string>
    <string name="user_enable_calling_sms" msgid="9172507088023097063">"Activer appels téléphoniques et textos"</string>
    <string name="user_remove_user" msgid="3612979309028881318">"Supprimer l\'utilisateur"</string>
    <string name="user_enable_calling_confirm_title" msgid="4315789475268695378">"Activer les appels téléphoniques?"</string>
    <string name="user_enable_calling_confirm_message" msgid="8061594235219352787">"L\'historique des appels sera partagé avec cet utilisateur."</string>
    <string name="user_enable_calling_and_sms_confirm_title" msgid="7243308401401932681">"Activer les appels téléphoniques et les textos?"</string>
    <string name="user_enable_calling_and_sms_confirm_message" msgid="4025082715546544967">"L\'historique des appels et des textos sera partagé avec cet utilisateur."</string>
    <string name="emergency_info_title" msgid="208607506217060337">"Coordonnées d\'urgence"</string>
    <string name="emergency_info_summary" msgid="5062945162967838521">"Information et contacts pour <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="application_restrictions" msgid="8207332020898004394">"Autoriser des applications et des contenus"</string>
    <string name="apps_with_restrictions_header" msgid="3660449891478534440">"Applications avec restrictions"</string>
    <string name="apps_with_restrictions_settings_button" msgid="3841347287916635821">"Développer paramètres applis"</string>
    <string name="nfc_payment_settings_title" msgid="1807298287380821613">"Toucher et payer"</string>
    <string name="nfc_payment_how_it_works" msgid="3028822263837896720">"Fonctionnement"</string>
    <string name="nfc_payment_no_apps" msgid="5477904979148086424">"Payez avec votre téléphone en magasin"</string>
    <string name="nfc_payment_default" msgid="8648420259219150395">"Mode de paiement par défaut"</string>
    <string name="nfc_payment_default_not_set" msgid="7485060884228447765">"Non défini"</string>
    <string name="nfc_payment_app_and_desc" msgid="7942415346564794258">"<xliff:g id="APP">%1$s</xliff:g> - <xliff:g id="DESCRIPTION">%2$s</xliff:g>"</string>
    <string name="nfc_payment_use_default" msgid="3234730182120288495">"Valeur par défaut"</string>
    <string name="nfc_payment_favor_default" msgid="5743781166099608372">"Toujours"</string>
    <string name="nfc_payment_favor_open" msgid="1923314062109977944">"Sauf si une autre application de paiement est ouverte"</string>
    <string name="nfc_payment_pay_with" msgid="7524904024378144072">"Application à utiliser aux terminaux de paiement sans contact :"</string>
    <string name="nfc_how_it_works_title" msgid="1984068457698797207">"Paiement à un terminal"</string>
    <string name="nfc_how_it_works_content" msgid="4749007806393224934">"Configurez une application de paiement. Il suffit ensuite de poser l\'arrière de votre téléphone sur n\'importe quel terminal disposant du symbole Sans contact."</string>
    <string name="nfc_how_it_works_got_it" msgid="259653300203217402">"OK"</string>
    <string name="nfc_more_title" msgid="815910943655133280">"Plus..."</string>
    <string name="nfc_payment_set_default_label" msgid="7315817259485674542">"Définir comme application de paiement par défaut?"</string>
    <string name="nfc_payment_set_default" msgid="8532426406310833489">"Toujours utiliser <xliff:g id="APP">%1$s</xliff:g> pour les paiements sans contact?"</string>
    <string name="nfc_payment_set_default_instead_of" msgid="6993301165940432743">"Toujours utiliser <xliff:g id="APP_0">%1$s</xliff:g> au lieu de l\'application <xliff:g id="APP_1">%2$s</xliff:g> pour les paiements sans contact?"</string>
    <string name="restriction_settings_title" msgid="4233515503765879736">"Restrictions"</string>
    <string name="restriction_menu_reset" msgid="2067644523489568173">"Annuler les restrictions"</string>
    <string name="restriction_menu_change_pin" msgid="740081584044302775">"Modifier le NIP"</string>
    <string name="app_notifications_switch_label" msgid="9124072219553687583">"Afficher les notifications"</string>
    <string name="help_label" msgid="6886837949306318591">"Aide et commentaires"</string>
    <string name="support_summary" msgid="2705726826263742491">"Articles d\'aide, assistance par téléphone et par clavardage, premiers pas"</string>
    <string name="user_account_title" msgid="1127193807312271167">"Compte pour contenu"</string>
    <string name="user_picture_title" msgid="7297782792000291692">"ID de photo"</string>
    <string name="extreme_threats_title" msgid="6549541803542968699">"Menaces extrêmes"</string>
    <string name="extreme_threats_summary" msgid="8777860706500920667">"Recevoir alertes pour menaces extrêmes à la vie et aux biens"</string>
    <string name="severe_threats_title" msgid="8362676353803170963">"Menaces graves"</string>
    <string name="severe_threats_summary" msgid="8848126509420177320">"Recevoir alertes pour menaces graves à la vie et aux biens"</string>
    <string name="amber_alerts_title" msgid="2772220337031146529">"Alertes AMBER"</string>
    <string name="amber_alerts_summary" msgid="4312984614037904489">"Recevoir les bulletins sur les enlèvements d\'enfants"</string>
    <string name="repeat_title" msgid="6473587828597786996">"Répéter"</string>
    <string name="call_manager_enable_title" msgid="7718226115535784017">"Activer le gestionnaire d\'appels"</string>
    <string name="call_manager_enable_summary" msgid="8458447798019519240">"Autoriser ce service à gérer comment vous faites vos appels."</string>
    <string name="call_manager_title" msgid="4479949569744516457">"Gestionnaire d\'appels"</string>
    <!-- no translation found for call_manager_summary (5918261959486952674) -->
    <skip />
    <string name="cell_broadcast_settings" msgid="4124461751977706019">"Alertes d\'urgence"</string>
    <string name="network_operators_settings" msgid="2583178259504630435">"Fournisseurs de services cellulaires"</string>
    <string name="access_point_names" msgid="1381602020438634481">"Noms des points d\'accès"</string>
    <string name="enhanced_4g_lte_mode_title" msgid="2544026384901010606">"VoLTE"</string>
    <string name="enhanced_4g_lte_mode_title_advanced_calling" msgid="480304128966864221">"Appels avancés"</string>
    <string name="enhanced_4g_lte_mode_title_4g_calling" msgid="6839553611093179243">"Appels 4G"</string>
    <string name="enhanced_4g_lte_mode_summary" msgid="4156658595226379286">"Utiliser les services LTE pour améliorer les communications vocales et autres (recommandé)"</string>
    <string name="enhanced_4g_lte_mode_summary_4g_calling" msgid="6145184730437907078">"Utiliser les services 4G pour améliorer les communications vocales et autres (recommandé)"</string>
    <string name="preferred_network_type_title" msgid="3431041717309776341">"Type de réseau préféré"</string>
    <string name="preferred_network_type_summary" msgid="6564884693884755019">"LTE (recommandé)"</string>
    <string name="mms_message_title" msgid="6068098013612041440">"Messages multimédias"</string>
    <string name="mms_message_summary" msgid="8408985719331988420">"Envoi et réception lorsque les données cellulaires sont désactivées"</string>
    <string name="data_during_calls_title" msgid="4476240693784306761">"Données durant les appels"</string>
    <string name="data_during_calls_summary" msgid="497978580819604521">"Autoriser l\'utilisation de cette carte SIM pour les données cellulaires seulement durant les appels"</string>
    <string name="work_sim_title" msgid="4843322164662606891">"Carte SIM professionnelle"</string>
    <string name="user_restrictions_title" msgid="5794473784343434273">"Accès aux applications et au contenu"</string>
    <string name="user_rename" msgid="8523499513614655279">"RENOMMER"</string>
    <string name="app_restrictions_custom_label" msgid="6160672982086584261">"Définir des restrictions d\'applis"</string>
    <string name="user_restrictions_controlled_by" msgid="3164078767438313899">"Contrôlées par <xliff:g id="APP">%1$s</xliff:g>"</string>
    <string name="app_sees_restricted_accounts" msgid="7503264525057246240">"Cette application peut accéder à vos comptes."</string>
    <string name="app_sees_restricted_accounts_and_controlled_by" msgid="6968697624437267294">"Cette application peut accéder à vos comptes. Contrôlée par <xliff:g id="APP">%1$s</xliff:g>."</string>
    <string name="restriction_wifi_config_title" msgid="8889556384136994814">"Wi‑Fi et données cellulaires"</string>
    <string name="restriction_wifi_config_summary" msgid="70888791513065244">"Autoriser les modifications des paramètres du Wi‑Fi et des données cellulaires"</string>
    <string name="restriction_bluetooth_config_title" msgid="8871681580962503671">"Bluetooth"</string>
    <string name="restriction_bluetooth_config_summary" msgid="8372319681287562506">"Autoriser les modifications des associations et des paramètres Bluetooth"</string>
    <string name="restriction_nfc_enable_title" msgid="5888100955212267941">"NFC"</string>
    <string name="restriction_nfc_enable_summary_config" msgid="3232480757215851738">"Autoriser l\'échange de données lorsque cet appareil (<xliff:g id="DEVICE_NAME">%1$s</xliff:g>) touche un autre appareil NFC"</string>
    <string name="restriction_nfc_enable_summary" product="tablet" msgid="3891097373396149915">"Autoriser l\'échange de données lorsque la tablette est en contact avec un autre appareil"</string>
    <string name="restriction_nfc_enable_summary" product="default" msgid="825331120501418592">"Autoriser l\'échange de données lorsque le téléphone est en contact avecun autre appareil"</string>
    <string name="restriction_location_enable_title" msgid="5020268888245775164">"Position"</string>
    <string name="restriction_location_enable_summary" msgid="3489765572281788755">"Autoriser les applications à utiliser vos données de localisation"</string>
    <string name="wizard_back" msgid="5567007959434765743">"Précédent"</string>
    <string name="wizard_next" msgid="3606212602795100640">"SUIVANT"</string>
    <string name="wizard_finish" msgid="3286109692700083252">"Terminer"</string>
    <string name="user_image_take_photo" msgid="4038201220173969126">"Prendre une photo"</string>
    <string name="user_image_choose_photo" msgid="7643300431215339631">"Sélectionner une image"</string>
    <string name="user_image_photo_selector" msgid="5492565707299454873">"Sélectionner une photo"</string>
    <string name="regulatory_info_text" msgid="5623087902354026557"></string>
    <string name="sim_setup_wizard_title" msgid="1732682852692274928">"Cartes SIM"</string>
    <string name="sim_settings_title" msgid="6822745211458959756">"Cartes SIM"</string>
    <string name="sim_settings_summary" msgid="4050372057097516088">"<xliff:g id="SIM_NAME">%1$s</xliff:g> – <xliff:g id="SIM_NUMBER">%2$s</xliff:g>"</string>
    <string name="sim_cards_changed_message" msgid="7900721153345139783">"Les cartes SIM ont été changées."</string>
    <string name="sim_cards_changed_message_summary" msgid="8258058274989383204">"Touchez pour définir les activités"</string>
    <string name="sim_cellular_data_unavailable" msgid="9109302537004566098">"Données cellulaires non disponibles"</string>
    <string name="sim_cellular_data_unavailable_summary" msgid="5416535001368135327">"Touchez pour sélectionner une carte SIM pour les données"</string>
    <string name="sim_calls_always_use" msgid="7936774751250119715">"Toujours l\'utiliser pour les appels"</string>
    <string name="select_sim_for_data" msgid="2366081042162853044">"Sélectionnez une carte SIM pour données"</string>
    <string name="select_sim_for_sms" msgid="6232060107120265044">"Sélectionnez la carte SIM pour les textos"</string>
    <string name="data_switch_started" msgid="2040761479817166311">"Changement de carte SIM pour les données, cela peut prendre jusqu\'à une minute..."</string>
    <string name="select_sim_for_calls" msgid="3503094771801109334">"Appeler avec"</string>
    <string name="sim_select_card" msgid="211285163525563293">"Sélectionnez une carte SIM"</string>
    <string name="sim_card_number_title" msgid="7845379943474336488">"Carte SIM <xliff:g id="CARD_NUMBER">%1$d</xliff:g>"</string>
    <string name="sim_slot_empty" msgid="8964505511911854688">"La fente pour carte SIM est vide"</string>
    <string name="sim_editor_name" msgid="1722945976676142029">"Nom de la carte SIM"</string>
    <string name="sim_name_hint" msgid="7038643345238968930">"Entrez le nom de la carte SIM"</string>
    <string name="sim_editor_title" msgid="4034301817366627870">"Fente pour carte SIM %1$d"</string>
    <string name="sim_editor_carrier" msgid="5684523444677746573">"Fournisseur de services"</string>
    <string name="sim_editor_number" msgid="6705955651035440667">"Numéro"</string>
    <string name="sim_editor_color" msgid="2542605938562414355">"Couleur de la carte SIM"</string>
    <string name="sim_card_select_title" msgid="6668492557519243456">"Sélectionner une carte SIM"</string>
    <string name="color_orange" msgid="4417567658855022517">"Orange"</string>
    <string name="color_purple" msgid="3888532466427762504">"Mauve"</string>
    <string name="sim_no_inserted_msg" msgid="210316755353227087">"Aucune carte SIM insérée"</string>
    <string name="sim_status_title" msgid="6744870675182447160">"État de la carte SIM"</string>
    <string name="sim_status_title_sim_slot" msgid="5725659316463979194">"État de la carte SIM (fente SIM n° %1$d)"</string>
    <string name="sim_call_back_title" msgid="5181549885999280334">"Rappeler avec la carte SIM par défaut"</string>
    <string name="sim_outgoing_call_title" msgid="1019763076116874255">"Carte SIM pour les appels sortants"</string>
    <string name="sim_other_call_settings" msgid="8247802316114482477">"Autres paramètres d\'appel"</string>
    <string name="preferred_network_offload_title" msgid="1605829724169550275">"Décharg. réseau préféré"</string>
    <string name="preferred_network_offload_header" msgid="2321173571529106767">"Désact. diff. nom réseau"</string>
    <string name="preferred_network_offload_footer" msgid="5857279426054744020">"La désactivation de la diffusion du nom du réseau empêche les tiers d\'accéder aux détails du réseau."</string>
    <string name="preferred_network_offload_popup" msgid="2252915199889604600">"La désactivation de la diffusion du nom du réseau bloque la connexion automatique aux réseaux masqués"</string>
    <string name="sim_signal_strength" msgid="9144010043784767984">"<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="6272913297433198340">"Les cartes SIM ont été changées."</string>
    <string name="sim_notification_summary" msgid="8858043655706669772">"Touchez pour configurer"</string>
    <string name="sim_pref_divider" msgid="6778907671867621874">"Carte SIM préférée pour"</string>
    <string name="sim_calls_ask_first_prefs_title" msgid="7941299533514115976">"Toujours demander"</string>
    <string name="sim_selection_required_pref" msgid="3446721423206414652">"Veuillez indiquer votre préférence"</string>
    <string name="sim_selection_channel_title" msgid="2760909074892782589">"Sélection de carte SIM"</string>
    <string name="dashboard_title" msgid="5453710313046681820">"Paramètres"</string>
    <plurals name="settings_suggestion_header_summary_hidden_items" formatted="false" msgid="5597356221942118048">
      <item quantity="one">Afficher %d élément masqué</item>
      <item quantity="other">Afficher %d éléments masqués</item>
    </plurals>
    <string name="network_dashboard_title" msgid="3135144174846753758">"Réseau et Internet"</string>
    <string name="network_dashboard_summary_mobile" msgid="3851083934739500429">"cellulaire"</string>
    <string name="network_dashboard_summary_data_usage" msgid="3843261364705042212">"utilisation de données"</string>
    <string name="network_dashboard_summary_hotspot" msgid="8494210248613254574">"point d\'accès sans fil"</string>
    <string name="connected_devices_dashboard_title" msgid="2355264951438890709">"Appareils connectés"</string>
    <string name="connected_devices_dashboard_summary" msgid="2665221896894251402">"Bluetooth, mode Voiture, NFC"</string>
    <string name="connected_devices_dashboard_no_nfc_summary" msgid="3840842725283655533">"Bluetooth, mode Voiture"</string>
    <string name="connected_devices_dashboard_no_driving_mode_summary" msgid="5018708106066758867">"Bluetooth, NFC"</string>
    <string name="connected_devices_dashboard_no_driving_mode_no_nfc_summary" msgid="5250078362483148199">"Bluetooth"</string>
    <string name="app_and_notification_dashboard_title" msgid="7838365599185397539">"Applis et notifications"</string>
    <string name="app_and_notification_dashboard_summary" msgid="3285151907659820564">"Applications récentes, applications par défaut"</string>
    <string name="notification_settings_work_profile" msgid="3186757479243373003">"Les applications du profil professionnel n\'ont pas accès aux notifications."</string>
    <string name="account_dashboard_title" msgid="5895948991491438911">"Comptes"</string>
    <string name="account_dashboard_default_summary" msgid="3998347400161811075">"Aucun compte ajouté"</string>
    <string name="app_default_dashboard_title" msgid="7342549305933047317">"Applications par défaut"</string>
    <string name="system_dashboard_summary" msgid="6839969589170062254">"Langues, gestes, heure, sauvegarde"</string>
    <string name="search_results_title" msgid="1796252422574886932">"Paramètres"</string>
    <string name="keywords_wifi" msgid="3646884600964177062">"wifi, wi-fi, connexion réseau, internet, sans fil, données, wi fi"</string>
    <string name="keywords_wifi_notify_open_networks" msgid="8745178424405564885">"notification Wi‑Fi, notification wifi"</string>
    <string name="keywords_vibrate_on_touch" msgid="1494239633254176598">"Arrêter les vibrations, toucher, clavier"</string>
    <string name="keywords_time_format" msgid="5581515674151927461">"Utiliser le format 24 heures"</string>
    <string name="keywords_storage_files" msgid="7075933058850826819">"Télécharger"</string>
    <string name="keywords_app_default" msgid="5822717006354487071">"Ouvrir avec"</string>
    <string name="keywords_applications_settings" msgid="1268353611121497450">"Applications"</string>
    <string name="keywords_time_zone" msgid="998254736898753085">"fuseau horaire"</string>
    <string name="keywords_draw_overlay" msgid="1001120206241401007">"Bulle de clavardage, système, alerte, fenêtre, boîte de dialogue, écran, superposition autres applis, dessin"</string>
    <string name="keywords_flashlight" msgid="6161632177705233710">"Lampe de poche, lumière"</string>
    <string name="keywords_change_wifi_state" msgid="627068244033681010">"wifi, wi-fi, activer, désactiver, gestion"</string>
    <string name="keywords_more_mobile_networks" msgid="8995946622054642367">"cellulaire, mobile, fournisseur de services, sans fil, données, 4g, 3g, 2g, lte"</string>
    <string name="keywords_wifi_calling" msgid="1784064367330122679">"wifi, wi-fi, appel, appeler"</string>
    <string name="keywords_display" msgid="8910345814565493016">"écran, tactile"</string>
    <string name="keywords_display_brightness_level" msgid="3138350812626210404">"assombrir l\'écran, écran tactile, pile, lumineux"</string>
    <string name="keywords_display_night_display" msgid="2534032823231355074">"assombrir l\'écran, nuit, teinte, heures de nuit, luminosité, couleur de l\'écran, couleur, couleurs"</string>
    <string name="keywords_display_wallpaper" msgid="7362076351860131776">"fond d\'écran, personnaliser, personnaliser affichage"</string>
    <string name="keywords_display_font_size" msgid="3404655440064726124">"taille du texte"</string>
    <string name="keywords_display_cast_screen" msgid="1209288893924324904">"projet, diffuser, duplication d\'écran, partage d\'écran, dupliquer l\'écran, partager l\'écran, diffusion d\'écran"</string>
    <string name="keywords_storage" msgid="3299217909546089225">"espace, disque, disque dur, utilisation appareil"</string>
    <string name="keywords_battery" msgid="1173830745699768388">"frais, consommation d\'énergie"</string>
    <string name="keywords_spell_checker" msgid="1399641226370605729">"orthographe, dictionnaire, correcteur orthographique, correction automatique"</string>
    <string name="keywords_voice_input" msgid="769778245192531102">"détecteur, entrée, voix, parler, langue, mains libres, reconnaissance, mains libres, terme choquant, historique, audio, écouteur, bluetooth"</string>
    <string name="keywords_text_to_speech_output" msgid="5150660047085754699">"débit, langue, valeur par défaut, parler, discuter, tts, accessibilité, lecteur d\'écran, aveugle"</string>
    <string name="keywords_date_and_time" msgid="758325881602648204">"horloge, militaire"</string>
    <string name="keywords_network_reset" msgid="6024276007080940820">"réinitialiser, restaurer, paramètres d\'usine"</string>
    <string name="keywords_factory_data_reset" msgid="2261491208836438871">"nettoyer, supprimer, restaurer, effacer, retirer, réinitialisation d\'usine"</string>
    <string name="keywords_printing" msgid="1701778563617114846">"imprimante"</string>
    <string name="keywords_sounds" msgid="5633386070971736608">"bip haut-parleur, haut-parleur, volume, muet, silence, audio, musique"</string>
    <string name="keywords_sounds_and_notifications_interruptions" msgid="5426093074031208917">"ne pas déranger, interrompre, interruption, pause"</string>
    <string name="keywords_app" msgid="6334757056536837791">"Mémoire vive"</string>
    <string name="keywords_location" msgid="4132655528196729043">"à proximité, position, historique, signalement, GPS"</string>
    <string name="keywords_accounts" msgid="4479029747403203867">"compte, ajouter un compte, profil professionnel"</string>
    <string name="keywords_users" msgid="3434190133131387942">"restriction, restreindre, restreint"</string>
    <string name="keywords_keyboard_and_ime" msgid="9143339015329957107">"correction de texte, corriger, son, vibreur, automatique, langue, geste, suggérer, suggestion, thème, choquant, mot, type, emoji, international"</string>
    <string name="keywords_reset_apps" msgid="5293291209613191845">"réinitialiser, préférences, par défaut"</string>
    <string name="keywords_all_apps" msgid="7814015440655563156">"applis, télécharger, applications, système"</string>
    <string name="keywords_app_permissions" msgid="4229936435938011023">"applications, autorisations, sécurité"</string>
    <string name="keywords_default_apps" msgid="223872637509160136">"applications, par défaut"</string>
    <string name="keywords_ignore_optimizations" msgid="6102579291119055029">"ignorer les optimisations, mise en veille, mode veille des application"</string>
    <string name="keywords_color_mode" msgid="6362744316886077510">"vibrantes, rvb, srvb, couleurs, naturelles, standard"</string>
    <string name="keywords_color_temperature" msgid="6239410718075715449">"température, couleur, D65, D73, blanc, jaune, bleu, chaud, froid"</string>
    <string name="keywords_lockscreen" msgid="5746561909668570047">"glisser pour déverrouiller, mot de passe, schéma, nip"</string>
    <string name="keywords_profile_challenge" msgid="789611397846512845">"défi professionnel, travail, profil"</string>
    <string name="keywords_unification" msgid="1922900767659821025">"profil professionnel, profil géré, unifier, unification, travail, profil"</string>
    <string name="keywords_gesture" msgid="3526905012224714078">"gestes"</string>
    <string name="keywords_payment_settings" msgid="5220104934130446416">"payer, toucher, paiements"</string>
    <string name="keywords_backup" msgid="470070289135403022">"sauvegarde, sauvegarder"</string>
    <string name="keywords_assist_gesture_launch" msgid="813968759791342591">"geste"</string>
    <string name="keywords_face_unlock" msgid="254144854349092754">"visage, déverrouiller, authentification, se connecter"</string>
    <string name="keywords_imei_info" msgid="7230982940217544527">"iiem, idem, min, version de la liste d\'itinérance préférée, iiem sv"</string>
    <string name="keywords_sim_status" msgid="6682044233620329507">"réseau, état du réseau cellulaire, état du service, puissance du signal, type de réseau cellulaire, itinérance, iccid, eid"</string>
    <string name="keywords_model_and_hardware" msgid="1459248377212829642">"numéro de série, version matérielle"</string>
    <string name="keywords_android_version" msgid="9069747153590902819">"niveau du correctif de sécurité android, version de la bande de base, version du noyau"</string>
    <string name="keywords_dark_ui_mode" msgid="8999745898782012625">"thème, clair, sombre, mode"</string>
    <string name="keywords_systemui_theme" msgid="9112852512550404882">"thème sombre"</string>
    <string name="keywords_device_feedback" msgid="564493721125966719">"bogue"</string>
    <string name="keywords_ambient_display_screen" msgid="5874969496073249362">"Affichage en mode Veille, écran de verrouillage"</string>
    <string name="keywords_lock_screen_notif" msgid="6716392855813576197">"notification sur l\'écran de verrouillage, notifications"</string>
    <string name="keywords_face_settings" msgid="7505388678116799329">"visage"</string>
    <string name="keywords_fingerprint_settings" msgid="4425098764810291897">"empreinte digitale, ajouter une empreinte digitale"</string>
    <string name="keywords_display_auto_brightness" msgid="4561771351118904241">"réduire la luminosité de l\'écran, écran tactile, pile, réglage intelligent de la luminosité, luminosité dynamique, luminosité automatique"</string>
    <string name="keywords_display_adaptive_sleep" msgid="6865504720946121402">"assombrir l\'écran, veille, pile, délai d\'inactivité, attention, affichage, écran, inactivité"</string>
    <string name="keywords_auto_rotate" msgid="5620879898668211494">"faire pivoter, tourner, retourner, rotation, portrait, paysage, orientation, vertical, horizontal"</string>
    <string name="keywords_system_update_settings" msgid="7752189778843741773">"mise à niveau, android"</string>
    <string name="keywords_zen_mode_settings" msgid="6526742836231604995">"ne pas déranger, horaire, notifications, bloquer, silence, vibrer, dormir, travailler, se concentrer, son, muet, jour, jour de semaine, fin de semaine, soir de semaine, événement"</string>
    <string name="keywords_screen_timeout" msgid="8161370660970309476">"écran, temps de verrouillage, expiration du délai, verrouillage de l\'écran"</string>
    <string name="keywords_storage_settings" msgid="297283751968446577">"mémoire, cache, données, supprimer, effacer, libre, espace"</string>
    <string name="keywords_bluetooth_settings" msgid="6804844062789439858">"connecté, appareil, casque d\'écoute, casque, haut-parleur, sans fil, associer, écouteurs, musique, médias"</string>
    <string name="keywords_wallpaper" msgid="5058364390917429896">"fond d\'écran, écran, écran de verrouillage, thème"</string>
    <string name="keywords_styles" msgid="5828725481814049422">"forme de l\'icône, couleur d\'accent, police"</string>
    <string name="keywords_assist_input" msgid="5017533309492679287">"par défaut, assistant"</string>
    <string name="keywords_default_payment_app" msgid="3838565809518896799">"paiement, par défaut"</string>
    <string name="keywords_ambient_display" msgid="3103487805748659132">"notification entrante"</string>
    <string name="keywords_hotspot_tethering" msgid="1137511742967410918">"partage de connexion usb, partage de connexion bluetooth, partage de connexion wi-fi, fonction modem"</string>
    <string name="keywords_touch_vibration" msgid="5983211715076385822">"haptique, vibrer, écran, sensibilité"</string>
    <string name="keywords_ring_vibration" msgid="4652101158979064884">"haptique, vibration, téléphone, appel, sensibilité, sonnerie"</string>
    <string name="keywords_notification_vibration" msgid="31924624421190547">"haptique, vibration, sensibilité"</string>
    <string name="keywords_battery_saver_sticky" msgid="5586215686021650278">"économiseur de pile, fixe, persistant, économie d\'énergie, pile"</string>
    <string name="keywords_battery_saver_schedule" msgid="7358789228486231944">"routine, horaire, économiseur de pile, économie d\'énergie, pile, automatique, pour cent"</string>
    <string name="default_sound" msgid="8821684447333687810">"Son par défaut"</string>
    <string name="sound_settings_summary" msgid="4100853606668287965">"Le volume de la sonnerie est à <xliff:g id="PERCENTAGE">%1$s</xliff:g>"</string>
    <string name="sound_dashboard_summary" msgid="3402435125958012986">"Volume, vibration, Ne pas déranger"</string>
    <string name="sound_settings_summary_vibrate" msgid="1869282574422220096">"Sonnerie en mode vibration"</string>
    <string name="sound_settings_summary_silent" msgid="5074529767435584948">"Sonnerie en mode silencieux"</string>
    <string name="sound_settings_example_summary" msgid="2404914514266523165">"Le volume de la sonnerie est à 80 %"</string>
    <string name="media_volume_option_title" msgid="2811531786073003825">"Volume du contenu multimédia"</string>
    <string name="remote_media_volume_option_title" msgid="7602586327091007461">"Volume de diffusion"</string>
    <string name="call_volume_option_title" msgid="1265865226974255384">"Volume des appels"</string>
    <string name="alarm_volume_option_title" msgid="8219324421222242421">"Volume de l\'alarme"</string>
    <string name="ring_volume_option_title" msgid="6767101703671248309">"Volume de la sonnerie"</string>
    <string name="notification_volume_option_title" msgid="6064656124416882130">"Volume des notifications"</string>
    <string name="ringtone_title" msgid="5379026328015343686">"Sonnerie du téléphone"</string>
    <string name="notification_ringtone_title" msgid="4468722874617061231">"Son de notification par défaut"</string>
    <string name="notification_unknown_sound_title" msgid="2535027767851838335">"Son fourni par l\'application"</string>
    <string name="notification_sound_default" msgid="565135733949733766">"Son de notification par défaut"</string>
    <string name="alarm_ringtone_title" msgid="6344025478514311386">"Son de l\'alarme par défaut"</string>
    <string name="vibrate_when_ringing_title" msgid="8658910997501323472">"Vibrer pour les appels"</string>
    <string name="other_sound_settings" msgid="3151004537006844718">"Autres sons"</string>
    <string name="dial_pad_tones_title" msgid="1999293510400911558">"Tonalités du clavier"</string>
    <string name="screen_locking_sounds_title" msgid="1340569241625989837">"Sons du verrouillage d\'écran"</string>
    <string name="charging_sounds_title" msgid="3379885700913955599">"Sons et vibrations de recharge"</string>
    <string name="docking_sounds_title" msgid="155236288949940607">"Sons de la station d\'accueil"</string>
    <string name="touch_sounds_title" msgid="5326587106892390176">"Sons des touches"</string>
    <string name="vibrate_on_touch_title" msgid="1510405818894719079">"Vibration tactile"</string>
    <string name="vibrate_on_touch_summary" msgid="8015901758501868229">"Retour haptique pour les touchers, le clavier et plus"</string>
    <string name="dock_audio_media_title" msgid="1346838179626123900">"Lecture : station d\'accueil"</string>
    <string name="dock_audio_media_disabled" msgid="3430953622491538080">"Tout l\'audio"</string>
    <string name="dock_audio_media_enabled" msgid="667849382924908673">"Audio des médias seulement"</string>
    <string name="emergency_tone_silent" msgid="3750231842974733677">"Silence"</string>
    <string name="emergency_tone_alert" msgid="8523447641290736852">"Tonalités"</string>
    <string name="emergency_tone_vibrate" msgid="2278872257053690683">"Vibrations"</string>
    <string name="boot_sounds_title" msgid="567029107382343709">"Activation par les sons"</string>
    <string name="live_caption_title" msgid="2241633148129286971">"Transcription instantanée"</string>
    <string name="live_caption_summary" msgid="3365960379606535783">"Ajouter automatiquement des sous-titres aux médias"</string>
    <string name="zen_mode_settings_summary_off" msgid="6119891445378113334">"Jamais"</string>
    <plurals name="zen_mode_settings_summary_on" formatted="false" msgid="2249085722517252521">
      <item quantity="one"><xliff:g id="ON_COUNT">%d</xliff:g> règle activée</item>
      <item quantity="other"><xliff:g id="ON_COUNT">%d</xliff:g> règles activées</item>
    </plurals>
    <string name="zen_mode_settings_title" msgid="1066226840983908121">"Ne pas déranger"</string>
    <string name="zen_mode_slice_subtitle" msgid="1495506059205752083">"Limiter les interruptions"</string>
    <string name="zen_mode_settings_turn_on_dialog_title" msgid="2297134204747331078">"Activer la fonction « Ne pas déranger »"</string>
    <string name="zen_mode_behavior_settings_title" msgid="5453115212674008032">"Exceptions"</string>
    <string name="zen_mode_duration_settings_title" msgid="8471983919324532829">"Durée par défaut"</string>
    <string name="zen_mode_behavior_allow_title" msgid="3845615648136218141">"Autoriser sons et vibrations de"</string>
    <string name="zen_mode_behavior_no_sound" msgid="1219626004723208056">"Aucun son"</string>
    <string name="zen_mode_behavior_total_silence" msgid="2229976744274214528">"Aucune interruption"</string>
    <string name="zen_mode_behavior_no_sound_except" msgid="4968477585788243114">"Aucun son sauf <xliff:g id="CATEGORIES">%1$s</xliff:g>"</string>
    <string name="zen_mode_behavior_alarms_only" msgid="6455884547877702466">"Aucun son, sauf pour les alarmes et les médias"</string>
    <string name="zen_mode_automation_settings_title" msgid="6155298704165984370">"Horaires"</string>
    <string name="zen_mode_delete_automatic_rules" msgid="5975522152123354381">"Supprimer les horaires"</string>
    <string name="zen_mode_schedule_delete" msgid="5717258786128155695">"Supprimer"</string>
    <string name="zen_mode_rule_name_edit" msgid="812185626159430507">"Modifier"</string>
    <string name="zen_mode_automation_settings_page_title" msgid="8995524726286378583">"Horaires"</string>
    <string name="zen_mode_automatic_rule_settings_page_title" msgid="4773111805919088437">"Horaire"</string>
    <string name="zen_mode_schedule_category_title" msgid="5482757877262584975">"Horaire"</string>
    <string name="zen_mode_automation_suggestion_title" msgid="4321254843908888574">"Tél. en silence à certains moments"</string>
    <string name="zen_mode_automation_suggestion_summary" msgid="6223252025075862701">"Créer des règles pour le mode Ne pas déranger"</string>
    <string name="zen_mode_schedule_title" msgid="8616187805239590649">"Horaire"</string>
    <string name="zen_mode_use_automatic_rule" msgid="489102635414919052">"Utiliser l\'horaire"</string>
    <string name="zen_mode_option_important_interruptions" msgid="3903928008177972500">"Prioritaires seulement"</string>
    <string name="zen_mode_option_alarms" msgid="5785372117288803600">"Alarmes seulement"</string>
    <string name="zen_mode_option_no_interruptions" msgid="8107126344850276878">"Aucune interruption"</string>
    <string name="zen_mode_summary_combination" msgid="8715563402849273459">"<xliff:g id="MODE">%1$s</xliff:g> : <xliff:g id="EXIT_CONDITION">%2$s</xliff:g>"</string>
    <string name="zen_mode_visual_interruptions_settings_title" msgid="6751708745442997940">"Bloquer dérangements visuels"</string>
    <string name="zen_mode_visual_signals_settings_subtitle" msgid="6308824824208120508">"Autoriser les signaux visuels"</string>
    <string name="zen_mode_settings_category" msgid="8404473163624911791">"Quand la fonction Ne pas déranger est activée"</string>
    <string name="zen_mode_restrict_notifications_title" msgid="8138441771855063771">"Restreindre les notifications"</string>
    <string name="zen_mode_restrict_notifications_mute" msgid="3690261619682396872">"Aucun son des notifications"</string>
    <string name="zen_mode_restrict_notifications_mute_summary" msgid="5810076116489877312">"Vous verrez des notifications sur l\'écran"</string>
    <string name="zen_mode_restrict_notifications_mute_footer" msgid="3465600930732602159">"Lorsque de nouvelles notifications arrivent, votre téléphone n\'émettra aucun son et ne vibrera pas."</string>
    <string name="zen_mode_restrict_notifications_hide" msgid="5305121630186687339">"Aucun élément visuel ni son provenant des notifications"</string>
    <string name="zen_mode_restrict_notifications_hide_summary" msgid="7555448406901864904">"Vous ne verrez et n\'entendrez pas de notifications"</string>
    <string name="zen_mode_restrict_notifications_hide_footer" msgid="1069960859746788356">"Votre téléphone n\'affichera rien à l\'écran, ne vibrera pas et n\'émettra aucun son pour les notifications, nouvelles et existantes. Gardez à l\'esprit que les notifications cruciales pour le fonctionnement et l\'état du téléphone continueront de s\'afficher.\n\nLorsque vous désactivez le mode Ne pas déranger, vous pouvez afficher les notifications manquées en balayant l\'écran du haut vers le bas."</string>
    <string name="zen_mode_restrict_notifications_custom" msgid="7498689167767941034">"Personnalisées"</string>
    <string name="zen_mode_restrict_notifications_enable_custom" msgid="4250962169561739747">"Activer les paramètres personnalisés"</string>
    <string name="zen_mode_restrict_notifications_disable_custom" msgid="6676997522330453597">"Supprimer les paramètres personnalisés"</string>
    <string name="zen_mode_restrict_notifications_summary_muted" msgid="5450158135853888485">"Aucun son des notifications"</string>
    <string name="zen_mode_restrict_notifications_summary_custom" msgid="7416121534987213074">"Partiellement masquées"</string>
    <string name="zen_mode_restrict_notifications_summary_hidden" msgid="3618285192806732504">"Aucun élément visuel ni son provenant des notifications"</string>
    <string name="zen_mode_what_to_block_title" msgid="5480903548365697159">"Restrictions personnalisées"</string>
    <string name="zen_mode_block_effects_screen_on" msgid="4659484530849212827">"Lorsque l\'écran est allumé"</string>
    <string name="zen_mode_block_effects_screen_off" msgid="4276414460889400625">"Lorsque l\'écran est éteint"</string>
    <string name="zen_mode_block_effect_sound" msgid="7383953383758025895">"Désactiver les sons et les vibrations"</string>
    <string name="zen_mode_block_effect_intent" msgid="350764335391428447">"Ne pas activer l\'écran"</string>
    <string name="zen_mode_block_effect_light" msgid="8106976110224107316">"Ne pas faire clignoter la lumière"</string>
    <string name="zen_mode_block_effect_peek" msgid="6836997464098657115">"Ne pas afficher de notifications à l\'écran"</string>
    <string name="zen_mode_block_effect_status" msgid="1651527249762752921">"Masquer les icônes de la barre d\'état dans le haut de l\'écran"</string>
    <string name="zen_mode_block_effect_badge" msgid="214553506070597320">"Masquer les points de notification sur les icônes d\'application"</string>
    <string name="zen_mode_block_effect_ambient" msgid="4704755879961212658">"Ne pas réactiver pour les notifications"</string>
    <string name="zen_mode_block_effect_list" msgid="4722887783222298295">"Masquer du volet déroulant"</string>
    <string name="zen_mode_block_effect_summary_none" msgid="2617875282623486256">"Jamais"</string>
    <string name="zen_mode_block_effect_summary_screen_off" msgid="1230265589026355094">"Lorsque l\'écran est éteint"</string>
    <string name="zen_mode_block_effect_summary_screen_on" msgid="6017536991063513394">"Lorsque l\'écran est allumé"</string>
    <string name="zen_mode_block_effect_summary_sound" msgid="1065107568053759972">"Sons et vibrations"</string>
    <string name="zen_mode_block_effect_summary_some" msgid="3635646031575107456">"Sons, vibrations et certains signes visuels des notifications"</string>
    <string name="zen_mode_block_effect_summary_all" msgid="1213328945418248026">"Sons, vibrations et signes visuels des notifications"</string>
    <string name="zen_mode_blocked_effects_footer" msgid="5710896246703497760">"Les notifications nécessaires pour les activités et les états de base du téléphone ne seront jamais masquées"</string>
    <string name="zen_mode_no_exceptions" msgid="7653433997399582247">"Aucun"</string>
    <string name="zen_mode_other_options" msgid="520015080445012355">"autres options"</string>
    <string name="zen_mode_add" msgid="90014394953272517">"Ajouter"</string>
    <string name="zen_mode_enable_dialog_turn_on" msgid="8287824809739581837">"Activer"</string>
    <string name="zen_mode_button_turn_on" msgid="2824380626482175552">"Activer maintenant"</string>
    <string name="zen_mode_button_turn_off" msgid="6181953727880503094">"Désactiver maintenant"</string>
    <string name="zen_mode_settings_dnd_manual_end_time" msgid="8860646554263965569">"Le mode Ne pas déranger est activé jusqu\'à <xliff:g id="FORMATTED_TIME">%s</xliff:g>"</string>
    <string name="zen_mode_settings_dnd_manual_indefinite" msgid="7186615007561990908">"Le mode Ne pas déranger restera actif jusqu\'à ce que vous le désactiviez"</string>
    <string name="zen_mode_settings_dnd_automatic_rule" msgid="6195725842906270996">"Le mode Ne pas déranger a été activé automatiquement par un horaire (<xliff:g id="RULE_NAME">%s</xliff:g>)"</string>
    <string name="zen_mode_settings_dnd_automatic_rule_app" msgid="1721179577382915270">"Le mode Ne pas déranger a été activé par une application (<xliff:g id="APP_NAME">%s</xliff:g>)"</string>
    <string name="zen_mode_settings_dnd_custom_settings_footer" msgid="1965922539531521052">"Le mode Ne pas déranger est activé <xliff:g id="RULE_NAMES">%s</xliff:g>, avec des paramètres personnalisés."</string>
    <string name="zen_mode_settings_dnd_custom_settings_footer_link" msgid="7555742240858292255"><annotation id="link">" Afficher les paramètres personnalisés"</annotation></string>
    <string name="zen_interruption_level_priority" msgid="2078370238113347720">"Priorités seulement"</string>
    <string name="zen_mode_and_condition" msgid="4927230238450354412">"<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="1202632669798211342">"Activé/<xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="zen_mode_sound_summary_off_with_info" msgid="2348629457144123849">"Désactivé : <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="zen_mode_sound_summary_off" msgid="4375814717589425561">"Désactivé"</string>
    <string name="zen_mode_sound_summary_on" msgid="7718273231309882914">"Activé"</string>
    <string name="zen_mode_duration_summary_always_prompt" msgid="3483258992533158479">"Toujours demander"</string>
    <string name="zen_mode_duration_summary_forever" msgid="8597777321810802309">"Jusqu\'à la désactivation"</string>
    <plurals name="zen_mode_duration_summary_time_hours" formatted="false" msgid="3224363976852136871">
      <item quantity="one"><xliff:g id="NUM_HOURS">%d</xliff:g> heure</item>
      <item quantity="other"><xliff:g id="NUM_HOURS">%d</xliff:g> heures</item>
    </plurals>
    <string name="zen_mode_duration_summary_time_minutes" msgid="6238305783533884764">"<xliff:g id="NUM_MINUTES">%d</xliff:g> minutes"</string>
    <plurals name="zen_mode_sound_summary_summary_off_info" formatted="false" msgid="6751226506661227581">
      <item quantity="one"><xliff:g id="ON_COUNT">%d</xliff:g> horaire peut s\'activer automatiquement</item>
      <item quantity="other"><xliff:g id="ON_COUNT">%d</xliff:g> horaires peuvent s\'activer automatiquement</item>
    </plurals>
    <string name="zen_category_behavior" msgid="554277240833452070">"Désactiver le son de l\'appareil, mais autoriser les exceptions"</string>
    <string name="zen_category_exceptions" msgid="7601136604273265629">"Exceptions"</string>
    <string name="zen_category_schedule" msgid="9000447592251450453">"Horaire"</string>
    <string name="zen_sound_title" msgid="4461494611692749446">"Afficher toutes les exceptions"</string>
    <string name="zen_sound_footer" msgid="7621745273287208979">"Lorsque le mode Ne pas déranger est activé, le son et les vibrations sont désactivés, sauf pour les éléments autorisés ci-dessus."</string>
    <string name="zen_sound_category_title" msgid="4336596939661729188">"Tout désactiver sauf"</string>
    <string name="zen_sound_all_muted" msgid="4850363350480968114">"Désactivés"</string>
    <string name="zen_sound_none_muted" msgid="3938508512103612527">"Non désactivés"</string>
    <string name="zen_sound_one_allowed" msgid="8447313454438932276">"Désactivés, mais autoriser : <xliff:g id="SOUND_TYPE">%1$s</xliff:g>"</string>
    <string name="zen_sound_two_allowed" msgid="980491120444358550">"Désactivés, mais autoriser : <xliff:g id="SOUND_TYPE_0">%1$s</xliff:g> et <xliff:g id="SOUND_TYPE_1">%2$s</xliff:g>"</string>
    <string name="zen_sound_three_allowed" msgid="3455767205934547985">"Désactivés, mais autoriser : <xliff:g id="SOUND_TYPE_0">%1$s</xliff:g>, <xliff:g id="SOUND_TYPE_1">%2$s</xliff:g> et <xliff:g id="SOUND_TYPE_2">%3$s</xliff:g>"</string>
    <string name="zen_custom_settings_dialog_title" msgid="3999383687283620283">"Paramètres personnalisés"</string>
    <string name="zen_custom_settings_dialog_review_schedule" msgid="7056997717364939238">"Examiner l\'horaire"</string>
    <string name="zen_custom_settings_dialog_ok" msgid="5302885851078421866">"OK"</string>
    <string name="zen_custom_settings_notifications_header" msgid="6931035609369698584">"Notifications"</string>
    <string name="zen_custom_settings_duration_header" msgid="1190989278065507035">"Durée"</string>
    <string name="zen_msg_event_reminder_title" msgid="5137894077488924820">"Messages, événements et rappels"</string>
    <string name="zen_msg_event_reminder_footer" msgid="4376930591019535192">"Lorsque le mode Ne pas déranger est activé, le son des messages, des rappels et des événements est coupé, sauf pour les éléments autorisés ci-dessus. Vous pouvez régler les paramètres des messages pour que vos proches ou d\'autres contacts puissent quand même vous joindre."</string>
    <string name="zen_onboarding_ok" msgid="6131211000824433013">"OK"</string>
    <string name="zen_onboarding_settings" msgid="9046451821239946868">"Paramètres"</string>
    <string name="zen_onboarding_new_setting_title" msgid="1893095176110470711">"Aucun élément visuel ni son provenant des notifications"</string>
    <string name="zen_onboarding_current_setting_title" msgid="776426065129609376">"Aucun son des notifications"</string>
    <string name="zen_onboarding_new_setting_summary" msgid="6293026064871880706">"Vous ne verrez et n\'entendrez pas de notifications. Les appels des contacts marqués d\'une étoile et les appels répétés sont autorisés."</string>
    <string name="zen_onboarding_current_setting_summary" msgid="1280614488924843713">"(Paramètre actuel)"</string>
    <string name="zen_onboarding_dnd_visual_disturbances_header" msgid="1352808651270918932">"Modifier les paramètres de notification du mode Ne pas déranger?"</string>
    <string name="sound_work_settings" msgid="6774324553228566442">"Sons du profil professionnel"</string>
    <string name="work_use_personal_sounds_title" msgid="1148331221338458874">"Utiliser sons du profil perso"</string>
    <string name="work_use_personal_sounds_summary" msgid="6207040454949823153">"Les sons du profil professionnel sont les mêmes que ceux du profil personnel"</string>
    <string name="work_ringtone_title" msgid="5806657896300235315">"Sonnerie téléphone profess."</string>
    <string name="work_notification_ringtone_title" msgid="6081247402404510004">"Son de notification par défaut pour le profil professionnel"</string>
    <string name="work_alarm_ringtone_title" msgid="1441926676833738891">"Son de l\'alarme par défaut du profil professionnel"</string>
    <string name="work_sound_same_as_personal" msgid="3123383644475266478">"Mêmes que le profil personnel"</string>
    <string name="work_sync_dialog_title" msgid="7123973297187354813">"Remplacer les sons?"</string>
    <string name="work_sync_dialog_yes" msgid="7243884940551635717">"Remplacer"</string>
    <string name="work_sync_dialog_message" msgid="7841728953710863208">"Les sons de votre profil personnel seront utilisés dans votre profil professionnel"</string>
    <string name="ringtones_install_custom_sound_title" msgid="5948792721161302255">"Ajouter un son personnalisé?"</string>
    <string name="ringtones_install_custom_sound_content" msgid="2195581481608512786">"Ce fichier sera copié dans le dossier <xliff:g id="FOLDER_NAME">%s</xliff:g>"</string>
    <string name="ringtones_category_preference_title" msgid="5675912303120102366">"Sonneries"</string>
    <string name="other_sound_category_preference_title" msgid="2521096636124314015">"Autres sons et vibrations"</string>
    <string name="configure_notification_settings" msgid="7616737397127242615">"Notifications"</string>
    <string name="recent_notifications" msgid="5660639387705060156">"Envoyées récemment"</string>
    <string name="recent_notifications_see_all_title" msgid="8572160812124540326">"Tout afficher depuis les sept derniers jours"</string>
    <string name="advanced_section_header" msgid="8833934850242546903">"Paramètres avancés"</string>
    <string name="profile_section_header" msgid="2320848161066912001">"Notifications professionnelles"</string>
    <string name="smart_notifications_title" msgid="3702411478231865970">"Notifications adaptatives"</string>
    <string name="asst_capability_prioritizer_title" msgid="3854208223528908688">"Priorité adaptative pour les notifications"</string>
    <string name="asst_capability_prioritizer_summary" msgid="7553129095829077229">"Définir automatiquement les notifications à faible priorité sur Discrètes"</string>
    <string name="asst_capabilities_actions_replies_title" msgid="8621608733904251499">"Suggestions d\'actions et de réponses"</string>
    <string name="asst_capabilities_actions_replies_summary" msgid="2367828721274129806">"Afficher automatiquement les suggestions d\'actions et de réponses"</string>
    <string name="snooze_options_title" msgid="7447722951050463793">"Autoriser le report des notifications"</string>
    <string name="hide_silent_icons_title" msgid="3803036978493857276">"Masquer les icônes des notifications discrètes"</string>
    <string name="hide_silent_icons_summary" msgid="8422819235336628802">"Les icônes des notifications discrètes ne s\'affichent pas dans la barre d\'état"</string>
    <string name="notification_badging_title" msgid="5938709971403474078">"Autoriser points de notification"</string>
    <string name="notification_bubbles_title" msgid="526545466417027926">"Bulles"</string>
    <string name="notification_bubbles_developer_setting_summary" msgid="5044678712656329427">"Certaines notifications peuvent s\'afficher sous forme de bulles à l\'écran"</string>
    <string name="bubbles_feature_education" msgid="69923617148394578">"Certaines notifications et d\'autre contenu peuvent s\'afficher sous forme de bulles à l\'écran. Pour ouvrir une bulle, touchez-la. Pour l\'ignorer, faites-la glisser vers le bas de l\'écran."</string>
    <string name="bubbles_app_toggle_title" msgid="9143702245165359360">"Bulles"</string>
    <string name="bubbles_app_toggle_summary" msgid="7714358008428342285">"Autoriser l\'application <xliff:g id="APP_NAME">%1$s</xliff:g> à afficher des notifications sous forme de bulles"</string>
    <string name="bubbles_feature_disabled_dialog_title" msgid="8013961655723563787">"Activer les bulles"</string>
    <string name="bubbles_feature_disabled_dialog_text" msgid="3616822820657195387">"Avant de pouvoir activer les bulles pour cette application, vous devez les activer pour votre appareil. Cette modification a un impact sur les autres applications dans lesquelles vous avez déjà activé les bulles."</string>
    <string name="bubbles_feature_disabled_button_approve" msgid="5317196831268846883">"Activer pour l\'appareil"</string>
    <string name="bubbles_feature_disabled_button_cancel" msgid="8176870537170586852">"Annuler"</string>
    <string name="swipe_direction_title" msgid="6877543492435053137">"Balayages"</string>
    <string name="swipe_direction_ltr" msgid="3623394320915041215">"Balayer l\'écran vers la droite pour fermer la notification ou vers la gauche pour afficher le menu"</string>
    <string name="swipe_direction_rtl" msgid="4972099509548044938">"Balayer l\'écran vers la gauche pour fermer la notification ou vers la droite pour afficher le menu"</string>
    <string name="gentle_notifications_title" msgid="3976374971153475110">"Notifications discrètes"</string>
    <string name="gentle_notifications_also_display" msgid="6455360420411828133">"Aussi afficher sur"</string>
    <string name="gentle_notifications_display_status" msgid="2904115658980383410">"Barre d\'état"</string>
    <string name="gentle_notifications_display_lock" msgid="1395567209329239992">"Écran de verrouillage"</string>
    <string name="gentle_notifications_education" msgid="8713358646047345762">"Les notifications discrètes sont toujours silencieuses et s\'affichent toujours dans le volet déroulant"</string>
    <string name="gentle_notifications_display_summary_shade" msgid="6583107817329430916">"Afficher uniquement dans le volet déroulant"</string>
    <string name="gentle_notifications_display_summary_shade_lock" msgid="1434426811760016414">"S\'affiche dans le volet déroulant et sur l\'écran de verrouillage"</string>
    <string name="gentle_notifications_display_summary_shade_status" msgid="6113566548809874319">"S\'affiche dans le volet déroulant et dans la barre d\'état"</string>
    <string name="gentle_notifications_display_summary_shade_status_lock" msgid="4222628772925544654">"S\'affiche dans le volet déroulant, dans la barre d\'état et sur l\'écran de verrouillage"</string>
    <string name="notification_pulse_title" msgid="1905382958860387030">"Faire clignoter le voyant"</string>
    <string name="lock_screen_notifications_title" msgid="7604704224172951090">"Écran de verrouillage"</string>
    <string name="lockscreen_bypass_title" msgid="3077831331856929085">"Ignorer l\'écran de verrouillage"</string>
    <string name="lockscreen_bypass_summary" msgid="2767475923650816867">"Après le déverr. par rec. faciale, aller au dernier écran util."</string>
    <string name="keywords_lockscreen_bypass" msgid="250300001805572693">"Écran de verrouillage, écran verrouillé, ignorer, contourner"</string>
    <string name="locked_work_profile_notification_title" msgid="8327882003361551992">"Lorsque le profil professionnel est verrouillé"</string>
    <string name="lock_screen_notifs_title" msgid="3812061224136552712">"Notifications sur l\'écran verrouillé"</string>
    <string name="lock_screen_notifs_show_all" msgid="5848645268278883539">"Afficher les notifications d\'alerte et silencieuses"</string>
    <string name="lock_screen_notifs_show_alerting" msgid="3085615237751195449">"Afficher seulement les notifications d\'alerte"</string>
    <string name="lock_screen_notifs_show_none" msgid="3357167536259901686">"Ne pas afficher les notifications"</string>
    <string name="lock_screen_notifs_redact" msgid="3942294440983226225">"Notifications sensibles"</string>
    <string name="lock_screen_notifs_redact_summary" msgid="3095153536179931941">"Afficher le contenu sensible lorsque l\'écran est verrouillé"</string>
    <string name="lock_screen_notifs_redact_work" msgid="6777821963954035608">"Notifications sensibles du profil professionnel"</string>
    <string name="lock_screen_notifs_redact_work_summary" msgid="2179290697692276201">"Afficher le contenu sensible du profil professionnel lorsque l\'écran est verrouillé"</string>
    <string name="lock_screen_notifications_summary_show" msgid="6407527697810672847">"Afficher tout le contenu des notifications"</string>
    <string name="lock_screen_notifications_summary_hide" msgid="1133085507139112569">"Affich. contenu sensible seulement quand verrouillé"</string>
    <string name="lock_screen_notifications_summary_disable" msgid="859628910427886715">"N\'afficher aucune notification"</string>
    <string name="lock_screen_notifications_interstitial_message" msgid="3143593517597479937">"Que souhaitez-vous afficher sur l\'écran de verrouillage?"</string>
    <string name="lock_screen_notifications_interstitial_title" msgid="709573564312902481">"Écran de verrouillage"</string>
    <string name="lock_screen_notifications_summary_show_profile" msgid="835870815661120772">"Afficher tout le contenu des notif. professionn."</string>
    <string name="lock_screen_notifications_summary_hide_profile" msgid="2005907007779384635">"Masquer le contenu professionnel sensible"</string>
    <string name="lock_screen_notifications_interstitial_message_profile" msgid="8307705621027472346">"Lorsque votre appareil est verrouillé, comment voulez-vous que les notifications de profil s\'affichent?"</string>
    <string name="lock_screen_notifications_interstitial_title_profile" msgid="3169806586032521333">"Notifications de profil"</string>
    <string name="notifications_title" msgid="8086372779371204971">"Notifications"</string>
    <string name="app_notifications_title" msgid="5810577805218003760">"Notifications de l\'appli"</string>
    <string name="notification_channel_title" msgid="2260666541030178452">"Catégorie de notifications"</string>
    <string name="notification_group_title" msgid="7180506440133859601">"Groupe de notifications"</string>
    <string name="notification_importance_title" msgid="4368578960344731828">"Comportement"</string>
    <string name="notification_importance_unspecified" msgid="6622173510486113958">"Autoriser le son"</string>
    <string name="notification_importance_blocked" msgid="7938180808339386300">"Ne jamais afficher les notifications"</string>
    <string name="notification_importance_min" msgid="9054819132085066824">"Affichage silencieux et réduction"</string>
    <string name="notification_importance_low" msgid="2445139943005315690">"Affichage silencieux"</string>
    <string name="notification_importance_default" msgid="5958338024601957516">"Émettre un son"</string>
    <string name="notification_importance_high" msgid="2082429479238228527">"Alerte sonore et affichage à l\'écran"</string>
    <string name="notification_importance_high_silent" msgid="2667033773703765252">"Afficher sur l\'écran"</string>
    <string name="notification_importance_min_title" msgid="5024538864029341539">"Réduire"</string>
    <string name="notification_importance_low_title" msgid="8131254047772814309">"Moyenne"</string>
    <string name="notification_importance_default_title" msgid="9120383978536089489">"Élevée"</string>
    <string name="notification_importance_high_title" msgid="8792310396497954857">"Afficher sur l\'écran"</string>
    <string name="notification_block_title" msgid="1366361048463539674">"Bloquer"</string>
    <string name="notification_silence_title" msgid="6986752165900591125">"Mode silencieux"</string>
    <string name="notification_alert_title" msgid="2267584776990348784">"Alertes"</string>
    <string name="allow_interruption" msgid="7136150018111848721">"Autoriser les interruptions"</string>
    <string name="allow_interruption_summary" msgid="7870159391333957050">"Autoriser l\'application à émettre des sons, à vibrer et à afficher des notifications à l\'écran"</string>
    <string name="notification_channel_summary_min" msgid="2965790706738495761">"Dans le volet déroulant, afficher les notifications sur une seule ligne"</string>
    <string name="notification_channel_summary_low" msgid="7050068866167282765">"Vous aider à vous concentrer, sans son ni vibration"</string>
    <string name="notification_channel_summary_default" msgid="5753454293847059695">"Attire votre attention à l\'aide de sons et de vibrations"</string>
    <string name="notification_channel_summary_high" msgid="7737315941884569891">"Lorsque l\'appareil est déverrouillé, afficher les notifications dans une bannière dans le haut de l\'écran"</string>
    <string name="notification_switch_label" msgid="6843075654538931025">"Afficher les notifications"</string>
    <string name="default_notification_assistant" msgid="8441022088918117445">"Notifications adaptatives"</string>
    <plurals name="notifications_sent_daily" formatted="false" msgid="6049014219388148161">
      <item quantity="one">~<xliff:g id="NUMBER_1">%d</xliff:g> notification par jour</item>
      <item quantity="other">~<xliff:g id="NUMBER_1">%d</xliff:g> notifications par jour</item>
    </plurals>
    <plurals name="notifications_sent_weekly" formatted="false" msgid="5096638662520720959">
      <item quantity="one">~<xliff:g id="NUMBER_1">%d</xliff:g> notification par semaine</item>
      <item quantity="other">~<xliff:g id="NUMBER_1">%d</xliff:g> notifications par semaine</item>
    </plurals>
    <string name="notifications_sent_never" msgid="1001964786456700536">"Jamais"</string>
    <string name="manage_notification_access_title" msgid="7510080164564944891">"Accès aux notifications"</string>
    <string name="work_profile_notification_access_blocked_summary" msgid="8748026238701253040">"L\'accès aux notifications du profil professionnel est bloqué"</string>
    <string name="manage_notification_access_summary_zero" msgid="2409912785614953348">"Les applications ne peuvent pas lire les notifications."</string>
    <plurals name="manage_notification_access_summary_nonzero" formatted="false" msgid="7930130030691218387">
      <item quantity="one">%d application peut lire les notifications</item>
      <item quantity="other">%d application peuvent lire les notifications</item>
    </plurals>
    <string name="notification_assistant_title" msgid="7531256823396529700">"Notifications adaptatives"</string>
    <string name="no_notification_assistant" msgid="2818970196806227480">"Aucun"</string>
    <string name="no_notification_listeners" msgid="3487091564454192821">"Aucune demande d\'accès aux notifications n\'a été envoyée pour les applications installées."</string>
    <string name="notification_assistant_security_warning_title" msgid="300600401595343861">"Autoriser <xliff:g id="SERVICE">%1$s</xliff:g> à accéder aux notifications?"</string>
    <string name="notification_assistant_security_warning_summary" msgid="5829972610310154776">"<xliff:g id="NOTIFICATION_ASSISTANT_NAME">%1$s</xliff:g> pourra lire toutes les notifications, y compris des données personnelles, telles que des noms de contacts et le texte des messages que vous recevez. Ce service pourra également masquer des notifications ou déclencher les boutons d\'action que celles-ci contiennent. \n\nCela permettra également à l\'application d\'activer et de désactiver la fonction Ne pas déranger et de modifier les paramètres connexes."</string>
    <string name="notification_listener_security_warning_title" msgid="5522924135145843279">"Autoriser <xliff:g id="SERVICE">%1$s</xliff:g> à accéder aux notifications?"</string>
    <string name="notification_listener_security_warning_summary" msgid="119203147791040151">"<xliff:g id="NOTIFICATION_LISTENER_NAME">%1$s</xliff:g> pourra lire toutes les notifications, y compris des données personnelles, telles que des noms de contacts et le texte des messages que vous recevez. Ce service pourra également masquer des notifications ou déclencher les boutons d\'action que celles-ci contiennent. \n\nCela permettra également à l\'application d\'activer et de désactiver la fonction Ne pas déranger et de modifier les paramètres connexes."</string>
    <string name="notification_listener_disable_warning_summary" msgid="6738915379642948000">"Si vous désactivez l\'accès aux notifications pour <xliff:g id="NOTIFICATION_LISTENER_NAME">%1$s</xliff:g>, l\'accès à la fonction Ne pas déranger peut également être désactivé."</string>
    <string name="notification_listener_disable_warning_confirm" msgid="8333442186428083057">"Désactiver"</string>
    <string name="notification_listener_disable_warning_cancel" msgid="8586417377104211584">"Annuler"</string>
    <string name="vr_listeners_title" msgid="1318901577754715777">"Services d\'assistance de réalité virtuelle"</string>
    <string name="no_vr_listeners" msgid="2689382881717507390">"Aucune demande d\'exécution en tant que services de soutien de réalité virtuelle n\'a été envoyée pour les applications installées."</string>
    <string name="vr_listener_security_warning_title" msgid="8309673749124927122">"Autoriser <xliff:g id="SERVICE">%1$s</xliff:g> à accéder au service de réalité virtuelle?"</string>
    <string name="vr_listener_security_warning_summary" msgid="6931541068825094653">"L\'écouteur « <xliff:g id="VR_LISTENER_NAME">%1$s</xliff:g> » pourra être exécuté lorsque vous utiliserez des applications en mode Réalité virtuelle."</string>
    <string name="display_vr_pref_title" msgid="8104485269504335481">"Lorsque l\'appareil est en mode RV"</string>
    <string name="display_vr_pref_low_persistence" msgid="5707494209944718537">"Réduire le flou (recommandé)"</string>
    <string name="display_vr_pref_off" msgid="2190091757123260989">"Réduire le scintillement"</string>
    <string name="picture_in_picture_title" msgid="5824849294270017113">"Incrustation d\'image"</string>
    <string name="picture_in_picture_empty_text" msgid="685224245260197779">"Aucune application installée n\'est compatible avec le mode d\'image incrusté"</string>
    <string name="picture_in_picture_keywords" msgid="8361318686701764690">"image incrustée, image dans image"</string>
    <string name="picture_in_picture_app_detail_title" msgid="4080800421316791732">"Incrustation d\'image"</string>
    <string name="picture_in_picture_app_detail_switch" msgid="1131910667023738296">"Autoriser l\'incrustation d\'image"</string>
    <string name="picture_in_picture_app_detail_summary" msgid="1264019085827708920">"Autorisez cette application à créer une fenêtre d\'incrustation d\'image lorsqu\'elle est ouverte ou après l\'avoir quittée (par exemple, pour continuer de regarder une vidéo). Cette fenêtre se superpose aux autres applications en cours d\'utilisation."</string>
    <string name="manage_zen_access_title" msgid="2611116122628520522">"Accès à Ne pas déranger"</string>
    <string name="zen_access_detail_switch" msgid="1188754646317450926">"Autoriser le mode Ne pas déranger"</string>
    <string name="zen_access_empty_text" msgid="8772967285742259540">"Aune application installée n\'a demandé l\'accès au mode « Ne pas déranger »"</string>
    <string name="loading_notification_apps" msgid="5031818677010335895">"Chargement des applications en cours..."</string>
    <string name="app_notifications_off_desc" msgid="8289223211387083447">"À votre demande, Android empêche les notifications de cette application de s\'afficher sur cet appareil"</string>
    <string name="channel_notifications_off_desc" msgid="9013011134681491778">"À votre demande, Android empêche cette catégorie de notifications de s\'afficher sur cet appareil"</string>
    <string name="channel_group_notifications_off_desc" msgid="2315252834146837470">"À votre demande, Android empêche ce groupe de notifications de s\'afficher sur cet appareil"</string>
    <string name="notification_channels" msgid="5346841743182627500">"Catégories"</string>
    <string name="notification_channels_other" msgid="5645317113885788226">"Autre"</string>
    <plurals name="notification_group_summary" formatted="false" msgid="3420621520561455358">
      <item quantity="one"><xliff:g id="COUNT_1">%d</xliff:g> catégorie</item>
      <item quantity="other"><xliff:g id="COUNT_1">%d</xliff:g> catégories</item>
    </plurals>
    <string name="no_channels" msgid="3077375508177744586">"Cette application n\'a publié aucune notification"</string>
    <string name="app_settings_link" msgid="8894946007543660906">"Paramètres supplémentaires dans l\'application"</string>
    <string name="app_notification_listing_summary_zero" msgid="8046168435207424440">"Activé pour toutes les applications"</string>
    <plurals name="app_notification_listing_summary_others" formatted="false" msgid="6709582776823665660">
      <item quantity="one">Désactivé pour <xliff:g id="COUNT_1">%d</xliff:g> application</item>
      <item quantity="other">Désactivé pour <xliff:g id="COUNT_1">%d</xliff:g> applications</item>
    </plurals>
    <plurals name="deleted_channels" formatted="false" msgid="8028574302599397935">
      <item quantity="one"><xliff:g id="COUNT_1">%d</xliff:g> catégorie supprimée</item>
      <item quantity="other"><xliff:g id="COUNT_1">%d</xliff:g> catégories supprimées</item>
    </plurals>
    <string name="notification_toggle_on" msgid="650145396718191048">"Activées"</string>
    <string name="notification_toggle_off" msgid="2142010737190671762">"Désactivées"</string>
    <string name="app_notification_block_title" msgid="4069351066849087649">"Tout bloquer"</string>
    <string name="app_notification_block_summary" msgid="4744020456943215352">"Ne jamais afficher ces notifications"</string>
    <string name="notification_content_block_title" msgid="5854232570963006360">"Afficher les notifications"</string>
    <string name="notification_content_block_summary" msgid="7746185794438882389">"Ne jamais afficher les notifications dans l\'ombre ou sur des appareils périphériques"</string>
    <string name="notification_badge_title" msgid="6370122441168519809">"Autoriser la pastille de notification"</string>
    <string name="notification_channel_badge_title" msgid="2240827899882847087">"Afficher le point de notification"</string>
    <string name="app_notification_override_dnd_title" msgid="7867458246395884830">"Ignorer le mode Ne pas déranger"</string>
    <string name="app_notification_override_dnd_summary" msgid="2612502099373472686">"Activer ces notifications même lorsque le mode Ne pas déranger est activé"</string>
    <string name="app_notification_visibility_override_title" msgid="3618860781666494595">"Écran de verrouillage"</string>
    <string name="app_notification_row_banned" msgid="5983655258784814773">"Bloqué"</string>
    <string name="app_notification_row_priority" msgid="7723839972982746568">"Priorité"</string>
    <string name="app_notification_row_sensitive" msgid="1809610030432329940">"Sensible"</string>
    <string name="app_notifications_dialog_done" msgid="3484067728568791014">"Terminé"</string>
    <string name="app_notification_importance_title" msgid="8002263131149345584">"Importance"</string>
    <string name="notification_show_lights_title" msgid="7671781299688190532">"Faire clignoter le voyant"</string>
    <string name="notification_vibrate_title" msgid="1646667807969755957">"Vibreur"</string>
    <string name="notification_channel_sound_title" msgid="3899212238513507941">"Son"</string>
    <string name="zen_mode_rule_delete_button" msgid="903658142711011617">"Supprimer"</string>
    <string name="zen_mode_rule_rename_button" msgid="4642843370946599164">"Renommer"</string>
    <string name="zen_mode_rule_name" msgid="5607736317244760638">"Nom de l\'horaire"</string>
    <string name="zen_mode_rule_name_hint" msgid="278109122579468433">"Entrez le nom de l\'horaire"</string>
    <string name="zen_mode_rule_name_warning" msgid="3856485373110366912">"Ce nom d\'horaire existe déjà"</string>
    <string name="zen_mode_add_rule" msgid="7459154136384467057">"Ajouter"</string>
    <string name="zen_mode_add_event_rule" msgid="4454759739839069898">"Ajouter un horaire d\'événement"</string>
    <string name="zen_mode_add_time_rule" msgid="7890557350868257760">"Ajouter un horaire temporel"</string>
    <string name="zen_mode_delete_rule" msgid="8055032645990309096">"Supprimer l\'horaire"</string>
    <string name="zen_mode_choose_rule_type" msgid="40993242338494595">"Choisir le type d\'horaire"</string>
    <string name="zen_mode_delete_rule_confirmation" msgid="6237882294348570283">"Supprimer la règle « <xliff:g id="RULE">%1$s</xliff:g> »?"</string>
    <string name="zen_mode_delete_rule_button" msgid="4248741120307752294">"Supprimer"</string>
    <string name="zen_mode_rule_type_unknown" msgid="3049377282766700600">"Inconnue"</string>
    <string name="zen_mode_app_set_behavior" msgid="1534429320064381355">"Ces paramètres ne peuvent pas être modifiés pour le moment. Une application (<xliff:g id="APP_NAME">%1$s</xliff:g>) a activé un mode Ne pas déranger personnalisé."</string>
    <string name="zen_mode_unknown_app_set_behavior" msgid="2558968232814237874">"Ces paramètres ne peuvent pas être modifiés pour le moment. Une application a activé un mode Ne pas déranger personnalisé."</string>
    <string name="zen_mode_qs_set_behavior" msgid="6200424436456086312">"Ces paramètres ne peuvent pas être modifiés pour le moment. Un mode Ne pas déranger personnalisé a été activé manuellement."</string>
    <string name="zen_schedule_rule_type_name" msgid="6163149826036287324">"Heure"</string>
    <string name="zen_schedule_rule_enabled_toast" msgid="3379499360390382259">"Règle automatique pour activer le mode « Ne pas déranger » à certaines heures"</string>
    <string name="zen_event_rule_type_name" msgid="6503468472212606158">"Événement"</string>
    <string name="zen_event_rule_enabled_toast" msgid="6910577623330811480">"Règle automatique pour activer le mode « Ne pas déranger » pendant les événements indiqués"</string>
    <string name="zen_mode_event_rule_calendar" msgid="8787906563769067418">"Pendant les événements suivants :"</string>
    <string name="zen_mode_event_rule_summary_calendar_template" msgid="5135844750232403975">"Pendant les événements de l\'agenda <xliff:g id="CALENDAR">%1$s</xliff:g>"</string>
    <string name="zen_mode_event_rule_summary_any_calendar" msgid="4936646399126636358">"tout agenda"</string>
    <string name="zen_mode_event_rule_summary_reply_template" msgid="6590671260829837157">"Si la réponse est : <xliff:g id="REPLY">%1$s</xliff:g>"</string>
    <string name="zen_mode_event_rule_calendar_any" msgid="6485568415998569885">"Tout agenda"</string>
    <string name="zen_mode_event_rule_reply" msgid="5166322024212403739">"Si la réponse est"</string>
    <string name="zen_mode_event_rule_reply_any_except_no" msgid="8868873496008825961">"Oui, Peut-être ou Sans réponse"</string>
    <string name="zen_mode_event_rule_reply_yes_or_maybe" msgid="2769656565454495824">"Oui ou Peut-être"</string>
    <string name="zen_mode_event_rule_reply_yes" msgid="1003598835878784659">"Oui"</string>
    <string name="zen_mode_rule_not_found_text" msgid="8963662446092059836">"Règle non trouvée."</string>
    <string name="zen_mode_rule_summary_enabled_combination" msgid="976098744828219297">"Mode <xliff:g id="MODE">%1$s</xliff:g> activé"</string>
    <string name="zen_mode_rule_summary_provider_combination" msgid="2101201392041867409">"<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="3195058680641389948">"Jours"</string>
    <string name="zen_mode_schedule_rule_days_none" msgid="4954143628634166317">"Aucun"</string>
    <string name="zen_mode_schedule_rule_days_all" msgid="146511166522076034">"Tous les jours"</string>
    <string name="zen_mode_schedule_alarm_title" msgid="767054141267122030">"L\'alarme peut remplacer l\'heure de fin"</string>
    <string name="zen_mode_schedule_alarm_summary" msgid="1673667979187593693">"L\'horaire sera désactivé lorsque l\'alarme sonnera"</string>
    <string name="zen_mode_custom_behavior_title" msgid="1148856394866360783">"Comportement du mode Ne pas déranger"</string>
    <string name="zen_mode_custom_behavior_summary_default" msgid="7750128187766412708">"Utiliser les paramètres par défaut"</string>
    <string name="zen_mode_custom_behavior_summary" msgid="7458258833216726120">"Créer des paramètres personnalisés pour cet horaire"</string>
    <string name="zen_mode_custom_behavior_category_title" msgid="4070854282812755247">"Pour « <xliff:g id="SCHEDULE_NAME">%1$s</xliff:g> »"</string>
    <string name="summary_divider_text" msgid="7228986578690919294">", "</string>
    <string name="summary_range_symbol_combination" msgid="5695218513421897027">"<xliff:g id="START">%1$s</xliff:g> à <xliff:g id="END">%2$s</xliff:g>"</string>
    <string name="summary_range_verbal_combination" msgid="8467306662961568656">"De <xliff:g id="START">%1$s</xliff:g> à <xliff:g id="END">%2$s</xliff:g>"</string>
    <string name="zen_mode_calls" msgid="4769117032399813012">"Autoriser les appels"</string>
    <string name="zen_mode_calls_title" msgid="2905770092665685857">"Appels"</string>
    <string name="zen_mode_calls_footer" msgid="2002070641802102110">"Pour vous assurer que les appels autorisés émettent un son, vérifiez si votre appareil est réglé pour sonner, vibrer ou rester silencieux."</string>
    <string name="zen_mode_custom_calls_footer" msgid="4764756801941329281">"Pendant « <xliff:g id="SCHEDULE_NAME">%1$s</xliff:g> », les appels entrants sont bloqués. Vous pouvez régler les paramètres pour permettre à vos amis, à votre famille ou à d\'autres contacts de vous joindre."</string>
    <string name="zen_mode_starred_contacts_title" msgid="1848464279786960190">"Contacts marqués d\'une étoile"</string>
    <plurals name="zen_mode_starred_contacts_summary_additional_contacts" formatted="false" msgid="500105380255018671">
      <item quantity="one"><xliff:g id="NUM_PEOPLE">%d</xliff:g> autre personne</item>
      <item quantity="other"><xliff:g id="NUM_PEOPLE">%d</xliff:g> autres personnes</item>
    </plurals>
    <string name="zen_mode_messages" msgid="6406892731721926170">"Autoriser les messages"</string>
    <string name="zen_mode_messages_footer" msgid="2616568463646674149">"Pour vous assurer que les messages autorisés émettent un son, vérifiez si votre appareil est réglé pour sonner, vibrer ou rester silencieux."</string>
    <string name="zen_mode_custom_messages_footer" msgid="800067279796770040">"Pendant « <xliff:g id="SCHEDULE_NAME">%1$s</xliff:g> », les messages entrants sont bloqués. Vous pouvez régler les paramètres pour permettre à vos amis, à votre famille ou à d\'autres contacts de vous joindre."</string>
    <string name="zen_mode_messages_title" msgid="7325983674655986445">"Applis de message texte et multimédia"</string>
    <string name="zen_mode_from_anyone" msgid="2638322015361252161">"De tout le monde"</string>
    <string name="zen_mode_from_contacts" msgid="2232335406106711637">"Des contacts seulement"</string>
    <string name="zen_mode_from_starred" msgid="2678345811950997027">"Des contacts favoris seulement"</string>
    <string name="zen_calls_summary_starred_repeat" msgid="4046151920710059778">"Des contacts marqués d\'une étoile et des appels répétés"</string>
    <string name="zen_calls_summary_contacts_repeat" msgid="1528716671301999084">"Des contacts et des appels répétés"</string>
    <string name="zen_calls_summary_repeat_only" msgid="7105261473107715445">"Seulement des appels répétés"</string>
    <string name="zen_mode_from_none" msgid="8219706639954614136">"Aucun"</string>
    <string name="zen_mode_from_none_calls" msgid="7705112158761351044">"Ne pas autoriser les appels"</string>
    <string name="zen_mode_from_none_messages" msgid="3300937656725582608">"Ne pas autoriser les messages"</string>
    <string name="zen_mode_alarms" msgid="6510378757005935647">"Autoriser les alarmes"</string>
    <string name="zen_mode_alarms_list" msgid="1090332840207025714">"alarmes"</string>
    <string name="zen_mode_media" msgid="4529187475698084320">"Faire jouer les sons des médias"</string>
    <string name="zen_mode_media_list" msgid="5483540766397328038">"média"</string>
    <string name="zen_mode_system" msgid="236278770843463810">"Autoriser les sons des touches"</string>
    <string name="zen_mode_system_list" msgid="6996104733185177115">"sons des touches"</string>
    <string name="zen_mode_reminders" msgid="5445657061499098675">"Autoriser les rappels"</string>
    <string name="zen_mode_reminders_list" msgid="2853975802240340190">"rappels"</string>
    <string name="zen_mode_events" msgid="6154853744271591007">"Autoriser les événements"</string>
    <string name="zen_mode_bypassing_apps" msgid="5493729796981237881">"Autoriser les applications à ignorer le mode Ne pas déranger"</string>
    <string name="zen_mode_bypassing_apps_title" msgid="2072590348079644482">"Exceptions des applications"</string>
    <plurals name="zen_mode_bypassing_apps_subtext" formatted="false" msgid="3726913165356014788">
      <item quantity="one">Les notifications de <xliff:g id="NUMBER">%1$d</xliff:g> application peuvent ignorer le mode Ne pas déranger</item>
      <item quantity="other">Les notifications de <xliff:g id="NUMBER">%1$d</xliff:g> applications peuvent ignorer le mode Ne pas déranger</item>
    </plurals>
    <string name="zen_mode_events_list" msgid="5571368229052715098">"événements"</string>
    <string name="zen_mode_all_callers" msgid="2378065871253871057">"n\'importe qui"</string>
    <string name="zen_mode_contacts_callers" msgid="5569804103920394175">"contacts"</string>
    <string name="zen_mode_starred_callers" msgid="1023167821338514140">"contacts marqués d\'une étoile"</string>
    <string name="zen_mode_repeat_callers" msgid="5019521886428322131">"Appelants fréquents"</string>
    <string name="zen_mode_repeat_callers_list" msgid="2529895519653237330">"appelants fréquents"</string>
    <string name="zen_mode_repeat_callers_title" msgid="8553876328249671783">"Autoriser les appels répétés"</string>
    <string name="zen_mode_calls_summary_one" msgid="1711737896388108388">"Autoriser les appels de <xliff:g id="CALLER_TYPE">%1$s</xliff:g>"</string>
    <string name="zen_mode_calls_summary_two" msgid="8476861928783654064">"Autoriser les appels de <xliff:g id="CALLER_TYPE">%1$s</xliff:g> et de <xliff:g id="CALLERT_TPYE">%2$s</xliff:g>"</string>
    <string name="zen_mode_repeat_callers_summary" msgid="239685342222975733">"Si la même personne appelle deux fois en <xliff:g id="MINUTES">%d</xliff:g> minutes, autoriser le deuxième appel"</string>
    <string name="zen_mode_behavior_summary_custom" msgid="168127313238020146">"Personnalisé"</string>
    <string name="zen_mode_when" msgid="2767193283311106373">"Activation auto"</string>
    <string name="zen_mode_when_never" msgid="8809494351918405602">"Jamais"</string>
    <string name="zen_mode_when_every_night" msgid="3122486110091921009">"Tous les soirs"</string>
    <string name="zen_mode_when_weeknights" msgid="8354070633893273783">"Les soirs de semaine"</string>
    <string name="zen_mode_start_time" msgid="8102602297273744441">"Heure de début"</string>
    <string name="zen_mode_end_time" msgid="8774327885892705505">"Heure de fin"</string>
    <string name="zen_mode_end_time_next_day_summary_format" msgid="4201521691238728701">"<xliff:g id="FORMATTED_TIME">%s</xliff:g> le lendemain"</string>
    <string name="zen_mode_summary_alarms_only_indefinite" msgid="2061973221027570123">"Ne recevoir que les alarmes sans limite de temps"</string>
    <plurals name="zen_mode_summary_alarms_only_by_minute" formatted="false" msgid="6122003583875424601">
      <item quantity="one">Alarmes seulement pendant <xliff:g id="DURATION">%1$d</xliff:g> minute, jusqu\'à <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g></item>
      <item quantity="other">Alarmes seulement pendant <xliff:g id="DURATION">%1$d</xliff:g> minutes, jusqu\'à <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g></item>
    </plurals>
    <plurals name="zen_mode_summary_alarms_only_by_hour" formatted="false" msgid="2407703455581767748">
      <item quantity="one">Alarmes seulement pendant <xliff:g id="DURATION">%1$d</xliff:g> heure, jusqu\'à <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g></item>
      <item quantity="other">Alarmes seulement pendant <xliff:g id="DURATION">%1$d</xliff:g> heures, jusqu\'à <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g></item>
    </plurals>
    <string name="zen_mode_summary_alarms_only_by_time" msgid="7465525754879341907">"Ne recevoir que les alarmes jusqu\'à <xliff:g id="FORMATTEDTIME">%1$s</xliff:g>"</string>
    <string name="zen_mode_summary_always" msgid="6172985102689237703">"Activer le mode Toujours interrompre"</string>
    <string name="zen_mode_screen_on" msgid="8774571998575673502">"Lorsque l\'écran est activé"</string>
    <string name="zen_mode_screen_on_summary" msgid="2208664848367443505">"Autoriser les notif. désactivées par le mode Ne pas déranger à s\'afficher à l\'écran et à présenter une icône dans la barre d\'état"</string>
    <string name="zen_mode_screen_off" msgid="3144446765110327937">"Lorsque l\'écran est éteint"</string>
    <string name="zen_mode_screen_off_summary" msgid="7430034620565812258">"Autoriser les notifications désactivées par le mode Ne pas déranger d\'activer l\'écran et de faire clignoter le voyant"</string>
    <string name="zen_mode_screen_off_summary_no_led" msgid="2826121465026642017">"Autoriser les notifications désactivées par le mode Ne pas déranger d\'activer l\'écran"</string>
    <string name="notification_app_settings_button" msgid="6685640230371477485">"Paramètres de notification"</string>
    <string name="suggestion_button_text" msgid="3275010948381252006">"OK"</string>
    <string name="device_feedback" msgid="3238056036766293294">"Commentaires sur cet appareil"</string>
    <string name="restr_pin_enter_admin_pin" msgid="1085834515677448072">"Entrez le NIP d\'administrateur"</string>
    <string name="switch_on_text" msgid="1124106706920572386">"Activé"</string>
    <string name="switch_off_text" msgid="1139356348100829659">"Désactivé"</string>
    <string name="screen_pinning_title" msgid="2292573232264116542">"Épinglage à l\'écran"</string>
    <string name="screen_pinning_description" msgid="1110847562111827766">"Lorsque ce paramètre est activé, vous pouvez utiliser l\'épinglage pour garder l\'écran actuel actif.\n\nPour épingler l\'écran :\n\n1. Assurez-vous que l\'épinglage d\'écran est activé\n\n2. Ouvrez Aperçu\n\n3. Touchez l\'icône de l\'application dans le haut de l\'écran, puis touchez Épingler"</string>
    <string name="screen_pinning_unlock_pattern" msgid="8282268570060313339">"Demander le schéma de déverrouillage avant d\'annuler l\'épinglage"</string>
    <string name="screen_pinning_unlock_pin" msgid="8757588350454795286">"Demander le NIP avant d\'annuler l\'épinglage"</string>
    <string name="screen_pinning_unlock_password" msgid="2514079566873826434">"Demander le mot de passe avant d\'annuler l\'épinglage"</string>
    <string name="screen_pinning_unlock_none" msgid="3814188275713871856">"Verrouiller l\'écran après l\'annulation de l\'épinglage"</string>
    <string name="opening_paragraph_delete_profile_unknown_company" msgid="2232461523882170874">"Le profil professionnel est géré par :"</string>
    <string name="managing_admin" msgid="8843802210377459055">"Géré par <xliff:g id="ADMIN_APP_LABEL">%s</xliff:g>"</string>
    <string name="experimental_preference" msgid="7083015446690681376">"(Expérimentale)"</string>
    <string name="encryption_interstitial_header" msgid="468015813904595613">"Démarrage sécurisé"</string>
    <string name="encryption_continue_button" msgid="1121880322636992402">"Continuer"</string>
    <string name="encryption_interstitial_message_pin" msgid="2317181134653424679">"Pour améliorer la protection de cet appareil, vous pouvez exiger l\'entrée du NIP avant le démarrage. L\'appareil ne reçoit pas d\'appels, de messages ni de notifications, y compris les alertes, tant qu\'il n\'a pas démarré. \n\nCette fonctionnalité permet de protéger les données en cas de perte ou de vol de l\'appareil. Exiger le NIP pour démarrer l\'appareil?"</string>
    <string name="encryption_interstitial_message_pattern" msgid="7081249914068568570">"Pour améliorer la protection de cet appareil, vous pouvez exiger l\'entrée du schéma avant le démarrage. L\'appareil ne reçoit pas d\'appels, de messages ni de notifications, y compris les alertes, tant qu\'il n\'a pas démarré. \n\nCette fonctionnalité permet de protéger les données en cas de perte ou de vol de l\'appareil. Exiger le schéma pour démarrer l\'appareil?"</string>
    <string name="encryption_interstitial_message_password" msgid="7796567133897436443">"Pour améliorer la protection de cet appareil, vous pouvez exiger l\'entrée du mot de passe avant le démarrage. L\'appareil ne reçoit pas d\'appels, de messages ni de notifications, y compris les alertes, tant qu\'il n\'a pas démarré. \n\nCette fonctionnalité permet de protéger les données en cas de perte ou de vol de l\'appareil. Exiger un mot de passe pour démarrer l\'appareil?"</string>
    <string name="encryption_interstitial_message_pin_for_fingerprint" msgid="4550632760119547492">"Vous pouvez ajouter un niveau de protection pour le déverrouillage de cet appareil en exigeant votre NIP avant que l\'appareil ne démarre, en plus de la lecture de votre empreinte digitale. L\'appareil ne peut pas recevoir d\'appel, de message, de notification, ni d\'alarme tant qu\'il n\'a pas démarré.\n\nCela permet de protéger les données de vos appareils en cas de perte ou de vol. Exiger le NIP pour démarrer l\'appareil?"</string>
    <string name="encryption_interstitial_message_pattern_for_fingerprint" msgid="932184823193006087">"Vous pouvez ajouter un niveau de protection pour le déverrouillage de cet appareil en exigeant votre schéma avant que l\'appareil ne démarre, en plus de la lecture de votre empreinte digitale. L\'appareil ne peut pas recevoir d\'appel, de message, de notification, ni d\'alarme tant qu\'il n\'a pas démarré.\n\nCela permet de protéger les données de vos appareils en cas de perte ou de vol. Exiger le schéma pour démarrer l\'appareil?"</string>
    <string name="encryption_interstitial_message_password_for_fingerprint" msgid="5560954719370251702">"Vous pouvez ajouter un niveau de protection pour le déverrouillage de cet appareil en exigeant votre mot de passe avant que l\'appareil ne démarre, en plus de la lecture de votre empreinte digitale. L\'appareil ne peut pas recevoir d\'appel, de message, de notification, ni d\'alarme tant qu\'il n\'a pas démarré.\n\nCela permet de protéger les données de vos appareils en cas de perte ou de vol. Exiger un mot de passe pour démarrer l\'appareil?"</string>
    <string name="encryption_interstitial_message_pin_for_face" msgid="2017438765366716760">"Vous pouvez ajouter un niveau de protection pour le déverrouillage de cet appareil en exigeant votre NIP avant que l\'appareil ne démarre, en plus de la reconnaissance du visage. L\'appareil ne peut pas recevoir d\'appel, de message, de notification, ni d\'alarme tant qu\'il n\'a pas démarré.\n\nCela permet de protéger les données de vos appareils en cas de perte ou de vol. Exiger le NIP pour démarrer l\'appareil?"</string>
    <string name="encryption_interstitial_message_pattern_for_face" msgid="3551827507967661552">"Vous pouvez ajouter un niveau de protection pour le déverrouillage de cet appareil en exigeant votre schéma avant que l\'appareil ne démarre, en plus de la reconnaissance du visage. L\'appareil ne peut pas recevoir d\'appel, de message, de notification, ni d\'alarme tant qu\'il n\'a pas démarré.\n\nCela permet de protéger les données de vos appareils en cas de perte ou de vol. Exiger le schéma pour démarrer l\'appareil?"</string>
    <string name="encryption_interstitial_message_password_for_face" msgid="3452793542112093614">"Vous pouvez ajouter un niveau de protection pour le déverrouillage de cet appareil en exigeant votre mot de passe avant que l\'appareil ne démarre, en plus de la reconnaissance du visage. L\'appareil ne peut alors pas recevoir d\'appels ni de messages, ni émettre de notifications, y compris des alarmes, tant qu\'il n\'a pas démarré.\n\nCela permet de protéger les données de vos appareils en cas de perte ou de vol. Exiger le mot de passe pour démarrer l\'appareil?"</string>
    <string name="encryption_interstitial_yes" msgid="4439509435889513411">"Oui"</string>
    <string name="encryption_interstitial_no" msgid="8935031349097025137">"Non"</string>
    <string name="restricted_true_label" msgid="4761453839409220473">"Restreinte"</string>
    <string name="restricted_false_label" msgid="3279282180297058755">"Cette application peut utiliser la pile en arrière-plan"</string>
    <string name="encrypt_talkback_dialog_require_pin" msgid="8299960550048989807">"Exiger le NIP?"</string>
    <string name="encrypt_talkback_dialog_require_pattern" msgid="1499790256154146639">"Exiger le schéma?"</string>
    <string name="encrypt_talkback_dialog_require_password" msgid="8841994614218049215">"Exiger le mot de passe?"</string>
    <string name="encrypt_talkback_dialog_message_pin" msgid="7582096542997635316">"Lorsque vous entrez votre NIP pour démarrer cet appareil, les services d\'accessibilité comme <xliff:g id="SERVICE">%1$s</xliff:g> ne seront pas accessibles immédiatement."</string>
    <string name="encrypt_talkback_dialog_message_pattern" msgid="2020083142199612743">"Lorsque vous entrez votre schéma pour démarrer cet appareil, les services d\'accessibilité comme <xliff:g id="SERVICE">%1$s</xliff:g> ne seront pas accessibles immédiatement."</string>
    <string name="encrypt_talkback_dialog_message_password" msgid="4155875981789127796">"Lorsque vous entrez votre mot de passe pour démarrer cet appareil, les services d\'accessibilité comme <xliff:g id="SERVICE">%1$s</xliff:g> ne seront pas accessibles immédiatement."</string>
    <string name="direct_boot_unaware_dialog_message" msgid="2433632805847985867">"Remarque : Si vous redémarrez votre téléphone et que vous avez défini un verrouillage de l\'écran, cette application ne peut pas démarrer tant que vous n\'avez pas déverrouillé votre téléphone"</string>
    <string name="imei_information_title" msgid="8499085421609752290">"Information concernant le code IIEM"</string>
    <string name="imei_information_summary" msgid="2074095606556565233">"Information concernant le code IIEM"</string>
    <string name="slot_number" msgid="3762676044904653577">"(Fente <xliff:g id="SLOT_NUM">%1$d</xliff:g>)"</string>
    <string name="launch_by_default" msgid="1840761193189009248">"Ouvert par défaut"</string>
    <string name="app_launch_domain_links_title" msgid="1160925981363706090">"Ouverture des liens"</string>
    <string name="app_launch_open_domain_urls_title" msgid="8914721351596745701">"Ouvrir les liens compatibles"</string>
    <string name="app_launch_open_domain_urls_summary" msgid="5367573364240712217">"Ouvrir sans demander"</string>
    <string name="app_launch_supported_domain_urls_title" msgid="8250695258211477480">"Liens compatibles"</string>
    <string name="app_launch_other_defaults_title" msgid="2516812499807835178">"Autres défauts"</string>
    <string name="storage_summary_format" msgid="5419902362347539755">"<xliff:g id="SIZE">%1$s</xliff:g> utilisé dans <xliff:g id="STORAGE_TYPE">%2$s</xliff:g>"</string>
    <string name="storage_type_internal" msgid="6042049833565674948">"Mémoire stockage interne"</string>
    <string name="storage_type_external" msgid="7738894330670001898">"Stockage externe"</string>
    <string name="data_summary_format" msgid="6213211533341068366">"<xliff:g id="SIZE">%1$s</xliff:g> utilisés depuis <xliff:g id="DATE">%2$s</xliff:g>"</string>
    <string name="storage_used" msgid="7128074132917008743">"Espace de stockage utilisé"</string>
    <string name="change" msgid="6657848623929839991">"Modifier"</string>
    <string name="change_storage" msgid="600475265207060436">"Modifier type de stockage"</string>
    <string name="notifications_label" msgid="2872668710589600731">"Notifications"</string>
    <string name="notifications_enabled" msgid="6983396130566021385">"Activé"</string>
    <string name="notifications_enabled_with_info" msgid="5669544704839269901">"<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="1262114548434938079">"Désactivé"</string>
    <string name="notifications_partly_blocked" msgid="592071133950126656">"<xliff:g id="COUNT_0">%1$d</xliff:g> catégories sur <xliff:g id="COUNT_1">%2$d</xliff:g> sont désactivées"</string>
    <string name="notifications_silenced" msgid="4728603513072110381">"Désactivées"</string>
    <string name="notifications_redacted" msgid="4493588975742803160">"Aucun contenu sensible sur l\'écran de verrouillage"</string>
    <string name="notifications_hidden" msgid="3619610536038757468">"Pas sur l\'écran de verrouillage"</string>
    <string name="notifications_priority" msgid="1066342037602085552">"Ignorer le mode Ne pas déranger"</string>
    <string name="notifications_summary_divider" msgid="9013807608804041387">" / "</string>
    <string name="notification_summary_level" msgid="2726571692704140826">"Niveau %d"</string>
    <string name="notification_summary_channel" msgid="5831124672372023524">"<xliff:g id="CHANNEL_NAME">%1$s</xliff:g> • <xliff:g id="GROUP_NAME">%2$s</xliff:g>"</string>
    <plurals name="notifications_categories_off" formatted="false" msgid="5583365573683409754">
      <item quantity="one"><xliff:g id="COUNT_1">%d</xliff:g> catégorie désactivée</item>
      <item quantity="other"><xliff:g id="COUNT_1">%d</xliff:g> catégories désactivées</item>
    </plurals>
    <plurals name="permissions_summary" formatted="false" msgid="6402730318075959117">
      <item quantity="one"><xliff:g id="COUNT_1">%d</xliff:g> autorisations accordées</item>
      <item quantity="other"><xliff:g id="COUNT_1">%d</xliff:g> autorisations accordées</item>
    </plurals>
    <plurals name="runtime_permissions_summary" formatted="false" msgid="1564663886246010959">
      <item quantity="one"><xliff:g id="COUNT_2">%d</xliff:g> autorisation accordée sur <xliff:g id="COUNT_3">%d</xliff:g></item>
      <item quantity="other"><xliff:g id="COUNT_2">%d</xliff:g> autorisations accordées sur <xliff:g id="COUNT_3">%d</xliff:g></item>
    </plurals>
    <plurals name="runtime_permissions_additional_count" formatted="false" msgid="931276038884210752">
      <item quantity="one"><xliff:g id="COUNT_1">%d</xliff:g> autorisation supplémentaire</item>
      <item quantity="other"><xliff:g id="COUNT_1">%d</xliff:g> autorisations supplémentaires</item>
    </plurals>
    <string name="runtime_permissions_summary_no_permissions_granted" msgid="1679758182657005375">"Aucune autorisation accordée"</string>
    <string name="runtime_permissions_summary_no_permissions_requested" msgid="7655100570513818534">"Aucune autorisation demandée"</string>
    <string name="filter_all_apps" msgid="1988403195820688644">"Toutes les applications"</string>
    <string name="filter_enabled_apps" msgid="5395727306799456250">"Applications installées"</string>
    <string name="filter_instant_apps" msgid="574277769963965565">"Applications instantanées"</string>
    <string name="filter_personal_apps" msgid="3277727374174355971">"Personnel"</string>
    <string name="filter_work_apps" msgid="24519936790795574">"Travail"</string>
    <string name="filter_notif_all_apps" msgid="2299049859443680242">"Applications : toutes"</string>
    <string name="filter_notif_blocked_apps" msgid="3383043508771300704">"Désactivées"</string>
    <string name="filter_notif_urgent_channels" msgid="3972473613117159653">"Catégories : importance urgente"</string>
    <string name="filter_notif_low_channels" msgid="4128487387390004604">"Catégories : importance faible"</string>
    <string name="filter_notif_blocked_channels" msgid="5880190882221644289">"Catégories : notif. bloquées"</string>
    <string name="filter_notif_dnd_channels" msgid="1817930848881696728">"Catégories : ignorent « Ne pas déranger »"</string>
    <string name="advanced_apps" msgid="4812975097124803873">"Paramètres avancés"</string>
    <string name="configure_apps" msgid="6685680790825882528">"Configurer les applications"</string>
    <string name="unknown_app" msgid="5275921288718717656">"Application inconnue"</string>
    <string name="app_permissions" msgid="5584182129908141622">"Gestionnaire des autorisations"</string>
    <string name="app_permissions_summary" msgid="5163974162150406324">"Applications qui utilisent <xliff:g id="APPS">%1$s</xliff:g>"</string>
    <string name="tap_to_wake" msgid="7211944147196888807">"Toucher pour réveiller"</string>
    <string name="tap_to_wake_summary" msgid="4341387904987585616">"Double-touchez l\'écran pour réveiller l\'appareil"</string>
    <string name="domain_urls_title" msgid="3132983644568821250">"Ouverture des liens"</string>
    <string name="domain_urls_summary_none" msgid="2639588015479657864">"Ne pas ouvrir les liens compatibles"</string>
    <string name="domain_urls_summary_one" msgid="3704934031930978405">"Ouvrir « <xliff:g id="DOMAIN">%s</xliff:g> »"</string>
    <string name="domain_urls_summary_some" msgid="3950089361819428455">"Ouvrir <xliff:g id="DOMAIN">%s</xliff:g> et d\'autres URL"</string>
    <string name="domain_urls_apps_summary_off" msgid="1833056772600031220">"Aucune application ouvrant des liens compatibles"</string>
    <plurals name="domain_urls_apps_summary_on" formatted="false" msgid="240214361240709399">
      <item quantity="one"><xliff:g id="COUNT">%d</xliff:g> application ouvrant des liens compatibles</item>
      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> applications ouvrant des liens compatibles</item>
    </plurals>
    <string name="app_link_open_always" msgid="2474058700623948148">"Ouvrir dans cette application"</string>
    <string name="app_link_open_ask" msgid="7800878430190575991">"Toujours demander"</string>
    <string name="app_link_open_never" msgid="3407647600352398543">"Ne pas ouvrir dans cette application"</string>
    <string name="default_apps_title" msgid="1660450272764331490">"Par défaut"</string>
    <string name="default_for_work" msgid="9152194239366247932">"Par déf. pour util. professionn."</string>
    <string name="assist_and_voice_input_title" msgid="1733165754793221197">"Assist. et entrée vocale"</string>
    <string name="default_assist_title" msgid="8868488975409247921">"Application d\'assistance"</string>
    <string name="assistant_security_warning_title" msgid="8673079231955467177">"Définir <xliff:g id="ASSISTANT_APP_NAME">%s</xliff:g> comme assistant?"</string>
    <string name="assistant_security_warning" msgid="8498726261327239136">"L\'assistant pourra accéder aux données des applications en cours d\'utilisation sur votre système, y compris les données visibles à l\'écran ou accessibles au sein des applications."</string>
    <string name="assistant_security_warning_agree" msgid="7710290206928033908">"J\'accepte"</string>
    <string name="assistant_security_warning_disagree" msgid="877419950830205913">"Je refuse"</string>
    <string name="choose_voice_input_title" msgid="975471367067718019">"Choisissez l\'entrée vocale"</string>
    <string name="default_browser_title" msgid="8101772675085814670">"Application de navigateur"</string>
    <string name="default_browser_title_none" msgid="2124785489953628553">"Aucun navigateur par défaut"</string>
    <string name="default_phone_title" msgid="282005908059637350">"Application de téléphonie"</string>
    <string name="default_app" msgid="6864503001385843060">"(Par défaut)"</string>
    <string name="system_app" msgid="9068313769550747372">"(Système)"</string>
    <string name="system_default_app" msgid="3091113402349739037">"(Valeurs par défaut du système)"</string>
    <string name="apps_storage" msgid="4353308027210435513">"Stockage des applications"</string>
    <string name="usage_access" msgid="5479504953931038165">"Accès aux données d\'utilisation"</string>
    <string name="permit_usage_access" msgid="4012876269445832300">"Autoriser l\'accès aux données d\'utilisation"</string>
    <string name="app_usage_preference" msgid="7065701732733134991">"Préférences d\'utilisation de l\'application"</string>
    <string name="time_spent_in_app_pref_title" msgid="9124796405314626532">"Temps d\'utilisation des écrans"</string>
    <string name="usage_access_description" msgid="1352111094596416795">"L\'accès aux données d\'utilisation permet à une application d\'effectuer le suivi des applications que vous utilisez, de la fréquence d\'utilisation, du fournisseur de services, des paramètres de langue et d\'autres détails."</string>
    <string name="memory_settings_title" msgid="7490541005204254222">"Mémoire"</string>
    <string name="memory_details_title" msgid="8542565326053693320">"Détails de la mémoire"</string>
    <string name="always_running" msgid="6042448320077429656">"Toujours en cours d\'exécution (<xliff:g id="PERCENTAGE">%s</xliff:g>)"</string>
    <string name="sometimes_running" msgid="6611250683037700864">"Parfois en cours d\'exécution (<xliff:g id="PERCENTAGE">%s</xliff:g>)"</string>
    <string name="rarely_running" msgid="348413460168817458">"Rarement en cours d\'exécution (<xliff:g id="PERCENTAGE">%s</xliff:g>)"</string>
    <string name="memory_max_use" msgid="6874803757715963097">"Maximum"</string>
    <string name="memory_avg_use" msgid="7382015389130622870">"Moyenne"</string>
    <string name="memory_max_desc" msgid="2861832149718335864">"Maximum : <xliff:g id="MEMORY">%1$s</xliff:g>"</string>
    <string name="memory_avg_desc" msgid="1551240906596518412">"Moyenne : <xliff:g id="MEMORY">%1$s</xliff:g>"</string>
    <string name="memory_use_running_format" msgid="4172488041800743760">"<xliff:g id="MEMORY">%1$s</xliff:g>/<xliff:g id="RUNNING">%2$s</xliff:g>"</string>
    <string name="process_format" msgid="77905604092541454">"<xliff:g id="APP_NAME">%1$s</xliff:g> (<xliff:g id="COUNT">%2$d</xliff:g>)"</string>
    <string name="high_power_apps" msgid="3459065925679828230">"Optimisation de la pile"</string>
    <string name="additional_battery_info" msgid="4754099329165411970">"Alertes d\'utilisation"</string>
    <string name="show_all_apps" msgid="1512506948197818534">"Afficher l\'utilisation totale de l\'appareil"</string>
    <string name="hide_extra_apps" msgid="5016497281322459633">"Afficher utilisation des applis"</string>
    <plurals name="power_high_usage_summary" formatted="false" msgid="467347882627862744">
      <item quantity="one"><xliff:g id="NUMBER">%2$d</xliff:g> application se comporte de manière anormale</item>
      <item quantity="other"><xliff:g id="NUMBER">%2$d</xliff:g> applications se comportent de manière anormale</item>
    </plurals>
    <plurals name="power_high_usage_title" formatted="false" msgid="3826660033363082922">
      <item quantity="one">Application qui draine la pile</item>
      <item quantity="other">Applications qui drainent la pile</item>
    </plurals>
    <string name="high_power_filter_on" msgid="3222265297576680099">"Non optimisée"</string>
    <string name="high_power_on" msgid="6216293998227583810">"Non optimisée"</string>
    <string name="high_power_off" msgid="3393904131961263278">"L\'utilisation de la pile est optimisée"</string>
    <string name="high_power_system" msgid="7362862974428225301">"L\'optimisation de la pile n\'est pas disponible"</string>
    <string name="high_power_desc" msgid="6283926163708585760">"N\'appliquer aucune optimisation de la pile. Cela risque de décharger la pile plus rapidement."</string>
    <string name="high_power_prompt_title" msgid="6358673688590282655">"Autoriser l\'application à toujours fonctionner en arrière-plan?"</string>
    <string name="high_power_prompt_body" msgid="1031422980602565049">"Si vous autorisez <xliff:g id="APP_NAME">%1$s</xliff:g> à toujours fonctionner en arrière-plan, l\'autonomie de la pile peut être réduite. \n\nVous pouvez modifier cette option plus tard dans Paramètres &gt; Applications et notifications."</string>
    <string name="battery_summary" msgid="8044042095190688654">"Usage depuis la dernière charge complète : <xliff:g id="PERCENTAGE">%1$s</xliff:g>"</string>
    <string name="battery_power_management" msgid="5571519699679107523">"Gestion de l\'alimentation"</string>
    <string name="no_battery_summary" msgid="3528036835462846814">"Aucune utilisation de la pile depuis la dernière charge complète"</string>
    <string name="app_notification_preferences" msgid="1599319335092722613">"Paramètres de l\'application"</string>
    <string name="system_ui_settings" msgid="579824306467081123">"Afficher les paramètres SystemUI"</string>
    <string name="additional_permissions" msgid="6463784193877056080">"Autorisations supplémentaires"</string>
    <string name="additional_permissions_more" msgid="3538612272673191451">"<xliff:g id="COUNT">%1$d</xliff:g> autre(s)"</string>
    <string name="share_remote_bugreport_dialog_title" msgid="1124840737776588602">"Partager le rapport de bogue?"</string>
    <string name="share_remote_bugreport_dialog_message_finished" msgid="4973886976504823801">"Votre administrateur informatique a demandé un rapport de bogue pour l\'aider à dépanner cet appareil. Les applications et les données peuvent être partagées."</string>
    <string name="share_remote_bugreport_dialog_message" msgid="3495929560689435496">"Votre administrateur informatique a demandé un rapport de bogue pour l\'aider à dépanner cet appareil. Les applications et les données peuvent être partagées. Cela pourrait temporairement ralentir votre appareil."</string>
    <string name="sharing_remote_bugreport_dialog_message" msgid="5859287696666024466">"Ce rapport de bogue est partagé avec votre administrateur informatique. Pour en savoir plus, communiquez avec lui."</string>
    <string name="share_remote_bugreport_action" msgid="532226159318779397">"Partager"</string>
    <string name="decline_remote_bugreport_action" msgid="518720235407565134">"Refuser"</string>
    <string name="usb_use_charging_only" msgid="4800495064747543954">"Pas de transfert de données"</string>
    <string name="usb_use_charging_only_desc" msgid="3066256793008540627">"Charger cet appareil seulement"</string>
    <string name="usb_use_power_only" msgid="3236391691786786070">"Charger l\'appareil connecté"</string>
    <string name="usb_use_file_transfers" msgid="1223134119354320726">"Transfert de fichiers"</string>
    <string name="usb_use_file_transfers_desc" msgid="4235764784331804488">"Transférer des fichiers vers un autre appareil"</string>
    <string name="usb_use_photo_transfers" msgid="8192719651229326283">"PTP"</string>
    <string name="usb_use_photo_transfers_desc" msgid="2963034811151325996">"Transferer des photos ou des fichiers si MTP n\'est pas pris en charge (PTP)"</string>
    <string name="usb_use_tethering" msgid="3944506882789422118">"Partage de connexion par USB"</string>
    <string name="usb_use_MIDI" msgid="5116404702692483166">"MIDI"</string>
    <string name="usb_use_MIDI_desc" msgid="8473936990076693175">"Utiliser cet appareil en tant que MIDI"</string>
    <string name="usb_use" msgid="3372728031108932425">"Utiliser la connexion USB pour"</string>
    <string name="usb_default_label" msgid="2211094045594574774">"Configuration USB par défaut"</string>
    <string name="usb_default_info" msgid="8864535445796200695">"Lorsqu\'un autre appareil sera connecté et que votre téléphone sera déverrouillé, ces paramètres seront appliqués. Connectez-vous uniquement aux appareils de confiance."</string>
    <string name="usb_pref" msgid="1400617804525116158">"USB"</string>
    <string name="usb_preference" msgid="7394265019817945275">"Préférences USB"</string>
    <string name="usb_control_title" msgid="4404322722995917160">"USB contrôlé par"</string>
    <string name="usb_control_host" msgid="2276710819046647200">"Appareil connecté"</string>
    <string name="usb_control_device" msgid="5821511964163469463">"Cet appareil"</string>
    <string name="usb_switching" msgid="8995313698715545619">"Changement en cours…"</string>
    <string name="usb_switching_failed" msgid="4156073015692409651">"Impossible de changer de mode"</string>
    <string name="usb_summary_charging_only" msgid="7544327009143659751">"Chargement de l\'appareil"</string>
    <string name="usb_summary_power_only" msgid="1996391096369798526">"Chargement de l\'appareil connecté"</string>
    <string name="usb_summary_file_transfers" msgid="6925168380589489645">"Transfert de fichiers"</string>
    <string name="usb_summary_tether" msgid="951190049557074535">"Partage de connexion par USB"</string>
    <string name="usb_summary_photo_transfers" msgid="665584667685030007">"PTP"</string>
    <string name="usb_summary_MIDI" msgid="2399066753961085360">"MIDI"</string>
    <string name="usb_summary_file_transfers_power" msgid="7700800611455849806">"Transfert de fichiers et alimentation"</string>
    <string name="usb_summary_tether_power" msgid="5825335393952752238">"Partage de connexion par USB et alimentation"</string>
    <string name="usb_summary_photo_transfers_power" msgid="6826058111908423069">"PTP et alimentation"</string>
    <string name="usb_summary_MIDI_power" msgid="3308250484012677596">"MIDI et alimentation"</string>
    <string name="background_check_pref" msgid="7550258400138010979">"Vérification en arrière-plan"</string>
    <string name="background_check_title" msgid="4534254315824525593">"Accès complet à l\'arrière-plan"</string>
    <string name="assist_access_context_title" msgid="2269032346698890257">"Utiliser le texte affiché à l\'écran"</string>
    <string name="assist_access_context_summary" msgid="1991421283142279560">"Autoriser l\'application d\'assistance à accéder au contenu affiché à l\'écran sous forme de texte"</string>
    <string name="assist_access_screenshot_title" msgid="4034721336291215819">"Utiliser la saisie d\'écran"</string>
    <string name="assist_access_screenshot_summary" msgid="6761636689013259901">"Autoriser l\'application d\'assistance à accéder au contenu affiché à l\'écran sous forme d\'image"</string>
    <string name="assist_flash_title" msgid="506661221230034891">"Faire clignoter l\'écran"</string>
    <string name="assist_flash_summary" msgid="9160668468824099262">"Faire clignoter les bordures de l\'écran lorsque l\'application d\'assistance accède à du texte à partir de l\'écran ou d\'une capture d\'écran"</string>
    <string name="assist_footer" msgid="1982791172085896864">"Les applications d\'assistance peuvent vous aider en fonction de l\'information affichée à l\'écran. Certaines applications sont compatibles à la fois avec le lanceur d\'applications et les services d\'entrée vocale, vous permettant de bénéficier d\'une assistance intégrée."</string>
    <string name="average_memory_use" msgid="829566450150198512">"Utilisation moyenne de la mémoire"</string>
    <string name="maximum_memory_use" msgid="7493720799710132496">"Utilisation max. de la mémoire"</string>
    <string name="memory_usage" msgid="1781358557214390033">"Utilisation de la mémoire"</string>
    <string name="app_list_memory_use" msgid="6987417883876419338">"Utilisation de l\'application"</string>
    <string name="memory_details" msgid="5943436005716991782">"Détails"</string>
    <string name="memory_use_summary" msgid="5608257211903075754">"Moyenne de mémoire utilisée au cours des trois dernières heures : <xliff:g id="SIZE">%1$s</xliff:g>"</string>
    <string name="no_memory_use_summary" msgid="2016900536806235588">"Aucune mémoire utilisée au cours des trois dernières heures"</string>
    <string name="sort_avg_use" msgid="3998036180505143129">"Trier par utilisation moyenne"</string>
    <string name="sort_max_use" msgid="4629247978290075124">"Trier par utilisation maximale"</string>
    <string name="memory_performance" msgid="5661005192284103281">"Performance"</string>
    <string name="total_memory" msgid="2017287600738630165">"Mémoire totale"</string>
    <string name="average_used" msgid="5338339266517245782">"Utilisation moyenne (%)"</string>
    <string name="free_memory" msgid="4003936141603549746">"Libre"</string>
    <string name="memory_usage_apps" msgid="5650192998273294098">"Mémoire utilisée par les applications"</string>
    <plurals name="memory_usage_apps_summary" formatted="false" msgid="6089210945574265774">
      <item quantity="one"><xliff:g id="COUNT">%1$d</xliff:g> application a utilisé de la mémoire au cours de la période suivante : <xliff:g id="DURATION_1">%2$s</xliff:g></item>
      <item quantity="other"><xliff:g id="COUNT">%1$d</xliff:g> applications ont utilisé de la mémoire au cours de la période suivante : <xliff:g id="DURATION_1">%2$s</xliff:g></item>
    </plurals>
    <string name="running_frequency" msgid="6622624669948277693">"Fréquence"</string>
    <string name="memory_maximum_usage" msgid="6513785462055278341">"Utilisation maximale"</string>
    <string name="no_data_usage" msgid="9131454024293628063">"Aucune donnée utilisée"</string>
    <string name="zen_access_warning_dialog_title" msgid="1198189958031157142">"Autoriser l\'accès au mode Ne pas déranger pour <xliff:g id="APP">%1$s</xliff:g>?"</string>
    <string name="zen_access_warning_dialog_summary" msgid="4015885767653010873">"L\'application disposera d\'une autorisation d\'activation ou de désactivation du mode Ne pas déranger et de modification des paramètres associés."</string>
    <string name="zen_access_disabled_package_warning" msgid="302820100078584431">"Cette fonction doit rester activée, car l\'accès aux notifications est activé"</string>
    <string name="zen_access_revoke_warning_dialog_title" msgid="558779234015793950">"Révoquer l\'accès aux fonctions Ne pas déranger de <xliff:g id="APP">%1$s</xliff:g>?"</string>
    <string name="zen_access_revoke_warning_dialog_summary" msgid="5518216907304930148">"Toutes les règles Ne pas déranger créées par cette application seront supprimées."</string>
    <string name="ignore_optimizations_on" msgid="6915689518016285116">"Ne pas optimiser"</string>
    <string name="ignore_optimizations_off" msgid="6153196256410296835">"Optimiser"</string>
    <string name="ignore_optimizations_on_desc" msgid="3549930955839111652">"Cela peut épuiser la pile de votre appareil plus rapidement. L\'application pourra maintenant utiliser la pile en arrière-plan."</string>
    <string name="ignore_optimizations_off_desc" msgid="5255731062045426544">"Recommandé pour une meilleure autonomie de la pile"</string>
    <string name="ignore_optimizations_title" msgid="2829637961185027768">"Autoriser <xliff:g id="APP">%s</xliff:g> à ignorer les optimisations de la pile?"</string>
    <string name="app_list_preference_none" msgid="108006867520327904">"Aucune"</string>
    <string name="work_profile_usage_access_warning" msgid="2918050775124911939">"Désactiver l\'accès aux données d\'utilisation pour cette application n\'empêchera pas votre administrateur d\'effectuer le suivi de la consommation des données pour les applications de votre profil professionnel"</string>
    <string name="accessibility_lock_screen_progress" msgid="2408292742980383166">"<xliff:g id="COUNT_0">%1$d</xliff:g> sur <xliff:g id="COUNT_1">%2$d</xliff:g> caractères utilisés"</string>
    <string name="draw_overlay" msgid="6564116025404257047">"Afficher par-dessus autres applis"</string>
    <string name="system_alert_window_settings" msgid="8466613169103527868">"Afficher par-dessus les autres applications"</string>
    <string name="system_alert_window_apps_title" msgid="7005760279028569491">"Applications"</string>
    <string name="system_alert_window_access_title" msgid="6297115362542361241">"Afficher par-dessus les autres applications"</string>
    <string name="permit_draw_overlay" msgid="7456536798718633432">"Autoriser la superposition d\'applis"</string>
    <string name="allow_overlay_description" msgid="8961670023925421358">"Permet à l\'application d\'afficher des éléments dans d\'autres applications, et cela risque de nuire à l\'utilisation de ces dernières ou de modifier leur apparence ou leur comportement."</string>
    <string name="keywords_vr_listener" msgid="7441221822576384680">"vr réalité virtuelle écouteur service de soutien stéréo"</string>
    <string name="overlay_settings" msgid="6930854109449524280">"Afficher par-dessus autres applis"</string>
    <string name="system_alert_window_summary" msgid="602892301318324492">"<xliff:g id="COUNT_0">%1$d</xliff:g> applis sur <xliff:g id="COUNT_1">%2$d</xliff:g> sont autorisées à aff. par-dessus autres applis"</string>
    <string name="filter_overlay_apps" msgid="6965969283342557573">"Applications dotées de l\'autorisation"</string>
    <string name="app_permission_summary_allowed" msgid="1505409933012886711">"Autorisée"</string>
    <string name="app_permission_summary_not_allowed" msgid="2592617058101882802">"Non autorisée"</string>
    <string name="keywords_install_other_apps" msgid="761078076051006558">"installer des applications provenant de sources inconnues"</string>
    <string name="write_settings" msgid="4797457275727195681">"Modifier param. système"</string>
    <string name="keywords_write_settings" msgid="6415597272561105138">"écrire des modifications aux paramètres du système"</string>
    <string name="write_settings_summary" msgid="4302268998611412696">"<xliff:g id="COUNT_0">%1$d</xliff:g> applis sur <xliff:g id="COUNT_1">%2$d</xliff:g> sont autorisées à modifier les param. système"</string>
    <string name="filter_install_sources_apps" msgid="3102976274848199118">"Peut installer d\'autres applications"</string>
    <string name="filter_write_settings_apps" msgid="2914615026197322551">"Peut modifier les paramètres du système"</string>
    <string name="write_settings_title" msgid="4232152481902542284">"Peut modifier les paramètres du système"</string>
    <string name="write_system_settings" msgid="3482913590601096763">"Modifier param. système"</string>
    <string name="permit_write_settings" msgid="658555006453212691">"Autoriser la modification des paramètres du système"</string>
    <string name="write_settings_description" msgid="6868293938839954623">"Cette autorisation permet à une application de modifier les paramètres du système."</string>
    <string name="write_settings_on" msgid="8230580416068832239">"Oui"</string>
    <string name="write_settings_off" msgid="5156104383386336233">"Non"</string>
    <string name="external_source_switch_title" msgid="3621381992793251070">"Autoriser de cette source"</string>
    <string name="camera_gesture_title" msgid="1075838577642393011">"Pivot. poignet deux fois pour app. photo"</string>
    <string name="camera_gesture_desc" msgid="1831390075255870960">"Ouvrez l\'application de l\'appareil photo en pivotant votre poignet deux fois"</string>
    <string name="camera_double_tap_power_gesture_title" msgid="1651873760405034645">"App. 2x sur interr. pr activ. app. photo"</string>
    <string name="camera_double_tap_power_gesture_desc" msgid="7355664631775680376">"Lancez rapidement l\'appareil photo sans déverrouiller l\'écran"</string>
    <string name="screen_zoom_title" msgid="5233515303733473927">"Taille d\'affichage"</string>
    <string name="screen_zoom_short_summary" msgid="7291960817349834688">"Rendez les objets à l\'écran plus grands ou plus petits"</string>
    <string name="screen_zoom_keywords" msgid="9176477565403352552">"densité d\'affichage, zoom de l\'écran, échelle, mise à l\'échelle"</string>
    <string name="screen_zoom_summary" msgid="6445488991799015407">"Agrandissez ou réduisez les éléments affichés. Si vous modifiez ce paramètre, certaines applications risquent de changer de position à l\'écran."</string>
    <string name="screen_zoom_preview_title" msgid="4680671508172336572">"Aperçu"</string>
    <string name="screen_zoom_make_smaller_desc" msgid="4622359904253364742">"Rapetisser"</string>
    <string name="screen_zoom_make_larger_desc" msgid="2236171043607896594">"Agrandir"</string>
    <string name="screen_zoom_conversation_icon_alex" msgid="8443032489384985820">"A"</string>
    <string name="screen_zoom_conversation_icon_pete" msgid="998709701837681129">"P"</string>
    <string name="screen_zoom_conversation_message_1" msgid="6546951024984852686">"Salut Pierre!"</string>
    <string name="screen_zoom_conversation_message_2" msgid="6935424214137738647">"Un petit café et une jasette, ça te tente aujourd\'hui?"</string>
    <string name="screen_zoom_conversation_message_3" msgid="5218221201861387402">"Super. Je connais un bon café pas trop loin d\'ici."</string>
    <string name="screen_zoom_conversation_message_4" msgid="5564676794767555447">"Parfait!"</string>
    <string name="screen_zoom_conversation_timestamp_1" msgid="7453710416319650556">"Mardi à 18 h 00"</string>
    <string name="screen_zoom_conversation_timestamp_2" msgid="7107225702890747588">"Mardi à 18 h 01"</string>
    <string name="screen_zoom_conversation_timestamp_3" msgid="3785674344762707688">"Mardi à 18 h 02"</string>
    <string name="screen_zoom_conversation_timestamp_4" msgid="2511469395448561259">"Mardi à 18 h 03"</string>
    <string name="disconnected" msgid="4836600637485526329">"Non connecté"</string>
    <string name="keyboard_disconnected" msgid="1495037256967224035">"Non connecté"</string>
    <string name="data_usage_summary_format" msgid="7507047900192160585">"<xliff:g id="AMOUNT">%1$s</xliff:g> de données utilisées"</string>
    <string name="data_usage_wifi_format" msgid="5417296451392612860">"<xliff:g id="AMOUNT">^1</xliff:g> utilisés sur Wi‑Fi"</string>
    <plurals name="notification_summary" formatted="false" msgid="3941492005316143599">
      <item quantity="one">Désactivé pour <xliff:g id="COUNT">%d</xliff:g> application</item>
      <item quantity="other">Désactivé pour <xliff:g id="COUNT">%d</xliff:g> applications</item>
    </plurals>
    <string name="notification_summary_none" msgid="4586376436702610">"Activées pour toutes les applications"</string>
    <string name="apps_summary" msgid="193158055537070092">"<xliff:g id="COUNT">%1$d</xliff:g> applications installées"</string>
    <string name="apps_summary_example" msgid="2118896966712746139">"24 applications installées"</string>
    <string name="storage_summary" msgid="3801281635351732202">"Utilisé : <xliff:g id="PERCENTAGE">%1$s</xliff:g>. Libre : <xliff:g id="FREE_SPACE">%2$s</xliff:g>"</string>
    <string name="storage_summary_with_sdcard" msgid="3290457009629490121">"Stockage interne : <xliff:g id="PERCENTAGE">%1$s</xliff:g> utilisé - <xliff:g id="FREE_SPACE">%2$s</xliff:g> disponible"</string>
    <string name="display_summary" msgid="6737806235882127328">"Passer en veille après <xliff:g id="TIMEOUT_DESCRIPTION">%1$s</xliff:g> d\'inactivité"</string>
    <string name="display_dashboard_summary" msgid="4145888780290131488">"Fond d\'écran, mode sommeil, taille de la police"</string>
    <string name="display_dashboard_summary_with_style" msgid="870920274423314524">"Styles, fond d\'écran, mise en veille de l\'écran, taille de la police"</string>
    <string name="display_dashboard_nowallpaper_summary" msgid="7840559323355210111">"Mode veille, taille de la police"</string>
    <string name="display_summary_example" msgid="9102633726811090523">"Veille après 10 minutes d\'inactivité"</string>
    <string name="memory_summary" msgid="8080825904671961872">"Mémoire utilisée en moyenne : <xliff:g id="USED_MEMORY">%1$s</xliff:g> sur <xliff:g id="TOTAL_MEMORY">%2$s</xliff:g>"</string>
    <string name="users_summary" msgid="1674864467098487328">"Connecté en tant que <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="payment_summary" msgid="3472482669588561110">"<xliff:g id="APP_NAME">%1$s</xliff:g> est l\'application par défaut"</string>
    <string name="backup_disabled" msgid="485189128759595412">"Sauvegardes désactivées"</string>
    <string name="android_version_summary" msgid="2935995161657697278">"Mis à jour vers Android <xliff:g id="VERSION">%1$s</xliff:g>"</string>
    <string name="android_version_pending_update_summary" msgid="487831391976523090">"Mise à jour disponible"</string>
    <string name="disabled_by_policy_title" msgid="627023216027648534">"Action interdite"</string>
    <string name="disabled_by_policy_title_adjust_volume" msgid="3208724801293696486">"Impossible de modifier le volume"</string>
    <string name="disabled_by_policy_title_outgoing_calls" msgid="7919816644946067058">"Les appels sont désactivés"</string>
    <string name="disabled_by_policy_title_sms" msgid="5733307423899610340">"La messagerie texte est désactivée"</string>
    <string name="disabled_by_policy_title_camera" msgid="6225008536855644874">"L\'appareil photo est désactivé"</string>
    <string name="disabled_by_policy_title_screen_capture" msgid="4066913623298047094">"Les captures d\'écran sont désactivées"</string>
    <string name="disabled_by_policy_title_suspend_packages" msgid="7872038990805477554">"Impossible d\'ouvrir cette application"</string>
    <string name="default_admin_support_msg" msgid="4489678214035485367">"Si vous avez des questions, veuillez communiquer avec votre administrateur informatique"</string>
    <string name="admin_support_more_info" msgid="8901377038510512654">"Détails supplémentaires"</string>
    <string name="admin_profile_owner_message" msgid="5860816886981109626">"Votre administrateur peut surveiller et gérer les applications et les données associées à votre profil professionnel, y compris les paramètres, les autorisations, l\'accès aux contenus de l\'entreprise, l\'activité réseau et les données de localisation de l\'appareil."</string>
    <string name="admin_profile_owner_user_message" msgid="3842630535450382172">"Votre administrateur peut surveiller et gérer les applications et les données associées à cet utilisateur, y compris les paramètres, les autorisations, l\'accès aux contenus de l\'entreprise, l\'activité réseau et les données de localisation de l\'appareil."</string>
    <string name="admin_device_owner_message" msgid="6232893638259790789">"Votre administrateur peut surveiller et gérer les applications et les données associées à cet appareil, y compris les paramètres, les autorisations, l\'accès aux contenus de l\'entreprise, l\'activité réseau et les données de localisation de l\'appareil."</string>
    <string name="condition_turn_off" msgid="1960945836880080298">"Désactiver"</string>
    <string name="condition_turn_on" msgid="9089876276117874591">"Activer"</string>
    <string name="condition_expand_show" msgid="608202020023489939">"Afficher"</string>
    <string name="condition_expand_hide" msgid="948507739223760667">"Masquer"</string>
    <string name="condition_hotspot_title" msgid="5959815393203320845">"Le point d\'accès est actif"</string>
    <string name="condition_airplane_title" msgid="287356299107070503">"Le mode Avion est activé"</string>
    <string name="condition_airplane_summary" msgid="2500054042183138980">"Aucun réseau accessible"</string>
    <string name="condition_zen_title" msgid="2897779738211625">"Mode Ne pas déranger activé"</string>
    <string name="condition_zen_summary_phone_muted" msgid="3644614024467141806">"Téléphone en sourdine"</string>
    <string name="condition_zen_summary_with_exceptions" msgid="4047564276599301064">"Avec des exceptions"</string>
    <string name="condition_battery_title" msgid="3272131008388575349">"Économie d\'énergie activée"</string>
    <string name="condition_battery_summary" msgid="5847532902924566572">"Fonctionnalités restreintes"</string>
    <string name="condition_cellular_title" msgid="1327317003797575735">"Données cellulaires désactivées"</string>
    <string name="condition_cellular_summary" msgid="816822977403022625">"Internet est uniquement accessible par Wi‑Fi"</string>
    <string name="condition_bg_data_title" msgid="5475793236997935138">"Économiseur de données"</string>
    <string name="condition_bg_data_summary" msgid="1852811387315557164">"Fonctionnalités restreintes"</string>
    <string name="condition_work_title" msgid="7293722361184366648">"Profil professionnel désactivé"</string>
    <string name="condition_work_summary" msgid="9167580982244020746">"Pour les applications et les notifications"</string>
    <string name="condition_device_muted_action_turn_on_sound" msgid="4930240942726349213">"Activer le son"</string>
    <string name="condition_device_muted_title" msgid="3476439379918599716">"Sonnerie désactivée"</string>
    <string name="condition_device_muted_summary" msgid="6313274406443663781">"Pour les appels et les notifications"</string>
    <string name="condition_device_vibrate_title" msgid="8070177546359590131">"Vibrations seulement"</string>
    <string name="condition_device_vibrate_summary" msgid="5743200564646910423">"Pour les appels et les notifications"</string>
    <string name="night_display_suggestion_title" msgid="6602129097059325291">"Créer un horaire pour le mode Éclairage nocturne"</string>
    <string name="night_display_suggestion_summary" msgid="228346372178218442">"Donner automatiquement des tons ambrés à l\'écran tous les soirs"</string>
    <string name="condition_night_display_title" msgid="5599814941976856183">"Éclairage nocturne activé"</string>
    <string name="condition_night_display_summary" msgid="7150932917610919907">"Écran teinté ambre"</string>
    <string name="condition_grayscale_title" msgid="3426050703427823519">"Nuances de gris"</string>
    <string name="condition_grayscale_summary" msgid="7652835784223724625">"Afficher uniquement en nuances de gris"</string>
    <string name="homepage_condition_footer_content_description" msgid="2335918927419018030">"Réduire"</string>
    <string name="suggestions_title_v2" msgid="5601181602924147569">"Suggestions personnalisées"</string>
    <string name="suggestions_title" msgid="7280792342273268377">"Suggestions"</string>
    <string name="suggestions_summary" msgid="2509040178581728056">"+<xliff:g id="ID_1">%1$d</xliff:g>"</string>
    <string name="suggestions_more_title" msgid="8223690393059519879">"+<xliff:g id="ID_1">%1$d</xliff:g> autre(s)"</string>
    <plurals name="suggestions_collapsed_title" formatted="false" msgid="1857433444865249823">
      <item quantity="one"><xliff:g id="COUNT">%1$d</xliff:g> suggestion</item>
      <item quantity="other"><xliff:g id="COUNT">%1$d</xliff:g> suggestions</item>
    </plurals>
    <plurals name="suggestions_collapsed_summary" formatted="false" msgid="7680263825371165461">
      <item quantity="one">+<xliff:g id="COUNT">%1$d</xliff:g> suggestion</item>
      <item quantity="other">+<xliff:g id="COUNT">%1$d</xliff:g> suggestions</item>
    </plurals>
    <string name="suggestion_remove" msgid="904627293892092439">"Supprimer"</string>
    <string name="color_temperature" msgid="2070126836910615605">"Température des couleurs froides"</string>
    <string name="color_temperature_desc" msgid="4793729830226404052">"Utiliser des couleurs plus froides à l\'écran"</string>
    <string name="color_temperature_toast" msgid="4974218172133854827">"Pour appliquer la modification des couleurs, éteignez l\'écran"</string>
    <string name="camera_laser_sensor_switch" msgid="8913588990743234440">"Capteur laser de l\'appareil photo"</string>
    <string name="ota_disable_automatic_update" msgid="2319639631655915050">"Mises à jour automatiques du système"</string>
    <string name="ota_disable_automatic_update_summary" msgid="940729694354373087">"Appliquer les mises à jour au redémarrage de l\'appareil"</string>
    <string name="usage" msgid="2977875522080448986">"Utilisation"</string>
    <string name="cellular_data_usage" msgid="2155683719898158203">"Utilis. données cell."</string>
    <string name="app_cellular_data_usage" msgid="5468472735806533448">"Utilisation des données des applications"</string>
    <string name="wifi_data_usage" msgid="771603760674507659">"Utilisation des données Wi-Fi"</string>
    <string name="ethernet_data_usage" msgid="5108764537574354616">"Utilisation de données Ethernet"</string>
    <string name="wifi" msgid="1081550856200013637">"Wi-Fi"</string>
    <string name="ethernet" msgid="6600095783781389720">"Ethernet"</string>
    <string name="cell_data_template" msgid="405684854174361041">"Données cellulaires utilisées : <xliff:g id="AMOUNT">^1</xliff:g>"</string>
    <string name="wifi_data_template" msgid="6265570748799357386">"Données Wi-Fi : <xliff:g id="AMOUNT">^1</xliff:g>"</string>
    <string name="ethernet_data_template" msgid="5782476509881033590">"Données Ethernet : <xliff:g id="AMOUNT">^1</xliff:g>"</string>
    <string name="billing_cycle" msgid="6614597736285325497">"Avertissement et limites données"</string>
    <string name="app_usage_cycle" msgid="8877223251648092131">"Cycle d\'util. données d\'appli."</string>
    <string name="cell_data_warning" msgid="1985956818884847057">"Seuil à partir duquel un avertissement relatif à la consommation des données est envoyé : <xliff:g id="ID_1">^1</xliff:g>"</string>
    <string name="cell_data_limit" msgid="1578367585799358854">"Limite d\'utilisation de données : <xliff:g id="ID_1">^1</xliff:g>"</string>
    <string name="cell_data_warning_and_limit" msgid="6888825370687743208">"Seuil à partir duquel un avertissement relatif à la consommation des données est envoyé : <xliff:g id="ID_1">^1</xliff:g>. Limite d\'utilisation de données : <xliff:g id="ID_2">^2</xliff:g>."</string>
    <string name="billing_cycle_fragment_summary" msgid="8231066353654583106">"Mensuel (le <xliff:g id="ID_1">%1$s</xliff:g>)"</string>
    <string name="network_restrictions" msgid="8234695294536675380">"Restrictions réseau"</string>
    <plurals name="network_restrictions_summary" formatted="false" msgid="4301618027244595839">
      <item quantity="one"><xliff:g id="COUNT">%1$d</xliff:g> restriction</item>
      <item quantity="other"><xliff:g id="COUNT">%1$d</xliff:g> restrictions</item>
    </plurals>
    <string name="operator_warning" msgid="1862988028996859195">"Le suivi de consommation de données du fournisseur de services peut différer de celui de l\'appareil"</string>
    <string name="data_used_template" msgid="3245919669966296505">"<xliff:g id="ID_1">%1$s</xliff:g> utilisés"</string>
    <string name="set_data_warning" msgid="6115364758236594593">"Activer une alerte"</string>
    <string name="data_warning" msgid="209133958008062117">"Seuil d\'alerte"</string>
    <string name="data_warning_footnote" msgid="776341964125603711">"C\'est votre appareil qui mesure l\'utilisation des données pour les limites et les avertissements. Ces mesures peuvent différer de celles de votre fournisseur de services."</string>
    <string name="set_data_limit" msgid="2901526323210516923">"Définir limite consomm. données"</string>
    <string name="data_limit" msgid="1885406964934590552">"Limite de données"</string>
    <string name="data_usage_template" msgid="2923744765873163859">"<xliff:g id="ID_1">%1$s</xliff:g> utilisés pour la période : <xliff:g id="ID_2">%2$s</xliff:g>"</string>
    <string name="configure" msgid="1029654422228677273">"Configurer"</string>
    <string name="data_usage_other_apps" msgid="3272872663517382050">"Autres applications incluses dans l\'utilisation"</string>
    <plurals name="data_saver_unrestricted_summary" formatted="false" msgid="2635267833484232703">
      <item quantity="one"><xliff:g id="COUNT">%1$d</xliff:g> application est autorisée à ignorer les restrictions lorsque la fonction Économiseur de données est activée</item>
      <item quantity="other"><xliff:g id="COUNT">%1$d</xliff:g> applications sont autorisées à ignorer les restrictions lorsque la fonction Économiseur de données est activée</item>
    </plurals>
    <string name="data_usage_title" msgid="3659356290392241789">"Données primaires"</string>
    <string name="data_usage_wifi_title" msgid="7063659423081820720">"Données Wi-Fi"</string>
    <string name="data_used" msgid="5116389957228457203">"<xliff:g id="ID_1">^1</xliff:g> utilisés"</string>
    <string name="data_used_formatted" msgid="2989129931961311051">"<xliff:g id="ID_1">^1</xliff:g> <xliff:g id="ID_2">^2</xliff:g> utilisés"</string>
    <string name="data_overusage" msgid="1134445012475270295">"Limite dépassée de <xliff:g id="ID_1">^1</xliff:g>"</string>
    <string name="data_remaining" msgid="8998091725895502181">"Il reste <xliff:g id="ID_1">^1</xliff:g>"</string>
    <plurals name="billing_cycle_days_left" formatted="false" msgid="456503215317213651">
      <item quantity="one">Il reste %d jour</item>
      <item quantity="other">Il reste %d jours</item>
    </plurals>
    <string name="billing_cycle_none_left" msgid="5892754995098583472">"Aucun temps restant"</string>
    <string name="billing_cycle_less_than_one_day_left" msgid="825838050296069404">"Il reste moins d\'un jour"</string>
    <string name="carrier_and_update_text" msgid="7963409972475063897">"Mis à jour par <xliff:g id="ID_1">^1</xliff:g> il y a <xliff:g id="ID_2">^2</xliff:g>"</string>
    <string name="no_carrier_update_text" msgid="3277403390316201982">"Mis à jour il y a <xliff:g id="ID_1">^2</xliff:g>"</string>
    <string name="carrier_and_update_now_text" msgid="4057997726060106722">"Mis à jour par <xliff:g id="ID_1">^1</xliff:g> à l\'instant"</string>
    <string name="no_carrier_update_now_text" msgid="1766859656868932996">"Mis à jour à l\'instant"</string>
    <string name="launch_mdp_app_text" msgid="6751296320061773169">"Afficher le forfait"</string>
    <string name="launch_wifi_text" msgid="2311424914664372687">"Afficher les détails"</string>
    <string name="data_saver_title" msgid="8034286939200289826">"Économiseur de données"</string>
    <string name="unrestricted_data_saver" msgid="952796077540228711">"Données sans restrictions"</string>
    <string name="restrict_background_blacklisted" msgid="3995443391711013068">"Les données en arrière-plan sont désactivées"</string>
    <string name="data_saver_on" msgid="6774217590237934709">"Activé"</string>
    <string name="data_saver_off" msgid="6892309031162738794">"Désactivé"</string>
    <string name="data_saver_switch_title" msgid="836312690356005669">"Utiliser l\'économiseur de données"</string>
    <string name="unrestricted_app_title" msgid="4465437191723332066">"Utilis. donn. sans restriction"</string>
    <string name="unrestricted_app_summary" msgid="6458008993501723912">"Ignorer restrict. données lorsque Écon. donn. act."</string>
    <string name="home_app" msgid="4066188520886810030">"Application d\'accueil"</string>
    <string name="no_default_home" msgid="7184117487704520238">"Aucune application d\'accueil par défaut"</string>
    <string name="lockpattern_settings_require_cred_before_startup" msgid="3832020101401318248">"Démarrage sécurisé"</string>
    <string name="lockpattern_settings_require_pattern_before_startup_summary" msgid="7873036097628404476">"Un schéma est nécessaire pour démarrer l\'appareil. Lorsque celui-ci est éteint, il ne peut pas recevoir d\'appels ni de messages, ni émettre de notifications et d\'alarmes."</string>
    <string name="lockpattern_settings_require_pin_before_startup_summary" msgid="6022831284097476933">"Un NIP est nécessaire pour démarrer l\'appareil. Lorsque celui-ci est éteint, il ne peut pas recevoir d\'appels ni de messages, ni émettre de notifications et d\'alarmes."</string>
    <string name="lockpattern_settings_require_password_before_startup_summary" msgid="6818285221244966231">"Un mot de passe est nécessaire pour démarrer l\'appareil. Lorsque celui-ci est éteint, il ne peut pas recevoir d\'appels ni de messages, ni émettre de notifications et d\'alarmes."</string>
    <string name="suggestion_additional_fingerprints" msgid="2214281455363797037">"Ajouter une empreinte digitale"</string>
    <string name="suggestion_additional_fingerprints_summary" msgid="5471253233176471245">"Déverrouiller avec un autre doigt"</string>
    <string name="battery_saver_on_summary" msgid="7722791295871319534">"Activé"</string>
    <string name="battery_saver_off_scheduled_summary" msgid="3953785517002197881">"S\'active lorsque la pile atteint <xliff:g id="BATTERY_PERCENTAGE">%1$s</xliff:g>"</string>
    <string name="battery_saver_off_summary" msgid="784360321235698247">"Désactivé"</string>
    <string name="battery_saver_button_turn_on" msgid="3699954061337848832">"Activer maintenant"</string>
    <string name="battery_saver_button_turn_off" msgid="5916996792004611890">"Désactiver maintenant"</string>
    <string name="not_battery_optimizing" msgid="5362861851864837617">"L\'optimisation de la pile n\'est pas utilisée"</string>
    <string name="lockscreen_remote_input" msgid="969871538778211843">"Si l\'appareil est verrouillé, empêcher l\'entrée de réponses ou de texte dans les notifications"</string>
    <string name="default_spell_checker" msgid="8506899870026026660">"Correcteur ortho par défaut"</string>
    <string name="choose_spell_checker" msgid="6596539862291699367">"Sélectionner correcteur ortho"</string>
    <string name="spell_checker_master_switch_title" msgid="8763132750954344372">"Utiliser le vérificateur d\'orthographe"</string>
    <string name="spell_checker_not_selected" msgid="8871083796179200696">"Non sélectionné"</string>
    <string name="notification_log_no_title" msgid="5678029849672024215">"(aucun)"</string>
    <string name="notification_log_details_delimiter" msgid="3116559361552416747">" : "</string>
    <string name="notification_log_details_package" msgid="2596495677039100284">"pkg"</string>
    <string name="notification_log_details_key" msgid="2995791937075862968">"clé"</string>
    <string name="notification_log_details_group" msgid="2430467015200368698">"groupe"</string>
    <string name="notification_log_details_group_summary" msgid="7945543958255585829">"(sommaire)"</string>
    <string name="notification_log_details_visibility" msgid="2552873780715930971">"visibilité"</string>
    <string name="notification_log_details_public_version" msgid="4247242364605495240">"publicVersion"</string>
    <string name="notification_log_details_priority" msgid="8371354971235991398">"priorité"</string>
    <string name="notification_log_details_importance" msgid="2153168790791683139">"importance"</string>
    <string name="notification_log_details_explanation" msgid="1914295130775393551">"explication"</string>
    <string name="notification_log_details_badge" msgid="3258183328267662285">"peut présenter un badge"</string>
    <string name="notification_log_details_content_intent" msgid="1113554570409128083">"intention"</string>
    <string name="notification_log_details_delete_intent" msgid="905118520685297007">"supprimer intention"</string>
    <string name="notification_log_details_full_screen_intent" msgid="7118560817013522978">"intention plein écran"</string>
    <string name="notification_log_details_actions" msgid="242523930165118066">"actions"</string>
    <string name="notification_log_details_title" msgid="7177091647508863295">"titre"</string>
    <string name="notification_log_details_remoteinput" msgid="8328591329858827409">"entrées à distance"</string>
    <string name="notification_log_details_content_view" msgid="6638731378278561786">"affichage personnalisée"</string>
    <string name="notification_log_details_extras" msgid="4188418723779942047">"bonus"</string>
    <string name="notification_log_details_icon" msgid="8939114059726188218">"icône"</string>
    <string name="notification_log_details_parcel" msgid="243148037601903212">"taille du colis"</string>
    <string name="notification_log_details_ashmem" msgid="7241814108477320636">"ashmem"</string>
    <string name="notification_log_details_alerted" msgid="6622944771989529320">"notification alertée"</string>
    <string name="notification_log_details_sound" msgid="5506232879598808099">"son"</string>
    <string name="notification_log_details_vibrate" msgid="6890065466625335940">"vibration"</string>
    <string name="notification_log_details_vibrate_pattern" msgid="6076984056201975221">"motif"</string>
    <string name="notification_log_details_default" msgid="2345249399796730861">"par défaut"</string>
    <string name="notification_log_details_none" msgid="184131801230614059">"aucun(e)"</string>
    <string name="notification_log_details_ranking_null" msgid="244660392058720919">"L\'objet de classement est manquant."</string>
    <string name="notification_log_details_ranking_none" msgid="599607025882587844">"L\'objet de classement ne contient pas cette touche."</string>
    <string name="theme_customization_device_default" msgid="5058147707906551368">"Valeurs par défaut de l\'appareil"</string>
    <string name="display_cutout_emulation" msgid="7466869822418376317">"Encoche de l\'écran"</string>
    <string name="display_cutout_emulation_keywords" msgid="4495418317471622562">"découpe d\'affichage, encoche"</string>
    <string name="overlay_option_device_default" msgid="294510212512203638">"Valeurs par défaut de l\'appareil"</string>
    <string name="overlay_toast_failed_to_apply" msgid="3506731619973103346">"Impossible d\'appliquer la superposition"</string>
    <string name="special_access" msgid="3458780842491881155">"Accès spéciaux applis"</string>
    <plurals name="special_access_summary" formatted="false" msgid="260765309935675867">
      <item quantity="one"><xliff:g id="COUNT">%d</xliff:g> application peut utiliser les données sans restriction</item>
      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> applications peuvent utiliser les données sans restriction</item>
    </plurals>
    <string name="special_access_more" msgid="6927066457969301921">"En voir plus"</string>
    <string name="confirm_convert_to_fbe_warning" msgid="1487005506049137659">"Voulez-vous vraiment effacer les données des utilisateurs et chiffrer les fichiers?"</string>
    <string name="button_confirm_convert_fbe" msgid="7101855374850373091">"Effacer et convertir"</string>
    <string name="reset_shortcut_manager_throttling" msgid="6495066467198668994">"Réinitialiser la limitation de fréquence ShortcutManager"</string>
    <string name="reset_shortcut_manager_throttling_complete" msgid="1826770872063707900">"La limitation de fréquence ShortcutManager a été réinitialisée"</string>
    <string name="notification_suggestion_title" msgid="387052719462473500">"Gérer les données sur l\'écran de verrouillage"</string>
    <string name="notification_suggestion_summary" msgid="8521159741445416875">"Afficher ou masquer le contenu des notifications"</string>
    <string name="page_tab_title_summary" msgid="4070309266374993258">"Tous"</string>
    <string name="page_tab_title_support" msgid="4407600495101788249">"Astuces et assistance"</string>
    <string name="developer_smallest_width" msgid="7516950434587313360">"La plus petite largeur"</string>
    <string name="premium_sms_none" msgid="8268105565738040566">"Aucune application installée n\'a demandé l\'accès aux textos payants"</string>
    <string name="premium_sms_warning" msgid="9086859595338944882">"Les textos de cette catégorie peuvent être payants et s\'ajouter aux factures mensuelles de votre fournisseur de services. Si vous activez l\'autorisation pour une application, vous serez en mesure d\'envoyer des textos payants à l\'aide de cette dernière."</string>
    <string name="premium_sms_access" msgid="4660047004791638305">"Accès aux textos payants"</string>
    <string name="bluetooth_disabled" msgid="6244000672828617410">"Désactivé"</string>
    <string name="bluetooth_connected_summary" msgid="7672528674593152862">"Connecté à <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="bluetooth_connected_multiple_devices_summary" msgid="9173661896296663932">"Connecté à plusieurs appareils"</string>
    <string name="demo_mode" msgid="2798762752209330277">"Mode de démonstration de l\'interface système"</string>
    <string name="dark_ui_mode" msgid="6795784845192720944">"Thème sombre"</string>
    <string name="dark_ui_mode_disabled_summary_dark_theme_on" msgid="5141126532745008289">"Activé/Temporairement désactivé par l\'économiseur de batterie"</string>
    <string name="dark_ui_mode_disabled_summary_dark_theme_off" msgid="4619248181769223081">"Temporairement activé par l\'économiseur de pile"</string>
    <string name="dark_ui_settings_dark_summary" msgid="8205234847639399279">"Les applications compatibles utiliseront aussi le thème sombre"</string>
    <string name="dark_ui_settings_dialog_acknowledge" msgid="8683868642329596059">"OK"</string>
    <string name="quick_settings_developer_tiles" msgid="5947788063262762448">"Paramètres rapides, tuiles de concepteur"</string>
    <string name="winscope_trace_quick_settings_title" msgid="1294290008255732032">"Traçage Winscope"</string>
    <string name="sensors_off_quick_settings_title" msgid="1487323753632515801">"Capteurs désactivés"</string>
    <string name="managed_profile_settings_title" msgid="2729481936758125054">"Paramètres du profil professionnel"</string>
    <string name="managed_profile_contact_search_title" msgid="6034734926815544221">"Recherche de contacts"</string>
    <string name="managed_profile_contact_search_summary" msgid="5431253552272970512">"Autoriser les recherches de contacts dans votre organisation à identifier les appelants et les contacts"</string>
    <string name="cross_profile_calendar_title" msgid="4414835261437899531">"Agenda multi-profil"</string>
    <string name="cross_profile_calendar_summary" msgid="8139424817135929870">"Afficher les événements professionnels dans l\'agenda personnel"</string>
    <string name="cross_profile_calendar_restricted_summary" msgid="295371538704418613">"Votre organisation n\'autorise pas les applications personnelles à accéder à votre agenda professionnel"</string>
    <plurals name="hours" formatted="false" msgid="7020844602875333472">
      <item quantity="one"><xliff:g id="NUMBER">%s</xliff:g> heure</item>
      <item quantity="other"><xliff:g id="NUMBER">%s</xliff:g> heures</item>
    </plurals>
    <plurals name="minutes" formatted="false" msgid="4666832442068789413">
      <item quantity="one"><xliff:g id="NUMBER">%s</xliff:g> minute</item>
      <item quantity="other"><xliff:g id="NUMBER">%s</xliff:g> minutes</item>
    </plurals>
    <plurals name="seconds" formatted="false" msgid="3876307354560025025">
      <item quantity="one"><xliff:g id="NUMBER">%s</xliff:g> seconde</item>
      <item quantity="other"><xliff:g id="NUMBER">%s</xliff:g> secondes</item>
    </plurals>
    <string name="automatic_storage_manager_settings" msgid="7819434542155181607">"Gérer l\'espace de stockage"</string>
    <string name="automatic_storage_manager_text" msgid="4562950476680600604">"Pour vous aider à libérer de l\'espace, le Gestionnaire de stockage supprime les photos et les vidéos sauvegardées sur votre appareil."</string>
    <string name="automatic_storage_manager_days_title" msgid="2017913896160914647">"Supprimer les photos et les vidéos"</string>
    <string name="automatic_storage_manager_preference_title" msgid="5753702798151073383">"Gestionnaire de stockage"</string>
    <string name="automatic_storage_manager_master_switch_title" msgid="6792996736190821417">"Utiliser le gestionnaire de stockage"</string>
    <string name="deletion_helper_automatic_title" msgid="6605660435498272520">"Automatique"</string>
    <string name="deletion_helper_manual_title" msgid="7947432164411214029">"Manuel"</string>
    <string name="deletion_helper_preference_title" msgid="5271510052022285884">"Libérer de l\'espace maintenant"</string>
    <string name="gesture_preference_title" msgid="5280023307132819052">"Gestes"</string>
    <string name="gesture_preference_summary" product="default" msgid="8627850388011956901">"Gestes rapides pour contrôler votre téléphone"</string>
    <string name="gesture_preference_summary" product="tablet" msgid="4717535378272065510">"Gestes rapides pour contrôler votre tablette"</string>
    <string name="gesture_preference_summary" product="device" msgid="4205941452664950852">"Gestes rapides pour contrôler votre appareil"</string>
    <string name="double_tap_power_for_camera_title" msgid="64716226816032800">"Accès rapide à l\'appareil photo"</string>
    <string name="double_tap_power_for_camera_summary" msgid="242037150983277829">"Pour ouvrir rapidement l\'appareil photo, appuyer deux fois sur l\'interrupteur. Cela fonctionne à partir de n\'importe quel écran."</string>
    <string name="double_tap_power_for_camera_suggestion_title" msgid="6500405261202883589">"Ouvrez l\'appareil photo rapidement"</string>
    <string name="double_twist_for_camera_mode_title" msgid="4877834147983530479">"Changer d\'appareil photo"</string>
    <string name="double_twist_for_camera_mode_summary" msgid="122977081337563340"></string>
    <string name="double_twist_for_camera_suggestion_title" msgid="4689410222517954869">"Prenez des égoportraits plus rapidement"</string>
    <string name="system_navigation_title" msgid="6797710220442338366">"Navigation système"</string>
    <string name="swipe_up_to_switch_apps_title" msgid="7381617686249459562">"Navigation à deux boutons"</string>
    <string name="swipe_up_to_switch_apps_summary" msgid="2158312695920408870">"Pour changer d\'application, balayez un doigt vers le haut sur la touche d\'accueil. Pour voir toutes les applications, balayez vers le haut de nouveau. Pour revenir, touchez le bouton Précédent."</string>
    <string name="swipe_up_to_switch_apps_suggestion_title" msgid="1465200107913259595">"Essayer la nouvelle touche d\'accueil"</string>
    <string name="swipe_up_to_switch_apps_suggestion_summary" msgid="4825314186907812743">"Activez le nouveau geste pour changer d\'application"</string>
    <string name="edge_to_edge_navigation_title" msgid="4889073348091667667">"Navigation par gestes"</string>
    <string name="edge_to_edge_navigation_summary" msgid="511639046551586471">"Pour accéder à l\'écran d\'accueil, balayez du bas de l\'écran vers le haut. Pour changer d\'applications, balayez l\'écran du bas vers le haut, maintenez le doigt sur l\'écran, puis relâchez-le. Pour revenir en arrière, balayez un doigt de l\'extrémité gauche ou droite de l\'écran dans la direction opposée."</string>
    <string name="legacy_navigation_title" msgid="2635061924638361565">"Navigation à trois boutons"</string>
    <string name="legacy_navigation_summary" msgid="5631274479304544610">"Revenez en arrière, à l\'écran d\'accueil, puis changez d\'applications à l\'aide des boutons dans le bas de votre écran."</string>
    <string name="keywords_system_navigation" msgid="5825645072714635357">"navigation système, navigation à deux boutons, navigation à trois boutons, navigation par gestes"</string>
    <string name="gesture_not_supported_dialog_message" msgid="4315436164949864999">"Cette fonctionnalité n\'est pas prise en charge par votre application d\'accueil par défaut, <xliff:g id="DEFAULT_HOME_APP">%s</xliff:g>"</string>
    <string name="gesture_not_supported_positive_button" msgid="8233003373902032396">"Changer d\'application d\'accueil par défaut"</string>
    <string name="information_label" msgid="8133109685432913360">"Information"</string>
    <string name="low_label" msgid="1679136861385616813">"Faible"</string>
    <string name="high_label" msgid="7278863493316447831">"Élevée"</string>
    <string name="back_sensitivity_dialog_message" msgid="1742132397253621623">\n"Une sensibilité élevée pourrait interférer avec les gestes dans l\'application le long des rebords de l\'écran."</string>
    <string name="back_sensitivity_dialog_title" msgid="5403946345652118253">"Sensibilité du retour arrière"</string>
    <string name="ambient_display_title" product="default" msgid="5144814600610448504">"Toucher deux fois le téléphone pour le consulter"</string>
    <string name="ambient_display_title" product="tablet" msgid="8688795028609563837">"Touchez l\'écran deux fois pour consulter votre tablette"</string>
    <string name="ambient_display_title" product="device" msgid="3423781975742145894">"Touchez l\'écran deux fois pour consulter votre appareil"</string>
    <string name="ambient_display_summary" msgid="8534654210539169707">"Pour vérifier l\'heure, vos notifications et d\'autres renseignements, toucher deux fois l\'écran."</string>
    <string name="ambient_display_pickup_title" product="default" msgid="818688002837687268">"Saisir le téléphone pour le consulter"</string>
    <string name="ambient_display_pickup_title" product="tablet" msgid="4455864282995698097">"Saisissez la tablette pour consulter les notifications"</string>
    <string name="ambient_display_pickup_title" product="device" msgid="5380534405773531175">"Saisissez l\'appareil pour consulter les notifications"</string>
    <string name="ambient_display_wake_screen_title" msgid="4091523525326925790">"Réactiver l\'écran"</string>
    <string name="ambient_display_pickup_summary" product="default" msgid="3436302177038243869">"Pour vérifier l\'heure, vos notifications et d\'autres renseignements, saisir votre téléphone."</string>
    <string name="ambient_display_pickup_summary" product="tablet" msgid="4938504160398665156">"Pour vérifier l\'heure, vos notifications et d\'autres renseignements, saisissez votre tablette."</string>
    <string name="ambient_display_pickup_summary" product="device" msgid="4264958533375250254">"Pour vérifier l\'heure, vos notifications et d\'autres renseignements, saisissez votre appareil."</string>
    <string name="ambient_display_tap_screen_title" product="default" msgid="5458679563086979424">"Toucher pour vérifier le téléphone"</string>
    <string name="ambient_display_tap_screen_title" product="tablet" msgid="9108878716863882877">"Toucher pour vérifier la tablette"</string>
    <string name="ambient_display_tap_screen_title" product="device" msgid="7071150656699666085">"Toucher pour vérifier l\'appareil"</string>
    <string name="ambient_display_tap_screen_summary" msgid="8862155601920379979">"Pour vérifier l\'heure, vos notifications et d\'autres renseignements, touchez l\'écran."</string>
    <string name="fingerprint_swipe_for_notifications_title" msgid="5816346492253270243">"Balayer le lecteur d\'empreintes pour voir les notifications"</string>
    <string name="fingerprint_gesture_screen_title" msgid="8562169633234041196">"Balayer empreinte"</string>
    <string name="fingerprint_swipe_for_notifications_summary" product="default" msgid="1770661868393713922">"Pour consulter vos notifications, passer votre doigt de haut en bas sur le capteur d\'empreintes digitales à l\'arrière du téléphone."</string>
    <string name="fingerprint_swipe_for_notifications_summary" product="tablet" msgid="902719947767712895">"Pour consulter vos notifications, passer votre doigt de haut en bas sur le capteur d\'empreintes digitales à l\'arrière de la tablette."</string>
    <string name="fingerprint_swipe_for_notifications_summary" product="device" msgid="5372926094116306647">"Pour consulter vos notifications, passer votre doigt de haut en bas sur le capteur d\'empreintes digitales à l\'arrière de l\'appareil."</string>
    <string name="fingerprint_swipe_for_notifications_suggestion_title" msgid="1677291167470357802">"Affichez les notifications rapidement"</string>
    <string name="gesture_setting_on" msgid="3455094265233870280">"Activé"</string>
    <string name="gesture_setting_off" msgid="5230169535435881894">"Désactivé"</string>
    <string name="oem_unlock_enable_disabled_summary_bootloader_unlocked" msgid="4265541229765635629">"Le programme d\'amorçage est déjà déverrouillé"</string>
    <string name="oem_unlock_enable_disabled_summary_connectivity" msgid="3361344735430813695">"Connectez-vous d\'abord à Internet"</string>
    <string name="oem_unlock_enable_disabled_summary_connectivity_or_locked" msgid="2479038689567925511">"Connectez à Internet ou contactez votre fournisseur de services"</string>
    <string name="oem_unlock_enable_disabled_summary_sim_locked_device" msgid="4149387448213399630">"Non disp. sur les appareils verrouillés par un f. de services"</string>
    <string name="oem_lock_info_message" msgid="9218313722236417510">"Veuillez redémarrer l\'appareil pour activer la fonction de protection d\'appareil."</string>
    <string name="automatic_storage_manager_freed_bytes" msgid="7517560170441007788">"<xliff:g id="SIZE">%1$s</xliff:g> libéré(s) au total\n\n Dernière exécution : <xliff:g id="DATE">%2$s</xliff:g>"</string>
    <string name="web_action_enable_title" msgid="4051513950976670853">"Applications instantanées"</string>
    <string name="web_action_enable_summary" msgid="3108127559723396382">"Ouvrir les liens dans les applications, même si elles ne sont pas installées"</string>
    <string name="web_action_section_title" msgid="7364647086538399136">"Applications instantanées"</string>
    <string name="instant_apps_settings" msgid="8827777916518348213">"Préf. applis instantanées"</string>
    <string name="domain_url_section_title" msgid="7046835219056428883">"Applications installées"</string>
    <string name="automatic_storage_manager_activation_warning" msgid="6353100011690933254">"Votre espace de stockage est maintenant géré par le gestionnaire de stockage"</string>
    <string name="account_for_section_header" msgid="5356566418548737121">"Comptes pour <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="configure_section_header" msgid="7391183586410814450">"Configurer"</string>
    <string name="auto_sync_account_title" msgid="898796354710116383">"Synchroniser auto. données"</string>
    <string name="auto_sync_personal_account_title" msgid="8496263182646100610">"Synchroniser automatiquement les données personnelles"</string>
    <string name="auto_sync_work_account_title" msgid="4489172450037434152">"Synchroniser automatiquement les données professionnelles"</string>
    <string name="auto_sync_account_summary" msgid="692499211629185107">"Autoriser les applications à actualiser les données automatiquement"</string>
    <string name="account_sync_title" msgid="7214747784136106491">"Synchro. du compte"</string>
    <string name="account_sync_summary_some_on" msgid="3375930757891381175">"La synchronisation est activée pour <xliff:g id="ID_1">%1$d</xliff:g> élément(s) sur <xliff:g id="ID_2">%2$d</xliff:g>"</string>
    <string name="account_sync_summary_all_on" msgid="570431636622254156">"La synchronisation est activée pour tous les éléments"</string>
    <string name="account_sync_summary_all_off" msgid="8782409931761182734">"La synchronisation est désactivée pour tous les éléments"</string>
    <string name="enterprise_privacy_settings" msgid="1177106810374146496">"Renseignements sur l\'appareil géré"</string>
    <string name="enterprise_privacy_settings_summary_generic" msgid="5853292305730761128">"Changements et paramètres gérés par votre organisation"</string>
    <string name="enterprise_privacy_settings_summary_with_name" msgid="4266234968317996188">"Changements et paramètres gérés par <xliff:g id="ORGANIZATION_NAME">%s</xliff:g>"</string>
    <string name="enterprise_privacy_header" msgid="7402406406883832509">"Afin d\'accéder à vos données professionnelles, votre organisation peut modifier des paramètres et installer des logiciels sur votre appareil.\n\nPour en savoir plus, communiquez avec l\'administrateur de votre organisation."</string>
    <string name="enterprise_privacy_exposure_category" msgid="7313392680107938517">"Types de données que votre organisation peut voir"</string>
    <string name="enterprise_privacy_exposure_changes_category" msgid="9079283547182933771">"Modifications apportées par l\'administrateur de votre organisation"</string>
    <string name="enterprise_privacy_device_access_category" msgid="5423434164248819058">"Votre accès à cet appareil"</string>
    <string name="enterprise_privacy_enterprise_data" msgid="2773968662865848413">"Les données associées à votre compte professionnel, comme les courriels et l\'agenda"</string>
    <string name="enterprise_privacy_installed_packages" msgid="2313698828178764590">"Liste des applications installées sur votre appareil"</string>
    <string name="enterprise_privacy_usage_stats" msgid="4398411405572759370">"Temps passé et quantité de données utilisée pour chaque application"</string>
    <string name="enterprise_privacy_network_logs" msgid="161722817268849590">"Journal de trafic réseau le plus récent"</string>
    <string name="enterprise_privacy_bug_reports" msgid="843225086779037863">"Rapport de bogue le plus récent"</string>
    <string name="enterprise_privacy_security_logs" msgid="5377362481617301074">"Journal de sécurité le plus récent"</string>
    <string name="enterprise_privacy_none" msgid="7706621148858381189">"Aucune"</string>
    <string name="enterprise_privacy_enterprise_installed_packages" msgid="6353757812144878828">"Applications installées"</string>
    <string name="enterprise_privacy_apps_count_estimation_info" msgid="7433213592572082606">"Le nombre d\'applications est estimé. Il peut exclure les applications installées à partir d\'une source autre que la boutique Google Play Store."</string>
    <plurals name="enterprise_privacy_number_packages_lower_bound" formatted="false" msgid="3005116533873542976">
      <item quantity="one">Minimum de <xliff:g id="COUNT_1">%d</xliff:g> application</item>
      <item quantity="other">Minimum de <xliff:g id="COUNT_1">%d</xliff:g> applications</item>
    </plurals>
    <string name="enterprise_privacy_location_access" msgid="4158197200885270634">"Autorisations de localisation"</string>
    <string name="enterprise_privacy_microphone_access" msgid="5717375623568864441">"Autorisations du microphone"</string>
    <string name="enterprise_privacy_camera_access" msgid="4858146118537519375">"Autorisations de l\'appareil photo"</string>
    <string name="enterprise_privacy_enterprise_set_default_apps" msgid="3288495615791128724">"Applications par défaut"</string>
    <plurals name="enterprise_privacy_number_packages" formatted="false" msgid="2765037387436064893">
      <item quantity="one"><xliff:g id="COUNT_1">%d</xliff:g> application</item>
      <item quantity="other"><xliff:g id="COUNT_1">%d</xliff:g> applications</item>
    </plurals>
    <string name="enterprise_privacy_input_method" msgid="6531350246850814920">"Clavier par défaut"</string>
    <string name="enterprise_privacy_input_method_name" msgid="4941106433683067953">"Valeur définie : <xliff:g id="APP_LABEL">%s</xliff:g>"</string>
    <string name="enterprise_privacy_always_on_vpn_device" msgid="4409098287763221215">"Le RPV permanent est activé"</string>
    <string name="enterprise_privacy_always_on_vpn_personal" msgid="9217774730260037434">"Le RPV permanent est activé dans votre profil personnel"</string>
    <string name="enterprise_privacy_always_on_vpn_work" msgid="7244472958208315814">"Le RPV permanent est activé dans votre profil professionnel"</string>
    <string name="enterprise_privacy_global_http_proxy" msgid="7936664553416257333">"Le serveur mandataire HTTP global a été défini"</string>
    <string name="enterprise_privacy_ca_certs_device" msgid="2019652712782510262">"Certificats de confiance"</string>
    <string name="enterprise_privacy_ca_certs_personal" msgid="2279084820904076599">"Certificats de confiance installés dans votre profil personnel"</string>
    <string name="enterprise_privacy_ca_certs_work" msgid="6187377647815301809">"Certificats de confiance installés dans votre profil professionnel"</string>
    <plurals name="enterprise_privacy_number_ca_certs" formatted="false" msgid="526375234629534165">
      <item quantity="one">Minimum de <xliff:g id="COUNT_1">%d</xliff:g> certificat CA</item>
      <item quantity="other">Minimum de <xliff:g id="COUNT_1">%d</xliff:g> certificats CA</item>
    </plurals>
    <string name="enterprise_privacy_lock_device" msgid="8791656477097208540">"L\'administrateur peut verrouiller l\'appareil et réinitialiser le mot de passe"</string>
    <string name="enterprise_privacy_wipe_device" msgid="2821960015797241790">"L\'administrateur peut supprimer toutes les données de l\'appareil"</string>
    <string name="enterprise_privacy_failed_password_wipe_device" msgid="1001255609345002878">"Nombre maximal de tentatives d\'entrée du mot de passe avant de supprimer toutes les données de l\'appareil"</string>
    <string name="enterprise_privacy_failed_password_wipe_work" msgid="4040565826652951057">"Nombre maximal de tentatives d\'entrée du mot de passe avant de supprimer les données du profil professionnel"</string>
    <plurals name="enterprise_privacy_number_failed_password_wipe" formatted="false" msgid="5279099270351036696">
      <item quantity="one"><xliff:g id="COUNT_1">%d</xliff:g> tentative</item>
      <item quantity="other"><xliff:g id="COUNT_1">%d</xliff:g> tentatives</item>
    </plurals>
    <string name="do_disclosure_generic" msgid="8653670456990823307">"Cet appareil est géré par votre organisation."</string>
    <string name="do_disclosure_with_name" msgid="1141081465968481380">"Cet appareil est géré par <xliff:g id="ORGANIZATION_NAME">%s</xliff:g>."</string>
    <string name="do_disclosure_learn_more_separator" msgid="3558079393757238670">" "</string>
    <string name="learn_more" msgid="2623878455042103404">"En savoir plus"</string>
    <plurals name="default_camera_app_title" formatted="false" msgid="1134677050353971363">
      <item quantity="one">Application d\'appareil photo</item>
      <item quantity="other">Applications d\'appareil photo</item>
    </plurals>
    <string name="default_calendar_app_title" msgid="3545972964391065220">"Application d\'agenda"</string>
    <string name="default_contacts_app_title" msgid="3497370557378660098">"Application de contacts"</string>
    <plurals name="default_email_app_title" formatted="false" msgid="42826975161049245">
      <item quantity="one">Application de client de courriel</item>
      <item quantity="other">Applications de client de courriel</item>
    </plurals>
    <string name="default_map_app_title" msgid="7560143381633608567">"Application de carte"</string>
    <plurals name="default_phone_app_title" formatted="false" msgid="6714041230953195024">
      <item quantity="one">Application de téléphone</item>
      <item quantity="other">Applications de téléphone</item>
    </plurals>
    <string name="app_names_concatenation_template_2" msgid="4309216198909946380">"<xliff:g id="FIRST_APP_NAME">%1$s</xliff:g> et <xliff:g id="SECOND_APP_NAME">%2$s</xliff:g>"</string>
    <string name="app_names_concatenation_template_3" msgid="8949045544491604376">"<xliff:g id="FIRST_APP_NAME">%1$s</xliff:g>, <xliff:g id="SECOND_APP_NAME">%2$s</xliff:g> et <xliff:g id="THIRD_APP_NAME">%3$s</xliff:g>"</string>
    <string name="storage_photos_videos" msgid="319854636702241898">"Photos et vidéos"</string>
    <string name="storage_music_audio" msgid="789779084825206838">"Musique et audio"</string>
    <string name="storage_games" msgid="7703159201697117621">"Jeux"</string>
    <string name="storage_other_apps" msgid="5524321740031718083">"Autres applications"</string>
    <string name="storage_files" msgid="8581083146777364063">"Fichiers"</string>
    <string name="storage_size_large_alternate" msgid="3395208658399637645">"<xliff:g id="NUMBER">^1</xliff:g>"<small>" "<font size="20">"<xliff:g id="UNIT">^2</xliff:g>"</font></small>""</string>
    <string name="storage_volume_total" msgid="3499221850532701342">"utilisé(s) sur <xliff:g id="TOTAL">%1$s</xliff:g>"</string>
    <string name="storage_percent_full" msgid="6095012055875077036">"utilisé"</string>
    <string name="clear_instant_app_data" msgid="2004222610585890909">"Effacer les données de l\'application"</string>
    <string name="clear_instant_app_confirmation" msgid="7451671214898856857">"Voulez-vous supprimer cette application instantanée?"</string>
    <string name="launch_instant_app" msgid="391581144859010499">"Ouvrir"</string>
    <string name="game_storage_settings" msgid="3410689937046696557">"Jeux"</string>
    <string name="audio_files_title" msgid="4777048870657911307">"Fichiers audio"</string>
    <string name="app_info_storage_title" msgid="5554719444625611987">"Espace utilisé"</string>
    <string name="webview_uninstalled_for_user" msgid="1819903169194420983">"(désinst. pour l\'utilisateur <xliff:g id="USER">%s</xliff:g>)"</string>
    <string name="webview_disabled_for_user" msgid="1216426047631256825">"(désactivé pour l\'utilisateur <xliff:g id="USER">%s</xliff:g>)"</string>
    <string name="autofill_app" msgid="7338387238377914374">"Service de remplissage auto"</string>
    <string name="autofill_keywords" msgid="7485591824120812710">"automatique, remplir, remplissage automatique"</string>
    <string name="autofill_confirmation_message" msgid="2784869528908005194">"&lt;b&gt;Assurez-vous de faire confiance à cette application&lt;/b&gt; &lt;br/&gt; &lt;br/&gt; &lt;xliff:g id=app_name example=Google Remplissage automatique&gt;%1$s&lt;/xliff:g&gt; utilise les éléments affichés à l\'écran pour déterminer les champs qui peuvent bénéficier de l\'entrée automatique."</string>
    <string name="debug_autofill_category" msgid="8050326960545979035">"Remplissage automatique"</string>
    <string name="autofill_logging_level_title" msgid="899483289251346778">"Niveau de journalisation"</string>
    <string name="autofill_max_partitions" msgid="7590272120101271461">"Nombre maximal de demandes par session"</string>
    <string name="autofill_max_visible_datasets" msgid="4531033613378881109">"Nombre maximal d\'ensembles de données"</string>
    <string name="autofill_reset_developer_options" msgid="5819016237049525099">"Réinitialiser aux valeurs par défaut"</string>
    <string name="autofill_reset_developer_options_complete" msgid="7548288932341619412">"Les options de remplissage automatique du concepteur ont été réinitialisées"</string>
    <string name="device_theme" msgid="4571803018917608588">"Thème de l\'appareil"</string>
    <string name="default_theme" msgid="7085644992078579076">"Par défaut"</string>
    <string name="show_operator_name_title" msgid="805135053530442951">"Nom du réseau"</string>
    <string name="show_operator_name_summary" msgid="5962567590205757550">"Afficher le nom du réseau dans la barre d\'état"</string>
    <string name="storage_manager_indicator" msgid="1516810749625915020">"Gestionnaire de stockage : <xliff:g id="STATUS">^1</xliff:g>"</string>
    <string name="storage_manager_indicator_off" msgid="7488057587180724388">"Désactivé"</string>
    <string name="storage_manager_indicator_on" msgid="8625551710194584733">"Activé"</string>
    <string name="install_type_instant" msgid="3174425974536078647">"Application instantanée"</string>
    <string name="automatic_storage_manager_deactivation_warning" msgid="5605210730828410482">"Désactiver le gestionnaire de stockage?"</string>
    <string name="storage_movies_tv" msgid="5498394447562086890">"Applis de films et d\'émissions"</string>
    <string name="carrier_provisioning" msgid="4398683675591893169">"Données d\'approvisionnement du fournisseur de services"</string>
    <string name="trigger_carrier_provisioning" msgid="3434865918009286187">"Déclencher l\'approvisionnement du fournisseur de services"</string>
    <string name="zen_suggestion_title" msgid="798067603460192693">"Mettre à jour les paramètres du mode Ne pas déranger"</string>
    <string name="zen_suggestion_summary" msgid="5928686804697233014">"Suspendre les notifications pour rester concentré"</string>
    <string name="disabled_low_ram_device" msgid="3751578499721173344">"Cette fonctionnalité n\'est pas accessible sur cet appareil."</string>
    <string name="disabled_feature" msgid="3232554901854971743">"Cette fonctionnalité n\'est pas accessible"</string>
    <string name="disabled_feature_reason_slow_down_phone" msgid="3557117039415422481">"Cette fonctionnalité a été désactivée, car elle ralentit votre téléphone"</string>
    <string name="enable_gnss_raw_meas_full_tracking" msgid="1294470289520660584">"Forcer les mesures GNSS complètes"</string>
    <string name="enable_gnss_raw_meas_full_tracking_summary" msgid="496344699046454200">"Faire le suivi de toutes les constellations et les fréquences GNSS sans cycle de tâches"</string>
    <string name="show_first_crash_dialog" msgid="8889957119867262599">"Toujours afficher la fenêtre de plantage"</string>
    <string name="show_first_crash_dialog_summary" msgid="703224456285060428">"Afficher la fenêtre chaque fois qu\'une application plante"</string>
    <string name="angle_enabled_app" msgid="1841862539745838255">"Sélectionnez l\'application compatible avec ANGLE"</string>
    <string name="angle_enabled_app_not_set" msgid="864740024581634768">"Aucune application compatible avec ANGLE n\'a été définie"</string>
    <string name="angle_enabled_app_set" msgid="226015765615525056">"Application compatible avec ANGLE : <xliff:g id="APP_NAME">%1$s</xliff:g>"</string>
    <string name="game_driver_dashboard_title" msgid="8804074441354504919">"Préférences de pilote de jeu"</string>
    <string name="game_driver_dashboard_summary" msgid="2392113100578771289">"Modifier les paramètres du pilote de jeu"</string>
    <string name="game_driver_footer_text" msgid="3202576403048267763">"Lorsque le paramètre Pilote de jeu est activé, vous pouvez choisir d\'utiliser le pilote graphique à jour pour les applications installées sur l\'appareil."</string>
    <string name="game_driver_all_apps_preference_title" msgid="6067527642706295180">"Activer pour toutes les applications"</string>
    <string name="game_driver_app_preference_title" msgid="5072626013346650374">"Sélectionner un pilote graphique"</string>
    <string name="game_driver_app_preference_default" msgid="7686384740483216333">"Par défaut"</string>
    <string name="game_driver_app_preference_game_driver" msgid="6426312331295324606">"Paquets du jeu"</string>
    <string name="game_driver_app_preference_prerelease_driver" msgid="1295460693830677733">"Pilote de version préliminaire"</string>
    <string name="game_driver_app_preference_system" msgid="8272672982113332753">"Pilote graphique du système"</string>
    <!-- no translation found for game_driver_all_apps_preference_values:0 (7193648562434970105) -->
    <!-- no translation found for game_driver_all_apps_preference_values:1 (7189663725490629463) -->
    <!-- no translation found for game_driver_all_apps_preference_values:2 (7166160247759864796) -->
    <!-- no translation found for game_driver_app_preference_values:0 (4271044622117073985) -->
    <!-- no translation found for game_driver_app_preference_values:1 (6628516810440406199) -->
    <!-- no translation found for game_driver_app_preference_values:2 (1760397725970916076) -->
    <!-- no translation found for game_driver_app_preference_values:3 (6260984152570269090) -->
    <string name="unsupported_setting_summary" product="default" msgid="11246953620654225">"Le paramètre n\'est pas compatible avec ce téléphone"</string>
    <string name="unsupported_setting_summary" product="tablet" msgid="6328431665635673717">"Le paramètre n\'est pas compatible avec cette tablette"</string>
    <string name="unsupported_setting_summary" product="device" msgid="2348970994972110886">"Le paramètre n\'est pas compatible avec cet appareil"</string>
    <string name="disabled_for_user_setting_summary" msgid="3388525317680711262">"Le paramètre ne peut pas être modifié par l\'utilisateur actuel"</string>
    <string name="disabled_dependent_setting_summary" msgid="8291322239940946902">"Dépend d\'un autre paramètre"</string>
    <string name="unknown_unavailability_setting_summary" msgid="4589584678033059435">"Paramètre non accessible"</string>
    <string name="my_device_info_account_preference_title" msgid="342933638925781861">"Compte"</string>
    <string name="my_device_info_device_name_preference_title" msgid="7104085224684165324">"Nom de l\'appareil"</string>
    <string name="change_wifi_state_title" msgid="3261945855372885427">"Gestion du Wi-Fi"</string>
    <string name="change_wifi_state_app_detail_switch" msgid="7942268646980694224">"Autoriser l\'application à gérer le Wi-Fi"</string>
    <string name="change_wifi_state_app_detail_summary" msgid="8434262633905502679">"Autorisez cette application à activer ou à désactiver le Wi-Fi, à rechercher les réseaux Wi-Fi et à s\'y connecter, à ajouter et à supprimer des réseaux ou à créer un point d\'accès local uniquement"</string>
    <string name="media_output_title" msgid="115223550977351699">"Faire jouer les médias vers"</string>
    <string name="media_output_default_summary" msgid="8115153381240348279">"Cet appareil"</string>
    <string name="media_output_summary" product="default" msgid="6839458453831567167">"Téléphone"</string>
    <string name="media_output_summary" product="tablet" msgid="7217221078578554515">"Tablette"</string>
    <string name="media_output_summary" product="device" msgid="5677420090811068649">"Appareil"</string>
    <string name="media_out_summary_ongoing_call_state" msgid="3533731701018680693">"Indisponible pendant les appels"</string>
    <string name="media_output_summary_unavailable" msgid="7970304720507697019">"Indisponible"</string>
    <string name="take_call_on_title" msgid="6066362463436122655">"Répondre à l\'appel sur"</string>
    <string name="cannot_change_apn_toast" msgid="4652498125702594916">"Impossible de modifier ce nom de point d\'accès."</string>
    <string name="battery_suggestion_title" product="tablet" msgid="752439050748267917">"Améliorer l\'autonomie de la tablette"</string>
    <string name="battery_suggestion_title" product="device" msgid="1507272328369733005">"Améliorer l\'autonomie de l\'appareil"</string>
    <string name="battery_suggestion_title" product="default" msgid="4038053023336285165">"Améliorer l\'autonomie du téléphone"</string>
    <string name="battery_suggestion_summary" msgid="4585677159811722359"></string>
    <string name="gesture_prevent_ringing_screen_title" msgid="7840226017975251549">"Empêcher la sonnerie"</string>
    <string name="gesture_prevent_ringing_title" msgid="5961391929839748111">"Appuyez simultanément sur l\'interrupteur et sur la touche d\'augmentation du volume pour"</string>
    <string name="gesture_prevent_ringing_sound_title" msgid="5724512060316688779">"Raccourci pour empêcher la sonnerie"</string>
    <string name="prevent_ringing_option_vibrate" msgid="7286821846542822661">"Activer les vibrations"</string>
    <string name="prevent_ringing_option_mute" msgid="7551545579059879853">"Désactiver le son"</string>
    <string name="prevent_ringing_option_none" msgid="4656046650769569175">"Ne rien faire"</string>
    <string name="prevent_ringing_option_vibrate_summary" msgid="1157524435626890116">"Activé (vibration)"</string>
    <string name="prevent_ringing_option_mute_summary" msgid="4472465110708640980">"Activé (muet)"</string>
    <string name="prevent_ringing_option_none_summary" msgid="5013718946609276137">"Désactivé"</string>
    <string name="pref_title_network_details" msgid="7186418845727358964">"Détails du réseau"</string>
    <string name="about_phone_device_name_warning" msgid="8885670415541365348">"Le nom de votre appareil est visible pour les applications de votre téléphone. Il est aussi possible que d\'autres personnes le voient lorsque vous vous connectez à des appareils Bluetooth ou lorsque vous configurez un point d\'accès Wi-Fi."</string>
    <string name="devices_title" msgid="7701726109334110391">"Appareils"</string>
    <string name="homepage_all_settings" msgid="1245540304900512919">"Tous les paramètres"</string>
    <string name="homepage_personal_settings" msgid="1570415428680432319">"Suggestions"</string>
    <string name="choose_network_title" msgid="5702586742615861037">"Choisir un réseau"</string>
    <string name="network_disconnected" msgid="2933191767567503504">"Déconnecté"</string>
    <string name="network_connected" msgid="4943925032253989621">"Connecté"</string>
    <string name="network_connecting" msgid="76404590784733557">"Connexion en cours…"</string>
    <string name="network_could_not_connect" msgid="1113813392274155369">"Impossible de se connecter"</string>
    <string name="empty_networks_list" msgid="2578752112731781190">"Aucun réseau trouvé."</string>
    <string name="network_query_error" msgid="7487714485362598410">"Impossible de trouver des réseaux. Réessayez."</string>
    <string name="forbidden_network" msgid="4626592887509826545">"(interdit)"</string>
    <string name="no_sim_card" msgid="1360669528113557381">"Aucune carte SIM"</string>
    <string name="preferred_network_mode_wcdma_perf_summary" msgid="3956515670308744433">"Mode réseau préféré : WCDMA de préférence"</string>
    <string name="preferred_network_mode_gsm_only_summary" msgid="5225727680228194864">"Mode réseau préféré : GSM uniquement"</string>
    <string name="preferred_network_mode_wcdma_only_summary" msgid="8956197584659205699">"Mode réseau préféré : WCDMA uniquement"</string>
    <string name="preferred_network_mode_gsm_wcdma_summary" msgid="4290654515569144276">"Mode réseau préféré : GSM/WCDMA"</string>
    <string name="preferred_network_mode_cdma_summary" msgid="854981096234906594">"Mode réseau préféré : CDMA"</string>
    <string name="preferred_network_mode_cdma_evdo_summary" msgid="2578065433446506616">"Mode réseau préféré : CDMA/EvDo"</string>
    <string name="preferred_network_mode_cdma_only_summary" msgid="6604102246309629962">"Mode réseau préféré : CDMA uniquement"</string>
    <string name="preferred_network_mode_evdo_only_summary" msgid="7558385602277592784">"Mode réseau préféré : EvDo uniquement"</string>
    <string name="preferred_network_mode_cdma_evdo_gsm_wcdma_summary" msgid="1742638677806401815">"Mode réseau préféré : CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_lte_summary" msgid="8528755811985330696">"Mode réseau préféré : LTE"</string>
    <string name="preferred_network_mode_lte_gsm_wcdma_summary" msgid="6632007438739933645">"Mode réseau préféré : GSM/WCDMA/LTE"</string>
    <string name="preferred_network_mode_lte_cdma_evdo_summary" msgid="5464960267483576515">"Mode réseau préféré : CDMA+LTE/EvDo"</string>
    <string name="preferred_network_mode_global_summary" msgid="8552400100470153638">"Mode réseau préféré : global"</string>
    <string name="preferred_network_mode_lte_wcdma_summary" msgid="8037915274486919940">"Mode réseau préféré : LTE/WCDMA"</string>
    <string name="preferred_network_mode_lte_gsm_umts_summary" msgid="104110625441127919">"Mode réseau préféré : LTE/GSM/UMTS"</string>
    <string name="preferred_network_mode_lte_cdma_summary" msgid="2561159741461407053">"Mode réseau préféré : LTE/CDMA"</string>
    <string name="preferred_network_mode_tdscdma_summary" msgid="1111689194136766011">"Mode réseau préféré : TDSCDMA"</string>
    <string name="preferred_network_mode_tdscdma_wcdma_summary" msgid="4272515966019344433">"Mode réseau préféré : TDSCDMA/WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_summary" msgid="3138210224248737600">"Mode réseau préféré : LTE/TDSCDMA"</string>
    <string name="preferred_network_mode_tdscdma_gsm_summary" msgid="7575595856957063853">"Mode réseau préféré : TDSCDMA/GSM"</string>
    <string name="preferred_network_mode_lte_tdscdma_gsm_summary" msgid="1512046749970721629">"Mode réseau préféré : LTE/GSM/TDSCDMA"</string>
    <string name="preferred_network_mode_tdscdma_gsm_wcdma_summary" msgid="1038314909945393905">"Mode réseau préféré : TDSCDMA/GSM/WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_wcdma_summary" msgid="3277980364222159279">"Mode réseau préféré : LTE/TDSCDMA/WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_gsm_wcdma_summary" msgid="1572937828071126891">"Mode réseau préféré : LTE/TDSCDMA/GSM/WCDMA"</string>
    <string name="preferred_network_mode_tdscdma_cdma_evdo_gsm_wcdma_summary" msgid="8393145171649288912">"Mode réseau préféré : TDSCDMA/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_cdma_evdo_gsm_wcdma_summary" msgid="5544016990994809932">"Mode réseau préféré : LTE/TDSCDMA/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="network_lte" msgid="1287709529829131860">"LTE (recommandé)"</string>
    <string name="network_4G" msgid="8611758013994499559">"4G (recommandé)"</string>
    <string name="network_global" msgid="959947774831178632">"Global"</string>
    <string name="label_available" msgid="1731547832803057893">"Réseaux disponibles"</string>
    <string name="load_networks_progress" msgid="7709402068413190831">"Recherche en cours…"</string>
    <string name="register_on_network" msgid="766516026652295941">"Enregistrement sur <xliff:g id="NETWORK">%s</xliff:g> en cours…"</string>
    <string name="not_allowed" msgid="1667079919821581706">"Votre carte SIM ne vous permet pas de vous connecter à ce réseau."</string>
    <string name="connect_later" msgid="978991102125216741">"Impossible de se connecter à ce réseau pour le moment. Veuillez réessayer plus tard."</string>
    <string name="registration_done" msgid="4573820010512184521">"Enregistré sur le réseau."</string>
    <string name="select_automatically" msgid="7318032984017853975">"Sélectionner automatiquement le réseau"</string>
    <string name="carrier_settings_title" msgid="3503012527671299886">"Param. du fourn. de serv."</string>
    <string name="cdma_lte_data_service" msgid="8507044148856536098">"Configurer service de données"</string>
    <string name="mobile_data_settings_title" msgid="7674604042461065482">"Données cellulaires"</string>
    <string name="mobile_data_settings_summary" msgid="2708261377199805404">"Accéder aux données sur réseau cellulaire"</string>
    <string name="mobile_data_settings_summary_auto_switch" msgid="2914985502279794000">"Le téléphone passera automatiquement sur le réseau de ce fournisseur de services lorsqu\'il se trouve dans sa zone de couverture"</string>
    <string name="calls_preference" msgid="4628557570999372758">"Préférences d\'appel"</string>
    <string name="sms_preference" msgid="3479810211828513772">"Préférences de messagerie texte"</string>
    <string name="calls_and_sms_ask_every_time" msgid="2127802836576375306">"Toujours demander"</string>
    <string name="mobile_network_summary_add_a_network" msgid="9148476748420654283">"Ajouter un réseau"</string>
    <plurals name="mobile_network_summary_count" formatted="false" msgid="4505694491027023039">
      <item quantity="one"><xliff:g id="COUNT_1">%1$d</xliff:g> carte SIM</item>
      <item quantity="other"><xliff:g id="COUNT_1">%1$d</xliff:g> cartes SIM</item>
    </plurals>
    <string name="default_for_calls" msgid="6732520879241581841">"Valeur par défaut pour les appels"</string>
    <string name="default_for_sms" msgid="294276190503132313">"Valeur par défaut pour les messages texte"</string>
    <string name="default_for_calls_and_sms" msgid="3862322027700754792">"Valeur par déf. pour appels et les textos"</string>
    <string name="default_for_mobile_data" msgid="955987144209828344">"Valeur par défaut pour donn. cellulaires"</string>
    <string name="mobile_data_active" msgid="5108294051762397700">"Données cellulaires actives"</string>
    <string name="mobile_data_off" msgid="5831854766113105657">"Données cellulaires désactivées"</string>
    <string name="subscription_available" msgid="6502502298446954785">"Disponible"</string>
    <string name="mobile_network_in_range" msgid="8212440637838603215">"À portée"</string>
    <string name="mobile_network_not_in_range" msgid="5287596455212313284">"Hors de portée"</string>
    <string name="mobile_network_list_add_more" msgid="4000806369124701679">"Ajouter"</string>
    <string name="mobile_network_active_sim" msgid="2375956837678169169">"Services actifs/Carte SIM"</string>
    <string name="mobile_network_inactive_sim" msgid="291768076436646044">"Services inactifs/Carte SIM"</string>
    <string name="mobile_network_active_esim" msgid="4914509039134228659">"Services actifs/Cartes SIM téléchargées"</string>
    <string name="mobile_network_inactive_esim" msgid="7653631389686307842">"Services inactifs/Cartes SIM téléchargées"</string>
    <string name="mobile_network_sim_name" msgid="6026120971523242277">"Nom et couleur de la carte SIM"</string>
    <string name="mobile_network_sim_name_label" msgid="281403463781467324">"Nom"</string>
    <string name="mobile_network_sim_color_label" msgid="3662112943353180621">"Couleur (utilisée par applis compatibles)"</string>
    <string name="mobile_network_sim_name_rename" msgid="3082357234342116252">"Enregistrer"</string>
    <string name="mobile_network_use_sim_on" msgid="8035448244261570189">"Utiliser la carte SIM"</string>
    <string name="mobile_network_use_sim_off" msgid="889073420068380943">"Désactivé"</string>
    <string name="mobile_network_disable_sim_explanation" msgid="1515981880164339357">"Pour désactiver cette carte SIM, retirez-la"</string>
    <string name="mobile_network_tap_to_activate" msgid="4573431375941175566">"Touchez pour activer le réseau de <xliff:g id="CARRIER">%1$s</xliff:g>"</string>
    <string name="mobile_network_esim_swap_confirm_title" msgid="6546784593612512953">"Passer au réseau de <xliff:g id="CARRIER">%1$s</xliff:g>?"</string>
    <string name="mobile_network_esim_swap_confirm_body" msgid="1621021150667547211">"Une seule carte SIM téléchargée peut être active à la fois.\n\nLe fait de passer au réseau de <xliff:g id="CARRIER1">%1$s</xliff:g> n\'annulera pas votre service auprès de <xliff:g id="CARRIER2">%2$s</xliff:g>."</string>
    <string name="mobile_network_esim_swap_confirm_ok" msgid="8025086398614992834">"Passer au réseau de <xliff:g id="CARRIER">%1$s</xliff:g>"</string>
    <string name="mobile_network_erase_sim" msgid="896275511321635947">"Effacer la carte SIM"</string>
    <string name="mobile_network_erase_sim_dialog_title" msgid="8211945787729023193">"Effacer cette carte SIM téléchargée?"</string>
    <string name="mobile_network_erase_sim_dialog_body" msgid="3363079846287650684">"Si vous effacez cette carte SIM, le service de <xliff:g id="CARRIER_0">%1$s</xliff:g> sera supprimé de cet appareil.\n\nLe service de <xliff:g id="CARRIER_1">%2$s</xliff:g> ne sera pas annulé."</string>
    <string name="mobile_network_erase_sim_dialog_ok" msgid="5130805470041783437">"Effacer"</string>
    <string name="mobile_network_erase_sim_dialog_progress" msgid="6541813899575453878">"Effacement de la carte SIM en cours…"</string>
    <string name="mobile_network_erase_sim_error_dialog_title" msgid="730767308428197756">"Impossible d\'effacer la carte SIM"</string>
    <string name="mobile_network_erase_sim_error_dialog_body" msgid="6835262809290075813">"Cette carte SIM ne peut pas être effacée en raison d\'une erreur.\n\nRedémarrez votre appareil et réessayez."</string>
    <string name="preferred_network_mode_title" msgid="6505630109389684100">"Type de réseau préféré"</string>
    <string name="preferred_network_mode_summary" msgid="1216219115667163264">"Changer le mode de fonctionnement du réseau"</string>
    <string name="preferred_network_mode_dialogtitle" msgid="849254040214447984">"Type de réseau préféré"</string>
    <string name="carrier_settings_euicc" msgid="8658562169133242581">"Fournisseur de services"</string>
    <string name="carrier_settings_version" msgid="3469507893844448432">"Version des paramètres"</string>
    <string name="call_category" msgid="8108654745239563833">"Appels"</string>
    <string name="video_calling_settings_title" msgid="8153216918491498505">"Appels vidéo par l\'entremise du fournisseur de services"</string>
    <string name="cdma_system_select_title" msgid="7210256688912895790">"Sélection système"</string>
    <string name="cdma_system_select_summary" msgid="3413863051181111941">"Modifier le mode d\'itinérance CDMA"</string>
    <string name="cdma_system_select_dialogtitle" msgid="1198883288864916563">"Sélection système"</string>
    <string name="network_operator_category" msgid="8451238364605724918">"Réseau"</string>
    <string name="network_select_title" msgid="8394621216255081026">"Réseau"</string>
    <string name="cdma_subscription_title" msgid="1473189596933979467">"Abonnement CDMA"</string>
    <string name="cdma_subscription_summary" msgid="7191590908367194209">"Basculer entre les cartes RUIM/SIM et NV"</string>
    <string name="cdma_subscription_dialogtitle" msgid="9153005469617575361">"abonnement"</string>
    <string name="register_automatically" msgid="518185886971595020">"Enregistrement automatique en cours…"</string>
    <string name="roaming_alert_title" msgid="7458177294163751484">"Autoriser les données en itinérance?"</string>
    <string name="roaming_check_price_warning" msgid="4979418631753681300">"Communiquez avec votre fournisseur réseau pour connaître les tarifs."</string>
    <string name="mobile_data_usage_title" msgid="7862429216994894656">"Utilisation des données par application"</string>
    <string name="mobile_network_mode_error" msgid="4784347953600013818">"Mode réseau non valide : <xliff:g id="NETWORKMODEID">%1$d</xliff:g>. Ignorer."</string>
    <string name="mobile_network_apn_title" msgid="7610812642954395440">"Noms des points d\'accès"</string>
    <string name="manual_mode_disallowed_summary" msgid="2085670341790561153">"Indisponible lorsque vous êtes connectés au réseau de <xliff:g id="CARRIER">%1$s</xliff:g>"</string>
    <string name="emergency_info_contextual_card_summary" msgid="7993926837251874514">"Renseignements médicaux, contacts d\'urgence"</string>
    <string name="see_more" msgid="5953815986207345223">"En voir plus"</string>
    <string name="see_less" msgid="1250265310929558370">"En voir moins"</string>
    <string name="network_connection_request_dialog_title" msgid="3502355504717957803">"Appareil à utiliser avec <xliff:g id="APPNAME">%1$s</xliff:g>"</string>
    <string name="network_connection_timeout_dialog_message" msgid="3711556077945728716">"Aucun appareil trouvé. Assurez-vous que l\'appareil est allumé et prêt à se connecter."</string>
    <string name="network_connection_timeout_dialog_ok" msgid="8924405960181020156">"Réessayer"</string>
    <string name="network_connection_errorstate_dialog_message" msgid="6953778550775646710">"Une erreur s\'est produite. L\'application a annulé la demande de sélection d\'un appareil."</string>
    <string name="network_connection_connect_successful" msgid="5935510954474494928">"Connexion réussie"</string>
    <string name="network_connection_request_dialog_showall" msgid="6938922880244567521">"Tout afficher"</string>
    <plurals name="show_bluetooth_devices" formatted="false" msgid="1715020480026568408">
      <item quantity="one"><xliff:g id="NUMBER_DEVICE_COUNT_1">%1$d</xliff:g> appareil connecté</item>
      <item quantity="other"><xliff:g id="NUMBER_DEVICE_COUNT_1">%1$d</xliff:g> appareils connectés</item>
    </plurals>
    <string name="no_bluetooth_devices" msgid="861861879657732058">"Aucun appareil Bluetooth"</string>
    <string name="bluetooth_left_name" msgid="2133431890020995442">"Gauche"</string>
    <string name="bluetooth_right_name" msgid="525578831502355410">"Droite"</string>
    <string name="bluetooth_middle_name" msgid="3272836932362043957">"Étui"</string>
    <string name="settings_panel_title" msgid="4688575606213055744">"Panneau Paramètres"</string>
    <string name="internet_connectivity_panel_title" msgid="721392242301676444">"Connectivité Internet"</string>
    <string name="volume_connectivity_panel_title" msgid="9192664643867101356">"Volume"</string>
    <string name="mobile_data_ap_mode_disabled" msgid="1127588179830051811">"Données cellulaires non accessibles en mode Vol"</string>
    <string name="force_desktop_mode" msgid="4303240595324847998">"Forcer le mode bureau"</string>
    <string name="force_desktop_mode_summary" msgid="6259798246015387202">"Forcer le mode bureau expérimental sur les écrans secondaires"</string>
    <string name="hwui_force_dark_title" msgid="2466919877609396257">"Forcer l\'activation de SmartDark"</string>
    <string name="hwui_force_dark_summary" msgid="8705328793382981780">"Forcer la fonctionnalité SmartDark à rester active"</string>
    <string name="privacy_dashboard_title" msgid="2458407399263943923">"Confidentialité"</string>
    <string name="privacy_dashboard_summary" msgid="4570241983077984329">"Autorisations, activité du compte, données personnelles"</string>
    <string name="contextual_card_dismiss_remove" msgid="2813670241047194713">"Supprimer"</string>
    <string name="contextual_card_dismiss_keep" msgid="2230740610451447340">"Garder"</string>
    <string name="contextual_card_dismiss_confirm_message" msgid="5507487987591500742">"Supprimer cette suggestion?"</string>
    <string name="contextual_card_removed_message" msgid="6744732110721136227">"Suggestion supprimée"</string>
    <string name="contextual_card_undo_dismissal_text" msgid="3564089284222177020">"Annuler"</string>
    <string name="low_storage_summary" msgid="2077564126033530">"L\'espace de stockage est presque plein. Espace utilisé : <xliff:g id="PERCENTAGE">%1$s</xliff:g>. Espace libre : <xliff:g id="FREE_SPACE">%2$s</xliff:g>."</string>
    <string name="contextual_card_feedback_send" msgid="2996691837358030021">"Envoyer des commentaires"</string>
    <string name="contextual_card_feedback_confirm_message" msgid="8115454795160804779">"Souhaitez-vous nous envoyer des commentaires sur cette suggestion?"</string>
    <string name="copyable_slice_toast" msgid="2924110841440836023">"<xliff:g id="COPY_CONTENT">%1$s</xliff:g> copié dans le presse-papiers"</string>
    <string name="search_bar_account_avatar_content_description" msgid="4718261366290530792"></string>
    <string name="permission_bar_chart_empty_text" msgid="4380731551728553852">"Aucune application n\'a utilisé les autorisations"</string>
    <string name="permission_bar_chart_title" msgid="2745425703472199837">"Autorisations utilisées (24 dernières heures)"</string>
    <string name="permission_bar_chart_details" msgid="2977943114535855210">"Tout afficher dans le tableau de bord"</string>
    <plurals name="permission_bar_chart_label" formatted="false" msgid="5346938677887948252">
      <item quantity="one"><xliff:g id="NUMBER">%s</xliff:g> application</item>
      <item quantity="other"><xliff:g id="NUMBER">%s</xliff:g> applications</item>
    </plurals>
    <string name="accessibility_usage_title" msgid="5136753034714150614">"Usage des fonctions d\'accessibilité"</string>
    <plurals name="accessibility_usage_summary" formatted="false" msgid="5790789101231115740">
      <item quantity="one"><xliff:g id="SERVICE_COUNT">%1$d</xliff:g> application a l\'accès complet à votre appareil</item>
      <item quantity="other"><xliff:g id="SERVICE_COUNT">%1$d</xliff:g> applications ont l\'accès complet à votre appareil</item>
    </plurals>
    <string name="manage_app_notification" msgid="4575452737886198216">"Gérer les notifications de l\'application <xliff:g id="APP_NAME">%1$s</xliff:g>"</string>
    <string name="no_suggested_app" msgid="5722034393216359231">"Aucune suggestion d\'application"</string>
    <plurals name="notification_few_channel_count_summary" formatted="false" msgid="1090888820158822106">
      <item quantity="one"><xliff:g id="NOTIFICATION_CHANNEL_COUNT_1">%1$d</xliff:g> canal de notification.</item>
      <item quantity="other"><xliff:g id="NOTIFICATION_CHANNEL_COUNT_1">%1$d</xliff:g> canaux de notification.</item>
    </plurals>
    <string name="notification_many_channel_count_summary" msgid="8647409434789898073">"<xliff:g id="NOTIFICATION_CHANNEL_COUNT">%1$d</xliff:g> canaux de notification. Touchez ici pour les gérer."</string>
    <string name="recently_installed_app" msgid="2877671740090335492">"Vous avez récemment installé cette application."</string>
    <string name="media_output_panel_title" msgid="6197092814295528184">"Changer de sortie"</string>
    <string name="media_output_panel_summary_of_playing_device" msgid="629529380940058789">"En cours de lecture sur l\'appareil <xliff:g id="DEVICE_NAME">%1$s</xliff:g>"</string>
    <string name="wfc_disclaimer_title_text" msgid="6164569741719679613">"Renseignements importants"</string>
    <string name="wfc_disclaimer_agree_button_text" msgid="1405773141236165542">"CONTINUER"</string>
    <string name="wfc_disclaimer_disagree_text" msgid="2700358281438736674">"NON MERCI"</string>
    <string name="wfc_disclaimer_location_title_text" msgid="6658735446562619865">"Lieu"</string>
    <string name="wfc_disclaimer_location_desc_text" msgid="3096546236221656018">"Il se peut que votre fournisseur de services recueille votre position pour vous fournir ce service.\n\nVeuillez consulter la politique de confidentialité de votre fournisseur de services."</string>
    <string name="forget_passpoint_dialog_message" msgid="7331876195857622224">"Vous risquez de perdre l\'accès au temps ou aux données restants. Communiquez avec votre fournisseur de services avant de procéder au retrait."</string>
    <string name="keywords_content_capture" msgid="8252675452668954083">"capture de contenu, contenu de l\'application"</string>
    <string name="content_capture" msgid="3210232615756364639">"Contenu de l\'application"</string>
    <string name="content_capture_summary" msgid="659506647507221852">"Autoriser les applications à envoyer du contenu au système Android"</string>
    <string name="capture_system_heap_dump_title" msgid="8043655498113164693">"Capturer l\'empreinte de mémoire système"</string>
    <string name="capturing_system_heap_dump_message" msgid="8680086369500395131">"Capture de l\'empreinte de mémoire système en cours…"</string>
    <string name="error_capturing_system_heap_dump_message" msgid="6346229989760615103">"Impossible de capturer l\'empreinte de mémoire du système"</string>
    <string name="automatic_system_heap_dump_title" msgid="442496436397957988">"Capturer automatiquement les empreintes de mémoire système"</string>
    <string name="automatic_system_heap_dump_summary" msgid="8253838659009241350">"Capturer automatiquement une empreinte de mémoire pour le système Android lorsqu\'il utilise trop de mémoire"</string>
    <string name="wifi_disconnect_button_text" msgid="2032651902928903819">"Déconnexion"</string>
    <string name="wfc_disclaimer_emergency_limitation_title_text" msgid="3354031536141983602">"Appels d\'urgence"</string>
    <string name="wfc_disclaimer_emergency_limitation_desc_text" msgid="6068582272230311464">"Votre fournisseur de services ne prend pas en charge les appels Wi‑Fi.\nL\'appareil basculera automatiquement vers le réseau cellulaire pour faire un appel urgence.\nLes appels d\'urgence sont uniquement possibles dans les régions couvertes par un réseau cellulaire."</string>
    <string name="wifi_calling_summary" msgid="513599567573172420">"Utiliser le Wi‑Fi pour les appels afin d\'améliorer la qualité"</string>
    <string name="enable_receiving_mms_notification_title" msgid="8809328429865242752">"Message multimédia entrant"</string>
    <string name="enable_sending_mms_notification_title" msgid="3852773093703966351">"Impossible d\'envoyer le message multimédia"</string>
    <string name="enable_mms_notification_summary" msgid="7643379825980866408">"Touchez pour autor. mess. multim. sur le réseau de <xliff:g id="OPERATOR_NAME">%1$s</xliff:g> lorsque les données cellulaires sont désactivées"</string>
    <string name="enable_mms_notification_channel_title" msgid="4402474709766126987">"Message multimédia"</string>
    <string name="sim_combination_warning_notification_title" msgid="3717178238465948430">"Problème avec la combinaison de cartes SIM"</string>
    <string name="dual_cdma_sim_warning_notification_summary" msgid="2602011424635850202">"L\'utilisation de <xliff:g id="OPERATOR_NAMES">%1$s</xliff:g> pourrait limiter la fonctionnalité. Touchez ici pour en savoir plus."</string>
    <string name="dual_cdma_sim_warning_notification_channel_title" msgid="4144088600737896010">"Combinaison de cartes SIM"</string>
    <string name="work_policy_privacy_settings" msgid="2348992644755730215">"Les détails de votre politique professionnelle"</string>
    <string name="work_policy_privacy_settings_summary" msgid="2236899807429121767">"Les paramètres sont gérés par votre administrateur informatique"</string>
</resources>
