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

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

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

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

<resources xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
    <string name="yes" msgid="1999566976857398962">"Oui"</string>
    <string name="no" msgid="5541738710521607130">"Non"</string>
    <string name="create" msgid="986997212165228751">"Créer"</string>
    <string name="allow" msgid="3763244945363657722">"Autoriser"</string>
    <string name="deny" msgid="7326117222944479942">"Refuser"</string>
    <string name="confirmation_turn_on" msgid="2979094011928347665">"Activer"</string>
    <string name="device_info_default" msgid="1406619232867343310">"Inconnu"</string>
    <string name="device_info_protected_single_press" msgid="3810785480060743677">"Touchez pour afficher les renseignements"</string>
    <string name="show_dev_countdown" msgid="2936506773086395069">"{count,plural, =1{Plus que # étape pour devenir un développeur.}one{Plus que # étape pour devenir un développeur.}other{Plus que # étapes pour devenir un développeur.}}"</string>
    <string name="show_dev_on" msgid="2840850085134853754">"Vous êtes maintenant développeur!"</string>
    <string name="show_dev_already" msgid="7041756429707644630">"Inutile, vous êtes déjà un développeur."</string>
    <string name="dev_settings_disabled_warning" msgid="6971867026249671244">"Veuillez d\'abord activer les options pour les développeurs"</string>
    <string name="header_category_system" msgid="1665516346845259058">"Système"</string>
    <string name="radioInfo_service_in" msgid="9088637745836646271">"En service"</string>
    <string name="radioInfo_service_out" msgid="1868347333892403287">"Hors service"</string>
    <string name="radioInfo_service_off" msgid="6184928420860868571">"Signal radio désactivé"</string>
    <string name="radioInfo_roaming_in" msgid="8892550453644088692">"Itinérance"</string>
    <string name="radioInfo_roaming_not" msgid="3137594549464975054">"Pas en itinérance"</string>
    <string name="radioInfo_data_disconnected" msgid="362604130117666924">"Déconnecté"</string>
    <string name="radioInfo_data_connecting" msgid="7280819598028917888">"Connexion en cours…"</string>
    <string name="radioInfo_data_connected" msgid="8816467971633020141">"Connecté"</string>
    <string name="radioInfo_data_suspended" msgid="2001254415431299603">"Suspendu"</string>
    <string name="radioInfo_unknown" msgid="2892562356748600367">"Inconnu"</string>
    <string name="preview_pager_content_description" msgid="3762247188224576303">"Aperçu"</string>
    <string name="font_size_make_smaller_desc" msgid="4978038055549590140">"Rapetisser"</string>
    <string name="font_size_make_larger_desc" msgid="5583046033381722247">"Agrandir"</string>
    <string name="auto_rotate_settings_primary_switch_title" msgid="3440951924928594520">"Utiliser la rotation automatique"</string>
    <string name="smart_rotate_text_headline" msgid="5878008933992951904">"La technologie de détection des visages utilise l\'appareil photo avant pour améliorer la précision de la rotation automatique. Les images ne sont jamais stockées ni envoyées à Google."</string>
    <string name="bluetooth" msgid="8898478620943459654">"Bluetooth"</string>
    <string name="bluetooth_is_discoverable" msgid="4798961627677790935">"Identifiable par tous appareils Bluetooth à proximité (<xliff:g id="DISCOVERABLE_TIME_PERIOD">%1$s</xliff:g>)"</string>
    <string name="bluetooth_is_discoverable_always" msgid="8122823110652921674">"Identifiable par appareils Bluetooth à proximité"</string>
    <string name="bluetooth_not_visible_to_other_devices" msgid="6181960579190879601">"Non identifiable par d\'autres appareils Bluetooth"</string>
    <string name="bluetooth_only_visible_to_paired_devices" msgid="3574936359739213455">"Identifiable uniquement par les appareils associés"</string>
    <string name="bluetooth_devices" msgid="1063177983261608277">"Appareils Bluetooth"</string>
    <string name="bluetooth_device_name" msgid="1294669733490268384">"Nom de l\'appareil"</string>
    <string name="bluetooth_rename_device" msgid="4219655243836021443">"Renommer cet appareil"</string>
    <string name="bluetooth_rename_button" msgid="9162500408570289545">"Renommer"</string>
    <string name="bluetooth_disconnect_title" msgid="4581951246357823044">"Déconnecter l\'appareil?"</string>
    <string name="bluetooth_pairing_pref_title" msgid="3497193027590444598">"Associer un autre appareil"</string>
    <string name="keywords_add_bt_device" msgid="4533191164203174011">"Bluetooth"</string>
    <string name="bluetooth_pair_right_ear_button" msgid="3979894494803078852">"Asso. oreille droite"</string>
    <string name="bluetooth_pair_left_ear_button" msgid="1019938875726073791">"Asso. oreille gauche"</string>
    <string name="bluetooth_pair_other_ear_dialog_title" msgid="3814943511999984012">"Associer l\'autre oreille"</string>
    <string name="bluetooth_pair_other_ear_dialog_left_ear_message" msgid="7936892941892347102">"Votre prothèse auditive gauche est connectée.\n\nPour associer celle de droite, assurez-vous qu\'elle est activée et prête à être associée."</string>
    <string name="bluetooth_pair_other_ear_dialog_right_ear_message" msgid="8242208936062915941">"Votre prothèse auditive droite est connectée.\n\nPour associer celle de gauche, assurez-vous qu\'elle est activée et prête à être associée."</string>
    <string name="bluetooth_pair_other_ear_dialog_right_ear_positive_button" msgid="533612082529204078">"Assoc. oreille droite"</string>
    <string name="bluetooth_pair_other_ear_dialog_left_ear_positive_button" msgid="6500192653171220257">"Assoc. oreille gauche"</string>
    <string name="bluetooth_device_controls_general" msgid="1399214835599665488">"Pour tous les appareils auditifs accessibles"</string>
    <string name="bluetooth_device_controls_title" msgid="4293399064818086587">"Raccourcis et compatibilité avec les prothèses auditives"</string>
    <string name="bluetooth_device_controls_specific" msgid="7706863288754077107">"Pour cet appareil"</string>
    <string name="bluetooth_audio_routing_title" msgid="5541729245424856226">"Sortie audio"</string>
    <string name="bluetooth_audio_routing_about_title" msgid="5773336779246891954">"À propos de la sortie audio"</string>
    <string name="bluetooth_audio_routing_summary" msgid="7180947533985969066">"Acheminez les sons vers votre appareil auditif ou le haut-parleur de votre téléphone"</string>
    <string name="bluetooth_screen_related" msgid="7976543255501825536">"Connexes"</string>
    <string name="bluetooth_ringtone_title" msgid="3177308461256892085">"Sonnerie et alarmes"</string>
    <string name="bluetooth_call_title" msgid="6851464952021874072">"Sortie audio des appels"</string>
    <string name="bluetooth_media_title" msgid="343705257183053699">"Multimédia"</string>
    <string name="bluetooth_system_sounds_title" msgid="6746938637128763205">"Notif. et autres sons du système"</string>
    <string name="bluetooth_audio_routing_footer_summary" msgid="410260713589309293">"Par défaut, la sortie audio est définie par les différentes applications"</string>
    <string name="bluetooth_device" msgid="2217973503732544291">"Appareil Bluetooth sans nom"</string>
    <string name="progress_scanning" msgid="2564746192843011826">"Recherche en cours…"</string>
    <string name="bluetooth_no_devices_found" msgid="7704539337219953182">"Aucun appareil Bluetooth détecté."</string>
    <string name="bluetooth_notif_ticker" msgid="209515545257862858">"Demande d\'association Bluetooth"</string>
    <string name="bluetooth_notif_title" msgid="1196532269131348647">"Demande d\'association"</string>
    <string name="bluetooth_notif_message" msgid="5584717784198086653">"Touchez pour associer à <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="bluetooth_devices_card_off_title" msgid="1320149821945129127">"Le Bluetooth est désactivé"</string>
    <string name="bluetooth_devices_card_off_summary" msgid="2276527382891105858">"Touchez pour l\'activer"</string>
    <string name="device_picker" msgid="2427027896389445414">"Sélectionner un appareil Bluetooth"</string>
    <string name="bluetooth_ask_enablement" msgid="1529030199895339199">"<xliff:g id="APP_NAME">%1$s</xliff:g> souhaite activer le Bluetooth"</string>
    <string name="bluetooth_ask_disablement" msgid="1879788777942714761">"<xliff:g id="APP_NAME">%1$s</xliff:g> souhaite désactiver le Bluetooth"</string>
    <string name="bluetooth_ask_enablement_no_name" msgid="5091401961637405417">"Une application souhaite activer le Bluetooth."</string>
    <string name="bluetooth_ask_disablement_no_name" msgid="382299750909188822">"Une application souhaite désactiver le Bluetooth"</string>
    <string name="bluetooth_turning_on" msgid="3842613808709024730">"Activation du Bluetooth..."</string>
    <string name="bluetooth_turning_off" msgid="7406309124247701148">"Désactivation du Bluetooth..."</string>
    <string name="bluetooth_connection_permission_request" msgid="8793131019383198861">"Demande de connexion Bluetooth"</string>
    <string name="bluetooth_phonebook_request" msgid="1085102844577089889">"Demande d\'accès au répertoire téléphonique"</string>
    <string name="bluetooth_map_request" msgid="8664081227240707479">"Demande d\'accès aux messages"</string>
    <string name="bluetooth_device_name_summary" msgid="8678342689845439583">"Visible comme « <xliff:g id="DEVICE_NAME">^1</xliff:g> » aux autres appareils"</string>
    <string name="bluetooth_off_footer" msgid="76578735660216295">"Activez le Bluetooth pour vous connecter à d\'autres appareils."</string>
    <string name="bluetooth_paired_device_title" msgid="3240639218362342026">"Vos appareils"</string>
    <string name="bluetooth_pairing_page_title" msgid="3403981358823707692">"Associer un autre appareil"</string>
    <string name="bluetooth_disable_a2dp_hw_offload" msgid="5942913792817797541">"Désactiver la décharge matérielle de Bluetooth A2DP"</string>
    <string name="bluetooth_disable_le_audio_hw_offload" msgid="4656853795514691257">"Désactiver la décharge matérielle de Bluetooth LE Audio"</string>
    <string name="bluetooth_disable_hw_offload_dialog_title" msgid="6001142380445276918">"Redémarrer l\'appareil?"</string>
    <string name="bluetooth_disable_hw_offload_dialog_message" msgid="1524373895333698779">"Vous devez redémarrer votre appareil pour modifier ce paramètre."</string>
    <string name="bluetooth_disable_hw_offload_dialog_confirm" msgid="5594859658551707592">"Redémarrer"</string>
    <string name="bluetooth_disable_hw_offload_dialog_cancel" msgid="3663690305043973720">"Annuler"</string>
    <string name="bluetooth_enable_leaudio" msgid="1245004820628723136">"Activer Bluetooth LE Audio"</string>
    <string name="bluetooth_enable_leaudio_summary" msgid="8066117764037123479">"Active la fonctionnalité Bluetooth LE Audio si l\'appareil prend en charge les capacités matérielles LE Audio."</string>
    <string name="bluetooth_enable_leaudio_allow_list" msgid="1692999156437357534">"Activer la liste d\'autorisation du Bluetooth LE audio"</string>
    <string name="bluetooth_enable_leaudio_allow_list_summary" msgid="725601205276008525">"Activez la fonctionnalité de liste d\'autorisation du Bluetooth LE audio."</string>
    <string name="connected_device_media_device_title" msgid="3783388247594566734">"Appareils de stockage multimédia"</string>
    <string name="connected_device_call_device_title" msgid="88732390601723608">"Appareils avec fonctionnalités d\'appel"</string>
    <string name="connected_device_other_device_title" msgid="4652120430615729193">"Autres appareils"</string>
    <string name="connected_device_saved_title" msgid="5607274378851905959">"Appareils enregistrés"</string>
    <string name="connected_device_add_device_summary" msgid="8671009879957120802">"Le Bluetooth s\'activera pour l\'association"</string>
    <string name="connected_device_connections_title" msgid="4164120115341579170">"Préférences de connexion"</string>
    <string name="connected_device_previously_connected_screen_title" msgid="8823331744788100605">"Connecté précedemment"</string>
    <string name="connected_device_bluetooth_turned_on_toast" msgid="144664089794199928">"Bluetooth activé"</string>
    <string name="previous_connected_see_all" msgid="7759413145713251328">"Tout afficher"</string>
    <string name="stylus_device_details_title" msgid="7618295136015480864">"Stylet"</string>
    <string name="stylus_default_notes_app" msgid="3896158797687806941">"Application de prise de notes par défaut"</string>
    <string name="stylus_textfield_handwriting" msgid="2363579035338976327">"Écrire dans les champs de texte"</string>
    <string name="stylus_ignore_button" msgid="7734540973145241391">"Ignorer tous les appuis d\'un stylet sur les boutons"</string>
    <string name="stylus_connected_devices_title" msgid="2823967577941359812">"Stylet"</string>
    <string name="date_and_time" msgid="1788358029823431692">"Date et heure"</string>
    <string name="proxy_settings_title" msgid="4201866858226087066">"Serveur mandataire"</string>
    <string name="proxy_clear_text" msgid="6529658759984031149">"Effacer"</string>
    <string name="proxy_port_label" msgid="4647357286461712574">"Port du serveur mandataire"</string>
    <string name="proxy_exclusionlist_label" msgid="2598613986784917542">"Ignorer le serveur mandataire pour"</string>
    <string name="proxy_defaultView_text" msgid="6795150505379688451">"Rétablir les paramètres par défaut"</string>
    <string name="proxy_action_text" msgid="1103328484441449542">"Terminé"</string>
    <string name="proxy_hostname_label" msgid="5504327742505848063">"Nom d\'hôte du serveur mandataire"</string>
    <string name="proxy_error" msgid="3615905975598084126">"Attention"</string>
    <string name="proxy_error_dismiss" msgid="4207430265140873078">"OK"</string>
    <string name="proxy_error_invalid_host" msgid="3814412792702059247">"Le nom d\'hôte saisi n\'est pas valide."</string>
    <string name="proxy_error_invalid_exclusion_list" msgid="6096353559936226599">"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="4250295137005082992">"Le champ « Port » est obligatoire."</string>
    <string name="proxy_error_empty_host_set_port" msgid="8886572276450900049">"Le champ Port doit rester vide si le champ Hôte n\'est pas renseigné."</string>
    <string name="proxy_error_invalid_port" msgid="2830054691770209166">"Le port indiqué n\'est pas valide."</string>
    <string name="proxy_warning_limited_support" msgid="3277104160797351942">"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="3502625766036404073">"URL config. auto mand. : "</string>
    <string name="radio_info_ping_hostname_v4" msgid="4790577760885127088">"Faire un ping de l\'IPv4 du nom d\'hôte (www.google.com) :"</string>
    <string name="radio_info_http_client_test" msgid="5673975677271544085">"Test du client HTTP :"</string>
    <string name="ping_test_label" msgid="265427033290391845">"Effectuer le test de ping"</string>
    <string name="skip_label" msgid="6380034601349015895">"Ignorer"</string>
    <string name="next_label" msgid="1248293387735652187">"Suivant"</string>
    <string name="language_picker_title" msgid="4271307478263345133">"Langues"</string>
    <string name="language_picker_category_title" msgid="1792199453060454565">"Ordre de préférence des langues"</string>
    <string name="desc_current_default_language" msgid="1901157141663662859">"Langue du système"</string>
    <string name="locale_remove_menu" msgid="3521546263421387474">"Supprimer"</string>
    <string name="add_a_language" msgid="2126220398077503271">"Ajouter une langue"</string>
    <string name="app_locale_preference_title" msgid="5513627099300360232">"Langue"</string>
    <string name="locale_picker_category_title" msgid="6212064706962721255">"Langue favorite"</string>
    <string name="app_locales_picker_menu_title" msgid="7617427959223831373">"Langues de l\'application"</string>
    <string name="app_locale_picker_summary" msgid="6742557329924446252">"Configurez la langue pour chaque application"</string>
    <string name="app_locale_picker_title" msgid="2431448962911301366">"Langue de l\'application"</string>
    <string name="suggested_app_locales_title" msgid="8898358282377369405">"Langues suggérées"</string>
    <string name="all_supported_app_locales_title" msgid="5479289964316009026">"Toutes les langues"</string>
    <string name="preference_of_system_locale_title" msgid="8067226276038751504">"Langue du système"</string>
    <string name="preference_of_system_locale_summary" msgid="5612241394431188535">"Paramètre système par défaut"</string>
    <string name="desc_no_available_supported_locale" msgid="7883271726226947273">"La sélection de la langue pour cette application n\'est pas accessible à partir des paramètres."</string>
    <string name="desc_app_locale_disclaimer" msgid="5295933110644789052">"La langue peut différer des langues offertes dans l\'application. Certaines applications peuvent ne pas prendre en charge ce paramètre."</string>
    <string name="desc_app_locale_selection_supported" msgid="6149467826636295127">"Seules les applications qui prennent en charge la sélection de la langue sont affichées ici."</string>
    <string name="desc_introduction_of_language_picker" msgid="1038423471887102449">"Le système, les applications et les sites web utilisent la première langue prise en charge parmi vos langues préférées."</string>
    <string name="desc_notice_of_language_picker" msgid="3449290526457925447">"Pour sélectionner une langue pour chaque application, consultez les paramètres de langue de l\'application."</string>
    <!-- no translation found for desc_locale_helper_footer_general (6112153921151780303) -->
    <skip />
    <string name="title_change_system_locale" msgid="8589844586256566951">"Modifier la langue du système à %s?"</string>
    <string name="desc_notice_device_locale_settings_change" msgid="8311132485850714160">"Vos préférences régionales et les paramètres de votre appareil seront modifiés."</string>
    <string name="button_label_confirmation_of_system_locale_change" msgid="5593798559604894733">"Modifier"</string>
    <string name="title_unavailable_locale" msgid="2628898110416542386">"%s non accessible"</string>
    <string name="desc_unavailable_locale" msgid="2201756477400935896">"Cette langue ne peut pas être utilisée comme langue du système, mais vous l\'avez indiquée comme langue préférée aux applications et aux sites Web."</string>
    <string name="regional_preferences_title" msgid="4304567374498629528">"Préférences régionales"</string>
    <string name="regional_preferences_summary" msgid="1189876997389469650">"Définissez les unités et les préférences numériques"</string>
    <string name="regional_preferences_main_page_sub_title" msgid="4237109940015254725">"Indiquez aux applications vos préférences régionales afin qu\'elles puissent personnaliser votre expérience."</string>
    <string name="regional_preferences_option_page_sub_title" msgid="8303661099255197036">"Les applications utiliseront vos préférences régionales quand c\'est possible."</string>
    <string name="temperature_preferences_title" msgid="5009881556503629058">"Température"</string>
    <string name="calendar_preferences_title" msgid="8312485828206542600">"Agenda"</string>
    <string name="first_day_of_week_preferences_title" msgid="1971850087589599553">"Premier jour de la semaine"</string>
    <string name="numbers_preferences_title" msgid="8197418984391195446">"Préférences relatives aux chiffres"</string>
    <string name="default_string_of_regional_preference" msgid="7662581547334113719">"Utiliser la valeur par défaut de l\'application"</string>
    <string name="celsius_temperature_unit" msgid="6118523647432383132">"Celsius(°C)"</string>
    <string name="fahrenheit_temperature_unit" msgid="4622209814782318725">"Fahrenheit(°F)"</string>
    <string name="sunday_first_day_of_week" msgid="7644548348295686051">"Dimanche"</string>
    <string name="monday_first_day_of_week" msgid="7244698610476506771">"Lundi"</string>
    <string name="tuesday_first_day_of_week" msgid="5085370946936582391">"Mardi"</string>
    <string name="wednesday_first_day_of_week" msgid="6544537589727042869">"Mercredi"</string>
    <string name="thursday_first_day_of_week" msgid="3035885630945594833">"Jeudi"</string>
    <string name="friday_first_day_of_week" msgid="7074795061812083541">"Vendredi"</string>
    <string name="saturday_first_day_of_week" msgid="3702282590450322727">"Samedi"</string>
    <string name="dlg_remove_locales_title" msgid="3170501604483612114">"{count,plural, =1{Retirer la langue sélectionnée?}one{Retirer la langue sélectionnée?}other{Retirer les langues sélectionnées?}}"</string>
    <string name="dlg_remove_locales_message" msgid="8110560091134252067">"Le texte s\'affichera dans une autre langue."</string>
    <string name="dlg_remove_locales_error_title" msgid="5875503658221562572">"Impossible de supprimer toutes les langues"</string>
    <string name="dlg_remove_locales_error_message" msgid="6504279959974675302">"Conservez au moins une langue"</string>
    <string name="locale_not_translated" msgid="3071618135527110152">"Non offerte comme langue du système"</string>
    <string name="action_drag_label_move_up" msgid="3392196942330705015">"Déplacer vers le haut"</string>
    <string name="action_drag_label_move_down" msgid="9069518740553953426">"Déplacer vers le bas"</string>
    <string name="action_drag_label_move_top" msgid="2430471023612171619">"Déplacer dans le haut"</string>
    <string name="action_drag_label_move_bottom" msgid="6266165197792827003">"Déplacer dans le bas"</string>
    <string name="action_drag_label_remove" msgid="1034900377796780568">"Supprimer la langue"</string>
    <string name="activity_picker_label" msgid="351250401590691126">"Sélectionnez une activité"</string>
    <string name="cancel" msgid="5780102414089664898">"Annuler"</string>
    <string name="okay" msgid="4827099303045669054">"OK"</string>
    <string name="forget" msgid="3754013654135912783">"Supprimer"</string>
    <string name="save" msgid="3125033126936493822">"Enregistrer"</string>
    <string name="done" msgid="7497982645646431310">"Terminé"</string>
    <string name="apply" msgid="7834684883190163536">"Appliquer"</string>
    <string name="share" msgid="8502235338607613795">"Partager"</string>
    <string name="add" msgid="8335206931421683426">"Ajouter"</string>
    <string name="remove" msgid="1028414219245072102">"Retirer"</string>
    <string name="settings_label" msgid="943294133671632976">"Paramètres"</string>
    <string name="settings_label_launcher" msgid="820982375501978609">"Paramètres"</string>
    <string name="settings_shortcut" msgid="8548239727871847171">"Raccourci vers les paramètres"</string>
    <string name="airplane_mode" msgid="3196085857882526817">"Mode Avion"</string>
    <string name="wireless_networks_settings_title" msgid="8557542379234105369">"Sans fil et réseaux"</string>
    <string name="roaming" msgid="3055365654530847985">"Itinérance"</string>
    <string name="roaming_enable" msgid="7845716016861535340">"Connectez-vous aux services de données lors de l\'itinérance"</string>
    <string name="roaming_disable" msgid="729512894708689604">"Se connecter aux services de données lors de l\'itinérance"</string>
    <string name="roaming_warning" msgid="7703647889040229013">"Des frais d\'itinérance peuvent s\'appliquer."</string>
    <string name="date_time_auto" msgid="4239202185055225869">"Définir l\'heure automatiquement"</string>
    <string name="zone_auto_title" msgid="5141692422373097957">"Définir automatiquement"</string>
    <string name="auto_zone_requires_location_summary" msgid="4831038184260596735">"La position sera utilisée pour définir le fuseau horaire lorsque cette option est activée"</string>
    <string name="date_time_24hour_auto" msgid="6583078135067804252">"Utiliser les paramètres régionaux par défaut"</string>
    <string name="date_time_24hour" msgid="286679379105653406">"Utiliser le format 24 h"</string>
    <string name="date_time_set_time_title" msgid="2870083415922991906">"Heure"</string>
    <string name="time_format_category_title" msgid="7108616745509689991">"Format de l\'heure"</string>
    <string name="date_time_set_timezone_title" msgid="790404320569600222">"Fuseau horaire"</string>
    <string name="date_time_set_timezone" msgid="2915125337941495746">"Sélectionner le fuseau horaire"</string>
    <string name="date_time_set_date_title" msgid="7624166157167528407">"Date"</string>
    <string name="date_time_search_region" msgid="1364133854952610919">"Rechercher une région"</string>
    <string name="date_time_select_region" msgid="5449345333305056072">"Région"</string>
    <string name="date_time_select_fixed_offset_time_zones" msgid="594848300882055361">"Sélect. fuseau horaire (UTC)"</string>
    <string name="zone_info_exemplar_location_and_offset" msgid="2186042522225153092">"<xliff:g id="EXEMPLAR_LOCATION">%1$s</xliff:g> (<xliff:g id="OFFSET">%2$s</xliff:g>)"</string>
    <string name="zone_info_offset_and_name" msgid="3960192548990990152">"<xliff:g id="TIME_TYPE">%2$s</xliff:g> (<xliff:g id="OFFSET">%1$s</xliff:g>)"</string>
    <string name="zone_info_footer_first_sentence" msgid="1326664252091302458">"Utilise <xliff:g id="OFFSET_AND_NAME">%1$s</xliff:g>. <xliff:g id="SECOND_SENTENCE">%2$s</xliff:g>"</string>
    <string name="zone_info_footer_second_sentence" msgid="6472889173541729110">"<xliff:g id="DST_TIME_TYPE">%1$s</xliff:g> commence le <xliff:g id="TRANSITION_DATE">%2$s</xliff:g>."</string>
    <string name="zone_info_footer_no_dst" msgid="8399585343328811158">"Utilise <xliff:g id="OFFSET_AND_NAME">%1$s</xliff:g>. Pas d\'heure avancée."</string>
    <string name="zone_time_type_dst" msgid="9189689342265305808">"Heure avancée"</string>
    <string name="zone_time_type_standard" msgid="6865420715430680352">"Heure normale"</string>
    <string name="zone_menu_by_region" msgid="2963565278710225652">"Sélectionner par région"</string>
    <string name="zone_menu_by_offset" msgid="1257702747474426745">"Sélectionner par décalage UTC"</string>
    <string name="lock_after_timeout" msgid="8682769000437403444">"Verrouiller après la mise en veille"</string>
    <string name="lock_after_timeout_summary" msgid="4869265514658147304">"<xliff:g id="TIMEOUT_STRING">%1$s</xliff:g> après la mise en veille"</string>
    <string name="lock_immediately_summary_with_exception" msgid="40819611828339044">"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="3441806647509073124">"<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="owner_info_settings_title" msgid="3555626140700093017">"Ajouter texte sur écr. de verr."</string>
    <string name="owner_info_settings_summary" msgid="347238313388083297">"Aucun"</string>
    <string name="owner_info_settings_edit_text_hint" msgid="841926875876050274">"Par exemple : Android de Jonathan"</string>
    <string name="location_settings_title" msgid="8375074508036087178">"Position"</string>
    <string name="location_settings_primary_switch_title" msgid="8849081766644685127">"Utiliser ma position"</string>
    <string name="location_settings_summary_location_off" msgid="4797932754681162262">"Désactivé"</string>
    <string name="location_settings_summary_location_on" msgid="7029728269719893381">"{count,plural, =1{Activée : # application a accès à la position}one{Activée : # application a accès à la position}other{Activée : # applications ont accès à la position}}"</string>
    <string name="location_settings_loading_app_permission_stats" msgid="6054103701535557342">"Chargement en cours…"</string>
    <string name="location_settings_footer_general" msgid="1040507068701188821">"Les applications qui disposent de l\'autorisation de détection des appareils à proximité peuvent déterminer la position relative des appareils connectés."</string>
    <string name="location_settings_footer_location_off" msgid="8568995909147566720">"L\'accès à la position est désactivé pour les applications et les services. La position de votre appareil pourrait quand même être envoyée aux intervenants d\'urgence lorsque vous appelez ou textez un numéro d\'urgence."</string>
    <string name="location_settings_footer_learn_more_content_description" msgid="5329024810729665156">"Apprenez-en plus à propos des paramètres de localisation."</string>
    <string name="account_settings_title" msgid="9138880127246241885">"Comptes"</string>
    <string name="security_settings_title" msgid="6710768415432791970">"Sécurité"</string>
    <string name="encryption_and_credential_settings_title" msgid="5856216318961482983">"Chiffrement et authentifiants"</string>
    <string name="lockscreen_settings_title" msgid="4086121748092341549">"Écran de verrouillage"</string>
    <string name="lockscreen_settings_what_to_show_category" msgid="9205490627927741254">"Éléments affichés"</string>
    <string name="disabled_by_administrator_summary" msgid="5424846182313851124">"Non accessible"</string>
    <string name="security_status_title" msgid="6958004275337618656">"État de la sécurité"</string>
    <string name="security_dashboard_summary" msgid="7571035662779425918">"Verrouillage d\'écran, Localiser mon appareil, sécurité des applications"</string>
    <string name="safety_center_title" msgid="7732397372178774777">"Sécurité et confidentialité"</string>
    <string name="safety_center_summary" msgid="3554867379951053869">"Sécurité applications, verrouillage appareil, autorisations"</string>
    <string name="security_settings_face_preference_summary" msgid="6675126437396914838">"Visage ajouté"</string>
    <string name="security_settings_face_preference_summary_none" msgid="5952752252122581846">"Touchez pour configurer le déverrouillage facial"</string>
    <string name="security_settings_face_preference_title" msgid="2126625155005348417">"Déverrouillage par recon. faciale"</string>
    <string name="security_settings_face_profile_preference_title" msgid="7519527436266375005">"Déverrouillage reconnaissance faciale pour travail"</string>
    <string name="security_settings_face_enroll_education_title" msgid="6448806884597691208">"Comment configurer le déverrouillage facial"</string>
    <string name="security_settings_face_enroll_education_title_accessibility" msgid="3701874093226957891">"Configurer le déverrouillage facial"</string>
    <string name="security_settings_face_enroll_education_title_unlock_disabled" msgid="8810954233979716906">"Utiliser son visage pour s\'authentifier"</string>
    <string name="security_settings_face_enroll_education_message" msgid="4308030157487176799"></string>
    <string name="security_settings_face_enroll_education_start" msgid="8830924400907195590">"Démarrer"</string>
    <string name="security_settings_face_enroll_education_accessibility_dialog_message" msgid="2965952386172202665">"Si le déverrouillage par reconnaissance faciale est désactivé, certaines étapes de configuration pourraient ne pas fonctionner avec TalkBack."</string>
    <string name="security_settings_face_enroll_education_accessibility_dialog_negative" msgid="7872647360361245461">"Retour"</string>
    <string name="security_settings_face_enroll_education_accessibility_dialog_positive" msgid="3148077647572203458">"Poursuivre configur."</string>
    <string name="security_settings_face_enroll_introduction_accessibility" msgid="5748221179069430975">"Utiliser config. d\'accessibilité"</string>
    <string name="security_settings_face_enroll_introduction_accessibility_diversity" msgid="2774962371839179206"></string>
    <string name="security_settings_face_enroll_introduction_accessibility_vision" msgid="7700394302162170363"></string>
    <string name="security_settings_face_enroll_introduction_cancel" msgid="7551159644361639436">"Annuler"</string>
    <string name="security_settings_face_enroll_introduction_no_thanks" msgid="1820618982738898717">"Non, merci"</string>
    <string name="security_settings_face_enroll_introduction_agree" msgid="6319476573697497750">"J\'accepte"</string>
    <string name="security_settings_face_enroll_introduction_more" msgid="1970820298889710532">"Plus"</string>
    <string name="security_settings_face_enroll_introduction_title" msgid="7061610077237098046">"Déverrouiller avec votre visage"</string>
    <string name="security_settings_face_enroll_consent_introduction_title" msgid="3942331854413767814">"Autoriser le déverr. par reconn. faciale"</string>
    <string name="security_settings_face_enroll_introduction_title_unlock_disabled" msgid="5903924766168353113">"Utiliser son visage pour s\'authentifier"</string>
    <string name="security_settings_face_enroll_introduction_message_unlock_disabled" msgid="5841976283789481311">"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="765965418187421753">"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_info_title" msgid="7120796118179406944"></string>
    <string name="security_settings_face_enroll_introduction_info_glasses" msgid="2733870453868907471"></string>
    <string name="security_settings_face_enroll_introduction_info_consent_glasses" msgid="6303917184145586880"></string>
    <string name="security_settings_face_enroll_introduction_how_title" msgid="3680193263037835600"></string>
    <string name="security_settings_face_enroll_introduction_control_title" msgid="4536951089583821051"></string>
    <string name="security_settings_face_enroll_introduction_control_consent_title" msgid="5892729331412694759"></string>
    <string name="security_settings_face_enroll_repeat_title" msgid="4446229670377418717">"Centrez votre visage dans le cercle"</string>
    <string name="security_settings_face_enroll_enrolling_skip" msgid="5568617401632528567">"Ignorer"</string>
    <string name="face_intro_error_max" msgid="2474735057709291626">"Vous avez ajouté le nombre maximal de visages"</string>
    <string name="face_intro_error_unknown" msgid="1626057493054989995">"Impossible d\'ajouter d\'autres visages"</string>
    <string name="security_settings_face_enroll_error_dialog_title" msgid="2460820099922775936">"L\'inscription n\'est pas terminée"</string>
    <string name="security_settings_face_enroll_dialog_ok" msgid="1674650455786434426">"OK"</string>
    <string name="security_settings_face_enroll_error_timeout_dialog_message" msgid="7768349698547951750">"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="3186810411630091490">"L\'inscription du visage n\'a pas fonctionné."</string>
    <string name="security_settings_face_enroll_finish_title" msgid="5882322568359775393">"Tout est prêt et semble être en ordre."</string>
    <string name="security_settings_face_enroll_done" msgid="3048687969498187442">"Terminé"</string>
    <string name="security_settings_face_enroll_should_re_enroll_title" msgid="6835778900387289683">"Améliorer la performance du déverrouillage facial"</string>
    <string name="security_settings_face_enroll_should_re_enroll_subtitle" msgid="7055780282999744813">"Reconfigurez le déverrouillage facial"</string>
    <string name="security_settings_face_enroll_must_re_enroll_title" msgid="4421818770682557621">"Reconfigurer déverrouillage reconnaissance faciale"</string>
    <string name="security_settings_face_enroll_must_re_enroll_subtitle" msgid="3584740139535177961">"Améliorez la sécurité et les performances"</string>
    <string name="security_settings_face_enroll_improve_face_alert_title" msgid="6194184776580066012">"Configurer le déverrouillage par reconnaissance faciale"</string>
    <string name="security_settings_face_enroll_improve_face_alert_body" msgid="2670118180411127323">"Supprimez votre modèle facial actuel pour reconfigurer le déverrouillage par reconnaissance faciale.\n\nCelui-ci sera supprimé de façon permanente et sécurisée.\n\nPour déverrouiller votre téléphone ou pour vous authentifier dans les applis, vous aurez besoin de ce qui suit : NIP, schéma ou mot de passe."</string>
    <string name="security_settings_face_enroll_improve_face_alert_body_fingerprint" msgid="2469599074650327489">"Supprimez votre modèle facial actuel pour reconfigurer le déverrouillage facial.\n\nCelui-ci sera supprimé de façon permanente et sécurisée.\n\nPour déverrouiller votre téléphone ou vous authentifier dans les applis, vous aurez besoin de ce qui suit : empreinte digitale, NIP, schéma ou mot de passe."</string>
    <string name="security_settings_face_settings_use_face_category" msgid="1638314154119800188">"Utiliser pour"</string>
    <string name="security_settings_face_settings_preferences_category" msgid="7628929873407280453">"Avec le déverrouillage par reconnaissance faciale"</string>
    <string name="security_settings_face_settings_require_attention" msgid="4395309855914391104">"Exiger des yeux ouverts"</string>
    <string name="security_settings_face_settings_require_attention_details" msgid="2546230511769544074">"Pour déverrouiller le téléphone, vos yeux doivent être ouverts"</string>
    <string name="security_settings_face_settings_require_confirmation" msgid="6603039421004198334">"Toujours demander une confirmation"</string>
    <string name="security_settings_face_settings_require_confirmation_details" msgid="3498729789625461914">"Toujours confirmer déverrouillage reconnaissance faciale dans applis"</string>
    <string name="security_settings_face_settings_remove_face_model" msgid="812920481303980846">"Supprimer le modèle facial"</string>
    <string name="security_settings_face_settings_enroll" msgid="3726313826693825029">"Configurer le déverrouillage facial"</string>
    <string name="security_settings_face_settings_footer" msgid="625696606490947189">"Utilisez votre visage pour déverrouiller votre téléphone ou pour vous authentifier dans les applications, par exemple lorsque vous vous connectez ou approuvez un achat.\n\nGardez à l\'esprit :\nUn seul visage peut être configuré à la fois. Pour ajouter un autre visage, supprimez le visage actuel.\n\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.\n\nVotre téléphone pourrait être déverrouillé par une personne qui vous ressemble beaucoup, comme un jumeau identique."</string>
    <string name="security_settings_face_settings_footer_attention_not_supported" msgid="2071065435536235622">"Utilisez votre visage pour déverrouiller votre téléphone ou pour vous authentifier dans les applications, par exemple lorsque vous vous connectez ou approuvez un achat.\n\nGardez à l\'esprit :\nUn seul visage peut être configuré à la fois. Pour ajouter un autre visage, supprimez le visage actuel.\n\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, même si vos yeux sont fermés.\n\nVotre téléphone pourrait être déverrouillé par une personne qui vous ressemble beaucoup, comme un jumeau identique."</string>
    <string name="security_settings_face_settings_remove_dialog_title" msgid="2899669764446232715">"Supprimer le modèle facial?"</string>
    <string name="security_settings_face_settings_remove_dialog_details" msgid="916131485988121592">"Votre modèle facial sera supprimé définitivement de façon sécurisée.\n\nVous devrez ensuite utiliser votre NIP, votre schéma ou votre mot de passe pour déverrouiller votre téléphone ou pour vous authentifier dans les applications."</string>
    <string name="security_settings_face_settings_remove_dialog_details_convenience" msgid="475568135197468990">"Votre modèle facial sera supprimé de façon permanente et sécurisée.\n\nPour déverrouiller votre téléphone, vous aurez ensuite besoin de ce qui suit : NIP, schéma ou mot de passe."</string>
    <string name="security_settings_face_settings_context_subtitle" msgid="8284262560781442403">"Utilisez le déverrouillage par reconnaissance faciale pour déverrouiller votre téléphone"</string>
    <string name="security_settings_fingerprint_preference_title" msgid="2484965173528415458">"Empreintes digitales"</string>
    <string name="security_settings_fingerprint_settings_preferences_category" msgid="8975029409126780752">"Lors de l\'utilisation du déverrouillage par empreinte digitale"</string>
    <string name="security_settings_work_fingerprint_preference_title" msgid="2076006873519745979">"Empreinte digitale pour le travail"</string>
    <string name="fingerprint_add_title" msgid="1837610443487902050">"Ajouter une empreinte digitale"</string>
    <string name="security_settings_fingerprint_preference_summary" msgid="8486134175759676037">"{count,plural, =1{Empreinte digitale ajoutée}one{# empreinte digitale ajoutée}other{# empreintes digitales ajoutées}}"</string>
    <string name="security_settings_fingerprint_preference_summary_none" msgid="1044059475710838504"></string>
    <string name="security_settings_fingerprint_enroll_introduction_title" msgid="7931650601996313070">"Configurer empreinte digitale"</string>
    <string name="security_settings_fingerprint_enroll_consent_introduction_title" msgid="2278592030102282364">"Autoriser le déverrouillage par empreinte digitale"</string>
    <string name="security_settings_fingerprint_enroll_introduction_title_unlock_disabled" msgid="1911710308293783998">"Utilisez votre empreinte digitale"</string>
    <string name="security_settings_fingerprint_settings_footer_learn_more" msgid="2508322993726483601">"En savoir plus sur le déverrouillage par empreinte digitale"</string>
    <string name="security_settings_fingerprint_enroll_introduction_footer_title_1" msgid="6808124116419325722">"Vous êtes aux commandes"</string>
    <string name="security_settings_fingerprint_enroll_introduction_footer_title_consent_1" msgid="1122676690472680734">"Vous et votre enfant êtes aux commandes"</string>
    <string name="security_settings_fingerprint_enroll_introduction_footer_title_2" msgid="5663733424583416266">"Souvenez-vous"</string>
    <string name="security_settings_fingerprint_enroll_introduction_message_unlock_disabled" msgid="8957789840251747092">"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_cancel" msgid="6086532316718920562">"Annuler"</string>
    <string name="security_settings_fingerprint_enroll_introduction_no_thanks" msgid="6104718999323591180">"Non merci"</string>
    <string name="security_settings_fingerprint_enroll_introduction_agree" msgid="4068276083536421828">"J\'accepte"</string>
    <string name="setup_fingerprint_enroll_skip_title" msgid="2473807887676247264">"Ignorer configuration empreinte?"</string>
    <string name="setup_fingerprint_enroll_skip_after_adding_lock_text" msgid="2412645723804450304">"La configuration de l\'empreinte digitale 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="security_settings_fingerprint_v2_enroll_introduction_message_setup" msgid="6255210343107484206">"Si vous voyez cette icône, utilisez votre empreinte pour vous authentifier (comme pour vous connecter à des applications ou approuver un achat)"</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_title_1" msgid="4360262371633254407">"Gardez à l\'esprit"</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_title_2" msgid="2580899232734177771">"Fonctionnement"</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_message_2" msgid="5909924864816776516">"Le déverrouillage par empreinte digitale crée un modèle unique de votre empreinte digitale pour vérifier qu\'il s\'agit bien de vous. Pour créer ce modèle durant la configuration, l\'appareil vous demandera de capturer des images de votre empreinte digitale dans différentes positions."</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_message_consent_2" msgid="3493356605815124807">"Le déverrouillage par empreinte digitale crée un modèle unique de l\'empreinte digitale de votre enfant pour vérifier qu\'il s\'agit bien de lui. Pour créer ce modèle durant la configuration, l\'appareil lui demandera de capturer des images de son empreinte digitale dans différentes positions."</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_message_6" msgid="5314031490467481499">"Pour obtenir des résultats optimaux, utilisez un protecteur d\'écran certifié Fait pour Google. Vos empreintes digitales peuvent ne pas être reconnues avec d\'autres protecteurs d\'écran."</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_message_consent_6" msgid="3563942520716110478">"Pour obtenir des résultats optimaux, utilisez un protecteur d\'écran certifié Fait pour Google. Les empreintes digitales de votre enfant peuvent ne pas être reconnues avec d\'autres protecteurs d\'écran."</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_message_learn_more" msgid="5856010507790137793"></string>
    <string name="security_settings_activeunlock_preference_title" msgid="4257580421087062228">"Déverrouillage à l\'aide d\'une montre"</string>
    <string name="biometric_settings_intro_with_activeunlock" msgid="6583248094453119314">"Lorsque vous configurez le déverrouillage par reconnaissance faciale et par empreinte digitale, votre téléphone vous demandera votre empreinte digitale quand vous portez un masque ou quand vous êtes dans un endroit sombre.\n\nVous pouvez déverrouiller votre téléphone à l\'aide de votre montre lorsque votre empreinte digitale ou votre visage ne sont pas reconnus."</string>
    <string name="biometric_settings_intro_with_fingerprint" msgid="4312041617237493461">"Vous pouvez déverrouiller votre téléphone à l\'aide de votre montre lorsque votre empreinte digitale n\'est pas reconnue."</string>
    <string name="biometric_settings_intro_with_face" msgid="7658123658803417930">"Vous pouvez déverrouiller votre téléphone à l\'aide de votre montre lorsque votre visage n\'est pas reconnu."</string>
    <string name="biometric_settings_use_face_or_watch_preference_summary" msgid="4969685200340861744">"Utilisation du visage ou de la montre"</string>
    <string name="biometric_settings_use_fingerprint_or_watch_preference_summary" msgid="2425628094194828407">"Utilisation : empreinte digitale ou montre"</string>
    <string name="biometric_settings_use_face_fingerprint_or_watch_preference_summary" msgid="188805113048792007">"Utilisation : visage, empreinte digitale ou montre"</string>
    <string name="biometric_settings_use_watch_preference_summary" msgid="2311453276747908475">"Utilisation de la montre"</string>
    <string name="security_settings_activeunlock_require_face_fingerprint_setup_title" msgid="8776904312629209685">"Configurer le déverrouillage par rec. faciale/emp. digitale"</string>
    <string name="security_settings_activeunlock_require_face_fingerprint_setup_message" msgid="1669326067732567911">"Vous pouvez déverrouiller votre téléphone à l\'aide de votre montre lorsque votre empreinte digitale ou votre visage n\'est pas reconnu"</string>
    <string name="security_settings_activeunlock_require_fingerprint_setup_title" msgid="6703703635881050623">"Configurer d\'abord le déverrouillage par empreinte digitale"</string>
    <string name="security_settings_activeunlock_require_fingerprint_setup_message" msgid="4966813766409918392">"Vous pouvez déverrouiller votre téléphone à l\'aide de votre montre lorsque votre empreinte digitale n\'est pas reconnue"</string>
    <string name="security_settings_activeunlock_require_face_setup_title" msgid="1428795376597739880">"Configurer d\'abord le déverrouillage par reconnais. faciale"</string>
    <string name="security_settings_activeunlock_require_face_setup_message" msgid="8904070645721933399">"Vous pouvez déverrouiller votre téléphone à l\'aide de votre montre lorsque votre visage n\'est pas reconnu"</string>
    <string name="security_settings_activeunlock_biometric_setup" msgid="8876454457817955475">"Configurer"</string>
    <string name="security_settings_fingerprint_single_watch_preference_summary" msgid="6464470096384164369">"Empreinte digitale et <xliff:g id="WATCH">%s</xliff:g> ajoutées"</string>
    <string name="security_settings_fingerprint_multiple_watch_preference_summary" msgid="2259261786932097004">"Empreintes digitales et <xliff:g id="WATCH">%s</xliff:g> ajoutées"</string>
    <string name="security_settings_face_watch_preference_summary" msgid="5817376447253802793">"<xliff:g id="WATCH">%s</xliff:g> et visage ajoutés"</string>
    <string name="security_settings_fingerprint_single_face_watch_preference_summary" msgid="764951912234638192">"Empreinte digitale, <xliff:g id="WATCH">%s</xliff:g> et visage ajoutés"</string>
    <string name="security_settings_fingerprint_multiple_face_watch_preference_summary" msgid="3935500711366489380">"Empreintes digitales, <xliff:g id="WATCH">%s</xliff:g> et visage ajoutés"</string>
    <string name="security_settings_biometric_preference_title" msgid="298146483579539448">"Déverrouillage par recon. faciale et empreinte digitale"</string>
    <string name="security_settings_work_biometric_preference_title" msgid="3121755615533533585">"Déverrouillage par recon. faciale et emp. digitale pour le travail"</string>
    <string name="security_settings_biometric_preference_summary_none_enrolled" msgid="6941188982863819389">"Touchez pour configurer"</string>
    <string name="security_settings_biometric_preference_summary_both_fp_multiple" msgid="4821859306609955966">"Empreintes digitales et visage ajoutés"</string>
    <string name="security_settings_biometric_preference_summary_both_fp_single" msgid="684409535278676426">"Empreinte digitale et visage ajoutés"</string>
    <string name="biometric_settings_intro" msgid="4263069383955676756">"Lorsque vous configurez le déverrouillage par reconnaissance faciale et par empreinte digitale, votre téléphone vous demande votre empreinte digitale quand vous portez un masque ou vous trouvez dans un endroit sombre"</string>
    <string name="biometric_settings_category_ways_to_unlock" msgid="3384767901580915266">"Méthodes de déverrouillage"</string>
    <string name="biometric_settings_category_use_face_fingerprint" msgid="4377659744376863913">"Utiliser le visage ou l\'empreinte digitale pour"</string>
    <string name="biometric_settings_use_biometric_unlock_phone" msgid="8180914579885804358">"Déverrouiller votre téléphone"</string>
    <string name="biometric_settings_use_biometric_for_apps" msgid="6201168728906364189">"Vérifier votre identité dans les applications"</string>
    <string name="biometric_settings_use_face_preference_summary" msgid="1821648836899408477">"Utilisation du visage"</string>
    <string name="biometric_settings_use_fingerprint_preference_summary" msgid="6077762097826050165">"Utilisation des empreintes digitales"</string>
    <string name="biometric_settings_use_face_or_fingerprint_preference_summary" msgid="3029102492674234728">"Utilisation du visage ou des empreintes digitales"</string>
    <string name="biometric_settings_hand_back_to_guardian_ok" msgid="1763788801883247426">"OK"</string>
    <string name="lock_screen_intro_skip_title" msgid="342553937472568925">"Ignorer verrouillage d\'écran?"</string>
    <string name="skip_anyway_button_label" msgid="3442274117023270068">"Ignorer quand même"</string>
    <string name="go_back_button_label" msgid="6139455414099035594">"Retour"</string>
    <string name="skip_lock_screen_dialog_button_label" msgid="641984698150020591">"Ignorer"</string>
    <string name="cancel_lock_screen_dialog_button_label" msgid="1801132985957491690">"Annuler"</string>
    <string name="security_settings_fingerprint_enroll_find_sensor_title" msgid="886085239313346000">"Toucher le capteur"</string>
    <string name="security_settings_sfps_enroll_find_sensor_title" msgid="8327884364635804363">"Touchez l\'interrupteur sans l\'enfoncer"</string>
    <string name="security_settings_udfps_enroll_find_sensor_title" msgid="8077484429913330179">"Voici comment configurer votre empreinte digitale"</string>
    <string name="security_settings_fingerprint_enroll_find_sensor_message" msgid="6160543980992596286">"Il se trouve à l\'arrière de votre téléphone. Utilisez votre index."</string>
    <string name="security_settings_udfps_enroll_find_sensor_message" msgid="8383106460819519961">"Le capteur d\'empreintes digitales se trouve sur votre écran. Vous capturerez votre empreinte digitale au prochain écran."</string>
    <string name="security_settings_udfps_enroll_find_sensor_start_button" msgid="3172268783620336357">"Démarrer"</string>
    <string name="security_settings_udfps_enroll_a11y" msgid="1899453114050362235">"Déplacez votre doigt sur l\'écran pour trouver le capteur. Maintenez le doigt sur le capteur d\'empreintes digitales."</string>
    <string name="security_settings_fingerprint_enroll_find_sensor_content_description" msgid="3065850549419750523">"Illustration présentant l\'appareil et la position du capteur d\'empreintes digitales"</string>
    <string name="security_settings_fingerprint_enroll_dialog_name_label" msgid="7298812463228440333">"Nom"</string>
    <string name="security_settings_fingerprint_enroll_dialog_ok" msgid="4074335979239208021">"OK"</string>
    <string name="security_settings_fingerprint_enroll_dialog_try_again" msgid="8117874972945407006">"Réessayer"</string>
    <string name="security_settings_fingerprint_enroll_dialog_delete" msgid="6027141901007342389">"Supprimer"</string>
    <string name="security_settings_fingerprint_enroll_start_title" msgid="7391368057800077604">"Toucher le capteur"</string>
    <string name="security_settings_fingerprint_enroll_start_message" msgid="5010227772754175346">"Placez votre doigt sur le capteur, puis soulevez-le lorsque vous sentez une vibration"</string>
    <string name="security_settings_udfps_enroll_start_message" msgid="5032954588171487566">"Maintenez votre empreinte digitale à plat sur le capteur jusqu\'à ce que vous sentiez une vibration"</string>
    <string name="security_settings_sfps_enroll_start_message" msgid="9054672627477685212">"Sans appuyer sur le bouton, maintenez votre empreinte digitale sur le capteur jusqu\'à ce que vous ressentiez une vibration.\n\nDéplacez légèrement votre doigt chaque fois. Cela aide à capter une plus grande partie de votre empreinte digitale."</string>
    <string name="security_settings_fingerprint_enroll_udfps_title" msgid="6665610134560896895">"Maintenez le doigt sur le capteur d\'empreintes digitales"</string>
    <string name="security_settings_fingerprint_enroll_repeat_title" msgid="9172202128243545021">"Relevez le doigt et touchez le capteur"</string>
    <string name="security_settings_udfps_enroll_title_one_more_time" msgid="424937043843482410">"Encore une fois."</string>
    <string name="security_settings_udfps_enroll_repeat_title_touch_icon" msgid="4096344864386190335">"Suivez l\'icône d\'empreinte digitale"</string>
    <string name="security_settings_fingerprint_enroll_repeat_message" msgid="5382958363770893577">"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_udfps_enroll_repeat_message" msgid="2213106975297867798">"Maintenez le doigt sur le capteur chaque fois que l\'icône de l\'empreinte digitale bouge. Cela aide à capter une plus grande partie de votre empreinte digitale."</string>
    <string name="security_settings_udfps_enroll_fingertip_title" msgid="4123142574168831116">"Placez le bout de votre doigt sur le capteur"</string>
    <string name="security_settings_udfps_enroll_left_edge_title" msgid="1944076382202470458">"Placez le bord gauche de votre doigt"</string>
    <string name="security_settings_udfps_enroll_right_edge_title" msgid="9036744264606447490">"Placez le bord droit de votre doigt"</string>
    <string name="security_settings_sfps_enroll_finger_center_title" msgid="1320688855767675739">"Placez la partie centrale de votre doigt sur le capteur"</string>
    <string name="security_settings_sfps_enroll_fingertip_title" msgid="2737520837684516446">"Placez le bout de votre doigt sur le capteur"</string>
    <string name="security_settings_sfps_enroll_left_edge_title" msgid="9022963735924413343">"Placez le bord gauche de votre doigt sur le capteur"</string>
    <string name="security_settings_sfps_enroll_right_edge_title" msgid="823106857743394392">"Finalement, placez le bord droit de votre doigt sur le capteur"</string>
    <string name="security_settings_udfps_enroll_edge_message" msgid="4455253923746607702">"Placez le côté de votre doigt sur le capteur et maintenez-le en place, puis passez à l\'autre côté"</string>
    <string name="security_settings_udfps_enroll_repeat_a11y_message" msgid="2785464357615568197">"Ce geste aide à capter une plus grande partie de votre empreinte digitale"</string>
    <string name="security_settings_sfps_enroll_progress_a11y_message" msgid="6450772721691523736">"Inscription de l\'empreinte digitale : <xliff:g id="PERCENTAGE">%d</xliff:g> pour cent"</string>
    <string name="security_settings_sfps_animation_a11y_label" msgid="8808819903730940446">"Inscription : <xliff:g id="PERCENTAGE">%d</xliff:g> pour cent"</string>
    <string name="security_settings_udfps_enroll_progress_a11y_message" msgid="6183535114682369699">"Inscription de l\'empreinte digitale : <xliff:g id="PERCENTAGE">%d</xliff:g> pour cent"</string>
    <string name="security_settings_fingerprint_enroll_finish_title" msgid="3606325177406951457">"Empreinte digitale ajoutée"</string>
    <string name="security_settings_require_screen_on_to_auth_title" msgid="1641621458536715518">"Toucher pour déverrouiller à tout moment"</string>
    <string name="security_settings_require_screen_on_to_auth_description" msgid="4158414711168345398">"Touchez le capteur pour déverrouiller, même lorsque l\'écran est éteint. Cela rend le déverrouillage accidentel plus probable."</string>
    <string name="security_settings_require_screen_on_to_auth_keywords" msgid="5557869560397089603">"Écran, déverrouiller"</string>
    <string name="security_settings_fingerprint_enroll_enrolling_skip" msgid="3004786457919122854">"Plus tard"</string>
    <string name="security_settings_udfps_tip_fingerprint_help" msgid="7580784640741217494">"Levez le doigt et touchez le capteur de nouveau"</string>
    <string name="security_settings_udfps_side_fingerprint_help" msgid="2567232481013195191">"Placez le côté de votre empreinte digitale sur le capteur et maintenez-le en place, puis passez à l\'autre côté"</string>
    <string name="setup_fingerprint_enroll_enrolling_skip_title" msgid="352947044008973812">"Ignorer config. empreintes digitales?"</string>
    <string name="setup_fingerprint_enroll_enrolling_skip_message" msgid="4876965433600560365">"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="lock_screen_pin_skip_title" msgid="6853866579893458111">"Ignorer la configuration du NIP?"</string>
    <string name="lock_screen_pin_skip_face_title" msgid="8810770395309512358">"Ignorer cette étape de configuration?"</string>
    <string name="lock_screen_pin_skip_fingerprint_title" msgid="371214283158750976">"Ignorer cette étape de configuration?"</string>
    <string name="lock_screen_pin_skip_biometrics_title" msgid="1082066572914073311">"Ignorer cette étape de configuration?"</string>
    <string name="lock_screen_password_skip_title" msgid="8891463713793185768">"Ignorer la configuration du mot de passe?"</string>
    <string name="lock_screen_password_skip_face_title" msgid="8166210519462164998">"Ignorer cette étape de configuration?"</string>
    <string name="lock_screen_password_skip_fingerprint_title" msgid="2506392546016772170">"Ignorer cette étape de configuration?"</string>
    <string name="lock_screen_password_skip_biometrics_title" msgid="900281322095862009">"Ignorer cette étape de configuration?"</string>
    <string name="lock_screen_pattern_skip_title" msgid="7214938393640060932">"Ignorer la configuration du schéma?"</string>
    <string name="lock_screen_pattern_skip_face_title" msgid="145100333454316334">"Ignorer cette étape de configuration?"</string>
    <string name="lock_screen_pattern_skip_fingerprint_title" msgid="2513110208722100495">"Ignorer cette étape de configuration?"</string>
    <string name="lock_screen_pattern_skip_biometrics_title" msgid="2434258106825380187">"Ignorer cette étape de configuration?"</string>
    <string name="security_settings_fingerprint_enroll_setup_screen_lock" msgid="3538784524778508018">"Configurer le verrouil. de l\'écran"</string>
    <string name="security_settings_fingerprint_enroll_done" msgid="9198775984215057337">"Terminé"</string>
    <string name="security_settings_fingerprint_enroll_touch_dialog_title" msgid="5742429501012827526">"Oups, ce n\'est pas le capteur"</string>
    <string name="security_settings_fingerprint_enroll_touch_dialog_message" msgid="7172969336386036998">"Touchez le capteur à l\'arrière de votre téléphone. Utilisez votre index."</string>
    <string name="security_settings_fingerprint_enroll_error_unable_to_process_dialog_title" msgid="5796228438604723279">"L\'inscription n\'est pas terminée"</string>
    <string name="security_settings_fingerprint_enroll_error_dialog_title" msgid="8582267776559099046">"Délai dépassé pour config. d\'empreinte digitale"</string>
    <string name="security_settings_fingerprint_enroll_error_timeout_dialog_message" msgid="467965101751652156">"Réessayez maintenant ou configurez votre empreinte digitale plus tard dans les paramètres"</string>
    <string name="security_settings_fingerprint_enroll_error_generic_dialog_message" msgid="6068935528640241271">"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="6652490687672815760">"Ajouter une empreinte"</string>
    <string name="fingerprint_enroll_button_next" msgid="1034110123277869532">"Suivant"</string>
    <string name="security_fingerprint_disclaimer_lockscreen_disabled_1" msgid="294529888220959309">"L\'option de verrouillage de l\'écran est désactivée. Pour en savoir plus, communiquez avec l\'administrateur de votre organisation."</string>
    <string name="security_fingerprint_disclaimer_lockscreen_disabled_2" msgid="8070829069640846543">"Vous pouvez toujours utiliser votre empreinte digitale pour autoriser des achats et accéder à des applications."</string>
    <string name="security_settings_fingerprint_enroll_lift_touch_again" msgid="2590665137265458789">"Relevez le doigt, puis touchez le capteur à nouveau"</string>
    <string name="security_settings_fingerprint_bad_calibration" msgid="598502302101068608">"Impossible utiliser capteur empreintes digitales. Consultez un fournisseur de services de réparation"</string>
    <string name="security_advanced_settings" msgid="6260756619837834042">"Plus de paramètres de sécurité"</string>
    <string name="security_advanced_settings_work_profile_settings_summary" msgid="7295451997961973175">"Verrouillage de profil professionnel, chiffrement et plus"</string>
    <string name="security_advanced_settings_no_work_profile_settings_summary" msgid="345336447137417638">"Chiffrement, authentifiants et plus"</string>
    <string name="security_advanced_settings_keywords" msgid="5294945170370974974">"sécurité, plus de paramètres de sécurité, plus de paramètres, paramètres de sécurité avancés"</string>
    <string name="privacy_advanced_settings" msgid="8828215456566937719">"Plus de paramètres de sécurité"</string>
    <string name="more_security_privacy_settings" msgid="977191087706506398">"Plus de paramètres"</string>
    <string name="security_header" msgid="961514795852103424">"Sécurité"</string>
    <string name="privacy_header" msgid="5526002421324257007">"Confidentialité"</string>
    <string name="work_profile_category_header" msgid="85707750968948517">"Profil professionnel"</string>
    <string name="fingerprint_add_max" msgid="8639321019299347447">"Vous pouvez ajouter jusqu\'à <xliff:g id="COUNT">%d</xliff:g> empreintes digitales"</string>
    <string name="fingerprint_intro_error_max" msgid="4431784409732135610">"Vous avez ajouté le nombre maximal d\'empreintes digitales"</string>
    <string name="fingerprint_intro_error_unknown" msgid="877005321503793963">"Impossible d\'ajouter des empreintes digitales"</string>
    <string name="fingerprint_delete_title" msgid="5412123164503407098">"Supprimer « <xliff:g id="FINGERPRINT_ID">%1$s</xliff:g> »"</string>
    <string name="fingerprint_last_delete_message_profile_challenge" msgid="4104208067277655068">"Vous ne pourrez pas utiliser votre empreinte digitale pour déverrouiller votre profil professionnel, autoriser vos achats ni vous connecter à des applications professionnelles."</string>
    <string name="encryption_settings_title" msgid="2848716008695618360">"Chiffrement"</string>
    <string name="encrypted_summary" msgid="545623487587251207">"Chiffré"</string>
    <string name="no_screen_lock_issue_title" msgid="1814109590692792891">"Configurer le verrouillage de l\'écran"</string>
    <string name="no_screen_lock_issue_summary" msgid="2383217853510608406">"Pour renforcer la sécurité, définissez un NIP, un schéma ou un mot de passe pour cet appareil."</string>
    <string name="no_screen_lock_issue_action_label" msgid="2691229130486382863">"Configurer le verrouillage de l\'écran"</string>
    <string name="no_screen_lock_issue_notification_title" msgid="5718363966239208505">"Verrouillage d\'écran non défini pour cet appareil"</string>
    <string name="no_screen_lock_issue_notification_text" msgid="8696194459170873345">"Pour renforcer la sécurité, définissez un NIP, un schéma ou un mot de passe pour cet appareil."</string>
    <string name="suggested_lock_settings_title" msgid="7836065447159730217">"Sécurisez votre téléphone"</string>
    <string name="suggested_fingerprint_lock_settings_title" msgid="3140266181874137984">"Ajouter empreinte digitale pour déverrouiller"</string>
    <string name="lock_settings_picker_title" msgid="9219376327364915334">"Verrouillage de l\'écran"</string>
    <string name="lock_settings_picker_new_lock_title" msgid="3113042086804290919">"Choisissez un verrouillage d\'écran"</string>
    <string name="lock_settings_picker_update_lock_title" msgid="536853138943415927">"Choisissez nouv. verr. écran"</string>
    <string name="lock_settings_picker_new_profile_lock_title" msgid="2270462215256413800">"Choisir verrouillage pour applis pro"</string>
    <string name="lock_settings_picker_update_profile_lock_title" msgid="5929068163516308927">"Choisir nouveau verrouillage prof."</string>
    <string name="lock_settings_picker_biometrics_added_security_message" msgid="1105247657304421299">"Pour plus de sécurité, configurez une méthode secondaire pour verrouiller l\'écran"</string>
    <string name="lock_settings_picker_biometric_message" msgid="2609666443527262781">"Choisissez votre méthode secondaire de verrouillage d\'écran"</string>
    <string name="lock_settings_picker_admin_restricted_personal_message" msgid="3532653662159888328">"Si vous oubliez votre code de verrouillage, votre admin. informatique ne pourra pas le réinitialiser."</string>
    <string name="lock_settings_picker_admin_restricted_personal_message_action" msgid="5956615234246626264">"Définir un code de verrouillage distinct pour le profil professionnel"</string>
    <string name="lock_settings_picker_profile_message" msgid="9142379549980873478">"Si vous oubliez ce verrouillage, demandez à votre administrateur informatique de le réinitialiser"</string>
    <string name="setup_lock_settings_options_button_label" msgid="6098297461618298505">"Options de verrouillage de l\'écran"</string>
    <string name="setup_lock_settings_options_dialog_title" msgid="7985107300517468569">"Options de verrouillage de l\'écran"</string>
    <string name="lock_screen_auto_pin_confirm_title" msgid="3012128112186088375">"Confirmation automatique du déverrouillage"</string>
    <string name="lock_screen_auto_pin_confirm_summary" msgid="9050818870806580819">"Déverrouillage automatique si vous entrez un NIP correct de six chiffres ou plus. Cette méthode est un peu moins sécuritaire que de toucher Entrée pour confirmer."</string>
    <string name="auto_pin_confirm_user_message" msgid="6194556173488939314">"Confirmation automatique du NIP correct"</string>
    <string name="auto_pin_confirm_opt_in_security_message" msgid="580773976736184893">"La confirmation de votre NIP en touchant Entrée est plus sécuritaire que la confirmation automatique"</string>
    <string name="unlock_set_unlock_launch_picker_title" msgid="4981063601772605609">"Verrouillage de l\'écran"</string>
    <string name="unlock_set_unlock_launch_picker_title_profile" msgid="7631371082326055429">"Verrouillage du profil professionnel"</string>
    <string name="unlock_set_unlock_off_title" msgid="2831957685685921667">"Aucun"</string>
    <string name="unlock_set_unlock_none_title" msgid="2844029875174409728">"Balayer l\'écran"</string>
    <string name="unlock_set_unlock_pattern_title" msgid="8224895208452995332">"Schéma"</string>
    <string name="unlock_set_unlock_pin_title" msgid="5283636759362880407">"NIP"</string>
    <string name="unlock_set_unlock_password_title" msgid="2559842616268607041">"Mot de passe"</string>
    <string name="unlock_set_do_later_title" msgid="6565575303676064364">"Pas maintenant"</string>
    <string name="current_screen_lock" msgid="1367883977261098017">"Verrouillage actuel de l\'écran"</string>
    <string name="fingerprint_unlock_set_unlock_pattern" msgid="4492334416059646032">"Empreinte digitale + schéma"</string>
    <string name="fingerprint_unlock_set_unlock_pin" msgid="4724451168139460493">"Empreinte digitale + NIP"</string>
    <string name="fingerprint_unlock_set_unlock_password" msgid="5614333047430835971">"Empreinte digitale + mot de passe"</string>
    <string name="fingerprint_unlock_skip_fingerprint" msgid="7631242444064287891">"Continuer sans empreintes digitales"</string>
    <string name="face_unlock_set_unlock_pattern" msgid="3117316407679805330">"Déverr. par  reconnaissance faciale + schéma"</string>
    <string name="face_unlock_set_unlock_pin" msgid="5300188327595503657">"Déverr. par reconnaissance faciale + NIP"</string>
    <string name="face_unlock_set_unlock_password" msgid="8395722611524617956">"Déverr. par reconnaissance faciale + mot de passe"</string>
    <string name="face_unlock_skip_face" msgid="189695556498300008">"Continuer sans configurer déverr. par reconnaissance faciale"</string>
    <string name="biometrics_unlock_set_unlock_pattern" msgid="8084495264354847044">"Schéma • Visage • Empreinte digitale"</string>
    <string name="biometrics_unlock_set_unlock_pin" msgid="5912980580857825894">"NIP • Visage • Empreinte digitale"</string>
    <string name="biometrics_unlock_set_unlock_password" msgid="4612217647465743624">"Mot de passe • Visage • Empreinte digitale"</string>
    <string name="biometrics_unlock_skip_biometrics" msgid="7785643433551409223">"Continuer sans reconnaissance faciale ni empreinte digitale"</string>
    <string name="unlock_set_unlock_mode_off" msgid="4632139864722236359">"Aucun"</string>
    <string name="unlock_set_unlock_mode_none" msgid="5596049938457028214">"Balayer l\'écran"</string>
    <string name="unlock_set_unlock_mode_pattern" msgid="1926480143883094896">"Schéma"</string>
    <string name="unlock_set_unlock_mode_pin" msgid="9028659554829888373">"NIP"</string>
    <string name="unlock_set_unlock_mode_password" msgid="8810609692771987513">"Mot de passe"</string>
    <string name="unlock_disable_frp_warning_title" msgid="3606280046362811229">"Supprimer le verrouillage de l\'écran?"</string>
    <string name="unlock_disable_frp_warning_title_profile" msgid="1005284289723910461">"Supprimer la protection du profil?"</string>
    <string name="unlock_disable_frp_warning_content_pattern" msgid="6246242612158828147">"Un schéma protège votre téléphone en cas de perte ou de vol"</string>
    <string name="unlock_disable_frp_warning_content_pattern_fingerprint" msgid="2259825377085781801">"Un schéma protège votre téléphone en cas de perte ou de vol.<xliff:g id="EMPTY_LINE">

</xliff:g>Cette fonctionnalité supprime également le modèle d\'empreinte digitale stocké sur votre appareil. Vous ne pourrez pas utiliser votre empreinte digitale pour vous authentifier dans les applications."</string>
    <string name="unlock_disable_frp_warning_content_pattern_face" msgid="4699508435412336378">"Un schéma protège votre téléphone en cas de perte ou de vol.<xliff:g id="EMPTY_LINE">

</xliff:g>Votre modèle facial sera également supprimé définitivement de façon sécurisée. Vous ne pourrez pas utiliser votre visage pour vous authentifier dans les applications."</string>
    <string name="unlock_disable_frp_warning_content_pattern_face_fingerprint" msgid="7049706229344804972">"Un schéma protège votre téléphone en cas de perte ou de vol.<xliff:g id="EMPTY_LINE">

</xliff:g>Cette fonctionnalité supprime le modèle d\'empreinte digitale stocké sur votre appareil. Votre modèle facial sera également supprimé définitivement de façon sécurisée. Vous ne pourrez pas utiliser votre visage ni votre empreinte digitale pour vous authentifier dans les applications."</string>
    <string name="unlock_disable_frp_warning_content_pin" msgid="122154942944422284">"Un NIP protège votre téléphone en cas de perte ou de vol"</string>
    <string name="unlock_disable_frp_warning_content_pin_fingerprint" msgid="983373874470746066">"Un NIP protège votre téléphone en cas de perte ou de vol.<xliff:g id="EMPTY_LINE">

</xliff:g>Cette fonctionnalité supprime également le modèle d\'empreinte digitale stocké sur votre appareil. Vous ne pourrez pas utiliser votre empreinte digitale pour vous authentifier dans les applications."</string>
    <string name="unlock_disable_frp_warning_content_pin_face" msgid="5607150515413131761">"Un NIP protège votre téléphone en cas de perte ou de vol.<xliff:g id="EMPTY_LINE">

</xliff:g>Votre modèle facial sera également supprimé définitivement de façon sécurisée. Vous ne pourrez pas utiliser votre visage pour vous authentifier dans les applications."</string>
    <string name="unlock_disable_frp_warning_content_pin_face_fingerprint" msgid="1821792325159866312">"Un NIP protège votre téléphone en cas de perte ou de vol.<xliff:g id="EMPTY_LINE">

</xliff:g>Cette fonctionnalité supprime le modèle d\'empreinte digitale stocké sur votre appareil. Votre modèle facial sera également supprimé définitivement de façon sécurisée. Vous ne pourrez pas utiliser votre visage ni votre empreinte digitale pour vous authentifier dans les applications."</string>
    <string name="unlock_disable_frp_warning_content_password" msgid="6422723907917376210">"Un mot de passe protège votre téléphone en cas de perte ou de vol"</string>
    <string name="unlock_disable_frp_warning_content_password_fingerprint" msgid="8899452884016354856">"Un mot de passe protège votre téléphone en cas de perte ou de vol.<xliff:g id="EMPTY_LINE">

</xliff:g>Cette fonctionnalité supprime également le modèle d\'empreinte digitale stocké sur votre appareil. Vous ne pourrez pas utiliser votre empreinte digitale pour vous authentifier dans les applications."</string>
    <string name="unlock_disable_frp_warning_content_password_face" msgid="1811067332335964495">"Un mot de passe protège votre téléphone en cas de perte ou de vol.<xliff:g id="EMPTY_LINE">

</xliff:g>Votre modèle facial sera également supprimé définitivement de façon sécurisée. Vous ne pourrez pas utiliser votre visage pour vous authentifier dans les applications."</string>
    <string name="unlock_disable_frp_warning_content_password_face_fingerprint" msgid="7063649456205159491">"Un mot de passe protège votre téléphone en cas de perte ou de vol.<xliff:g id="EMPTY_LINE">

</xliff:g>Cette fonctionnalité supprime le modèle d\'empreinte digitale stocké sur votre appareil. Votre modèle facial sera également supprimé définitivement de façon sécurisée. Vous ne pourrez pas utiliser votre visage ni votre empreinte digitale pour vous authentifier dans les applications."</string>
    <string name="unlock_disable_frp_warning_content_unknown" msgid="8903568674104115231">"Les fonctionnalités de protection de l\'appareil ne fonctionneront pas sans votre verrouillage d\'écran."</string>
    <string name="unlock_disable_frp_warning_content_unknown_fingerprint" msgid="6542744110902941189">"Les fonctionnalités de protection de l\'appareil ne fonctionneront pas sans votre verrouillage d\'écran.<xliff:g id="EMPTY_LINE">

</xliff:g>Cette fonctionnalité supprime également le modèle d\'empreinte digitale stocké sur votre appareil. Vous ne pourrez pas utiliser votre empreinte digitale pour vous authentifier dans les applications."</string>
    <string name="unlock_disable_frp_warning_content_unknown_face" msgid="4559917661432267841">"Les fonctionnalités de protection de l\'appareil ne fonctionneront pas sans votre verrouillage d\'écran.<xliff:g id="EMPTY_LINE">

</xliff:g>Votre modèle facial sera également supprimé définitivement de façon sécurisée. Vous ne pourrez pas utiliser votre visage pour vous authentifier dans les applications."</string>
    <string name="unlock_disable_frp_warning_content_unknown_face_fingerprint" msgid="3779582301453677644">"Les fonctionnalités de protection de l\'appareil ne fonctionneront pas sans votre verrouillage d\'écran.<xliff:g id="EMPTY_LINE">

</xliff:g>Cette fonctionnalité supprime le modèle d\'empreinte digitale stocké sur votre appareil. Votre modèle facial sera également supprimé définitivement de façon sécurisée. Vous ne pourrez pas utiliser votre visage ni votre empreinte digitale pour vous authentifier dans les applications."</string>
    <string name="unlock_disable_frp_warning_ok" msgid="6173427638951230842">"Supprimer"</string>
    <string name="unlock_footer_high_complexity_requested" msgid="4471274783909915352">"<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="5515870066751600640">"<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="2517656037576567971">"<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="8534900170428140529">"L\'application <xliff:g id="APP_NAME">%1$s</xliff:g> vous recommande d\'utiliser un nouveau mode de verrouillage de l\'écran"</string>
    <string name="lock_failed_attempts_before_wipe" msgid="6874652886647631418">"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="7450322567217745999">"Vos données seront supprimées"</string>
    <string name="lock_last_pattern_attempt_before_wipe_device" msgid="5816668400104558952">"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="2815681042623708775">"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="985126164175708507">"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="8283944727199433440">"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="972834567684477451">"Si vous entrez un NIP incorrect à la prochaine tentative, cet utilisateur sera supprimé"</string>
    <string name="lock_last_password_attempt_before_wipe_user" msgid="3797239847079686727">"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="2479195488386373253">"Si vous entrez un schéma incorrect à la prochaine tentative, votre profil professionnel et ses données seront supprimés"</string>
    <string name="lock_last_pin_attempt_before_wipe_profile" msgid="7086428013814722436">"Si vous entrez un NIP incorrect à la prochaine tentative, votre profil professionnel et ses données seront supprimés"</string>
    <string name="lock_last_password_attempt_before_wipe_profile" msgid="253673907244112643">"Si vous entrez un mot de passe incorrect à la prochaine tentative, votre profil professionnel et ses données seront supprimés"</string>
    <string name="lockpassword_password_too_short" msgid="1938086368137797700">"{count,plural, =1{Doit contenir au moins # caractère}one{Doit contenir au moins # caractère}other{Doit contenir au moins # caractères}}"</string>
    <string name="lockpassword_password_too_short_all_numeric" msgid="4301294924022401502">"{count,plural, =1{Les mots de passe numériques doivent contenir au moins 1 chiffre}one{Les mots de passe numériques doivent contenir au moins # chiffre}other{Les mots de passe numériques doivent contenir au moins # chiffres}}"</string>
    <string name="lockpassword_pin_too_short" msgid="8910105226463085689">"{count,plural, =1{Le NIP doit contenir au moins # chiffre}one{Le NIP doit contenir au moins # chiffre}other{Le NIP doit contenir au moins # chiffres}}"</string>
    <string name="lockpassword_pin_too_short_autoConfirm_extra_message" msgid="3271351502900762571">"{count,plural, =1{Le NIP doit contenir au moins # chiffre, mais un NIP à {minAutoConfirmLen} chiffres est recommandé pour plus de sécurité}one{Le NIP doit contenir au moins # chiffre, mais un NIP à {minAutoConfirmLen} chiffres est recommandé pour plus de sécurité}other{Le NIP doit contenir au moins # chiffres, mais un NIP à {minAutoConfirmLen} chiffres est recommandé pour plus de sécurité}}"</string>
    <string name="lockpassword_password_too_long" msgid="1940345313260498308">"{count,plural, =1{Doit contenir moins de # caractère}one{Doit contenir moins de # caractère}other{Doit contenir moins de # caractères}}"</string>
    <string name="lockpassword_pin_too_long" msgid="1678212054564388576">"{count,plural, =1{Doit contenir moins de # chiffre}one{Doit contenir moins de # chiffre}other{Doit contenir moins de # chiffres}}"</string>
    <string name="lockpassword_pin_recently_used" msgid="6650277060998923465">"L\'administrateur de l\'appareil ne permet pas l\'utilisation d\'un NIP récent"</string>
    <string name="lockpassword_illegal_character" msgid="3434031212215886433">"Vous ne pouvez pas inclure de caractère non valide"</string>
    <string name="lockpassword_password_requires_letters" msgid="7058340182953750553">"{count,plural, =1{Doit contenir au moins 1 lettre}one{Doit contenir au moins # lettre}other{Doit contenir au moins # lettres}}"</string>
    <string name="lockpassword_password_requires_lowercase" msgid="3286121470522077547">"{count,plural, =1{Doit contenir au moins 1 lettre minuscule}one{Doit contenir au moins # lettre minuscule}other{Doit contenir au moins # lettres minuscules}}"</string>
    <string name="lockpassword_password_requires_uppercase" msgid="720312543910397772">"{count,plural, =1{Doit contenir au moins 1 lettre majuscule}one{Doit contenir au moins # lettre majuscule}other{Doit contenir au moins # lettres majuscules}}"</string>
    <string name="lockpassword_password_requires_numeric" msgid="3886918493600507548">"{count,plural, =1{Doit contenir au moins 1 chiffre}one{Doit contenir au moins # chiffre}other{Doit contenir au moins # chiffres}}"</string>
    <string name="lockpassword_password_requires_symbols" msgid="2904870551002210131">"{count,plural, =1{Doit contenir au moins 1 caractère spécial}one{Doit contenir au moins # caractère spécial}other{Doit contenir au moins # caractères spéciaux}}"</string>
    <string name="lockpassword_password_requires_nonletter" msgid="1185342065898300006">"{count,plural, =1{Doit contenir au moins 1 caractère non alphabétique}one{Doit contenir au moins # caractère non alphabétique}other{Doit contenir au moins # caractères non alphabétiques}}"</string>
    <string name="lockpassword_password_requires_nonnumerical" msgid="389687423482993365">"{count,plural, =1{Doit contenir au moins 1 caractère non numérique}one{Doit contenir au moins # caractère non numérique}other{Doit contenir au moins # caractères non numériques}}"</string>
    <string name="lockpassword_password_recently_used" msgid="5341218079730167191">"L\'administrateur de l\'appareil ne permet pas l\'utilisation d\'un mot de passe récent"</string>
    <string name="lockpassword_pin_no_sequential_digits" msgid="5843639256988031272">"Les suites croissantes, décroissantes ou répétitives de chiffres ne sont pas autorisées"</string>
    <string name="lockpassword_confirm_label" msgid="560897521093566777">"Confirmer"</string>
    <string name="lockpassword_clear_label" msgid="311359833434539894">"Effacer"</string>
    <string name="lockpassword_credential_changed" msgid="5934778179732392028">"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="775215267818384016">"Annuler"</string>
    <string name="lockpattern_tutorial_continue_label" msgid="1329049481210689408">"Suivant"</string>
    <string name="manage_device_admin" msgid="1044620606203916275">"Applications d\'administration d\'appareils"</string>
    <string name="number_of_device_admins_none" msgid="152926922020437312">"Aucune application active"</string>
    <string name="number_of_device_admins" msgid="3402909995362162876">"{count,plural, =1{# application active}one{# application active}other{# applications actives}}"</string>
    <string name="manage_trust_agents" msgid="6410149930029992356">"Agents de confiance"</string>
    <string name="disabled_because_no_backup_security" msgid="4998095356607488854">"Pour l\'utiliser, définissez d\'abord un écran de verrouillage"</string>
    <string name="manage_trust_agents_summary" msgid="6423843123607674286">"Aucun"</string>
    <string name="manage_trust_agents_summary_on" msgid="3302574418419446146">"{count,plural, =1{1 agent de confiance actif}one{# agent de confiance actif}other{# agents de confiance actifs}}"</string>
    <string name="bluetooth_settings" msgid="2967239493428695171">"Bluetooth"</string>
    <string name="bluetooth_settings_title" msgid="2642029095769509647">"Bluetooth"</string>
    <string name="bluetooth_pairing_request" msgid="7762990650683525640">"Associer avec <xliff:g id="DEVICE_NAME">%1$s</xliff:g>?"</string>
    <string name="bluetooth_pairing_key_msg" msgid="1329835708475701761">"Code d\'association Bluetooth"</string>
    <string name="bluetooth_enter_passkey_msg" msgid="5806420933599368592">"Entrez le code d\'association, puis appuyez sur Retour ou Entrée"</string>
    <string name="bluetooth_enable_alphanumeric_pin" msgid="7256286571636950635">"Le NIP contient des lettres ou des symboles."</string>
    <string name="bluetooth_pin_values_hint" msgid="2753202519050044670">"Habituellement 0000 ou 1234"</string>
    <string name="bluetooth_pin_values_hint_16_digits" msgid="5603928271430883558">"Le numéro doit comporter 16 chiffres"</string>
    <string name="bluetooth_enter_pin_other_device" msgid="6737778699899780717">"Vous devrez peut-être également saisir ce NIP sur l\'autre appareil."</string>
    <string name="bluetooth_enter_passkey_other_device" msgid="8270426446247344709">"Vous devrez peut-être également saisir cette clé d\'accès sur l\'autre appareil."</string>
    <string name="bluetooth_paring_group_msg" msgid="4609515924670823316">"Confirmez pour effectuer l\'association avec l\'ensemble coordonné"</string>
    <string name="bluetooth_pairing_shares_phonebook" msgid="4329325125260724843">"Autoriser l\'accès à vos contacts et à l\'historique des appels"</string>
    <string name="bluetooth_error_title" msgid="2284738188253690278"></string>
    <string name="bluetooth_connecting_error_message" msgid="3941893154784152112">"Impossible de se connecter à <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="bluetooth_preference_found_media_devices" msgid="830061195998352840">"Appareils détectés"</string>
    <string name="bluetooth_device_context_connect" msgid="4913860372216815855">"Connexion"</string>
    <string name="bluetooth_device_context_disconnect" msgid="4464167389972513232">"Déconnecter"</string>
    <string name="bluetooth_device_context_pair_connect" msgid="2406032703622371826">"Associer et connecter"</string>
    <string name="bluetooth_empty_list_bluetooth_off" msgid="316627049372961941">"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="786648535600075223">"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é en tout temps, même si le Bluetooth est désactivé. Cette autorisation peut permettre, par exemple, d\'améliorer les fonctionnalités et les services reposant sur la localisation. Vous pouvez modifier cette option dans les paramètres de recherche Bluetooth."</string>
    <string name="bluetooth_scan_change" msgid="1744636222637390367">"Modifier"</string>
    <string name="device_details_title" msgid="1155622417516195481">"Détails de l\'appareil"</string>
    <string name="bluetooth_device_keyboard_settings_preference_title" msgid="3411693160917620519">"Paramètres du clavier"</string>
    <string name="bluetooth_device_mac_address" msgid="4873325074786732703">"Adresse Bluetooth de l\'appareil : <xliff:g id="ADDRESS">%1$s</xliff:g>"</string>
    <string name="bluetooth_multuple_devices_mac_address" msgid="4974301550897923376">"Adresse Bluetooth de l\'appareil :\n<xliff:g id="ADDRESS">%1$s</xliff:g>"</string>
    <string name="bluetooth_unpair_dialog_title" msgid="6943633443716052995">"Oublier l\'appareil?"</string>
    <string name="remove_association_button" msgid="5004208145998061135">"Retirer l\'association"</string>
    <string name="bluetooth_companion_app_remove_association_dialog_title" msgid="1344518601377991897">"Déconnecter l\'application?"</string>
    <string name="bluetooth_companion_app_body" msgid="8442643629075687761">"L\'application <xliff:g id="APP_NAME">%1$s</xliff:g> ne se connectera plus à votre <xliff:g id="DEVICE_NAME">%2$s</xliff:g>"</string>
    <string name="bluetooth_unpair_dialog_forget_confirm_button" msgid="9184489424930549015">"Oublier l\'appareil"</string>
    <string name="bluetooth_companion_app_remove_association_confirm_button" msgid="76323555527926915">"Déconnecter l\'application"</string>
    <string name="bluetooth_max_connected_audio_devices_string" msgid="3114156958598821615">"Maximum d\'appareils audio Bluetooth connectés"</string>
    <string name="bluetooth_max_connected_audio_devices_dialog_title" msgid="4056811727247312473">"Sélectionnez le nombre maximal d\'appareils Bluetooth connectés"</string>
    <string name="nfc_stack_debuglog_title" msgid="2926748386805740609">"Journal de débogage de la pile de la CCP"</string>
    <string name="nfc_stack_debuglog_summary" msgid="7333205107551132121">"Accroître le niveau de journalisation de la pile de la CCP"</string>
    <string name="nfc_verbose_vendor_log_title" msgid="5554505631122964628">"Journal de débogage détaillé des fournisseurs CCP"</string>
    <string name="nfc_verbose_vendor_log_summary" msgid="3049128322855928507">"Incluez les journaux supplémentaires du fournisseur propres à l\'appareil dans les rapports de bogue, qui peuvent contenir des renseignements confidentiels."</string>
    <string name="nfc_snoop_log_title" msgid="1576197495976952388">"Journal CCP non filtré d\'ACTA"</string>
    <string name="nfc_snoop_log_summary" msgid="3988383328800163180">"Capturez les détails des paquets CCP, qui peuvent contenir des renseignements confidentiels."</string>
    <string name="nfc_reboot_dialog_title" msgid="2033983438635768169">"Redémarrer l\'appareil?"</string>
    <string name="nfc_reboot_dialog_message" msgid="4929353168157966992">"Les détails de la journalisation CCP sont enregistrés à des fins de développement uniquement. Des données CCP supplémentaires sont comprises dans les rapports de bogue, qui peuvent contenir des renseignements confidentiels. Redémarrez votre appareil pour modifier ce paramètre."</string>
    <string name="nfc_reboot_dialog_confirm" msgid="4769763632008584567">"Redémarrer"</string>
    <string name="wifi_display_settings_title" msgid="6451625615274960175">"Cast"</string>
    <string name="keywords_wifi_display_settings" msgid="5753883229564422679">"miroir"</string>
    <string name="wifi_display_enable_menu_item" msgid="7391841780777318134">"Activer l\'affichage sans fil"</string>
    <string name="wifi_display_no_devices_found" msgid="7904877793677102805">"Aucun appareil détecté à proximité."</string>
    <string name="wifi_display_status_connecting" msgid="530880182560077334">"Connexion en cours…"</string>
    <string name="wifi_display_status_connected" msgid="2189925211258519539">"Connecté"</string>
    <string name="wifi_display_status_in_use" msgid="5904009697167947449">"En cours d\'utilisation"</string>
    <string name="wifi_display_status_not_available" msgid="8463750208946968594">"Non disponible"</string>
    <string name="wifi_display_options_title" msgid="7584326966240865043">"Options d\'affichage sans fil"</string>
    <string name="wifi_display_options_forget" msgid="3140558691112356024">"Supprimer"</string>
    <string name="wifi_display_options_done" msgid="7608851767701954020">"Terminé"</string>
    <string name="wifi_display_options_name" msgid="8181334945680312228">"Nom"</string>
    <string name="wifi_band_24ghz" msgid="7322286660245127384">"2,4 GHz"</string>
    <string name="wifi_band_5ghz" msgid="7995204987245404797">"5 GHz"</string>
    <string name="wifi_band_6ghz" msgid="8166833829829455339">"6 GHz"</string>
    <string name="wifi_sign_in_button_text" msgid="8483892122845654850">"Connexion"</string>
    <string name="wifi_venue_website_button_text" msgid="7749360432667175030">"Ouvrir le site"</string>
    <string name="wifi_time_remaining" msgid="8503606272869846170">"Il reste <xliff:g id="REMAINING_TIME">%1$s</xliff:g>"</string>
    <string name="wifi_expiry_time" msgid="5419758551129267624">"Expire le <xliff:g id="EXPIRY_TIME">%1$s</xliff:g>"</string>
    <string name="tx_link_speed" msgid="3071955184703668113">"<xliff:g id="TRANSMIT_LINK_SPEED">%1$d</xliff:g> Mb/s"</string>
    <string name="rx_link_speed" msgid="6292229178855567783">"<xliff:g id="RECEIVE_LINK_SPEED">%1$d</xliff:g> Mb/s"</string>
    <string name="link_speed" msgid="931786745741016446">"<xliff:g id="LINK_SPEED">%1$d</xliff:g> Mb/s"</string>
    <string name="wifi_ask_enable" msgid="6860056048266810769">"<xliff:g id="REQUESTER">%s</xliff:g> souhaite activer le Wi-Fi"</string>
    <string name="wifi_ask_disable" msgid="1663208096020309639">"<xliff:g id="REQUESTER">%s</xliff:g> souhaite désactiver le Wi-Fi"</string>
    <string name="art_verifier_for_debuggable_title" msgid="1926445785190030479">"Vérif. code à octets des applis déboguables"</string>
    <string name="art_verifier_for_debuggable_summary" msgid="4802875841862652879">"Autoriser ART à vérifier le code à octets pour les applications débogables"</string>
    <string name="show_refresh_rate" msgid="5742688821872354973">"Afficher le taux d\'actualisation"</string>
    <string name="show_refresh_rate_summary" msgid="3558118122374609663">"Afficher le taux d\'actualisation actuel"</string>
    <string name="nfc_quick_toggle_title" msgid="3607620705230351666">"CCP"</string>
    <string name="nfc_secure_settings_title" msgid="4906958426927741485">"Déverrouillage de l\'appareil requis pour utiliser la fonctionnalité CCP"</string>
    <string name="android_beam_settings_title" msgid="2797963824490671295">"Android Beam"</string>
    <string name="android_beam_on_summary" msgid="6067720758437490896">"Prêt à partager le contenu de l\'application par CCP"</string>
    <string name="android_beam_off_summary" msgid="5693961375631325042">"Désactivé"</string>
    <string name="nfc_disabled_summary" msgid="8737797364522502351">"Non accessible, car la CCP est désactivée"</string>
    <string name="android_beam_explained" msgid="5684416131846701256">"Lorsque cette fonctionnalité est activée, vous pouvez partager le contenu d\'une application avec un appareil compatible CCP 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_settings" msgid="8313301946393559700">"Wi-Fi"</string>
    <string name="wifi_settings_primary_switch_title" msgid="628360786662947258">"Utiliser le Wi-Fi"</string>
    <string name="wifi_settings_category" msgid="3523464780563778321">"Paramètres Wi-Fi"</string>
    <string name="wifi_select_network" msgid="6692897876718813259">"Sélectionner le Wi-Fi"</string>
    <string name="wifi_starting" msgid="6147022683967506341">"Activation du Wi-Fi en cours…"</string>
    <string name="wifi_stopping" msgid="4471699665741299711">"Désactivation du Wi-Fi en cours…"</string>
    <string name="wifi_error" msgid="4903954145386086899">"Erreur"</string>
    <string name="wifi_sap_no_channel_error" msgid="2126487622024749402">"La bande de 5 GHz n\'est pas disponible dans ce pays"</string>
    <string name="wifi_in_airplane_mode" msgid="1235412508135267981">"En mode Avion"</string>
    <string name="wifi_notify_open_networks" msgid="2610323626246818961">"Notifier pour les réseaux publics"</string>
    <string name="wifi_notify_open_networks_summary" msgid="191058832201741013">"M\'informer quand un réseau public de haute qualité se trouve à proximité"</string>
    <string name="wifi_wakeup" msgid="3834327315861781611">"Activer le Wi-Fi automatiquement"</string>
    <string name="wifi_wakeup_summary" msgid="5778059083790221465">"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="681323616606485096">"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_install_credentials" msgid="5192903644606839972">"Installer les certificats"</string>
    <string name="wifi_scan_notify_text" msgid="7163137260385995873">"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 de réseaux Wi-Fi<xliff:g id="LINK_END_1">LINK_END</xliff:g>."</string>
    <string name="wifi_scan_notify_text_scanning_off" msgid="7439201783168213149">"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 de réseaux Wi-Fi<xliff:g id="LINK_END_1">LINK_END</xliff:g>."</string>
    <string name="wifi_cellular_data_fallback_title" msgid="2844653839490977040">"Passer automatiquement au réseau cellulaire"</string>
    <string name="wifi_cellular_data_fallback_summary" msgid="7039944853033554386">"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="4178564862173751181">"Ajouter un réseau"</string>
    <string name="wifi_configure_settings_preference_title" msgid="2536725796700696566">"Préférences Wi-Fi"</string>
    <string name="wifi_configure_settings_preference_summary_wakeup_on" msgid="7822368955551467382">"Le Wi-Fi se réactive automatiquement"</string>
    <string name="wifi_configure_settings_preference_summary_wakeup_off" msgid="5710203586018223864">"Le Wi-Fi ne se réactive pas automatiquement"</string>
    <string name="wifi_menu_p2p" msgid="5234165837732940385">"Wi-Fi direct"</string>
    <string name="wifi_empty_list_wifi_off" msgid="7697422506708419298">"Activez le Wi-Fi pour voir les réseaux disponibles."</string>
    <string name="wifi_empty_list_wifi_on" msgid="2448010040478321376">"Recherche de réseaux en cours…"</string>
    <string name="wifi_empty_list_user_restricted" msgid="454861411536708709">"Vous n\'avez pas l\'autorisation de modifier le réseau Wi‑Fi."</string>
    <string name="wifi_settings_scanning_required_title" msgid="1088663325396007484">"Activer la recherche de réseaux Wi-Fi?"</string>
    <string name="wifi_settings_scanning_required_summary" msgid="4770243653675416569">"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="1473411566072565789">"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="1112223196123955447">"Activer"</string>
    <string name="wifi_settings_scanning_required_enabled" msgid="4721729158927146365">"La recherche de réseaux Wi-Fi est activée"</string>
    <string name="wifi_show_advanced" msgid="2969378109942071741">"Options avancées"</string>
    <string name="wifi_advanced_toggle_description" msgid="7299179796727934885">"Liste déroulante des options avancées"</string>
    <string name="wifi_advanced_toggle_description_collapsed" msgid="3615140699129928913">"développer"</string>
    <string name="wifi_ssid" msgid="2713062130735103151">"Nom du réseau"</string>
    <string name="wifi_ssid_hint" msgid="1940577553241083524">"Entrez le SSID"</string>
    <string name="wifi_security" msgid="9095934643631406913">"Sécurité"</string>
    <string name="wifi_hidden_network" msgid="6466834025375485596">"Réseau masqué"</string>
    <string name="wifi_hidden_network_warning" msgid="3937433813754746158">"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="4442182285304271424">"Intensité du signal"</string>
    <string name="wifi_status" msgid="5349199188871002778">"État"</string>
    <string name="tx_wifi_speed" msgid="2368986629172050673">"Vitesse du lien de transmission"</string>
    <string name="rx_wifi_speed" msgid="5167966079215111232">"Vitesse du lien de réception"</string>
    <string name="wifi_speed" msgid="6562147734565434513">"Vitesse de connexion"</string>
    <string name="wifi_frequency" msgid="3120998420184702834">"Fréquence"</string>
    <string name="wifi_ip_address" msgid="8903577251845268209">"Adresse IP"</string>
    <string name="passpoint_label" msgid="6513669696739302866">"Enregistré par"</string>
    <string name="passpoint_content" msgid="5219226173518418335">"Données de connexion pour <xliff:g id="NAME">%1$s</xliff:g>"</string>
    <string name="wifi_eap_method" msgid="3776009521349381742">"Méthode EAP"</string>
    <string name="please_select_phase2" msgid="577633852089847142">"Authentification de la phase 2"</string>
    <string name="wifi_eap_ca_cert" msgid="8033404008276298886">"Certificat CA"</string>
    <string name="wifi_eap_min_tls_ver" msgid="174023604103299457">"Version TLS minimale"</string>
    <string name="wifi_eap_ocsp" msgid="8713933962516871238">"État du certificat en ligne"</string>
    <string name="wifi_eap_domain" msgid="8304301470752333203">"Domaine"</string>
    <string name="wifi_eap_user_cert" msgid="3569182430929173220">"Certificat utilisateur"</string>
    <string name="wifi_eap_identity" msgid="3629406902174137028">"Identité"</string>
    <string name="wifi_eap_anonymous" msgid="8630332141751267000">"Anonyme"</string>
    <string name="wifi_password" msgid="1458802324849513755">"Mot de passe"</string>
    <string name="wifi_show_password" msgid="6865993988238157923">"Afficher le mot de passe"</string>
    <string name="wifi_ap_choose_2G" msgid="1436802195991542016">"Bande de 2,4 GHz"</string>
    <string name="wifi_ap_prefer_5G" msgid="2520628479818369902">"Préférer la bande de 5,0 GHz"</string>
    <string name="wifi_ip_settings" msgid="6420498748726599133">"Paramètres IP"</string>
    <string name="wifi_privacy_settings" msgid="3283946009000725698">"Confidentialité"</string>
    <string name="wifi_subscription" msgid="4432423938285430113">"Abonnement"</string>
    <string name="wifi_subscription_summary" msgid="18802471063384598">"Affichez ou modifiez l\'abonnement"</string>
    <string name="wifi_privacy_settings_ephemeral_summary" msgid="8502084692297249372">"Adresse MAC aléatoire"</string>
    <string name="wifi_dpp_add_device_to_network" msgid="6141246783457722976">"Ajouter un appareil"</string>
    <string name="wifi_dpp_center_qr_code" msgid="5270782275746178104">"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="3543923817779444434">"Numérisez le code QR"</string>
    <string name="wifi_dpp_scan_qr_code_join_network" msgid="969985020363459133">"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="3180020429793614145">"Connectez-vous au Wi-Fi en numérisant un code QR"</string>
    <string name="wifi_dpp_share_wifi" msgid="2431744447544057866">"Partager le Wi‑Fi"</string>
    <string name="wifi_dpp_scan_qr_code_with_another_device" msgid="6967364080214325016">"Numérisez ce code QR avec un autre appareil pour vous connecter à « <xliff:g id="SSID">%1$s</xliff:g> »"</string>
    <string name="wifi_dpp_scan_open_network_qr_code_with_another_device" msgid="5398619697898444311">"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="847551626830740204">"Réessayez. Si le problème persiste, communiquez avec le fabricant de l\'appareil"</string>
    <string name="wifi_dpp_failure_not_compatible" msgid="4453775826337805825">"Un problème s\'est produit"</string>
    <string name="wifi_dpp_failure_timeout" msgid="7902971341771145564">"Assurez-vous que l\'appareil est branché, chargé et allumé"</string>
    <string name="wifi_dpp_failure_generic" msgid="6559442892600448442">"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="2908961523550486480">"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_failure_cannot_find_network" msgid="8519567801353014036">"Essayez de rapprocher l\'appareil du point d\'accès ou du routeur Wi‑Fi"</string>
    <string name="wifi_dpp_failure_enrollee_authentication" msgid="7008840843663520852">"Vérifiez votre mot de passe, puis réessayez"</string>
    <string name="wifi_dpp_failure_enrollee_rejected_configuration" msgid="982310033782652478">"Communiquez avec le fabricant de l\'appareil"</string>
    <string name="wifi_dpp_check_connection_try_again" msgid="6118892932595974823">"Vérifiez votre connexion et réessayez"</string>
    <string name="wifi_dpp_choose_network" msgid="3987007684129341427">"Choisir un réseau"</string>
    <string name="wifi_dpp_choose_network_to_connect_device" msgid="4321618376432197593">"Pour connecter votre appareil, choisissez un réseau"</string>
    <string name="wifi_dpp_add_device_to_wifi" msgid="5170095438763569255">"Ajouter cet appareil au réseau « <xliff:g id="SSID">%1$s</xliff:g> »?"</string>
    <string name="wifi_dpp_wifi_shared_with_device" msgid="4484366631307204949">"Wi‑Fi partagé avec cet appareil"</string>
    <string name="wifi_dpp_add_another_device" msgid="3307575293580739604">"Ajouter un appareil"</string>
    <string name="wifi_dpp_choose_different_network" msgid="8963625819804792157">"Choisir un réseau différent"</string>
    <string name="wifi_dpp_could_not_add_device" msgid="6865710911186601933">"Impossible d\'ajouter l\'appareil"</string>
    <string name="wifi_dpp_device_found" msgid="633646744759830603">"Appareil trouvé"</string>
    <string name="wifi_dpp_sharing_wifi_with_this_device" msgid="7250369936882080107">"Partage du Wi‑Fi avec cet appareil en cours…"</string>
    <string name="wifi_dpp_connecting" msgid="2312769193202897589">"Connexion en cours…"</string>
    <string name="wifi_dpp_share_hotspot" msgid="6186452780604755316">"Partager le point d\'accès"</string>
    <string name="wifi_dpp_lockscreen_title" msgid="4231438175617953652">"Vérifier qu\'il s\'agit bien de vous"</string>
    <string name="wifi_dpp_wifi_password" msgid="4992986319806934381">"Mot de passe Wi-Fi : <xliff:g id="PASSWORD">%1$s</xliff:g>"</string>
    <string name="wifi_dpp_hotspot_password" msgid="688464342650820420">"Mot de passe du point d\'accès : <xliff:g id="PASSWORD">%1$s</xliff:g>"</string>
    <string name="wifi_auto_connect_title" msgid="1890342051674657892">"Connexion automatique"</string>
    <string name="wifi_auto_connect_summary" msgid="1707702705345670370">"Autoriser la connexion à ce réseau lorsqu\'il est à portée"</string>
    <string name="wifi_dpp_add_device" msgid="8695656122114721335">"Ajouter un appareil"</string>
    <string name="wifi_dpp_connect_network_using_qr_code" msgid="6975258007798254937">"Utiliser un code QR pour ajouter un appareil à ce réseau"</string>
    <string name="wifi_dpp_qr_code_is_not_valid_format" msgid="5190689503019328279">"Le format du code QR est incorrect"</string>
    <string name="retry" msgid="7542103800274026915">"Réessayer"</string>
    <string name="wifi_shared" msgid="8850748923537589782">"Partager avec d\'autres utilisateurs d\'appareils"</string>
    <string name="wifi_unchanged" msgid="8026045290856150191">"(aucune modification)"</string>
    <string name="wifi_unspecified" msgid="4561964943472312208">"Veuillez choisir"</string>
    <string name="wifi_multiple_cert_added" msgid="2151019652853383776">"(Certificats multiples ajoutés)"</string>
    <string name="wifi_use_system_certs" msgid="5587866698144996931">"Utiliser les certificats système"</string>
    <string name="wifi_do_not_provide_eap_user_cert" msgid="6336636553673065145">"Ne pas fournir"</string>
    <string name="wifi_trust_on_first_use" msgid="7488431582505858774">"Faire confiance lors de la première utilisation"</string>
    <string name="wifi_ssid_too_long" msgid="5961719058705013875">"Le nom du réseau est trop long."</string>
    <string name="wifi_no_domain_warning" msgid="1452133316532366772">"Vous devez spécifier un domaine."</string>
    <string name="wifi_no_user_cert_warning" msgid="8466376918835248956">"Certificat obligatoire."</string>
    <string name="wifi_scan_always_turnon_message" msgid="2165909441512029921">"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="4903345360745717385">"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_confirm_allow" msgid="4154200627800959777">"Autoriser"</string>
    <string name="wifi_scan_always_confirm_deny" msgid="6997087934558839256">"Refuser"</string>
    <string name="no_internet_access_text" msgid="3611993143350310936">"Ce réseau ne dispose d\'aucun accès à Internet. Voulez-vous quand même l\'utiliser?"</string>
    <string name="partial_connectivity_text" msgid="8874614799723694554">"Connectivité limitée : certains services et applis pourraient ne pas fonctionner. Utiliser quand même?"</string>
    <string name="no_internet_access_remember" msgid="5113610157731269258">"Ne plus me demander pour ce réseau"</string>
    <string name="lost_internet_access_title" msgid="9032463989950384698">"Le Wi‑Fi n\'est pas connecté à Internet"</string>
    <string name="lost_internet_access_text" msgid="1535911323549496789">"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="7935665847081706202">"Passer au réseau cellulaire"</string>
    <string name="lost_internet_access_cancel" msgid="1981171269794585284">"Rester connecté au Wi-Fi"</string>
    <string name="lost_internet_access_persist" msgid="6813604557672782197">"Ne plus afficher"</string>
    <string name="wifi_connect" msgid="2481467560349907397">"Connexion"</string>
    <string name="wifi_turned_on_message" msgid="8069855406962662881">"Wi-Fi activé"</string>
    <string name="wifi_connected_to_message" msgid="8976048616505112896">"Connecté à <xliff:g id="NETWORK_NAME">%1$s</xliff:g>"</string>
    <string name="wifi_connecting_to_message" msgid="3153205024060064551">"Connexion à <xliff:g id="NETWORK_NAME">%1$s</xliff:g> en cours…"</string>
    <string name="wifi_connecting" msgid="7450277833386859724">"Connexion en cours…"</string>
    <string name="wifi_failed_connect_message" msgid="8538000546604347894">"Échec de la connexion au réseau."</string>
    <string name="wifi_not_in_range_message" msgid="3885327464037574739">"Réseau hors de portée"</string>
    <string name="wifi_forget" msgid="3485573280364015620">"Supprimer"</string>
    <string name="wifi_modify" msgid="5127926476383659412">"Modifier"</string>
    <string name="wifi_failed_forget_message" msgid="8272732599235525880">"Échec de la suppression du réseau."</string>
    <string name="wifi_save" msgid="2312643132472226807">"Enregistrer"</string>
    <string name="wifi_failed_save_message" msgid="1830279872341387120">"Échec de l\'enregistrement du réseau."</string>
    <string name="wifi_cancel" msgid="6698897376888935410">"Annuler"</string>
    <string name="wifi_forget_dialog_title" msgid="4363829200968563164">"Oublier le réseau?"</string>
    <string name="wifi_saved_access_points_summary" msgid="6637163320524940353">"{count,plural, =1{1 réseau}one{# réseau}other{# réseaux}}"</string>
    <string name="wifi_saved_passpoint_access_points_summary" msgid="8939933724918673785">"{count,plural, =1{1 abonnement}one{# abonnement}other{# abonnements}}"</string>
    <string name="wifi_saved_all_access_points_summary" msgid="2335870101156113858">"{count,plural, =1{1 réseau et abonnement}one{# réseau et abonnement}other{# réseaux et abonnements}}"</string>
    <string name="wifi_advanced_ssid_title" msgid="1561437650193980185">"SSID"</string>
    <string name="wifi_advanced_device_mac_address_title" msgid="6155800851233164411">"Adresse MAC de l\'appareil"</string>
    <string name="wifi_advanced_randomized_mac_address_title" msgid="3930671320234553088">"Adresse MAC aléatoire"</string>
    <string name="wifi_advanced_randomized_mac_address_disconnected_title" msgid="2755843130417523727">"Adresse MAC aléatoire (dernière utilisée)"</string>
    <string name="wifi_details_title" msgid="222735438574597493">"Infos sur le réseau"</string>
    <string name="wifi_details_subnet_mask" msgid="1619151769276260512">"Masque de sous-réseau"</string>
    <string name="wifi_type_title" msgid="2174893488722015838">"Type"</string>
    <string name="wifi_details_dns" msgid="273231528073312579">"DNS"</string>
    <string name="wifi_details_ipv6_address_header" msgid="1913151339341722443">"Adresses IPv6"</string>
    <string name="wifi_saved_access_points_label" msgid="5691340724310548151">"Réseaux enregistrés"</string>
    <string name="wifi_subscribed_access_points_tab" msgid="7224061396195667208">"Abonnements"</string>
    <string name="wifi_saved_other_networks_tab" msgid="7942647415716557293">"Autres réseaux"</string>
    <string name="wifi_ip_settings_invalid_ip_address" msgid="3622891107865052307">"Saisissez une adresse IP valide."</string>
    <string name="wifi_ip_settings_invalid_gateway" msgid="1174931247370931239">"Saisissez une adresse de passerelle valide."</string>
    <string name="wifi_ip_settings_invalid_dns" msgid="1757402215999845975">"Saisissez une adresse DNS correcte."</string>
    <string name="wifi_ip_settings_invalid_network_prefix_length" msgid="5980808986926987299">"Le préfixe réseau doit être compris entre 0 et 32."</string>
    <string name="wifi_dns1" msgid="6764769531843748514">"DNS 1 (sauf si un DNS privé ignore ce paramètre)"</string>
    <string name="wifi_dns2" msgid="7273133202625326148">"DNS 2 (sauf si un DNS privé ignore ce paramètre)"</string>
    <string name="wifi_gateway" msgid="3699227808616416759">"Passerelle"</string>
    <string name="wifi_network_prefix_length" msgid="1003365439352276622">"Longueur préfixe réseau"</string>
    <string name="wifi_p2p_settings_title" msgid="1689918226469221870">"Wi-Fi direct"</string>
    <string name="wifi_p2p_menu_search" msgid="8383306178784876840">"Rechercher des appareils"</string>
    <string name="wifi_p2p_menu_searching" msgid="3428767661028761100">"Recherche en cours…"</string>
    <string name="wifi_p2p_menu_rename" msgid="7059994112737743336">"Renommer l\'appareil"</string>
    <string name="wifi_p2p_peer_devices" msgid="5158559154640283546">"Appareils associés"</string>
    <string name="wifi_p2p_remembered_groups" msgid="5497007770930525695">"Groupes mémorisés"</string>
    <string name="wifi_p2p_failed_connect_message" msgid="6767831720507440027">"Impossible de se connecter."</string>
    <string name="wifi_p2p_failed_rename_message" msgid="1317434386267376606">"Échec du changement de nom de l\'appareil."</string>
    <string name="wifi_p2p_disconnect_title" msgid="96361896458072463">"Voulez-vous vraiment vous déconnecter?"</string>
    <string name="wifi_p2p_disconnect_message" msgid="1208761239498807208">"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="4490648217799144078">"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="8476985132989357041">"Annuler l\'invitation?"</string>
    <string name="wifi_p2p_cancel_connect_message" msgid="2409074184473879809">"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="4880242270742385699">"Voulez-vous vraiment supprimer ce groupe?"</string>
    <string name="wifi_hotspot_checkbox_text" msgid="1549663436920597006">"Point d\'accès Wi‑Fi"</string>
    <string name="wifi_hotspot_off_subtext" msgid="2751383134504362078">"Connexion Internet ou contenu non partagés avec d\'autres appareils"</string>
    <string name="wifi_hotspot_no_password_subtext" msgid="3685689196772398783">"Aucun mot de passe défini"</string>
    <string name="wifi_hotspot_name_title" msgid="6633480190014369846">"Nom du point d\'accès"</string>
    <string name="wifi_hotspot_password_title" msgid="9096340919454296786">"Mot de passe du point d\'accès"</string>
    <string name="wifi_hotspot_ap_band_title" msgid="560262446129195042">"Bande du point d\'accès"</string>
    <string name="wifi_hotspot_auto_off_title" msgid="8855711787485504882">"Désactiver automatiquement le point d\'accès Wi‑Fi"</string>
    <string name="wifi_hotspot_auto_off_summary" msgid="8283656069997871354">"Lorsqu\'aucun appareil n\'est connecté"</string>
    <string name="wifi_hotspot_maximize_compatibility" msgid="6494125684420024058">"Prolonger la compatibilité"</string>
    <string name="wifi_hotspot_maximize_compatibility_single_ap_summary" msgid="383355687431591441">"Aide d\'autres appareils à détecter ce point d\'accès. Réduit la vitesse de connexion du point d\'accès."</string>
    <string name="wifi_hotspot_maximize_compatibility_dual_ap_summary" msgid="3579549223159056533">"Aide d\'autres appareils à détecter ce point d\'accès. Cette fonction sollicite davantage la pile de l\'appareil."</string>
    <string name="wifi_hotspot_speed_title" msgid="8629448084180512685">"Vitesse et compatibilité"</string>
    <!-- no translation found for wifi_hotspot_speed_summary_2g (2280013579858833466) -->
    <skip />
    <!-- no translation found for wifi_hotspot_speed_summary_5g (8006841294118040080) -->
    <skip />
    <!-- no translation found for wifi_hotspot_speed_summary_6g (5398769134180715191) -->
    <skip />
    <!-- no translation found for wifi_hotspot_speed_summary_2g_and_5g (6471272988396018113) -->
    <skip />
    <!-- no translation found for wifi_hotspot_speed_intro (6973482196363758925) -->
    <skip />
    <!-- no translation found for wifi_hotspot_speed_category (5265655850463630286) -->
    <skip />
    <!-- no translation found for wifi_hotspot_speed_2g (3400600834257664480) -->
    <skip />
    <!-- no translation found for wifi_hotspot_speed_2g_summary (2737911775799813597) -->
    <skip />
    <!-- no translation found for wifi_hotspot_speed_5g (4058116867148848395) -->
    <skip />
    <!-- no translation found for wifi_hotspot_speed_5g_summary (8979160165280825325) -->
    <skip />
    <!-- no translation found for wifi_hotspot_speed_2g_5g (9192756255938408285) -->
    <skip />
    <!-- no translation found for wifi_hotspot_speed_2g_5g_summary (2901777498770191018) -->
    <skip />
    <!-- no translation found for wifi_hotspot_speed_6g (3787697484862730500) -->
    <skip />
    <!-- no translation found for wifi_hotspot_speed_6g_summary (1170553321510689693) -->
    <skip />
    <!-- no translation found for wifi_hotspot_speed_summary_unavailable (7276080644693388756) -->
    <skip />
    <!-- no translation found for wifi_hotspot_speed_footer (8846939503916795002) -->
    <skip />
    <string name="wifi_tether_starting" msgid="8879874184033857814">"Activation du point d\'accès Wi-Fi en cours…"</string>
    <string name="wifi_tether_stopping" msgid="4416492968019409188">"Désactivation du point d\'accès Wi-Fi en cours…"</string>
    <string name="wifi_tether_carrier_unsupport_dialog_title" msgid="3089432578433978073">"Le partage de connexion n\'est pas pris en charge"</string>
    <string name="wifi_tether_carrier_unsupport_dialog_content" msgid="5920421547607921112">"Communiquez avec votre fournisseur de services pour en savoir plus"</string>
    <string name="wifi_tether_enabled_subtext" msgid="5085002421099821056">"<xliff:g id="NETWORK_SSID">%1$s</xliff:g> est actif"</string>
    <string name="wifi_tether_configure_ssid_default" msgid="1709397571393179300">"AndroidHotspot"</string>
    <string name="wifi_add_app_single_network_title" msgid="8911612806204065225">"Enregistrer ce réseau?"</string>
    <string name="wifi_add_app_single_network_saving_summary" msgid="7366337245410388895">"Enregistrement en cours…"</string>
    <string name="wifi_add_app_single_network_saved_summary" msgid="7135016314713158289">"Enregistré"</string>
    <string name="wifi_add_app_network_save_failed_summary" msgid="7223817782309294652">"Enregistrement impossible. Réessayez."</string>
    <string name="wifi_add_app_networks_title" msgid="4384594865433042851">"Enregistrer les réseaux?"</string>
    <string name="wifi_add_app_networks_saving_summary" msgid="577680250954742033">"Enregistrement <xliff:g id="NUMBER">%d</xliff:g> de réseaux en cours…"</string>
    <string name="wifi_add_app_networks_saved_summary" msgid="1648417628665152905">"Réseaux enregistrés"</string>
    <string name="wifi_calling_settings_title" msgid="264665264535884440">"Appels Wi-Fi"</string>
    <string name="wifi_calling_suggestion_title" msgid="4791435106729906727">"Étendez la portée des appels avec le Wi-Fi"</string>
    <string name="wifi_calling_suggestion_summary" msgid="5413024679599742858">"Activez les appels Wi-Fi pour étendre la couverture"</string>
    <string name="wifi_calling_mode_title" msgid="5145896168360825619">"Préférences d\'appel"</string>
    <string name="wifi_calling_mode_dialog_title" msgid="944146521898592440">"Préférences d\'appel"</string>
    <string name="wifi_calling_roaming_mode_title" msgid="7703305991991520773">"Préférences d\'itinérance"</string>
    <!-- no translation found for wifi_calling_roaming_mode_summary (6061631305384464179) -->
    <skip />
    <string name="wifi_calling_roaming_mode_dialog_title" msgid="5382466713784067077">"Préférences d\'itinérance"</string>
  <string-array name="wifi_calling_mode_choices_v2">
    <item msgid="6052353275413974742">"Wi-Fi"</item>
    <item msgid="8622872038388687383">"Cellulaire"</item>
    <item msgid="3027927219952052398">"Wi-Fi seulement"</item>
  </string-array>
  <string-array name="wifi_calling_mode_choices_v2_without_wifi_only">
    <item msgid="588620799769664461">"Wi-Fi"</item>
    <item msgid="7566603075659706590">"Cellulaire"</item>
  </string-array>
    <string name="wifi_calling_mode_wifi_preferred_summary" msgid="3240387177966098351">"Si aucun réseau Wi‑Fi n\'est accessible, utiliser le réseau cellulaire"</string>
    <string name="wifi_calling_mode_cellular_preferred_summary" msgid="3746914244902314059">"Si le réseau cellulaire n\'est pas accessible, utiliser le Wi‑Fi"</string>
    <string name="wifi_calling_mode_wifi_only_summary" msgid="3155660680014892641">"Appeler sur réseau Wi‑Fi. Si le Wi‑Fi est interr., l\'appel prendra fin."</string>
    <string name="wifi_calling_off_explanation" msgid="6295526820826322895">"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="3487475808574416183"></string>
    <string name="emergency_address_title" msgid="8102786488994263815">"Adresse d\'urgence"</string>
    <string name="emergency_address_summary" msgid="3022628750270626473">"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="851221502063782306"><annotation id="url">"En savoir plus"</annotation>" sur la fonctionnalité de DNS privé"</string>
    <string name="private_dns_mode_on" msgid="8878679071975375696">"Activé"</string>
    <string name="wifi_calling_settings_activation_instructions" msgid="3936067355828542266">"Activer les appels Wi-Fi"</string>
    <string name="wifi_calling_turn_on" msgid="7687886259199428823">"Activer les appels Wi-Fi"</string>
    <string name="wifi_disconnected_from" msgid="5249576734324159708">"Déconnecté de <xliff:g id="SSID">%1$s</xliff:g>"</string>
    <string name="sound_settings" msgid="7622986039384531304">"Son et vibration"</string>
    <string name="account_settings" msgid="255404935489127404">"Comptes"</string>
    <string name="accessibility_category_work" msgid="5133894487353964944">"Comptes de profil professionnel - <xliff:g id="MANAGED_BY">%s</xliff:g>"</string>
    <string name="accessibility_category_personal" msgid="2228088849803484780">"Comptes de profil personnel"</string>
    <string name="accessibility_work_account_title" msgid="7622485151217943839">"Compte professionnel - <xliff:g id="MANAGED_BY">%s</xliff:g>"</string>
    <string name="accessibility_personal_account_title" msgid="8535265881509557013">"Compte personnel - <xliff:g id="MANAGED_BY">%s</xliff:g>"</string>
    <string name="search_settings" msgid="7573686516434589771">"Rechercher"</string>
    <string name="display_settings" msgid="7197750639709493852">"Affichage"</string>
    <string name="accelerometer_title" msgid="7745991950833748909">"Rotation automatique de l\'écran"</string>
    <string name="auto_rotate_option_off" msgid="2788096269396290731">"Désactivé"</string>
    <string name="auto_rotate_option_on" msgid="5776678230808498171">"Activé"</string>
    <string name="auto_rotate_option_face_based" msgid="3438645484087953174">"Activé : en fonction du visage"</string>
    <string name="auto_rotate_switch_face_based" msgid="9116123744601564320">"Détection des visages"</string>
    <string name="auto_rotate_link_a11y" msgid="5146188567212233286">"En savoir plus sur la rotation automatique"</string>
    <string name="auto_rotate_summary_a11y" msgid="1505094100328581685">"Lorsque vous basculez votre téléphone en mode portrait ou paysage"</string>
    <string name="screen_resolution_title" msgid="2690518693139811486">"Résolution de l\'écran"</string>
    <string name="screen_resolution_option_high" msgid="2617496842852992853">"Haute résolution"</string>
    <string name="screen_resolution_option_full" msgid="2694003735219114186">"Résolution intégrale"</string>
    <string name="screen_resolution_footer" msgid="6772341522952795647">"La résolution intégrale sollicite davantage votre pile. Le changement de résolution peut entraîner le redémarrage de certaines applications."</string>
    <string name="screen_resolution_selected_a11y" msgid="6158451180032224977">"Sélectionnée"</string>
    <string name="color_mode_title" msgid="8666690832113906028">"Couleurs"</string>
    <string name="color_mode_option_natural" msgid="6192875655101283303">"Naturelles"</string>
    <string name="color_mode_option_boosted" msgid="4698797857766774289">"Intenses"</string>
    <string name="color_mode_option_saturated" msgid="3413853820158447300">"Saturées"</string>
    <string name="color_mode_option_automatic" msgid="2281217686509980870">"Adaptatives"</string>
    <string name="brightness" msgid="6216871641021779698">"Niveau de luminosité"</string>
    <string name="auto_brightness_title" msgid="4239324728760986697">"Luminosité adaptative"</string>
    <string name="auto_brightness_description" msgid="6807117118142381193">"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="auto_brightness_summary_on" msgid="2748088951224387004">"Activé"</string>
    <string name="auto_brightness_summary_off" msgid="8077066192887677956">"Désactivée"</string>
    <string name="display_white_balance_title" msgid="2624544323029364713">"Afficher la balance des blancs"</string>
    <string name="display_white_balance_summary" msgid="7625456704950209050"></string>
    <string name="peak_refresh_rate_title" msgid="1878771412897140903">"Affichage fluide"</string>
    <string name="peak_refresh_rate_summary" msgid="3627278682437562787">"Augmente automatiquement la fréquence d\'actualisation de 60 Hz à <xliff:g id="ID_1">%1$s</xliff:g> Hz pour certains contenus. Augmente l\'utilisation de la pile."</string>
    <string name="force_high_refresh_rate_toggle" msgid="3325789621928312050">"Forcer la fréquence d\'actualisation de pointe"</string>
    <string name="force_high_refresh_rate_desc" msgid="7794566420873814875">"Taux d\'actualisation supérieur pour une amélioration de la réactivité tactile et de la fluidité des animations. Cette fonction sollicite davantage la pile de l\'appareil."</string>
    <string name="adaptive_sleep_title" msgid="2987961991423539233">"Écran attentif"</string>
    <string name="adaptive_sleep_title_no_permission" msgid="1719759921214237016">"L\'accès à l\'appareil photo est requis"</string>
    <string name="adaptive_sleep_summary_no_permission" msgid="5822591289468803691">"Vous devez autoriser l\'accès à l\'appareil photo pour utiliser l\'écran attentif. Touchez pour gérer les services de personnalisation de l\'appareil."</string>
    <string name="adaptive_sleep_manage_permission_button" msgid="1404510197847664846">"Gérer les autorisations"</string>
    <string name="adaptive_sleep_description" msgid="1835321775327187860">"Empêche l\'écran de s\'éteindre pendant que vous le regardez"</string>
    <string name="adaptive_sleep_privacy" msgid="7664570136417980556">"La fonctionnalité Écran attentif utilise l\'appareil photo avant pour détecter si quelqu\'un regarde l\'écran. Elle fonctionne sur l\'appareil, et les images ne sont jamais enregistrées ni envoyées à Google."</string>
    <string name="adaptive_sleep_contextual_slice_title" msgid="7467588613212629758">"Activer la fonctionnalité d\'écran attentif"</string>
    <string name="adaptive_sleep_contextual_slice_summary" msgid="2993867044745446094">"Empêchez l\'écran de s\'éteindre pendant que vous le regardez"</string>
    <string name="auto_rotate_camera_lock_title" msgid="5369003176695105872">"L\'appareil photo est verrouillé"</string>
    <string name="auto_rotate_camera_lock_summary" msgid="5699491516271544672">"L\'appareil photo doit être déverrouillé pour utiliser la détection des visages"</string>
    <string name="adaptive_sleep_camera_lock_summary" msgid="8417541183603618098">"L\'appareil photo doit être déverrouillé pour utiliser la fonctionnalité d\'écran attentif"</string>
    <string name="auto_rotate_summary_no_permission" msgid="1025061139746254554">"L\'accès à l\'appareil photo est nécessaire pour utiliser la détection des visages. Touchez pour gérer les services de personnalisation de l\'appareil"</string>
    <string name="auto_rotate_manage_permission_button" msgid="2591146085906382385">"Gérer les autorisations"</string>
    <string name="night_display_title" msgid="8532432776487216581">"Éclairage nocturne"</string>
    <string name="night_display_text" msgid="4789324042428095383">"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="5869128421470824381">"Horaire"</string>
    <string name="night_display_auto_mode_never" msgid="2721729920187175239">"Aucun"</string>
    <string name="night_display_auto_mode_custom" msgid="3938791496034086916">"S\'active à l\'heure de votre choix"</string>
    <string name="night_display_auto_mode_twilight" msgid="4291855156158833997">"Actif toute la nuit"</string>
    <string name="night_display_start_time_title" msgid="2611541851596977786">"Heure de début"</string>
    <string name="night_display_end_time_title" msgid="5243112480391192111">"Heure de fin"</string>
    <string name="night_display_temperature_title" msgid="857248782470764263">"Intensité"</string>
    <string name="night_display_summary_off_auto_mode_never" msgid="7406899634169354142">"Ne s\'activera jamais automatiquement"</string>
    <string name="night_display_summary_off_auto_mode_custom" msgid="6667008039080687931">"S\'activera automatiquement à <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="night_display_summary_off_auto_mode_twilight" msgid="3669132200611324994">"S\'activera automatiquement au coucher du soleil."</string>
    <string name="night_display_summary_on_auto_mode_never" msgid="832333009202889350">"Ne se désactivera jamais automatiquement"</string>
    <string name="night_display_summary_on_auto_mode_custom" msgid="2096677025343425755">"Se désactivera automatiquement à <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="night_display_summary_on_auto_mode_twilight" msgid="8070517472000680361">"Se désactivera automatiquement au lever du soleil"</string>
    <string name="night_display_not_currently_on" msgid="6600205753103093827">"Mode Écl. nocturne pas activé"</string>
    <string name="twilight_mode_location_off_dialog_message" msgid="4559150893687124801">"La position de l\'appareil est nécessaire pour déterminer les heures de coucher et de lever du soleil."</string>
    <string name="twilight_mode_launch_location" msgid="7799112373591153956">"Paramètres de localisation"</string>
    <string name="dark_ui_activation_on_manual" msgid="1541006734577325234">"Activer maintenant"</string>
    <string name="dark_ui_activation_off_manual" msgid="2395333709291250065">"Désactiver maintenant"</string>
    <string name="dark_ui_activation_on_auto" msgid="4824339634784765049">"Activer jusqu\'au lever du soleil"</string>
    <string name="dark_ui_activation_off_auto" msgid="9136717444658505208">"Désactiver jusqu\'au coucher du soleil"</string>
    <string name="dark_ui_title" msgid="3373976268671557416">"Mode sombre"</string>
    <string name="dark_ui_auto_mode_title" msgid="9027528859262295099">"Horaire"</string>
    <string name="dark_ui_auto_mode_never" msgid="3980412582267787662">"Aucun"</string>
    <string name="dark_ui_auto_mode_auto" msgid="6658909029498623375">"Actif toute la nuit"</string>
    <string name="dark_ui_auto_mode_custom" msgid="3800138185265182170">"S\'active à l\'heure de votre choix"</string>
    <string name="dark_ui_auto_mode_custom_bedtime" msgid="8465023741946439266">"S\'active à l\'heure du coucher"</string>
    <string name="dark_ui_status_title" msgid="3505119141437774329">"État"</string>
    <string name="dark_ui_summary_off_auto_mode_never" msgid="5828281549475697398">"Ne s\'activera jamais automatiquement"</string>
    <string name="dark_ui_summary_off_auto_mode_auto" msgid="6766831395970887213">"S\'activera automatiquement au coucher du soleil."</string>
    <string name="dark_ui_summary_off_auto_mode_custom" msgid="1345906088326708376">"S\'activera automatiquement à <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="dark_ui_summary_off_auto_mode_custom_bedtime" msgid="7759826673214624622">"S\'activera automatiquement à l\'heure du coucher"</string>
    <string name="dark_ui_summary_on_auto_mode_never" msgid="2468597062391435521">"Ne se désactivera jamais automatiquement"</string>
    <string name="dark_ui_summary_on_auto_mode_auto" msgid="5553376115092648636">"Se désactivera automatiquement au lever du soleil"</string>
    <string name="dark_ui_summary_on_auto_mode_custom" msgid="2526935680241734784">"Se désactivera automatiquement à <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="dark_ui_summary_on_auto_mode_custom_bedtime" msgid="1976993025762551246">"Se désactivera automatiquement après l\'heure du coucher"</string>
    <string name="dark_ui_text" msgid="4392646155331126666">"Le thème sombre utilise un arrière-plan noir pour aider à prolonger l\'autonomie de votre pile sur certains écrans. Les horaires du thème sombre attendent que votre écran soit éteint pour s\'activer."</string>
    <string name="dark_ui_bedtime_footer_summary" msgid="5576501833145170581">"L\'activation du thème sombre suit actuellement votre horaire de mode Nuit"</string>
    <string name="dark_ui_bedtime_footer_action" msgid="1493095487994054339">"Paramètres du mode Nuit"</string>
    <string name="screen_timeout" msgid="7709947617767439410">"Mise en veille de l\'écran"</string>
    <string name="screen_timeout_summary" msgid="5558778019594643427">"Après <xliff:g id="TIMEOUT_DESCRIPTION">%1$s</xliff:g> d\'inactivité"</string>
    <string name="screen_timeout_summary_not_set" msgid="5107680774964178875">"Non défini"</string>
    <string name="wallpaper_settings_title" msgid="5635129851136006383">"Fond d\'écran"</string>
    <string name="style_and_wallpaper_settings_title" msgid="2232042809407308946">"Fond d\'écran et style"</string>
    <string name="wallpaper_dashboard_summary" msgid="2324472863981057118">"Accueil, écran de verrouillage"</string>
    <string name="wallpaper_suggestion_title" msgid="3812842717939877330">"Changer le fond d\'écran"</string>
    <string name="wallpaper_suggestion_summary" msgid="9077061486716754784">"Personnalisez votre écran"</string>
    <string name="wallpaper_settings_fragment_title" msgid="8445963841717633149">"Sélectionner un fond d\'écran dans"</string>
    <string name="style_suggestion_title" msgid="1213747484782364775">"Personnaliser votre téléphone"</string>
    <string name="style_suggestion_summary" msgid="4271131877800968159">"Essayez différents styles, fonds d\'écran, etc."</string>
    <string name="screensaver_settings_title" msgid="3588535639672365395">"Écran de veille"</string>
    <string name="keywords_screensaver" msgid="7249337959432229172">"écran de veille"</string>
    <string name="screensaver_settings_when_to_dream_bedtime" msgid="3279310576803094771">"Cette fonctionnalité n\'est pas accessible parce que le mode Nuit est activé"</string>
    <string name="screensaver_settings_toggle_title" msgid="6194634226897244374">"Utiliser l\'écran de veille"</string>
    <string name="screensaver_settings_summary_either_long" msgid="371949139331896271">"Pendant la charge ou sur la station d\'accueil"</string>
    <string name="screensaver_settings_summary_dock_and_charging" msgid="8485905100159376156">"Durant la recharge sur la station"</string>
    <string name="screensaver_settings_summary_sleep" msgid="6555922932643037432">"Pendant la charge"</string>
    <string name="screensaver_settings_summary_dock" msgid="6997766385189369733">"Sur la station d\'accueil"</string>
    <string name="screensaver_settings_summary_never" msgid="4988141393040918450">"Jamais"</string>
    <string name="screensaver_settings_summary_on" msgid="4210827304351483645">"Activé : <xliff:g id="SCREEN_SAVER">%1$s</xliff:g>"</string>
    <string name="screensaver_settings_summary_off" msgid="8720357504939106923">"Désactivé"</string>
    <string name="screensaver_settings_when_to_dream" msgid="8145025742428940520">"Quand commencer"</string>
    <string name="lift_to_wake_title" msgid="8994218158737714046">"Soulever pour activer"</string>
    <string name="ambient_display_screen_title" msgid="8615947016991429325">"Affichage en mode Veille"</string>
    <string name="ambient_display_category_triggers" msgid="1216640141609270011">"Activation du mode Veille"</string>
    <string name="doze_title" msgid="1523090408230862316">"Réactiv. écran pour notifications"</string>
    <string name="doze_summary" msgid="8252867381522942804">"Lorsque l\'écran est sombre, il s\'allume en cas de nouvelles notifications"</string>
    <string name="doze_always_on_title" msgid="7326245192352868477">"Toujours affich. heure et données"</string>
    <string name="doze_always_on_summary" msgid="509097829739647852">"Utilisation accrue de la pile"</string>
    <string name="force_bold_text" msgid="4620929631102086716">"Mettre le texte en gras"</string>
    <string name="title_font_size" msgid="570613010306330622">"Taille de police"</string>
    <string name="short_summary_font_size" msgid="8444689613442419978">"Rendez le texte plus grand ou plus petit"</string>
    <string name="sim_lock_settings" msgid="7331982427303002613">"Paramètres de verrouillage de carte SIM"</string>
    <string name="sim_lock_settings_category" msgid="6475255139493877786">"Verrouillage de carte SIM"</string>
    <string name="sim_pin_toggle" msgid="6814489621760857328">"Verrouiller la carte SIM"</string>
    <string name="sim_pin_change" msgid="5978881209990507379">"Modifier le NIP de la carte SIM"</string>
    <string name="sim_enter_pin" msgid="8235202785516053253">"NIP de la carte SIM"</string>
    <string name="sim_enable_sim_lock" msgid="6486354334679225748">"Verrouiller la carte SIM"</string>
    <string name="sim_disable_sim_lock" msgid="6939439812841857306">"Déverrouiller la carte SIM"</string>
    <string name="sim_enter_old" msgid="6882545610939674813">"Ancien NIP de la carte SIM"</string>
    <string name="sim_enter_new" msgid="9010947802784561582">"Nouveau NIP de la carte SIM"</string>
    <string name="sim_reenter_new" msgid="6131418271490374263">"Confirmez le nouveau NIP"</string>
    <string name="sim_change_pin" msgid="1104103818545005448">"NIP de la carte SIM"</string>
    <string name="sim_invalid_pin_hint" msgid="3376397829969578877">"Entrez un NIP de quatre à huit chiffres"</string>
    <string name="sim_pins_dont_match" msgid="1540348773896609260">"Les NIP ne correspondent pas"</string>
    <string name="sim_change_succeeded" msgid="3516905528149069739">"Le NIP de la carte SIM a été modifié."</string>
    <string name="sim_pin_disable_failed" msgid="8719890393181032837">"Impossible de désactiver le NIP."</string>
    <string name="sim_pin_enable_failed" msgid="5156513975085380284">"Impossible d\'activer le NIP."</string>
    <string name="sim_enter_ok" msgid="3401715290135787531">"OK"</string>
    <string name="sim_enter_cancel" msgid="2001859323724961490">"Annuler"</string>
    <string name="sim_change_data_title" msgid="4663239438584588847">"Utiliser <xliff:g id="CARRIER">%1$s</xliff:g> pour les donn. cell.?"</string>
    <string name="sim_change_data_message" msgid="3046178883369645132">"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="4922114750417276560">"Utiliser le réseau de <xliff:g id="CARRIER">%1$s</xliff:g>"</string>
    <string name="sim_preferred_title" msgid="8850185380445309835">"Modifier la SIM préférée?"</string>
    <string name="sim_preferred_message" msgid="6004009449266648351">"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="enable_auto_data_switch_dialog_title" msgid="3563043560556718994">"Améliorer couv. données cell.?"</string>
    <string name="enable_auto_data_switch_dialog_message" msgid="5777287241521946883">"Autorisez votre téléphone à passer automatiquement à <xliff:g id="BACKUP_CARRIER">%1$s</xliff:g> pour les données cellulaires en cas de meilleure disponibilité."</string>
    <string name="auto_data_switch_dialog_managed_profile_warning" msgid="6839438290079866605">\n\n"Les appels, les messages et le trafic réseau peuvent être visibles pour votre organisation."</string>
    <string name="wrong_pin_code_pukked" msgid="3414172752791445033">"NIP de carte SIM incorrect. Vous devez maintenant communiquer avec votre fournisseur de services pour déverrouiller votre appareil."</string>
    <string name="wrong_pin_code" msgid="8124222991071607958">"{count,plural, =1{NIP de la carte SIM incorrect. Il vous reste # tentative. Après cela, vous devrez communiquer avec votre fournisseur de services pour déverrouiller votre appareil.}one{NIP de la carte SIM incorrect. Il vous reste # tentative.}other{NIP de la carte SIM incorrect. Il vous reste # tentatives.}}"</string>
    <string name="wrong_pin_code_one" msgid="6924852214263071441">"NIP de module SIM incorrect. Il vous reste une tentative. Après cela, vous devrez communiquer avec votre fournisseur de services pour déverrouiller votre appareil."</string>
    <string name="pin_failed" msgid="3726505565797352255">"Le déverrouillage par NIP de carte SIM a échoué."</string>
    <string name="system_update_settings_list_item_title" msgid="3398346836439366350">"Mises à jour du système"</string>
    <string name="system_update_settings_list_item_summary" msgid="6703752298349642101"></string>
    <string name="firmware_version" msgid="1606901586501447275">"Version d\'Android"</string>
    <string name="security_patch" msgid="4071756145347865382">"Mise à jour de sécurité Android"</string>
    <string name="model_info" msgid="8997566254717810904">"Modèle"</string>
    <string name="hardware_revision" msgid="3454709180861965025">"Version du matériel"</string>
    <string name="fcc_equipment_id" msgid="6596668314025646129">"Equipment ID"</string>
    <string name="baseband_version" msgid="2600182227599835857">"Version de bande de base"</string>
    <string name="kernel_version" msgid="3513538109381366881">"Version du noyau"</string>
    <string name="build_number" msgid="9009733242117579826">"Numéro de version"</string>
    <string name="module_version" msgid="1787518340082046658">"Mise à jour du système Google Play"</string>
    <string name="device_info_not_available" msgid="4804474466616712326">"Non disponible"</string>
    <string name="storage_settings" msgid="7472188817781592677">"Stockage"</string>
    <string name="storage_settings_for_app" msgid="229425418984637483">"Stockage et mise en cache"</string>
    <string name="storage_settings_title" msgid="486118156723194815">"Paramètres de stockage"</string>
    <string name="status_eid" msgid="7532406028683438634">"EID"</string>
    <string name="eid_multi_sim" msgid="9087924808336397804">"EID (fente pour carte SIM <xliff:g id="EID_SLOT_ID">%1$d</xliff:g>)"</string>
    <string name="imei_multi_sim" msgid="9001570420423929507">"IIEM (fente SIM <xliff:g id="IMEI_SLOT_ID">%1$d</xliff:g>)"</string>
    <string name="imei_multi_sim_primary" msgid="7914653040843734282">"IIEM (fente SIM <xliff:g id="IMEI_SLOT_ID_PRIMARY">%1$d</xliff:g>) (principale)"</string>
    <string name="view_saved_network" msgid="1232387673095080910">"Pour l\'afficher, sélectionnez un réseau enregistré"</string>
    <string name="status_min_number" msgid="4492899165438225714">"MIN"</string>
    <string name="status_msid_number" msgid="3871958248824595774">"MSID"</string>
    <string name="status_prl_version" msgid="9002131357502714281">"Version de la liste d\'itinérance préférée"</string>
    <string name="meid_multi_sim" msgid="1460689549266621286">"IDEM (fente SIM <xliff:g id="MEID_SLOT_ID">%1$d</xliff:g>)"</string>
    <string name="meid_multi_sim_primary" msgid="8921262417580407201">"IDEM (fente SIM <xliff:g id="MEID_SLOT_ID_PRIMARY">%1$d</xliff:g>) (principale)"</string>
    <string name="scanning_status_text_on" msgid="3846571210578042940">"Activé"</string>
    <string name="scanning_status_text_off" msgid="4002352668313705132">"Désactivé"</string>
    <string name="status_meid_number" msgid="6040380838489162650">"MEID"</string>
    <string name="status_icc_id" msgid="7995690631650006970">"ICCID"</string>
    <string name="status_data_network_type" msgid="3689772955330665876">"Type de réseau de données cellulaires"</string>
    <string name="status_voice_network_type" msgid="8700356693062562884">"Type de réseau vocal cellulaire"</string>
    <string name="status_latest_area_info" msgid="8288488664620741734">"Informations sur l\'opérateur"</string>
    <string name="status_data_state" msgid="525196229491743487">"État du réseau mobile"</string>
    <string name="status_esim_id" msgid="5158916796362809133">"EID"</string>
    <string name="status_service_state" msgid="1693424422121058791">"État du service"</string>
    <string name="status_signal_strength" msgid="7644525712554444359">"Intensité du signal"</string>
    <string name="status_roaming" msgid="1253597174715663778">"Itinérance"</string>
    <string name="status_operator" msgid="4335640583552058491">"Réseau"</string>
    <string name="status_wifi_mac_address" msgid="4447611754614388914">"Adresse MAC Wi-Fi"</string>
    <string name="status_device_wifi_mac_address" msgid="1896121694334176494">"Adresse MAC Wi‑Fi de l\'appareil"</string>
    <string name="status_bt_address" msgid="6919660304578476547">"Adresse Bluetooth"</string>
    <string name="status_serial_number" msgid="9060064164331466789">"Numéro de série"</string>
    <string name="status_up_time" msgid="1274778533719495438">"Durée d\'activité"</string>
    <string name="memory_calculating_size" msgid="3898240439798661242">"Calcul en cours"</string>
    <string name="storage_menu_rename" msgid="8549835371429159336">"Renommer"</string>
    <string name="storage_menu_mount" msgid="4760531872302820569">"Monter"</string>
    <string name="storage_menu_unmount" msgid="8171552487742912282">"Éjecter"</string>
    <string name="storage_menu_format" msgid="8903698999905354146">"Formater la carte SD en tant que mémoire externe"</string>
    <string name="storage_menu_format_button" msgid="7623565190643699626">"Formater la carte"</string>
    <string name="storage_menu_format_public" msgid="5567214442727034630">"Formater comme mémoire externe"</string>
    <string name="storage_menu_format_option" msgid="4886059624052908432">"Formater"</string>
    <string name="storage_menu_migrate" msgid="2196088149560070193">"Transférer les données"</string>
    <string name="storage_menu_forget" msgid="5154017890033638936">"Supprimer"</string>
    <string name="storage_menu_set_up" msgid="4401074025612064744">"Configurer"</string>
    <string name="storage_menu_free" msgid="616100170298501673">"Libérer de l\'espace"</string>
    <string name="storage_menu_manage" msgid="7465522758801346408">"Gérer l\'espace de stockage"</string>
    <string name="storage_free_up_space_title" msgid="281047807372131975">"Libérer de l\'espace"</string>
    <string name="storage_free_up_space_summary" msgid="6650027929735481350">"Accédez à l\'application Fichiers pour gérer l\'espace et en libérer"</string>
    <string name="storage_other_users" msgid="7017206190449510992">"Autres utilisateurs"</string>
    <string name="storage_size_large" msgid="1155308277890194878">"<xliff:g id="NUMBER">^1</xliff:g>"<small><small>" <xliff:g id="UNIT">^2</xliff:g>"</small></small>""</string>
    <string name="storage_mount_success" msgid="393972242641313135">"<xliff:g id="NAME">%1$s</xliff:g> est monté"</string>
    <string name="storage_mount_failure" msgid="3667915814876418011">"Impossible de monter <xliff:g id="NAME">%1$s</xliff:g>"</string>
    <string name="storage_unmount_success" msgid="6406298575402936148">"<xliff:g id="NAME">%1$s</xliff:g> a été éjecté en toute sécurité"</string>
    <string name="storage_unmount_failure" msgid="3796912279003790607">"Impossible d\'éjecter <xliff:g id="NAME">%1$s</xliff:g> en toute sécurité"</string>
    <string name="storage_rename_title" msgid="5911285992205282312">"Renommer le stockage"</string>
    <string name="storage_dialog_unmountable" msgid="1761107904296941687">"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_internal_format_details" msgid="2399034372813686846">"Vous pouvez formater cette carte SD pour y stocker des photos, des vidéos, de la musique et plus encore. Vous pouvez aussi y accéder à partir d\'autres appareils. \n\n"<b>"Toutes les données de cette carte SD seront supprimées."</b>" \n\n"<b>"Avant le formatage"</b>" \n\n"<b>"Sauvegardez les photos et les autres contenus multimédias"</b>" \nDéplacez vos fichiers multimédias vers un autre support de stockage sur cet appareil, ou transférez-les sur un ordinateur au moyen d\'un câble USB. \n\n"<b>"Sauvegardez vos applications"</b>" \nToutes les applications stockées sur cette <xliff:g id="NAME">^1</xliff:g> seront désinstallées, et leurs données seront supprimées. Pour conserver ces applications, déplacez-les vers un autre support de stockage sur cet appareil."</string>
    <string name="storage_internal_unmount_details" msgid="487689543322907311"><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="5606507270046186691">"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="379238668153099015">"Oublier « <xliff:g id="NAME">^1</xliff:g> »?"</string>
    <string name="storage_internal_forget_confirm" msgid="5752634604952674123">"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_dialog_system" msgid="7461009051858709479">"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_wizard_guest" msgid="5813419895687733649">"En mode Invité, on ne peut formater de cartes SD"</string>
    <string name="storage_wizard_format_progress_title" msgid="9170393018855949774">"Formatage de « <xliff:g id="NAME">^1</xliff:g> » en cours..."</string>
    <string name="storage_wizard_format_progress_body" msgid="1044024044955390417">"Ne retirez pas <xliff:g id="NAME">^1</xliff:g> durant le formatage."</string>
    <string name="storage_wizard_ready_title" msgid="3631022511474086605">"<xliff:g id="NAME">^1</xliff:g> formatée"</string>
    <string name="storage_wizard_move_confirm_title" msgid="6812469630804101590">"Déplacer <xliff:g id="APP">^1</xliff:g>"</string>
    <string name="storage_wizard_move_confirm_body" msgid="1713022828842263574">"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="14651384927767749">"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="3912406225614672391">"Déplacement de <xliff:g id="APP">^1</xliff:g> en cours..."</string>
    <string name="storage_wizard_move_progress_body" msgid="2396714553394935094">"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_init_v2_title" msgid="2538630338392381113">"Comment utiliserez-vous ce périphérique <xliff:g id="NAME">^1</xliff:g>?"</string>
    <string name="storage_wizard_init_v2_or" msgid="5558706089661158026">"ou"</string>
    <string name="storage_wizard_init_v2_external_title" msgid="2786416384217054112">"Formater la carte SD en tant que mémoire externe"</string>
    <string name="storage_wizard_init_v2_external_summary" msgid="2002761631147966185">"Stockez vos photos, vos vidéos, votre musique et plus encore, et accédez-y à partir d\'autres appareils. &lt;a href=https://support.google.com/android/answer/12153449&gt;En savoir plus sur la configuration d\'une carte SD&lt;/a&gt;."</string>
    <string name="storage_wizard_init_v2_external_action" msgid="6140058734875839081">"Formater"</string>
    <string name="storage_wizard_init_v2_later" msgid="5366815913892609285">"Configurer plus tard"</string>
    <string name="storage_wizard_format_confirm_v2_title" msgid="6294104100437326067">"Formater cette <xliff:g id="NAME">^1</xliff:g>?"</string>
    <string name="storage_wizard_format_confirm_v2_body" msgid="635958708974709506">"Cette <xliff:g id="NAME_0">^1</xliff:g> doit être formatée pour stocker des applications et des fichiers. \n\nLe formatage effacera le contenu existant de la <xliff:g id="NAME_1">^2</xliff:g>. Pour éviter de perdre votre contenu, sauvegardez-le sur une autre <xliff:g id="NAME_2">^3</xliff:g> ou un autre appareil."</string>
    <string name="storage_wizard_format_confirm_v2_body_external" msgid="5810296966099830035">"Vous devez formater cette <xliff:g id="NAME_0">^1</xliff:g> pour pouvoir y stocker des photos, des vidéos, de la musique, et plus encore. \n\nLe formatage supprimera le contenu existant de la <xliff:g id="NAME_1">^2</xliff:g>. Pour éviter de perdre votre contenu, sauvegardez-le sur une autre <xliff:g id="NAME_2">^3</xliff:g> ou un autre appareil."</string>
    <string name="storage_wizard_format_confirm_v2_action" msgid="5718254101386377126">"Formater <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_migrate_v2_title" msgid="3471564531564756698">"Déplacer le contenu vers <xliff:g id="NAME">^1</xliff:g>?"</string>
    <string name="storage_wizard_migrate_v2_checklist" msgid="2618258869444553060">"Pendant le déplacement :"</string>
    <string name="storage_wizard_migrate_v2_checklist_media" msgid="5867134681730723744">"Ne retirez pas le périphérique <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_migrate_v2_checklist_apps" msgid="1882077445750580783">"Certaines applications ne fonctionneront pas"</string>
    <string name="storage_wizard_migrate_v2_now" msgid="3341460117088026966">"Déplacer le contenu"</string>
    <string name="storage_wizard_migrate_v2_later" msgid="6067756122853315642">"Déplacer le contenu plus tard"</string>
    <string name="storage_wizard_migrate_progress_v2_title" msgid="8791318509516968103">"Déplacement du contenu en cours…"</string>
    <string name="storage_wizard_slow_v2_title" msgid="3760766921170980221">"Périphérique <xliff:g id="NAME">^1</xliff:g> lent"</string>
    <string name="storage_wizard_slow_v2_body" msgid="7604252106419016929">"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="1806852287668077536">"Recommencer"</string>
    <string name="storage_wizard_slow_v2_continue" msgid="7469713755893007901">"Continuer"</string>
    <string name="storage_wizard_ready_v2_external_body" msgid="7688457485389886923">"Vous pouvez commencer à utiliser votre <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_ready_v2_internal_body" msgid="3520269956641115883">"Vous pouvez commencer à utiliser votre <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_ready_v2_internal_moved_body" msgid="1163588718127651062">"Vous pouvez commencer à utiliser votre <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="battery_status_title" msgid="4661768220545945771">"État de la batterie"</string>
    <string name="battery_level_title" msgid="1371765298786083448">"Niveau de la pile"</string>
    <string name="communal_settings_title" msgid="2845678473945902115">"Commun"</string>
    <string name="communal_settings_summary" msgid="4923914136953940317">"Paramètres communs"</string>
    <string name="apn_settings" msgid="4295467389400441299">"Noms des points d\'accès"</string>
    <string name="apn_edit" msgid="2003683641840248741">"Modifier le point d\'accès"</string>
    <string name="apn_not_set" msgid="8246646433109750293">"Non défini"</string>
    <string name="apn_not_set_for_mvno" msgid="1141490067313964640">"Non configuré"</string>
    <string name="apn_name" msgid="6677695784108157953">"Nom"</string>
    <string name="apn_apn" msgid="5812828833797458602">"Nom du point d\'accès"</string>
    <string name="apn_http_proxy" msgid="1052464912365838007">"Serveur mandataire"</string>
    <string name="apn_http_port" msgid="9138610639873966046">"Port"</string>
    <string name="apn_user" msgid="5831763936428279228">"Nom d\'utilisateur"</string>
    <string name="apn_password" msgid="7435086635953953029">"Mot de passe"</string>
    <string name="apn_server" msgid="6997704279138388384">"Serveur"</string>
    <string name="apn_mmsc" msgid="4985570919581927224">"MMSC"</string>
    <string name="apn_mms_proxy" msgid="6592247653258283592">"Serveur mandataire MMS"</string>
    <string name="apn_mms_port" msgid="6500563737462966663">"Port MMS"</string>
    <string name="apn_mcc" msgid="4971414138516074809">"MCC"</string>
    <string name="apn_mnc" msgid="1926382406843447854">"MNC"</string>
    <string name="apn_auth_type" msgid="4234397513494356932">"Type d\'authentification"</string>
    <string name="apn_type" msgid="1835573305077788773">"Type d\'APN"</string>
    <string name="apn_protocol" msgid="181529867160380010">"Protocole de l\'APN"</string>
    <string name="apn_roaming_protocol" msgid="1645131094105362513">"Protocole APN en itinérance"</string>
    <string name="carrier_enabled" msgid="664074151573150130">"Activer/Désactiver l\'APN"</string>
    <string name="carrier_enabled_summaryOn" msgid="5212067975273903381">"APN activé"</string>
    <string name="carrier_enabled_summaryOff" msgid="8541959867953738521">"APN désactivé"</string>
    <string name="bearer" msgid="3231443241639159358">"Réseau"</string>
    <string name="mvno_type" msgid="4734654257494971247">"Type MVNO"</string>
    <string name="mvno_match_data" msgid="5213193073684321156">"Valeur MVNO"</string>
    <string name="menu_delete" msgid="9199740901584348273">"Supprimer l\'APN"</string>
    <string name="menu_new" msgid="6571230342655509006">"Nouveau nom point d\'accès"</string>
    <string name="menu_save" msgid="6611465355127483100">"Enregistrer"</string>
    <string name="menu_cancel" msgid="1197826697950745335">"Annuler"</string>
    <string name="error_title" msgid="7158648377702417716"></string>
    <string name="error_name_empty" msgid="1258275899283079142">"Le champ « Nom » est obligatoire."</string>
    <string name="error_apn_empty" msgid="7657491065443746915">"L\'APN est obligatoire."</string>
    <string name="error_mcc_not3" msgid="883659545640179094">"Le champ MCC doit contenir 3 chiffres."</string>
    <string name="error_mnc_not23" msgid="7642478711158474918">"Le champ MNC doit contenir 2 ou 3 chiffres."</string>
    <string name="error_adding_apn_type" msgid="1324263534991467943">"Le fournisseur de services n\'autorise pas l\'ajout de points d\'accès de type %s."</string>
    <string name="restore_default_apn" msgid="6596048535642130689">"Restauration des paramètres APN par défaut en cours..."</string>
    <string name="menu_restore" msgid="4310539620115151551">"Rétablir les valeurs par défaut"</string>
    <string name="restore_default_apn_completed" msgid="5167505087078340256">"La réinitialisation des paramètres APN par défaut est terminée."</string>
    <string name="reset_dashboard_title" msgid="7423200250697886918">"Options de réinitialisation"</string>
    <string name="reset_mobile_network_settings_title" msgid="5616713931258506842">"Réinitialiser les paramètres du réseau cellulaire"</string>
    <string name="reset_mobile_network_settings_desc" msgid="7292636387692165727">"Les paramètres du réseau cellulaire seront réinitialisés"</string>
    <string name="reset_mobile_network_settings_confirm_title" msgid="7510965634669511241">"Réinit. param. réseau. cell.?"</string>
    <string name="reset_bluetooth_wifi_title" msgid="4113071322344697317">"Réinitialiser le Bluetooth et le Wi-Fi"</string>
    <string name="reset_bluetooth_wifi_desc" msgid="4030295669083059711">"Tous les paramètres Wi-Fi et Bluetooth seront réinitialisés. Vous ne pouvez pas annuler cette action."</string>
    <string name="reset_bluetooth_wifi_button_text" msgid="3974098137045963639">"Réinitialiser"</string>
    <string name="reset_bluetooth_wifi_complete_toast" msgid="5893439291030574365">"Le Bluetooth et le Wi-Fi ont été réinitialisés"</string>
    <string name="erase_euicc_data_button" msgid="728078969563311737">"Effacer"</string>
    <string name="reset_esim_title" msgid="4194570573425902754">"Effacer les cartes eSIM"</string>
    <string name="reset_esim_desc" msgid="3662444090563399131">"Cela n\'annulera aucun forfait de services cellulaires. Pour télécharger une carte SIM de remplacement, communiquez avec votre fournisseur de services."</string>
    <string name="reset_network_button_text" msgid="2281476496459610071">"Réinitialiser les paramètres"</string>
    <string name="reset_network_final_desc" msgid="5304365082065278425">"Réinitialiser tous les paramètres réseau? Cette action est irréversible."</string>
    <string name="reset_network_final_desc_esim" msgid="1129251284212847939">"Réinitialiser tous les paramètres du réseau et effacer les cartes eSIM? Vous ne pouvez pas annuler cette action."</string>
    <string name="reset_network_final_button_text" msgid="2433867118414000462">"Réinitialiser les paramètres"</string>
    <string name="reset_network_confirm_title" msgid="913014422184481270">"Réinitialiser?"</string>
    <string name="network_reset_not_available" msgid="1966334631394607829">"La réinitialisation du réseau n\'est pas disponible pour cet utilisateur."</string>
    <string name="reset_network_complete_toast" msgid="1367872474130621115">"Les paramètres réseau ont été réinitialisés"</string>
    <string name="reset_esim_error_title" msgid="4670073610967959597">"Impossible d\'effacer les cartes SIM"</string>
    <string name="reset_esim_error_msg" msgid="7279607120606365250">"Les cartes eSIM ne peuvent pas être effacées à cause d\'une erreur.\n\nRedémarrez votre appareil et réessayez."</string>
    <string name="main_clear_title" msgid="277664302144837723">"Effacer toutes les données (réinitialisation des paramètres par défaut)"</string>
    <string name="main_clear_short_title" msgid="4752094765533020696">"Effacer toutes les données"</string>
    <string name="main_clear_desc_also_erases_external" msgid="3687911419628956693"><li>"Musique"</li>\n<li>"Photos"</li>\n<li>"Autres données de l\'utilisateur"</li></string>
    <string name="main_clear_desc_also_erases_esim" msgid="4553469876411831729"><li>"Modules eSIM"</li></string>
    <string name="main_clear_desc_no_cancel_mobile_plan" msgid="369883568059127035">\n\n"Cela n\'annulera pas votre forfait de services cellulaires."</string>
    <string name="main_clear_final_desc" msgid="5800877928569039580">"Tous vos renseignements personnels et les applications téléchargées seront supprimés. Vous ne pouvez pas annuler cette action."</string>
    <string name="main_clear_final_desc_esim" msgid="440406836793824969">"Tous vos renseignements personnels, y compris les applications téléchargées et les modules SIM, seront supprimés. Vous ne pouvez pas annuler cette action."</string>
    <string name="main_clear_confirm_title" msgid="6577071819657853713">"Effacer toutes les données?"</string>
    <string name="main_clear_not_available" msgid="3433795327146684827">"La réinitialisation aux paramètres par défaut n\'est pas possible pour cet utilisateur"</string>
    <string name="main_clear_progress_title" msgid="7239741132015617719">"Suppression en cours…"</string>
    <string name="main_clear_progress_text" msgid="4636695115176327972">"Veuillez patienter…"</string>
    <string name="call_settings_title" msgid="2531072044177194164">"Paramètres d\'appel"</string>
    <string name="call_settings_summary" msgid="8244293779053318053">"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="5926474044238409099">"Partage de connexion par USB"</string>
    <string name="tether_settings_title_wifi" msgid="4327056146425282159">"Point d\'accès Wi-Fi mobile"</string>
    <string name="tether_settings_title_bluetooth" msgid="8878813702520141084">"Partage connexion Bluetooth"</string>
    <string name="tether_settings_title_usb_bluetooth" msgid="4437274151658505496">"Partage de connexion"</string>
    <string name="tether_settings_title_all" msgid="6807525590937697228">"Point d\'accès sans fil et partage de connexion"</string>
    <string name="tether_settings_summary_hotspot_on_tether_on" msgid="6110241048260139633">"Point d\'accès activé, partage de connexion"</string>
    <string name="tether_settings_summary_hotspot_on_tether_off" msgid="5057598961245943644">"Point d\'accès activé"</string>
    <string name="tether_settings_summary_hotspot_off_tether_on" msgid="7181518138494995888">"Partage de connexion"</string>
    <string name="tether_settings_disabled_on_data_saver" msgid="9054069463426952689">"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="tether_settings_summary_hotspot_only" msgid="8529008147731140279">"Point d\'accès sans fil uniquement"</string>
    <string name="tether_settings_summary_usb_tethering_only" msgid="6351624505239356221">"USB uniquement"</string>
    <string name="tether_settings_summary_bluetooth_tethering_only" msgid="1451008625343274930">"Bluetooth uniquement"</string>
    <string name="tether_settings_summary_ethernet_tethering_only" msgid="3582266687537419309">"Ethernet seulement"</string>
    <string name="tether_settings_summary_hotspot_and_usb" msgid="5999349643653265016">"Point d\'accès sans fil, USB"</string>
    <string name="tether_settings_summary_hotspot_and_bluetooth" msgid="810514646401708557">"Point d\'accès sans fil, Bluetooth"</string>
    <string name="tether_settings_summary_hotspot_and_ethernet" msgid="5489192670354277152">"Partage de connexion, Ethernet"</string>
    <string name="tether_settings_summary_usb_and_bluetooth" msgid="1355680331767261967">"USB, Bluetooth"</string>
    <string name="tether_settings_summary_usb_and_ethernet" msgid="2195017679820919905">"USB, Ethernet"</string>
    <string name="tether_settings_summary_bluetooth_and_ethernet" msgid="1015253926959211012">"Bluetooth, Ethernet"</string>
    <string name="tether_settings_summary_hotspot_and_usb_and_bluetooth" msgid="2949043525073791732">"Point d\'accès sans fil, USB, Bluetooth"</string>
    <string name="tether_settings_summary_hotspot_and_usb_and_ethernet" msgid="5178946567323581144">"Partage de connexion, USB, Ethernet"</string>
    <string name="tether_settings_summary_hotspot_and_bluetooth_and_ethernet" msgid="4104425838594994441">"Partage de connexion, Bluetooth, Ethernet"</string>
    <string name="tether_settings_summary_usb_and_bluetooth_and_ethernet" msgid="5880591133984166550">"USB, Bluetooth, Ethernet"</string>
    <string name="tether_settings_summary_all" msgid="7565193614882005775">"Partage de connexion, USB, Bluetooth, Ethernet"</string>
    <string name="tether_settings_summary_off" msgid="2526164899130351968">"Connexion Internet non partagée avec d\'autres appareils"</string>
    <string name="tether_preference_summary_off" msgid="6266799346319794630">"Désactivé"</string>
    <string name="tethering_interface_options" msgid="7575535888135143650">"Partage de connexion"</string>
    <string name="disable_wifi_hotspot_title" msgid="2167985468585290478">"Ne pas utiliser les points d\'accès Wi‑Fi"</string>
    <string name="disable_wifi_hotspot_when_usb_on" msgid="220439059794714583">"Uniquement partager la connexion Internet par USB"</string>
    <string name="disable_wifi_hotspot_when_bluetooth_on" msgid="4711723299880116345">"Uniquement partager la connexion Internet par Bluetooth"</string>
    <string name="disable_wifi_hotspot_when_ethernet_on" msgid="4123242400542103599">"Uniquement partager la connexion Internet par Ethernet"</string>
    <string name="disable_wifi_hotspot_when_usb_and_bluetooth_on" msgid="5258774769658150180">"Uniquement partager la connexion Internet par USB et par Bluetooth"</string>
    <string name="disable_wifi_hotspot_when_usb_and_ethernet_on" msgid="7126313562907225612">"Uniquement partager la connexion Internet par USB et par Ethernet"</string>
    <string name="disable_wifi_hotspot_when_bluetooth_and_ethernet_on" msgid="2943464651349235967">"Uniquement partager la connexion Internet par Bluetooth et par Ethernet"</string>
    <string name="disable_wifi_hotspot_when_usb_and_bluetooth_and_ethernet_on" msgid="3934609816834760008">"Uniquement partager la connexion Internet par USB, par Bluetooth et par Ethernet"</string>
    <string name="usb_title" msgid="1157283449840612901">"USB"</string>
    <string name="usb_tethering_button_text" msgid="7364633823180913777">"Partage de connexion par USB"</string>
    <string name="bluetooth_tether_checkbox_text" msgid="6108398414967813545">"Partage de connexion par Bluetooth"</string>
    <string name="ethernet_tether_checkbox_text" msgid="959743110824197356">"Partage connexion Ethernet"</string>
    <string name="tethering_footer_info" msgid="6782375845587483281">"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_footer_info_sta_ap_concurrency" msgid="2079039077487477676">"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 de données Wi-Fi ou 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="2823655011510912001">"Aide"</string>
    <string name="network_settings_title" msgid="4663717899931613176">"Réseau cellulaire"</string>
    <string name="manage_mobile_plan_title" msgid="5616930513733409064">"Forfait de données cellulaires"</string>
    <string name="sms_application_title" msgid="4791107002724108809">"Application de messagerie texte"</string>
    <string name="sms_change_default_dialog_title" msgid="2343439998715457307">"Modifier l\'application de messagerie texte?"</string>
    <string name="sms_change_default_dialog_text" msgid="8777606240342982531">"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="6215622785087181275">"Utiliser <xliff:g id="NEW_APP">%s</xliff:g> comme application de messagerie texte?"</string>
    <string name="network_scorer_change_active_dialog_title" msgid="7005220310238618141">"Changer d\'assistant Wi‑Fi?"</string>
    <string name="network_scorer_change_active_dialog_text" msgid="7006057749370850706">"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="680685773455072321">"Utiliser <xliff:g id="NEW_APP">%s</xliff:g> pour gérer vos connexions réseau?"</string>
    <string name="mobile_unknown_sim_operator" msgid="6650422533065760963">"Fournisseur de la carte SIM inconnu"</string>
    <string name="mobile_no_provisioning_url" msgid="609462719893503773">"Aucun site Web de configuration connu pour <xliff:g id="OPERATOR">%1$s</xliff:g>"</string>
    <string name="mobile_insert_sim_card" msgid="3639245241283948038">"Insérez la carte SIM, puis redémarrez."</string>
    <string name="mobile_connect_to_internet" msgid="8162654404357069060">"Connectez-vous à Internet."</string>
    <string name="location_category_recent_location_requests" msgid="2205900488782832082">"Demandes de localisation récentes"</string>
    <string name="managed_profile_location_switch_title" msgid="1265007506385460066">"Position pour profil profess."</string>
    <string name="location_app_level_permissions" msgid="907206607664629759">"Autor. localisation de l\'appli"</string>
    <string name="location_app_permission_summary_location_off" msgid="2711822936853500335">"Le signalement de position est désactivé"</string>
    <string name="location_app_permission_summary_location_on" msgid="7552095451731948984">"{count,plural, =1{# application sur {total} a accès à la position}one{# application sur {total} a accès à la position}other{# applications sur {total} ont accès à la position}}"</string>
    <string name="location_category_recent_location_access" msgid="2558063524482178146">"Accès récents"</string>
    <string name="location_recent_location_access_see_all" msgid="4203102419355323325">"Tout afficher"</string>
    <string name="location_recent_location_access_view_details" msgid="5803264082558504544">"Afficher les détails"</string>
    <string name="location_no_recent_apps" msgid="6814206631456177033">"Aucune application n\'a récemment demandé l\'accès à votre position"</string>
    <string name="location_no_recent_accesses" msgid="6031735777805464247">"Aucune application n\'a récemment accédé à la position"</string>
    <string name="location_high_battery_use" msgid="4277318891200626524">"Forte utilisation de la pile"</string>
    <string name="location_low_battery_use" msgid="5218950289737996431">"Faible utilisation de la pile"</string>
    <string name="location_scanning_wifi_always_scanning_title" msgid="5004781272733434794">"Recherche de réseaux Wi-Fi"</string>
    <string name="location_scanning_wifi_always_scanning_description" msgid="6236055656376931306">"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="1809309545730215891">"Recherche d\'appareils Bluetooth"</string>
    <string name="location_scanning_bluetooth_always_scanning_description" msgid="5362988856388462841">"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="location_services_preference_title" msgid="604317859531782159">"Services de localisation"</string>
    <string name="location_services_screen_title" msgid="5640002489976602476">"Services de localisation"</string>
    <string name="location_time_zone_detection_toggle_title" msgid="6478751613645015287">"Utiliser ma position"</string>
    <string name="location_time_zone_detection_status_title" msgid="8903495354385600423">"Impossible de définir automati. le fuseau horaire"</string>
    <string name="location_time_zone_detection_status_summary_degraded_by_settings" msgid="6198939835335841106"></string>
    <string name="location_time_zone_detection_status_summary_blocked_by_settings" msgid="5276280770344278768">"La position ou les services de localisation sont désactivés"</string>
    <string name="location_time_zone_detection_status_summary_blocked_by_environment" msgid="2279833212923765802"></string>
    <string name="location_time_zone_detection_status_summary_temporarily_unavailable" msgid="6586801403644278967"></string>
    <string name="location_time_zone_detection_location_is_off_dialog_title" msgid="231698690198001146">"La position de l\'appareil est nécessaire"</string>
    <string name="location_time_zone_detection_location_is_off_dialog_message" msgid="5846316326139169523">"Pour définir le fuseau horaire à l\'aide de votre position, activez la localisation et mettez à jour les paramètres de fuseau horaire"</string>
    <string name="location_time_zone_detection_location_is_off_dialog_ok_button" msgid="2685647335717750297">"Paramètres de localisation"</string>
    <string name="location_time_zone_provider_fix_dialog_ok_button" msgid="9026666001835079126">"Corriger ce problème"</string>
    <string name="location_time_zone_detection_location_is_off_dialog_cancel_button" msgid="3968729678789071154">"Annuler"</string>
    <string name="location_time_zone_detection_auto_is_off" msgid="6264253990141650280">"La détection automatique du fuseau horaire est désactivée"</string>
    <string name="location_time_zone_detection_not_applicable" msgid="6757964612836952714">"La détection du fuseau horaire basée sur la position est désactivée"</string>
    <string name="location_time_zone_detection_not_supported" msgid="3251181656388306501">"La détection du fuseau horaire basée sur la position n\'est pas prise en charge"</string>
    <string name="location_time_zone_detection_not_allowed" msgid="8264525161514617051">"Les modifications de la détection du fuseau horaire basée sur la position ne sont pas autorisées"</string>
    <string name="location_time_zone_detection_auto_is_on" msgid="8797434659844659323">"La position peut être utilisée pour définir le fuseau horaire"</string>
    <string name="about_settings_summary" msgid="4831942939227432513">"Informations légales, état et version du logiciel"</string>
    <string name="legal_information" msgid="7509900979811934843">"Renseignements juridiques"</string>
    <string name="manual" msgid="3651593989906084868">"Manuel"</string>
    <string name="regulatory_labels" msgid="5960251403367154270">"Étiquettes réglementaires"</string>
    <string name="safety_and_regulatory_info" msgid="8285048080439298528">"Guide relatif à la sécurité et à la réglementation"</string>
    <string name="copyright_title" msgid="83245306827757857">"Droits d\'auteur"</string>
    <string name="license_title" msgid="8745742085916617540">"Licence"</string>
    <string name="module_license_title" msgid="8705484239826702828">"Licences des mises à jour système pour Google Play"</string>
    <string name="terms_title" msgid="2071742973672326073">"Conditions d\'utilisation"</string>
    <string name="webview_license_title" msgid="5832692241345780517">"Licence WebView du système"</string>
    <string name="wallpaper_attributions" msgid="4323659759250650736">"À propos du fond d\'écran"</string>
    <string name="wallpaper_attributions_values" msgid="987277439026021925">"Fournisseurs d\'images satellite :\n© CNES/Astrium, DigitalGlobe, Bluesky 2014"</string>
    <string name="settings_manual_activity_title" msgid="1682978148920788484">"Manuel"</string>
    <string name="settings_manual_activity_unavailable" msgid="2514549851682321576">"Problème lors du chargement du manuel."</string>
    <string name="settings_license_activity_title" msgid="7832071619364734914">"Licences tierces"</string>
    <string name="settings_license_activity_unavailable" msgid="9014803774391134570">"Un problème est survenu lors du chargement des licences."</string>
    <string name="settings_license_activity_loading" msgid="1653151990366578827">"Chargement en cours..."</string>
    <string name="settings_safetylegal_activity_loading" msgid="1757860124583063395">"Chargement en cours..."</string>
    <string name="lockpassword_choose_your_password_header" msgid="2407205113298094824">"Définissez un mot de passe"</string>
    <string name="lockpassword_choose_your_profile_password_header" msgid="7038997227611893312">"Définir un mot de passe professionnel"</string>
    <string name="lockpassword_choose_your_pin_header" msgid="7754265746504679473">"Définissez un NIP"</string>
    <string name="lockpassword_choose_your_profile_pin_header" msgid="4581749963670819048">"Définir un NIP professionnel"</string>
    <string name="lockpassword_choose_your_pattern_header" msgid="5674909390779586252">"Définir un schéma"</string>
    <string name="lockpassword_choose_your_pattern_description" msgid="6808109256008481046">"Pour renforcer la sécurité, définissez un schéma pour déverrouiller l\'appareil"</string>
    <string name="lockpassword_choose_your_profile_pattern_header" msgid="3101811498330756641">"Définir un mot de schéma professionnel"</string>
    <string name="lockpassword_choose_your_password_header_for_fingerprint" msgid="3167261267229254090">"Pour util. empr. digit., config. m. de passe"</string>
    <string name="lockpassword_choose_your_pattern_header_for_fingerprint" msgid="4707788269512303400">"Pour utiliser votre empreinte, configurez un schéma"</string>
    <string name="lockpassword_choose_your_pin_message" msgid="7230665212172041837">"Pour votre sécurité, définissez un NIP"</string>
    <string name="lockpassword_choose_your_pin_header_for_fingerprint" msgid="2783879743691792556">"Pour util. empr. digit., config. NIP"</string>
    <string name="lockpassword_confirm_your_password_header" msgid="6132312814563023990">"Entrer de nouveau votre mot de passe"</string>
    <string name="lockpassword_reenter_your_profile_password_header" msgid="3812040127714827685">"Confirmer votre mot de passe professionnel"</string>
    <string name="lockpassword_confirm_your_work_password_header" msgid="4647071231702288305">"Entrer votre mot de passe professionnel"</string>
    <string name="lockpassword_confirm_your_pattern_header" msgid="4037701363240138651">"Confirmer votre schéma"</string>
    <string name="lockpassword_confirm_your_work_pattern_header" msgid="2668883108969165844">"Entrer votre schéma prof."</string>
    <string name="lockpassword_confirm_your_pin_header" msgid="2241722970567131308">"Entrez de nouveau votre NIP"</string>
    <string name="lockpassword_reenter_your_profile_pin_header" msgid="2890233614560435538">"Confirmer votre NIP professionnel"</string>
    <string name="lockpassword_confirm_your_work_pin_header" msgid="4229765521391960255">"Entrer votre NIP professionnel"</string>
    <string name="lockpassword_confirm_passwords_dont_match" msgid="2100071354970605232">"Les mots de passe ne correspondent pas"</string>
    <string name="lockpassword_confirm_pins_dont_match" msgid="1103699575489401030">"Les NIP ne correspondent pas"</string>
    <string name="lockpassword_draw_your_pattern_again_header" msgid="1045638030120803622">"Tracer de nouveau votre schéma"</string>
    <string name="lockpassword_choose_lock_generic_header" msgid="5669348379247148696">"Mode de déverrouillage"</string>
    <string name="lockpassword_password_set_toast" msgid="6615759749393973795">"Le mot de passe a été défini."</string>
    <string name="lockpassword_pin_set_toast" msgid="5415783847198570890">"Le NIP a été défini."</string>
    <string name="lockpassword_pattern_set_toast" msgid="3090582314362416762">"Le schéma a été défini."</string>
    <string name="lockpassword_choose_your_password_header_for_face" msgid="622276003801157839">"Mot de passe pour déverrouillage facial"</string>
    <string name="lockpassword_choose_your_pattern_header_for_face" msgid="7333603579958317102">"Schéma pour le déverrouillage facial"</string>
    <string name="lockpassword_choose_your_pin_header_for_face" msgid="704061826984851309">"Code pour le déverrouillage facial"</string>
    <string name="lockpassword_choose_your_password_header_for_biometrics" msgid="2053366309272487015">"Définir mot passe pour utiliser visage ou empreinte digitale"</string>
    <string name="lockpassword_choose_your_pattern_header_for_biometrics" msgid="4038476475293734905">"Définir un schéma pour utiliser visage ou empreinte digitale"</string>
    <string name="lockpassword_choose_your_pin_header_for_biometrics" msgid="9086039918921009380">"Définissez un NIP de secours"</string>
    <string name="lockpassword_forgot_password" msgid="5730587692489737223">"Mot de passe oublié?"</string>
    <string name="lockpassword_forgot_pattern" msgid="1196116549051927516">"Schéma oublié?"</string>
    <string name="lockpassword_forgot_pin" msgid="7164232234705747672">"NIP oublié?"</string>
    <string name="lockpassword_confirm_your_pattern_generic" msgid="7692794426682501482">"Entrez le schéma de l\'appareil pour continuer"</string>
    <string name="lockpassword_confirm_your_pin_generic" msgid="9206928587904701094">"Entrez le NIP de l\'appareil pour continuer."</string>
    <string name="lockpassword_confirm_your_password_generic" msgid="2616127423884477152">"Entrez le mot de passe de l\'appareil pour continuer."</string>
    <string name="lockpassword_confirm_your_pattern_generic_profile" msgid="9110305410672321714">"Entrez le schéma de votre profil professionnel pour continuer"</string>
    <string name="lockpassword_confirm_your_pin_generic_profile" msgid="6524208128570235127">"Entrez le NIP de votre profil professionnel pour continuer"</string>
    <string name="lockpassword_confirm_your_password_generic_profile" msgid="5918738487760814147">"Entrez le mot de passe de votre profil professionnel pour continuer"</string>
    <string name="lockpassword_strong_auth_required_device_pattern" msgid="113817518413715557">"Pour plus de sécurité, tracez le schéma de votre appareil"</string>
    <string name="lockpassword_strong_auth_required_device_pin" msgid="9163822166411129815">"Pour plus de sécurité, entrez le NIP de votre appareil"</string>
    <string name="lockpassword_strong_auth_required_device_password" msgid="8310047427464299337">"Pour plus de sécurité, entrez le mot de passe de votre appareil"</string>
    <string name="lockpassword_strong_auth_required_work_pattern" msgid="6803652050512161140">"Pour plus de sécurité, tracez votre schéma professionnel"</string>
    <string name="lockpassword_strong_auth_required_work_pin" msgid="4208510396448713500">"Pour plus de sécurité, entrez votre NIP professionnel"</string>
    <string name="lockpassword_strong_auth_required_work_password" msgid="6119482061429323090">"Pour plus de sécurité, entrez votre mot de passe professionnel"</string>
    <string name="lockpassword_confirm_your_pattern_header_frp" msgid="5641858015891896427">"Vérifier le schéma"</string>
    <string name="lockpassword_confirm_your_pin_header_frp" msgid="8285647793164729982">"Vérifier le NIP"</string>
    <string name="lockpassword_confirm_your_password_header_frp" msgid="7932240547542564033">"Vérifier le mot de passe"</string>
    <string name="lockpassword_remote_validation_header" msgid="4992647285784962073">"Vérif. que c\'est vous"</string>
    <string name="lockpassword_remote_validation_pattern_details" msgid="4655537780358707983">"Pour transférer des comptes Google, des paramètres et autres, entrez le schéma de votre autre appareil. Votre schéma est chiffré."</string>
    <string name="lockpassword_remote_validation_pin_details" msgid="2373654227583206297">"Pour transférer des comptes Google, des paramètres et autres, entrez le NIP de votre autre appareil. Votre NIP est chiffré."</string>
    <string name="lockpassword_remote_validation_password_details" msgid="3482328925925888340">"Pour transférer des comptes Google, des paramètres et autres, entrez le mot de passe de votre autre appareil. Votre mot de passe est chiffré."</string>
    <string name="lockpassword_remote_validation_set_pattern_as_screenlock" msgid="7595104317648465901">"Utiliser un schéma pour déverr. l\'appareil"</string>
    <string name="lockpassword_remote_validation_set_pin_as_screenlock" msgid="509672303005547218">"Utiliser un NIP pour déverr. l\'appareil"</string>
    <string name="lockpassword_remote_validation_set_password_as_screenlock" msgid="2066701840753591922">"Utiliser un mot de passe pour déverr. l\'appareil"</string>
    <string name="lockpassword_invalid_pin" msgid="7530854476819820600">"NIP erroné"</string>
    <string name="lockpassword_invalid_password" msgid="1588184930542221687">"Mot de passe incorrect"</string>
    <string name="lockpattern_need_to_unlock_wrong" msgid="8109305107409924083">"Schéma erroné"</string>
    <string name="work_challenge_emergency_button_text" msgid="5529942788380505927">"Urgence"</string>
    <string name="lock_settings_title" msgid="665707559508132349">"Sécurité de l\'appareil"</string>
    <string name="lockpattern_change_lock_pattern_label" msgid="5853706275279878879">"Modifier le schéma"</string>
    <string name="lockpattern_change_lock_pin_label" msgid="7327409886587802756">"Modifier le NIP de déverrouillage"</string>
    <string name="lockpattern_recording_intro_header" msgid="8325736706877916560">"Dessinez un schéma de déverrouillage"</string>
    <string name="lockpattern_recording_intro_footer" msgid="2656868858594487197">"Appuyez sur Menu pour obtenir de l\'aide."</string>
    <string name="lockpattern_recording_inprogress" msgid="7268008332694009191">"Relevez le doigt lorsque vous avez terminé"</string>
    <string name="lockpattern_recording_incorrect_too_short" msgid="3351522018450593723">"Reliez au moins <xliff:g id="NUMBER">%d</xliff:g> points. Veuillez réessayer."</string>
    <string name="lockpattern_pattern_entered_header" msgid="7709618312713127249">"Schéma enregistré"</string>
    <string name="lockpattern_need_to_confirm" msgid="6489499109451714360">"Redessinez le schéma pour confirmer"</string>
    <string name="lockpattern_pattern_confirmed_header" msgid="2969990617475456153">"Votre nouveau schéma de déverrouillage est le suivant :"</string>
    <string name="lockpattern_confirm_button_text" msgid="6122815520373044089">"Confirmer"</string>
    <string name="lockpattern_restart_button_text" msgid="255339375151895998">"Redessiner"</string>
    <string name="lockpattern_retry_button_text" msgid="4229668933251849760">"Effacer"</string>
    <string name="lockpattern_continue_button_text" msgid="5253269556259503537">"Continuer"</string>
    <string name="lockpattern_settings_title" msgid="9223165804553269083">"Schéma de déverrouillage"</string>
    <string name="lockpattern_settings_enable_title" msgid="7401197111303283723">"Schéma obligatoire"</string>
    <string name="lockpattern_settings_enable_summary" msgid="1116467204475387886">"Dessiner un schéma pour déverrouiller l\'écran"</string>
    <string name="lockpattern_settings_enable_visible_pattern_title" msgid="3340969054395584754">"Faire apparaître le schéma"</string>
    <string name="lockpattern_settings_enhanced_pin_privacy_title" msgid="7172693275721931683">"Confidentialité accrue du NIP"</string>
    <string name="lockpattern_settings_enhanced_pin_privacy_summary" msgid="8639588868341114740">"Désactiver les animations lors de la saisie du NIP"</string>
    <string name="lockpattern_settings_enable_visible_pattern_title_profile" msgid="5138189101808127489">"Rendre visible le schéma du profil"</string>
    <string name="lockpattern_settings_enable_tactile_feedback_title" msgid="2273374883831956787">"Vibrer au toucher"</string>
    <string name="lockpattern_settings_enable_power_button_instantly_locks" msgid="1638619728773344099">"Verr. auto avec Marche/Arrêt"</string>
    <string name="lockpattern_settings_power_button_instantly_locks_summary" msgid="2202430156268094229">"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="2193588309557281466">"Créer un schéma"</string>
    <string name="lockpattern_settings_change_lock_pattern" msgid="7614155083815661347">"Modifier le schéma"</string>
    <string name="lockpattern_settings_help_how_to_record" msgid="2093801939046625774">"Comment dessiner un schéma de déverrouillage :"</string>
    <string name="lockpattern_too_many_failed_confirmation_attempts" msgid="7891484005551794824">"Trop de tentatives incorrectes. Réessayez dans <xliff:g id="NUMBER">%d</xliff:g> secondes."</string>
    <string name="activity_not_found" msgid="5464331414465894254">"L\'application n\'est pas installée sur votre téléphone."</string>
    <string name="lock_settings_profile_title" msgid="103605580492566086">"Sécurité du profil professionnel"</string>
    <string name="lock_settings_profile_screen_lock_title" msgid="3776275029218681815">"Verrouillage de l\'écran du profil professionnel"</string>
    <string name="lock_settings_profile_unification_title" msgid="5777961097706546513">"Utiliser un seul mode de verrouillage"</string>
    <string name="lock_settings_profile_unification_summary" msgid="1317553536289481654">"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="5163178097464820825">"Utiliser un seul mode de verrouillage?"</string>
    <string name="lock_settings_profile_unification_dialog_body" msgid="1222905637428672355">"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="8844682343443755895">"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="6276915393736137843">"Utiliser un seul mode de verrouillage"</string>
    <string name="lock_settings_profile_unification_dialog_uncompliant_confirm" msgid="8509287115116369677">"Utiliser un seul mode de verrouillage"</string>
    <string name="lock_settings_profile_unified_summary" msgid="777095092175037385">"Identique au verrouillage de l\'écran de l\'appareil"</string>
    <string name="manageapplications_settings_title" msgid="9198876415524237657">"Gérer les applications"</string>
    <string name="applications_settings" msgid="1941993743933425622">"Détails de l\'application"</string>
    <string name="applications_settings_header" msgid="3154670675856048015">"Paramètres de l\'application"</string>
    <string name="install_applications" msgid="3921609656584369901">"Sources inconnues"</string>
    <string name="install_applications_title" msgid="7890233747559108106">"Autoriser toutes sources appli"</string>
    <string name="recent_app_category_title" msgid="189758417804427533">"Applications récemment ouvertes"</string>
    <string name="see_all_apps_title" msgid="1650653853942381797">"{count,plural, =1{Afficher l\'unique application}one{Afficher l\'unique (#) application}other{Afficher les # applications}}"</string>
    <string name="forgot_password_title" msgid="3967873480875239885">"Contacter l\'administrateur informatique"</string>
    <string name="forgot_password_text" msgid="2583194470767613163">"Il peut vous aider à réinitialiser votre NIP, votre schéma ou votre mot de passe"</string>
    <string name="advanced_settings" msgid="2368905204839169094">"Paramètres avancés"</string>
    <string name="advanced_settings_summary" msgid="1823765348195530035">"Activer d\'autres paramètres"</string>
    <string name="application_info_label" msgid="1015706497694165866">"Détails de l\'application"</string>
    <string name="storage_label" msgid="2522307545547515733">"Stockage"</string>
    <string name="auto_launch_label" msgid="4069860409309364872">"Ouvrir par défaut"</string>
    <string name="auto_launch_label_generic" msgid="5033137408273064599">"Valeurs par défaut"</string>
    <string name="screen_compatibility_label" msgid="7549658546078613431">"Compatibilité de l\'écran"</string>
    <string name="permissions_label" msgid="1708927634370314404">"Autorisations"</string>
    <string name="cache_header_label" msgid="2441967971921741047">"Cache"</string>
    <string name="clear_cache_btn_text" msgid="8597272828928143723">"Vider le cache"</string>
    <string name="cache_size_label" msgid="313456088966822757">"Cache"</string>
    <string name="uri_permissions_text" msgid="8406345863117405105">"{count,plural, =1{1 élément}one{# élément}other{# éléments}}"</string>
    <string name="clear_uri_btn_text" msgid="4828117421162495134">"Supprimer l\'accès"</string>
    <string name="controls_label" msgid="8671492254263626383">"Commandes"</string>
    <string name="force_stop" msgid="2681771622136916280">"Forcer l\'arrêt"</string>
    <string name="total_size_label" msgid="2052185048749658866">"Total"</string>
    <string name="application_size_label" msgid="6407051020651716729">"Taille de l\'application"</string>
    <string name="external_code_size_label" msgid="7375146402660973743">"Application sur USB"</string>
    <string name="data_size_label" msgid="7814478940141255234">"Données de l\'utilisateur"</string>
    <string name="uninstall_text" msgid="315764653029060126">"Désinstaller"</string>
    <string name="uninstall_all_users_text" msgid="5924715251087176474">"Uninstall for all users"</string>
    <string name="install_text" msgid="4558333621516996473">"Installer"</string>
    <string name="disable_text" msgid="5146002260857428005">"Désactiver"</string>
    <string name="enable_text" msgid="8570798764647110430">"Activer"</string>
    <string name="clear_user_data_text" msgid="6773186434260397947">"Effacer l\'espace de stockage"</string>
    <string name="app_factory_reset" msgid="8974044931667015201">"Désinstaller mises à jour"</string>
    <string name="app_restricted_settings_lockscreen_title" msgid="5993061278264872648">"Autoriser les paramètres restreints"</string>
    <string name="auto_launch_enable_text" msgid="8912714475823807798">"Certaines activités que vous avez sélectionnées s\'ouvrent dans cette application par défaut."</string>
    <string name="always_allow_bind_appwidgets_text" msgid="2069415023986858324">"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="502648841250936209">"Aucun paramètre par défaut défini"</string>
    <string name="clear_activities" msgid="488089228657585700">"Effacer les préférences par défaut"</string>
    <string name="screen_compatibility_text" msgid="5915767835411020274">"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="8388397595148476565">"Demander au moment du lancement"</string>
    <string name="enable_compatibility" msgid="1163387233622859712">"Mettre l\'application à l\'échelle"</string>
    <string name="unknown" msgid="8192160131923461175">"Inconnu"</string>
    <string name="sort_order_alpha" msgid="3400680865280266582">"Trier par nom"</string>
    <string name="sort_order_size" msgid="7731928486199737223">"Trier par taille"</string>
    <string name="sort_order_recent_notification" msgid="1496198895330443073">"Les plus récentes"</string>
    <string name="sort_order_frequent_notification" msgid="4063700985742284794">"Les plus fréquentes"</string>
    <string name="show_running_services" msgid="8666008279959853318">"Afficher les services en cours"</string>
    <string name="show_background_processes" msgid="5682856012453562151">"Afficher processus en cache"</string>
    <string name="default_emergency_app" msgid="1929974800666613803">"Application d\'urgence"</string>
    <string name="reset_app_preferences" msgid="8861758340732716573">"Réinitialiser préférences applis"</string>
    <string name="reset_app_preferences_title" msgid="8935136792316050759">"Réinitialiser les préférences relatives aux applis?"</string>
    <string name="reset_app_preferences_desc" msgid="8550782670650158299">"Les préférences relatives aux éléments suivants seront réinitialisées :\n\n"<li>"Applications désactivées"</li>\n<li>"Notifications des 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<li>"Paramètres d\'utilisation de la pile"</li>\n\n"Vous ne perdrez aucune donnée liée aux applications."</string>
    <string name="reset_app_preferences_button" msgid="2591318711372850058">"Réinitialiser applis"</string>
    <string name="filter" msgid="9039576690686251462">"Filtre"</string>
    <string name="filter_dlg_title" msgid="3086282431958601338">"Sélectionner les options du filtre"</string>
    <string name="filter_apps_all" msgid="5705421199299914620">"Toutes les applications"</string>
    <string name="filter_apps_disabled" msgid="5068011814871004105">"Applications désactivées"</string>
    <string name="filter_apps_third_party" msgid="9049447784849114843">"Téléchargée"</string>
    <string name="filter_apps_running" msgid="535465683273284141">"Diffusion en cours"</string>
    <string name="not_installed" msgid="5074606858798519449">"Pas installée pour cet utilisateur"</string>
    <string name="installed" msgid="2837449358488825884">"Installée"</string>
    <string name="no_applications" msgid="985069304755391640">"Aucune application"</string>
    <string name="internal_storage" msgid="999496851424448809">"Mémoire de stockage interne"</string>
    <string name="recompute_size" msgid="1098091228370999128">"Calcul de la taille..."</string>
    <string name="clear_data_dlg_title" msgid="180446967743732410">"Supprimer les données de l\'application?"</string>
    <string name="clear_data_dlg_text" msgid="3440011276559762619">"Les données de cette application, y compris les fichiers et les paramètres, seront supprimées de cet appareil"</string>
    <string name="dlg_ok" msgid="1421350367857960997">"OK"</string>
    <string name="dlg_cancel" msgid="5164705061530774899">"Annuler"</string>
    <string name="dlg_delete" msgid="1790919205039397659">"Supprimer"</string>
    <string name="app_not_found_dlg_text" msgid="8634675268730513704">"L\'application ne figure pas dans la liste des applications installées."</string>
    <string name="clear_failed_dlg_text" msgid="6866741916836125732">"Impossible de supprimer l\'espace de stockage pour l\'application."</string>
    <string name="computing_size" msgid="4915310659841174866">"Traitement..."</string>
    <string name="invalid_size_value" msgid="7017371543563259201">"Impossible de calculer la taille du package."</string>
    <string name="version_text" msgid="7628938665256107608">"version <xliff:g id="VERSION_NUM">%1$s</xliff:g>"</string>
    <string name="move_app" msgid="5421158479447276791">"Déplacer"</string>
    <string name="another_migration_already_in_progress" msgid="6550546307856052261">"Un autre transfert est déjà en cours."</string>
    <string name="insufficient_storage" msgid="8115088042669030558">"Espace de stockage insuffisant."</string>
    <string name="does_not_exist" msgid="6499163879348776120">"L\'application n\'existe pas."</string>
    <string name="invalid_location" msgid="8013853455355520557">"L\'emplacement d\'installation n\'est pas valide."</string>
    <string name="system_package" msgid="7559476279008519360">"Les mises à jour du système ne peuvent pas être installées sur des supports externes."</string>
    <string name="move_error_device_admin" msgid="1561502976834303626">"Les applications d\'administration d\'appareils ne peuvent pas être installées sur un support externe"</string>
    <string name="force_stop_dlg_title" msgid="86745852555490146">"Forcer l\'arrêt?"</string>
    <string name="force_stop_dlg_text" msgid="1527286468544457368">"Si vous forcez l\'arrêt d\'une application, son fonctionnement peut en être affecté."</string>
    <string name="app_disable_dlg_positive" msgid="1414218905322009505">"Désactiver l\'application"</string>
    <string name="app_disable_dlg_text" msgid="2449382902751908916">"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_install_details_group_title" msgid="1172114479073704677">"Boutique d\'applications"</string>
    <string name="app_install_details_title" msgid="7783556181897142187">"Détails de l\'application"</string>
    <string name="app_install_details_summary" msgid="2013043219249992373">"Source de l\'application : <xliff:g id="APP_STORE">%1$s</xliff:g>"</string>
    <string name="instant_app_details_summary" msgid="417197491598208216">"Plus d\'information sur <xliff:g id="APP_STORE">%1$s</xliff:g>"</string>
    <string name="app_ops_running" msgid="6127474473137428721">"En cours d\'exécution"</string>
    <string name="app_ops_never_used" msgid="9038133162371204506">"(Jamais utilisé)"</string>
    <string name="storageuse_settings_title" msgid="3125650750657988194">"Utilisation de la mémoire"</string>
    <string name="service_restarting" msgid="5104563288155809226">"Redémarrage"</string>
    <string name="cached" msgid="5379485147573438201">"Processus d\'arrière-plan en cache"</string>
    <string name="no_running_services" msgid="9079738069349859373">"Aucun service en cours"</string>
    <string name="service_started_by_app" msgid="6845028506417670179">"Démarré par l\'application"</string>
    <!-- no translation found for service_client_name (2210898622981598861) -->
    <skip />
    <string name="service_background_processes" msgid="2800539421534521948">"Libre: <xliff:g id="MEMORY">%1$s</xliff:g>"</string>
    <string name="service_foreground_processes" msgid="6380905887193621704">"<xliff:g id="MEMORY">%1$s</xliff:g> utilisé(s)"</string>
    <string name="memory" msgid="5253757199926592074">"RAM"</string>
    <!-- no translation found for service_process_name (7827318358399776412) -->
    <skip />
    <string name="running_process_item_user_label" msgid="1444898861984132133">"Utilisateur : <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="running_process_item_removed_user_label" msgid="4812732296696662613">"Utilisateur supprimé"</string>
    <string name="running_processes_item_description_s_s" msgid="6835918861352501671">"<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="1209371773353932361">"<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="8957061449107822282">"<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="3292999232897469679">"<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="558961782589967366">"Mémoire de l\'appareil"</string>
    <string name="running_processes_header_footer" msgid="2726092156680487584">"Utilisation de la mémoire vive par l\'application"</string>
    <string name="running_processes_header_system_prefix" msgid="8819527769608555124">"Système"</string>
    <string name="running_processes_header_apps_prefix" msgid="4151874328324238133">"Applications"</string>
    <string name="running_processes_header_free_prefix" msgid="4271100378295864738">"Disponible"</string>
    <string name="running_processes_header_used_prefix" msgid="5205762402234243007">"Utilisée"</string>
    <string name="running_processes_header_cached_prefix" msgid="839132595831993521">"En cache"</string>
    <string name="running_processes_header_ram" msgid="3014991380467004685">"<xliff:g id="RAM_0">%1$s</xliff:g> de mémoire vive"</string>
    <string name="runningservicedetails_settings_title" msgid="1057845389092757121">"Application en cours d\'exécution"</string>
    <string name="no_services" msgid="3898812785511572899">"Inactif"</string>
    <string name="runningservicedetails_services_title" msgid="11853795112787355">"Services"</string>
    <string name="runningservicedetails_processes_title" msgid="5292271587797234038">"Processus"</string>
    <string name="service_stop" msgid="5712522600201308795">"Arrêter"</string>
    <string name="service_manage" msgid="3896322986828332075">"Paramètres"</string>
    <string name="service_stop_description" msgid="6327742632400026677">"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="3086419998820881290">"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="4792038933517438037">"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="6615788996428486121">"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="6685973937935027773">"Processus principal en cours d\'utilisation."</string>
    <string name="process_service_in_use_description" msgid="4210957264507014878">"Le service <xliff:g id="COMP_NAME">%1$s</xliff:g> est actuellement utilisé."</string>
    <string name="process_provider_in_use_description" msgid="6730020083976048028">"L\'opérateur <xliff:g id="COMP_NAME">%1$s</xliff:g> est actuellement utilisé."</string>
    <string name="runningservicedetails_stop_dlg_title" msgid="6201041461740445113">"Arrêter le service système?"</string>
    <string name="language_input_gesture_title" msgid="3292455685728572960">"Langues, entrée et gestes"</string>
    <string name="language_settings" msgid="8700174277543875046">"Langues et modes d\'entrée"</string>
    <string name="languages_settings" msgid="5784775502251770671">"Langues"</string>
    <string name="keyboard_settings" msgid="184185708597386454">"Clavier"</string>
    <string name="language_empty_list_user_restricted" msgid="8050367405839231863">"Vous n\'êtes pas autorisé à modifier la langue de l\'appareil."</string>
    <string name="language_keyboard_settings_title" msgid="7934844313233544557">"Langues et modes d\'entrée"</string>
    <string name="input_assistance" msgid="3437568284144952104">"Outils"</string>
    <string name="keyboard_settings_category" msgid="5392847229300117064">"Clavier et modes de saisie"</string>
    <string name="system_language" msgid="1146762166579643257">"Langues du système"</string>
    <string name="phone_language" msgid="5986939176239963826">"Langues"</string>
    <string name="phone_language_summary" msgid="863041222809685325"></string>
    <string name="auto_replace" msgid="4830732960264447043">"Remplacement automatique"</string>
    <string name="auto_replace_summary" msgid="1285443414597153423">"Corriger les mots mal saisis"</string>
    <string name="auto_caps" msgid="5573583581288305355">"Majuscules automatiques"</string>
    <string name="auto_caps_summary" msgid="3144141933426846665">"Mettre une majuscule en début de phrase"</string>
    <string name="auto_punctuate" msgid="2838809477621809507">"Ponctuation automatique"</string>
    <string name="hardkeyboard_category" msgid="8729780593378161071">"Paramètres du clavier physique"</string>
    <string name="auto_punctuate_summary" msgid="3549190848611386748">"Appuyez deux fois sur la touche Espace pour insérer « . »"</string>
    <string name="show_password" msgid="7101900779571040117">"Afficher les mots de passe"</string>
    <string name="show_password_summary" msgid="9025960283785111619">"Afficher les caractères brièvement pendant la saisie"</string>
    <string name="spellchecker_security_warning" msgid="2016059050608271820">"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="6449414356743946577">"Paramètres"</string>
    <string name="spellchecker_language" msgid="8905487366580285282">"Langue"</string>
    <string name="keyboard_and_input_methods_category" msgid="5296847777802891649">"Claviers"</string>
    <string name="virtual_keyboard_category" msgid="2339505603075527212">"Clavier à l\'écran"</string>
    <string name="keywords_virtual_keyboard" msgid="1494726424879503434">"Gboard"</string>
    <string name="available_virtual_keyboard_category" msgid="6930012948152749337">"Clavier à l\'écran accessible"</string>
    <string name="add_virtual_keyboard" msgid="2515850206289352606">"Gérer les claviers à l\'écran"</string>
    <string name="keyboard_options_category" msgid="8040137073401152608">"Options"</string>
    <string name="physical_keyboard_title" msgid="3328134097512350958">"Clavier physique"</string>
    <string name="show_ime" msgid="4334255501724746849">"Utiliser le clavier à l\'écran"</string>
    <string name="show_ime_summary" msgid="7293345791727205975">"Afficher lorsque le clavier physique est activé"</string>
    <string name="keyboard_shortcuts_helper" msgid="2553221039203165344">"Raccourcis clavier"</string>
    <string name="keyboard_shortcuts_helper_summary" msgid="5979507677602559203">"Afficher la liste de raccourcis"</string>
    <string name="language_and_input_for_work_category_title" msgid="2546950919124199743">"Claviers et outils pour le profil professionnel"</string>
    <string name="virtual_keyboards_for_work_title" msgid="786459157034008675">"Clavier à l\'écran pour le travail"</string>
    <string name="keyboard_default_layout" msgid="5377811770620422301">"Par défaut"</string>
    <string name="trackpad_settings" msgid="2071131324087677005">"Pavé tactile"</string>
    <string name="trackpad_mouse_settings" msgid="136226693583218429">"Pavé tactile et souris"</string>
    <string name="trackpad_settings_summary" msgid="3369855644136760402">"Vitesse du pointeur, gestes"</string>
    <string name="trackpad_tap_to_click" msgid="1938230946542070746">"Toucher pour cliquer"</string>
    <string name="trackpad_touchpad_gesture_title" msgid="7568052847609914436">"Gestes du pavé tactile"</string>
    <string name="trackpad_touchpad_gesture_summary" msgid="6256074591395359124">"Personna. les gestes individuels de navigation du pavé tactile"</string>
    <string name="trackpad_reverse_scrolling_title" msgid="422877284529360866">"Défilement inversé"</string>
    <string name="trackpad_reverse_scrolling_summary" msgid="6048648562887499036">"Le contenu remonte lorsque la page défile vers le bas"</string>
    <string name="trackpad_bottom_right_tap_title" msgid="6275428879042702880">"Toucher en bas à droite"</string>
    <string name="trackpad_bottom_right_tap_summary" msgid="8734094086900680674">"Touch. coin inférieur droit (pavé tactile) pour plus d\'options"</string>
    <string name="trackpad_pointer_speed" msgid="7786579408631352625">"Vitesse du pointeur"</string>
    <string name="trackpad_touch_gesture" msgid="8641725062131922497">"Apprendre les gestes du pavé tactile"</string>
    <string name="gesture_title_go_home" msgid="3682238648647225933">"Retour à la page d\'accueil"</string>
    <string name="gesture_summary_go_home" msgid="6409031586904205741">"Balayez votre pavé tactile vers le haut avec trois doigts"</string>
    <string name="gesture_title_go_back" msgid="6619462058488419802">"Retour"</string>
    <string name="gesture_summary_go_back" msgid="4981604277892236888">"Balayez l\'écran à gauche ou à droite avec trois doigts"</string>
    <string name="gesture_title_recent_apps" msgid="6082688963233208761">"Afficher les applications récentes"</string>
    <string name="gesture_summary_recent_apps" msgid="6643179135202417509">"Balayez vers le haut avec trois doigts, maintenez et relâchez"</string>
    <string name="gesture_title_notifications" msgid="791717222472350194">"Afficher notif. et param. rapides"</string>
    <string name="gesture_summary_notifications" msgid="8419514601638387255">"Balayez votre écran d\'accueil vers le bas avec trois doigts"</string>
    <string name="gesture_title_switch_apps" msgid="5840994412037872157">"Changer d\'application"</string>
    <string name="gesture_summary_switch_apps" msgid="6842648062151413042">"Balayez vers la gauche ou vers la droite avec quatre doigts"</string>
    <string name="gesture_button_skip" msgid="5174842083451193213">"Ignorer"</string>
    <string name="gesture_button_next" msgid="695288092704187356">"Suivant"</string>
    <string name="gesture_button_restart" msgid="1895850891992530133">"Redémarrer"</string>
    <string name="gesture_button_done" msgid="6387900351203032188">"OK"</string>
    <string name="trackpad_go_back_title" msgid="5312164160947491440">"Retour"</string>
    <string name="trackpad_go_back_summary" msgid="4201901101085902768">"Balayez vers la gauche ou vers la droite avec trois doigts"</string>
    <string name="trackpad_go_home_title" msgid="2146525662148291552">"Retour à la page d\'accueil"</string>
    <string name="trackpad_go_home_summary" msgid="2222744701528360887">"Balayez l\'écran vers le haut avec trois doigts"</string>
    <string name="trackpad_recent_apps_title" msgid="8195970908411585445">"Applications récentes"</string>
    <string name="trackpad_recent_apps_summary" msgid="2685092851677573794">"Balayez vers le haut avec trois doigts, puis maintenez-les"</string>
    <string name="trackpad_notifications_title" msgid="3521663305043747880">"Notifications"</string>
    <string name="trackpad_notifications_summary" msgid="7663647367648690040">"Balayez l\'écran vers le bas avec trois doigts"</string>
    <string name="trackpad_switch_apps_title" msgid="7342032935377284039">"Changer d\'application"</string>
    <string name="trackpad_switch_apps_summary" msgid="9193942041912927440">"Balayez vers la gauche ou vers la droite avec quatre doigts"</string>
    <string name="modifier_keys_settings" msgid="2537108435032034683">"Touches de modification"</string>
    <string name="modifier_keys_settings_summary" msgid="6933143361657444436">"Modifiez le comportement des touches"</string>
    <string name="modifier_keys_reset_title" msgid="948294258402761066">"Tout réinitialiser"</string>
    <string name="modifier_keys_default_summary" msgid="8701640508670973258">"Par défaut"</string>
    <string name="modifier_keys_reset_message" msgid="5236994817619936058">"Voulez-vous vraiment réinitialiser toutes les touches de modification à leur valeur par défaut?"</string>
    <string name="modifier_keys_done" msgid="8196199314913909700">"OK"</string>
    <string name="modifier_keys_cancel" msgid="7136520252570826772">"Annuler"</string>
    <!-- no translation found for modifier_keys_reset (551170906710422041) -->
    <skip />
    <string name="modifier_keys_picker_title" msgid="244545904150587851">"Choisir la touche de modification"</string>
    <string name="modifier_keys_picker_summary" msgid="739397232249560785">"Choisissez une nouvelle clé pour <xliff:g id="MODIFIER_KEY_DEFAULT_NAME">%1$s</xliff:g> :"</string>
    <string name="default_keyboard_layout" msgid="8690689331289452201">"Par défaut"</string>
    <string name="speech_category_title" msgid="5995161659186229742">"Parole"</string>
    <string name="pointer_speed" msgid="7398649279282675718">"Vitesse du pointeur"</string>
    <string name="game_controller_settings_category" msgid="8557472715034961918">"Manette de jeu"</string>
    <string name="vibrate_input_devices" msgid="5192591087864449142">"Rediriger les vibrations"</string>
    <string name="vibrate_input_devices_summary" msgid="8791680891376689823">"Rediriger les vibrations vers la manette de jeu lorsqu\'elle est connectée"</string>
    <string name="keyboard_layout_dialog_title" msgid="8770130364048089954">"Sélectionner disposition du clavier"</string>
    <string name="keyboard_layout_dialog_setup_button" msgid="6546245862744626706">"Configurer dispositions clavier"</string>
    <string name="keyboard_layout_dialog_switch_hint" msgid="3303564123674979354">"Appuyez sur Ctrl+Espace pour changer disposition"</string>
    <string name="keyboard_layout_default_label" msgid="6078569989261528039">"Par défaut"</string>
    <string name="keyboard_layout_picker_title" msgid="240504762718562906">"Dispositions du clavier"</string>
    <string name="keyboard_layout_picker_category_title" msgid="2369473692906329772">"Dispositions du clavier physique"</string>
    <string name="user_dict_settings_title" msgid="680410651924276991">"Dictionnaire personnel"</string>
    <string name="user_dict_settings_for_work_title" msgid="1245315720684961770">"Dictionnaire personnel pour le travail"</string>
    <string name="user_dict_settings_summary" msgid="4939694372338975081">"Ajoutez des mots à utiliser dans des applications comme un correcteur orthographique"</string>
    <string name="user_dict_settings_add_menu_title" msgid="8046882347281382968">"Add"</string>
    <string name="user_dict_settings_add_dialog_title" msgid="3485845465134083084">"Ajouter au dictionnaire"</string>
    <string name="user_dict_settings_add_screen_title" msgid="1866408024073475379">"Expression"</string>
    <string name="user_dict_settings_add_dialog_more_options" msgid="2642928746425808108">"Plus d\'options"</string>
    <string name="user_dict_settings_add_dialog_less_options" msgid="100432503633458156">"Moins d\'options"</string>
    <string name="user_dict_settings_add_dialog_confirm" msgid="1866751313790655088">"OK"</string>
    <string name="user_dict_settings_add_word_option_name" msgid="2686051785623698231">"Mot :"</string>
    <string name="user_dict_settings_add_shortcut_option_name" msgid="5722204336242646866">"Raccourci :"</string>
    <string name="user_dict_settings_add_locale_option_name" msgid="2117468247460253346">"Langue :"</string>
    <string name="user_dict_settings_add_word_hint" msgid="4560494723256242785">"Entrez un mot"</string>
    <string name="user_dict_settings_add_shortcut_hint" msgid="6209624157217434640">"Raccourci facultatif"</string>
    <string name="user_dict_settings_edit_dialog_title" msgid="316493656442362284">"Modifier le mot"</string>
    <string name="user_dict_settings_context_menu_edit_title" msgid="4909198741914531509">"Modifier"</string>
    <string name="user_dict_settings_context_menu_delete_title" msgid="651550824433043545">"Supprimer"</string>
    <string name="user_dict_settings_empty_text" msgid="86562873609647919">"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="8563387437755363526">"Pour toutes les langues"</string>
    <string name="user_dict_settings_more_languages" msgid="5378870726809672319">"Plus de langues…"</string>
    <string name="testing" msgid="6294172343766732037">"Tests"</string>
    <string name="keyboard_settings_summary" msgid="2716339620942356432">"Clavier à l\'écran, parole, outils"</string>
    <string name="keyboard_settings_with_physical_keyboard_summary" msgid="6628668004523183413">"Clavier à l\'écran, clavier physique, parole, outils"</string>
    <string name="builtin_keyboard_settings_title" msgid="5096171620714179661">"Clavier physique"</string>
    <string name="enabled_locales_keyboard_layout" msgid="3939886151098958639">"Disposition"</string>
    <string name="gadget_picker_title" msgid="7615902510050731400">"Choisir un gadget"</string>
    <string name="widget_picker_title" msgid="7641298325488989676">"Choisir un widget"</string>
    <string name="allow_bind_app_widget_activity_allow_bind_title" msgid="3537968409832846255">"Créer un widget et autoriser l\'accès?"</string>
    <string name="allow_bind_app_widget_activity_allow_bind" msgid="5825298768068148804">"Une fois le widget créé, l\'application peut accéder à tout ce qui est affiché.\n\nApplication : <xliff:g id="WIDGET_HOST_NAME">%1$s</xliff:g>\nWidget : <xliff:g id="WIDGET_LABEL">%2$s</xliff:g>\n"</string>
    <string name="allow_bind_app_widget_activity_always_allow_bind" msgid="7268758525344468364">"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="testing_usage_stats" msgid="4660643799010906365">"Données statistiques"</string>
    <string name="usage_stats_sort_by_usage_time" msgid="2927310334119998301">"Trier par temps d\'utilisation"</string>
    <string name="usage_stats_sort_by_last_time_used" msgid="7039213339779884017">"Trier par dernière utilisation"</string>
    <string name="usage_stats_sort_by_app_name" msgid="4463833145514850478">"Trier par nom d\'application"</string>
    <string name="last_time_used_label" msgid="2639712813493534074">"Dernière utilisation :"</string>
    <string name="usage_time_label" msgid="9105343335151559883">"Temps d\'utilisation"</string>
    <string name="accessibility_settings" msgid="4713215774904704682">"Accessibilité"</string>
    <string name="accessibility_settings_title" msgid="6739115703615065716">"Paramètres d\'accessibilité"</string>
    <string name="accessibility_settings_summary" msgid="2366627644570558503">"Écran, interaction, audio"</string>
    <string name="vision_settings_title" msgid="8919983801864103069">"Paramètres de visibilité"</string>
    <string name="vision_settings_description" msgid="7614894785054441991">"Vous pouvez personnaliser cet appareil en fonction de vos besoins. Vous pourrez modifier ces fonctionnalités d\'accessibilité plus tard dans les paramètres."</string>
    <string name="vision_settings_suggestion_title" msgid="4689275412658803919">"Modifier la taille de la police"</string>
    <string name="screen_reader_category_title" msgid="5825700839731107803">"Lecteur d\'écran"</string>
    <string name="captions_category_title" msgid="574490148949400274">"Sous-titres"</string>
    <string name="audio_category_title" msgid="5283853679967605826">"Audio"</string>
    <string name="general_category_title" msgid="6298579528716834157">"Général"</string>
    <string name="display_category_title" msgid="6638191682294461408">"Affichage"</string>
    <string name="accessibility_color_and_motion_title" msgid="2323301706545305874">"Couleur et mouvement"</string>
    <string name="accessibility_turn_screen_darker_title" msgid="5986223133285858349">"Assombrir l\'écran"</string>
    <string name="interaction_control_category_title" msgid="2696474616743882372">"Commandes d\'interaction"</string>
    <string name="accessibility_tap_assistance_title" msgid="1058913033421048284">"Contrôles du minutage"</string>
    <string name="accessibility_system_controls_title" msgid="6403287349518987624">"Commandes système"</string>
    <string name="user_installed_services_category_title" msgid="2639470729311439731">"Applications téléchargées"</string>
    <string name="experimental_category_title" msgid="898904396646344152">"Fonctions expérimentales"</string>
    <string name="feature_flags_dashboard_title" msgid="348990373716658289">"Indicateurs de fonctionnalité"</string>
    <string name="bt_hci_snoop_log_filters_dashboard_title" msgid="401330708633716596">"Filtrage des journaux HCI Snoop Bluetooth"</string>
    <string name="bt_hci_snoop_log_filters_dashboard_summary" msgid="1319792184194176235">"Définissez les filtres"</string>
    <string name="bt_hci_snoop_log_filters_dashboard_footer" msgid="4158945851818483666">"Désactivez puis activez le Bluetooth pour que les modifications prennent effet"</string>
    <string name="bt_hci_snoop_log_filter_pbap_title" msgid="1735427364451634823">"Filtrage PBAP des journaux HCI Snoop Bluetooth"</string>
    <string name="bt_hci_snoop_log_filter_map_title" msgid="180092480793945544">"Filtrage MAP des journaux HCI Snoop Bluetooth"</string>
    <string name="bt_hci_snoop_log_filter_summary" msgid="7217091930762522599">"Définissez le mode de filtrage. (Activer/désactiver le Bluetooth pour que les modif. prennent effet)"</string>
    <string name="bt_hci_snoop_log_filtered_mode_disabled_summary" msgid="8824952559433361848">"Définissez mode des journaux HCI Snoop Bluetooth à Activé et filtré pour modifier cette option"</string>
    <string name="talkback_title" msgid="8756080454514251327">"TalkBack"</string>
    <string name="talkback_summary" msgid="5820927220378864281">"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="1995285446766920925">"Touchez les éléments à l\'écran pour les entendre à haute voix"</string>
    <string name="accessibility_captioning_title" msgid="4561871958958925225">"Préférences de sous-titres"</string>
    <string name="accessibility_captioning_about_title" msgid="3542171637334191563">"À propos des préférences de sous-titres"</string>
    <string name="accessibility_captioning_footer_learn_more_content_description" msgid="5730040700677017706">"En savoir plus sur les préférences de sous-titres"</string>
    <string name="accessibility_screen_magnification_title" msgid="1211169976144629087">"Agrandissement"</string>
    <string name="accessibility_screen_magnification_shortcut_title" msgid="2387963646377987780">"Raccourci de l\'agrandissement"</string>
    <string name="accessibility_screen_magnification_follow_typing_title" msgid="6379517513916651560">"Agrandir l\'entrée"</string>
    <string name="accessibility_screen_magnification_follow_typing_summary" msgid="2882250257391761678">"La loupe suit le texte lorsque vous tapez"</string>
    <string name="accessibility_screen_magnification_always_on_title" msgid="3738009998799304549">"Toujours activé"</string>
    <string name="accessibility_screen_magnification_always_on_summary" msgid="8946516092699010033">"Au lieu d\'être désactivé à chaque changement d\'application, l\'agrandissement est dézoomé pour revenir à la taille normale. Pincez pour zoomer de nouveau quand vous le souhaitez."</string>
    <string name="accessibility_screen_magnification_joystick_title" msgid="1803769708582404964">"Manche"</string>
    <string name="accessibility_screen_magnification_joystick_summary" msgid="4640300148573982720">"Activez et déplacez la loupe à l\'aide d\'un manche à l\'écran. Touchez et maintenez, puis faites glisser le manche pour contrôler la loupe. Touchez et faites glisser pour déplacer le manche lui-même."</string>
    <string name="accessibility_screen_magnification_about_title" msgid="8857919020223505415">"À propos de la fonctionnalité d\'agrandissement"</string>
    <string name="accessibility_screen_magnification_footer_learn_more_content_description" msgid="924848332575978463">"En savoir plus sur la fonctionnalité d\'agrandissement"</string>
    <string name="accessibility_magnification_mode_title" msgid="8446475127807168063">"Type d\'agrandissement"</string>
    <string name="accessibility_magnification_area_settings_message" msgid="8498648925928109462">"Agrandissez la totalité de votre écran, une région précise ou passez d\'une option à l\'autre"</string>
    <string name="accessibility_magnification_area_settings_full_screen_summary" msgid="2728962784113713010">"Plein écran"</string>
    <string name="accessibility_magnification_area_settings_window_screen_summary" msgid="9191632962955877019">"Une partie de l\'écran"</string>
    <string name="accessibility_magnification_area_settings_all_summary" msgid="8107511976748799455">"Passer d\'un mode à l\'autre : plein écran ou écran partiel"</string>
    <string name="accessibility_magnification_mode_dialog_title" msgid="9151027667059878578">"Choisir le mode d\'agrandissement"</string>
    <string name="accessibility_magnification_mode_dialog_option_full_screen" msgid="4892487869954032029">"Agrandir la totalité de l\'écran"</string>
    <string name="accessibility_magnification_mode_dialog_option_window" msgid="4492443201099153362">"Agrandir une partie de l\'écran"</string>
    <string name="accessibility_magnification_mode_dialog_option_switch" msgid="561043521011229424">"Passer du mode plein écran au mode écran partiel"</string>
    <string name="accessibility_magnification_area_settings_mode_switch_summary" msgid="2885238806099080966">"Touchez le bouton du commutateur pour passer d\'une option à l\'autre"</string>
    <string name="accessibility_magnification_switch_shortcut_title" msgid="3671432048806533079">"Passer au bouton d\'accessibilité?"</string>
    <string name="accessibility_magnification_switch_shortcut_message" msgid="7718653917415163833">"L\'utilisation du triple toucher pour agrandir une partie de l\'écran a pour effet de retarder l\'entrée et les autres actions.\n\nLe bouton d\'accessibilité flotte sur votre écran par-dessus les autres applications. Touchez-le pour l\'agrandir."</string>
    <string name="accessibility_magnification_switch_shortcut_positive_button" msgid="2446942190957296957">"Passer au bouton d\'accessibilité"</string>
    <string name="accessibility_magnification_switch_shortcut_negative_button" msgid="7115794462123071594">"Utiliser le triple toucher"</string>
    <string name="accessibility_magnification_triple_tap_warning_title" msgid="8484669851397296597">"Cela peut ralentir votre clavier"</string>
    <string name="accessibility_magnification_triple_tap_warning_message" msgid="2008671502848936410">"Lorsque vous touchez trois fois pour agrandir une partie de votre écran, vous remarquerez peut-être des problèmes avec le clavier.\n\nPour éviter cela, vous pouvez changer votre raccourci d\'agrandissement du toucher trois fois à une autre option.\n"<annotation id="link">"Changer le paramètre"</annotation></string>
    <string name="accessibility_magnification_triple_tap_warning_positive_button" msgid="8712304035901450010">"Continuer quand même"</string>
    <string name="accessibility_magnification_triple_tap_warning_negative_button" msgid="2028849736366584733">"Annuler"</string>
    <string name="accessibility_magnification_service_settings_title" msgid="3531350704632316017">"Paramètres d\'agrandissement"</string>
    <string name="accessibility_screen_magnification_gestures_title" msgid="3121714118381882167">"Agrandir en touchant 3 fois"</string>
    <string name="accessibility_screen_magnification_navbar_title" msgid="480853328665484528">"Agrandir avec un raccourci"</string>
    <string name="accessibility_screen_magnification_state_navbar_gesture" msgid="8067042663897802231">"Agrandir avec le raccourci et en touchant trois fois"</string>
    <string name="accessibility_introduction_title" msgid="8834950581512452348">"À propos de <xliff:g id="SERVICE">%1$s</xliff:g>"</string>
    <string name="accessibility_text_reading_options_title" msgid="3224648909213325563">"Taille d\'affichage et texte"</string>
    <string name="accessibility_text_reading_options_suggestion_title" msgid="2492155642665312733">"Modifier l\'affichage du texte"</string>
    <string name="accessibility_text_reading_preview_mail_subject" msgid="4597374768612733616">"Objet : Conceptions de ballon à air chaud"</string>
    <string name="accessibility_text_reading_preview_mail_from" msgid="1797499780365288020">"De : Bill"</string>
    <string name="accessibility_text_reading_preview_mail_content" msgid="8078152365771951802">"Bonjour!\n\nJe voulais juste vérifier l\'avancement des conceptions. Seront-elles prêtes avant que nous commencions à construire les nouveaux ballons?"</string>
    <string name="accessibility_text_reading_reset_button_title" msgid="5960753279788187669">"Réinitialiser paramètres"</string>
    <string name="accessibility_text_reading_reset_message" msgid="824644303661026712">"Les paramètres de texte et de taille d\'affichage ont été réinitialisés"</string>
    <string name="accessibility_text_reading_confirm_dialog_title" msgid="2865331351355690389">"Réinitialiser la taille d\'affichage et le texte?"</string>
    <string name="accessibility_text_reading_confirm_dialog_reset_button" msgid="8215800137850243736">"Réinitialiser"</string>
    <string name="accessibility_text_reading_conversation_message_1" msgid="7883952203831957831">"Des plans pour la fin de semaine?"</string>
    <string name="accessibility_text_reading_conversation_message_2" msgid="8112160435318635856">"Direction la plage. Tu viens?"</string>
    <string name="accessibility_screen_option" msgid="8465307075278878145">"Options"</string>
    <string name="accessibility_preference_magnification_summary" msgid="2875518904115896888">"Zoomez sur l\'écran"</string>
    <string name="accessibility_screen_magnification_short_summary" msgid="2207048420669939150">"Touchez trois fois pour zoomer vers l\'avant"</string>
    <string name="accessibility_screen_magnification_navbar_short_summary" msgid="4885018322430052037">"Touchez un bouton pour zoomer"</string>
    <string name="accessibility_screen_magnification_intro_text" msgid="3856180549393526339">"Zoomez rapidement pour agrandir le contenu"</string>
    <string name="accessibility_screen_magnification_summary" msgid="8267672508057326959">"&lt;b&gt;Pour zoomer :&lt;/b&gt;&lt;br/&gt; {0,number,integer}. Utilisez le raccourci pour commencer l\'agrandissement&lt;br/&gt; {1,number,integer}. Touchez l\'écran&lt;br/&gt; {2,number,integer}. Faites glisser deux doigts pour naviguer dans l\'écran&lt;br/&gt; {3,number,integer}. Pincez l\'écran avec deux doigts pour ajuster le zoom&lt;br/&gt; {4,number,integer}. Utilisez le raccourci pour arrêter l\'agrandissement&lt;br/&gt;&lt;br/&gt;&lt;b&gt;Pour zoomer temporairement :&lt;/b&gt;&lt;br/&gt; {0,number,integer}. Assurez-vous que le type d\'agrandissement est défini à plein écran&lt;br/&gt; {1,number,integer}. Utilisez le raccourci pour commencer l\'agrandissement&lt;br/&gt; {2,number,integer}. Maintenez le doigt sur une zone de l\'écran&lt;br/&gt; {3,number,integer}. Faites glisser un doigt pour naviguer dans l\'écran&lt;br/&gt; {4,number,integer}. Levez le doigt pour arrêter l\'agrandissement"</string>
    <string name="accessibility_screen_magnification_navbar_summary" msgid="807985499898802296">"When magnification is turned on, you can zoom in on your screen.\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 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 l\'écran"</b>", touchez le bouton d\'accessibilité, puis maintenez le doigt sur ailleurs sur l\'écran.\n"<ul><li>"Glissez votre doigt sur l\'écran à l\'endroit désiré"</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_tutorial_pager" msgid="8461939455728454061">"Page <xliff:g id="CURRENT_PAGE">%1$d</xliff:g> sur <xliff:g id="NUM_PAGES">%2$d</xliff:g>"</string>
    <string name="accessibility_tutorial_dialog_title_button" msgid="4681164949716215131">"Utiliser le bouton d\'accessibilité pour ouvrir"</string>
    <string name="accessibility_tutorial_dialog_title_volume" msgid="494810949830845234">"Maintenez les touches de volume enfoncées pour l\'ouvrir"</string>
    <string name="accessibility_tutorial_dialog_title_triple" msgid="7089562919284464400">"Touchez l\'écran trois fois pour l\'ouvrir"</string>
    <string name="accessibility_tutorial_dialog_title_gesture" msgid="4965810097646659332">"Utiliser un geste pour activer le service"</string>
    <string name="accessibility_tutorial_dialog_title_gesture_settings" msgid="6800684770875867559">"Utiliser le geste d\'accessibilité"</string>
    <string name="accessibility_tutorial_dialog_message_button" msgid="7002398857479782303">"Pour utiliser cette fonctionnalité, touchez le bouton d\'accessibilité <xliff:g id="ACCESSIBILITY_ICON">%s</xliff:g> dans le bas de l\'écran.\n\nPour basculer entre les fonctionnalités, maintenez le doigt sur le bouton d\'accessibilité."</string>
    <string name="accessibility_tutorial_dialog_message_floating_button" msgid="2551777208185138391">"Pour utiliser cette fonctionnalité, touchez le bouton d\'accessibilité sur votre écran."</string>
    <string name="accessibility_tutorial_dialog_message_volume" msgid="5033080515460519183">"Pour utiliser cette fonctionnalité, maintenez les deux touches de volume enfoncées."</string>
    <string name="accessibility_tutorial_dialog_message_triple" msgid="5219991116201165146">"Pour démarrer et arrêter l\'agrandissement, touchez l\'écran trois fois n\'importe où."</string>
    <string name="accessibility_tutorial_dialog_message_gesture" msgid="4148062210755434854">"Pour utiliser cette fonctionnalité, balayez l\'écran de bas en haut avec deux doigts.\n\nPour basculer entre les fonctionnalités, balayez l\'écran vers le haut avec deux doigts et maintenez-les-y."</string>
    <string name="accessibility_tutorial_dialog_message_gesture_talkback" msgid="8142847782708562793">"Pour utiliser cette fonctionnalité, balayez l\'écran de bas en haut avec trois doigts.\n\nPour basculer entre les fonctionnalités, balayez l\'écran vers le haut avec trois doigts et maintenez-les-y."</string>
    <string name="accessibility_tutorial_dialog_message_gesture_settings" msgid="40769674586981429">"Pour utiliser une fonctionnalité d\'accessibilité, balayez l\'écran de bas en haut avec deux doigts.\n\nPour basculer entre les fonctionnalités, balayez l\'écran vers le haut avec deux doigts et maintenez-les-y."</string>
    <string name="accessibility_tutorial_dialog_message_gesture_settings_talkback" msgid="7292969929578621958">"Pour utiliser une fonctionnalité d\'accessibilité, balayez l\'écran de bas en haut avec trois doigts.\n\nPour basculer entre les fonctionnalités, balayez l\'écran vers le haut avec trois doigts et maintenez-les-y."</string>
    <string name="accessibility_tutorial_dialog_button" msgid="2031773187678948436">"OK"</string>
    <string name="accessibility_tutorial_dialog_link_button" msgid="1624189347106713695">"Param. du bouton d\'accessibilité"</string>
    <string name="accessibility_shortcut_title" msgid="8125867833704517463">"Raccourci pour <xliff:g id="SERVICE">%1$s</xliff:g>"</string>
    <string name="accessibility_shortcut_edit_summary_software" msgid="6405629977940618205">"Bouton d\'accessibilité"</string>
    <string name="accessibility_shortcut_edit_summary_software_gesture" msgid="5489284264414421286">"Geste d\'accessibilité"</string>
    <string name="accessibility_shortcut_edit_dialog_title_software_gesture" msgid="8078659880723370597">"Balayer l\'écran vers le haut avec deux doigts"</string>
    <string name="accessibility_shortcut_edit_dialog_title_software_gesture_talkback" msgid="7422753388389160524">"Balayez l\'écran vers le haut avec trois doigts"</string>
    <string name="accessibility_shortcut_edit_dialog_title_software" msgid="4796192466943479849">"Toucher le bouton d\'accessibilité"</string>
    <string name="accessibility_shortcut_edit_dialog_title_software_by_gesture" msgid="3981188764050497346">"Utilisez le geste d\'accessibilité"</string>
    <string name="accessibility_shortcut_edit_dialog_summary_software" msgid="5606196352833449600">"Touchez le bouton d\'accessibilité <xliff:g id="ACCESSIBILITY_ICON">%s</xliff:g> dans le bas de l\'écran.\n\nPour basculer entre les fonctionnalités, maintenez le doigt sur le bouton d\'accessibilité."</string>
    <string name="accessibility_shortcut_edit_dialog_summary_software_gesture" msgid="8292555254353761635">"Balayez l\'écran de bas en haut avec deux doigts.\n\nPour basculer entre les fonctionnalités, balayez l\'écran vers le haut avec deux doigts et maintenez-les-y."</string>
    <string name="accessibility_shortcut_edit_dialog_summary_software_gesture_talkback" msgid="84483464524360845">"Balayez l\'écran de bas en haut avec trois doigts.\n\nPour basculer entre les fonctionnalités, balayez l\'écran vers le haut avec trois doigts et maintenez-les-y."</string>
    <string name="accessibility_shortcut_edit_dialog_summary_software_floating" msgid="4459254227203203324"><annotation id="link">"Autres options"</annotation></string>
    <string name="footer_learn_more_content_description" msgid="8843798273152131341">"En savoir plus sur <xliff:g id="SERVICE">%1$s</xliff:g>"</string>
    <string name="accessibility_shortcut_edit_dialog_title_hardware" msgid="2356853121810443026">"Maintenir enfoncées les touches de volume"</string>
    <string name="accessibility_shortcut_hardware_keyword" msgid="3921915304537166064">"maintenir enfoncées les touches de volume"</string>
    <string name="accessibility_shortcut_edit_dialog_summary_hardware" msgid="2503134386397991634">"Maintenez enfoncées les deux touches de volume"</string>
    <string name="accessibility_shortcut_edit_dialog_title_triple_tap" msgid="6672798007229795841">"Toucher l\'écran trois fois"</string>
    <string name="accessibility_shortcut_triple_tap_keyword" msgid="6863958573135995927">"toucher l\'écran trois fois"</string>
    <string name="accessibility_shortcut_edit_dialog_summary_triple_tap" msgid="2102327956423320536">"Touchez rapidement l\'écran {0,number,integer} fois. Ce raccourci peut ralentir votre appareil"</string>
    <string name="accessibility_shortcut_edit_dialog_title_advance" msgid="4567868630655591506">"Paramètres avancés"</string>
    <string name="accessibility_screen_magnification_navbar_configuration_warning" msgid="266736851606791552">"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="991017769735632046">"Le geste d\'accessibilité est défini pour <xliff:g id="SERVICE">%1$s</xliff:g>. Pour utiliser le zoom, balayez l\'écran de bas en haut deux avec doigts, puis maintenez-les-y. Sélectionnez ensuite Zoom."</string>
    <string name="accessibility_global_gesture_preference_title" msgid="3713636732641882959">"Raccourci touches volume"</string>
    <string name="accessibility_shortcut_settings" msgid="836783442658447995">"Paramètres du raccourci"</string>
    <string name="accessibility_shortcut_service_on_lock_screen_title" msgid="3923122834058574478">"Raccourci à l\'écran de verrouillage"</string>
    <string name="accessibility_shortcut_description" msgid="2184693606202133549">"Autorisez le raccourci à activer la fonctionnalité à l\'écran de verrouillage. Pour cela, maintenez enfoncées les deux touches de volume pendant quelques secondes."</string>
    <string name="accessibility_button_title" msgid="5251235485581552614">"Bouton d\'accessibilité"</string>
    <string name="accessibility_button_gesture_title" msgid="3573456209050374139">"Bouton d\'accessibilité et geste"</string>
    <string name="accessibility_button_intro_text" msgid="80993874471745687">"Accédez rapidement aux fonctionnalités d\'accessibilité à partir de n\'importe quel écran"</string>
    <string name="accessibility_button_about_title" msgid="3581116105084067926">"À propos du bouton d\'accessibilité"</string>
    <string name="accessibility_button_gesture_about_title" msgid="8468987303602865536">"À propos du bouton d\'accessibilité et des gestes"</string>
    <string name="accessibility_button_gesture_footer_learn_more_content_description" msgid="4144803517680297869">"En savoir plus sur le bouton d\'accessibilité et les gestes"</string>
    <string name="accessibility_button_intro" msgid="2601976470525277903">"Utilisez le bouton d\'accessibilité. Le geste n\'est pas proposé avec la navigation à trois boutons."</string>
    <string name="accessibility_button_summary" msgid="8510939012631455831">"Accès rapide aux fonctionnalités d\'accessibilité"</string>
    <string name="accessibility_button_gesture_description" msgid="7507097717493960397"><b>"Pour commencer :"</b>\n"1. Accédez aux paramètres d\'accessibilité\n2. Sélectionnez une fonctionnalité et touchez le raccourci\n3. Choisissez d\'utiliser un bouton ou un geste pour accéder à la fonctionnalité"</string>
    <string name="accessibility_button_description" msgid="1261273371298608222"><b>"Pour commencer :"</b>\n"1. Accédez aux paramètres d\'accessibilité\n2. Sélectionnez une fonctionnalité et touchez le raccourci\n3. Choisissez le bouton pour accéder à la fonctionnalité"</string>
    <string name="accessibility_button_or_gesture_title" msgid="3510075963401163529">"Utiliser le bouton ou le geste"</string>
    <string name="accessibility_button_location_title" msgid="7182107846092304942">"Position"</string>
    <string name="accessibility_button_size_title" msgid="5785110470538960881">"Taille"</string>
    <string name="accessibility_button_fade_title" msgid="8081993897680588829">"Disparaît s\'il n\'est pas utilisé"</string>
    <string name="accessibility_button_fade_summary" msgid="7865950833524973709">"Disparaît après quelques secondes, l\'écran devient donc plus facile à voir"</string>
    <string name="accessibility_button_opacity_title" msgid="4727355657530362289">"Transparent s\'il n\'est pas utilisé"</string>
    <string name="accessibility_button_low_label" msgid="4193015407828927741">"Transparent"</string>
    <string name="accessibility_button_high_label" msgid="9138077512008190896">"Opaque"</string>
    <string name="accessibility_toggle_high_text_contrast_preference_title" msgid="1830189632458752698">"Texte de contraste élevé"</string>
    <string name="accessibility_toggle_high_text_contrast_preference_summary" msgid="5286411556836346180">"Changez la couleur du texte en noir ou en blanc. Cela aide à maximiser le contraste avec l\'arrière-plan."</string>
    <string name="accessibility_toggle_screen_magnification_auto_update_preference_title" msgid="4987009529235165664">"Mise à jour auto de la loupe"</string>
    <string name="accessibility_toggle_screen_magnification_auto_update_preference_summary" msgid="9034532513972547720">"Mettre à jour la loupe si transition entre applis"</string>
    <string name="accessibility_power_button_ends_call_prerefence_title" msgid="8187306131979612144">"Interrupteur pour raccrocher"</string>
    <string name="accessibility_toggle_large_pointer_icon_title" msgid="5508351959249876801">"Grand curseur de souris"</string>
    <string name="accessibility_toggle_large_pointer_icon_summary" msgid="1480527946039237705">"Mettez en évidence le pointeur de la souris"</string>
    <string name="accessibility_disable_animations" msgid="2993529829457179058">"Supprimer les animations"</string>
    <string name="accessibility_disable_animations_summary" msgid="5828228669556554565">"Réduisez les mouvements sur l\'écran"</string>
    <string name="accessibility_toggle_primary_mono_title" msgid="7587152099472946571">"Audio mono"</string>
    <string name="accessibility_toggle_primary_mono_summary" msgid="1935283927319407303">"Combiner les chaînes lors de la lecture audio"</string>
    <string name="accessibility_toggle_primary_balance_title" msgid="7332275200153366714">"Équilibre sonore"</string>
    <string name="accessibility_toggle_primary_balance_left_label" msgid="6415750010517682014">"Gauche"</string>
    <string name="accessibility_toggle_primary_balance_right_label" msgid="2987443495390104935">"Droite"</string>
    <string name="accessibility_timeout_default" msgid="1033702739376842824">"Par défaut"</string>
    <string name="accessibility_timeout_10secs" msgid="5072577454521239794">"10 secondes"</string>
    <string name="accessibility_timeout_30secs" msgid="7814673496724760684">"30 secondes"</string>
    <string name="accessibility_timeout_1min" msgid="4804644263166961262">"1 minute"</string>
    <string name="accessibility_timeout_2mins" msgid="7901692984522708679">"2 minutes"</string>
    <string name="accessibility_setting_item_control_timeout_title" msgid="1600516937989217899">"Délai pour eff. une action (accessibilité)"</string>
    <string name="accessibility_control_timeout_about_title" msgid="813588002683460837">"À propos du délai pour effectuer une action (accessibilité)"</string>
    <string name="accessibility_control_timeout_footer_learn_more_content_description" msgid="8118584413220542193">"En savoir plus sur le délai pour effectuer une action (accessibilité)"</string>
    <string name="accessibility_control_timeout_preference_title" msgid="1443940538597464758">"Temps pour réagir"</string>
    <string name="accessibility_control_timeout_preference_summary" msgid="4037051091059316310">"Cette préférence du temps d\'affichage n\'est pas prise en charge par toutes les applications"</string>
    <string name="accessibility_control_timeout_preference_intro_text" msgid="1398116710556762245">"Choisissez la durée d\'affichage des messages temporaires qui vous demandent d\'effectuer une action"</string>
    <string name="accessibility_long_press_timeout_preference_title" msgid="5237764682976688855">"Délai de pression"</string>
    <string name="accessibility_display_inversion_preference_title" msgid="5476133104746207952">"Inversion des couleurs"</string>
    <string name="accessibility_display_inversion_switch_title" msgid="7458595722552743503">"Utiliser l\'inversion des couleurs"</string>
    <string name="accessibility_display_inversion_shortcut_title" msgid="6889624526691513462">"Raccourci de l\'inversion des couleurs"</string>
    <string name="accessibility_display_inversion_preference_intro_text" msgid="1159663288481145318">"L\'inversion des couleurs assombrit les écrans lumineux. Elle illumine également les écrans sombres."</string>
    <string name="accessibility_display_inversion_preference_subtitle" msgid="4494767676482389509">"&lt;b&gt;N\'oubliez pas&lt;/b&gt;&lt;br/&gt; &lt;ol&gt; &lt;li&gt; Les couleurs changeront dans les fichiers multimédias et les images.&lt;/li&gt; &lt;li&gt; L\'inversion des couleurs fonctionne sur toutes les applications.&lt;/li&gt; &lt;li&gt; Le thème sombre peut être utilisé pour afficher un arrière-plan sombre.&lt;/li&gt; &lt;/ol&gt;"</string>
    <string name="accessibility_autoclick_preference_title" msgid="2703143361605555752">"Clic automatique (temps d\'arrêt)"</string>
    <string name="accessibility_autoclick_about_title" msgid="152923024405552594">"Clic automatique (temps d\'arrêt)"</string>
    <string name="accessibility_autoclick_footer_learn_more_content_description" msgid="7056189627042350691">"En savoir plus sur le clic automatique (temps d\'arrêt)"</string>
    <string name="accessibility_autoclick_intro_text" msgid="8959680635470639347">"Vous pouvez configurer une souris connectée pour qu\'elle clique automatiquement lorsque le curseur s\'immobilise pendant un certain temps"</string>
    <string name="accessibility_autoclick_description" msgid="6695732131412361101">"Le clic automatique peut être utile lorsqu\'il est difficile de cliquer avec la souris"</string>
    <string name="accessibility_autoclick_default_title" msgid="2024730028293793490">"Clic automatique désactivé"</string>
    <string name="accessibility_autoclick_short_title" msgid="7938302504358912984">"Court"</string>
    <string name="accessibility_autoclick_short_summary" msgid="4106953930081213514">"0,2 seconde"</string>
    <string name="accessibility_autoclick_medium_title" msgid="3134175117576834320">"Moyen"</string>
    <string name="accessibility_autoclick_medium_summary" msgid="1343390686514222871">"0,6 seconde"</string>
    <string name="accessibility_autoclick_long_title" msgid="6799311820641687735">"Long"</string>
    <string name="accessibility_autoclick_long_summary" msgid="3747153151313563637">"1 seconde"</string>
    <string name="accessibility_autoclick_custom_title" msgid="4597792235546232038">"Personnalisé"</string>
    <string name="accessibility_autoclick_shorter_desc" msgid="7631013255724544348">"Plus court"</string>
    <string name="accessibility_autoclick_longer_desc" msgid="2566025502981487443">"Plus long"</string>
    <string name="accessibility_autoclick_seekbar_desc" msgid="8363959277814621118">"Durée du clic automatique"</string>
    <string name="accessibility_vibration_settings_title" msgid="936301142478631993">"Vibrations et rétroactions haptiques"</string>
    <string name="accessibility_vibration_settings_summary" msgid="3690308537483465527">"Contrôler la force des vibrations pour différentes utilisations"</string>
    <string name="accessibility_vibration_settings_state_on" msgid="5566026932372832502">"Activées"</string>
    <string name="accessibility_vibration_settings_state_off" msgid="7946588741954981703">"Désactivées"</string>
    <string name="accessibility_vibration_setting_disabled_for_silent_mode_summary" msgid="3982701772953323190">"Le paramètre est désactivé parce que l\'appareil est en mode silencieux"</string>
    <string name="accessibility_call_vibration_category_title" msgid="2545607568768192318">"Appels"</string>
    <string name="accessibility_notification_alarm_vibration_category_title" msgid="2683635252414849417">"Notifications et alarmes"</string>
    <string name="accessibility_interactive_haptics_category_title" msgid="3162855291184592021">"Rétroactions haptiques interactives"</string>
    <string name="accessibility_vibration_primary_switch_title" msgid="6162579254864450592">"Utiliser les vibrations et les rétroactions haptiques"</string>
    <string name="accessibility_alarm_vibration_title" msgid="4661294337828522745">"Vibrations d\'alarme"</string>
    <string name="accessibility_media_vibration_title" msgid="1372073715403945428">"Vibration multimédia"</string>
    <string name="accessibility_ring_vibration_title" msgid="4689811297654320885">"Vibration pour la sonnerie"</string>
    <string name="accessibility_notification_vibration_title" msgid="6205679908785776478">"Vibration pour les notifications"</string>
    <string name="accessibility_touch_vibration_title" msgid="533931451319110741">"Retour tactile"</string>
    <string name="accessibility_service_primary_switch_title" msgid="437610853412159406">"Utiliser <xliff:g id="ACCESSIBILITY_APP_NAME">%1$s</xliff:g>"</string>
    <string name="accessibility_service_primary_open_title" msgid="8655108684769091154">"Ouvrir <xliff:g id="ACCESSIBILITY_APP_NAME">%1$s</xliff:g>"</string>
    <string name="accessibility_service_auto_added_qs_tooltip_content" msgid="2941824314912928072">"L\'application <xliff:g id="ACCESSIBILITY_APP_NAME">%1$s</xliff:g> a été ajoutée aux Paramètres rapides. Balayez vers le bas pour l\'activer ou la désactiver à tout moment."</string>
    <string name="accessibility_service_qs_tooltip_content" msgid="6002493441414967868">"Vous pouvez également ajouter <xliff:g id="ACCESSIBILITY_APP_NAME">%1$s</xliff:g> aux Paramètres rapides à partir du haut de votre écran"</string>
    <string name="accessibility_color_correction_auto_added_qs_tooltip_content" msgid="9092661358437404374">"La fonctionnalité de correction des couleurs a été ajoutée aux Paramètres rapides. Balayez vers le bas pour l\'activer ou la désactiver à tout moment."</string>
    <string name="accessibility_color_correction_qs_tooltip_content" msgid="3258628434235475205">"Vous pouvez également ajouter la fonctionnalité de correction des couleurs aux Paramètres rapides à partir du haut de votre écran"</string>
    <string name="accessibility_color_inversion_auto_added_qs_tooltip_content" msgid="7267618234972101725">"La fonctionnalité d\'inversion des couleurs a été ajoutée aux Paramètres rapides. Balayez vers le bas pour l\'activer ou la désactiver à tout moment."</string>
    <string name="accessibility_color_inversion_qs_tooltip_content" msgid="5046332142185711869">"Vous pouvez également ajouter la fonctionnalité d\'inversion des couleurs aux Paramètres rapides à partir du haut de votre écran"</string>
    <string name="accessibility_reduce_bright_colors_auto_added_qs_tooltip_content" msgid="1906588335786328512">"La fonctionnalité de réduction supplémentaire de la luminosité a été ajoutée aux Paramètres rapides. Balayez vers le bas pour l\'activer ou la désactiver à tout moment."</string>
    <string name="accessibility_reduce_bright_colors_qs_tooltip_content" msgid="7522121299176176785">"Vous pouvez également ajouter la fonctionnalité de réduction supplémentaire de la luminosité aux Paramètres rapides à partir du haut de votre écran"</string>
    <string name="accessibility_one_handed_mode_auto_added_qs_tooltip_content" msgid="7914554254280416532">"Le mode Une main a été ajouté aux Paramètres rapides. Balayez vers le bas pour l\'activer ou le désactiver à tout moment."</string>
    <string name="accessibility_one_handed_mode_qs_tooltip_content" msgid="2754332083184384603">"Vous pouvez également ajouter le mode Une main aux Paramètres rapides à partir du haut de votre écran"</string>
    <!-- no translation found for accessibility_font_scaling_auto_added_qs_tooltip_content (7229921960884718332) -->
    <skip />
    <string name="accessibility_quick_settings_tooltip_dismiss" msgid="3269120277643884190">"Fermer"</string>
    <string name="accessibility_daltonizer_primary_switch_title" msgid="32064721588910540">"Utiliser la correction des couleurs"</string>
    <string name="accessibility_daltonizer_shortcut_title" msgid="7480360363995502369">"Raccourci de la correction des couleurs"</string>
    <string name="accessibility_daltonizer_about_title" msgid="6063650804116981287">"À propos de la correction des couleurs"</string>
    <string name="accessibility_daltonizer_footer_learn_more_content_description" msgid="2091679253892040910">"En savoir plus sur la correction des couleurs"</string>
    <string name="accessibility_color_inversion_about_title" msgid="8275754480247040136">"À propos de l\'inversion des couleurs"</string>
    <string name="accessibility_color_inversion_footer_learn_more_content_description" msgid="5382579548498952445">"En savoir plus sur l\'inversion des couleurs"</string>
    <string name="accessibility_captioning_primary_switch_title" msgid="3663677340286206100">"Afficher les sous-titres"</string>
    <string name="accessibility_captioning_primary_switch_summary" msgid="2544094070306830218">"Pour l\'application prise en charge seulement"</string>
    <string name="captioning_appearance_title" msgid="3128792092290011408">"Taille et style des sous-titres"</string>
    <string name="captioning_appearance_summary" msgid="4620682807315588019">"Taille du texte : <xliff:g id="ACCESSIBILITY_FONT_SIZE">%1$s</xliff:g>"</string>
    <string name="captioning_more_options_title" msgid="3484496882942539652">"Autres options"</string>
    <string name="accessibility_captioning_preference_intro" msgid="8995427146374031134">"Personnalisez la taille et le style des sous-titres pour les rendre plus faciles à lire"</string>
    <string name="accessibility_captioning_preference_summary" msgid="8335768472978374255">"Ces préférences de sous-titres ne sont pas prises en charge par toutes les applications multimédias"</string>
    <string name="accessibility_shortcut_type_software" msgid="2552732582767687515">"bouton d\'accessibilité"</string>
    <string name="accessibility_shortcut_type_software_gesture" msgid="5608959693931019059">"Balayer l\'écran du bas vers le haut avec deux doigts"</string>
    <string name="accessibility_shortcut_type_hardware" msgid="4834144210432451916">"Maintenir enfoncées les touches de volume"</string>
    <string name="accessibility_shortcut_type_triple_tap" msgid="7717524216825494543">"Toucher l\'écran trois fois"</string>
    <string name="accessibility_hearingaid_instruction_continue_button" msgid="3367260988024430722">"Continuer"</string>
    <string name="accessibility_hearingaid_title" msgid="1263619711863375614">"Appareils auditifs"</string>
    <string name="accessibility_hearingaid_intro" msgid="5856992709195963850">"Vous pouvez utiliser des prothèses auditives, des implants cochléaires et d\'autres appareils d\'amplification avec votre téléphone"</string>
    <string name="accessibility_hearingaid_not_connected_summary" msgid="3371427366765435743">"Aucune prothèse auditive connectée"</string>
    <string name="accessibility_hearingaid_adding_summary" msgid="999051610528600783">"Ajouter des prothèses auditives"</string>
    <string name="accessibility_hearingaid_pair_instructions_title" msgid="2357706801112207624">"Associer prothèses audit."</string>
    <string name="accessibility_hearingaid_pair_instructions_message" msgid="581652489109350119">"À l\'écran suivant, sélectionnez vos prothèses auditives. Vous devrez peut-être associer les oreilles gauche et droite séparément.\n\nAssurez-vous que vos prothèses auditives sont activées et prêtes à être associées."</string>
    <string name="accessibility_hearingaid_active_device_summary" msgid="509703438222873967">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g> est actif"</string>
    <string name="accessibility_hearingaid_left_side_device_summary" msgid="1907302799168261001">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g>, gauche seulement"</string>
    <string name="accessibility_hearingaid_right_side_device_summary" msgid="148257064855054376">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g>, droite seulement"</string>
    <string name="accessibility_hearingaid_left_and_right_side_device_summary" msgid="4268221140368164452">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g>, gauche et droite"</string>
    <string name="accessibility_hearingaid_more_device_summary" msgid="8092641784056942546">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g> +1 autre"</string>
    <string name="accessibility_hearing_device_pairing_title" msgid="2701812183769537320">"Associer un appareil"</string>
    <string name="accessibility_pair_hearing_device_about_title" msgid="5870335480815052755">"À propos de l\'association d\'un nouvel appareil"</string>
    <string name="accessibility_hearing_device_connected_title" msgid="3785140037249487287">"Appareils auditifs"</string>
    <string name="accessibility_hearing_device_saved_title" msgid="7573926212664909296">"Appareils consignés"</string>
    <string name="accessibility_hearing_device_control" msgid="2661965917013100611">"Commandes de l\'appareil auditif"</string>
    <string name="accessibility_hearing_device_shortcut_title" msgid="7645100199603031360">"Raccourci pour appareils auditifs"</string>
    <string name="accessibility_hac_mode_title" msgid="2037950424429555652">"Compatibilité : prothèses auditives"</string>
    <string name="accessibility_hac_mode_summary" msgid="5198760061256669067">"Améliore la compatibilité avec les phonocapteurs et réduit les bruits indésirables"</string>
    <string name="accessibility_hearing_device_about_title" msgid="7883758309646288250">"À propos des appareils auditifs"</string>
    <string name="accessibility_hearing_device_footer_summary" msgid="7451899224828040581">"Assurez-vous que votre appareil auditif est allumé et prêt à être associé"</string>
    <string name="accessibility_hearing_device_pairing_page_title" msgid="6608901091770850295">"Associer appareil auditif"</string>
    <string name="accessibility_found_hearing_devices" msgid="637407580358386553">"Appareils auditifs accessibles"</string>
    <string name="accessibility_found_all_devices" msgid="7817834722148556520">"Vous ne voyez pas votre appareil auditif?"</string>
    <string name="accessibility_list_all_devices_title" msgid="161495343959211216">"Afficher d\'autres appareils"</string>
    <string name="accessibility_audio_adjustment_title" msgid="1332113739136802997">"Ajustement audio"</string>
    <string name="accessibility_toggle_audio_description_preference_title" msgid="8916473886256061220">"Audiodescription"</string>
    <string name="accessibility_audio_description_summary" msgid="2554789094873781056">"Écoutez une description de ce qui se passe à l\'écran dans les émissions et les films pris en charge"</string>
    <string name="keywords_audio_description" msgid="6202816411593281252">"audiodescription, audio, description, vision faible,"</string>
    <string name="accessibility_summary_shortcut_enabled" msgid="4030427268146752644">"Raccourci activé"</string>
    <string name="accessibility_summary_shortcut_disabled" msgid="564005462092499068">"Désactivé"</string>
    <string name="accessibility_summary_state_enabled" msgid="1065431632216039369">"Activé"</string>
    <string name="accessibility_summary_state_disabled" msgid="9173234532752799694">"Désactivé"</string>
    <string name="accessibility_summary_state_stopped" msgid="2343602489802623424">"Ne fonctionne pas. Touchez l\'écran pour obtenir plus d\'information."</string>
    <string name="accessibility_description_state_stopped" msgid="5364752492861199133">"Ce service est défectueux."</string>
    <string name="accessibility_shortcuts_settings_title" msgid="974740249671825145">"Raccourcis d\'accessibilité"</string>
    <string name="enable_quick_setting" msgid="6648073323202243604">"Afficher dans la fenêtre de configuration rapide"</string>
    <string name="daltonizer_mode_deuteranomaly_title" msgid="4210949400493358650">"Rouge-vert"</string>
    <string name="daltonizer_mode_protanomaly_title" msgid="6392456967103014723">"Rouge-vert"</string>
    <string name="daltonizer_mode_tritanomaly_title" msgid="2278786218762602022">"Bleu-jaune"</string>
    <string name="daltonizer_mode_grayscale_title" msgid="152005391387952588">"Nuances de gris"</string>
    <string name="daltonizer_mode_deuteranomaly_summary" msgid="2117727423019598455">"Vert faible, deutéranomalie"</string>
    <string name="daltonizer_mode_protanomaly_summary" msgid="4617032854982040748">"Rouge faible, protanomalie"</string>
    <string name="daltonizer_mode_tritanomaly_summary" msgid="2428218320118180070">"Tritanomalie"</string>
    <string name="reduce_bright_colors_preference_title" msgid="2249314004651574997">"Très sombre"</string>
    <string name="reduce_bright_colors_switch_title" msgid="1751678397884065312">"Activer la réduction suppl. de la luminosité"</string>
    <string name="reduce_bright_colors_shortcut_title" msgid="495648157059202745">"Raccourci de la réduction supplémentaire de la luminosité"</string>
    <string name="reduce_bright_colors_about_title" msgid="503655452544934393">"Réduction supplémentaire de la luminosité"</string>
    <string name="reduce_bright_colors_preference_intro_text" msgid="3502290826747650566">"Réduisez la luminosité de votre écran pour qu\'il soit plus facile à lire"</string>
    <string name="reduce_bright_colors_intensity_preference_title" msgid="7455443033955118267">"Intensité"</string>
    <string name="reduce_bright_colors_intensity_start_label" msgid="930387498396426039">"Diminuer"</string>
    <string name="reduce_bright_colors_intensity_end_label" msgid="1422600205484299860">"Augmenter"</string>
    <string name="reduce_bright_colors_persist_preference_title" msgid="4368829654993343354">"Laisser activé après le redémarrage de l\'appareil"</string>
    <string name="accessibilty_autoclick_preference_subtitle_short_delay" msgid="2981206111858937724">"{count,plural, =1{Court ({time} seconde)}one{Court ({time} seconde)}other{Court ({time} secondes)}}"</string>
    <string name="accessibilty_autoclick_preference_subtitle_medium_delay" msgid="6867395206533459204">"{count,plural, =1{Moyen ({time} seconde)}one{Moyen ({time} seconde)}other{Moyen ({time} secondes)}}"</string>
    <string name="accessibilty_autoclick_preference_subtitle_long_delay" msgid="4079139970819335593">"{count,plural, =1{Long ({time} seconde)}one{Long ({time} seconde)}other{Long ({time} secondes)}}"</string>
    <string name="accessibilty_autoclick_delay_unit_second" msgid="5979297390686370567">"{count,plural, =1{{time} seconde}one{{time} seconde}other{{time} secondes}}"</string>
    <string name="accessibility_menu_item_settings" msgid="2652637954865389271">"Paramètres"</string>
    <string name="accessibility_feature_state_on" msgid="1777344331063467511">"Activée"</string>
    <string name="accessibility_feature_state_off" msgid="169119895905460512">"Désactivée"</string>
    <string name="captioning_preview_title" msgid="2888561631323180535">"Aperçu"</string>
    <string name="captioning_standard_options_title" msgid="5360264497750980205">"Options standards"</string>
    <string name="captioning_locale" msgid="5533303294290661590">"Langue"</string>
    <string name="captioning_text_size" msgid="8039448543171463017">"Taille de la police"</string>
    <string name="captioning_preset" msgid="4174276086501638524">"Style de sous-titres"</string>
    <string name="captioning_custom_options_title" msgid="3858866498893566351">"Options de personnalisation"</string>
    <string name="captioning_background_color" msgid="5231412761368883107">"Couleur de l\'arrière-plan"</string>
    <string name="captioning_background_opacity" msgid="6453738649182382614">"Opacité du fond"</string>
    <string name="captioning_window_color" msgid="1406167274530183119">"Couleur de la zone de sous-titres"</string>
    <string name="captioning_window_opacity" msgid="4031752812991199525">"Opacité de la zone de sous-titres"</string>
    <string name="captioning_foreground_color" msgid="9057327228286129232">"Couleur du texte"</string>
    <string name="captioning_foreground_opacity" msgid="1395843080697567189">"Opacité du texte"</string>
    <string name="captioning_edge_color" msgid="6035818279902597518">"Couleur de la bordure"</string>
    <string name="captioning_edge_type" msgid="5281259280060811506">"Type de bordure"</string>
    <string name="captioning_typeface" msgid="285325623518361407">"Famille de polices"</string>
    <string name="captioning_preview_text" msgid="4973475065545995704">"Les sous-titres ressembleront à ceci"</string>
    <string name="captioning_preview_characters" msgid="7854812443613580460">"Aa"</string>
    <string name="locale_default" msgid="8948077172250925164">"Par défaut"</string>
    <string name="color_title" msgid="2511586788643787427">"Couleur"</string>
    <string name="color_unspecified" msgid="4102176222255378320">"Par défaut"</string>
    <string name="color_none" msgid="3703632796520710651">"Aucune"</string>
    <string name="color_white" msgid="1896703263492828323">"Blanc"</string>
    <string name="color_gray" msgid="8554077329905747877">"Gris"</string>
    <string name="color_black" msgid="9006830401670410387">"Noir"</string>
    <string name="color_red" msgid="5210756997426500693">"Rouge"</string>
    <string name="color_green" msgid="4400462091250882271">"Vert"</string>
    <string name="color_blue" msgid="4997784644979140261">"Bleu"</string>
    <string name="color_cyan" msgid="4341758639597035927">"Cyan"</string>
    <string name="color_yellow" msgid="5957551912912679058">"Jaune"</string>
    <string name="color_magenta" msgid="8943538189219528423">"Magenta"</string>
    <string name="enable_service_title" msgid="7231533866953706788">"Permettre à <xliff:g id="SERVICE">%1$s</xliff:g> de contrôler complètement votre appareil?"</string>
    <string name="capabilities_list_title" msgid="1225853611983394386">"<xliff:g id="SERVICE">%1$s</xliff:g> doit pouvoir :"</string>
    <string name="touch_filtered_warning" msgid="4225815157460318241">"Une application obscurcit une demande d\'autorisation, alors Paramètres ne peut pas vérifier votre réponse."</string>
    <string name="accessibility_service_warning" msgid="6779187188736432618">"<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="6573203795976134751">"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="324795030658109870">"Afficher et contrôler l\'écran"</string>
    <string name="accessibility_service_screen_control_description" msgid="8431940515157990426">"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="1449360056585337833">"Afficher et effectuer des actions"</string>
    <string name="accessibility_service_action_perform_description" msgid="7807832069800034738">"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="8274918676473216697">"Autoriser"</string>
    <string name="accessibility_dialog_button_deny" msgid="2037249860078259284">"Refuser"</string>
    <string name="accessibility_dialog_button_stop" msgid="7295448112784528196">"Arrêter"</string>
    <string name="accessibility_dialog_button_cancel" msgid="4813234247237851121">"Annuler"</string>
    <string name="disable_service_title" msgid="2909108731776956167">"Arrêter <xliff:g id="SERVICE">%1$s</xliff:g>?"</string>
    <string name="disable_service_message" msgid="4814173941688548016">"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="3725569493860028593">"Aucun service installé"</string>
    <string name="accessibility_no_service_selected" msgid="1310596127128379897">"Aucun service sélectionné"</string>
    <string name="accessibility_service_default_description" msgid="7801435825448138526">"Aucune description fournie"</string>
    <string name="settings_button" msgid="2195468788019730377">"Paramètres"</string>
    <string name="keywords_reduce_bright_colors" msgid="1683190961013139183">"sensibilité à la lumière, photophobie, thème sombre, migraine, mal de tête, mode lecture, mode nuit, réduire la luminosité, point blanc"</string>
    <string name="keywords_accessibility" msgid="4263443239404659143">"Convivialité, facilité d\'accès, assistance, accessibilité"</string>
    <string name="keywords_magnification" msgid="3908145308269840862">"Agrandisseur d\'écran, zoom, agrandissement, vision faible, agrandir, rendre plus gros"</string>
    <string name="keywords_talkback" msgid="2816435437095102527"></string>
    <string name="keywords_live_caption" msgid="1667203998080567556">"Sous-titres, sous-titrage, CC, sous-titres instantanés, malentendant, perte auditive, transcription en temps réel assistée par ordinateur, synthèse textuelle, sous-titrer"</string>
    <string name="keywords_live_transcribe" msgid="3226990195174890997"></string>
    <string name="keywords_sound_notifications" msgid="8183107485754075413"></string>
    <string name="keywords_sound_amplifier" msgid="939404835256246663"></string>
    <string name="keywords_display_size" msgid="5286419615221231518">"taille de l\'écran, grand écran"</string>
    <string name="keywords_bold_text" msgid="6257418169207099589">"Contraste élevé, vision faible, police grasse, caractères gras"</string>
    <string name="keywords_select_to_speak" msgid="2872704811610888719"></string>
    <string name="keywords_color_correction" msgid="8540442886990423681">"ajuster la couleur"</string>
    <string name="keywords_color_inversion" msgid="4291058365873221962">"assombrir l\'écran, éclaircir l\'écran"</string>
    <string name="keywords_accessibility_menu" msgid="4300579436464706608"></string>
    <string name="keywords_switch_access" msgid="5813094504384313402"></string>
    <string name="keywords_auto_click" msgid="7151756353013736931">"motricité, souris"</string>
    <string name="keywords_hearing_aids" msgid="4550504337687223314">"prothèses auditives, malentendants, perte auditive, implants cochléaires, appareils d\'amplification, processeurs de son"</string>
    <string name="keywords_rtt" msgid="2429130928152514402">"malentendant, perte auditive, sous-titres, téléimprimeur, ATS"</string>
    <string name="keywords_voice_access" msgid="7807335263195876454"></string>
    <string name="print_settings" msgid="8519810615863882491">"Impression"</string>
    <string name="print_settings_summary_no_service" msgid="6721731154917653862">"Désactivé"</string>
    <string name="print_settings_summary" msgid="1458773840720811915">"{count,plural, =1{1 service d\'impression activé}one{# service d\'impression activé}other{# services d\'impression activés}}"</string>
    <string name="print_jobs_summary" msgid="7040836482336577323">"{count,plural, =1{1 tâche d\'impression}one{# tâche d\'impression}other{# tâches d\'impression}}"</string>
    <string name="print_settings_title" msgid="7680498284751129935">"Services d\'impression"</string>
    <string name="print_no_services_installed" msgid="7554057966540602692">"Aucun service installé"</string>
    <string name="print_no_printers_found" msgid="4833082484646109486">"Aucune imprimante trouvée"</string>
    <string name="print_menu_item_settings" msgid="8202755044784599740">"Paramètres"</string>
    <string name="print_menu_item_add_printers" msgid="7958192149202584039">"Ajouter des imprimantes"</string>
    <string name="print_feature_state_on" msgid="7132063461008624685">"Activé"</string>
    <string name="print_feature_state_off" msgid="1466195699995209446">"Désactivé"</string>
    <string name="print_menu_item_add_service" msgid="1549091062463044676">"Ajouter un service"</string>
    <string name="print_menu_item_add_printer" msgid="8711630848324870892">"Ajouter une imprimante"</string>
    <string name="print_menu_item_search" msgid="5989979785203603169">"Rechercher"</string>
    <string name="print_searching_for_printers" msgid="5401413178028348800">"Recherche d\'imprimantes en cours..."</string>
    <string name="print_service_disabled" msgid="9185935228930987786">"Service désactivé"</string>
    <string name="print_print_jobs" msgid="2605944855933091183">"Tâches d\'impression"</string>
    <string name="print_print_job" msgid="8477859161886726608">"Tâches d\'impression"</string>
    <string name="print_restart" msgid="4424096106141083945">"Redémarrer"</string>
    <string name="print_cancel" msgid="7611266511967568501">"Annuler"</string>
    <string name="print_job_summary" msgid="277210060872032969">"<xliff:g id="PRINTER">%1$s</xliff:g>\n<xliff:g id="TIME">%2$s</xliff:g>"</string>
    <string name="print_configuring_state_title_template" msgid="2887013172492183045">"Configuration de <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_printing_state_title_template" msgid="7367513245156603431">"Impression de <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g> en cours…"</string>
    <string name="print_cancelling_state_title_template" msgid="9094795458159980190">"Annulation de « <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g> »…"</string>
    <string name="print_failed_state_title_template" msgid="4751695809935404505">"Erreur d\'impression : <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_blocked_state_title_template" msgid="3134100215188411074">"<xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g> bloquée par l\'imprimante"</string>
    <string name="print_search_box_shown_utterance" msgid="6215002365360341961">"Champ de recherche affiché"</string>
    <string name="print_search_box_hidden_utterance" msgid="5355387966141712567">"Champ de recherche masqué"</string>
    <string name="printer_info_desc" msgid="1206872325746154206">"Plus d\'information sur cette imprimante"</string>
    <string name="power_usage_summary_title" msgid="4198312848584882113">"Pile"</string>
    <string name="power_usage_summary" msgid="6857382582534984531">"Répartition·de·l\'utilisation·de·la·batterie"</string>
    <string name="power_usage_level_and_status" msgid="821521456989429593">"<xliff:g id="LEVEL">%1$s</xliff:g> – <xliff:g id="STATUS">%2$s</xliff:g>"</string>
    <string name="power_discharge_remaining" msgid="6997529817917076536">"Temps restant : <xliff:g id="REMAIN">%1$s</xliff:g>"</string>
    <string name="power_charge_remaining" msgid="7046064326172265116">"<xliff:g id="UNTIL_CHARGED">%1$s</xliff:g> avant le chargement complet"</string>
    <string name="low_battery_summary" msgid="4458925347316501953">"Pile faible"</string>
    <string name="background_activity_summary" msgid="3817376868497046016">"Autoriser l\'application à fonctionner en arrière-plan"</string>
    <string name="background_activity_warning_dialog_title" msgid="3449566823290744823">"Limiter l\'activité en arrière-plan?"</string>
    <string name="background_activity_warning_dialog_text" msgid="8202776985767701095">"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="4053170297325882494">"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="manager_battery_usage_unrestricted_title" msgid="2426486290463258032">"Aucune restriction"</string>
    <string name="manager_battery_usage_optimized_title" msgid="8080765739761921817">"Optimisée"</string>
    <string name="manager_battery_usage_restricted_title" msgid="7702863764130323118">"Limitée"</string>
    <string name="manager_battery_usage_unrestricted_summary" msgid="6819279865465667692">"Autoriser l\'utilisation de la pile en arrière-plan sans restrictions. Cela pourrait solliciter davantage la pile."</string>
    <string name="manager_battery_usage_optimized_summary" msgid="1332545476428039900">"Optimiser en fonction de votre usage. Ce réglage est recommandé pour la plupart des applications."</string>
    <string name="manager_battery_usage_restricted_summary" msgid="8324695640704416905">"Restreindre l\'utilisation de la pile lors du fonctionnement en arrière-plan. L\'application pourrait ne pas fonctionner comme prévu. Les notifications pourraient être retardées."</string>
    <string name="manager_battery_usage_footer" msgid="2635906573922553766">"La modification de la manière dont une application utilise la pile peut avoir une incidence sur ses performances."</string>
    <string name="manager_battery_usage_footer_limited" msgid="5180776148877306780">"Cette application nécessite une utilisation <xliff:g id="STATE">%1$s</xliff:g> de la pile."</string>
    <string name="manager_battery_usage_unrestricted_only" msgid="3646162131339418216">"aucune restriction"</string>
    <string name="manager_battery_usage_optimized_only" msgid="7121785281913056432">"optimisée"</string>
    <string name="manager_battery_usage_link_a11y" msgid="374918091821438564">"En savoir plus à propos des options d\'utilisation de la pile"</string>
    <string name="device_screen_usage" msgid="1011630249648289909">"Utilisation de l\'écran depuis la charge complète"</string>
    <string name="advanced_battery_title" msgid="3005993394776555079">"Utilisation de la pile"</string>
    <string name="history_details_title" msgid="8628584613889559355">"Détails de l\'historique"</string>
    <string name="advanced_battery_preference_title" msgid="3790901207877260883">"Utilisation de la pile"</string>
    <string name="advanced_battery_preference_summary_with_hours" msgid="954091349133320955">"Voir utilisation des dernières 24 heures"</string>
    <string name="advanced_battery_preference_summary" msgid="2372763700477268393">"Utilisation depuis la charge complète"</string>
    <string name="battery_details_title" msgid="3289680399291090588">"Utilisation de la pile par les applications"</string>
    <string name="details_subtitle" msgid="2550872569652785527">"Détails d\'utilisation"</string>
    <string name="controls_subtitle" msgid="3759606830916441564">"Ajuster la consommation"</string>
    <string name="packages_subtitle" msgid="8687690644931499428">"Modules inclus"</string>
    <string name="battery_tip_summary_title" msgid="321127485145626939">"Les applications fonctionnent normalement"</string>
    <string name="battery_tip_low_battery_title" msgid="4155239078744100997">"Pile faible"</string>
    <string name="battery_tip_low_battery_summary" msgid="2629633757244297436">"Activez l\'économiseur de pile pour prolonger l\'autonomie de la pile"</string>
    <string name="battery_tip_smart_battery_title" msgid="8925025450214912325">"Améliorer l\'autonomie de la pile"</string>
    <string name="battery_tip_smart_battery_summary" msgid="3592965553502362965">"Activer le gestionnaire de pile"</string>
    <string name="battery_tip_early_heads_up_title" msgid="4411387863476629452">"Activer l\'économiseur de pile"</string>
    <string name="battery_tip_early_heads_up_summary" msgid="578523794827443977">"La pile pourrait s\'épuiser plus tôt que d\'habitude"</string>
    <string name="battery_tip_early_heads_up_done_title" msgid="7705597228709143337">"Économiseur de pile activé"</string>
    <string name="battery_saver_link_a11y" msgid="740558184830458845">"En savoir plus à propos de l\'économiseur de pile"</string>
    <string name="battery_tip_early_heads_up_done_summary" msgid="7858923105760361208">"Certaines fonctionnalités pourraient être limitées"</string>
    <string name="battery_tip_high_usage_title" msgid="9110720762506146697">"Utilisation plus élevée de la pile"</string>
    <string name="battery_tip_high_usage_summary" msgid="3938999581403084551">"Affichez les applications qui utilisent le plus d\'énergie"</string>
    <string name="battery_tip_limited_temporarily_title" msgid="6258554134146272311">"La recharge est optimisée afin de protéger votre pile"</string>
    <string name="battery_tip_limited_temporarily_summary" msgid="6836981984725209843">"La recharge est optimisée afin de prolonger la durée de vie de votre pile"</string>
    <string name="battery_tip_dock_defender_future_bypass_title" msgid="4332616280495788195">"La recharge est optimisée afin de protéger votre pile"</string>
    <string name="battery_tip_dock_defender_future_bypass_summary" msgid="7870758621381307597">"La recharge est optimisée lorsque l\'appareil est dans sa station afin de prolonger la durée de vie de votre pile"</string>
    <string name="battery_tip_dock_defender_active_title" msgid="1414785238383255699">"La recharge est optimisée afin de protéger votre pile"</string>
    <string name="battery_tip_dock_defender_active_summary" msgid="3512082623718801459">"La recharge est optimisée lorsque l\'appareil est dans sa station afin de prolonger la durée de vie de votre pile"</string>
    <string name="battery_tip_dock_defender_temporarily_bypassed_title" msgid="1679449361090557201">"En charge complète"</string>
    <string name="battery_tip_dock_defender_temporarily_bypassed_summary" msgid="1099500476761333281">"Afin de protéger votre pile, la recharge sera optimisée la prochaine fois que votre tablette sera placée dans sa station"</string>
    <string name="battery_tip_limited_temporarily_sec_button_content_description" msgid="5648444926736883551">"En savoir sur l\'interruption de la recharge"</string>
    <string name="battery_tip_limited_temporarily_dialog_resume_charge" msgid="2302295458913832342">"Reprendre la charge"</string>
    <string name="battery_tip_dialog_message_footer" msgid="986542164372177504">"Inclut les activités énergivores en arrière-plan"</string>
    <string name="battery_tip_restrict_title" msgid="4537101947310626753">"{count,plural, =1{Limiter # application}one{Limiter # application}other{Limiter # applications}}"</string>
    <string name="battery_tip_restrict_handled_title" msgid="7142074986508706853">"{count,plural, =1{{label} récemment limitée}one{# application récemment limitée}other{# applications récemment limitées}}"</string>
    <string name="battery_tip_restrict_summary" msgid="7539469590829235277">"{count,plural, =1{{label} consomme beaucoup d\'énergie en arrière-plan}one{# application consomme beaucoup d\'énergie en arrière-plan}other{# applications consomment beaucoup d\'énergie en arrière-plan}}"</string>
    <string name="battery_tip_restrict_handled_summary" msgid="3535697154547199190">"{count,plural, =1{Cette application ne peut pas fonctionner en arrière-plan}one{Cette application ne peut pas fonctionner en arrière-plan}other{Ces applications ne peuvent pas fonctionner en arrière-plan}}"</string>
    <string name="battery_tip_restrict_app_dialog_title" msgid="1649476357343160240">"{count,plural, =1{Limiter l\'application?}one{Limiter # application?}other{Limiter # applications?}}"</string>
    <string name="battery_tip_restrict_app_dialog_message" msgid="137856003724730751">"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="5894648804112181324">"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="4546838397423565138">"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="7025027696689301916">"Restreindre"</string>
    <string name="battery_tip_unrestrict_app_dialog_title" msgid="5501997201160532301">"Supprimer la restriction?"</string>
    <string name="battery_tip_unrestrict_app_dialog_message" msgid="215449637818582819">"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="7940183167721998470">"Supprimer"</string>
    <string name="battery_tip_unrestrict_app_dialog_cancel" msgid="4968135709160207507">"Annuler"</string>
    <string name="battery_tip_charge_to_full_button" msgid="6701709034348116261">"Recharger complètement"</string>
    <string name="battery_tip_incompatible_charging_title" msgid="5120763575150751300">"Problème concernant l\'accessoire de recharge"</string>
    <string name="battery_tip_incompatible_charging_content_description" msgid="355668467640367701">"En savoir plus sur les chargeurs incompatibles"</string>
    <string name="smart_battery_manager_title" msgid="3677620516657920364">"Gestionnaire de pile"</string>
    <string name="smart_battery_title" msgid="9095903608520254254">"Gérer les applications automatiquement"</string>
    <string name="smart_battery_footer" msgid="8407121907452993645">"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="6585080822121007436">"Applications restreintes"</string>
    <string name="restricted_app_summary" msgid="1022307922754893997">"{count,plural, =1{L\'utilisation de la pile est limitée pour # application}one{L\'utilisation de la pile est limitée pour # application}other{L\'utilisation de la pile est limitée pour # applications}}"</string>
    <string name="restricted_app_time_summary" msgid="3097721884155913252">"Application restreinte : <xliff:g id="TIME">%1$s</xliff:g>"</string>
    <string name="restricted_app_detail_footer" msgid="3495725286882138803">"Ces applications sont limitées à l\'utilisation de la pile en arrière-plan. Il se peut qu\'elles ne fonctionnent pas comme prévu et que les notifications soient retardées."</string>
    <string name="battery_auto_restriction_title" msgid="827206218118093357">"Utiliser le gestionnaire de pile"</string>
    <string name="battery_auto_restriction_summary" msgid="2140896101984815711">"Détecter quand les applications drainent la pile"</string>
    <string name="battery_manager_summary" msgid="255708681438809287">"Détecter quand les applications sollicitent beaucoup la pile"</string>
    <string name="battery_manager_summary_unsupported" msgid="7334173707292807964">"Détecter quand les applications sollicitent beaucoup la pile"</string>
    <string name="battery_manager_app_restricted" msgid="2583902700677009173">"{count,plural, =1{# application limitée}one{# application limitée}other{# applications limitées}}"</string>
    <string name="battery_header_title_alternate" msgid="8371821625994616659">"<xliff:g id="NUMBER">^1</xliff:g>"<small>" "<font size="20">"<xliff:g id="UNIT">%</xliff:g>"</font></small>""</string>
    <string name="battery_missing_message" msgid="400958471814422770">"Un problème est survenu lors de la lecture du niveau de charge de la pile."</string>
    <string name="battery_missing_link_message" msgid="6021565067124898074"></string>
    <string name="battery_missing_link_a11y_message" msgid="3310971406602316323">"Touchez pour en savoir plus à propos de cette erreur"</string>
    <string name="power_screen" msgid="3926703168513988776">"Écran"</string>
    <string name="power_cpu" msgid="1820472721627148746">"Processeur"</string>
    <string name="power_flashlight" msgid="8993388636332573202">"Lampe de poche"</string>
    <string name="power_camera" msgid="4778315081581293923">"Appareil photo"</string>
    <string name="power_gps" msgid="6352380895542498164">"GPS"</string>
    <string name="power_wifi" msgid="4614007837288250325">"Wi-Fi"</string>
    <string name="power_bluetooth" msgid="5085900180846238196">"Bluetooth"</string>
    <string name="power_cell" msgid="7793805106954398186">"Réseau cellulaire"</string>
    <string name="power_phone" msgid="2768396619208561670">"Appels vocaux"</string>
    <string name="battery_screen_usage" msgid="90008745183187461">"Utilisation de l\'écran : <xliff:g id="TIME">^1</xliff:g>"</string>
    <string name="battery_used_by" msgid="6457305178016189330">"<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="8940140259734182014">"<xliff:g id="PERCENT">%1$s</xliff:g> de l\'utilisation totale de la pile"</string>
    <string name="battery_detail_since_full_charge" msgid="5650946565524184582">"Répartition depuis la dernière charge complète"</string>
    <string name="battery_last_full_charge" msgid="8308424441475063956">"Dernière charge complète"</string>
    <string name="battery_full_charge_last" msgid="465146408601016923">"La charge complète dure environ"</string>
    <!-- no translation found for battery_footer_summary (6753248007004259000) -->
    <skip />
    <string name="battery_detail_power_usage" msgid="1492926471397355477">"Utilisation de la pile"</string>
    <string name="battery_not_usage" msgid="3851536644733662392">"Aucune utilisation depuis la dernière recharge complète"</string>
    <string name="battery_not_usage_24hr" msgid="8397519536160741248">"Aucune utilisation au cours des dernières 24 heures"</string>
    <string name="battery_usage_without_time" msgid="1346894834339420538"></string>
    <string name="battery_usage_since_last_full_charge" msgid="3488425008925924769">"depuis la dernière recharge complète"</string>
    <string name="battery_usage_system_apps" msgid="8659537819731575299">"Applications système"</string>
    <string name="battery_usage_others" msgid="311793281613609986">"Autres"</string>
    <string name="estimated_time_left" msgid="948717045180211777">"Temps restant estimé"</string>
    <string name="estimated_charging_time_left" msgid="2287135413363961246">"Jusqu\'à la charge complète"</string>
    <string name="estimated_time_description" msgid="211058785418596009">"La durée estimée peut changer en fonction de l\'utilisation"</string>
    <string name="process_mediaserver_label" msgid="6135260215912215092">"Serveur multimédia"</string>
    <string name="process_dex2oat_label" msgid="1190208677726583153">"Optimisation des applications"</string>
    <string name="process_network_tethering" msgid="6822671758152900766">"Partage de connexion"</string>
    <string name="process_removed_apps" msgid="6544406592678476902">"Applications retirées"</string>
    <string name="battery_saver" msgid="7737147344510595864">"Économiseur de pile"</string>
    <string name="battery_saver_auto_title" msgid="6789753787070176144">"Activer automatiquement"</string>
    <string name="battery_saver_auto_no_schedule" msgid="5123639867350138893">"Aucun horaire"</string>
    <string name="battery_saver_auto_routine" msgid="4656495097900848608">"Selon votre routine"</string>
    <string name="battery_saver_pref_auto_routine_summary" msgid="4739240095966241508">"S\'activera en fonction de votre routine"</string>
    <string name="battery_saver_auto_percentage" msgid="558533724806281980">"Selon le pourcentage"</string>
    <string name="battery_saver_auto_routine_summary" msgid="3913145448299472628">"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="6190884450723824287">"S\'active lorsque la pile atteint <xliff:g id="PERCENT">%1$s</xliff:g>"</string>
    <string name="battery_saver_schedule_settings_title" msgid="3688019979950082237">"Configurer un horaire"</string>
    <string name="battery_saver_turn_on_summary" msgid="1433919417587171160">"Prolongez l\'autonomie de la pile"</string>
    <string name="battery_saver_sticky_title_new" msgid="5942813274115684599">"Désactiver lorsque l\'appareil est chargé"</string>
    <string name="battery_saver_sticky_title_percentage" msgid="1178162022087559148">"Désactiver à <xliff:g id="BATTERY_PERCENTAGE">%1$s</xliff:g>"</string>
    <string name="battery_saver_sticky_description_new" msgid="6472610662679038342">"L\'économiseur de pile se désactive lorsque le niveau de la pile atteint <xliff:g id="BATTERY_PERCENTAGE">%1$s</xliff:g>"</string>
    <!-- no translation found for battery_saver_seekbar_title (3712266470054006641) -->
    <skip />
    <string name="battery_saver_seekbar_title_placeholder" msgid="7141264642540687540">"Activer"</string>
    <string name="battery_saver_master_switch_title" msgid="3474312070095834915">"Utiliser l\'économiseur de pile"</string>
    <string name="battery_saver_turn_on_automatically_title" msgid="7857393318205740864">"Activer automatiquement"</string>
    <string name="battery_saver_turn_on_automatically_never" msgid="6194649389871448663">"Jamais"</string>
    <string name="battery_saver_turn_on_automatically_pct" msgid="4294335680892392449">"à <xliff:g id="PERCENT">%1$s</xliff:g> d\'autonomie restante"</string>
    <string name="battery_percentage" msgid="1779934245963043490">"Pourcentage de charge de la pile"</string>
    <string name="battery_percentage_description" msgid="2321465139126125541">"Afficher le pourcentage de charge de la pile dans la barre d\'état"</string>
    <string name="battery_usage_chart_graph_hint_last_full_charge" msgid="6570336408060566877">"Niveau de la pile depuis la dernière recharge complète"</string>
    <string name="battery_usage_chart_graph_hint" msgid="9182079098173323005">"Niveau de la pile, dernières 24 h"</string>
    <string name="battery_app_usage" msgid="8976453608783133770">"Utilisation des applications depuis la dernière charge complète"</string>
    <string name="battery_app_usage_for_past_24" msgid="1234770810563940656">"Utilisation par application, dernières 24 h"</string>
    <string name="battery_system_usage" msgid="1395943945140097585">"Utilisation du système depuis la dernière recharge complète"</string>
    <string name="battery_system_usage_for_past_24" msgid="3341520273114616263">"Utilisation par le système, dernières 24 h"</string>
    <string name="battery_system_usage_for" msgid="3248552137819897140">"Utilisation par le système : <xliff:g id="SLOT">%s</xliff:g>"</string>
    <string name="battery_app_usage_for" msgid="7309909074935858949">"Utilisation par l\'application : <xliff:g id="SLOT">%s</xliff:g>"</string>
    <string name="battery_usage_total_less_than_one_minute" msgid="1035425863251685509">"Total : moins d\'une minute"</string>
    <string name="battery_usage_background_less_than_one_minute" msgid="3957971442554437909">"Arrière-plan : moins d\'une minute"</string>
    <string name="battery_usage_screen_time_less_than_one_minute" msgid="2911989465891679033">"Temps d\'utilisation des écrans : moins d\'une minute"</string>
    <string name="battery_usage_for_total_time" msgid="8402254046930910905">"Total : <xliff:g id="TIME">%s</xliff:g>"</string>
    <string name="battery_usage_for_background_time" msgid="9109637210617095188">"Arrière-plan : <xliff:g id="TIME">%s</xliff:g>"</string>
    <string name="battery_usage_screen_time" msgid="3973865893520804115">"Temps d\'utilisation des écrans : <xliff:g id="TIME">%s</xliff:g>"</string>
    <string name="battery_usage_screen_footer_empty" msgid="3301144846133808193">"Les données d\'utilisation de la pile seront accessibles dans quelques heures, une fois pleinement chargée"</string>
    <string name="battery_usage_chart_label_now" msgid="4598282721949430165">"maintenant"</string>
    <string name="battery_usage_timestamps_hyphen" msgid="7401188432989043905">"<xliff:g id="FROM_TIMESTAMP">%1$s</xliff:g> – <xliff:g id="TO_TIMESTAMP">%2$s</xliff:g>"</string>
    <string name="battery_usage_day_and_hour" msgid="1417890420844950881">"<xliff:g id="DAY">%1$s</xliff:g> <xliff:g id="HOUR">%2$s</xliff:g>⁠"</string>
    <string name="battery_usage_chart" msgid="4114747521432440017">"Graphique d\'utilisation de la pile"</string>
    <string name="daily_battery_usage_chart" msgid="4176059567682992686">"Graphique de l\'utilisation quotidienne de la pile"</string>
    <string name="hourly_battery_usage_chart" msgid="3098314511076561272">"Graphique de l\'utilisation horaire de la pile"</string>
    <string name="battery_usage_breakdown_title_since_last_full_charge" msgid="435006273323199906">"Utilisation de la pile depuis la dernière recharge complète"</string>
    <string name="battery_usage_breakdown_title_for_slot" msgid="4823179483667671406">"Utilisation de la pile : <xliff:g id="SLOT">%s</xliff:g>"</string>
    <string name="screen_time_category_last_full_charge" msgid="8856908320256057753">"Temps d\'utilisation des écrans depuis la dernière recharge complète"</string>
    <string name="screen_time_category_for_slot" msgid="8287722270554654959">"Temps d\'utilisation des écrans pour <xliff:g id="SLOT">%s</xliff:g>"</string>
    <string name="battery_usage_spinner_breakdown_by_apps" msgid="7746337368402445072">"Répartition par application"</string>
    <string name="battery_usage_spinner_breakdown_by_system" msgid="4646952798665973464">"Répartition par système"</string>
    <string name="battery_usage_less_than_percent" msgid="5873099028895001082">"&lt; <xliff:g id="PERCENTAGE">%1$s</xliff:g>"</string>
    <string name="process_stats_summary_title" msgid="502683176231281732">"Statistiques des processus"</string>
    <string name="process_stats_summary" msgid="522842188571764699">"Statistiques détaillées sur les processus en cours d\'exécution"</string>
    <string name="app_memory_use" msgid="7559666138324410666">"Mémoire utilisée"</string>
    <string name="process_stats_total_duration" msgid="3898635541254636618">"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="4391502694312709148">"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="4094034441562453522">"Arrière-plan"</string>
    <string name="process_stats_type_foreground" msgid="5043049335546793803">"Avant-plan"</string>
    <string name="process_stats_type_cached" msgid="129788969589599563">"En cache"</string>
    <string name="process_stats_os_label" msgid="2096501347732184886">"Système d\'exploitation Android"</string>
    <string name="process_stats_os_native" msgid="794547105037548539">"Natif"</string>
    <string name="process_stats_os_kernel" msgid="5626269994512354996">"Noyau"</string>
    <string name="process_stats_os_zram" msgid="3067278664868354143">"Z-RAM"</string>
    <string name="process_stats_os_cache" msgid="4753163023524305711">"Caches"</string>
    <string name="process_stats_ram_use" msgid="5966645638783509937">"Utilisation de mémoire vive"</string>
    <string name="process_stats_bg_ram_use" msgid="3572439697306771461">"Utilisation de mémoire vive (en arrière-plan)"</string>
    <string name="process_stats_run_time" msgid="8631920944819076418">"Durée d\'exécution"</string>
    <string name="processes_subtitle" msgid="5791138718719605724">"Processus"</string>
    <string name="services_subtitle" msgid="9136741140730524046">"Services"</string>
    <string name="menu_proc_stats_duration" msgid="1249684566371309908">"Durée"</string>
    <string name="mem_details_title" msgid="8064756349669711949">"Détails de la mémoire"</string>
    <string name="menu_duration_3h" msgid="9202635114831885878">"3 heures"</string>
    <string name="menu_duration_6h" msgid="2843895006519153126">"6 heures"</string>
    <string name="menu_duration_12h" msgid="9206922888181602565">"12 heures"</string>
    <string name="menu_duration_1d" msgid="8538390358158862330">"1 jour"</string>
    <string name="menu_show_system" msgid="3780310384799907818">"Afficher le système"</string>
    <string name="menu_hide_system" msgid="5197937451381420622">"Masquer les processus système"</string>
    <string name="menu_show_percentage" msgid="6143205879027928330">"Afficher les pourcentages"</string>
    <string name="menu_use_uss" msgid="1663914348353623749">"Utiliser USS"</string>
    <string name="menu_proc_stats_type" msgid="5048575824389855689">"Type de statistiques"</string>
    <string name="menu_proc_stats_type_background" msgid="6796434633192284607">"Arrière-plan"</string>
    <string name="menu_proc_stats_type_foreground" msgid="9011432748521890803">"Avant-plan"</string>
    <string name="menu_proc_stats_type_cached" msgid="1351321959600144622">"En cache"</string>
    <string name="voice_input_output_settings" msgid="1055497319048272051">"Saisie et sortie vocales"</string>
    <string name="voice_input_output_settings_title" msgid="6449454483955543064">"Paramètres de saisie et de sortie vocales"</string>
    <string name="voice_search_settings_title" msgid="228743187532160069">"Recherche vocale"</string>
    <string name="keyboard_settings_title" msgid="2199286020368890114">"Clavier Android"</string>
    <string name="voice_input_settings" msgid="105821652985768064">"Paramètres d\'entrée vocale"</string>
    <string name="voice_input_settings_title" msgid="3708147270767296322">"Entrée vocale"</string>
    <string name="voice_service_preference_section_title" msgid="4807795449147187497">"Services d\'entrée vocale"</string>
    <string name="voice_interactor_preference_summary" msgid="3942881638813452880">"Détection de mot clé et interaction totales"</string>
    <string name="voice_recognizer_preference_summary" msgid="9195427725367463336">"Synthèse vocale simple"</string>
    <string name="voice_interaction_security_warning" msgid="7962884055885987671">"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="on_device_recognition_settings" msgid="6503160369314598069">"Paramètres de reconnaissance sur l\'appareil"</string>
    <string name="on_device_recognition_settings_title" msgid="7137599722039096545">"Reconnaissance sur l\'appareil"</string>
    <string name="on_device_recognition_settings_summary" msgid="3292736423223499348">"Reconnaissance vocale sur l\'appareil"</string>
    <string name="tts_engine_preference_title" msgid="7808775764174571132">"Moteur préféré"</string>
    <string name="tts_engine_settings_title" msgid="1298093555056321577">"Paramètres du moteur"</string>
    <string name="tts_sliders_title" msgid="6901146958648426181">"Cadence et ton"</string>
    <string name="tts_engine_section_title" msgid="5115035218089228451">"Moteur"</string>
    <string name="tts_install_voice_title" msgid="5133545696447933812">"Voix"</string>
    <string name="tts_spoken_language" msgid="4652894245474520872">"Langue parlée"</string>
    <string name="tts_install_voices_title" msgid="6505257816336165782">"installer des voix"</string>
    <string name="tts_install_voices_text" msgid="902408506519246362">"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="919034855418197668">"Ouvrir l\'application"</string>
    <string name="tts_install_voices_cancel" msgid="5179154684379560628">"Annuler"</string>
    <string name="tts_reset" msgid="9047681050813970031">"Réinitialiser"</string>
    <string name="tts_play" msgid="2945513377250757221">"Lire"</string>
    <string name="vpn_settings_title" msgid="9131315656202257272">"RPV"</string>
    <string name="vpn_settings_insecure_single" msgid="9012504179995045195">"Non sécurisé"</string>
    <string name="vpn_settings_single_insecure_multiple_total" msgid="6107225844641301139">"<xliff:g id="VPN_COUNT">%d</xliff:g> non sécurisé"</string>
    <string name="vpn_settings_multiple_insecure_multiple_total" msgid="1706236062478680488">"<xliff:g id="VPN_COUNT">%d</xliff:g> non sécurisés"</string>
    <string name="adaptive_connectivity_title" msgid="7464959640138428192">"Connectivité adaptative"</string>
    <string name="adaptive_connectivity_summary" msgid="3648731530666326885">"Prolonge l\'autonomie de la pile et améliore la performance de l\'appareil en gérant automatiquement vos connexions réseau"</string>
    <string name="adaptive_connectivity_switch_on" msgid="3653067561620745493">"Activée"</string>
    <string name="adaptive_connectivity_switch_off" msgid="5076172560836115265">"Désactivé"</string>
    <string name="adaptive_connectivity_main_switch_title" msgid="261045483524512420">"Utiliser la connectivité adaptative"</string>
    <string name="credentials_title" msgid="7535942196886123656">"Stockage des authentifiants"</string>
    <string name="credentials_install" msgid="3933218407598415827">"Installer un certificat"</string>
    <string name="credentials_reset" msgid="4246628389366452655">"Effacer les authentifiants"</string>
    <string name="credentials_reset_summary" msgid="5400585520572874255">"Supprimer tous les certificats"</string>
    <string name="trusted_credentials" msgid="2522784976058244683">"Certificats de confiance"</string>
    <string name="trusted_credentials_summary" msgid="345822338358409468">"Afficher les certificats d\'autorité de confiance"</string>
    <string name="user_credentials" msgid="4044405430790970775">"Authentifiants d\'utilisateur"</string>
    <string name="user_credentials_summary" msgid="686471637627271856">"Afficher et modifier les authentifiants stockés"</string>
    <string name="advanced_security_title" msgid="7117581975877192652">"Paramètres avancés"</string>
    <string name="credentials_settings_not_available" msgid="7433088409177429600">"Les authentifiants ne sont pas accessibles pour cet utilisateur"</string>
    <string name="credential_for_vpn_and_apps" msgid="2208229692860871136">"Installé pour le RPV et les applications"</string>
    <string name="credential_for_wifi" msgid="2286560570630763556">"Installé pour le Wi-Fi"</string>
    <string name="credential_for_wifi_in_use" msgid="7276290656840986618">"Installé pour le Wi-Fi (en cours d\'utilisation)"</string>
    <string name="credentials_reset_hint" msgid="4054601857203464867">"Supprimer l\'intégralité du contenu?"</string>
    <string name="credentials_erased" msgid="9121052044566053345">"Les authentifiants sont effacés."</string>
    <string name="credentials_not_erased" msgid="3611058412683184031">"Impossible eff. stockage authentifiants."</string>
    <string name="usage_access_title" msgid="1580006124578134850">"Applis avec accès données"</string>
    <string name="ca_certificate" msgid="3076484307693855611">"Certificat CA"</string>
    <string name="user_certificate" msgid="6897024598058566466">"Certif. RPV et d\'appli de l\'util."</string>
    <string name="wifi_certificate" msgid="8461905432409380387">"Certificat Wi‑Fi"</string>
    <string name="ca_certificate_warning_title" msgid="7951148441028692619">"Vos données ne seront pas privées"</string>
    <string name="ca_certificate_warning_description" msgid="8409850109551028774">"Les certificats CA sont employés par les sites Web, les applications et les RPV pour assurer le chiffrement. Installez uniquement les certificats CA provenant d\'organisations en qui vous avez confiance. \n\nSi vous installez un certificat CA, son propriétaire pourrait accéder à vos données, comme vos mots de passe ou vos renseignements de cartes de crédit, provenant de sites Web que vous visitez ou d\'applications que vous utilisez, même si ces données sont chiffrées."</string>
    <string name="certificate_warning_dont_install" msgid="3794366420884560605">"Ne pas installer"</string>
    <string name="certificate_warning_install_anyway" msgid="4633118283407228740">"Installer quand même"</string>
    <string name="cert_not_installed" msgid="6725137773549974522">"Certificat non installé"</string>
    <string name="request_manage_credentials_title" msgid="596805634568013413">"Autoriser "<b>"<xliff:g id="APP_NAME">^1</xliff:g>"</b>" à installer des certificats sur cet appareil?"</string>
    <string name="request_manage_credentials_description" msgid="8044839857171509619">"Ces certificats vous vérifieront en partageant l\'identifiant unique de votre appareil avec les applications et les URL ci-dessous"</string>
    <string name="request_manage_credentials_dont_allow" msgid="3630610197644877809">"Ne pas autoriser"</string>
    <string name="request_manage_credentials_allow" msgid="4910940118408348245">"Autoriser"</string>
    <string name="request_manage_credentials_more" msgid="6101210283534101582">"Afficher plus d\'options"</string>
    <string name="certificate_management_app" msgid="8086699498358080826">"Appli de gest. de certificats"</string>
    <string name="no_certificate_management_app" msgid="3025739370424406717">"Aucune"</string>
    <string name="certificate_management_app_description" msgid="8507306554200869005">"Des certificats vous vérifieront lorsque vous utiliserez les applications et les URL ci-dessous"</string>
    <string name="uninstall_certs_credential_management_app" msgid="4945883254446077354">"Désinstaller les certificats"</string>
    <string name="remove_credential_management_app" msgid="6089291496976812786">"Retirer l\'application"</string>
    <string name="remove_credential_management_app_dialog_title" msgid="5713525435104706772">"Retirer cette application?"</string>
    <string name="remove_credential_management_app_dialog_message" msgid="7739474298063646935">"Cette application ne gérera pas les certificats, mais elle restera sur votre appareil. Tout certificat installé par l\'application sera désinstallé."</string>
    <string name="number_of_urls" msgid="1128699121050872188">"{count,plural, =1{# URL}one{# URL}other{# URL}}"</string>
    <string name="emergency_tone_title" msgid="6673118505206685168">"Signal de composition d\'urgence"</string>
    <string name="emergency_tone_summary" msgid="2519776254708767388">"Définir le comportement en cas d\'appel d\'urgence"</string>
    <string name="privacy_settings_title" msgid="6437057228255974577">"Sauvegarde"</string>
    <string name="backup_summary_state_on" msgid="9018954639693085240">"Activée"</string>
    <string name="backup_summary_state_off" msgid="5341339397224835909">"Désactivé"</string>
    <string name="backup_section_title" msgid="6539706829848457794">"Sauvegarde et restauration"</string>
    <string name="personal_data_section_title" msgid="6368610168625722682">"Données personnelles"</string>
    <string name="backup_data_title" msgid="507663517227498525">"Sauvegarder mes données"</string>
    <string name="backup_data_summary" msgid="8054551085241427531">"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="8574055186903658842">"Compte de sauvegarde"</string>
    <string name="backup_data_management_title" msgid="6596830198441939702">"Gérer le compte de sauvegarde"</string>
    <string name="include_app_data_title" msgid="2969603876620594523">"Inclure données applications"</string>
    <string name="auto_restore_title" msgid="4124345897936637561">"Restauration automatique"</string>
    <string name="auto_restore_summary" msgid="6830198851045584001">"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="6753265378043349277">"Le service de sauvegarde n\'est pas actif"</string>
    <string name="backup_configure_account_default_summary" msgid="5323225330966306690">"Actuellement, aucun compte n\'enregistre de données de sauvegarde"</string>
    <string name="backup_erase_dialog_title" msgid="5892431263348766484"></string>
    <string name="backup_erase_dialog_message" msgid="2250872501409574331">"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="2379053988557486162">"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="971587401251601473">"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="31392408594557070">"Paramètres d\'administration de l\'appareil"</string>
    <string name="active_device_admin_msg" msgid="7744106305636543184">"Appli d\'administration de l\'appareil"</string>
    <string name="remove_device_admin" msgid="3143059558744287259">"Désactiver cette application d\'administration d\'appareil"</string>
    <string name="uninstall_device_admin" msgid="4481095209503956916">"Désinstaller l\'application"</string>
    <string name="remove_and_uninstall_device_admin" msgid="707912012681691559">"Désactiver et désinstaller"</string>
    <string name="select_device_admin_msg" msgid="5501360309040114486">"Applications d\'administration d\'appareils"</string>
    <string name="no_device_admins" msgid="8888779888103079854">"Il n\'y a aucune application d\'administration d\'appareil"</string>
    <string name="no_trust_agents" msgid="8659098725864191600">"Aucun agent de confiance disponible"</string>
    <string name="add_device_admin_msg" msgid="7730006568970042119">"Activer l\'appli d\'admin de l\'appareil?"</string>
    <string name="add_device_admin" msgid="6252128813507932519">"Activer l\'application d\'administration de l\'appareil"</string>
    <string name="device_admin_add_title" msgid="6087481040932322289">"Administrateur de l\'appareil"</string>
    <string name="device_admin_warning" msgid="1889160106787280321">"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="2715756519899116115">"Cet appareil sera géré et surveillé par <xliff:g id="APP_NAME">%1$s</xliff:g>."</string>
    <string name="device_admin_status" msgid="6332571781623084064">"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="2774489881662331549">"Activer le gestionnaire de profil?"</string>
    <string name="profile_owner_add_title_simplified" msgid="2320828996993774182">"Autoriser la supervision?"</string>
    <string name="adding_profile_owner_warning" msgid="6868275476058020513">"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="8122039047419172139">"D\'autres options sont désactivées par votre administrateur"</string>
    <string name="admin_more_details" msgid="4928985331640193758">"En savoir plus"</string>
    <string name="notification_log_title" msgid="2812594935014664891">"Journal des notifications"</string>
    <string name="notification_history_title" msgid="8821060912502593309">"Historique des notifications"</string>
    <string name="notification_history_today" msgid="6081829638548808795">"Dernières %d heures"</string>
    <string name="notification_history_snooze" msgid="3980568893290512257">"Reportées"</string>
    <string name="notification_history_dismiss" msgid="6180321217375722918">"Récemment ignorées"</string>
    <string name="notification_history_count" msgid="885305572972482838">"{count,plural, =1{# notification}one{# notification}other{# notifications}}"</string>
    <string name="sound_category_call_ringtone_vibrate_title" msgid="9090693401915654528">"Sonnerie et vibreur pour les appels"</string>
    <string name="wifi_setup_detail" msgid="2012898800571616422">"Infos sur le réseau"</string>
    <string name="accessibility_sync_enabled" msgid="5308864640407050209">"Synchronisation activée"</string>
    <string name="accessibility_sync_disabled" msgid="5507600126380593611">"Synchronisation désactivée"</string>
    <string name="accessibility_sync_in_progress" msgid="3229428197779196660">"Synchronisation en cours…"</string>
    <string name="accessibility_sync_error" msgid="7248490045013170437">"Erreur de synchronisation."</string>
    <string name="sync_failed" msgid="3806495232114684984">"Échec de la synchronisation"</string>
    <string name="sync_active" msgid="5787407579281739975">"Synchronisation activée"</string>
    <string name="account_sync_settings_title" msgid="2684888109902800966">"Synchroniser"</string>
    <string name="sync_is_failing" msgid="6738004111400633331">"La synchronisation rencontre actuellement des problèmes. Elle sera rétablie sous peu."</string>
    <string name="add_account_label" msgid="7134707140831385869">"Ajouter un compte"</string>
    <string name="managed_profile_not_available_label" msgid="7500578232182547365">"Le profil professionnel n\'est pas encore disponible"</string>
    <string name="work_mode_label" msgid="1001415270126064436">"Profil professionnel"</string>
    <string name="work_mode_on_summary" msgid="2042885311126239961">"Géré par votre organisation"</string>
    <string name="work_mode_off_summary" msgid="4044568753909036134">"Les applications et les notifications sont désactivées"</string>
    <string name="remove_managed_profile_label" msgid="1294933737673830431">"Supprimer le profil professionnel"</string>
    <string name="background_data" msgid="321903213000101158">"Données en arrière-plan"</string>
    <string name="background_data_summary" msgid="6572245922513522466">"Synchronisation, envoi et réception de données à tout moment"</string>
    <string name="background_data_dialog_title" msgid="1692005302993229867">"Dés. données arr.-plan?"</string>
    <string name="background_data_dialog_message" msgid="7760280837612824670">"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_enabled" msgid="5794103781356455043">"Synchronisation activée"</string>
    <string name="sync_disabled" msgid="1636223106968593391">"Synchronisation désactivée"</string>
    <string name="sync_error" msgid="846923369794727644">"Erreur de synchronisation"</string>
    <string name="last_synced" msgid="1527008461298110443">"Dernière synchronisation : <xliff:g id="LAST_SYNC_TIME">%1$s</xliff:g>"</string>
    <string name="sync_in_progress" msgid="6200093151211458977">"Synchronisation en cours…"</string>
    <string name="settings_backup" msgid="5357973563989458049">"Sauvegarder les paramètres"</string>
    <string name="settings_backup_summary" msgid="6803046376335724034">"Sauvegarder mes paramètres"</string>
    <string name="sync_menu_sync_now" msgid="3948443642329221882">"Synchroniser"</string>
    <string name="sync_menu_sync_cancel" msgid="2422994461106269813">"Annuler la synchronisation"</string>
    <string name="sync_one_time_sync" msgid="8114337154112057462">"Touchez ici pour lancer la synchronisation<xliff:g id="LAST_SYNC_TIME">
%1$s</xliff:g>"</string>
    <string name="sync_gmail" msgid="228561698646018808">"Gmail"</string>
    <string name="sync_calendar" msgid="4603704438090387251">"# CALENDAR:"</string>
    <string name="sync_contacts" msgid="2376465611511325472">"Contacts"</string>
    <string name="header_application_sync_settings" msgid="7427706834875419243">"Paramètres de synchronisation de l\'application"</string>
    <string name="header_data_and_synchronization" msgid="453920312552838939">"Données et synchronisation"</string>
    <string name="preference_change_password_title" msgid="5465821666939825972">"Modifier le mot de passe"</string>
    <string name="header_account_settings" msgid="1189339410278750008">"Paramètres de compte"</string>
    <string name="remove_account_label" msgid="4169490568375358010">"Retirer le compte"</string>
    <string name="header_add_an_account" msgid="3919151542338822661">"Ajouter un compte"</string>
    <string name="really_remove_account_title" msgid="253097435885652310">"Retirer le compte?"</string>
    <string name="remove_account_failed" msgid="3709502163548900644">"Cette modification n\'est pas autorisée par votre administrateur"</string>
    <string name="cant_sync_dialog_title" msgid="2613000568881139517">"Impossible de procéder à la synchronisation manuelle."</string>
    <string name="cant_sync_dialog_message" msgid="7612557105054568581">"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="delete" msgid="8330605554706263775">"Supprimer"</string>
    <string name="select_all" msgid="7898929601615536401">"Tout sélectionner"</string>
    <string name="data_usage_summary_title" msgid="394067070764360142">"Utilisation de données"</string>
    <string name="data_usage_app_summary_title" msgid="4933742247928064178">"Données cellulaires et Wi-Fi"</string>
    <string name="account_settings_menu_auto_sync_personal" msgid="2905595464540145671">"Synchro auto des données perso"</string>
    <string name="account_settings_menu_auto_sync_work" msgid="8561102487795657789">"Synchro auto des données pros"</string>
    <string name="data_usage_change_cycle" msgid="4501026427365283899">"Changer le cycle..."</string>
    <string name="data_usage_pick_cycle_day" msgid="3548922497494790123">"Jour du mois de réinitialisation du cycle utilisation données :"</string>
    <string name="data_usage_empty" msgid="5619908658853726866">"Aucune donnée utilisée par les applications pendant cette période."</string>
    <string name="data_usage_label_foreground" msgid="8782117644558473624">"Avant-plan"</string>
    <string name="data_usage_label_background" msgid="8862781660427421859">"Arrière-plan"</string>
    <string name="data_usage_app_restricted" msgid="312065316274378518">"limitée"</string>
    <string name="data_usage_disable_mobile" msgid="6183809500102606801">"Désactiver les données cellulaires?"</string>
    <string name="data_usage_disable_mobile_limit" msgid="1370147078938479538">"Définir un plafond"</string>
    <string name="data_usage_disable_4g_limit" msgid="3084868504051520840">"Définir le quota de données 4G"</string>
    <string name="data_usage_disable_3g_limit" msgid="8867555130268898044">"Définir quota de données 2G-3G"</string>
    <string name="data_usage_disable_wifi_limit" msgid="7222459951785404241">"Définir quota données Wi-Fi"</string>
    <string name="data_usage_tab_wifi" msgid="801667863336456787">"Wi-Fi"</string>
    <string name="data_usage_tab_ethernet" msgid="2951873059375493878">"Ethernet"</string>
    <string name="data_usage_tab_mobile" msgid="952231704205870928">"Cellulaire"</string>
    <string name="data_usage_tab_4g" msgid="3265237821331861756">"4G"</string>
    <string name="data_usage_tab_3g" msgid="6111070409752123049">"2G-3G"</string>
    <string name="data_usage_list_mobile" msgid="3738130489722964291">"Cellulaire"</string>
    <string name="data_usage_list_none" msgid="2091924522549134855">"Aucun"</string>
    <string name="data_usage_enable_mobile" msgid="1996943748103310201">"Données cellulaires"</string>
    <string name="data_usage_enable_3g" msgid="2818189799905446932">"Données 2G-3G"</string>
    <string name="data_usage_enable_4g" msgid="1526584080251993023">"Données 4G"</string>
    <string name="data_roaming_enable_mobile" msgid="5745287603577995977">"Itinérance"</string>
    <string name="data_usage_forground_label" msgid="5762048187044975428">"Premier plan :"</string>
    <string name="data_usage_background_label" msgid="5363718469293175279">"Arrière-plan :"</string>
    <string name="data_usage_app_settings" msgid="5693524672522122485">"Paramètres de l\'application"</string>
    <string name="data_usage_app_restrict_background" msgid="5728840276368097276">"Données en arrière-plan"</string>
    <string name="data_usage_app_restrict_background_summary" msgid="2997942775999602794">"Activer l\'utilisation de données cellulaires en arrière-plan"</string>
    <string name="data_usage_app_restrict_background_summary_disabled" msgid="8213268097024597864">"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="5383874438677899255">"Limiter les données en arrière-plan?"</string>
    <string name="data_usage_app_restrict_dialog" msgid="5534272311979978297">"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="8599940395497268584">"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="2048411447974361181">"Activer synchro auto données?"</string>
    <string name="data_usage_auto_sync_off_dialog_title" msgid="1783917145440587470">"Désactiver synchro auto données?"</string>
    <string name="data_usage_auto_sync_off_dialog" msgid="6523112583569674837">"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="2019035830921480941">"Date de réinitialisation du cycle de consommation"</string>
    <string name="data_usage_cycle_editor_subtitle" msgid="1026234456777365545">"Jour du mois :"</string>
    <string name="data_usage_cycle_editor_positive" msgid="6110165528024717527">"Définir"</string>
    <string name="data_usage_warning_editor_title" msgid="5252748452973120016">"Définir avertissement d\'utilisation des données"</string>
    <string name="data_usage_limit_editor_title" msgid="8826855902435008518">"Définir la limite de consommation des données"</string>
    <string name="data_usage_limit_dialog_title" msgid="2053134451707801439">"Limitation de la consommation de données cellulaires"</string>
    <string name="data_usage_sweep_warning" msgid="2072854703184614828"><font size="18">"<xliff:g id="NUMBER">^1</xliff:g>"</font><font size="9">"<xliff:g id="UNIT">^2</xliff:g>"</font>\n<font size="12">"alerte"</font></string>
    <string name="data_usage_sweep_limit" msgid="6947019190890086284"><font size="18">"<xliff:g id="NUMBER">^1</xliff:g>"</font><font size="9">"<xliff:g id="UNIT">^2</xliff:g>"</font>\n<font size="12">"limite"</font></string>
    <string name="data_usage_uninstalled_apps" msgid="9065885396147675694">"Applications supprimées"</string>
    <string name="data_usage_uninstalled_apps_users" msgid="1262228664057122983">"Applications et utilisateurs supprimés"</string>
    <string name="wifi_metered_title" msgid="6623732965268033931">"Utilisation du réseau"</string>
    <string name="data_usage_metered_yes" msgid="4262598072030135223">"Facturé à l\'usage"</string>
    <string name="vpn_name" msgid="3806456074909253262">"Nom"</string>
    <string name="vpn_type" msgid="5533202873260826663">"Type"</string>
    <string name="vpn_server" msgid="2908816134941973935">"Adresse du serveur"</string>
    <string name="vpn_mppe" msgid="7366657055055114239">"Chiffrement PPP (MPPE)"</string>
    <string name="vpn_l2tp_secret" msgid="2356744369959140121">"Secret L2TP"</string>
    <string name="vpn_ipsec_identifier" msgid="8511842694369254801">"Identifiant IPSec"</string>
    <string name="vpn_ipsec_secret" msgid="532007567355505963">"Clé pré-partagée IPSec"</string>
    <string name="vpn_ipsec_user_cert" msgid="2714372103705048405">"Certificat utilisateur IPSec"</string>
    <string name="vpn_ipsec_ca_cert" msgid="5558498943577474987">"Certificat d\'autorité IPSec"</string>
    <string name="vpn_ipsec_server_cert" msgid="1411390470454731396">"Certificat de serveur IPSec"</string>
    <string name="vpn_show_options" msgid="6105437733943318667">"Afficher les options avancées"</string>
    <string name="vpn_search_domains" msgid="1973799969613962440">"Domaines de recherche DNS"</string>
    <string name="vpn_dns_servers" msgid="6505263074417737107">"Serveurs DNS (p. ex. 8.8.8.8)"</string>
    <string name="vpn_routes" msgid="1218707725375594862">"Itinéraires transfert (p. ex. 10.0.0.0/8)"</string>
    <string name="vpn_username" msgid="8671768183475960068">"Nom d\'utilisateur"</string>
    <string name="vpn_password" msgid="1183746907642628127">"Mot de passe"</string>
    <string name="vpn_save_login" msgid="5986762519977472618">"Enregistrer les informations de compte"</string>
    <string name="vpn_not_used" msgid="7229312881336083354">"(non utilisé)"</string>
    <string name="vpn_no_ca_cert" msgid="3687379414088677735">"(ne pas valider le serveur)"</string>
    <string name="vpn_no_server_cert" msgid="8106540968643125407">"(certificat reçu du serveur)"</string>
    <string name="vpn_always_on_invalid_reason_type" msgid="4699113710248872972">"Ce type de RPV ne peut pas rester connecté en permanence"</string>
    <string name="vpn_always_on_invalid_reason_server" msgid="2635347740046212693">"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="3980357762395272467">"Un serveur DNS doit être spécifié pour le RPV permanent"</string>
    <string name="vpn_always_on_invalid_reason_dns" msgid="3934369594591801587">"Les adresses de serveur DNS doivent être numériques pour le RPV permanent"</string>
    <string name="vpn_always_on_invalid_reason_other" msgid="4571905303713233321">"Les données entrées ne sont pas compatibles avec le RPV permanent"</string>
    <string name="vpn_cancel" msgid="5929410618112404383">"Annuler"</string>
    <string name="vpn_done" msgid="5137858784289564985">"Ignorer"</string>
    <string name="vpn_save" msgid="683868204634860888">"Enregistrer"</string>
    <string name="vpn_connect" msgid="7102335248484045354">"Connexion"</string>
    <string name="vpn_replace" msgid="1533147558671640341">"Remplacer"</string>
    <string name="vpn_edit" msgid="5862301148429324911">"Modifier le profil RPV"</string>
    <string name="vpn_forget" msgid="2913950864877236737">"Supprimer"</string>
    <string name="vpn_connect_to" msgid="216709261691085594">"Se connecter à <xliff:g id="PROFILE">%s</xliff:g>"</string>
    <string name="vpn_disconnect_confirm" msgid="6356789348816854539">"Déconnecter ce RPV?"</string>
    <string name="vpn_disconnect" msgid="7753808961085867345">"Déconnecter"</string>
    <string name="vpn_version" msgid="6344167191984400976">"Version"</string>
    <string name="vpn_forget_long" msgid="729132269203870205">"Oublier le profil RPV"</string>
    <string name="vpn_replace_vpn_title" msgid="3994226561866340280">"Remplacer le RPV existant?"</string>
    <string name="vpn_set_vpn_title" msgid="1667539483005810682">"Définir le RPV permanent?"</string>
    <string name="vpn_first_always_on_vpn_message" msgid="2769478310633047870">"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="9154843462740876652">"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="4299175336198481106">"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="1094297700371463386">"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="3568307071295211187">"Activer"</string>
    <string name="vpn_cant_connect_title" msgid="5670787575925519386">"<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="2139148820719163694">"Cette application ne prend pas en charge le RPV permanent"</string>
    <string name="vpn_title" msgid="3068868814145870274">"RPV"</string>
    <string name="vpn_create" msgid="7546073242936894638">"Ajouter un profil RPV"</string>
    <string name="vpn_menu_edit" msgid="5100387853773792379">"Modifier le profil"</string>
    <string name="vpn_menu_delete" msgid="4455966182219039928">"Supprimer le profil"</string>
    <string name="vpn_menu_lockdown" msgid="5284041663859541007">"RPV permanent"</string>
    <string name="vpn_no_vpns_added" msgid="7387080769821533728">"Aucun RPV ajouté"</string>
    <string name="vpn_always_on_summary" msgid="2171252372476858166">"Rester connecté au RPV en permanence"</string>
    <string name="vpn_always_on_summary_not_supported" msgid="9084872130449368437">"Non compatible avec cette application"</string>
    <string name="vpn_always_on_summary_active" msgid="175877594406330387">"Toujours activé"</string>
    <string name="vpn_insecure_summary" msgid="4450920215186742859">"Non sécurisé"</string>
    <string name="vpn_require_connection" msgid="1027347404470060998">"Bloquer les connexions sans RPV"</string>
    <string name="vpn_require_connection_title" msgid="4186758487822779039">"Exiger une connexion RPV?"</string>
    <string name="vpn_insecure_dialog_subtitle" msgid="1857621742868835300">"Pas sécuritaire. Passez à un RPV de type IKEv2"</string>
    <string name="vpn_lockdown_summary" msgid="4700625960550559029">"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="455915403560910517">"Aucun"</string>
    <string name="vpn_lockdown_config_error" msgid="1992071316416371316">"Le RPV permanent nécessite une adresse IP pour le serveur et le DNS."</string>
    <string name="vpn_no_network" msgid="7187593680049843763">"Aucune connexion réseau. Veuillez réessayer plus tard."</string>
    <string name="vpn_disconnected" msgid="7694522069957717501">"Déconnecté du RPV"</string>
    <string name="vpn_disconnected_summary" msgid="721699709491697712">"Aucun"</string>
    <string name="vpn_missing_cert" msgid="5397309964971068272">"Certificat manquant. Essayez de modifier le profil."</string>
    <string name="trusted_credentials_system_tab" msgid="675362923690364722">"Système"</string>
    <string name="trusted_credentials_user_tab" msgid="4978365619630094339">"Utilisateur"</string>
    <string name="trusted_credentials_disable_label" msgid="6649583220519447947">"Désactiver"</string>
    <string name="trusted_credentials_enable_label" msgid="5551204878588237991">"activer"</string>
    <string name="trusted_credentials_remove_label" msgid="8296330919329489422">"Désinstaller"</string>
    <string name="trusted_credentials_trust_label" msgid="4841047312274452474">"Faire confiance"</string>
    <string name="trusted_credentials_enable_confirmation" msgid="6686528499458144754">"Activer le certificat d\'autorité du système?"</string>
    <string name="trusted_credentials_disable_confirmation" msgid="5131642563381656676">"Désactiver le certificat d\'autorité du système?"</string>
    <string name="trusted_credentials_remove_confirmation" msgid="3420345440353248381">"Supprimer définitivement le certificat d\'autorité utilisateur?"</string>
    <string name="credential_being_used_by" msgid="3682869943025283499">"En cours d\'utilisation par"</string>
    <string name="credential_contains" msgid="3146519680449595771">"Cette entrée contient"</string>
    <string name="one_userkey" msgid="6363426728683951234">"Une clé utilisateur"</string>
    <string name="one_usercrt" msgid="2097644070227688983">"Un certificat utilisateur"</string>
    <string name="one_cacrt" msgid="982242103604501559">"Un certificat CA"</string>
    <string name="n_cacrts" msgid="5886462550192731627">"%d certificats CA"</string>
    <string name="user_credential_title" msgid="4686178602575567298">"Détails de l\'authentifiant"</string>
    <string name="user_credential_removed" msgid="4087675887725394743">"L\'identifiant suivant a été supprimé : <xliff:g id="CREDENTIAL_NAME">%s</xliff:g>"</string>
    <string name="user_credential_none_installed" msgid="918620912366836994">"Aucun authentifiant d\'utilisateur installé"</string>
    <string name="spellcheckers_settings_title" msgid="2799021700580591443">"Correcteur orthographique"</string>
    <string name="spellcheckers_settings_for_work_title" msgid="6471603934176062893">"Correcteur orthographique pour le travail"</string>
    <string name="current_backup_pw_prompt" msgid="4962276598546381140">"Saisissez votre mot de passe actuel pour les sauvegardes complètes."</string>
    <string name="new_backup_pw_prompt" msgid="4884439230209419503">"Saisissez votre nouveau mot de passe pour les sauvegardes complètes."</string>
    <string name="confirm_new_backup_pw_prompt" msgid="5753796799743881356">"Confirmez votre nouveau mot de passe pour les sauvegardes complètes."</string>
    <string name="backup_pw_set_button_text" msgid="8892357974661340070">"Définir le mot de passe de sauvegarde"</string>
    <string name="backup_pw_cancel_button_text" msgid="2244399819018756323">"Annuler"</string>
    <string name="additional_system_update_settings_list_item_title" msgid="7230385345152138051">"Mises à jour supplémentaires du système"</string>
    <string name="ssl_ca_cert_warning" msgid="3898387588657346106">"Le réseau peut être surveillé"</string>
    <string name="done_button" msgid="6269449526248267">"Terminé"</string>
    <string name="ssl_ca_cert_dialog_title" msgid="1032088078702042090">"{count,plural, =1{Faire confiance au certificat ou le retirer}one{Faire confiance au certificat ou le retirer}other{Faire confiance aux certificats ou les retirer}}"</string>
    <string name="ssl_ca_cert_info_message_device_owner" msgid="7528581447864707873">"{numberOfCertificates,plural, =1{{orgName} a installé une autorité de certification sur votre appareil, ce qui peut lui permettre de surveiller l\'activité de votre appareil sur le 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.}one{{orgName} a installé une autorité de certification sur votre appareil, ce qui peut lui permettre de surveiller l\'activité de votre appareil sur le 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.}other{{orgName} a installé des autorités de certification sur votre appareil, ce qui peut lui permettre de surveiller l\'activité de votre appareil sur le 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.}}"</string>
    <string name="ssl_ca_cert_info_message" msgid="3111724430981667845">"{numberOfCertificates,plural, =1{{orgName} a installé une autorité de certification pour votre profil professionnel, ce qui peut lui permettre de surveiller l\'activité professionnelle sur le 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.}one{{orgName} a installé une autorité de certification pour votre profil professionnel, ce qui peut lui permettre de surveiller l\'activité professionnelle sur le 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.}other{{orgName} a installé des autorités de certification pour votre profil professionnel, ce qui peut lui permettre de surveiller l\'activité professionnelle sur le 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.}}"</string>
    <string name="ssl_ca_cert_warning_message" msgid="4374052724815563051">"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>
    <string name="ssl_ca_cert_settings_button" msgid="2044927302268394991">"{count,plural, =1{Vérifier le certificat}one{Vérifier le certificat}other{Vérifier les certificats}}"</string>
    <string name="user_settings_title" msgid="6550866465409807877">"Plusieurs utilisateurs"</string>
    <string name="user_list_title" msgid="1387379079186123404">"Utilisateurs et profils"</string>
    <string name="user_add_user_or_profile_menu" msgid="305851380425838287">"Ajouter un utilisateur ou un profil"</string>
    <string name="user_summary_restricted_profile" msgid="451650609582185813">"Profil limité"</string>
    <string name="user_summary_not_set_up" msgid="4602868481732886115">"Non configuré"</string>
    <string name="user_summary_restricted_not_set_up" msgid="1658946988920104613">"Non configuré : profil limité"</string>
    <string name="user_summary_managed_profile_not_set_up" msgid="5739207307082458746">"Non configuré : profil professionnel"</string>
    <string name="user_admin" msgid="4024553191395768119">"Admin"</string>
    <string name="user_you" msgid="3070562015202859996">"Vous (<xliff:g id="NAME">%s</xliff:g>)"</string>
    <string name="user_add_max_count" msgid="3328539978480663740">"Vous ne pouvez plus ajouter d’utilisateurs. Retirez un utilisateur pour en ajouter un nouveau."</string>
    <string name="user_cannot_add_accounts_message" msgid="2351326078338805337">"Les profils limités ne peuvent pas ajouter de compte."</string>
    <string name="user_remove_user_menu" msgid="2183714948094429367">"Supp. <xliff:g id="USER_NAME">%1$s</xliff:g> de l\'appareil"</string>
    <string name="user_lockscreen_settings" msgid="4596612658981942092">"Paramètres de l\'écran de verrouillage"</string>
    <string name="user_add_on_lockscreen_menu" msgid="2539059062034644966">"Ajouter des utilisateurs à partir de l\'écran de verrouillage"</string>
    <string name="switch_to_dock_user_when_docked" msgid="2324395443311905635">"Activer l\'utilisateur administrateur lorsque connecté"</string>
    <string name="user_confirm_remove_self_title" msgid="926265330805361832">"Vous supprimer?"</string>
    <string name="user_confirm_remove_title" msgid="3626559103278006002">"Supprimer cet utilisateur?"</string>
    <string name="user_profile_confirm_remove_title" msgid="3131574314149375354">"Supprimer ce profil?"</string>
    <string name="work_profile_confirm_remove_title" msgid="6229618888167176036">"Supprimer le profil professionnel?"</string>
    <string name="user_confirm_remove_message" msgid="362545924965977597">"L\'ensemble des applications et des données seront supprimées."</string>
    <string name="work_profile_confirm_remove_message" msgid="1037294114103024478">"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="3641289528179850718">"L\'ensemble des applications et des données seront supprimées."</string>
    <string name="user_adding_new_user" msgid="7439602720177181412">"Ajout de l\'utilisateur…"</string>
    <string name="user_delete_user_description" msgid="7764153465503821011">"Supprimer l\'utilisateur"</string>
    <string name="user_delete_button" msgid="3833498650182594653">"Supprimer"</string>
    <string name="user_exit_guest_confirm_message" msgid="8995296853928816554">"Toutes les applications et les données de cette session seront supprimées."</string>
    <string name="user_exit_guest_dialog_remove" msgid="7067727314172605181">"Supprimer"</string>
    <string name="guest_category_title" msgid="5562663588315329152">"Invité (vous)"</string>
    <string name="user_category_title" msgid="4368580529662699083">"Utilisateurs"</string>
    <string name="other_user_category_title" msgid="7089976887307643217">"Autres utilisateurs"</string>
    <string name="remove_guest_on_exit" msgid="8202972371459611066">"Supprimer l\'activité d\'invité"</string>
    <string name="remove_guest_on_exit_summary" msgid="3969962695703280353">"Supprimer toutes les applications et données d\'invité en quittant le mode Invité"</string>
    <string name="remove_guest_on_exit_dialog_title" msgid="2310442892536079416">"Supprimer l\'activité d\'invité?"</string>
    <string name="remove_guest_on_exit_dialog_message" msgid="8112409834021851883">"Les applications et les données de cette session d\'invité seront supprimées maintenant, et toutes les activités d\'invité futures seront supprimées chaque fois que vous quitterez le mode Invité"</string>
    <string name="remove_guest_on_exit_keywords" msgid="4961310523576166193">"supprimer, invité, activité, retirer, données, visiteur, effacer"</string>
    <string name="enable_guest_calling" msgid="8300355036005240911">"Autoriser l\'invité à utiliser le téléphone"</string>
    <string name="enable_guest_calling_summary" msgid="4748224917641204782">"L\'historique des appels sera partagé avec l\'utilisateur invité"</string>
    <string name="user_enable_calling_sms" msgid="8546430559552381324">"Activer appels téléphoniques et textos"</string>
    <string name="user_grant_admin" msgid="6511342422361803820">"Accorder privilèges d\'admin. à cet utilisateur"</string>
    <string name="user_remove_user" msgid="8468203789739693845">"Supprimer l\'utilisateur"</string>
    <string name="user_enable_calling_and_sms_confirm_title" msgid="4041510268838725520">"Activer les appels téléphoniques et les textos?"</string>
    <string name="user_enable_calling_and_sms_confirm_message" msgid="367792286597449922">"L\'historique des appels et des textos sera partagé avec cet utilisateur."</string>
    <string name="user_revoke_admin_confirm_title" msgid="3057842401861731863">"Retirer les privilèges d\'administrateur?"</string>
    <string name="user_revoke_admin_confirm_message" msgid="2719667217562982318">"Voulez-vous vraiment retirer à cet utilisateur ses privilèges d\'administrateur?"</string>
    <string name="emergency_info_title" msgid="8233682750953695582">"Coordonnées d\'urgence"</string>
    <string name="emergency_info_summary" msgid="8463622253016757697">"Information et contacts pour <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="open_app_button" msgid="5025229765547191710">"Ouvrir <xliff:g id="APP_NAME">%1$s</xliff:g>"</string>
    <string name="application_restrictions" msgid="276179173572729205">"Autoriser des applications et des contenus"</string>
    <string name="apps_with_restrictions_header" msgid="5277698582872267931">"Applications avec restrictions"</string>
    <string name="apps_with_restrictions_settings_button" msgid="2648355133416902221">"Développer paramètres applis"</string>
    <string name="user_choose_copy_apps_to_another_user" msgid="5914037067347012870">"Choisir les applications à installer"</string>
    <string name="user_copy_apps_menu_title" msgid="5354300105759670300">"Installer les applis proposées"</string>
    <string name="nfc_payment_settings_title" msgid="2043139180030485500">"Paiements sans contact"</string>
    <string name="nfc_default_payment_settings_title" msgid="2150504446774382261">"Application de paiement par défaut"</string>
    <string name="nfc_default_payment_footer" msgid="978535088340021360">"Pour effectuer un paiement à l\'aide d\'une application, approchez l\'arrière de votre appareil du terminal"</string>
    <string name="nfc_more_details" msgid="1700713533074275233">"En savoir plus"</string>
    <string name="nfc_default_payment_workapp_confirmation_title" msgid="746921251872504687">"Appli pro par défaut pour les paiements?"</string>
    <string name="nfc_default_payment_workapp_confirmation_message_title" msgid="1533022606333010329">"Pour les paiements avec une appli pro :"</string>
    <string name="nfc_default_payment_workapp_confirmation_message_1" msgid="2917430119080702912">"le profil professionnel doit être activé;"</string>
    <string name="nfc_default_payment_workapp_confirmation_message_2" msgid="8161184137833245628">"vous devrez entrer le NIP, schéma ou mot de passe de votre compte professionnel."</string>
    <string name="nfc_payment_how_it_works" msgid="3658253265242662010">"Fonctionnement"</string>
    <string name="nfc_payment_no_apps" msgid="6840001883471438798">"Payez avec votre téléphone en magasin"</string>
    <string name="nfc_payment_default" msgid="3769788268378614608">"Mode de paiement par défaut"</string>
    <string name="nfc_payment_default_not_set" msgid="6471905683119084622">"Non défini"</string>
    <string name="nfc_payment_app_and_desc" msgid="2607417639227030398">"<xliff:g id="APP">%1$s</xliff:g> - <xliff:g id="DESCRIPTION">%2$s</xliff:g>"</string>
    <string name="nfc_payment_use_default" msgid="6127665705799658860">"Utiliser l\'application de paiement par défaut"</string>
    <string name="nfc_payment_use_default_dialog" msgid="8556328090777785383">"Utiliser l\'appli de paiement par défaut"</string>
    <string name="nfc_payment_favor_default" msgid="4508491832174644772">"Toujours"</string>
    <string name="nfc_payment_favor_open" msgid="8554643344050373346">"Sauf si une autre application de paiement est ouverte"</string>
    <string name="nfc_payment_pay_with" msgid="3001320460566523453">"À un terminal sans contact, payer avec :"</string>
    <string name="nfc_how_it_works_title" msgid="1363791241625771084">"Paiement à un terminal"</string>
    <string name="nfc_how_it_works_content" msgid="1141382684788210772">"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="4717868843368296630">"OK"</string>
    <string name="nfc_more_title" msgid="1041094244767216498">"Plus…"</string>
    <string name="nfc_payment_set_default_label" msgid="7395939287766230293">"Définissez l\'application de paiement par défaut"</string>
    <string name="nfc_payment_update_default_label" msgid="8201975914337221246">"Mettez à jour l\'application de paiement par défaut"</string>
    <string name="nfc_payment_set_default" msgid="4101484767872365195">"À un terminal sans contact, payer avec <xliff:g id="APP">%1$s</xliff:g>"</string>
    <string name="nfc_payment_set_default_instead_of" msgid="565237441045013280">"À un terminal sans contact, payer avec <xliff:g id="APP_0">%1$s</xliff:g>.\n\nCette application remplace <xliff:g id="APP_1">%2$s</xliff:g> comme application de paiement par défaut."</string>
    <string name="nfc_payment_btn_text_set_deault" msgid="1821065137209590196">"Définir par défaut"</string>
    <string name="nfc_payment_btn_text_update" msgid="5159700960497443832">"Mettre à jour"</string>
    <string name="nfc_work_text" msgid="2496515165821504077">"Travail"</string>
    <string name="restriction_settings_title" msgid="4293731103465972557">"Restrictions"</string>
    <string name="restriction_menu_reset" msgid="92859464456364092">"Annuler les restrictions"</string>
    <string name="restriction_menu_change_pin" msgid="2505923323199003718">"Modifier le NIP"</string>
    <string name="help_label" msgid="2896538416436125883">"Aide et commentaires"</string>
    <string name="user_account_title" msgid="6389636876210834864">"Compte pour contenu"</string>
    <string name="user_picture_title" msgid="7176437495107563321">"ID de photo"</string>
    <string name="extreme_threats_title" msgid="1098958631519213856">"Menaces extrêmes"</string>
    <string name="extreme_threats_summary" msgid="3560742429496902008">"Recevoir alertes pour menaces extrêmes à la vie et aux biens"</string>
    <string name="severe_threats_title" msgid="8962959394373974324">"Menaces graves"</string>
    <string name="severe_threats_summary" msgid="4982256198071601484">"Recevoir alertes pour menaces graves à la vie et aux biens"</string>
    <string name="amber_alerts_title" msgid="5238275758191804575">"Alertes AMBER"</string>
    <string name="amber_alerts_summary" msgid="5755221775246075883">"Recevoir les bulletins sur les enlèvements d\'enfants"</string>
    <string name="repeat_title" msgid="8676570486899483606">"Répéter"</string>
    <string name="call_manager_enable_title" msgid="1214301265395158720">"Activer le gestionnaire d\'appels"</string>
    <string name="call_manager_enable_summary" msgid="7362506369604163030">"Autoriser ce service à gérer comment vous faites vos appels."</string>
    <string name="call_manager_title" msgid="3397433159509629466">"Gestionnaire d\'appels"</string>
    <!-- no translation found for call_manager_summary (2558839230880919191) -->
    <skip />
    <string name="cell_broadcast_settings" msgid="2416980110093867199">"Alertes d\'urgence sans fil"</string>
    <string name="network_operators_settings" msgid="5105453353329748954">"Fournisseurs de services cellulaires"</string>
    <string name="access_point_names" msgid="5768430498022188057">"Noms des points d\'accès"</string>
    <string name="enhanced_4g_lte_mode_title" msgid="6624700245232361149">"VoLTE"</string>
    <string name="enhanced_4g_lte_mode_title_advanced_calling" msgid="7066009898031465265">"Appels avancés"</string>
    <string name="enhanced_4g_lte_mode_title_4g_calling" msgid="7445853566718786195">"Appels 4G"</string>
    <string name="enhanced_4g_lte_mode_summary" msgid="1067066329756036427">"Utiliser les services LTE pour améliorer les appels vocaux (recommandé)"</string>
    <string name="enhanced_4g_lte_mode_summary_4g_calling" msgid="2575004054914178405">"Utiliser les services 4G pour améliorer les appels vocaux (recommandé)"</string>
    <string name="nr_advanced_calling_title" msgid="6106286679535355939">"Voix sur 5G"</string>
    <string name="nr_advanced_calling_summary" msgid="6926192539172030330">"Utiliser le réseau 5G pour passer des appels vocaux"</string>
    <string name="contact_discovery_opt_in_title" msgid="8708034790649773814">"Envoyer les contacts au fournisseur de services"</string>
    <string name="contact_discovery_opt_in_summary" msgid="6539010458256667300">"Envoyer les numéros de téléphone de vos contacts pour accéder à des fonctionnalités améliorées"</string>
    <string name="contact_discovery_opt_in_dialog_title" msgid="2230536282911854114">"Envoyer les contacts à <xliff:g id="CARRIER">%1$s</xliff:g>?"</string>
    <string name="contact_discovery_opt_in_dialog_title_no_carrier_defined" msgid="2028983133745990320">"Envoyer les contacts à votre fournisseur de services?"</string>
    <string name="contact_discovery_opt_in_dialog_message" msgid="8818310894782757538">"Les numéros de téléphone de vos contacts seront régulièrement envoyés à <xliff:g id="CARRIER">%1$s</xliff:g>.<xliff:g id="EMPTY_LINE">

</xliff:g>Ces données permettent de déterminer si vos contacts peuvent utiliser certaines fonctionnalités, comme les appels vidéo ou des options de messagerie."</string>
    <string name="contact_discovery_opt_in_dialog_message_no_carrier_defined" msgid="1914894516552445911">"Les numéros de téléphone de vos contacts seront régulièrement envoyés à votre fournisseur de services.<xliff:g id="EMPTY_LINE">

</xliff:g>Ces données permettent de déterminer si vos contacts peuvent utiliser certaines fonctionnalités, comme les appels vidéo ou des options de messagerie."</string>
    <string name="preferred_network_type_title" msgid="812509938714590857">"Type de réseau préféré"</string>
    <string name="preferred_network_type_summary" msgid="8786291927331323061">"LTE (recommandé)"</string>
    <string name="mms_message_title" msgid="6624505196063391964">"Messages multimédias"</string>
    <string name="mms_message_summary" msgid="2855847140141698341">"Envoi et réception lorsque les données cellulaires sont désactivées"</string>
    <string name="auto_data_switch_title" msgid="5862200603753603464">"Basculer entre les données cellulaires automatiquement"</string>
    <string name="auto_data_switch_summary" msgid="1934340931995429057">"Utilisez ce réseau en cas de meilleure disponibilité"</string>
    <string name="work_sim_title" msgid="8999872928646924429">"Carte SIM professionnelle"</string>
    <string name="user_restrictions_title" msgid="4068914244980335993">"Accès aux applications et au contenu"</string>
    <string name="user_rename" msgid="8735940847878484249">"RENOMMER"</string>
    <string name="app_restrictions_custom_label" msgid="6949268049087435132">"Définir des restrictions d\'applis"</string>
    <string name="user_restrictions_controlled_by" msgid="2821526006742851624">"Contrôlées par <xliff:g id="APP">%1$s</xliff:g>"</string>
    <string name="app_sees_restricted_accounts" msgid="3526008344222566318">"Cette application peut accéder à vos comptes."</string>
    <string name="app_sees_restricted_accounts_and_controlled_by" msgid="8338520379923447143">"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="2630656989926554685">"Wi‑Fi et données cellulaires"</string>
    <string name="restriction_wifi_config_summary" msgid="920419010472168694">"Autoriser les modifications des paramètres du Wi‑Fi et des données cellulaires"</string>
    <string name="restriction_bluetooth_config_title" msgid="220586273589093821">"Bluetooth"</string>
    <string name="restriction_bluetooth_config_summary" msgid="7558879931011271603">"Autoriser les modifications des associations et des paramètres Bluetooth"</string>
    <string name="restriction_location_enable_title" msgid="4872281754836538066">"Position"</string>
    <string name="restriction_location_enable_summary" msgid="7139292323897390221">"Autoriser les applications à utiliser vos données de localisation"</string>
    <string name="wizard_back" msgid="8257697435061870191">"Précédent"</string>
    <string name="wizard_next" msgid="3884832431439072471">"SUIVANT"</string>
    <string name="wizard_back_adoptable" msgid="1447814356855134183">"Formater autrement"</string>
    <string name="regulatory_info_text" msgid="1154461023369976667"></string>
    <string name="sim_settings_title" msgid="2254609719033946272">"Cartes SIM"</string>
    <string name="sim_cellular_data_unavailable" msgid="4653591727755387534">"Données cellulaires non disponibles"</string>
    <string name="sim_cellular_data_unavailable_summary" msgid="6505871722911347881">"Touchez pour sélectionner une carte SIM pour les données"</string>
    <string name="sim_calls_always_use" msgid="967857230039768111">"Toujours l\'utiliser pour les appels"</string>
    <string name="select_sim_for_data" msgid="2642305487659432499">"Choisissez SIM pour données cellulaires"</string>
    <string name="select_sim_for_sms" msgid="5335510076282673497">"Sélectionnez la carte SIM pour les textos"</string>
    <string name="data_switch_started" msgid="6292759843974720112">"Changement de carte SIM pour les données, cela peut prendre jusqu\'à une minute…"</string>
    <string name="select_specific_sim_for_data_title" msgid="5851980301321577985">"Utiliser <xliff:g id="NEW_SIM">%1$s</xliff:g> pour les données cellulaires?"</string>
    <string name="select_specific_sim_for_data_msg" msgid="7401698123430573637">"Si vous passez au réseau de <xliff:g id="NEW_SIM">%1$s</xliff:g>, celui de <xliff:g id="OLD_SIM">%2$s</xliff:g> ne sera plus utilisé pour les données cellulaires."</string>
    <string name="select_specific_sim_for_data_button" msgid="6571935548920603512">"Utiliser <xliff:g id="NEW_SIM">%1$s</xliff:g>"</string>
    <string name="select_sim_for_calls" msgid="7843107015635189868">"Appeler avec"</string>
    <string name="sim_name_hint" msgid="8231524869124193119">"Entrez le nom de la carte SIM"</string>
    <string name="sim_editor_title" msgid="918655391915256859">"Fente pour carte SIM %1$d"</string>
    <string name="color_orange" msgid="216547825489739010">"Orange"</string>
    <string name="color_purple" msgid="6603701972079904843">"Mauve"</string>
    <string name="sim_status_title" msgid="6188770698037109774">"État de la carte SIM"</string>
    <string name="sim_status_title_sim_slot" msgid="4932996839194493313">"État de la carte SIM (fente SIM n° %1$d)"</string>
    <string name="sim_signal_strength" msgid="6351052821700294501">"<xliff:g id="DBM">%1$d</xliff:g> dBm <xliff:g id="ASU">%2$d</xliff:g> asu"</string>
    <string name="sim_notification_title" msgid="2819551384383504031">"Cartes SIM changées."</string>
    <string name="sim_notification_summary" msgid="5593339846307029991">"Touchez pour configurer"</string>
    <string name="sim_calls_ask_first_prefs_title" msgid="3077694594349657933">"Toujours demander"</string>
    <string name="sim_selection_required_pref" msgid="231437651041498359">"Veuillez indiquer votre préférence"</string>
    <string name="sim_selection_channel_title" msgid="3193666315607572484">"Sélection de carte SIM"</string>
    <string name="dashboard_title" msgid="5660733037244683387">"Paramètres"</string>
    <string name="network_dashboard_title" msgid="788543070557731240">"Réseau et Internet"</string>
    <string name="network_dashboard_summary_mobile" msgid="7750924671970583670">"Appareil mobile, Wi-Fi, point d\'accès"</string>
    <string name="network_dashboard_summary_no_mobile" msgid="4022575916334910790">"Wi-Fi, point d\'accès"</string>
    <string name="connected_devices_dashboard_title" msgid="19868275519754895">"Appareils connectés"</string>
    <string name="connected_devices_dashboard_default_summary" msgid="7211769956193710397">"Bluetooth, association"</string>
    <string name="connected_devices_dashboard_summary" msgid="6927727617078296491">"Bluetooth, mode Voiture, CCP"</string>
    <string name="connected_devices_dashboard_no_nfc_summary" msgid="8424794257586524040">"Bluetooth, mode Voiture"</string>
    <string name="connected_devices_dashboard_no_driving_mode_summary" msgid="7155882619333726331">"Bluetooth, CCP"</string>
    <string name="connected_devices_dashboard_no_driving_mode_no_nfc_summary" msgid="1175254057213044560">"Bluetooth"</string>
    <string name="connected_devices_dashboard_android_auto_summary" msgid="8179090809275818804">"Bluetooth, Android Auto, mode Voiture, CCP"</string>
    <string name="connected_devices_dashboard_android_auto_no_nfc_summary" msgid="2532811870469405527">"Bluetooth, Android Auto, mode Voiture"</string>
    <string name="connected_devices_dashboard_android_auto_no_driving_mode_summary" msgid="6426996842202276640">"Bluetooth, Android Auto, CCP"</string>
    <string name="connected_devices_dashboard_android_auto_no_nfc_no_driving_mode" msgid="1672426693308438634">"Bluetooth, Android Auto"</string>
    <string name="nfc_and_payment_settings_payment_off_nfc_off_summary" msgid="7132040463607801625">"Non accessible parce que la technologie CCP est désactivée"</string>
    <string name="nfc_and_payment_settings_no_payment_installed_summary" msgid="4879818114908207465">"Pour l\'utiliser, installez d\'abord une application de paiement"</string>
    <string name="app_and_notification_dashboard_summary" msgid="8047683010984186106">"Applications récentes, applications par défaut"</string>
    <string name="notification_settings_work_profile" msgid="6076211850526353975">"Les applications du profil professionnel n\'ont pas accès aux notifications."</string>
    <string name="account_dashboard_title" msgid="8228773251948253914">"Mots de passe et comptes"</string>
    <string name="account_dashboard_default_summary" msgid="1730719656099599488">"Mots de passe enregistrés, remplissage automatique, comptes synchronisés"</string>
    <string name="app_default_dashboard_title" msgid="4071015747629103216">"Applications par défaut"</string>
    <string name="cloned_apps_dashboard_title" msgid="5542076801222950921">"Applications clonées"</string>
    <string name="desc_cloned_apps_intro_text" msgid="1369621522882622476">"Créez une deuxième instance d\'une application afin de pouvoir utiliser deux comptes en même temps."</string>
    <string name="desc_cloneable_app_list_text" msgid="3354586725814708688">"Applications qui peuvent être clonées."</string>
    <string name="cloned_apps_summary" msgid="8805362440770795709">"<xliff:g id="CLONED_APPS_COUNT">%1$s</xliff:g> clonée(s), <xliff:g id="ALLOWED_APPS_COUNT">%2$d</xliff:g> disponible(s) pour le clonage"</string>
    <string name="delete_all_app_clones" msgid="3489053361980624999">"Supprimer tous les clones d\'applis"</string>
    <string name="delete_all_app_clones_failure" msgid="6821033414547132335">"Supprimer les clones d\'applis (échec)"</string>
    <string name="cloned_app_creation_summary" msgid="4642627294993918502">"Création en cours…"</string>
    <string name="cloned_app_created_summary" msgid="7277912971544890710">"Clonée"</string>
    <string name="cloned_app_creation_toast_summary" msgid="3854494347144867870">"Création d\'un clone de <xliff:g id="PACKAGE_LABEL">%1$s</xliff:g> en cours…"</string>
    <string name="cloned_app_created_toast_summary" msgid="755225403495544163">"Clone de <xliff:g id="PACKAGE_LABEL">%1$s</xliff:g> créé"</string>
    <string name="system_dashboard_summary" msgid="7400745270362833832">"Langues, gestes, heure, sauvegarde"</string>
    <string name="languages_setting_summary" msgid="4924440599794956443">"Langues du système, langues de l\'application"</string>
    <string name="keywords_wifi" msgid="8156528242318351490">"wifi, wi-fi, connexion réseau, internet, sans fil, données, wi fi"</string>
    <string name="keywords_wifi_notify_open_networks" msgid="6580896556389306636">"notification Wi‑Fi, notification wifi"</string>
    <string name="keywords_wifi_data_usage" msgid="4718555409695862085">"utilisation de données"</string>
    <string name="keywords_time_format" msgid="5384803098766166820">"Utiliser le format 24 heures"</string>
    <string name="keywords_app_default" msgid="8977706259156428770">"Ouvrir avec"</string>
    <string name="keywords_applications_settings" msgid="999926810912037792">"Applications"</string>
    <string name="keywords_time_zone" msgid="6402919157244589055">"fuseau horaire"</string>
    <string name="keywords_draw_overlay" msgid="3170036145197260392">"Bulle de clavardage, système, alerte, fenêtre, boîte de dialogue, écran, superposition autres applis, dessin"</string>
    <string name="keywords_flashlight" msgid="2133079265697578183">"Lampe de poche, lumière"</string>
    <string name="keywords_change_wifi_state" msgid="7573039644328488165">"wifi, wi-fi, activer, désactiver, gestion"</string>
    <string name="keywords_more_mobile_networks" msgid="5041272719326831744">"cellulaire, mobile, fournisseur de services, sans fil, données, 4g, 3g, 2g, lte"</string>
    <string name="keywords_wifi_calling" msgid="4319184318421027136">"wifi, wi-fi, appel, appeler"</string>
    <string name="keywords_display" msgid="874738809280751745">"écran, tactile"</string>
    <string name="keywords_display_brightness_level" msgid="850742707616318056">"assombrir l\'écran, écran tactile, pile, lumineux"</string>
    <string name="keywords_display_night_display" msgid="4711054330804250058">"assombrir l\'écran, nuit, teinte, heures de nuit, luminosité, couleur de l\'écran, couleur, couleurs"</string>
    <string name="keywords_display_wallpaper" msgid="8478137541939526564">"fond d\'écran, personnaliser, personnaliser affichage"</string>
    <string name="keywords_display_font_size" msgid="3593317215149813183">"taille du texte"</string>
    <string name="keywords_display_cast_screen" msgid="2572331770299149370">"projet, diffuser, duplication d\'écran, partage d\'écran, dupliquer l\'écran, partager l\'écran, diffusion d\'écran"</string>
    <string name="keywords_storage" msgid="3004667910133021783">"espace, disque, disque dur, utilisation appareil"</string>
    <string name="keywords_battery" msgid="7040323668283600530">"frais, consommation d\'énergie"</string>
    <string name="keywords_battery_usage" msgid="1763573071014260220">"voir l\'utilisation de la pile, utilisation de la pile, utilisation d\'énergie"</string>
    <string name="keywords_battery_saver" msgid="6289682844453234359">"économiseur de pile, économie d\'énergie, économiseur"</string>
    <string name="keywords_battery_adaptive_preferences" msgid="1774870663426502938">"préférences des technologies adaptatives, gestionnaire de pile adaptatif"</string>
    <string name="keywords_spell_checker" msgid="5148906820603481657">"orthographe, dictionnaire, correcteur orthographique, correction automatique"</string>
    <string name="keywords_voice_input" msgid="7534900094659358971">"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="6728080502619011668">"débit, langue, valeur par défaut, parler, discuter, tts, accessibilité, lecteur d\'écran, aveugle"</string>
    <string name="keywords_date_and_time" msgid="4402136313104901312">"horloge, militaire"</string>
    <string name="keywords_network_reset" msgid="4075670452112218042">"réinitialiser, restaurer, paramètres d\'usine"</string>
    <string name="keywords_factory_data_reset" msgid="4979623326958976773">"nettoyer, supprimer, restaurer, effacer, retirer, réinitialisation d\'usine"</string>
    <string name="keywords_printing" msgid="3528250034669909466">"imprimante"</string>
    <string name="keywords_sounds" msgid="187191900698371911">"bip du haut-parleur, haut-parleur, volume, muet, désactiver le son, audio, musique, haptique, vibreur, vibrer"</string>
    <string name="keywords_sounds_and_notifications_interruptions" msgid="1500312884808362467">"ne pas déranger, interrompre, interruption, pause"</string>
    <string name="keywords_app" msgid="7983814237980258061">"Mémoire vive"</string>
    <string name="keywords_location" msgid="8016374808099706213">"à proximité, position, historique, signalement, GPS"</string>
    <string name="keywords_accounts" msgid="3013897982630845506">"compte, ajouter un compte, profil professionnel, ajouter compte, retirer, supprimer"</string>
    <string name="keywords_users" msgid="3497517660077620843">"restriction, restreindre, restreint"</string>
    <string name="keywords_keyboard_and_ime" msgid="4741098648730042570">"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="8254315757754930862">"réinitialiser, préférences, par défaut"</string>
    <string name="keywords_all_apps" msgid="9016323378609007166">"applis, télécharger, applications, système"</string>
    <string name="keywords_app_permissions" msgid="2061773665663541610">"applications, autorisations, sécurité"</string>
    <string name="keywords_default_apps" msgid="4601664230800605416">"applications, par défaut"</string>
    <string name="keywords_ignore_optimizations" msgid="8967142288569785145">"ignorer les optimisations, mise en veille, mode veille des application"</string>
    <string name="keywords_color_mode" msgid="1193896024705705826">"vibrantes, rvb, srvb, couleurs, naturelles, standard"</string>
    <string name="keywords_screen_resolution" msgid="6652125115386722875">"FHD, QHD, résolution, 1080p, 1440p"</string>
    <string name="keywords_color_temperature" msgid="8159539138837118453">"température, couleur, D65, D73, blanc, jaune, bleu, chaud, froid"</string>
    <string name="keywords_lockscreen" msgid="3656926961043485797">"glisser pour déverrouiller, mot de passe, schéma, nip"</string>
    <string name="keywords_app_pinning" msgid="1564144561464945019">"épinglage d\'écran"</string>
    <string name="keywords_profile_challenge" msgid="5135555521652143612">"défi professionnel, travail, profil"</string>
    <string name="keywords_unification" msgid="2677472004971453468">"profil professionnel, profil géré, unifier, unification, travail, profil"</string>
    <string name="keywords_gesture" msgid="3456930847450080520">"gestes"</string>
    <string name="keywords_wallet" msgid="3757421969956996972">"portefeuille"</string>
    <string name="keywords_payment_settings" msgid="6268791289277000043">"payer, toucher, paiements"</string>
    <string name="keywords_backup" msgid="707735920706667685">"sauvegarde, sauvegarder"</string>
    <string name="keywords_assist_gesture_launch" msgid="7710762655355161924">"geste"</string>
    <string name="keywords_face_unlock" msgid="545338452730885392">"visage, déverrouiller, authentification, se connecter"</string>
    <string name="keywords_biometric_unlock" msgid="8569545388717753692">"visage, déverrouiller, authentification, connexion, empreinte digitale, données biométriques"</string>
    <string name="keywords_imei_info" msgid="8848791606402333514">"iiem, idem, min, version de la liste d\'itinérance préférée, iiem sv"</string>
    <string name="keywords_sim_status" msgid="4221401945956122228">"réseau, état du réseau cellulaire, état du service, puissance du signal, type de réseau cellulaire, itinérance"</string>
    <string name="keywords_sim_status_esim" msgid="3338719238556853609">"réseau, état du réseau cellulaire, état du service, puissance du signal, type de réseau cellulaire, itinérance, eid"</string>
    <string name="keywords_sim_status_iccid" msgid="4775398796251969759">"réseau, état du réseau cellulaire, état du service, puissance du signal, type de réseau cellulaire, itinérance, iccid"</string>
    <string name="keywords_sim_status_iccid_esim" msgid="4634015619840979184">"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_esim_eid" msgid="8128175058237372457">"eid"</string>
    <string name="keywords_model_and_hardware" msgid="4723665865709965044">"numéro de série, version matérielle"</string>
    <string name="keywords_android_version" msgid="1629882125290323070">"niveau du correctif de sécurité android, version de la bande de base, version du noyau"</string>
    <string name="keywords_dark_ui_mode" msgid="6373999418195344014">"thème, luminosité, sombre, mode, sensibilité à la lumière, photophobie, assombrir, rendre sombre, mode sombre, migraine"</string>
    <string name="keywords_systemui_theme" msgid="6341194275296707801">"thème sombre"</string>
    <string name="keywords_device_feedback" msgid="5489930491636300027">"bogue"</string>
    <string name="keywords_ambient_display_screen" msgid="661492302323274647">"Affichage en mode Veille, écran de verrouillage"</string>
    <string name="keywords_lock_screen_notif" msgid="6363144436467429932">"notification sur l\'écran de verrouillage, notifications"</string>
    <string name="keywords_face_settings" msgid="1360447094486865058">"visage"</string>
    <string name="keywords_fingerprint_settings" msgid="7345121109302813358">"empreinte digitale, ajouter une empreinte digitale"</string>
    <string name="keywords_biometric_settings" msgid="2173605297939326549">"visage, empreinte digitale, ajouter une empreinte digitale"</string>
    <string name="keywords_active_unlock_settings" msgid="4511320720304388889">"déverrouillage à l\'aide d\'une montre, ajouter le déverrouillage à l\'aide d\'une montre"</string>
    <string name="keywords_display_auto_brightness" msgid="7162942396941827998">"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="4905300860114643966">"intelligent, assombrir l\'écran, veille, pile, délai d\'inactivité, attention, affichage, écran, inactivité"</string>
    <string name="keywords_auto_rotate" msgid="7288697525101837071">"appareil photo, intelligent, rotation automatique, faire pivoter, tourner, retourner, rotation, portrait, paysage, orientation, vertical, horizontal"</string>
    <string name="keywords_system_update_settings" msgid="5769003488814164931">"mise à niveau, android"</string>
    <string name="keywords_zen_mode_settings" msgid="7810203406522669584">"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="8921857020437540572">"écran, temps de verrouillage, expiration du délai, verrouillage de l\'écran"</string>
    <string name="keywords_storage_settings" msgid="6018856193950281898">"mémoire, cache, données, supprimer, effacer, libre, espace"</string>
    <string name="keywords_bluetooth_settings" msgid="2588159530959868188">"connecté, appareil, casque d\'écoute, casque, haut-parleur, sans fil, associer, écouteurs, musique, médias"</string>
    <string name="keywords_wallpaper" msgid="7332890404629446192">"arrière-plan, thème, grille, personnalisation, personnaliser"</string>
    <string name="keywords_styles" msgid="5291614313348476068">"icône, accent, couleur"</string>
    <string name="keywords_assist_input" msgid="3086289530227075593">"par défaut, assistant"</string>
    <string name="keywords_default_payment_app" msgid="5162298193637362104">"paiement, par défaut"</string>
    <string name="keywords_ambient_display" msgid="3149287105145443697">"notification entrante"</string>
    <string name="keywords_hotspot_tethering" msgid="3688439689671232627">"partage de connexion usb, partage de connexion bluetooth, partage de connexion wi-fi, fonction modem"</string>
    <string name="keywords_accessibility_vibration_primary_switch" msgid="730692154347231253">"rétroactions haptiques, vibrer, vibration"</string>
    <string name="keywords_touch_vibration" msgid="1125291201902251273">"haptique, vibrer, écran, sensibilité"</string>
    <string name="keywords_ring_vibration" msgid="1736301626537417541">"haptique, vibration, téléphone, appel, sensibilité, sonnerie"</string>
    <string name="keywords_ramping_ringer_vibration" msgid="3678966746742257366">"haptique, vibration, téléphone, appel, sonnerie, graduellement"</string>
    <string name="keywords_notification_vibration" msgid="2620799301276142183">"haptique, vibration, sensibilité, notification"</string>
    <string name="keywords_alarm_vibration" msgid="4833220371621521817">"haptique, vibration, sensibilité, alarme"</string>
    <string name="keywords_media_vibration" msgid="723896490102792327">"haptique, vibration, sensibilité, multimédia"</string>
    <string name="keywords_vibration" msgid="670455132028025952">"rétroactions haptiques, vibrer, vibration"</string>
    <string name="keywords_battery_saver_sticky" msgid="1646191718840975110">"économiseur de pile, fixe, persistant, économie d\'énergie, pile"</string>
    <string name="keywords_battery_saver_schedule" msgid="8240483934368455930">"routine, horaire, économiseur de pile, économie d\'énergie, pile, automatique, pour cent"</string>
    <string name="keywords_enhance_4g_lte" msgid="658889360486800978">"volte, appels avancés, appels 4g"</string>
    <string name="keywords_nr_advanced_calling" msgid="4157823099610141014">"Voix sur 5G, voix sur NR, appels avancés, appels 5G"</string>
    <string name="keywords_add_language" msgid="1882751300359939436">"ajouter langue, ajouter une langue"</string>
    <string name="keywords_font_size" msgid="1643198841815006447">"taille du texte, grands caractères, police de grande taille, texte de grande taille, vision faible, agrandir le texte, agrandisseur de police, agrandissement de la police"</string>
    <string name="keywords_always_show_time_info" msgid="645658129239452778">"écran actif en permanence, EAP"</string>
    <string name="keywords_change_nfc_tag_apps_state" msgid="9032287964590554366">"ccp, balise, lecteur"</string>
    <string name="sound_dashboard_summary" msgid="6574444810552643312">"Volume, vibration, Ne pas déranger"</string>
    <string name="media_volume_option_title" msgid="5966569685119475630">"Volume du contenu multimédia"</string>
    <string name="remote_media_volume_option_title" msgid="8760846743943305764">"Volume de diffusion"</string>
    <string name="call_volume_option_title" msgid="1461105986437268924">"Volume des appels"</string>
    <string name="alarm_volume_option_title" msgid="6398641749273697140">"Volume de l\'alarme"</string>
    <string name="ring_volume_option_title" msgid="1520802026403038560">"Volume sonnerie et notifications"</string>
    <string name="separate_ring_volume_option_title" msgid="2212910223857375951">"Volume de la sonnerie"</string>
    <string name="notification_volume_option_title" msgid="4838818791683615978">"Volume des notifications"</string>
    <string name="notification_volume_disabled_summary" msgid="8679988555852056079">"Le son est désactivé parce que la sonnerie est désactivée"</string>
    <string name="ringtone_title" msgid="3271453110387368088">"Sonnerie du téléphone"</string>
    <string name="notification_ringtone_title" msgid="6924501621312095512">"Son de notification par défaut"</string>
    <string name="notification_unknown_sound_title" msgid="1319708450698738980">"Son fourni par l\'application"</string>
    <string name="notification_sound_default" msgid="8630353701915294299">"Son de notification par défaut"</string>
    <string name="alarm_ringtone_title" msgid="6680761007731764726">"Son de l\'alarme par défaut"</string>
    <string name="vibrate_when_ringing_option_ramping_ringer" msgid="2798848945803840348">"Vibrer en premier, puis sonnerie graduelle"</string>
    <string name="spatial_audio_title" msgid="6591051622375191603">"Son spatial"</string>
    <string name="dial_pad_tones_title" msgid="3536945335367914892">"Tonalités du clavier"</string>
    <string name="screen_locking_sounds_title" msgid="5695030983872787321">"Son de verrouillage de l\'écran"</string>
    <string name="charging_sounds_title" msgid="5261683808537783668">"Sons et vibrations de recharge"</string>
    <string name="docking_sounds_title" msgid="5341616179210436159">"Sons de la station d\'accueil"</string>
    <string name="touch_sounds_title" msgid="2200734041857425078">"Sons des touches"</string>
    <string name="vibrate_icon_title" msgid="1281100105045362530">"Toujours afficher l\'icône en mode vibration"</string>
    <string name="dock_audio_media_title" msgid="6474579339356398330">"Lecture : station d\'accueil"</string>
    <string name="dock_audio_media_disabled" msgid="8499927008999532341">"Tout l\'audio"</string>
    <string name="dock_audio_media_enabled" msgid="4039126523653131281">"Audio des médias seulement"</string>
    <string name="emergency_tone_silent" msgid="5048069815418450902">"Silence"</string>
    <string name="emergency_tone_alert" msgid="1977698889522966589">"Tonalités"</string>
    <string name="emergency_tone_vibrate" msgid="6282296789406984698">"Vibrations"</string>
    <string name="boot_sounds_title" msgid="5033062848948884111">"Activation par les sons"</string>
    <string name="live_caption_title" msgid="8617086825712756983">"Sous-titres instantanés"</string>
    <string name="live_caption_summary" msgid="2898451867595161809">"Ajouter automatiquement des sous-titres aux contenus multimédias"</string>
    <string name="spatial_audio_speaker" msgid="9145233652433523302">"Haut-parleur du téléphone"</string>
    <string name="spatial_audio_wired_headphones" msgid="2237355789145828648">"Casque d\'écoute filaire"</string>
    <string name="spatial_audio_text" msgid="8201387855375146000">"Le son des supports compatibles devient plus immersif"</string>
    <string name="spatial_summary_off" msgid="8272678804629774378">"Désactivé"</string>
    <string name="spatial_summary_on_one" msgid="6239933399496282994">"Activé : <xliff:g id="OUTPUT_DEVICE">%1$s</xliff:g>"</string>
    <string name="spatial_summary_on_two" msgid="4526919818832483883">"Activé : <xliff:g id="OUTPUT_DEVICE_0">%1$s</xliff:g> et <xliff:g id="OUTPUT_DEVICE_1">%2$s</xliff:g>"</string>
    <string name="spatial_audio_footer_title" msgid="8775010547623606088">"Vous pouvez également activer le son spatial pour les appareils Bluetooth."</string>
    <string name="spatial_audio_footer_learn_more_text" msgid="3826811708094366301">"Paramètres des appareils connectés"</string>
    <string name="zen_mode_settings_schedules_summary" msgid="2047688589286811617">"{count,plural, =0{Aucun}=1{1 horaire programmé}one{# horaire programmé}other{# horaires programmés}}"</string>
    <string name="zen_mode_settings_title" msgid="682676757791334259">"Ne pas déranger"</string>
    <string name="zen_mode_settings_summary" msgid="6040862775514495191">"Recevez uniquement les notifications des personnes et des applications importantes"</string>
    <string name="zen_mode_slice_subtitle" msgid="6849372107272604160">"Limiter les interruptions"</string>
    <string name="zen_mode_settings_turn_on_dialog_title" msgid="7500702838426404527">"Activer le mode Ne pas déranger"</string>
    <string name="zen_mode_behavior_alarms_only" msgid="2956938533859578315">"Les alarmes et les sons des éléments multimédias peuvent provoquer des interruptions"</string>
    <string name="zen_mode_automation_settings_title" msgid="3709324184191870926">"Horaires"</string>
    <string name="zen_mode_delete_automatic_rules" msgid="5020468289267191765">"Supprimer les horaires"</string>
    <string name="zen_mode_schedule_delete" msgid="5383420576833765114">"Supprimer"</string>
    <string name="zen_mode_rule_name_edit" msgid="1053237022416700481">"Modifier"</string>
    <string name="zen_mode_automation_settings_page_title" msgid="6217433860514433311">"Horaires"</string>
    <string name="zen_mode_automatic_rule_settings_page_title" msgid="5264835276518295033">"Horaire"</string>
    <string name="zen_mode_schedule_category_title" msgid="1381879916197350988">"Horaire"</string>
    <string name="zen_mode_automation_suggestion_title" msgid="7776129050500707960">"Tél. en silence à certains moments"</string>
    <string name="zen_mode_automation_suggestion_summary" msgid="1946750790084170826">"Créer des règles pour le mode Ne pas déranger"</string>
    <string name="zen_mode_schedule_title" msgid="7064866561892906613">"Horaire"</string>
    <string name="zen_mode_use_automatic_rule" msgid="733850322530002484">"Utiliser l\'horaire"</string>
    <string name="zen_mode_summary_combination" msgid="5944689309915947828">"<xliff:g id="MODE">%1$s</xliff:g> : <xliff:g id="EXIT_CONDITION">%2$s</xliff:g>"</string>
    <string name="zen_mode_settings_category" msgid="3794956668816783447">"Autoriser les interruptions qui émettent des sons"</string>
    <string name="zen_mode_visual_interruptions_settings_title" msgid="7806181124566937214">"Bloquer dérangements visuels"</string>
    <string name="zen_mode_visual_signals_settings_subtitle" msgid="7433077540895876672">"Autoriser les signaux visuels"</string>
    <string name="zen_mode_restrict_notifications_title" msgid="4169952466106040297">"Afficher les options pour les notifications masquées"</string>
    <string name="zen_mode_restrict_notifications_category" msgid="5870944770935394566">"Quand le mode Ne pas déranger est activé"</string>
    <string name="zen_mode_restrict_notifications_mute" msgid="6692072837485018287">"Aucun son des notifications"</string>
    <string name="zen_mode_restrict_notifications_mute_summary" msgid="966597459849580949">"Vous verrez des notifications sur l\'écran"</string>
    <string name="zen_mode_restrict_notifications_mute_footer" msgid="2152115038156049608">"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="5997930361607752541">"Aucun élément visuel ni son provenant des notifications"</string>
    <string name="zen_mode_restrict_notifications_hide_summary" msgid="6005445725686969583">"Vous ne verrez et n\'entendrez pas de notifications"</string>
    <string name="zen_mode_restrict_notifications_hide_footer" msgid="3761837271201073330">"Votre téléphone n\'affichera pas les notifications nouvelles ou existantes, ne vibrera pas et n\'émettra aucun son pour les signaler. Gardez à l\'esprit que les notifications importantes pour l\'activité et l\'état de l\'appareil continueront de s\'afficher.\n\nLorsque vous désactivez le mode Ne pas déranger, vous trouverez les notifications manquées en balayant l\'écran du haut vers le bas."</string>
    <string name="zen_mode_restrict_notifications_custom" msgid="5469078057954463796">"Personnalisées"</string>
    <string name="zen_mode_restrict_notifications_enable_custom" msgid="4303255634151330401">"Activer les paramètres personnalisés"</string>
    <string name="zen_mode_restrict_notifications_disable_custom" msgid="5062332754972217218">"Supprimer les paramètres personnalisés"</string>
    <string name="zen_mode_restrict_notifications_summary_muted" msgid="4750213316794189968">"Aucun son des notifications"</string>
    <string name="zen_mode_restrict_notifications_summary_custom" msgid="3918461289557316364">"Partiellement masquées"</string>
    <string name="zen_mode_restrict_notifications_summary_hidden" msgid="636494600775773296">"Aucun élément visuel ni son provenant des notifications"</string>
    <string name="zen_mode_what_to_block_title" msgid="5692710098205334164">"Restrictions personnalisées"</string>
    <string name="zen_mode_block_effects_screen_on" msgid="8780668375194500987">"Lorsque l\'écran est allumé"</string>
    <string name="zen_mode_block_effects_screen_off" msgid="2291988790355612826">"Lorsque l\'écran est éteint"</string>
    <string name="zen_mode_block_effect_sound" msgid="7929909410442858327">"Désactiver les sons et les vibrations"</string>
    <string name="zen_mode_block_effect_intent" msgid="7621578645742903531">"Ne pas activer l\'écran"</string>
    <string name="zen_mode_block_effect_light" msgid="1997222991427784993">"Ne pas faire clignoter la lumière"</string>
    <string name="zen_mode_block_effect_peek" msgid="2525844009475266022">"Ne pas afficher de notifications à l\'écran"</string>
    <string name="zen_mode_block_effect_status" msgid="5765965061064691918">"Masquer les icônes de la barre d\'état dans le haut de l\'écran"</string>
    <string name="zen_mode_block_effect_badge" msgid="332151258515152429">"Masquer les points de notification sur les icônes d\'application"</string>
    <string name="zen_mode_block_effect_ambient" msgid="1247740599476031543">"Ne pas réactiver pour les notifications"</string>
    <string name="zen_mode_block_effect_list" msgid="7549367848660137118">"Masquer du volet déroulant"</string>
    <string name="zen_mode_block_effect_summary_none" msgid="6688519142395714659">"Jamais"</string>
    <string name="zen_mode_block_effect_summary_screen_off" msgid="6989818116297061488">"Lorsque l\'écran est éteint"</string>
    <string name="zen_mode_block_effect_summary_screen_on" msgid="4876016548834916087">"Lorsque l\'écran est allumé"</string>
    <string name="zen_mode_block_effect_summary_sound" msgid="1559968890497946901">"Sons et vibrations"</string>
    <string name="zen_mode_block_effect_summary_some" msgid="2730383453754229650">"Sons, vibrations et certains signes visuels des notifications"</string>
    <string name="zen_mode_block_effect_summary_all" msgid="3131918059492425222">"Sons, vibrations et signes visuels des notifications"</string>
    <string name="zen_mode_blocked_effects_footer" msgid="6403365663466620328">"Les notifications nécessaires à l\'activité et à l\'état de base de l\'appareil ne seront jamais masquées."</string>
    <string name="zen_mode_no_exceptions" msgid="1580136061336585873">"Aucun"</string>
    <string name="zen_mode_other_options" msgid="3399967231522580421">"autres options"</string>
    <string name="zen_mode_add" msgid="8789024026733232566">"Ajouter"</string>
    <string name="zen_mode_enable_dialog_turn_on" msgid="1971034397501675078">"Activer"</string>
    <string name="zen_mode_button_turn_on" msgid="6583862599681052347">"Activer maintenant"</string>
    <string name="zen_mode_button_turn_off" msgid="2060862413234857296">"Désactiver maintenant"</string>
    <string name="zen_mode_settings_dnd_manual_end_time" msgid="8251503918238985549">"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="1436568478062106132">"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="1958092329238152236">"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="3401685760954156067">"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="6566115866660865385">"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="8255159194653341835">" "<annotation id="link">"Afficher les paramètres personnalisés"</annotation></string>
    <string name="zen_interruption_level_priority" msgid="4854123502362861192">"Prioritaires seulement"</string>
    <string name="zen_mode_and_condition" msgid="8580896862841920031">"<xliff:g id="ZEN_MODE">%1$s</xliff:g>. <xliff:g id="EXIT_CONDITION">%2$s</xliff:g>"</string>
    <string name="zen_mode_sound_summary_on_with_info" msgid="4803606180235742003">"Activé/<xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="zen_mode_sound_summary_on" msgid="9077659040104989899">"Activé"</string>
    <string name="zen_mode_duration_summary_always_prompt" msgid="7658172853423383037">"Toujours demander"</string>
    <string name="zen_mode_duration_summary_forever" msgid="5551992961329998606">"Jusqu\'à la désactivation"</string>
    <string name="zen_mode_duration_summary_time_hours" msgid="2602655749780428308">"{count,plural, =1{1 heure}one{# heure}other{# heures}}"</string>
    <string name="zen_mode_duration_summary_time_minutes" msgid="5755536844016835693">"{count,plural, =1{1 minute}one{# minute}other{# minutes}}"</string>
    <string name="zen_mode_sound_summary_off" msgid="7350437977839985836">"{count,plural, =0{Désactivé}=1{Désactivé : 1 horaire peut s\'activer automatiquement}one{Désactivé : # horaire peut s\'activer automatiquement}other{Désactivé : # horaires peuvent s\'activer automatiquement}}"</string>
    <string name="zen_category_behavior" msgid="3214056473947178507">"Ce qui peut interrompre le mode Ne pas déranger"</string>
    <string name="zen_category_people" msgid="8252926021894933047">"Personnes"</string>
    <string name="zen_category_apps" msgid="1167374545618451925">"Applications"</string>
    <string name="zen_category_exceptions" msgid="1316097981052752811">"Alarmes et autres interruptions"</string>
    <string name="zen_category_schedule" msgid="2003707171924226212">"Horaires"</string>
    <string name="zen_category_duration" msgid="7515850842082631460">"Durée des paramètres rapides"</string>
    <string name="zen_settings_general" msgid="2704932194620124153">"Général"</string>
    <string name="zen_sound_footer" msgid="4090291351903631977">"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_custom_settings_dialog_title" msgid="4613603772432720380">"Paramètres personnalisés"</string>
    <string name="zen_custom_settings_dialog_review_schedule" msgid="4674671820584759928">"Examiner l\'horaire"</string>
    <string name="zen_custom_settings_dialog_ok" msgid="8842373418878278246">"OK"</string>
    <string name="zen_custom_settings_notifications_header" msgid="7635280645171095398">"Notifications"</string>
    <string name="zen_custom_settings_duration_header" msgid="5065987827522064943">"Durée"</string>
    <string name="zen_msg_event_reminder_title" msgid="5362025129007417554">"Messages, événements et rappels"</string>
    <string name="zen_msg_event_reminder_footer" msgid="2700459146293750387">"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="8764248406533833392">"OK"</string>
    <string name="zen_onboarding_settings" msgid="2815839576245114342">"Paramètres"</string>
    <string name="zen_onboarding_new_setting_title" msgid="8813308612916316657">"Aucun élément visuel ni son provenant des notifications"</string>
    <string name="zen_onboarding_current_setting_title" msgid="5024603685220407195">"Aucun son des notifications"</string>
    <string name="zen_onboarding_new_setting_summary" msgid="7695808354942143707">"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="8864567406905990095">"(Paramètre actuel)"</string>
    <string name="zen_onboarding_dnd_visual_disturbances_header" msgid="8639698336231314609">"Modifier les paramètres de notification du mode Ne pas déranger?"</string>
    <string name="sound_work_settings" msgid="752627453846309092">"Sons du profil professionnel"</string>
    <string name="work_use_personal_sounds_title" msgid="7729428677919173609">"Utiliser les sons du profil personnel"</string>
    <string name="work_use_personal_sounds_summary" msgid="608061627969077231">"Utiliser les mêmes sons que votre profil personnel"</string>
    <string name="work_ringtone_title" msgid="4810802758746102589">"Sonnerie du téléphone professionnel"</string>
    <string name="work_notification_ringtone_title" msgid="2955312017013255515">"Son par défaut des notifications du profil professionnel"</string>
    <string name="work_alarm_ringtone_title" msgid="3369293796769537392">"Son par défaut des alarmes du profil professionnel"</string>
    <string name="work_sound_same_as_personal" msgid="1836913235401642334">"Comme pour le profil personnel"</string>
    <string name="work_sync_dialog_title" msgid="7810248132303515469">"Utiliser les sons du profil personnel?"</string>
    <string name="work_sync_dialog_yes" msgid="5785488304957707534">"Confirmer"</string>
    <string name="work_sync_dialog_message" msgid="5066178064994040223">"Votre profil professionnel utilisera les mêmes sons que votre profil personnel"</string>
    <string name="configure_notification_settings" msgid="1492820231694314376">"Notifications"</string>
    <string name="notification_dashboard_summary" msgid="7530169251902320652">"Historique des notifications, conversations"</string>
    <string name="conversation_notifs_category" msgid="2549844862379963273">"Conversation"</string>
    <string name="general_notification_header" msgid="3669031068980713359">"Gérer"</string>
    <string name="app_notification_field" msgid="3208079070539894909">"Notifications de l\'application"</string>
    <string name="app_notification_field_summary" msgid="5981393613897713471">"Contrôler les notifications provenant de chaque application"</string>
    <string name="advanced_section_header" msgid="6478709678084326738">"Général"</string>
    <string name="profile_section_header" msgid="4970209372372610799">"Notifications professionnelles"</string>
    <string name="profile_section_header_for_advanced_privacy" msgid="8385775428904838579">"Profil professionnel"</string>
    <string name="asst_capability_prioritizer_title" msgid="1181272430009156556">"Priorité adaptative pour les notifications"</string>
    <string name="asst_capability_prioritizer_summary" msgid="954988212366568737">"Définir automatiquement les notifications à faible priorité sur Discrètes"</string>
    <string name="asst_capability_ranking_title" msgid="312998580233257581">"Classement adaptatif des notifications"</string>
    <string name="asst_capability_ranking_summary" msgid="2293524677144599450">"Classer automatiquement les notifications par pertinence"</string>
    <string name="asst_feedback_indicator_title" msgid="5169801869752395354">"Commentaires à propos des notifications adaptatives"</string>
    <string name="asst_feedback_indicator_summary" msgid="5862082842073307900">"Indiquer les ajustements apportés aux notifications et afficher l\'option de fournir des commentaires au système"</string>
    <string name="asst_importance_reset_title" msgid="6191265591976440115">"Réinitialiser l\'importance des notifications"</string>
    <string name="asst_importance_reset_summary" msgid="684794589254282667">"Réinitialiser les paramètres d\'importances modifiés par l\'utilisateur et autoriser l\'assistant des notifications à prioriser"</string>
    <string name="asst_capabilities_actions_replies_title" msgid="4392470465646394289">"Suggestions d\'actions et de réponses"</string>
    <string name="asst_capabilities_actions_replies_summary" msgid="416234323365645871">"Afficher automatiquement les suggestions d\'actions et de réponses"</string>
    <string name="notification_history_summary" msgid="5434741516307706892">"Afficher les notifications récentes et reportées"</string>
    <string name="notification_history" msgid="8663811361243456201">"Historique des notifications"</string>
    <string name="notification_history_toggle" msgid="9093762294928569030">"Utiliser l\'historique des notifications"</string>
    <string name="notification_history_off_title_extended" msgid="853807652537281601">"L\'historique des notifications a été désactivé"</string>
    <string name="notification_history_off_summary" msgid="671359587084797617">"Activez l\'historique des notifications pour afficher les anciennes notifications et les notifications reportées"</string>
    <string name="history_toggled_on_title" msgid="4518001110492652830">"Aucune notification récente"</string>
    <string name="history_toggled_on_summary" msgid="9034278971358282728">"Vos notifications récentes et celles que vous avez reportées s\'afficheront ici"</string>
    <string name="notification_history_view_settings" msgid="5269317798670449002">"afficher les paramètres de notification"</string>
    <string name="notification_history_open_notification" msgid="2655071846911258371">"ouvrir la notification"</string>
    <string name="snooze_options_title" msgid="2109795569568344617">"Autoriser le report des notifications"</string>
    <string name="notification_badging_title" msgid="5469616894819568917">"Pastille de notification sur l\'icône de l\'application"</string>
    <string name="notification_bubbles_title" msgid="5681506665322329301">"Bulles"</string>
    <string name="bubbles_app_toggle_title" msgid="5319021259954576150">"Bulles"</string>
    <string name="bubbles_conversation_toggle_title" msgid="5225039214083311316">"Afficher cette conversation sous forme de bulles"</string>
    <string name="bubbles_conversation_toggle_summary" msgid="720229032254323578">"Afficher une icône flottante par-dessus les applications"</string>
    <string name="bubbles_feature_disabled_dialog_title" msgid="1794193899792284007">"Activer les bulles à l\'échelle de l\'appareil?"</string>
    <string name="bubbles_feature_disabled_dialog_text" msgid="5275666953364031055">"L\'activation des bulles pour cette application activera aussi les bulles pour votre appareil.\n\nCela a un impact sur les autres applications ou les conversations qui peuvent s\'afficher en bulles."</string>
    <string name="bubbles_feature_disabled_button_approve" msgid="2042628067101419871">"Activer"</string>
    <string name="bubbles_feature_disabled_button_cancel" msgid="8963409459448350600">"Annuler"</string>
    <string name="notifications_bubble_setting_on_summary" msgid="4641572377430901196">"Activées : les conversations peuvent s\'afficher sous forme d\'icônes flottantes"</string>
    <string name="notifications_bubble_setting_title" msgid="8287649393774855268">"Autoriser les applications à afficher des bulles"</string>
    <string name="notifications_bubble_setting_description" msgid="7336770088735025981">"Certaines conversations s\'afficheront sous forme d\'icônes flottantes superposées aux autres applications"</string>
    <string name="bubble_app_setting_all" msgid="312524752846978277">"Toutes les conversations peuvent s\'afficher dans des bulles"</string>
    <string name="bubble_app_setting_selected" msgid="4324386074198040675">"Les conversations sélectionnées peuvent s\'afficher dans des bulles"</string>
    <string name="bubble_app_setting_none" msgid="8643594711863996418">"Aucune bulle n\'est autorisée"</string>
    <string name="bubble_app_setting_selected_conversation_title" msgid="3060958976857529933">"Conversations"</string>
    <string name="bubble_app_setting_excluded_conversation_title" msgid="324818960338773945">"Toutes les conversations peuvent s\'afficher en bulles, sauf"</string>
    <string name="bubble_app_setting_unbubble_conversation" msgid="1769789500566080427">"Désactiver les bulles pour cette conversation"</string>
    <string name="bubble_app_setting_bubble_conversation" msgid="1461981680982964285">"Activer les bulles pour cette conversation"</string>
    <string name="swipe_direction_ltr" msgid="5137180130142633085">"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="1707391213940663992">"Balayer l\'écran vers la gauche pour fermer la notification ou vers la droite pour afficher le menu"</string>
    <string name="silent_notifications_status_bar" msgid="6113307620588767516">"Masquer les notifications silencieuses dans la barre d\'état"</string>
    <string name="notification_pulse_title" msgid="8013178454646671529">"Faire clignoter le voyant"</string>
    <string name="lock_screen_notifications_title" msgid="2876323153692406203">"Confidentialité"</string>
    <string name="lockscreen_bypass_title" msgid="6519964196744088573">"Ignorer l\'écran de verrouillage"</string>
    <!-- no translation found for lockscreen_bypass_summary (4578154430436224161) -->
    <skip />
    <string name="keywords_lockscreen_bypass" msgid="41035425468915498">"Écran de verrouillage, écran verrouillé, ignorer, contourner"</string>
    <string name="locked_work_profile_notification_title" msgid="279367321791301499">"Lorsque le profil professionnel est verrouillé"</string>
    <string name="unseen_notifs_lock_screen" msgid="6910701117021324612">"Afficher seul. les nouv. notif. sur l\'écran de verrouillage."</string>
    <string name="unseen_notifs_lock_screen_summary" msgid="5996722793868021391">"Retirez automatiquement les notifications consultées de l\'écran de verrouillage"</string>
    <string name="lock_screen_notifs_title" msgid="3412042692317304449">"Notifications sur l\'écran de verrouillage"</string>
    <string name="lock_screen_notifs_show_all_summary" msgid="4226586018375762117">"Afficher les conversations, par défaut et silencieuses"</string>
    <string name="lock_screen_notifs_show_all" msgid="1300418674456749664">"Afficher les conversations, par défaut et silencieuses"</string>
    <string name="lock_screen_notifs_show_alerting" msgid="6584682657382684566">"Masquer les conversations et les notifications silencieuses"</string>
    <string name="lock_screen_notifs_show_none" msgid="1941044980403067101">"N\'afficher aucune notification"</string>
    <string name="lock_screen_notifs_redact" msgid="9024158855454642296">"Notifications sensibles"</string>
    <string name="lock_screen_notifs_redact_summary" msgid="1395483766035470612">"Afficher le contenu sensible lorsque l\'écran est verrouillé"</string>
    <string name="lock_screen_notifs_redact_work" msgid="3833920196569208430">"Notifications confidentielles du profil professionnel"</string>
    <string name="lock_screen_notifs_redact_work_summary" msgid="3238238380405430156">"Afficher le contenu sensible du profil professionnel lorsque l\'écran est verrouillé"</string>
    <string name="lock_screen_notifications_summary_show" msgid="6540443483088311328">"Afficher tout le contenu des notifications"</string>
    <string name="lock_screen_notifications_summary_hide" msgid="7837303171531166789">"N\'afficher le contenu sensible que si déverrouillé"</string>
    <string name="lock_screen_notifications_summary_disable" msgid="3388290397947365744">"N\'afficher aucune notification"</string>
    <string name="lock_screen_notifications_interstitial_message" msgid="4688399629301178487">"Que souhaitez-vous afficher sur l\'écran de verrouillage?"</string>
    <string name="lock_screen_notifications_interstitial_title" msgid="1360388192096354315">"Écran de verrouillage"</string>
    <string name="lock_screen_notifications_summary_show_profile" msgid="8373401288962523946">"Afficher tout le contenu des notif. professionn."</string>
    <string name="lock_screen_notifications_summary_hide_profile" msgid="2183455323048921579">"Masquer le contenu professionnel sensible"</string>
    <string name="lock_screen_notifications_interstitial_message_profile" msgid="1456262034599029028">"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="6950124772255324448">"Notifications de profil"</string>
    <string name="notifications_title" msgid="4221655533193721131">"Notifications"</string>
    <string name="app_notifications_title" msgid="248374669037385148">"Notifications de l\'appli"</string>
    <string name="notification_channel_title" msgid="8859880871692797611">"Catégorie de notifications"</string>
    <string name="notification_importance_title" msgid="1545158655988342703">"Comportement"</string>
    <string name="conversations_category_title" msgid="5586541340846847798">"Conversations"</string>
    <string name="conversation_section_switch_title" msgid="3332885377659473775">"Section des conversations"</string>
    <string name="conversation_section_switch_summary" msgid="6123587625929439674">"Autoriser l\'application à utiliser la section des conversations"</string>
    <string name="demote_conversation_title" msgid="6355383023376508485">"Ce n\'est pas une conversation"</string>
    <string name="demote_conversation_summary" msgid="4319929331165604112">"Supprimer de la section des conversations"</string>
    <string name="promote_conversation_title" msgid="4731148769888238722">"C\'est une conversation"</string>
    <string name="promote_conversation_summary" msgid="3890724115743515035">"Ajouter à la section des conversations"</string>
    <string name="priority_conversation_count_zero" msgid="3862289535537564713">"Aucune conversation prioritaire"</string>
    <string name="priority_conversation_count" msgid="7291234530844412077">"{count,plural, =1{# conversation prioritaire}one{# conversation prioritaire}other{# conversations prioritaires}}"</string>
    <string name="important_conversations" msgid="1233893707189659401">"Conversations prioritaires"</string>
    <string name="important_conversations_summary_bubbles" msgid="614327166808117644">"Afficher dans le haut de la section des conversations comme bulles flottantes"</string>
    <string name="important_conversations_summary" msgid="3184022761562676418">"Afficher dans le haut de la section des conversations"</string>
    <string name="other_conversations" msgid="551178916855139870">"Conversations non prioritaires"</string>
    <string name="other_conversations_summary" msgid="3487426787901236273">"Conversations auxquelles vous avez apporté des modifications"</string>
    <string name="recent_conversations" msgid="471678228756995274">"Conversations récentes"</string>
    <string name="conversation_settings_clear_recents" msgid="8940398397663307054">"Effacer les conversations récentes"</string>
    <string name="recent_convos_removed" msgid="2122932798895714203">"Conversations récentes retirées"</string>
    <string name="recent_convo_removed" msgid="8686414146325958281">"Conversation retirée"</string>
    <string name="clear" msgid="5092178335409471100">"Effacer"</string>
    <string name="conversation_onboarding_title" msgid="5194559958353468484">"Les conversations prioritaires et modifiées s\'afficheront ici"</string>
    <string name="conversation_onboarding_summary" msgid="2484845363368486941">"Lorsque vous marquez des conversations comme prioritaires, ou si vous apportez d\'autres modifications aux conversations, elles s\'afficheront ici. \n\nPour modifier les paramètres de conversation : \nbalayez l\'écran du haut vers le bas pour ouvrir le volet déroulant, puis maintenez le doigt sur une conversation."</string>
    <string name="notification_importance_min_title" msgid="7676541266705442501">"Réduire"</string>
    <string name="notification_importance_high_title" msgid="394129291760607808">"Afficher sur l\'écran"</string>
    <string name="notification_silence_title" msgid="4085829874452944989">"Mode silencieux"</string>
    <string name="notification_alert_title" msgid="1632401211722199217">"Par défaut"</string>
    <string name="allow_interruption" msgid="5237201780159482716">"Autoriser les interruptions"</string>
    <string name="allow_interruption_summary" msgid="9044131663518112543">"Autoriser l\'application à émettre des sons, à vibrer et à afficher des notifications à l\'écran"</string>
    <string name="notification_priority_title" msgid="5554834239080425229">"Prioritaire"</string>
    <string name="notification_channel_summary_priority" msgid="7225362351439076913">"S\'affiche en haut de la section des conversations sous forme de bulle flottante et affiche la photo du profil sur l\'écran de verrouillage"</string>
    <string name="convo_not_supported_summary" msgid="4285471045268268048">"<xliff:g id="APP_NAME">%1$s</xliff:g> ne prend pas en charge la majorité des fonctionnalités de conversations. Vous ne pouvez pas définir une conversation comme prioritaire, et les conversations ne s\'afficheront pas comme bulles flottantes."</string>
    <string name="notification_channel_summary_min" msgid="8823399508450176842">"Dans le volet déroulant, afficher les notifications sur une seule ligne"</string>
    <string name="notification_channel_summary_low" msgid="5549662596677692000">"Aucun son ni vibration"</string>
    <string name="notification_conversation_summary_low" msgid="6352818857388412326">"Aucun son ni vibration, et s\'affiche plus bas dans la section des conversations"</string>
    <string name="notification_channel_summary_default" msgid="3674057458265438896">"Peut sonner ou vibrer, selon les paramètres du téléphone"</string>
    <string name="notification_channel_summary_high" msgid="3411637309360617621">"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="8029371325967501557">"Toutes les notifications de « <xliff:g id="APP_NAME">%1$s</xliff:g> »"</string>
    <string name="notification_app_switch_label" msgid="4422902423925084193">"Toutes les notifications de <xliff:g id="APP_NAME">%1$s</xliff:g>"</string>
    <string name="notifications_sent_daily" msgid="10274479224185437">"{count,plural, =1{Environ # notification par jour}one{Environ # notification par jour}other{Environ # notifications par jour}}"</string>
    <string name="notifications_sent_weekly" msgid="7895656213187555346">"{count,plural, =1{Environ # notification par semaine}one{Environ # notification par semaine}other{Environ # notifications par semaine}}"</string>
    <string name="notifications_sent_never" msgid="9081278709126812062">"Jamais"</string>
    <string name="manage_notification_access_title" msgid="6481256069087219982">"Notifications de l\'appareil et des applications"</string>
    <string name="manage_notification_access_summary" msgid="2907135226478903997">"Contrôler quelles applications et quels appareils peuvent lire les notifications"</string>
    <string name="work_profile_notification_access_blocked_summary" msgid="8643809206612366067">"L\'accès aux notifications du profil professionnel est bloqué"</string>
    <string name="notification_assistant_title" msgid="5889201903272393099">"Notifications améliorées"</string>
    <string name="notification_assistant_summary" msgid="1957783114840908887">"Recevoir des suggestions d\'actions, de réponses et plus encore"</string>
    <string name="no_notification_assistant" msgid="2533323397091834096">"Aucune"</string>
    <string name="no_notification_listeners" msgid="2839354157349636000">"Aucune demande d\'accès aux notifications n\'a été envoyée pour les applications installées."</string>
    <string name="notification_access_detail_switch" msgid="46386786409608330">"Autoriser l\'accès aux notifications"</string>
    <string name="notification_assistant_security_warning_summary" msgid="4846559755787348129">"Les notifications améliorées ont remplacé les notifications adaptatives Android sous Android 12. Cette fonctionnalité vous présente des suggestions d\'actions et de réponses, et organise vos notifications. \n\nLes notifications améliorées peuvent accéder au contenu de toutes les notifications, y compris les renseignements personnels comme le nom des contacts et les messages. Cette fonctionnalité peut aussi fermer des notifications ou interagir avec elles, comme répondre aux appels téléphoniques et gérer le mode Ne pas déranger."</string>
    <string name="notification_listener_security_warning_title" msgid="5791700876622858363">"Autoriser <xliff:g id="SERVICE">%1$s</xliff:g> à accéder aux notifications?"</string>
    <string name="notification_listener_security_warning_summary" msgid="1131986567509818121">"L\'application <xliff:g id="NOTIFICATION_LISTENER_NAME">%1$s</xliff:g> pourra lire toutes les notifications, y compris les renseignements personnels tels que les noms des contacts, les photos et le texte des messages que vous recevez. Cette application pourra également répéter ou fermer des notifications, ou effectuer des actions sur des boutons dans les notifications, y compris répondre à des appels téléphoniques. \n\nCette action permettra également à l\'application d\'activer et de désactiver la fonctionnalité Ne pas déranger et de modifier les paramètres connexes."</string>
    <string name="nls_warning_prompt" msgid="1486887096703743841">"L\'application <xliff:g id="NOTIFICATION_LISTENER_NAME">%1$s</xliff:g> pourra effectuer les actions suivantes :"</string>
    <string name="nls_feature_read_title" msgid="7629713268744220437">"Lire vos notifications"</string>
    <string name="nls_feature_read_summary" msgid="1064698238110273593">"Elle peut lire vos notifications, y compris les renseignements personnels, comme les contacts, les messages et les photos."</string>
    <string name="nls_feature_reply_title" msgid="7925455553821362039">"Répondre aux messages"</string>
    <string name="nls_feature_reply_summary" msgid="4492543411395565556">"Elle peut répondre aux messages et agir sur les boutons dans les notifications, y compris faire répéter ou ignorer des notifications et répondre à des appels."</string>
    <string name="nls_feature_settings_title" msgid="8208164329853194414">"Modifier les paramètres"</string>
    <string name="nls_feature_settings_summary" msgid="3770028705648985689">"Elle peut activer ou désactiver la fonctionnalité Ne pas déranger et modifier les paramètres connexes."</string>
    <string name="notification_listener_disable_warning_summary" msgid="8373396293802088961">"Si vous désactivez l\'accès aux notifications pour <xliff:g id="NOTIFICATION_LISTENER_NAME">%1$s</xliff:g>, l\'accès au mode Ne pas déranger peut également être désactivé."</string>
    <string name="notification_listener_disable_warning_confirm" msgid="841492108402184976">"Désactiver"</string>
    <string name="notification_listener_disable_warning_cancel" msgid="8802784105045594324">"Annuler"</string>
    <string name="notif_type_ongoing" msgid="135675014223627555">"En temps réel"</string>
    <string name="notif_type_ongoing_summary" msgid="2348867528527573574">"Communications actives dans les applications en cours d\'utilisation, navigation, appels téléphoniques, etc."</string>
    <string name="notif_type_conversation" msgid="4383931408641374979">"Conversations"</string>
    <string name="notif_type_conversation_summary" msgid="179142405410217101">"Messages texte et autres communications"</string>
    <string name="notif_type_alerting" msgid="4713073696855718576">"Notifications"</string>
    <string name="notif_type_alerting_summary" msgid="4681068287836313604">"Peut sonner ou vibrer, selon les paramètres"</string>
    <string name="notif_type_silent" msgid="6273951794420331010">"Mode silencieux"</string>
    <string name="notif_type_silent_summary" msgid="7820923063105060844">"Votre téléphone ne sonnera ou ne vibrera pas lorsqu\'il reçoit ces notifications"</string>
    <string name="notification_listener_allowed" msgid="5536962633536318551">"Autorisées"</string>
    <string name="notification_listener_not_allowed" msgid="3352962779597846538">"Non autorisées"</string>
    <string name="notif_listener_excluded_app_title" msgid="6679316209330349730">"Afficher toutes les applications"</string>
    <string name="notif_listener_excluded_app_summary" msgid="2914567678047195396">"Modifier les paramètres pour chaque application qui envoie des notifications"</string>
    <string name="notif_listener_excluded_app_screen_title" msgid="8636196723227432994">"Applications affichées sur l\'appareil"</string>
    <string name="notif_listener_not_migrated" msgid="6265206376374278226">"Cette application ne prend pas en charge les paramètres améliorés"</string>
    <string name="notif_listener_more_settings" msgid="1348409392307208921">"Plus de paramètres"</string>
    <string name="notif_listener_more_settings_desc" msgid="7995492074281663658">"Plus de paramètres sont accessibles dans cette application"</string>
    <string name="vr_listeners_title" msgid="4960357292472540964">"Services d\'assistance pour la réalité virtuelle"</string>
    <string name="no_vr_listeners" msgid="8442646085375949755">"Aucune demande d\'exécution en tant que services d\'assistance pour la réalité virtuelle n\'a été envoyée pour les applications installées."</string>
    <string name="vr_listener_security_warning_title" msgid="7026351795627615177">"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="1888843557687017791">"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="4850474436291113569">"Lorsque l\'appareil est en mode RV"</string>
    <string name="display_vr_pref_low_persistence" msgid="7039841277157739871">"Réduire le flou (recommandé)"</string>
    <string name="display_vr_pref_off" msgid="4008841566387432721">"Réduire le scintillement"</string>
    <string name="picture_in_picture_title" msgid="9001594281840542493">"Incrustation d\'image"</string>
    <string name="picture_in_picture_empty_text" msgid="9123600661268731579">"Aucune application installée n\'est compatible avec le mode d\'image incrusté"</string>
    <string name="picture_in_picture_keywords" msgid="3605379820551656253">"image incrustée, image dans image"</string>
    <string name="picture_in_picture_app_detail_title" msgid="4442235098255164650">"Incrustation d\'image"</string>
    <string name="picture_in_picture_app_detail_switch" msgid="8544190716075624017">"Autoriser l\'incrustation d\'image"</string>
    <string name="picture_in_picture_app_detail_summary" msgid="2503211101305358849">"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="interact_across_profiles_title" msgid="7285906999927669971">"Applis prof. et personnelles associées"</string>
    <string name="interact_across_profiles_summary_allowed" msgid="1365881452153799092">"Connectées"</string>
    <string name="interact_across_profiles_summary_not_allowed" msgid="5802674212788171790">"Non connectées"</string>
    <string name="interact_across_profiles_empty_text" msgid="419061031064397168">"Aucune application connectée"</string>
    <string name="interact_across_profiles_keywords" msgid="5996472773111665049">"application associée profil personnel et professionnel"</string>
    <string name="interact_across_profiles_switch_enabled" msgid="7294719120282287495">"Associées"</string>
    <string name="interact_across_profiles_switch_disabled" msgid="4312196170211463988">"Associer ces applications"</string>
    <string name="interact_across_profiles_summary_1" msgid="6093976896137600231">"Les applications associées partagent leurs autorisations, et chacune peut accéder aux données de l\'autre."</string>
    <string name="interact_across_profiles_summary_2" msgid="505748305453633885">"Connectez seulement des applications si vous avez confiance qu\'elles ne partageront pas de données personnelles avec votre administrateur informatique."</string>
    <string name="interact_across_profiles_summary_3" msgid="444428694843299854">"Vous pouvez dissocier des applications en tout temps dans les paramètres de confidentialité de votre appareil."</string>
    <string name="interact_across_profiles_consent_dialog_title" msgid="8530621211216508681">"Autoriser l\'application professionnelle <xliff:g id="NAME">%1$s</xliff:g> à accéder à vos données personnelles?"</string>
    <string name="interact_across_profiles_consent_dialog_summary" msgid="3949870271562055048">"Connectez seulement des applications si vous avez confiance qu\'elles ne partageront pas de données personnelles avec votre administrateur informatique."</string>
    <string name="interact_across_profiles_consent_dialog_app_data_title" msgid="8436318876213958940">"Données de l\'application"</string>
    <string name="interact_across_profiles_consent_dialog_app_data_summary" msgid="6057019384328088311">"Cette application peut accéder aux données de votre application personnelle <xliff:g id="NAME">%1$s</xliff:g>."</string>
    <string name="interact_across_profiles_consent_dialog_permissions_title" msgid="2316852600280487055">"Autorisations"</string>
    <string name="interact_across_profiles_consent_dialog_permissions_summary" msgid="995051542847604039">"Cette application peut utiliser les autorisations de votre application personnelle <xliff:g id="NAME">%1$s</xliff:g>, comme l\'accès à votre position, à votre espace de stockage ou à vos contacts."</string>
    <string name="interact_across_profiles_number_of_connected_apps_none" msgid="8573289199942092964">"Aucune application associée"</string>
    <string name="interact_across_profiles_number_of_connected_apps" msgid="4000424798291479207">"{count,plural, =1{# application connectée}one{# application connectée}other{# applications connectées}}"</string>
    <string name="interact_across_profiles_install_work_app_title" msgid="2821669067014436056">"Pour connecter ces applications, installez <xliff:g id="NAME">%1$s</xliff:g> dans votre profil professionnel"</string>
    <string name="interact_across_profiles_install_personal_app_title" msgid="4790651223324866344">"Pour connecter ces applications, installez <xliff:g id="NAME">%1$s</xliff:g> dans votre profil personnel"</string>
    <string name="interact_across_profiles_install_app_summary" msgid="7715324358034968657">"Touchez pour télécharger l\'application"</string>
    <string name="manage_zen_access_title" msgid="1562322900340107269">"Accès à Ne pas déranger"</string>
    <string name="zen_access_detail_switch" msgid="4183681772666138993">"Autoriser le mode Ne pas déranger"</string>
    <string name="zen_access_empty_text" msgid="3779921853282293080">"Aune application installée n\'a demandé l\'accès au mode « Ne pas déranger »"</string>
    <string name="app_notifications_off_desc" msgid="2484843759466874201">"Vous n\'avez pas autorisé les notifications de cette application"</string>
    <string name="channel_notifications_off_desc" msgid="6202042207121633488">"À 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="9096417708500595424">"À votre demande, Android empêche ce groupe de notifications de s\'afficher sur cet appareil"</string>
    <string name="app_notifications_not_send_desc" msgid="5683060986735070528">"Cette application n\'envoie pas de notifications"</string>
    <string name="notification_channels" msgid="1502969522886493799">"Catégories"</string>
    <string name="notification_channels_other" msgid="18159805343647908">"Autre"</string>
    <string name="no_channels" msgid="4716199078612071915">"Cette application n\'a publié aucune notification"</string>
    <string name="app_settings_link" msgid="6725453466705333311">"Paramètres supplémentaires dans l\'application"</string>
    <string name="deleted_channels" msgid="8489800381509312964">"{count,plural, =1{# catégorie supprimée}one{# catégorie supprimée}other{# catégories supprimées}}"</string>
    <string name="app_notification_block_title" msgid="3880322745749900296">"Tout bloquer"</string>
    <string name="app_notification_block_summary" msgid="1804611676339341551">"Ne jamais afficher ces notifications"</string>
    <string name="notification_content_block_title" msgid="6689085826061361351">"Afficher les notifications"</string>
    <string name="notification_content_block_summary" msgid="329171999992248925">"Ne jamais afficher les notifications dans l\'ombre ou sur des appareils périphériques"</string>
    <string name="notification_badge_title" msgid="6854537463548411313">"Autoriser la pastille de notification"</string>
    <string name="notification_channel_badge_title" msgid="6505542437385640049">"Afficher la pastille de notification"</string>
    <string name="app_notification_override_dnd_title" msgid="3769539356442226691">"Ignorer le mode Ne pas déranger"</string>
    <string name="app_notification_override_dnd_summary" msgid="4894641191397562920">"Activer ces notifications même lorsque le mode Ne pas déranger est activé"</string>
    <string name="app_notification_visibility_override_title" msgid="7778628150022065920">"Écran de verrouillage"</string>
    <string name="app_notifications_dialog_done" msgid="573716608705273004">"Terminé"</string>
    <string name="notification_show_lights_title" msgid="5564315979007438583">"Faire clignoter le voyant"</string>
    <string name="notification_vibrate_title" msgid="1422330728336623351">"Vibration"</string>
    <string name="notification_channel_sound_title" msgid="9018031231387273476">"Son"</string>
    <string name="notification_conversation_important" msgid="4365437037763608045">"Priorité"</string>
    <string name="zen_mode_rule_name" msgid="7303080427006917702">"Nom de l\'horaire"</string>
    <string name="zen_mode_rule_name_hint" msgid="7029432803855827697">"Entrez le nom de l\'horaire"</string>
    <string name="zen_mode_rule_name_warning" msgid="1244435780807634954">"Ce nom d\'horaire existe déjà"</string>
    <string name="zen_mode_add_rule" msgid="4217731747959400770">"Ajouter"</string>
    <string name="zen_mode_add_event_rule" msgid="9179404395950854471">"Ajouter un horaire d\'événement"</string>
    <string name="zen_mode_add_time_rule" msgid="2621320450155364432">"Ajouter un horaire temporel"</string>
    <string name="zen_mode_choose_rule_type" msgid="7656308563653982975">"Choisir le type d\'horaire"</string>
    <string name="zen_mode_delete_rule_confirmation" msgid="6195069346439736688">"Supprimer la règle « <xliff:g id="RULE">%1$s</xliff:g> »?"</string>
    <string name="zen_mode_delete_rule_button" msgid="8328729110756882244">"Supprimer"</string>
    <string name="zen_mode_app_set_behavior" msgid="4319517270279704677">"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="8544413884273894104">"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="3805244555649172848">"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="8071428540221112090">"Heure"</string>
    <string name="zen_event_rule_type_name" msgid="1921166617081971754">"Événement"</string>
    <string name="zen_mode_event_rule_calendar" msgid="6279460374929508907">"Pendant les événements suivants :"</string>
    <string name="zen_mode_event_rule_calendar_any" msgid="5152139705998281205">"Tout agenda"</string>
    <string name="zen_mode_event_rule_reply" msgid="6099405414361340225">"Si la réponse est"</string>
    <string name="zen_mode_event_rule_reply_any_except_no" msgid="4672746760505346596">"Oui, Peut-être ou Sans réponse"</string>
    <string name="zen_mode_event_rule_reply_yes_or_maybe" msgid="6584448788100186574">"Oui ou Peut-être"</string>
    <string name="zen_mode_event_rule_reply_yes" msgid="7812120982734551236">"Oui"</string>
    <string name="zen_mode_rule_not_found_text" msgid="5303667326973891036">"Règle non trouvée."</string>
    <string name="zen_mode_rule_summary_enabled_combination" msgid="1183604368083885789">"Mode <xliff:g id="MODE">%1$s</xliff:g> activé"</string>
    <string name="zen_mode_rule_summary_provider_combination" msgid="785343032708491365">"<xliff:g id="PACKAGE">%1$s</xliff:g>\n<xliff:g id="SUMMARY">%2$s</xliff:g>"</string>
    <string name="zen_mode_schedule_rule_days" msgid="8633770815307716351">"Jours"</string>
    <string name="zen_mode_schedule_rule_days_none" msgid="5636604196262227070">"Aucun"</string>
    <string name="zen_mode_schedule_alarm_title" msgid="305237266064819345">"L\'alarme peut remplacer l\'heure de fin"</string>
    <string name="zen_mode_schedule_alarm_summary" msgid="9162760856136645133">"L\'horaire sera désactivé lorsque l\'alarme sonnera"</string>
    <string name="zen_mode_custom_behavior_title" msgid="92525364576358085">"Comportement du mode Ne pas déranger"</string>
    <string name="zen_mode_custom_behavior_summary_default" msgid="3259312823717839148">"Utiliser les paramètres par défaut"</string>
    <string name="zen_mode_custom_behavior_summary" msgid="5390522750884328843">"Personnaliser cet horaire"</string>
    <string name="zen_mode_custom_behavior_category_title" msgid="7815612569425733764">"Pour « <xliff:g id="SCHEDULE_NAME">%1$s</xliff:g> »"</string>
    <string name="summary_divider_text" msgid="8836285171484563986">", "</string>
    <string name="summary_range_symbol_combination" msgid="8447490077794415525">"<xliff:g id="START">%1$s</xliff:g> à <xliff:g id="END">%2$s</xliff:g>"</string>
    <string name="zen_mode_conversations_title" msgid="5491912973456026379">"Conversations"</string>
    <string name="zen_mode_from_all_conversations" msgid="3447000451361857061">"Toutes les conversations"</string>
    <string name="zen_mode_from_important_conversations" msgid="528050873364229253">"Conversations prioritaires"</string>
    <string name="zen_mode_from_important_conversations_second" msgid="7588299891972136599">"conversations prioritaires"</string>
    <string name="zen_mode_from_no_conversations" msgid="3924593219855567165">"Aucune"</string>
    <string name="zen_mode_conversations_count" msgid="3199310723073707153">"{count,plural, =0{Aucune}=1{1 conversation}one{# conversation}other{# conversations}}"</string>
    <string name="zen_mode_people_calls_messages_section_title" msgid="6815202112413762206">"Qui peut provoquer des interruptions"</string>
    <string name="zen_mode_people_footer" msgid="7710707353004137431">"Même si vous ne pouvez pas recevoir de notifications des applications de messagerie ou de téléphonie, les personnes que vous choisissez ici peuvent toujours vous joindre par le biais de celles-ci"</string>
    <string name="zen_mode_calls_title" msgid="2078578043677037740">"Appels"</string>
    <string name="zen_mode_calls" msgid="7653245854493631095">"Appels"</string>
    <string name="zen_mode_calls_list" msgid="5044730950895749093">"appels"</string>
    <string name="zen_mode_calls_header" msgid="8379225445095856726">"Appels qui peuvent provoquer des interruptions"</string>
    <string name="zen_mode_calls_footer" msgid="2008079711083701243">"Pour vous assurer que les appels autorisés émettent un son, vérifiez si votre appareil est réglé pour sonner"</string>
    <string name="zen_mode_custom_calls_footer" msgid="6521283204577441053">"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="630299631659575589">"Contacts marqués d\'une étoile"</string>
    <string name="zen_mode_starred_contacts_summary_contacts" msgid="1629467178444895094">"{count,plural,offset:2 =0{Aucun}=1{{contact_1}}=2{{contact_1} et {contact_2}}=3{{contact_1}, {contact_2} et {contact_3}}one{{contact_1}, {contact_2} et # autre}other{{contact_1}, {contact_2} et # autres}}"</string>
    <string name="zen_mode_starred_contacts_empty_name" msgid="2906404745550293688">"(Sans nom)"</string>
    <string name="zen_mode_messages" msgid="7315084748885170585">"Messages"</string>
    <string name="zen_mode_messages_list" msgid="5431014101342361882">"messages"</string>
    <string name="zen_mode_messages_title" msgid="1777598523485334405">"Messages"</string>
    <string name="zen_mode_messages_header" msgid="253721635061451577">"Messages qui peuvent provoquer des interruptions"</string>
    <string name="zen_mode_messages_footer" msgid="6002468050854126331">"Pour vous assurer que les messages autorisés émettent un son, vérifiez si votre appareil est réglé pour sonner"</string>
    <string name="zen_mode_custom_messages_footer" msgid="7545180036949550830">"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_all_messages_summary" msgid="3756267858343104554">"Tous les messages peuvent vous parvenir"</string>
    <string name="zen_mode_all_calls_summary" msgid="7337907849083824698">"Tous les appels peuvent vous parvenir"</string>
    <string name="zen_mode_contacts_count" msgid="6568631261119795799">"{count,plural, =0{Aucun}=1{1 contact}one{# contact}other{# contacts}}"</string>
    <string name="zen_mode_from_anyone" msgid="6027004263046694174">"Tout le monde"</string>
    <string name="zen_mode_from_contacts" msgid="2989933306317064818">"Contacts"</string>
    <string name="zen_mode_from_starred" msgid="8616516644241652287">"Contacts marqués d\'une étoile"</string>
    <string name="zen_mode_none_calls" msgid="2047166006414016327">"Aucun"</string>
    <string name="zen_mode_none_messages" msgid="1386626352943268342">"Aucun"</string>
    <string name="zen_mode_alarms" msgid="5989343060100771099">"Alarmes"</string>
    <string name="zen_mode_alarms_summary" msgid="3388679177457223967">"Des minuteries, des alarmes, des systèmes de sécurité et d\'autres applications"</string>
    <string name="zen_mode_alarms_list" msgid="334782233067365405">"alarmes"</string>
    <string name="zen_mode_alarms_list_first" msgid="2780418316613576610">"Alarmes"</string>
    <string name="zen_mode_media" msgid="885017672250984735">"Sons des éléments multimédias"</string>
    <string name="zen_mode_media_summary" msgid="7174081803853351461">"Sons des vidéos, des jeux et d\'autres éléments multimédias"</string>
    <string name="zen_mode_media_list" msgid="2006413476596092020">"média"</string>
    <string name="zen_mode_media_list_first" msgid="7824427062528618442">"Éléments multimédias"</string>
    <string name="zen_mode_system" msgid="7301665021634204942">"Sons des touches"</string>
    <string name="zen_mode_system_summary" msgid="7225581762792177522">"Sons du clavier et des autres boutons"</string>
    <string name="zen_mode_system_list" msgid="2256218792042306434">"sons des touches"</string>
    <string name="zen_mode_system_list_first" msgid="8590078626001067855">"Sons des touches"</string>
    <string name="zen_mode_reminders" msgid="1970224691551417906">"Rappels"</string>
    <string name="zen_mode_reminders_summary" msgid="3961627037429412382">"Des tâches et des rappels"</string>
    <string name="zen_mode_reminders_list" msgid="3133513621980999858">"rappels"</string>
    <string name="zen_mode_reminders_list_first" msgid="1130470396012190814">"Rappels"</string>
    <string name="zen_mode_events" msgid="7425795679353531794">"Événements de l\'agenda"</string>
    <string name="zen_mode_events_summary" msgid="3241903481309766428">"Des événements de l\'agenda à venir"</string>
    <string name="zen_mode_events_list" msgid="7191316245742097229">"événements"</string>
    <string name="zen_mode_events_list_first" msgid="7425369082835214361">"Événements"</string>
    <string name="zen_mode_bypassing_apps" msgid="625309443389126481">"Autoriser les applications à ignorer le mode Ne pas déranger"</string>
    <string name="zen_mode_bypassing_apps_header" msgid="60083006963906906">"Applications qui peuvent provoquer des interruptions"</string>
    <string name="zen_mode_bypassing_apps_add_header" msgid="3201829605075172536">"Sélectionner plus d\'applications"</string>
    <string name="zen_mode_bypassing_apps_none" msgid="7944221631721778096">"Aucune application sélectionnée"</string>
    <string name="zen_mode_bypassing_apps_subtext_none" msgid="5128770411598722200">"Aucune application ne peut provoquer d\'interruption"</string>
    <string name="zen_mode_bypassing_apps_add" msgid="5031919618521327102">"Ajouter des applications"</string>
    <string name="zen_mode_bypassing_apps_summary_all" msgid="4684544706511555744">"Toutes les notifications"</string>
    <string name="zen_mode_bypassing_apps_summary_some" msgid="5315750826830358230">"Quelques notifications"</string>
    <string name="zen_mode_bypassing_apps_footer" msgid="1454862989340760124">"Les personnes sélectionnées peuvent toujours vous joindre, même si vous n\'autorisez pas les applications à provoquer des interruptions"</string>
    <string name="zen_mode_bypassing_apps_subtext" msgid="5258652366929842710">"{count,plural,offset:2 =0{Aucune application ne peut provoquer d\'interruption}=1{{app_1} peut provoquer des interruptions}=2{{app_1} et {app_2} peuvent provoquer des interruptions}=3{{app_1}, {app_2} et {app_3} peuvent provoquer des interruptions}one{{app_1}, {app_2} et # autre application peuvent provoquer des interruptions}other{{app_1}, {app_2} et # autres applications peuvent provoquer des interruptions}}"</string>
    <string name="zen_mode_bypassing_apps_title" msgid="371050263563164059">"Applications"</string>
    <string name="zen_mode_bypassing_app_channels_header" msgid="4011017798712587373">"Notifications qui peuvent provoquer des interruptions"</string>
    <string name="zen_mode_bypassing_app_channels_toggle_all" msgid="1449462656358219116">"Autoriser toutes les notifications"</string>
    <string name="zen_mode_other_sounds_summary" msgid="8784400697494837032">"{count,plural,offset:2 =0{Rien ne peut provoquer d\'interruption}=1{{sound_category_1} peut provoquer des interruptions}=2{{sound_category_1} et {sound_category_2} peuvent provoquer des interruptions}=3{{sound_category_1}, {sound_category_2} et {sound_category_3} peuvent provoquer des interruptions}one{{sound_category_1}, {sound_category_2} et # autre application peuvent provoquer des interruptions}other{{sound_category_1}, {sound_category_2} et # autres applications peuvent provoquer des interruptions}}"</string>
    <string name="zen_mode_sounds_none" msgid="6557474361948269420">"Rien ne peut provoquer d\'interruption"</string>
    <string name="zen_mode_people_none" msgid="4613147461974255046">"Personne ne peut provoquer d\'interruption"</string>
    <string name="zen_mode_people_some" msgid="9101872681298810281">"Certaines personnes peuvent provoquer des interruptions"</string>
    <string name="zen_mode_people_all" msgid="311036110283015205">"Tout le monde peut provoquer des interruptions"</string>
    <string name="zen_mode_repeat_callers" msgid="2270356100287792138">"Appelants fréquents"</string>
    <string name="zen_mode_repeat_callers_title" msgid="8016699240338264781">"Autoriser les appels répétés"</string>
    <string name="zen_mode_all_callers" msgid="8104755389401941875">"n\'importe qui"</string>
    <string name="zen_mode_contacts_callers" msgid="5429267704011896833">"contacts"</string>
    <string name="zen_mode_starred_callers" msgid="1002370699564211178">"contacts marqués d\'une étoile"</string>
    <string name="zen_mode_repeat_callers_list" msgid="181819778783743847">"appelants fréquents"</string>
    <!-- no translation found for zen_mode_calls_summary_one (1928015516061784276) -->
    <skip />
    <string name="zen_mode_calls_summary_two" msgid="6351563496898410742">"<xliff:g id="CALLER_TYPE_0">%1$s</xliff:g> et <xliff:g id="CALLER_TYPE_1">%2$s</xliff:g>"</string>
    <string name="zen_mode_repeat_callers_summary" msgid="4121054819936083025">"Si la même personne appelle deux fois en <xliff:g id="MINUTES">%d</xliff:g> minutes"</string>
    <string name="zen_mode_start_time" msgid="1252665038977523332">"Heure de début"</string>
    <string name="zen_mode_end_time" msgid="223502560367331706">"Heure de fin"</string>
    <string name="zen_mode_end_time_next_day_summary_format" msgid="419683704068360804">"<xliff:g id="FORMATTED_TIME">%s</xliff:g> le lendemain"</string>
    <string name="zen_mode_summary_alarms_only_indefinite" msgid="910047326128154945">"Ne recevoir que les alarmes sans limite de temps"</string>
    <string name="zen_mode_summary_alarms_only_by_minute" msgid="6673649005494939311">"{count,plural, =1{Ne recevoir que les alarmes pendant une minute jusqu\'à {time}}one{Ne recevoir que les alarmes pendant # minute (jusqu\'à {time})}other{Ne recevoir que les alarmes pendant # minutes (jusqu\'à {time})}}"</string>
    <string name="zen_mode_summary_alarms_only_by_hour" msgid="7400910210950788163">"{count,plural, =1{Ne recevoir que les alarmes pendant une heure jusqu\'à {time}}one{Ne recevoir que les alarmes pendant # heure jusqu\'à {time}}other{Ne recevoir que les alarmes pendant # heures jusqu\'à {time}}}"</string>
    <string name="zen_mode_summary_alarms_only_by_time" msgid="8140619669703968810">"Ne recevoir que les alarmes jusqu\'à <xliff:g id="FORMATTEDTIME">%1$s</xliff:g>"</string>
    <string name="zen_mode_summary_always" msgid="722093064250082317">"Activer le mode Toujours interrompre"</string>
    <string name="warning_button_text" msgid="1274234338874005639">"Mise en garde"</string>
    <string name="suggestion_button_close" msgid="6865170855573283759">"Fermer"</string>
    <string name="device_feedback" msgid="5351614458411688608">"Commentaires sur cet appareil"</string>
    <string name="restr_pin_enter_admin_pin" msgid="4435410646541671918">"Entrez le NIP d\'administrateur"</string>
    <string name="switch_on_text" msgid="5664542327776075105">"Activé"</string>
    <string name="switch_off_text" msgid="1315547447393646667">"Désactivé"</string>
    <string name="nfc_setting_on" msgid="7701896496026725772">"Activée"</string>
    <string name="nfc_setting_off" msgid="7142103438532732309">"Désactivée"</string>
    <string name="screen_pinning_switch_on_text" msgid="6971386830247542552">"Activé"</string>
    <string name="screen_pinning_switch_off_text" msgid="5032105155623003875">"Désactivé"</string>
    <string name="screen_pinning_title" msgid="6927227272780208966">"Épinglage d\'application"</string>
    <string name="app_pinning_intro" msgid="6409063008733004245">"L\'épinglage d\'application vous permet de garder l\'application actuelle en vue jusqu\'à ce que vous annuliez l\'épinglage. Cette fonctionnalité peut être utilisée, par exemple, pour laisser un ami de confiance jouer à un certain jeu."</string>
    <string name="screen_pinning_description" msgid="4305370471370474846">"Lorsqu\'une application est épinglée, elle peut ouvrir d\'autres applications, et certaines données personnelles pourraient être accessibles. \n\nPour utiliser l\'épinglage d\'application : 	\n1. Activez l\'épinglage d\'application 	\n2. Ouvrez Aperçu 	\n3. Touchez l\'icône de l\'application dans le haut de l\'écran, puis touchez Épingler"</string>
    <string name="screen_pinning_guest_user_description" msgid="2465729370037556955">"Lorsqu\'une application est épinglée, elle peut ouvrir d\'autres applications, et certaines données personnelles pourraient être accessibles. \n\nSi vous souhaitez partager votre appareil de manière sécuritaire, essayez d\'utiliser un profil d\'utilisateur invité à la place. \n\nPour utiliser l\'épinglage d\'application : 	\n1. Activez l\'épinglage d\'application 	\n2. Ouvrez Aperçu 	\n3. Touchez l\'icône de l\'application dans le haut de l\'écran, puis touchez Épingler"</string>
    <string name="screen_pinning_dialog_message" msgid="8144925258679476654">"Lorsqu\'une application est épinglée : \n\n•	 Certaines données personnelles pourraient être accessibles \n		(comme les contacts et le contenu des courriels) \n•	 L\'application épinglée peut ouvrir d\'autres applications \n\nUtilisez l\'épinglage d\'application uniquement avec les gens en qui vous avez confiance."</string>
    <string name="screen_pinning_unlock_pattern" msgid="1345877794180829153">"Demander le schéma de déverrouillage avant d\'annuler l\'épinglage"</string>
    <string name="screen_pinning_unlock_pin" msgid="8716638956097417023">"Demander le NIP avant d\'annuler l\'épinglage"</string>
    <string name="screen_pinning_unlock_password" msgid="4957969621904790573">"Demander le mot de passe avant d\'annuler l\'épinglage"</string>
    <string name="screen_pinning_unlock_none" msgid="2474959642431856316">"Verrouiller l\'écran après l\'annulation de l\'épinglage"</string>
    <string name="confirm_sim_deletion_title" msgid="9199369003530237871">"Confirmer la suppression du module eSIM"</string>
    <string name="confirm_sim_deletion_description" msgid="4439657901673639063">"Vérifiez qu\'il s\'agit bien de vous avant d\'effacer la carte eSIM"</string>
    <string name="memtag_title" msgid="5096176296797727201">"Protection mémoire avancée bêta"</string>
    <string name="memtag_toggle" msgid="8695028758462939212">"Protection avancée de la mémoire"</string>
    <string name="memtag_intro" msgid="579408691329568953">"Cette fonctionnalité en version bêta vous permet de protéger votre appareil contre les bogues qui peuvent compromettre votre sécurité."</string>
    <string name="memtag_on" msgid="824938319141503923">"Activée"</string>
    <string name="memtag_off" msgid="4835589640091709019">"Désactivée"</string>
    <string name="memtag_on_pending" msgid="1592053425431532361">"Activée après le redémarrage"</string>
    <string name="memtag_off_pending" msgid="1543177181383593726">"Désactivée après le redémarrage"</string>
    <string name="memtag_force_off" msgid="1143468955988138470">"Inaccessible pour votre appareil"</string>
    <string name="memtag_force_on" msgid="3254349938627883664">"Toujours activée pour votre appareil"</string>
    <string name="memtag_footer" msgid="8480784485124271376">"Vous devrez redémarrer votre appareil pour activer ou désactiver la protection avancée de la mémoire. Lorsqu\'elle est activée, vous pourriez constater un ralentissement des performances de l\'appareil."</string>
    <string name="memtag_reboot_title" msgid="1413471876903578769">"Redémarrer l\'appareil?"</string>
    <string name="memtag_reboot_message_on" msgid="3270256606602439418">"Vous devrez redémarrer votre appareil pour activer la protection avancée de la mémoire."</string>
    <string name="memtag_reboot_message_off" msgid="2567062468140476451">"Vous devrez redémarrer votre appareil pour désactiver la protection avancée de la mémoire."</string>
    <string name="memtag_reboot_yes" msgid="5788896350697141429">"Redémarrer"</string>
    <string name="memtag_reboot_no" msgid="2860671356184849330">"Plus tard"</string>
    <string name="memtag_learn_more" msgid="1596145970669119776">"Apprenez-en plus sur la protection avancée de la mémoire."</string>
    <string name="opening_paragraph_delete_profile_unknown_company" msgid="2951348192319498135">"Le profil professionnel est géré par :"</string>
    <string name="managing_admin" msgid="2633920317425356619">"Géré par <xliff:g id="ADMIN_APP_LABEL">%s</xliff:g>"</string>
    <string name="launch_by_default" msgid="892824422067985734">"Ouvrir par défaut"</string>
    <string name="app_launch_open_domain_urls_title" msgid="4805388403977096285">"Ouvrir les liens compatibles"</string>
    <string name="app_launch_top_intro_message" msgid="137370923637482459">"Permettre aux liens Web de s\'ouvrir dans cette application"</string>
    <string name="app_launch_links_category" msgid="2380467163878760037">"Liens à ouvrir dans cette application"</string>
    <string name="app_launch_supported_domain_urls_title" msgid="5088779668667217369">"Liens compatibles"</string>
    <string name="app_launch_other_defaults_title" msgid="5674385877838735586">"Autres préférences par défaut"</string>
    <string name="app_launch_add_link" msgid="8622558044530305811">"Ajouter un lien"</string>
    <string name="app_launch_footer" msgid="4521865035105622557">"Une application peut vérifier les liens pour les ouvrir automatiquement dans l\'application."</string>
    <string name="app_launch_verified_links_title" msgid="621908751569155356">"{count,plural, =1{# lien vérifié}one{# lien vérifié}other{# liens vérifiés}}"</string>
    <string name="app_launch_verified_links_message" msgid="190871133877476176">"{count,plural, =1{Ce lien a été vérifié et s\'ouvre automatiquement dans cette application.}one{Ce lien a été vérifié et s\'ouvre automatiquement dans cette application.}other{Ces liens ont été vérifiés et s\'ouvrent automatiquement dans cette application.}}"</string>
    <string name="app_launch_dialog_ok" msgid="1446157681861409861">"OK"</string>
    <string name="app_launch_verified_links_info_description" msgid="7514750232467132117">"Afficher la liste des liens vérifiés"</string>
    <string name="app_launch_checking_links_title" msgid="6119228853554114201">"Vérification des liens pris en charge en cours…"</string>
    <string name="app_launch_dialog_cancel" msgid="6961071841814898663">"Annuler"</string>
    <string name="app_launch_supported_links_title" msgid="2457931321701095763">"{count,plural, =1{# lien pris en charge}one{# lien pris en charge}other{# liens pris en charge}}"</string>
    <string name="app_launch_supported_links_add" msgid="3271247750388016131">"Ajouter"</string>
    <string name="app_launch_supported_links_subtext" msgid="4268004019469184113">"S\'ouvre dans <xliff:g id="APP_LABEL">%s</xliff:g>"</string>
    <string name="storage_summary_format" msgid="5721782272185284276">"<xliff:g id="SIZE">%1$s</xliff:g> utilisé(s) dans <xliff:g id="STORAGE_TYPE">%2$s</xliff:g>"</string>
    <string name="storage_type_internal" msgid="979243131665635278">"stockage interne"</string>
    <string name="storage_type_external" msgid="125078274000280821">"stockage externe"</string>
    <string name="data_summary_format" msgid="8802057788950096650">"<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="2591194906751432725">"Espace de stockage utilisé"</string>
    <string name="change" msgid="273206077375322595">"Modifier"</string>
    <string name="change_storage" msgid="8773820275624113401">"Modifier type de stockage"</string>
    <string name="notifications_label" msgid="8471624476040164538">"Notifications"</string>
    <string name="notifications_enabled" msgid="7743168481579361019">"Activé"</string>
    <string name="notifications_enabled_with_info" msgid="1808946629277684308">"<xliff:g id="NOTIFICATIONS_SENT">%1$s</xliff:g>/<xliff:g id="NOTIFICATIONS_CATEGORIES_OFF">%2$s</xliff:g>"</string>
    <string name="notifications_disabled" msgid="5603160425378437143">"Désactivé"</string>
    <string name="notifications_categories_off" msgid="7712037485557237328">"{count,plural, =1{# catégorie désactivée}one{# catégorie désactivée}other{# catégories désactivées}}"</string>
    <string name="runtime_permissions_additional_count" msgid="6071909675951786523">"{count,plural, =1{# autorisation supplémentaire}one{# autorisation supplémentaire}other{# autorisations supplémentaires}}"</string>
    <string name="runtime_permissions_summary_no_permissions_granted" msgid="7456745929035665029">"Aucune autorisation accordée"</string>
    <string name="runtime_permissions_summary_no_permissions_requested" msgid="7174876170116073356">"Aucune autorisation demandée"</string>
    <string name="runtime_permissions_summary_control_app_access" msgid="3744591396348990500">"Gérez l\'accès des applis à vos données"</string>
    <string name="permissions_usage_title" msgid="2942741460679049132">"Tableau de bord de confidentialité"</string>
    <string name="permissions_usage_summary" msgid="6784310472062516454">"Affichez les applications qui ont récemment utilisé les autorisations"</string>
    <string name="unused_apps" msgid="4566272194756830656">"Applications non utilisées"</string>
    <string name="unused_apps_summary" msgid="4236371818881973021">"{count,plural, =1{# application non utilisée}one{# application non utilisée}other{# applications non utilisées}}"</string>
    <string name="unused_apps_category" msgid="8954930958175500851">"Paramètres des applications inutilisées"</string>
    <string name="unused_apps_switch" msgid="7595419855882245772">"Suspendre l\'activité appli si inutilisée"</string>
    <string name="unused_apps_switch_summary" msgid="2171098908014596802">"Retirer les autorisations, supprimer les fichiers temporaires et arrêter les notifications"</string>
    <string name="filter_all_apps" msgid="6645539744080251371">"Toutes les applications"</string>
    <string name="filter_enabled_apps" msgid="8868356616126759124">"Applications installées"</string>
    <string name="filter_instant_apps" msgid="2292108467020380068">"Applications instantanées"</string>
    <string name="filter_notif_blocked_apps" msgid="1065653868850012325">"Désactivées"</string>
    <string name="advanced_apps" msgid="7643010673326578815">"Paramètres avancés"</string>
    <string name="app_permissions" msgid="8666537659217653626">"Gestionnaire des autorisations"</string>
    <string name="app_data_sharing_updates_title" msgid="1694297952320402788">"Mises à jour des pratiques de partage des données pour la localisation"</string>
    <string name="app_data_sharing_updates_summary" msgid="4465929918457739443">"Passez en revue les applications qui ont changé la façon dont elles peuvent partager vos données de localisation"</string>
    <string name="tap_to_wake" msgid="3313433536261440068">"Toucher pour réveiller"</string>
    <string name="tap_to_wake_summary" msgid="6641039858241611072">"Double-touchez l\'écran pour réveiller l\'appareil"</string>
    <string name="domain_urls_title" msgid="7012209752049678876">"Ouverture des liens"</string>
    <string name="domain_urls_summary_none" msgid="1132578967643384733">"Ne pas ouvrir les liens compatibles"</string>
    <string name="domain_urls_summary_one" msgid="3312008753802762892">"Ouvrir « <xliff:g id="DOMAIN">%s</xliff:g> »"</string>
    <string name="domain_urls_summary_some" msgid="1197692164421314523">"Ouvrir <xliff:g id="DOMAIN">%s</xliff:g> et d\'autres URL"</string>
    <string name="app_link_open_always" msgid="9167065494930657503">"Autoriser l\'application à gérer les liens pris en charge"</string>
    <string name="app_link_open_ask" msgid="2422450109908936371">"Toujours demander"</string>
    <string name="app_link_open_never" msgid="5299808605386052350">"Ne pas autoriser l\'application à ouvrir les liens"</string>
    <string name="app_link_open_always_summary" msgid="4524005594295855117">"{count,plural, =1{L\'application prétend cibler # lien}one{L\'application prétend cibler # lien}other{L\'application prétend cibler # liens}}"</string>
    <string name="open_supported_links_footer" msgid="3188808142432787933">"L\'application réclame les liens suivants :"</string>
    <string name="assist_and_voice_input_title" msgid="6317935163145135914">"Assist. et entrée vocale"</string>
    <string name="default_assist_title" msgid="1182435129627493758">"Application d\'assistant numérique"</string>
    <string name="default_digital_assistant_title" msgid="5654663086385490838">"Assistant numérique par défaut"</string>
    <string name="assistant_security_warning_agree" msgid="9013334158753473359">"J\'accepte"</string>
    <string name="default_browser_title" msgid="8342074390782390458">"Application de navigateur"</string>
    <string name="default_phone_title" msgid="7616730756650803827">"Application de téléphonie"</string>
    <string name="system_app" msgid="1863291702508355041">"(Système)"</string>
    <string name="apps_storage" msgid="643866814746927111">"Stockage des applications"</string>
    <string name="usage_access" msgid="5487993885373893282">"Accès aux données d\'utilisation"</string>
    <string name="permit_usage_access" msgid="179630895262172674">"Autoriser l\'accès aux données d\'utilisation"</string>
    <string name="time_spent_in_app_pref_title" msgid="25327097913383330">"Temps d\'utilisation des écrans"</string>
    <string name="usage_access_description" msgid="8547716253713890707">"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="6582588646363308430">"Mémoire"</string>
    <string name="always_running" msgid="9012705720688200252">"Toujours en cours d\'exécution (<xliff:g id="PERCENTAGE">%s</xliff:g>)"</string>
    <string name="sometimes_running" msgid="7954947311082655448">"Parfois en cours d\'exécution (<xliff:g id="PERCENTAGE">%s</xliff:g>)"</string>
    <string name="rarely_running" msgid="2704869567353196798">"Rarement en cours d\'exécution (<xliff:g id="PERCENTAGE">%s</xliff:g>)"</string>
    <string name="memory_use_running_format" msgid="4376086847362492613">"<xliff:g id="MEMORY">%1$s</xliff:g>/<xliff:g id="RUNNING">%2$s</xliff:g>"</string>
    <string name="high_power_apps" msgid="5623152700992102510">"Optimisation de la pile"</string>
    <string name="high_power_filter_on" msgid="447849271630431531">"Non optimisée"</string>
    <string name="high_power_on" msgid="8778058701270819268">"Non optimisée"</string>
    <string name="high_power_off" msgid="317000444619279018">"L\'utilisation de la pile est optimisée"</string>
    <string name="high_power_system" msgid="3966701453644915787">"L\'optimisation de la pile n\'est pas disponible"</string>
    <string name="high_power_prompt_title" msgid="2574478825228409124">"Autoriser l\'application à toujours fonctionner en arrière-plan?"</string>
    <string name="high_power_prompt_body" msgid="6029266540782139941">"Si vous autorisez l\'exécution en arrière-plan systématique de l\'application <xliff:g id="APP_NAME">%1$s</xliff:g>, vous risquez de réduire l\'autonomie de la pile. \n\nVous pouvez modifier ce choix plus tard dans Paramètres &gt; Applications."</string>
    <string name="battery_summary" msgid="2491764359695671207">"Usage depuis la dernière charge complète : <xliff:g id="PERCENTAGE">%1$s</xliff:g>"</string>
    <string name="battery_summary_24hr" msgid="7656033283282656551">"<xliff:g id="PERCENTAGE">%1$s</xliff:g> d\'utilisation au cours des 24 dernières heures"</string>
    <string name="no_battery_summary" msgid="5769159953384122003">"Aucune utilisation de la pile depuis la dernière charge complète"</string>
    <string name="share_remote_bugreport_dialog_title" msgid="1575283098565582433">"Partager le rapport de bogue?"</string>
    <string name="share_remote_bugreport_dialog_message_finished" msgid="4869053468609007680">"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="8714439220818865391">"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="3523877008096439251">"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="7173093464692893276">"Partager"</string>
    <string name="decline_remote_bugreport_action" msgid="1276509879613158895">"Refuser"</string>
    <string name="usb_use_charging_only" msgid="1743303747327057947">"Pas de transfert de données"</string>
    <string name="usb_use_power_only" msgid="3408055485802114621">"Charger l\'appareil connecté"</string>
    <string name="usb_use_file_transfers" msgid="483915710802018503">"Transfert de fichiers"</string>
    <string name="usb_use_photo_transfers" msgid="4641181628966036093">"PTP"</string>
    <string name="usb_use_uvc_webcam" msgid="6595429508472038732">"Caméra Web"</string>
    <string name="usb_transcode_files" msgid="2441954752105119109">"Convertir des vidéos au format AVC"</string>
    <string name="usb_transcode_files_summary" msgid="307102635711961513">"Les vidéos joueront sur un plus grand nombre de lecteurs multimédias, mais la qualité peut être réduite"</string>
    <string name="usb_use_tethering" msgid="2897063414491670531">"Partage de connexion par USB"</string>
    <string name="usb_use_MIDI" msgid="8621338227628859789">"MIDI"</string>
    <string name="usb_use" msgid="6783183432648438528">"Utiliser la connexion USB pour"</string>
    <string name="usb_default_label" msgid="3372838450371060750">"Configuration USB par défaut"</string>
    <string name="usb_default_info" msgid="167172599497085266">"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_power_title" msgid="5602112548385798646">"Options d\'alimentation"</string>
    <string name="usb_file_transfer_title" msgid="2261577861371481478">"Options de transfert de fichiers"</string>
    <string name="usb_pref" msgid="8521832005703261700">"USB"</string>
    <string name="usb_preference" msgid="5084550082591493765">"Préférences USB"</string>
    <string name="usb_control_title" msgid="1946791559052157693">"USB contrôlé par"</string>
    <string name="usb_control_host" msgid="7404215921555021871">"Appareil connecté"</string>
    <string name="usb_control_device" msgid="527916783743021577">"Cet appareil"</string>
    <string name="usb_switching" msgid="3654709188596609354">"Changement en cours…"</string>
    <string name="usb_switching_failed" msgid="5721262697715454137">"Impossible de changer de mode"</string>
    <string name="usb_summary_charging_only" msgid="678095599403565146">"Chargement de l\'appareil"</string>
    <string name="usb_summary_power_only" msgid="4901734938857822887">"Chargement de l\'appareil connecté"</string>
    <string name="usb_summary_file_transfers" msgid="5498487271972556431">"Transfert de fichiers"</string>
    <string name="usb_summary_tether" msgid="2554569836525075702">"Partage de connexion par USB"</string>
    <string name="usb_summary_photo_transfers" msgid="7331503733435780492">"PTP"</string>
    <string name="usb_summary_MIDI" msgid="2372443732675899571">"MIDI"</string>
    <string name="usb_summary_UVC" msgid="8733131110899174299">"Caméra Web"</string>
    <string name="usb_summary_file_transfers_power" msgid="2788374660532868630">"Transfert de fichiers et alimentation"</string>
    <string name="usb_summary_tether_power" msgid="4853034392919904792">"Partage de connexion par USB et alimentation"</string>
    <string name="usb_summary_photo_transfers_power" msgid="9077173567697482239">"PTP et alimentation"</string>
    <string name="usb_summary_MIDI_power" msgid="1184681982025435815">"MIDI et alimentation"</string>
    <string name="usb_summary_UVC_power" msgid="226810354412154061">"Caméra Web et alimentation"</string>
    <string name="background_check_pref" msgid="5304564658578987535">"Vérification en arrière-plan"</string>
    <string name="assist_access_context_title" msgid="5201495523514096201">"Utiliser le texte affiché à l\'écran"</string>
    <string name="assist_access_context_summary" msgid="6951814413185646275">"Autoriser l\'application d\'assistance à accéder au contenu affiché à l\'écran sous forme de texte"</string>
    <string name="assist_access_screenshot_title" msgid="4395902231753643633">"Utiliser la saisie d\'écran"</string>
    <string name="assist_access_screenshot_summary" msgid="5276593070956201863">"Autoriser l\'application d\'assistance à accéder au contenu affiché à l\'écran sous forme d\'image"</string>
    <string name="assist_flash_title" msgid="5449512572885550108">"Faire clignoter l\'écran"</string>
    <string name="assist_flash_summary" msgid="3032289860177784594">"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="8248015363806299068">"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="717313706368825388">"Utilisation moyenne de la mémoire"</string>
    <string name="maximum_memory_use" msgid="2171779724001152933">"Utilisation max. de la mémoire"</string>
    <string name="memory_usage" msgid="5594133403819880617">"Utilisation de la mémoire"</string>
    <string name="app_list_memory_use" msgid="3178720339027577869">"Utilisation de l\'application"</string>
    <string name="memory_details" msgid="6133226869214421347">"Détails"</string>
    <string name="memory_use_summary" msgid="3915964794146424142">"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="6708111974923274436">"Aucune mémoire utilisée au cours des trois dernières heures"</string>
    <string name="sort_avg_use" msgid="4416841047669186903">"Trier par utilisation moyenne"</string>
    <string name="sort_max_use" msgid="3370552820889448484">"Trier par utilisation maximale"</string>
    <string name="memory_performance" msgid="5448274293336927570">"Performance"</string>
    <string name="total_memory" msgid="5244174393008910567">"Mémoire totale"</string>
    <string name="average_used" msgid="690235917394070169">"Utilisation moyenne (%)"</string>
    <string name="free_memory" msgid="439783742246854785">"Libre"</string>
    <string name="memory_usage_apps" msgid="5776108502569850579">"Mémoire utilisée par les applications"</string>
    <string name="memory_usage_apps_summary" msgid="7168292864155527974">"{count,plural, =1{1 application a utilisé la mémoire depuis {time}}one{# application a utilisé la mémoire depuis {time}}other{# applications ont utilisé la mémoire depuis {time}}}"</string>
    <string name="running_frequency" msgid="7260225121706316639">"Fréquence"</string>
    <string name="memory_maximum_usage" msgid="2047013391595835607">"Utilisation maximale"</string>
    <string name="no_data_usage" msgid="4665617440434654132">"Aucune donnée utilisée"</string>
    <string name="zen_access_warning_dialog_title" msgid="6323325813123130154">"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="8468714854067428987">"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="6565908224294537889">"Cette fonction doit rester activée, car l\'accès aux notifications est activé"</string>
    <string name="zen_access_revoke_warning_dialog_title" msgid="7377261509261811449">"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="8689801842914183595">"Toutes les règles Ne pas déranger créées par cette application seront supprimées."</string>
    <string name="ignore_optimizations_on" msgid="6865583039303804932">"Ne pas optimiser"</string>
    <string name="ignore_optimizations_off" msgid="9186557038453586295">"Optimiser"</string>
    <string name="ignore_optimizations_on_desc" msgid="1280043916460939932">"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="3324571675983286177">"Recommandé pour une meilleure autonomie de la pile"</string>
    <string name="app_list_preference_none" msgid="1635406344616653756">"Aucune"</string>
    <string name="work_profile_usage_access_warning" msgid="3477719910927319122">"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="draw_overlay" msgid="7902083260500573027">"Afficher par-dessus autres applis"</string>
    <string name="system_alert_window_settings" msgid="6458633954424862521">"Afficher par-dessus les autres applications"</string>
    <string name="permit_draw_overlay" msgid="4468994037192804075">"Autoriser la superposition d\'applis"</string>
    <string name="allow_overlay_description" msgid="1607235723669496298">"Autorisez cette application à s\'afficher par-dessus les autres que vous utilisez. Cette application pourra voir où vous touchez et modifier ce qui est affiché sur l\'écran."</string>
    <string name="manage_external_storage_title" msgid="8024521099838816100">"Accès à tous les fichiers"</string>
    <string name="permit_manage_external_storage" msgid="6928847280689401761">"Autorisez l\'accès pour gérer tous les fichiers"</string>
    <string name="allow_manage_external_storage_description" msgid="5707948153603253225">"Autoriser cette application à lire, à modifier et à supprimer tous les fichiers qui se trouvent sur cet appareil ou sur des volumes de stockage connectés. Si vous accordez cette autorisation, l\'application pourra accéder à des fichiers sans que vous le sachiez."</string>
    <string name="filter_manage_external_storage" msgid="6751640571715343804">"Peuvent accéder à tous les fichiers"</string>
    <string name="full_screen_intent_title" msgid="1068024949389956404">"Gérer les intentions plein écran"</string>
    <string name="permit_full_screen_intent" msgid="2251949245519201421">"Autoriser les applications à envoyer des intentions plein écran"</string>
    <string name="footer_description_full_screen_intent" msgid="8322826300555418227">"Autorisez cette application à envoyer des notifications d\'intention plein écran couvrant la totalité de l\'écran."</string>
    <string name="media_management_apps_title" msgid="8222942355578724582">"Applis de gestion des fichiers multimédias"</string>
    <string name="media_management_apps_toggle_label" msgid="166724270857067456">"Autoriser l\'appli à gérer fichiers multimédias"</string>
    <string name="media_management_apps_description" msgid="8000565658455268524">"Si vous l\'autorisez à le faire, cette application peut modifier ou supprimer des fichiers multimédias créés à l\'aide d\'autres applications sans vous le demander. L\'application doit avoir l\'autorisation d\'accéder aux fichiers et aux fichiers multimédias."</string>
    <string name="keywords_media_management_apps" msgid="7499959607583088690">"éléments multimédias, fichier, gestion, gestionnaire, gérer, modifier, éditeur, appli, application, programme"</string>
    <string name="keywords_vr_listener" msgid="902737490270081131">"vr réalité virtuelle écouteur service de soutien stéréo"</string>
    <string name="overlay_settings" msgid="2030836934139139469">"Afficher par-dessus autres applis"</string>
    <string name="filter_overlay_apps" msgid="2483998217116789206">"Applications dotées de l\'autorisation"</string>
    <string name="app_permission_summary_allowed" msgid="1155115629167757278">"Autorisé"</string>
    <string name="app_permission_summary_not_allowed" msgid="2673793662439097900">"Non autorisé"</string>
    <string name="keywords_install_other_apps" msgid="563895867658775580">"installer des applications provenant de sources inconnues"</string>
    <string name="write_settings" msgid="6864794401614425894">"Modifier paramètres système"</string>
    <string name="keywords_write_settings" msgid="6908708078855507813">"écrire des modifications aux paramètres du système"</string>
    <string name="filter_install_sources_apps" msgid="6930762738519588431">"Peut installer d\'autres applications"</string>
    <string name="filter_write_settings_apps" msgid="4754994984909024093">"Peut modifier les paramètres du système"</string>
    <string name="write_settings_title" msgid="3011034187823288557">"Peut modifier les paramètres du système"</string>
    <string name="write_system_settings" msgid="5555707701419757421">"Modifier paramètres système"</string>
    <string name="permit_write_settings" msgid="3113056800709924871">"Autoriser la modification des paramètres du système"</string>
    <string name="write_settings_description" msgid="1474881759793261146">"Cette autorisation permet à une application de modifier les paramètres du système."</string>
    <string name="external_source_switch_title" msgid="101571983954849473">"Autoriser à partir de cette source"</string>
    <string name="camera_gesture_title" msgid="5559439253128696180">"Pivot. poignet deux fois pour app. photo"</string>
    <string name="camera_gesture_desc" msgid="7557645057320805328">"Ouvrez l\'application de l\'appareil photo en pivotant votre poignet deux fois"</string>
    <string name="screen_zoom_title" msgid="6928045302654960559">"Taille d\'affichage"</string>
    <string name="screen_zoom_short_summary" msgid="756254364808639194">"Rendez tout plus grand ou plus petit"</string>
    <string name="screen_zoom_keywords" msgid="5964023524422386592">"densité d\'affichage, zoom de l\'écran, échelle, mise à l\'échelle"</string>
    <string name="screen_zoom_preview_title" msgid="5288355628444562735">"Aperçu"</string>
    <string name="screen_zoom_make_smaller_desc" msgid="2628662648068995971">"Rapetisser"</string>
    <string name="screen_zoom_make_larger_desc" msgid="7268794713428853139">"Agrandir"</string>
    <string name="disconnected" msgid="3469373726996129247">"Non connecté"</string>
    <string name="keyboard_disconnected" msgid="796053864561894531">"Non connecté"</string>
    <string name="apps_summary" msgid="4007416751775414252">"<xliff:g id="COUNT">%1$d</xliff:g> applications installées"</string>
    <string name="storage_summary" msgid="5903562203143572768">"Utilisé : <xliff:g id="PERCENTAGE">%1$s</xliff:g>; libre : <xliff:g id="FREE_SPACE">%2$s</xliff:g>"</string>
    <string name="display_dashboard_summary" msgid="1599453894989339454">"Thème sombre, taille de la police, luminosité"</string>
    <string name="memory_summary" msgid="8221954450951651735">"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="8473589474976307510">"Connecté en tant que <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="android_version_summary" msgid="7818952662015042768">"Mis à jour vers Android <xliff:g id="VERSION">%1$s</xliff:g>"</string>
    <string name="android_version_pending_update_summary" msgid="5404532347171027730">"Mise à jour disponible"</string>
    <string name="disabled_by_policy_title" msgid="6852347040813204503">"Bloqué conformément à la politique de l\'entreprise"</string>
    <string name="disabled_by_policy_title_adjust_volume" msgid="1669689058213728099">"Impossible de modifier le volume"</string>
    <string name="disabled_by_policy_title_outgoing_calls" msgid="400089720689494562">"Impossible de faire des appels"</string>
    <string name="disabled_by_policy_title_sms" msgid="8951840850778406831">"Impossible d\'envoyer des messages texte"</string>
    <string name="disabled_by_policy_title_camera" msgid="6616508876399613773">"Impossible d\'utiliser l\'appareil photo"</string>
    <string name="disabled_by_policy_title_screen_capture" msgid="6085100101044105811">"Impossible de faire des captures d\'écran"</string>
    <string name="disabled_by_policy_title_suspend_packages" msgid="4223983156635729793">"Impossible d\'ouvrir cette application"</string>
    <string name="disabled_by_policy_title_financed_device" msgid="2328740314082888228">"Bloqué par votre fournisseur de crédit"</string>
    <string name="disabled_by_policy_title_biometric_parental_consent" msgid="2463673997797134678">"Consentement parental requis"</string>
    <string name="disabled_by_policy_content_biometric_parental_consent" msgid="7124116806784305206">"Remettez le téléphone à votre parent pour commencer la configuration de ce paramètre"</string>
    <string name="disabled_by_policy_parental_consent" msgid="9166060049019018978">"Remettez le téléphone à votre parent pour qu\'il autorise la modification de ce paramètre."</string>
    <string name="default_admin_support_msg" msgid="8816296554831532033">"Pour en savoir plus, communiquez avec votre administrateur informatique"</string>
    <string name="admin_support_more_info" msgid="8407433155725898290">"Détails supplémentaires"</string>
    <string name="admin_profile_owner_message" msgid="8860709969532649195">"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="4929926887231544950">"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="5503131744126520590">"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="admin_financed_message" msgid="1156197630834947884">"Votre administrateur d\'appareil pourrait être en mesure d\'accéder aux données associées à cet appareil, de modifier ses paramètres et de gérer des applications."</string>
    <string name="condition_turn_off" msgid="402707350778441939">"Désactiver"</string>
    <string name="condition_turn_on" msgid="3911077299444314791">"Activer"</string>
    <string name="condition_expand_show" msgid="1501084007540953213">"Afficher"</string>
    <string name="condition_expand_hide" msgid="8347564076209121058">"Masquer"</string>
    <string name="condition_hotspot_title" msgid="7903918338790641071">"Le point d\'accès est actif"</string>
    <string name="condition_airplane_title" msgid="5847967403687381705">"Le mode Avion est activé"</string>
    <string name="condition_airplane_summary" msgid="1964500689287879888">"Aucun réseau accessible"</string>
    <string name="condition_zen_title" msgid="7674761111934567490">"Mode Ne pas déranger activé"</string>
    <string name="condition_zen_summary_phone_muted" msgid="6516753722927681820">"Téléphone en sourdine"</string>
    <string name="condition_zen_summary_with_exceptions" msgid="9019937492602199663">"Avec des exceptions"</string>
    <string name="condition_battery_title" msgid="6395113995454385248">"Économiseur de pile activé"</string>
    <string name="condition_battery_summary" msgid="8436806157833107886">"Fonctionnalités restreintes"</string>
    <string name="condition_cellular_title" msgid="155474690792125747">"Données cellulaires désactivées"</string>
    <string name="condition_cellular_summary" msgid="1678098728303268851">"Internet est uniquement accessible par Wi‑Fi"</string>
    <string name="condition_bg_data_title" msgid="2719263664589753094">"Économiseur de données"</string>
    <string name="condition_bg_data_summary" msgid="1736255283216193834">"Fonctionnalités restreintes"</string>
    <string name="condition_work_title" msgid="174326145616998813">"Profil professionnel désactivé"</string>
    <string name="condition_work_summary" msgid="7113473121312772398">"Pour les applications et les notifications"</string>
    <string name="condition_device_muted_action_turn_on_sound" msgid="4078406807327674934">"Activer le son"</string>
    <string name="condition_device_muted_title" msgid="2446306263428466378">"Sonnerie désactivée"</string>
    <string name="condition_device_muted_summary" msgid="3772178424510397327">"Pour les appels et les notifications"</string>
    <string name="condition_device_vibrate_title" msgid="9058943409545158583">"Vibrations seulement"</string>
    <string name="condition_device_vibrate_summary" msgid="7537724181691903202">"Pour les appels et les notifications"</string>
    <string name="night_display_suggestion_title" msgid="5418911386429667704">"Créer un horaire pour le mode Éclairage nocturne"</string>
    <string name="night_display_suggestion_summary" msgid="4218017907425509769">"Donner automatiquement des tons ambrés à l\'écran tous les soirs"</string>
    <string name="condition_night_display_title" msgid="1072880897812554421">"Éclairage nocturne activé"</string>
    <string name="condition_night_display_summary" msgid="3278349775875166984">"Écran teinté ambre"</string>
    <string name="condition_grayscale_title" msgid="9029271080007984542">"Nuances de gris"</string>
    <string name="condition_grayscale_summary" msgid="1306034149271251292">"Afficher uniquement en nuances de gris"</string>
    <string name="homepage_condition_footer_content_description" msgid="1568313430995646108">"Réduire"</string>
    <string name="color_temperature" msgid="8256912135746305176">"Température des couleurs froides"</string>
    <string name="color_temperature_desc" msgid="6713259535885669622">"Utiliser des couleurs plus froides à l\'écran"</string>
    <string name="color_temperature_toast" msgid="7611532183532407342">"Pour appliquer la modification des couleurs, éteignez l\'écran"</string>
    <string name="camera_laser_sensor_switch" msgid="7097842750947187671">"Capteur laser de l\'appareil photo"</string>
    <string name="ota_disable_automatic_update" msgid="1953894421412420231">"Mises à jour automatiques du système"</string>
    <string name="ota_disable_automatic_update_summary" msgid="7803279951533276841">"Appliquer les mises à jour au redémarrage de l\'appareil"</string>
    <string name="usage" msgid="287782903846013936">"Utilisation"</string>
    <string name="cellular_data_usage" msgid="5874156338825285334">"Utilisation de données cellulaires"</string>
    <string name="app_cellular_data_usage" msgid="7603292978956033926">"Utilisation des données des applications"</string>
    <string name="wifi_data_usage" msgid="6868503699134605707">"Utilisation des données Wi-Fi"</string>
    <string name="non_carrier_data_usage" msgid="6494603202578414755">"Utilisation de données sur un réseau non cellulaire"</string>
    <string name="ethernet_data_usage" msgid="4552227880905679761">"Utilisation de données Ethernet"</string>
    <string name="wifi" msgid="2932584495223243842">"Wi-Fi"</string>
    <string name="ethernet" msgid="4665162609974492983">"Ethernet"</string>
    <string name="cell_data_template" msgid="6077963976103260821">"Données cellulaires utilisées : <xliff:g id="AMOUNT">^1</xliff:g>"</string>
    <string name="wifi_data_template" msgid="935934798340307438">"Données Wi-Fi : <xliff:g id="AMOUNT">^1</xliff:g>"</string>
    <string name="ethernet_data_template" msgid="1429173767445201145">"Données Ethernet : <xliff:g id="AMOUNT">^1</xliff:g>"</string>
    <string name="billing_cycle" msgid="6618424022653876279">"Avertissement et limites de données"</string>
    <string name="app_usage_cycle" msgid="341009528778520583">"Cycle d\'utilisation des données cellulaires"</string>
    <string name="cell_data_warning" msgid="5664921950473359634">"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="256855024790622112">"Limite d\'utilisation de données : <xliff:g id="ID_1">^1</xliff:g>"</string>
    <string name="cell_data_warning_and_limit" msgid="8393200831986035724">"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="operator_warning" msgid="5672761970087591211">"Le suivi de consommation de données du fournisseur de services peut différer de celui de l\'appareil"</string>
    <string name="non_carrier_data_usage_warning" msgid="4707184871368847697">"Exclut les données utilisées sur les réseaux cellulaires"</string>
    <string name="data_used_template" msgid="8229342096562327646">"<xliff:g id="ID_1">%1$s</xliff:g> utilisés"</string>
    <string name="set_data_warning" msgid="1685771882794205462">"Activer une alerte"</string>
    <string name="data_warning" msgid="2925054658166062884">"Seuil d\'alerte"</string>
    <string name="data_warning_footnote" msgid="5991901765915710592">"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="9010326815874642680">"Définir limite consomm. données"</string>
    <string name="data_limit" msgid="8731731657513652363">"Limite de données"</string>
    <string name="data_usage_template" msgid="3822452362629968010">"<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="1499586749829665889">"Configurer"</string>
    <string name="data_usage_other_apps" msgid="5649047093607329537">"Autres applications incluses dans l\'utilisation"</string>
    <string name="data_saver_unrestricted_summary" msgid="7343571401172437542">"{count,plural, =1{1 application est autorisée à ignorer les restrictions lorsque la fonction Économiseur de données est activée}one{# application est autorisée à ignorer les restrictions lorsque la fonction Économiseur de données est activée}other{# applications sont autorisées à ignorer les restrictions lorsque la fonction Économiseur de données est activée}}"</string>
    <string name="data_usage_title" msgid="4039024073687469094">"Données primaires"</string>
    <string name="data_usage_wifi_title" msgid="1060495519280456926">"Données Wi-Fi"</string>
    <string name="data_used_formatted" msgid="7913920278059077938">"<xliff:g id="ID_1">^1</xliff:g> <xliff:g id="ID_2">^2</xliff:g> utilisés"</string>
    <string name="data_overusage" msgid="3680477320458707259">"Limite dépassée de <xliff:g id="ID_1">^1</xliff:g>"</string>
    <string name="data_remaining" msgid="6316251496381922837">"Il reste <xliff:g id="ID_1">^1</xliff:g>"</string>
    <string name="data_usage_chart_brief_content_description" msgid="5548074070258881530">"Graphique illustrant l\'utilisation des données entre le <xliff:g id="START_DATE">%1$s</xliff:g> et le <xliff:g id="END_DATE">%2$s</xliff:g>."</string>
    <string name="data_usage_chart_no_data_content_description" msgid="5481968839079467231">"Aucune donnée durant cette période"</string>
    <string name="billing_cycle_days_left" msgid="174337287346866400">"{count,plural, =1{# jour restant}one{# jour restant}other{# jours restants}}"</string>
    <string name="billing_cycle_none_left" msgid="1694844019159277504">"Aucun temps restant"</string>
    <string name="billing_cycle_less_than_one_day_left" msgid="1210202399053992163">"Il reste moins d\'un jour"</string>
    <string name="carrier_and_update_text" msgid="5363656651921656280">"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="5432798085593055966">"Mis à jour il y a <xliff:g id="ID_1">^2</xliff:g>"</string>
    <string name="carrier_and_update_now_text" msgid="5075861262344398849">"Mis à jour par <xliff:g id="ID_1">^1</xliff:g> à l\'instant"</string>
    <string name="no_carrier_update_now_text" msgid="7898004907837200752">"Mis à jour à l\'instant"</string>
    <string name="launch_mdp_app_text" msgid="8791816789749304897">"Afficher le forfait"</string>
    <string name="launch_wifi_text" msgid="976421974332512894">"Afficher les détails"</string>
    <string name="data_saver_title" msgid="2593804270788863815">"Économiseur de données"</string>
    <string name="unrestricted_data_saver" msgid="7922563266857367495">"Données sans restrictions"</string>
    <string name="restrict_background_blocklisted" msgid="2308345280442438232">"Les données en arrière-plan sont désactivées"</string>
    <string name="data_saver_on" msgid="7848893946018448793">"Activé"</string>
    <string name="data_saver_off" msgid="5891210864117269045">"Désactivé"</string>
    <string name="data_saver_switch_title" msgid="7111538580123722959">"Utiliser l\'économiseur de données"</string>
    <string name="unrestricted_app_title" msgid="7117585996574329284">"Utilis. donn. sans restriction"</string>
    <string name="unrestricted_app_summary" msgid="282698963532000403">"Ignorer restrict. données lorsque Écon. donn. act."</string>
    <string name="home_app" msgid="6056850504746902747">"Application d\'accueil"</string>
    <string name="suggestion_additional_fingerprints" msgid="4726777300101156208">"Ajouter une empreinte digitale"</string>
    <string name="suggestion_additional_fingerprints_summary" msgid="2825364645039666674">"Déverrouiller avec un autre doigt"</string>
    <string name="battery_saver_on_summary" msgid="4605146593966255848">"Activé"</string>
    <string name="battery_saver_off_scheduled_summary" msgid="2193875981740829819">"S\'active lorsque la pile atteint <xliff:g id="BATTERY_PERCENTAGE">%1$s</xliff:g>"</string>
    <string name="battery_saver_off_summary" msgid="4411561435493109261">"Désactivé"</string>
    <string name="app_battery_usage_title" msgid="346558380609793334">"Utilisation de la pile par les applications"</string>
    <string name="app_battery_usage_summary" msgid="6349965904306339539">"Régler l\'utilisation de la pile pour les applis"</string>
    <string name="filter_battery_unrestricted_title" msgid="821027369424198223">"Aucune restriction"</string>
    <string name="filter_battery_optimized_title" msgid="8236647176487754796">"Optimisée"</string>
    <string name="filter_battery_restricted_title" msgid="5886859505802563232">"Limitée"</string>
    <string name="default_spell_checker" msgid="7108373288347014351">"Correcteur par défaut"</string>
    <string name="choose_spell_checker" msgid="7402513404783243675">"Sélectionner correcteur ortho"</string>
    <string name="spell_checker_primary_switch_title" msgid="529240542284039243">"Utiliser le correcteur orthographique"</string>
    <string name="spell_checker_not_selected" msgid="8818618543474481451">"Non sélectionné"</string>
    <string name="notification_log_details_delimiter" msgid="2475986465985309821">" : "</string>
    <string name="notification_log_details_package" msgid="3205243985502010202">"pkg"</string>
    <string name="notification_log_details_key" msgid="2690467272328709046">"clé"</string>
    <string name="notification_log_details_group" msgid="1765952974599794393">"groupe"</string>
    <string name="notification_log_details_group_summary" msgid="4364622087007803822">"(sommaire)"</string>
    <string name="notification_log_details_public_version" msgid="3057653571018432759">"publicVersion"</string>
    <string name="notification_log_details_importance" msgid="8516198274667183446">"importance"</string>
    <string name="notification_log_details_explanation" msgid="6966274549873070059">"explication"</string>
    <string name="notification_log_details_badge" msgid="648647240928645446">"peut présenter un badge"</string>
    <string name="notification_log_details_content_intent" msgid="2768423554375629089">"intention"</string>
    <string name="notification_log_details_delete_intent" msgid="8296434571041573503">"supprimer intention"</string>
    <string name="notification_log_details_full_screen_intent" msgid="4151243693072002296">"intention plein écran"</string>
    <string name="notification_log_details_actions" msgid="2269605330470905236">"actions"</string>
    <string name="notification_log_details_title" msgid="8365761340979164197">"titre"</string>
    <string name="notification_log_details_remoteinput" msgid="264204203044885921">"entrées à distance"</string>
    <string name="notification_log_details_content_view" msgid="7193602999512479112">"affichage personnalisée"</string>
    <string name="notification_log_details_extras" msgid="8602887256103970989">"bonus"</string>
    <string name="notification_log_details_icon" msgid="6728710746466389675">"icône"</string>
    <string name="notification_log_details_parcel" msgid="2098454650154230531">"taille du colis"</string>
    <string name="notification_log_details_ashmem" msgid="6163312898302809015">"ashmem"</string>
    <string name="notification_log_details_alerted" msgid="5285078967825048406">"notification alertée"</string>
    <string name="notification_log_channel" msgid="3406738695621767204">"chaîne"</string>
    <string name="notification_log_details_ranking_null" msgid="6607596177723101524">"L\'objet de classement est manquant."</string>
    <string name="notification_log_details_ranking_none" msgid="2484105338466675261">"L\'objet de classement ne contient pas cette touche."</string>
    <string name="display_cutout_emulation" msgid="1421648375408281244">"Encoche de l\'écran"</string>
    <string name="display_cutout_emulation_keywords" msgid="4506580703807358127">"découpe d\'affichage, encoche"</string>
    <string name="overlay_option_device_default" msgid="7986355499809313848">"Valeurs par défaut de l\'appareil"</string>
    <string name="overlay_toast_failed_to_apply" msgid="4839587811338164960">"Impossible d\'appliquer la superposition"</string>
    <string name="special_access" msgid="1767980727423395147">"Accès spécial des applications"</string>
    <plurals name="special_access_summary" formatted="false" msgid="4995506406763570815">
      <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="132919514147475846">"En voir plus"</string>
    <string name="long_background_tasks_label" msgid="3169590134850226687">"Longues tâches en arrière-plan"</string>
    <string name="long_background_tasks_switch_title" msgid="2491623894899492543">"Autoriser les longues tâches en arrière-plan"</string>
    <string name="long_background_tasks_title" msgid="3272230637974707490">"Longues tâches en arrière-plan"</string>
    <string name="long_background_tasks_footer_title" msgid="9117342254914743097">"Autoriser cette application à exécuter de longues tâches en arrière-plan. Ceci permet à cette application d\'exécuter des tâches qui pourraient prendre plus que quelques minutes, comme des téléchargements ou des téléversements. \n\nSi cette autorisation est refusée, le système va limiter le temps pendant lequel l\'application peut effectuer ces tâches en arrière-plan."</string>
    <string name="keywords_long_background_tasks" msgid="5788956269136054574">"longues tâches, transfert de données, tâches en arrière-plan"</string>
    <string name="reset_shortcut_manager_throttling" msgid="2183940254903144298">"Réinitialiser la limitation de fréquence ShortcutManager"</string>
    <string name="reset_shortcut_manager_throttling_complete" msgid="8949943009096885470">"La limitation de fréquence ShortcutManager a été réinitialisée"</string>
    <string name="notification_suggestion_title" msgid="6309263655965785411">"Gérer les données sur l\'écran de verrouillage"</string>
    <string name="notification_suggestion_summary" msgid="7615611244249276113">"Afficher ou masquer le contenu des notifications"</string>
    <string name="page_tab_title_support" msgid="3235725053332345773">"Astuces et assistance"</string>
    <string name="developer_smallest_width" msgid="632354817870920911">"La plus petite largeur"</string>
    <string name="premium_sms_none" msgid="8737045049886416739">"Aucune application installée n\'a demandé l\'accès aux textos payants"</string>
    <string name="premium_sms_warning" msgid="2192300872411073324">"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="5605970342699013212">"Accès aux textos payants"</string>
    <string name="bluetooth_disabled" msgid="835838280837359514">"Désactivé"</string>
    <string name="bluetooth_connected_summary" msgid="8043167194934315712">"Connecté à <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="bluetooth_connected_multiple_devices_summary" msgid="2294954614327771844">"Connecté à plusieurs appareils"</string>
    <string name="demo_mode" msgid="6566167465451386728">"Mode Démo de l\'interface système"</string>
    <string name="dark_ui_mode" msgid="898146394425795281">"Thème sombre"</string>
    <string name="dark_ui_mode_disabled_summary_dark_theme_on" msgid="4554134480159161533">"Temporairement désactivé par l\'économiseur de pile"</string>
    <string name="ambient_camera_summary_battery_saver_on" msgid="1787784892047029560">"Temporairement désactivé par l\'économiseur de pile"</string>
    <string name="ambient_camera_battery_saver_off" msgid="689825730569761613">"Désactiver l\'économiseur de pile"</string>
    <string name="dark_ui_mode_disabled_summary_dark_theme_off" msgid="4154227921313505702">"Temporairement activé par l\'économiseur de pile"</string>
    <string name="dark_theme_slice_title" msgid="4684222119481114062">"Essayer le thème sombre"</string>
    <string name="dark_theme_slice_subtitle" msgid="5555724345330434268">"Contribue à prolonger l\'autonomie de la pile"</string>
    <string name="quick_settings_developer_tiles" msgid="7336007844525766623">"Paramètres rapides, tuiles de développeur"</string>
    <string name="adb_authorization_timeout_title" msgid="6996844506783749754">"Désactiver le délai d\'expiration des autorisations adb"</string>
    <string name="adb_authorization_timeout_summary" msgid="409931540424019778">"Désactiver le retrait automatique des autorisations adb pour des systèmes qui ne se sont pas connectés ou qui n\'ont pas été configurés par l\'utilisateur dans le délai d\'expiration par défaut (respectivement, sept jours et un jour minimum)."</string>
    <string name="winscope_trace_quick_settings_title" msgid="4104768565053226689">"Traçage Winscope"</string>
    <string name="sensors_off_quick_settings_title" msgid="8472151847125917167">"Capteurs désactivés"</string>
    <string name="managed_profile_settings_title" msgid="3400923723423564217">"Paramètres du profil professionnel"</string>
    <string name="managed_profile_contact_search_title" msgid="6562061740814513737">"Laissez les applications personnelles déterminer les contacts à l\'aide de l\'annuaire professionnel"</string>
    <string name="managed_profile_contact_search_summary" msgid="4974727886709219105">"Les recherches et les appels entrants peuvent être visibles pour votre administrateur informatique"</string>
    <string name="cross_profile_calendar_title" msgid="7570277841490216947">"Agenda multi-profil"</string>
    <string name="cross_profile_calendar_summary" msgid="8856185206722860069">"Afficher les événements professionnels dans l\'agenda personnel"</string>
    <string name="automatic_storage_manager_settings" msgid="519158151463974656">"Gérer l\'espace de stockage"</string>
    <string name="automatic_storage_manager_text" msgid="6900593059927987273">"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="5077286114860539367">"Supprimer les photos et les vidéos"</string>
    <string name="automatic_storage_manager_preference_title" msgid="3483357910142595444">"Gestionnaire de stockage"</string>
    <string name="automatic_storage_manager_primary_switch_title" msgid="9131959126462101994">"Utiliser le gestionnaire de stockage"</string>
    <string name="gesture_preference_title" msgid="8291899281322647187">"Gestes"</string>
    <string name="double_tap_power_for_camera_title" msgid="7982364144330923683">"Ouvrir rapidement l\'appareil photo"</string>
    <string name="double_tap_power_for_camera_summary" msgid="1100926048598415509">"Pour ouvrir rapidement l\'appareil photo, appuyer deux fois sur l\'interrupteur. Cela fonctionne à partir de n\'importe quel écran."</string>
    <string name="double_twist_for_camera_mode_title" msgid="472455236910935684">"Changer d\'appareil photo pour prendre un égoportrait"</string>
    <string name="double_twist_for_camera_mode_summary" msgid="592503740044744951"></string>
    <string name="system_navigation_title" msgid="4890381153527184636">"Mode de navigation"</string>
    <string name="swipe_up_to_switch_apps_title" msgid="6677266952021118342">"Navigation à deux boutons"</string>
    <string name="swipe_up_to_switch_apps_summary" msgid="1415457307836359560">"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="emergency_settings_preference_title" msgid="6183455153241187148">"Sécurité et urgence"</string>
    <string name="emergency_dashboard_summary" msgid="401033951074039302">"Appel d\'urgence, données médicales, alertes"</string>
    <string name="edge_to_edge_navigation_title" msgid="714427081306043819">"Navigation par gestes"</string>
    <string name="edge_to_edge_navigation_summary" msgid="8497033810637690561">"Pour accéder à l\'écran d\'accueil, balayez l\'écran du bas de vers le haut. Pour changer d\'application, balayez l\'écran du bas vers le haut, maintenez le doigt sur l\'écran, puis relâchez-le. Pour revenir en arrière, balayez l\'écran de gauche à droite ou de droite à gauche."</string>
    <string name="legacy_navigation_title" msgid="7877402855994423727">"Navigation à trois boutons"</string>
    <string name="legacy_navigation_summary" msgid="5905301067778326433">"Revenez en arrière, retournez à l\'écran d\'accueil ou changez d\'application à l\'aide des boutons dans le bas de votre écran."</string>
    <string name="keywords_system_navigation" msgid="3131782378486554934">"navigation système, navigation à deux boutons, navigation à trois boutons, navigation par gestes, balayer"</string>
    <string name="assistant_gesture_category_title" msgid="2478251256585807920">"Assistant numérique"</string>
    <string name="assistant_corner_gesture_title" msgid="1895061522687002106">"Balayer l\'écran pour appeler l\'assistant"</string>
    <string name="assistant_corner_gesture_summary" msgid="7279576276455168075">"Pour lancer l\'application de l\'assistant numérique, balayez l\'écran vers le haut à partir d\'un coin inférieur."</string>
    <string name="assistant_long_press_home_gesture_title" msgid="4865972278738178753">"Maintenir le doigt sur Accueil pour utiliser l\'Assistant"</string>
    <string name="assistant_long_press_home_gesture_summary" msgid="592882226105081447">"Maintenez la touche d\'accueil enfoncée pour invoquer l\'application d\'assistant numérique."</string>
    <string name="low_label" msgid="6525629096999711220">"Faible"</string>
    <string name="high_label" msgid="357503396626018487">"Élevée"</string>
    <string name="left_edge" msgid="1513576842959071849">"Bord gauche"</string>
    <string name="right_edge" msgid="1505309103265829121">"Bord droit"</string>
    <string name="back_sensitivity_dialog_message" msgid="6638367716784103306">"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="6153608904168908264">"Sensibilité du retour arrière"</string>
    <string name="gesture_settings_activity_title" msgid="2025828425762595733">"Sensibilité de la navigation par gestes"</string>
    <string name="button_navigation_settings_activity_title" msgid="7335636045504461813">"Navigation à boutons"</string>
    <string name="keywords_gesture_navigation_settings" msgid="667561222717238931">"navigation par gestes, sensibilité du retour arrière, geste de retour"</string>
    <string name="keywords_button_navigation_settings" msgid="7888812253110553920">"navigation, touche d\'accueil"</string>
    <string name="one_handed_title" msgid="2584414010282746195">"Mode Une main"</string>
    <string name="one_handed_mode_enabled" msgid="3396864848786359651">"Utiliser le mode Une main"</string>
    <string name="one_handed_mode_shortcut_title" msgid="1847871530184067369">"Raccourci pour le mode Une main"</string>
    <string name="keywords_one_handed" msgid="969440592493034101">"accessibilité"</string>
    <string name="one_handed_mode_swipe_down_category" msgid="110178629274462484">"Balayer l\'écran vers le bas pour"</string>
    <string name="one_handed_mode_use_shortcut_category" msgid="1414714099339147711">"Utiliser le raccourci pour"</string>
    <string name="one_handed_mode_intro_text" msgid="7921988617828924342">"Déroulez vers le bas la moitié supérieure de votre écran pour qu\'elle soit plus facile à atteindre d\'une seule main"</string>
    <string name="one_handed_mode_footer_text" msgid="6336209800330679840">" "<b>"Comment utiliser le mode Une main"</b>\n" • Assurez-vous que la navigation par gestes est sélectionnée dans les paramètres de navigation du système\n • Balayez vers le bas près du bord inférieur de l\'écran"</string>
    <string name="one_handed_action_pull_down_screen_title" msgid="9187194533815438150">"Glisser l\'écran pour l\'avoir à portée de votre pouce"</string>
    <string name="one_handed_action_pull_down_screen_summary" msgid="7582432473450036628">"Le haut de l\'écran se déplacera pour être à portée de votre pouce."</string>
    <string name="one_handed_action_show_notification_title" msgid="8789305491485437130">"Afficher les notifications"</string>
    <string name="one_handed_action_show_notification_summary" msgid="8281689861222000436">"Les notifications et les paramètres s\'afficheront."</string>
    <string name="ambient_display_summary" msgid="2650326740502690434">"Pour vérifier l\'heure, vos notifications et d\'autres renseignements, toucher deux fois l\'écran."</string>
    <string name="ambient_display_wake_screen_title" msgid="7637678749035378085">"Réactiver l\'écran"</string>
    <string name="ambient_display_tap_screen_summary" msgid="4480489179996521405">"Pour vérifier l\'heure, vos notifications et d\'autres renseignements, touchez l\'écran."</string>
    <string name="emergency_gesture_screen_title" msgid="3280543310204360902">"Appel d\'urgence"</string>
    <string name="emergency_gesture_switchbar_title" msgid="7421353963329899514">"Utiliser l\'appel d\'urgence"</string>
    <string name="emergency_gesture_screen_summary" msgid="6640521030845132507">"Appuyez rapidement sur l\'interrupteur cinq fois ou plus pour lancer les actions indiquées ci-dessous"</string>
    <string name="emergency_gesture_sound_setting_title" msgid="7153948164862156536">"Faire jouer l\'alarme de compte à rebours"</string>
    <string name="emergency_gesture_sound_setting_summary" msgid="6573377104470235173">"Émettre un signal sonore très fort au démarrage de l\'appel d\'urgence"</string>
    <string name="emergency_gesture_category_call_for_help_title" msgid="1680040129478289510">"Appeler à l\'aide"</string>
    <string name="emergency_gesture_call_for_help_title" msgid="4969340870836239982">"Appeler au secours"</string>
    <string name="emergency_gesture_call_for_help_dialog_title" msgid="8901271205171421201">"Numéro à composer pour appeler au secours"</string>
    <string name="emergency_gesture_call_for_help_summary" msgid="6552830427932669221">"<xliff:g id="PHONE_NUMBER">%1$s</xliff:g>. Toucher pour modifier"</string>
    <string name="emergency_gesture_number_override_notes" msgid="233018570696200402">"Si vous entrez un numéro autre qu\'un numéro d\'urgence :\n • Votre appareil doit être déverrouillé pour utiliser la fonctionnalité d\'appel d\'urgence\n • Il se pourrait que personne ne réponde à votre appel"</string>
    <string name="fingerprint_swipe_for_notifications_title" msgid="2271217256447175017">"Balayer le lecteur d\'empreintes pour voir les notifications"</string>
    <string name="fingerprint_gesture_screen_title" msgid="9086261338232806522">"Balayer empreinte digit."</string>
    <string name="fingerprint_swipe_for_notifications_suggestion_title" msgid="2956636269742745449">"Affichez les notifications rapidement"</string>
    <string name="gesture_setting_on" msgid="3223448394997988591">"Activé"</string>
    <string name="gesture_setting_off" msgid="3444029475726294919">"Désactivé"</string>
    <string name="oem_unlock_enable_disabled_summary_bootloader_unlocked" msgid="65713754674288193">"Le programme d\'amorçage est déjà déverrouillé"</string>
    <string name="oem_unlock_enable_disabled_summary_connectivity_or_locked" msgid="7425519481227423860">"Connectez à Internet ou contactez votre fournisseur de services"</string>
    <string name="oem_unlock_enable_disabled_summary_sim_locked_device" msgid="168124660162907358">"Non disp. sur les appareils verrouillés par un f. de services"</string>
    <string name="oem_lock_info_message" msgid="8843145669619429197">"Veuillez redémarrer l\'appareil pour activer la fonction de protection d\'appareil."</string>
    <string name="automatic_storage_manager_freed_bytes" msgid="706230592123831676">"<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="6654581786741216382">"Applications instantanées"</string>
    <string name="web_action_enable_summary" msgid="2658930257777545990">"Ouvrir les liens dans les applications, même si elles ne sont pas installées"</string>
    <string name="web_action_section_title" msgid="994717569424234098">"Applications instantanées"</string>
    <string name="instant_apps_settings" msgid="4280942494969957858">"Préf. applis instantanées"</string>
    <string name="domain_url_section_title" msgid="9028890472923474958">"Applications installées"</string>
    <string name="automatic_storage_manager_activation_warning" msgid="170508173207142665">"Votre espace de stockage est maintenant géré par le gestionnaire de stockage"</string>
    <string name="account_for_section_header" msgid="7466759342105251096">"Comptes pour <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="auto_sync_account_title" msgid="1070908045600374254">"Synchroniser automatiquement les données des applications"</string>
    <string name="auto_sync_account_summary" msgid="7580352130028957346">"Autoriser les applications à actualiser les données automatiquement"</string>
    <string name="account_sync_title" msgid="7036067017433297574">"Synchro du compte"</string>
    <string name="account_sync_summary_some_on" msgid="911460286297968724">"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="2953682111836599841">"La synchronisation est activée pour tous les éléments"</string>
    <string name="account_sync_summary_all_off" msgid="6378301874540507884">"La synchronisation est désactivée pour tous les éléments"</string>
    <string name="enterprise_privacy_settings" msgid="786350385374794180">"Renseignements sur l\'appareil géré"</string>
    <string name="enterprise_privacy_settings_summary_generic" msgid="5471858290610344646">"Changements et paramètres gérés par votre organisation"</string>
    <string name="enterprise_privacy_settings_summary_with_name" msgid="1315413275836515937">"Changements et paramètres gérés par <xliff:g id="ORGANIZATION_NAME">%s</xliff:g>"</string>
    <string name="enterprise_privacy_header" msgid="4626225398848641603">"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="2507761423540037308">"Types de données que votre organisation peut voir"</string>
    <string name="enterprise_privacy_exposure_changes_category" msgid="5459989751333816587">"Modifications apportées par l\'administrateur de votre organisation"</string>
    <string name="enterprise_privacy_device_access_category" msgid="140157499478630004">"Votre accès à cet appareil"</string>
    <string name="enterprise_privacy_enterprise_data" msgid="3963070078195245028">"Les données associées à votre compte professionnel, comme les courriels et l\'agenda"</string>
    <string name="enterprise_privacy_installed_packages" msgid="6707006112254572820">"Liste des applications installées sur votre appareil"</string>
    <string name="enterprise_privacy_usage_stats" msgid="6328506963853465534">"Temps passé et quantité de données utilisée pour chaque application"</string>
    <string name="enterprise_privacy_network_logs" msgid="3081744541193695887">"Journal de trafic réseau le plus récent"</string>
    <string name="enterprise_privacy_bug_reports" msgid="2635897583413134123">"Rapport de bogue le plus récent"</string>
    <string name="enterprise_privacy_security_logs" msgid="8494681624247959075">"Journal de sécurité le plus récent"</string>
    <string name="enterprise_privacy_none" msgid="6026527690979756431">"Aucune"</string>
    <string name="enterprise_privacy_enterprise_installed_packages" msgid="9114143640515900082">"Applications installées"</string>
    <string name="enterprise_privacy_apps_count_estimation_info" msgid="7959907857710107792">"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>
    <string name="enterprise_privacy_number_packages_lower_bound" msgid="5317634640873658149">"{count,plural, =1{Minimum de # application}one{Minimum de # application}other{Minimum de # applications}}"</string>
    <string name="enterprise_privacy_location_access" msgid="8023838718108456971">"Autorisations de localisation"</string>
    <string name="enterprise_privacy_microphone_access" msgid="7242958026470143653">"Autorisations du microphone"</string>
    <string name="enterprise_privacy_camera_access" msgid="7685460535880069016">"Autorisations de l\'appareil photo"</string>
    <string name="enterprise_privacy_enterprise_set_default_apps" msgid="7498546659083996300">"Applications par défaut"</string>
    <string name="enterprise_privacy_number_packages" msgid="5294444005035188274">"{count,plural, =1{# application}one{# application}other{# applications}}"</string>
    <string name="enterprise_privacy_input_method" msgid="3278314982700662246">"Clavier par défaut"</string>
    <string name="enterprise_privacy_input_method_name" msgid="2974859490559054584">"Valeur définie : <xliff:g id="APP_LABEL">%s</xliff:g>"</string>
    <string name="enterprise_privacy_always_on_vpn_device" msgid="1735829327405126695">"Le RPV permanent est activé"</string>
    <string name="enterprise_privacy_always_on_vpn_personal" msgid="8395903360175064841">"Le RPV permanent est activé dans votre profil personnel"</string>
    <string name="enterprise_privacy_always_on_vpn_work" msgid="2496961514592522377">"Le RPV permanent est activé dans votre profil professionnel"</string>
    <string name="enterprise_privacy_global_http_proxy" msgid="4350347418068037051">"Le serveur mandataire HTTP global a été défini"</string>
    <string name="enterprise_privacy_ca_certs_device" msgid="1816495877258727663">"Certificats de confiance"</string>
    <string name="enterprise_privacy_ca_certs_personal" msgid="1516422660828485795">"Certificats de confiance installés dans votre profil personnel"</string>
    <string name="enterprise_privacy_ca_certs_work" msgid="4318941788592655561">"Certificats de confiance installés dans votre profil professionnel"</string>
    <string name="enterprise_privacy_number_ca_certs" msgid="4540897122831942658">"{count,plural, =1{Minimum de # certificat CA}one{Minimum de # certificat CA}other{Minimum de # certificats CA}}"</string>
    <string name="enterprise_privacy_lock_device" msgid="464054894363899866">"L\'administrateur peut verrouiller l\'appareil et réinitialiser le mot de passe"</string>
    <string name="enterprise_privacy_wipe_device" msgid="869589182352244591">"L\'administrateur peut supprimer toutes les données de l\'appareil"</string>
    <string name="enterprise_privacy_failed_password_wipe_device" msgid="7045164901334821226">"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="2537582942554484170">"Nombre maximal de tentatives d\'entrée du mot de passe avant de supprimer les données du profil professionnel"</string>
    <string name="enterprise_privacy_number_failed_password_wipe" msgid="2695842143305867642">"{count,plural, =1{# tentative}one{# tentative}other{# tentatives}}"</string>
    <string name="do_disclosure_generic" msgid="3067459392402324538">"Cet appareil est géré par votre organisation."</string>
    <string name="do_disclosure_with_name" msgid="867544298924410766">"Cet appareil est géré par <xliff:g id="ORGANIZATION_NAME">%s</xliff:g>."</string>
    <string name="do_disclosure_learn_more_separator" msgid="5714364437437041671">" "</string>
    <string name="learn_more" msgid="3534519107947510952">"En savoir plus"</string>
    <string name="blocked_by_restricted_settings_title" msgid="7334715011474037399">"Paramètres restreints"</string>
    <string name="toast_allows_restricted_settings_successfully" msgid="1219116121291466102">"Paramètres restreints autorisés pour <xliff:g id="APP_NAME">%s</xliff:g>"</string>
    <string name="blocked_by_restricted_settings_content" msgid="3628660029601161080">"Pour protéger votre sécurité, ce paramètre n\'est pas accessible actuellement."</string>
    <string name="financed_privacy_settings" msgid="2575114436197204145">"Renseignements sur l\'appareil financé"</string>
    <string name="financed_privacy_intro" msgid="7836497475568741579">"Votre fournisseur de crédit peut modifier des paramètres et installer des logiciels sur cet appareil pendant la configuration.\n\nSi vous manquez un paiement, votre fournisseur de crédit peut verrouiller votre appareil et en modifier les paramètres.\n\nPour en savoir plus, communiquez avec votre fournisseur de crédit."</string>
    <string name="financed_privacy_restrictions_category" msgid="2472659467919651602">"Si votre appareil est financé, vous ne pouvez pas :"</string>
    <string name="financed_privacy_install_apps" msgid="7381718005710210851">"Installer des applications ne provenant pas de Play Store"</string>
    <string name="financed_privacy_safe_mode" msgid="5362149445732602578">"Redémarrer votre appareil en mode sans échec"</string>
    <string name="financed_privacy_multi_users" msgid="1727194928477613081">"Ajouter plusieurs utilisateurs à votre appareil"</string>
    <string name="financed_privacy_config_date_time" msgid="8567370445374984365">"Modifier la date, l\'heure et les fuseaux horaires"</string>
    <string name="financed_privacy_developer_options" msgid="7602001474669831672">"Utiliser options pour les développeurs"</string>
    <string name="financed_privacy_credit_provider_capabilities_category" msgid="8737902277892987998">"Votre fournisseur de crédit peut :"</string>
    <string name="financed_privacy_IMEI" msgid="1852413860963824799">"Accéder à votre numéro IIEM"</string>
    <string name="financed_privacy_factory_reset" msgid="5505016667590160732">"Rétablir les paramètres par défaut de votre appareil en cas de problème"</string>
    <string name="financed_privacy_locked_mode_category" msgid="3708288398912647751">"Si votre appareil est verrouillé, vous ne pouvez l\'utiliser que pour :"</string>
    <string name="financed_privacy_emergency_calls" msgid="1108183987142736497">"Passer des appels d\'urgence"</string>
    <string name="financed_privacy_system_info" msgid="4158031444108708927">"Afficher les données système telles que la date, l\'heure, l\'état du réseau et l\'état de la pile"</string>
    <string name="financed_privacy_turn_on_off_device" msgid="3331566753152790571">"Activer ou désactiver votre appareil"</string>
    <string name="financed_privacy_notifications" msgid="5932303271274089968">"Afficher les notifications et les messages texte"</string>
    <string name="financed_privacy_allowlisted_apps" msgid="8333040812194879963">"Accéder aux applications autorisées par le fournisseur de crédit"</string>
    <string name="financed_privacy_fully_paid_category" msgid="9221763928564246923">"Une fois que vous avez payé le montant total :"</string>
    <string name="financed_privacy_restrictions_removed" msgid="3182636815294595072">"Toutes les restrictions sont retirées de l\'appareil"</string>
    <string name="financed_privacy_uninstall_creditor_app" msgid="6339004120497310705">"Vous pouvez désinstaller l\'appli du fournisseur de crédit"</string>
    <string name="default_camera_app_title" msgid="6546248868519965998">"{count,plural, =1{Application Appareil photo}one{Application Appareil photo}other{Applications Appareil photo}}"</string>
    <string name="default_calendar_app_title" msgid="1870095225089706093">"Application d\'agenda"</string>
    <string name="default_contacts_app_title" msgid="7740028900741944569">"Application de contacts"</string>
    <string name="default_email_app_title" msgid="5411280873093244250">"{count,plural, =1{Application de client de messagerie}one{Application de client de messagerie}other{Applications de client de messagerie}}"</string>
    <string name="default_map_app_title" msgid="7569231732944853320">"Application de carte"</string>
    <string name="default_phone_app_title" msgid="795025972645464135">"{count,plural, =1{Application Téléphone}one{Application Téléphone}other{Applications Téléphone}}"</string>
    <string name="app_names_concatenation_template_2" msgid="8320181646458855457">"<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="7019703249717854148">"<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_default_internal_storage" msgid="4055660218818688131">"Cet appareil"</string>
    <string name="storage_games" msgid="1176568610086802469">"Jeux"</string>
    <string name="storage_files" msgid="7968460921272772299">"Fichiers"</string>
    <string name="storage_images" msgid="2055893015567979387">"Images"</string>
    <string name="storage_videos" msgid="6117698226447251033">"Vidéos"</string>
    <string name="storage_audio" msgid="5994664984472140386">"Audio"</string>
    <string name="storage_apps" msgid="3564291603258795216">"Applications"</string>
    <string name="storage_documents_and_other" msgid="3293689243732236480">"Documents et autres"</string>
    <string name="storage_system" msgid="8472410119822911844">"Système"</string>
    <string name="storage_trash" msgid="2807138998886084856">"Corbeille"</string>
    <string name="storage_trash_dialog_title" msgid="2296169576049935200">"Vider la corbeille?"</string>
    <string name="storage_trash_dialog_ask_message" msgid="8982602137242358798">"Il y a <xliff:g id="TOTAL">%1$s</xliff:g> de fichiers dans la corbeille. Tous les éléments seront supprimés définitivement. Ils ne pourront pas être restaurés."</string>
    <string name="storage_trash_dialog_empty_message" msgid="7334670765528691400">"La corbeille est vide"</string>
    <string name="storage_trash_dialog_confirm" msgid="1707723334982760436">"Vider la corbeille"</string>
    <string name="storage_usage_summary" msgid="4591121727356723463">"<xliff:g id="NUMBER">%1$s</xliff:g> <xliff:g id="UNIT">%2$s</xliff:g> utilisés"</string>
    <string name="storage_total_summary" msgid="7163360249534964272">"<xliff:g id="NUMBER">%1$s</xliff:g> <xliff:g id="UNIT">%2$s</xliff:g> au total"</string>
    <string name="clear_instant_app_data" msgid="5951258323364386357">"Effacer les données de l\'application"</string>
    <string name="clear_instant_app_confirmation" msgid="3964731334459209482">"Voulez-vous supprimer cette application instantanée?"</string>
    <string name="launch_instant_app" msgid="8503927414339606561">"Ouvrir"</string>
    <string name="game_storage_settings" msgid="2521393115726178837">"Jeux"</string>
    <string name="app_info_storage_title" msgid="4076977173803093808">"Espace utilisé"</string>
    <string name="webview_uninstalled_for_user" msgid="627352948986275488">"(désinst. pour l\'utilisateur <xliff:g id="USER">%s</xliff:g>)"</string>
    <string name="webview_disabled_for_user" msgid="5809886172032644498">"(désactivé pour l\'utilisateur <xliff:g id="USER">%s</xliff:g>)"</string>
    <string name="autofill_app" msgid="7595308061826307921">"Service de remplissage auto"</string>
    <string name="default_autofill_app" msgid="372234803718251606">"Service de remplissage automatique par défaut"</string>
    <string name="autofill_passwords" msgid="6708057251459761083">"Mots de passe"</string>
    <string name="credman_credentials" msgid="7413302794874989255">"Services de mots de passe, de clés d\'accès et de données"</string>
    <string name="autofill_passwords_count" msgid="6359289285822955973">"{count,plural, =1{# mot de passe}one{# mot de passe}other{# mots de passe}}"</string>
    <string name="autofill_keywords" msgid="8598763328489346438">"automatique, remplir, remplissage automatique, mot de passe"</string>
    <string name="credman_keywords" msgid="8305600680836806170">"données, clé d\'accès, mot de passe"</string>
    <string name="autofill_confirmation_message" msgid="4888767934273494272">"&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="credman_confirmation_message_title" msgid="8847900085593880729">"Désactiver %1$s?"</string>
    <string name="credman_confirmation_message" msgid="3499478570809427026">"Lorsque vous vous connectez, les renseignements enregistrés, comme les adresses ou les modes de paiement, ne seront pas remplis. Pour que vos données enregistrées soient remplies, activez un service de mot de passe, de clé d\'accès ou de données."</string>
    <string name="credman_enable_confirmation_message_title" msgid="3722566298090698004">"Activer %1$s?"</string>
    <string name="credman_enable_confirmation_message" msgid="4466773747277583461">"Les renseignements enregistrés, tels que les adresses ou les modes de paiement, seront communiqués à ce fournisseur."</string>
    <string name="credman_enable_confirmation_message_positive_button" msgid="3479082692924433102">"Activer"</string>
    <string name="credman_error_message_title" msgid="4741457523969373713">"Limite atteinte pour les services de mots de passe, de clés d\'accès et de données"</string>
    <string name="credman_error_message" msgid="6793314648458925172">"Vous pouvez disposer d\'un maximum de cinq services de mots de passe, de clés d\'accès et de données actifs en même temps. Désactivez un service pour en ajouter d\'autres."</string>
    <string name="credman_confirmation_message_positive_button" msgid="2812613187691345361">"Désactiver"</string>
    <string name="debug_autofill_category" msgid="5998163555428196185">"Remplissage automatique"</string>
    <string name="autofill_logging_level_title" msgid="3733958845861098307">"Niveau de journalisation"</string>
    <string name="autofill_max_partitions" msgid="7342195529574406366">"Nombre maximal de demandes par session"</string>
    <string name="autofill_max_visible_datasets" msgid="4970201981694392229">"Nombre maximal d\'ensembles de données"</string>
    <string name="autofill_reset_developer_options" msgid="6425613608979498608">"Réinitialiser aux valeurs par défaut"</string>
    <string name="autofill_reset_developer_options_complete" msgid="1276741935956594965">"Les options de remplissage automatique du développeur ont été réinitialisées"</string>
    <string name="location_category" msgid="3496759112306219062">"Localisation"</string>
    <string name="location_indicator_settings_title" msgid="6655916258720093451">"Indicateur de localisation dans la barre d\'état"</string>
    <string name="location_indicator_settings_description" msgid="2888022085372804021">"Afficher pour tous les lieux, y compris le réseau et la connectivité"</string>
    <string name="enable_gnss_raw_meas_full_tracking" msgid="1206679951510243341">"Forcer les mesures GNSS complètes"</string>
    <string name="enable_gnss_raw_meas_full_tracking_summary" msgid="3841463141138247167">"Faire le suivi de toutes les constellations et les fréquences GNSS sans cycle de tâches"</string>
    <string name="input_method_category" msgid="2252659253631639005">"Méthode d\'entrée"</string>
    <string name="stylus_handwriting" msgid="2154591374132794563">"Écriture manuscrite au stylet"</string>
    <string name="stylus_handwriting_summary" msgid="6333425895172696950">"Lorsqu\'elle est activée, la méthode d\'entrée actuelle reçoit le stylet MotionEvent si un éditeur est mis en évidence."</string>
    <string name="device_theme" msgid="5027604586494772471">"Thème de l\'appareil"</string>
    <string name="default_theme" msgid="4815428567082263639">"Par défaut"</string>
    <string name="show_operator_name_title" msgid="3355910331531144028">"Nom du réseau"</string>
    <string name="show_operator_name_summary" msgid="5352696579216501773">"Afficher le nom du réseau dans la barre d\'état"</string>
    <string name="install_type_instant" msgid="7685381859060486009">"Application instantanée"</string>
    <string name="automatic_storage_manager_deactivation_warning" msgid="4905106133215702099">"Désactiver le gestionnaire de stockage?"</string>
    <string name="zen_suggestion_title" msgid="4555260320474465668">"Mettre à jour les paramètres du mode Ne pas déranger"</string>
    <string name="zen_suggestion_summary" msgid="1984990920503217">"Suspendre les notifications pour rester concentré"</string>
    <string name="disabled_feature" msgid="7151433782819744211">"Cette fonctionnalité n\'est pas accessible"</string>
    <string name="disabled_feature_reason_slow_down_phone" msgid="5743569256308510404">"Cette fonctionnalité a été désactivée, car elle ralentit votre téléphone"</string>
    <string name="show_first_crash_dialog" msgid="1696584857732637389">"Toujours afficher la fenêtre de plantage"</string>
    <string name="show_first_crash_dialog_summary" msgid="4692334286984681111">"Afficher la fenêtre chaque fois qu\'une application plante"</string>
    <string name="angle_enabled_app" msgid="6044941043384239076">"Sélectionnez l\'application compatible avec ANGLE"</string>
    <string name="angle_enabled_app_not_set" msgid="4472572224881726067">"Aucune application compatible avec ANGLE n\'a été définie"</string>
    <string name="angle_enabled_app_set" msgid="7811829383833353021">"Application compatible avec ANGLE : <xliff:g id="APP_NAME">%1$s</xliff:g>"</string>
    <string name="graphics_driver_dashboard_title" msgid="5661084817492587796">"Préférences du pilote graphique"</string>
    <string name="graphics_driver_dashboard_summary" msgid="6348759885315793654">"Modifier les paramètres du pilote graphique"</string>
    <string name="graphics_driver_footer_text" msgid="5123754522284046790">"Lorsqu\'il y a de nombreux pilotes graphiques, vous pouvez choisir d\'utiliser le pilote graphique à jour pour les applications installées sur l\'appareil."</string>
    <string name="graphics_driver_all_apps_preference_title" msgid="1343065382898127360">"Activer pour toutes les applications"</string>
    <string name="graphics_driver_app_preference_title" msgid="3133255818657706857">"Sélectionner un pilote graphique"</string>
    <string name="graphics_driver_app_preference_default" msgid="764432460281859855">"Par défaut"</string>
    <string name="graphics_driver_app_preference_production_driver" msgid="1515874802568434915">"Pilote du jeu"</string>
    <string name="graphics_driver_app_preference_prerelease_driver" msgid="7355929161805829480">"Pilote pour développeurs"</string>
    <string name="graphics_driver_app_preference_system" msgid="3754748149113184126">"Pilote graphique du système"</string>
    <!-- no translation found for graphics_driver_all_apps_preference_values:0 (8039644515855740879) -->
    <!-- no translation found for graphics_driver_all_apps_preference_values:1 (157748136905839375) -->
    <!-- no translation found for graphics_driver_all_apps_preference_values:2 (8104576549429294026) -->
    <!-- no translation found for graphics_driver_app_preference_values:0 (6403705826179314116) -->
    <!-- no translation found for graphics_driver_app_preference_values:1 (485288770206606512) -->
    <!-- no translation found for graphics_driver_app_preference_values:2 (5391218026495225599) -->
    <!-- no translation found for graphics_driver_app_preference_values:3 (2586045835780389650) -->
    <string name="platform_compat_dashboard_title" msgid="1323980546791790236">"Changements dans la compatibilité des applications"</string>
    <string name="platform_compat_dashboard_summary" msgid="4036546607938791337">"Basculer les changements de compatibilité des applications"</string>
    <string name="platform_compat_default_enabled_title" msgid="8973137337738388024">"Changements activés par défaut"</string>
    <string name="platform_compat_default_disabled_title" msgid="3975847180953793602">"Changements désactivés par défaut"</string>
    <string name="platform_compat_dialog_title_no_apps" msgid="4387656000745989506">"Aucune application"</string>
    <string name="platform_compat_dialog_text_no_apps" msgid="5715226015751055812">"Les modifications de compatibilité des applications peuvent uniquement être modifiées pour les applications débogables. Installez une application débogable, puis réessayez."</string>
    <string name="disabled_dependent_setting_summary" msgid="4508635725315852504">"Dépend d\'un autre paramètre"</string>
    <string name="my_device_info_account_preference_title" msgid="9197139254007133175">"Compte"</string>
    <string name="my_device_info_device_name_preference_title" msgid="8053298498727237971">"Nom de l\'appareil"</string>
    <string name="my_device_info_basic_info_category_title" msgid="381963187269356548">"Renseignements généraux"</string>
    <string name="my_device_info_legal_category_title" msgid="7732792841537995127">"Législation et réglementation"</string>
    <string name="my_device_info_device_details_category_title" msgid="4848438695638348680">"Détails de l\'appareil"</string>
    <string name="my_device_info_device_identifiers_category_title" msgid="2197063484127704153">"Identifiants de l\'appareil"</string>
    <string name="change_wifi_state_title" msgid="5629648102837821525">"Gestion du Wi-Fi"</string>
    <string name="change_wifi_state_app_detail_switch" msgid="1385358508267180745">"Autoriser l\'application à gérer le Wi-Fi"</string>
    <string name="change_wifi_state_app_detail_summary" msgid="8230854855584217111">"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="change_nfc_tag_apps_title" msgid="91514009058149617">"Lancer au moyen de la CCP"</string>
    <string name="change_nfc_tag_apps_detail_switch" msgid="240286205725043561">"Autoriser le lancement d\'applications lorsqu\'une balise CCP est détectée"</string>
    <string name="change_nfc_tag_apps_detail_summary" msgid="7083666814715607078">"Autorisez cette application à se lancer lorsqu\'une balise CCP est détectée.\nSi cette autorisation est activée, l\'application sera affichée comme option chaque fois qu\'une balise est détectée."</string>
    <string name="media_output_title" msgid="8283629315159510680">"Faire jouer les contenus multimédias sur"</string>
    <string name="media_output_label_title" msgid="4139048973886819148">"Faire jouer <xliff:g id="LABEL">%s</xliff:g> sur"</string>
    <string name="media_output_default_summary" msgid="4200343059396412376">"Cet appareil"</string>
    <string name="media_out_summary_ongoing_call_state" msgid="475188726850090363">"Indisponible pendant les appels"</string>
    <string name="take_call_on_title" msgid="1159417893879946757">"Répondre à l\'appel sur"</string>
    <string name="cannot_change_apn_toast" msgid="296540724089240405">"Impossible de modifier ce nom de point d\'accès."</string>
    <string name="gesture_prevent_ringing_screen_title" msgid="8293094715267769349">"Empêcher la sonnerie"</string>
    <string name="gesture_prevent_ringing_title" msgid="5978577898997523581">"Appuyez simultanément sur l\'interrupteur et sur la touche d\'augmentation du volume pour"</string>
    <string name="gesture_prevent_ringing_sound_title" msgid="4529077822282099235">"Raccourci pour empêcher la sonnerie"</string>
    <string name="prevent_ringing_option_vibrate" msgid="5456962289649581737">"Activer les vibrations"</string>
    <string name="prevent_ringing_option_mute" msgid="7446121133560945051">"Désactiver le son"</string>
    <string name="prevent_ringing_option_vibrate_summary" msgid="3435299885425754304">"Vibration"</string>
    <string name="prevent_ringing_option_mute_summary" msgid="3939350522269337013">"Désactiver le son"</string>
    <string name="prevent_ringing_option_unavailable_lpp_summary" msgid="8070356204398144241">"Pour activer la fonctionnalité, modifiez d\'abord l\'option « Maintenir l\'interrupteur enfoncé » du menu de l\'interrupteur."</string>
    <string name="pref_title_network_details" msgid="7329759534269363308">"Infos sur le réseau"</string>
    <string name="about_phone_device_name_warning" msgid="1938930553285875166">"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 à un réseau Wi-Fi, ou lorsque vous configurez un point d\'accès Wi-Fi."</string>
    <string name="devices_title" msgid="649715719278562515">"Appareils"</string>
    <string name="choose_network_title" msgid="5355609223363859430">"Choisir un réseau"</string>
    <string name="network_disconnected" msgid="8281188173486212661">"Déconnecté"</string>
    <string name="network_connected" msgid="7637745547242487795">"Connecté"</string>
    <string name="network_connecting" msgid="6856124847029124041">"Connexion en cours…"</string>
    <string name="network_could_not_connect" msgid="676574629319069922">"Impossible de se connecter"</string>
    <string name="empty_networks_list" msgid="6519489879480673428">"Aucun réseau trouvé."</string>
    <string name="network_query_error" msgid="6406348372070035274">"Impossible de trouver des réseaux. Réessayez."</string>
    <string name="forbidden_network" msgid="7404863971282262991">"(interdit)"</string>
    <string name="sim_card" msgid="6381158752066377709">"SIM"</string>
    <string name="wifi_no_sim_card" msgid="7144290066491585672">"Aucune carte SIM"</string>
    <string name="wifi_no_related_sim_card" msgid="3568255415415630510">"Aucune"</string>
    <string name="wifi_require_sim_card_to_connect" msgid="1524984445750423666">"Une carte SIM est requise pour établir la connexion"</string>
    <string name="wifi_require_specific_sim_card_to_connect" msgid="8136020469861668506">"Une carte SIM de <xliff:g id="WIRELESS_CARRIER">%s</xliff:g> est requise pour établir la connexion"</string>
    <string name="preferred_network_mode_wcdma_perf_summary" msgid="230527592752934655">"Mode réseau préféré : WCDMA de préférence"</string>
    <string name="preferred_network_mode_gsm_only_summary" msgid="2936969642076535162">"Mode réseau préféré : GSM uniquement"</string>
    <string name="preferred_network_mode_wcdma_only_summary" msgid="632816273979433076">"Mode réseau préféré : WCDMA uniquement"</string>
    <string name="preferred_network_mode_gsm_wcdma_summary" msgid="6419309630040697488">"Mode réseau préféré : GSM/WCDMA"</string>
    <string name="preferred_network_mode_cdma_summary" msgid="5735467143380764681">"Mode réseau préféré : CDMA"</string>
    <string name="preferred_network_mode_cdma_evdo_summary" msgid="1667358006735235626">"Mode réseau préféré : CDMA/EvDo"</string>
    <string name="preferred_network_mode_cdma_only_summary" msgid="6305930965673800101">"Mode réseau préféré : CDMA uniquement"</string>
    <string name="preferred_network_mode_evdo_only_summary" msgid="613903666107299289">"Mode réseau préféré : EvDo uniquement"</string>
    <string name="preferred_network_mode_cdma_evdo_gsm_wcdma_summary" msgid="5643603478619124717">"Mode réseau préféré : CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_lte_summary" msgid="4236015557975544307">"Mode réseau préféré : LTE"</string>
    <string name="preferred_network_mode_lte_gsm_wcdma_summary" msgid="1377100995001285751">"Mode réseau préféré : GSM/WCDMA/LTE"</string>
    <string name="preferred_network_mode_lte_cdma_evdo_summary" msgid="1221806410911793222">"Mode réseau préféré : CDMA+LTE/EvDo"</string>
    <string name="preferred_network_mode_lte_cdma_evdo_gsm_wcdma_summary" msgid="8974263692041299883">"Mode réseau préféré : LTE/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_global_summary" msgid="817118763629102239">"Mode réseau préféré : global"</string>
    <string name="preferred_network_mode_lte_wcdma_summary" msgid="7326137039981934928">"Mode réseau préféré : LTE/WCDMA"</string>
    <string name="preferred_network_mode_lte_gsm_umts_summary" msgid="5105989927899481131">"Mode réseau préféré : LTE/GSM/UMTS"</string>
    <string name="preferred_network_mode_lte_cdma_summary" msgid="2364210682008525703">"Mode réseau préféré : LTE/CDMA"</string>
    <string name="preferred_network_mode_tdscdma_summary" msgid="796303916110624922">"Mode réseau préféré : TDSCDMA"</string>
    <string name="preferred_network_mode_tdscdma_wcdma_summary" msgid="1465990745594594173">"Mode réseau préféré : TDSCDMA/WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_summary" msgid="3771917510642642724">"Mode réseau préféré : LTE/TDSCDMA"</string>
    <string name="preferred_network_mode_tdscdma_gsm_summary" msgid="8906951876805688851">"Mode réseau préféré : TDSCDMA/GSM"</string>
    <string name="preferred_network_mode_lte_tdscdma_gsm_summary" msgid="2264537129425897267">"Mode réseau préféré : LTE/GSM/TDSCDMA"</string>
    <string name="preferred_network_mode_tdscdma_gsm_wcdma_summary" msgid="2469046704847661521">"Mode réseau préféré : TDSCDMA/GSM/WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_wcdma_summary" msgid="2276439307637315057">"Mode réseau préféré : LTE/TDSCDMA/WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_gsm_wcdma_summary" msgid="1640309016390119366">"Mode réseau préféré : LTE/TDSCDMA/GSM/WCDMA"</string>
    <string name="preferred_network_mode_tdscdma_cdma_evdo_gsm_wcdma_summary" msgid="8918066490624875671">"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="1059705864131001171">"Mode réseau préféré : LTE/TDSCDMA/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_nr_only_summary" msgid="9153575102136218656">"Mode réseau préféré : NR seulement"</string>
    <string name="preferred_network_mode_nr_lte_summary" msgid="4326679533556458480">"Mode réseau préféré : NR/LTE"</string>
    <string name="preferred_network_mode_nr_lte_cdma_evdo_summary" msgid="4030662583832600005">"Mode réseau préféré : NR/LTE/CDMA/EvDo"</string>
    <string name="preferred_network_mode_nr_lte_gsm_wcdma_summary" msgid="8327982533965785835">"Mode réseau préféré : NR/LTE/GSM/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_cdma_evdo_gsm_wcdma_summary" msgid="7892233480076496041">"Mode réseau préféré : NR/LTE/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_wcdma_summary" msgid="5762334298562095421">"Mode réseau préféré : NR/LTE/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_summary" msgid="2356681171665091175">"Mode réseau préféré : NR/LTE/TDSCDMA"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_gsm_summary" msgid="8889597344872814893">"Mode réseau préféré : NR/LTE/TDSCDMA/GSM"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_wcdma_summary" msgid="506057560516483258">"Mode réseau préféré : NR/LTE/TDSCDMA/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_gsm_wcdma_summary" msgid="4337061745216872524">"Mode réseau préféré : NR/LTE/TDSCDMA/GSM/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_cdma_evdo_gsm_wcdma_summary" msgid="3396717432149544381">"Mode réseau préféré : NR/LTE/TDSCDMA/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="network_5G_recommended" msgid="4769018972369031538">"5G (recommandé)"</string>
    <string name="network_lte" msgid="2449425437381668780">"LTE (recommandé)"</string>
    <string name="network_4G" msgid="9018841362928321047">"4G (recommandé)"</string>
    <string name="select_automatically" msgid="2419752566747259155">"Sélectionner automatiquement le réseau"</string>
    <string name="carrier_settings_title" msgid="6959295328730560529">"Param. du fourn. de serv."</string>
    <string name="cdma_lte_data_service" msgid="6937443423651347345">"Configurer service de données"</string>
    <string name="mobile_data_settings_title" msgid="3927524078598009792">"Données cellulaires"</string>
    <string name="mobile_data_settings_summary" msgid="7323978798199919063">"Accédez aux données sur réseau cellulaire"</string>
    <string name="mobile_data_settings_summary_auto_switch" msgid="7851549787645698945">"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="mobile_data_settings_summary_unavailable" msgid="9176513507571883986">"Aucune carte SIM n\'est utilisable"</string>
    <string name="calls_preference" msgid="2166481296066890129">"Préférences d\'appel"</string>
    <string name="sms_preference" msgid="7742964962568219351">"Préférences de messagerie texte"</string>
    <string name="calls_and_sms_ask_every_time" msgid="3178743088737726677">"Toujours demander"</string>
    <string name="mobile_network_summary_add_a_network" msgid="9079866102827526779">"Ajouter un réseau"</string>
    <string name="default_for_calls" msgid="2788950217176988034">"Valeur par défaut pour les appels"</string>
    <string name="default_for_sms" msgid="1316988329407434771">"Valeur par défaut pour les messages texte"</string>
    <string name="default_for_calls_and_sms" msgid="8223971369339958151">"Valeur par déf. pour appels et les textos"</string>
    <string name="default_for_mobile_data" msgid="3725773640392315626">"Valeur par défaut pour donn. cellulaires"</string>
    <string name="mobile_data_active" msgid="8683694456401350210">"Données cellulaires actives"</string>
    <string name="mobile_data_off" msgid="2702029611959308269">"Données cellulaires désactivées"</string>
    <string name="subscription_available" msgid="2659722770210403365">"Disponible"</string>
    <string name="mobile_network_list_add_more" msgid="5076722903436552813">"Ajouter une carte SIM"</string>
    <string name="mobile_network_active_sim" msgid="6397581267971410039">"Services actifs/Carte SIM"</string>
    <string name="mobile_network_inactive_sim" msgid="5829757490580409899">"Services inactifs/Carte SIM"</string>
    <string name="mobile_network_active_esim" msgid="3984452275968408382">"Actif/eSIM"</string>
    <string name="mobile_network_inactive_esim" msgid="8777415108263057939">"Inactif/eSIM"</string>
    <string name="mobile_network_sim_name" msgid="3187192894150386537">"Nom et couleur de la carte SIM"</string>
    <string name="mobile_network_sim_name_label" msgid="1452440641628369625">"Nom"</string>
    <string name="mobile_network_sim_color_label" msgid="5293944087609632340">"Couleur (utilisée par applis compatibles)"</string>
    <string name="mobile_network_sim_name_rename" msgid="5967588549571582924">"Enregistrer"</string>
    <string name="mobile_network_use_sim_on" msgid="7298332437547707908">"Utiliser la carte SIM"</string>
    <string name="mobile_network_use_sim_off" msgid="6303281166199670639">"Désactivé"</string>
    <string name="mobile_network_disable_sim_explanation" msgid="2851862257846773796">"Pour désactiver cette carte SIM, retirez-la"</string>
    <string name="mobile_network_tap_to_activate" msgid="4139979375717958102">"Touchez pour activer le réseau de <xliff:g id="CARRIER">%1$s</xliff:g>"</string>
    <string name="mobile_network_erase_sim" msgid="4629071168032714930">"Effacer la carte SIM"</string>
    <string name="preferred_network_mode_title" msgid="3083431168988535628">"Type de réseau préféré"</string>
    <string name="preferred_network_mode_summary" msgid="537577807865497546">"Changer le mode de fonctionnement du réseau"</string>
    <string name="preferred_network_mode_dialogtitle" msgid="4179420486180351631">"Type de réseau préféré"</string>
    <string name="carrier_settings_version" msgid="3364919669057317776">"Version des paramètres du fournisseur de services"</string>
    <string name="call_category" msgid="641461844504128789">"Appels"</string>
    <string name="video_calling_settings_title" msgid="5490466306783552190">"Appels vidéo par l\'entremise du fournisseur de services"</string>
    <string name="cdma_system_select_title" msgid="8261408056382123386">"Sélection système"</string>
    <string name="cdma_system_select_summary" msgid="384128007068464145">"Modifier le mode d\'itinérance CDMA"</string>
    <string name="cdma_system_select_dialogtitle" msgid="6143586810486936984">"Sélection système"</string>
    <string name="network_operator_category" msgid="5309383730335681395">"Réseau"</string>
    <string name="cdma_subscription_title" msgid="3107207913315872336">"Abonnement CDMA"</string>
    <string name="cdma_subscription_summary" msgid="7134032708555561334">"Basculer entre les cartes RUIM/SIM et NV"</string>
    <string name="cdma_subscription_dialogtitle" msgid="555971296756231647">"abonnement"</string>
    <string name="register_automatically" msgid="5208258089316657167">"Enregistrement automatique en cours…"</string>
    <string name="roaming_alert_title" msgid="9052791521868787985">"Autoriser les données en itinérance?"</string>
    <string name="roaming_check_price_warning" msgid="5876977438036791361">"Communiquez avec votre fournisseur réseau pour connaître les tarifs."</string>
    <string name="mobile_data_usage_title" msgid="2047864499317759728">"Utilisation des données par application"</string>
    <string name="mobile_network_mode_error" msgid="9222056129897416074">"Mode réseau non valide : <xliff:g id="NETWORKMODEID">%1$d</xliff:g>. Ignorer."</string>
    <string name="mobile_network_apn_title" msgid="5582995550142073054">"Noms des points d\'accès"</string>
    <string name="keywords_access_point_names" msgid="8174967126858505945">"nom du point d\'accès"</string>
    <string name="manual_mode_disallowed_summary" msgid="4243142645520152175">"Indisponible lorsque vous êtes connectés au réseau de <xliff:g id="CARRIER">%1$s</xliff:g>"</string>
    <string name="see_more" msgid="7499355691042812723">"En voir plus"</string>
    <string name="sim_action_enable_sub_dialog_title" msgid="4003377033815971802">"Activer <xliff:g id="CARRIER_NAME">%1$s</xliff:g>?"</string>
    <string name="sim_action_enable_sub_dialog_title_without_carrier_name" msgid="4842051610633654278">"Activer la carte SIM?"</string>
    <string name="sim_action_switch_sub_dialog_title" msgid="9180969453358718635">"Passer à <xliff:g id="CARRIER_NAME">%1$s</xliff:g>?"</string>
    <string name="sim_action_switch_psim_dialog_title" msgid="5613177333235213024">"Passer à la carte SIM?"</string>
    <string name="sim_action_switch_sub_dialog_mep_title" msgid="933856847099933004">"Utiliser <xliff:g id="CARRIER_NAME">%1$s</xliff:g>?"</string>
    <string name="sim_action_switch_sub_dialog_text" msgid="2091834911153293004">"Une seule carte SIM peut être active à la fois.\n\nLe fait de passer au réseau de <xliff:g id="TO_CARRIER_NAME">%1$s</xliff:g> n\'annulera pas votre service auprès de <xliff:g id="FROM_CARRIER_NAME">%2$s</xliff:g>."</string>
    <string name="sim_action_switch_sub_dialog_text_downloaded" msgid="8977951796005849471">"Une seule carte eSIM peut être active.\n\nPasser à <xliff:g id="TO_CARRIER_NAME">%1$s</xliff:g> n\'annulera pas votre service <xliff:g id="FROM_CARRIER_NAME">%2$s</xliff:g>."</string>
    <string name="sim_action_switch_sub_dialog_text_single_sim" msgid="6188750682431170845">"Une seule carte SIM peut être active à la fois.\n\nLe fait de passer à un autre réseau n\'annulera pas votre service auprès de <xliff:g id="TO_CARRIER_NAME">%1$s</xliff:g>."</string>
    <string name="sim_action_switch_sub_dialog_mep_text" msgid="8348764755143679582">"Vous pouvez utiliser deux cartes SIM simultanément. Pour utiliser <xliff:g id="CARRIER_NAME">%1$s</xliff:g>, désactivez l\'autre SIM."</string>
    <string name="sim_action_switch_sub_dialog_confirm" msgid="1901181581944638961">"Passer à <xliff:g id="CARRIER_NAME">%1$s</xliff:g>"</string>
    <string name="sim_action_switch_sub_dialog_carrier_list_item_for_turning_off" msgid="5392037608705799522">"Désactiver <xliff:g id="CARRIER_NAME">%1$s</xliff:g>"</string>
    <string name="sim_action_switch_sub_dialog_info_outline_for_turning_off" msgid="1617619100229136888">"La désactivation d\'une carte SIM n\'annulera pas votre service"</string>
    <string name="sim_action_enabling_sim_without_carrier_name" msgid="2706862823501979981">"Connexion au réseau en cours…"</string>
    <string name="sim_action_switch_sub_dialog_progress" msgid="4718412054243793310">"Utilisez <xliff:g id="CARRIER_NAME">%1$s</xliff:g> pour traiter les appels et les messages…"</string>
    <string name="sim_action_enable_sim_fail_title" msgid="1765646238941015899">"Impossible de changer de fournisseur de services"</string>
    <string name="sim_action_enable_sim_fail_text" msgid="4781863235721417544">"Impossible de changer de fournisseur de services en raison d\'une erreur."</string>
    <string name="privileged_action_disable_sub_dialog_title" msgid="3298942357601334418">"Désactiver <xliff:g id="CARRIER_NAME">%1$s</xliff:g>?"</string>
    <string name="privileged_action_disable_sub_dialog_title_without_carrier" msgid="6518373229436331608">"Désactiver la carte SIM?"</string>
    <string name="privileged_action_disable_sub_dialog_progress" msgid="5900243067681478102">"Désactivation de la carte SIM en cours<xliff:g id="ELLIPSIS">…</xliff:g>"</string>
    <string name="privileged_action_disable_fail_title" msgid="6689494935697043555">"Impossible de désactiver le fournisseur de services"</string>
    <string name="privileged_action_disable_fail_text" msgid="8404023523406091819">"Une erreur s\'est produite et le fournisseur de services n\'a pas pu être désactivé."</string>
    <string name="sim_action_enable_dsds_title" msgid="226508711751577169">"Utiliser deux cartes SIM?"</string>
    <string name="sim_action_enable_dsds_text" msgid="970986559326263949">"Cet appareil prend en charge deux cartes SIM actives simultanément. Pour continuer d\'utiliser une seule carte SIM à la fois, touchez « Non merci »."</string>
    <string name="sim_action_restart_title" msgid="7054617569121993825">"Redémarrer l\'appareil?"</string>
    <string name="sim_action_yes" msgid="8076556020131395515">"Oui"</string>
    <string name="sim_action_reboot" msgid="3508948833333441538">"Redémarrer"</string>
    <string name="sim_action_no_thanks" msgid="435717748384544195">"Non merci"</string>
    <string name="sim_action_cancel" msgid="2668099867029610910">"Annuler"</string>
    <string name="sim_switch_button" msgid="1405772571706095387">"Changer"</string>
    <string name="dsds_activation_failure_title" msgid="4467364110584914794">"Impossible d\'activer la carte SIM"</string>
    <string name="dsds_activation_failure_body_msg2" msgid="73044349546544410">"Réessayer d\'activer la carte SIM. Si le problème persiste, redémarrez votre appareil."</string>
    <string name="sim_setup_channel_id" msgid="8797972565087458515">"Activation du réseau"</string>
    <string name="sim_switch_channel_id" msgid="4927038626791837861">"Changement de fournisseur de services en cours…"</string>
    <string name="post_dsds_reboot_notification_title_with_carrier" msgid="3308827462185135307">"<xliff:g id="CARRIER_NAME">%1$s</xliff:g> est actif"</string>
    <string name="post_dsds_reboot_notification_text" msgid="7533428378211541410">"Touchez l\'écran pour mettre à jour les paramètres de la carte SIM"</string>
    <string name="switch_to_removable_notification" msgid="7640342063449806296">"Vous êtes passé au réseau de <xliff:g id="CARRIER_NAME">%1$s</xliff:g>"</string>
    <string name="switch_to_removable_notification_no_carrier_name" msgid="7384856964036215338">"Vous êtes passé au réseau d\'un autre fournisseur de services"</string>
    <string name="network_changed_notification_text" msgid="2407908598496951243">"Votre réseau cellulaire a changé"</string>
    <string name="dsds_notification_after_suw_title" msgid="3738898232310273982">"Configurer votre autre carte SIM"</string>
    <string name="dsds_notification_after_suw_text" msgid="1287357774676361084">"Choisissez votre carte SIM active ou utilisez deux cartes à la fois"</string>
    <string name="choose_sim_title" msgid="4804689675237716286">"Choisissez un numéro à utiliser"</string>
    <string name="choose_sim_text" msgid="4356662002583501647">"{count,plural, =1{1 numéro est accessible sur cet appareil, mais 1 seul numéro peut être utilisé à la fois}=2{2 numéros sont accessibles sur cet appareil, mais 1 seul numéro peut être utilisé à la fois}one{# numéro est accessible sur cet appareil, mais 1 seul numéro peut être utilisé à la fois}other{# numéros sont accessibles sur cet appareil, mais 1 seul numéro peut être utilisé à la fois}}"</string>
    <string name="choose_sim_activating" msgid="9035902671985449448">"Activation en cours<xliff:g id="ELLIPSIS">…</xliff:g>"</string>
    <string name="choose_sim_could_not_activate" msgid="2154564459842291617">"Impossible d\'effectuer l\'activation pour le moment"</string>
    <string name="switch_sim_dialog_title" msgid="5407316878973237773">"Utiliser le réseau de <xliff:g id="CARRIER_NAME">%1$s</xliff:g>?"</string>
    <string name="switch_sim_dialog_text" msgid="7530186862171635464">"Le réseau de <xliff:g id="CARRIER_NAME">%1$s</xliff:g> sera utilisé pour les données cellulaires, les appels et les messages texte."</string>
    <string name="switch_sim_dialog_no_switch_title" msgid="809763410787744247">"Aucune carte SIM active n\'est accessible"</string>
    <string name="switch_sim_dialog_no_switch_text" msgid="7053939850026876088">"Pour utiliser les données cellulaires, les fonctionnalités d\'appels et les messages texte plus tard, accédez aux paramètres du réseau"</string>
    <string name="sim_card_label" msgid="6263064316075963775">"SIM"</string>
    <string name="erase_sim_dialog_title" msgid="4742077437653028326">"Effacer cette carte eSIM?"</string>
    <string name="erase_sim_dialog_text" msgid="753031064269699885">"Si vous effacez ce module SIM, le service de <xliff:g id="CARRIER_NAME_A">%1$s</xliff:g> sera retiré de cet appareil.\n\nLe service de <xliff:g id="CARRIER_NAME_B">%1$s</xliff:g> ne sera pas annulé."</string>
    <string name="erase_sim_confirm_button" msgid="8309115684335320541">"Effacer"</string>
    <string name="erasing_sim" msgid="7877703231075699139">"Effacement du module SIM en cours…"</string>
    <string name="erase_sim_fail_title" msgid="2024446702985862427">"Impossible d\'effacer le module SIM"</string>
    <string name="erase_sim_fail_text" msgid="7870804401227483131">"Ce module SIM ne peut pas être effacé en raison d\'une erreur.\n\nRedémarrez votre appareil et réessayez."</string>
    <string name="network_connection_request_dialog_title" msgid="1896186380874289434">"Se connecter à l’appareil"</string>
    <string name="network_connection_request_dialog_summary" msgid="7693038309792726170">"L\'application <xliff:g id="APPNAME">%1$s</xliff:g> souhaite utiliser un réseau Wi‑Fi temporaire pour se connecter à votre appareil"</string>
    <string name="network_connection_timeout_dialog_message" msgid="598509083077743772">"Aucun appareil trouvé. Assurez-vous que l\'appareil est allumé et prêt à se connecter."</string>
    <string name="network_connection_timeout_dialog_ok" msgid="6022675321823723755">"Réessayer"</string>
    <string name="network_connection_errorstate_dialog_message" msgid="3360714322047603239">"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="2587314077675642476">"Connexion réussie"</string>
    <string name="network_connection_connect_failure" msgid="6803313816657494319">"Échec de connexion"</string>
    <string name="network_connection_request_dialog_showall" msgid="6392059758456994944">"Tout afficher"</string>
    <string name="network_connection_searching_message" msgid="8521819623516926482">"Recherche d\'appareil en cours…"</string>
    <string name="network_connection_connecting_message" msgid="433189540877274889">"Connexion à l\'appareil en cours…"</string>
    <string name="bluetooth_left_name" msgid="7440064067910080502">"Gauche"</string>
    <string name="bluetooth_right_name" msgid="7588088072444124949">"Droite"</string>
    <string name="bluetooth_middle_name" msgid="3909371955137442319">"Étui"</string>
    <string name="settings_panel_title" msgid="346363079938069215">"Panneau Paramètres"</string>
    <string name="force_desktop_mode" msgid="1336913605091334238">"Forcer le mode bureau"</string>
    <string name="force_desktop_mode_summary" msgid="4587416867846930479">"Forcer le mode bureau expérimental sur les écrans secondaires"</string>
    <string name="enable_non_resizable_multi_window" msgid="6832903754625404477">"Activer éléments non redimensionnables en mode multi-fenêtre"</string>
    <string name="enable_non_resizable_multi_window_summary" msgid="3275763753261901999">"Activer les applications non redimensionnables en mode multi-fenêtre"</string>
    <string name="hwui_force_dark_title" msgid="4256904905631994219">"Forcer l\'activation de SmartDark"</string>
    <string name="hwui_force_dark_summary" msgid="6515748781487952769">"Forcer la fonctionnalité SmartDark à rester active"</string>
    <string name="privacy_dashboard_title" msgid="6845403825611829558">"Confidentialité"</string>
    <string name="privacy_dashboard_summary" msgid="5775090172422786808">"Autorisations, activité du compte, données personnelles"</string>
    <string name="privacy_controls_title" msgid="1383047169455206604">"Commandes"</string>
    <string name="contextual_card_dismiss_remove" msgid="8636557343011606722">"Supprimer"</string>
    <string name="contextual_card_dismiss_keep" msgid="440516181066490747">"Garder"</string>
    <string name="contextual_card_dismiss_confirm_message" msgid="6434344989238055188">"Supprimer cette suggestion?"</string>
    <string name="low_storage_summary" msgid="1979492757417779718">"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="7409408664417908922">"Envoyer des commentaires"</string>
    <string name="contextual_card_feedback_confirm_message" msgid="3186334562157665381">"Souhaitez-vous nous envoyer des commentaires sur cette suggestion?"</string>
    <string name="copyable_slice_toast" msgid="1008251852798990606">"<xliff:g id="COPY_CONTENT">%1$s</xliff:g> copié dans le presse-papiers"</string>
    <string name="search_bar_account_avatar_content_description" msgid="880523277036898350"></string>
    <string name="accessibility_usage_title" msgid="9190967143518779145">"Usage des fonctions d\'accessibilité"</string>
    <string name="accessibility_usage_summary" msgid="4348285359995227813">"{count,plural, =1{1 application dispose d\'un accès complet à votre appareil}one{# application dispose d\'un accès complet à votre appareil}other{# applications disposent d\'un accès complet à votre appareil}}"</string>
    <string name="wfc_disclaimer_title_text" msgid="4617195934203523503">"Renseignements importants"</string>
    <string name="wfc_disclaimer_agree_button_text" msgid="4082872292910770344">"CONTINUER"</string>
    <string name="wfc_disclaimer_disagree_text" msgid="8424457394700137703">"NON MERCI"</string>
    <string name="wfc_disclaimer_location_title_text" msgid="7913919887475418423">"Lieu"</string>
    <string name="wfc_disclaimer_location_desc_text" msgid="1417004513415772582">"Votre fournisseur de services peut collecter les données relatives à votre position lorsque vous utilisez ce service en lien avec les appels d\'urgence.\n\nConsultez la politique de confidentialité de votre fournisseur de services pour obtenir plus de détails."</string>
    <string name="forget_passpoint_dialog_message" msgid="2433875063907365760">"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="content_capture" msgid="868372905432812238">"Contenu de l\'application"</string>
    <string name="content_capture_summary" msgid="49720773699715531">"Autoriser les applications à envoyer du contenu au système Android"</string>
    <string name="capture_system_heap_dump_title" msgid="9210974110606886455">"Capturer l\'empreinte de mémoire système"</string>
    <string name="development_memtag_page_title" msgid="3546667618748029188">"Memory Tagging Extension"</string>
    <string name="development_memtag_intro" msgid="8032596625527637164">"L\'extension MTE (Memory Tagging Extension) facilite la détection des problèmes de sécurité de la mémoire dans votre application et rend plus sécuritaire son code natif."</string>
    <string name="development_memtag_footer" msgid="5681925148773626562">"L\'activation de l\'extension MTE peut entraîner un ralentissement des performances de l\'appareil."</string>
    <string name="development_memtag_learn_more" msgid="8961984806973926704">"En savoir plus sur l\'extension MTE"</string>
    <string name="development_memtag_toggle" msgid="2474420239518386894">"Activer l\'extension MTE jusqu\'à ce que vous la désactiviez"</string>
    <string name="development_memtag_reboot_message_on" msgid="8100075676107327847">"Vous devrez redémarrer votre appareil pour activer l\'extension MTE."</string>
    <string name="development_memtag_reboot_message_off" msgid="3703925647922079456">"Vous devrez redémarrer votre appareil pour désactiver l\'extension MTE."</string>
    <string name="reboot_with_mte_title" msgid="2320125810211279">"Activer l\'extension MTE pour une seule session"</string>
    <string name="reboot_with_mte_message" msgid="1232881567956207641">"Le système va redémarrer et vous permettra d\'expérimenter l\'extension MTE (Memory Tagging Extension). L\'extension MTE peut nuire aux performances et à la stabilité du système. Ce paramètre sera réinitialisé lors du prochain redémarrage."</string>
    <string name="reboot_with_mte_summary" msgid="3896537791216432882">"Redémarrez l\'appareil pour une seule session avec l\'extension MTE activée"</string>
    <string name="reboot_with_mte_already_enabled" msgid="4439168867613407167">"L\'extension MTE est déjà activée"</string>
    <string name="capturing_system_heap_dump_message" msgid="8410503247477360622">"Capture de l\'empreinte de mémoire système en cours…"</string>
    <string name="error_capturing_system_heap_dump_message" msgid="2352983250048200052">"Impossible de capturer l\'empreinte de mémoire du système"</string>
    <string name="automatic_system_heap_dump_title" msgid="4093306504711109479">"Capturer automatiquement les empreintes de mémoire système"</string>
    <string name="automatic_system_heap_dump_summary" msgid="4060846186592886986">"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="5698154296678571998">"Déconnecter"</string>
    <string name="wfc_disclaimer_emergency_limitation_title_text" msgid="8276287227589397162">"Appels d\'urgence"</string>
    <string name="wfc_disclaimer_emergency_limitation_desc_text" msgid="5503902001191552196">"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="8566648389959032967">"Utiliser le Wi‑Fi pour les appels afin d\'améliorer la qualité"</string>
    <string name="backup_calling_settings_title" msgid="519714752900364326">"Méthode d\'appel secondaire"</string>
    <string name="backup_calling_setting_summary" msgid="599493254305348733">"Si <xliff:g id="BACKUP_CALLING_OPERATOR_TEXT">%1$s</xliff:g> n\'est pas accessible ou si vous êtes en itinérance, servez-vous de votre carte SIM de données cellulaires pour faire et recevoir des appels avec <xliff:g id="BACKUP_CALLING_CARRIER_TEXT">%1$s</xliff:g>."</string>
    <string name="keywords_backup_calling" msgid="8592800915478816800">"méthode d\'appel secondaire"</string>
    <string name="enable_receiving_mms_notification_title" msgid="6465218559386990248">"Message multimédia entrant"</string>
    <string name="enable_sending_mms_notification_title" msgid="7120641300854953375">"Impossible d\'envoyer le message multimédia"</string>
    <string name="enable_mms_notification_summary" msgid="6432752438276672500">"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="1798206332620642108">"Message multimédia"</string>
    <string name="sim_combination_warning_notification_title" msgid="1365401631492986487">"Problème avec la combinaison de cartes SIM"</string>
    <string name="dual_cdma_sim_warning_notification_summary" msgid="2826474790710586487">"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="1049161096896074364">"Combinaison de cartes SIM"</string>
    <string name="work_policy_privacy_settings" msgid="2702644843505242596">"Les détails de votre politique professionnelle"</string>
    <string name="work_policy_privacy_settings_summary" msgid="690118670737638405">"Les paramètres sont gérés par votre administrateur informatique"</string>
    <string name="track_frame_time_keywords" msgid="7885340257945922239">"Processeur graphique"</string>
    <string name="bug_report_handler_title" msgid="713439959113250125">"Gestionnaire de rapport de bogue"</string>
    <string name="bug_report_handler_picker_footer_text" msgid="4935758328366585673">"Détermine quelle application gère le raccourci de rapport de bogue sur votre appareil."</string>
    <string name="personal_profile_app_subtext" msgid="5586060806997067676">"Personnel"</string>
    <string name="work_profile_app_subtext" msgid="5043419461440127879">"Travail"</string>
    <string name="system_default_app_subtext" msgid="5212055189703164839">"Paramètres par défaut"</string>
    <string name="default_app_none" msgid="5420632042222036264">"Aucune"</string>
    <string name="select_invalid_bug_report_handler_toast_text" msgid="8857326334015386692">"Ce choix n\'est plus valide. Réessayez."</string>
    <string name="power_menu_setting_name" msgid="2394440932633137229">"Maintenir l\'interrupteur enfoncé"</string>
    <string name="power_menu_long_press_category_title" msgid="1051146091093775002">"Maintenir l\'interrupteur enfoncé pour accéder au menu"</string>
    <string name="power_menu_long_press_for_power_menu_title" msgid="477584639843663599">"Menu de l\'interrupteur"</string>
    <string name="power_menu_long_press_for_assistant_title" msgid="6557738348262616455">"Assistant numérique"</string>
    <string name="power_menu_summary_long_press_for_assistant" msgid="32706459458422952">"Accéder à l\'assistant numérique"</string>
    <string name="power_menu_summary_long_press_for_power_menu" msgid="7617247135239683710">"Accédez au menu de l\'interrupteur"</string>
    <string name="lockscreen_privacy_not_secure" msgid="3251276389681975912">"Pour l\'utiliser, définissez d\'abord un écran de verrouillage"</string>
    <string name="power_menu_power_volume_up_hint" msgid="5619917593676125759">"Menu de l\'interrupteur :\nAppuyez simultanément sur l\'interrupteur et sur le bouton d\'augmentation du volume"</string>
    <string name="power_menu_power_prevent_ringing_hint" msgid="1169955014711158873">"Désactiver la sonnerie :\nAppuyez sur un bouton de volume pour le raccourci"</string>
    <string name="power_menu_long_press_for_assist_sensitivity_title" msgid="1626808509158422185">"Durée de maintien du doigt"</string>
    <string name="power_menu_long_press_for_assist_sensitivity_summary" msgid="7550610071666801935">"Réglez la sensibilité en choisissant la durée de maintien du doigt sur l\'interrupteur"</string>
    <string name="power_menu_long_press_for_assist_sensitivity_low_label" msgid="3430099983480845635">"Courte"</string>
    <string name="power_menu_long_press_for_assist_sensitivity_high_label" msgid="2059686170350829156">"Longue"</string>
    <string name="lockscreen_privacy_wallet_setting_toggle" msgid="4188327143734192000">"Afficher le portefeuille"</string>
    <string name="lockscreen_privacy_wallet_summary" msgid="3984851951621168573">"Autoriser l\'accès au portefeuille à partir de l\'écran de verrouillage"</string>
    <string name="lockscreen_privacy_qr_code_scanner_setting_toggle" msgid="1856477548806618829">"Afficher le lecteur de code QR"</string>
    <string name="lockscreen_privacy_qr_code_scanner_summary" msgid="4577409244972250235">"Autorisez l\'accès au lecteur de code QR à partir de l\'écran verrouillé"</string>
    <string name="lockscreen_privacy_controls_setting_toggle" msgid="7445725343949588613">"Afficher les commandes des appareils"</string>
    <string name="lockscreen_privacy_controls_summary" msgid="2769166101644452893">"Affichez les commandes des appareils externes à partir de l\'écran de verrouillage"</string>
    <string name="lockscreen_trivial_controls_setting_toggle" msgid="8211063535536295676">"Contrôler à partir d\'un appareil verrouillé"</string>
    <string name="lockscreen_trivial_controls_summary" msgid="680581904143387225">"Contrôlez les appareils externes sans déverrouiller votre téléphone ou votre tablette si l\'application de commandes de ces derniers l\'autorise"</string>
    <string name="lockscreen_trivial_disabled_controls_summary" msgid="7593626010580689155">"Pour les utiliser, activez d\'abord « Afficher les commandes de l\'appareil »"</string>
    <string name="lockscreen_double_line_clock_summary" msgid="2916159550425093703">"Afficher l\'horloge à double ligne lorsqu\'elle est accessible"</string>
    <string name="lockscreen_double_line_clock_setting_toggle" msgid="3408639316001688529">"Horloge à double ligne"</string>
    <string name="lockscreen_quick_affordances_title" msgid="8615741551327565793">"Raccourcis"</string>
    <plurals name="lockscreen_quick_affordances_summary" formatted="false" msgid="4225396036524703997">
      <item quantity="one"><xliff:g id="FIRST_1">%1$s</xliff:g>, <xliff:g id="SECOND">%2$s</xliff:g></item>
      <item quantity="other"><xliff:g id="FIRST_1">%1$s</xliff:g>, <xliff:g id="SECOND">%2$s</xliff:g></item>
    </plurals>
    <string name="rtt_settings_title" msgid="7049259598645966354"></string>
    <string name="rtt_settings_no_visible" msgid="7440356831140948382"></string>
    <string name="rtt_settings_visible_during_call" msgid="7866181103286073700"></string>
    <string name="rtt_settings_always_visible" msgid="2364173070088756238"></string>
    <string name="volte_5G_limited_title" msgid="5908052268836750629">"Désactiver la connexion VoLTE?"</string>
    <string name="volte_5G_limited_text" msgid="7150583768725182345">"Cela désactive aussi votre connexion 5G.\nDurant un appel vocal, vous ne pourrez pas utiliser la connexion Internet et certaines applications pourraient ne pas fonctionner."</string>
    <string name="cached_apps_freezer" msgid="1057519579761550350">"Suspendre l\'exécution pour les applications en cache"</string>
    <string name="blob_never_expires_text" msgid="7293376386620106623">"N\'expire jamais."</string>
    <string name="accessor_never_expires_text" msgid="4647624492147788340">"Le bail n\'expire jamais."</string>
    <string name="overlay_settings_title" msgid="1032863083496396365">"Autoriser les superpos. d\'écran pour les paramètres"</string>
    <string name="overlay_settings_summary" msgid="2745336273786148166">"Autorisez les applications qui peuvent se superposer à d\'autres à afficher du contenu par-dessus les écrans des paramètres"</string>
    <string name="allow_mock_modem" msgid="3832264806530479214">"Autoriser le service de modem simulé"</string>
    <string name="allow_mock_modem_summary" msgid="9097416612748005374">"Autorisez cet appareil à exécuter le service de modem simulé pour les tests d\'instrumentation; ne l\'activez pas pendant l\'utilisation normale du téléphone"</string>
    <string name="media_controls_title" msgid="403271085636252597">"Commandes multimédias"</string>
    <string name="media_controls_resume_title" msgid="855076860336652370">"Épingler le lecteur multimédia"</string>
    <string name="media_controls_resume_description" msgid="3163482266454802097">"Pour que vous puissiez reprendre rapidement la lecture, le lecteur multimédia reste ouvert dans Paramètres rapides"</string>
    <string name="media_controls_lockscreen_title" msgid="2188311721857512510">"Afficher le contenu multimédia sur l\'écran de verrouillage"</string>
    <string name="media_controls_lockscreen_description" msgid="3320333660404439510">"Pour que vous puissiez reprendre rapidement la lecture, le lecteur multimédia reste ouvert sur l\'écran de verrouillage"</string>
    <string name="media_controls_recommendations_title" msgid="184225835236807677">"Afficher les recommandations relatives aux contenus multimédias"</string>
    <string name="media_controls_recommendations_description" msgid="7596498733126824030">"En fonction de votre activité"</string>
    <string name="media_controls_hide_player" msgid="2751439192580884015">"Masquer le lecteur"</string>
    <string name="media_controls_show_player" msgid="8504571042365814021">"Afficher le lecteur"</string>
    <string name="keywords_media_controls" msgid="8345490568291778638">"commandes multimédias"</string>
    <string name="connected_device_see_all_summary" msgid="2056010318537268108">"Le Bluetooth sera activé"</string>
    <string name="provider_internet_settings" msgid="3831259474776313323">"Internet"</string>
    <string name="provider_network_settings_title" msgid="2624756136016346774">"Cartes SIM"</string>
    <string name="calls_and_sms" msgid="1931855083959003306">"Appels et messages texte"</string>
    <string name="calls_and_sms_category" msgid="3788238090898237767">"Appels Wi‑Fi"</string>
    <string name="calls_sms_wfc_summary" msgid="3940529919408667336">"Faire et recevoir des appels sur réseau Wi‑Fi"</string>
    <string name="calls_preference_title" msgid="7536882032182563800">"Appels"</string>
    <string name="sms_preference_title" msgid="8392745501754864395">"Messages texte"</string>
    <string name="calls_sms_preferred" msgid="6016477652522583496">"préféré"</string>
    <string name="calls_sms_calls_preferred" msgid="9004261125829377885">"carte SIM préférée pour les appels"</string>
    <string name="calls_sms_sms_preferred" msgid="3855778890660922711">"carte SIM préférée pour les messages texte"</string>
    <string name="calls_sms_unavailable" msgid="4055729705246556529">"non disponible"</string>
    <string name="calls_sms_temp_unavailable" msgid="8602291749338757424">"Momentanément inaccessible"</string>
    <string name="calls_sms_no_sim" msgid="2336377399761819718">"Aucune carte SIM"</string>
    <string name="network_and_internet_preferences_title" msgid="8635896466814033405">"Préférences réseau"</string>
    <string name="keywords_internet" msgid="7674082764898690310">"connexion réseau, internet, sans fil, données, wifi, wi-fi, wi fi, cellulaire, mobile, fournisseur cellulaire, 4g, 3g, 2g, lte"</string>
    <string name="reset_your_internet_title" msgid="4856899004343241310">"Réinitialiser votre connexion Internet?"</string>
    <string name="resetting_internet_text" msgid="6696779371800051806">"Réinitialisation de votre connexion Internet en cours…"</string>
    <string name="fix_connectivity" msgid="2781433603228089501">"Dépanner la connectivité"</string>
    <string name="networks_available" msgid="3299512933684383474">"Réseaux accessibles"</string>
    <string name="to_switch_networks_disconnect_ethernet" msgid="6615374552827587197">"Pour changer de réseau, débranchez le câble Ethernet"</string>
    <string name="carrier_wifi_offload_title" msgid="7263365988016247722">"Connexions W+"</string>
    <string name="carrier_wifi_offload_summary" msgid="2980563718888371142">"Autoriser Google Fi à utiliser les réseaux W+ afin d\'améliorer la vitesse et la couverture"</string>
    <string name="carrier_wifi_network_title" msgid="5461382943873831770">"Réseau W+"</string>
    <string name="sim_category_title" msgid="2341314000964710495">"SIM"</string>
    <string name="downloaded_sim_category_title" msgid="2876988650413179752">"Carte eSIM"</string>
    <string name="downloaded_sims_category_title" msgid="487799905978489922">"Cartes eSIM"</string>
    <string name="sim_category_active_sim" msgid="1503823567818544012">"Active"</string>
    <string name="sim_category_inactive_sim" msgid="4068899490133820881">"Inactive"</string>
    <string name="sim_category_default_active_sim" msgid="1208194173387987231">" / Configuration par défaut pour <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="default_active_sim_calls" msgid="2390973682556353558">"appels"</string>
    <string name="default_active_sim_sms" msgid="8041498593025994921">"messages texte"</string>
    <string name="default_active_sim_mobile_data" msgid="6798083892814045301">"données cellulaires"</string>
    <string name="wifi_scan_notify_message" msgid="1331238142061476869">"Pour améliorer l\'expérience d\'utilisation de l\'appareil, les applications et les services peuvent continuer de rechercher les réseaux Wi-Fi en tout temps, même si le Wi-FI est désactivé. Cette autorisation peut permettre, par exemple, d\'améliorer les fonctionnalités et les services reposant sur la localisation. Vous pouvez modifier vos préférences dans les paramètres de recherche de réseaux Wi-Fi."</string>
    <string name="wifi_scan_change" msgid="8438320311511852918">"Changer"</string>
    <string name="preference_summary_default_combination" msgid="4643585915107796253">"<xliff:g id="STATE">%1$s</xliff:g> : <xliff:g id="NETWORKMODE">%2$s</xliff:g>"</string>
    <string name="mobile_data_connection_active" msgid="2422223108911581552">"Connexion active"</string>
    <string name="mobile_data_temp_connection_active" msgid="3430470299756236413">"Connectée temporairement"</string>
    <string name="mobile_data_temp_using" msgid="5211002380149434155">"Utilise temporairement <xliff:g id="SUBNAME">%1$s</xliff:g>"</string>
    <string name="mobile_data_no_connection" msgid="905897142426974030">"Aucune connexion"</string>
    <string name="mobile_data_off_summary" msgid="1884248776904165539">"Aucune connexion auto. des données cellulaires"</string>
    <string name="mobile_data_disable_title" msgid="8438714772256088913">"Désactiver les données cellulaires?"</string>
    <string name="mobile_data_disable_message" msgid="7829414836454769970">"Vous n\'aurez pas accès aux données ni à Internet avec <xliff:g id="CARRIER">%s</xliff:g>. Vous ne pourrez accéder à Internet que par Wi-Fi."</string>
    <string name="mobile_data_disable_message_default_carrier" msgid="4449469407705838612">"votre fournisseur de services"</string>
    <string name="not_allowed_by_ent" msgid="1958611623122304411">"Non autorisé par votre organisation"</string>
    <string name="aware_summary_when_bedtime_on" msgid="2063856008597376344">"Cette fonctionnalité n\'est pas accessible parce que le mode Nuit est activé"</string>
    <string name="reset_importance_completed" msgid="3595536767426097205">"L\'importance de la notification a bien été réinitialisée."</string>
    <string name="apps_dashboard_title" msgid="3269953499954393706">"Applications"</string>
    <string name="bluetooth_message_access_notification_content" msgid="5111712860712823893">"Un appareil souhaite accéder à vos messages. Touchez l\'écran pour en savoir plus."</string>
    <string name="bluetooth_message_access_dialog_title" msgid="9009836130395061579">"Autoriser l\'accès aux messages?"</string>
    <string name="bluetooth_message_access_dialog_content" msgid="7186694737578788487">"Un appareil Bluetooth, <xliff:g id="DEVICE_NAME_0">%1$s</xliff:g>, souhaite accéder à vos messages.\n\nVous ne vous êtes jamais connecté à <xliff:g id="DEVICE_NAME_1">%2$s</xliff:g> auparavant."</string>
    <string name="bluetooth_phonebook_access_notification_content" msgid="9175220052703433637">"Un appareil veut accéder à vos contacts et à votre journal d\'appels. Touchez l\'écran pour en savoir plus."</string>
    <string name="bluetooth_phonebook_access_dialog_title" msgid="7624607995928968721">"Autoriser l\'accès aux contacts et au journal d\'appels?"</string>
    <string name="bluetooth_phonebook_access_dialog_content" msgid="959658135522249170">"Un appareil Bluetooth, <xliff:g id="DEVICE_NAME_0">%1$s</xliff:g>, souhaite accéder à vos contacts et à votre journal d\'appels. Cela comprend des données à propos des appels entrants et sortants.\n\nVous ne vous êtes jamais connecté à <xliff:g id="DEVICE_NAME_1">%2$s</xliff:g> auparavant."</string>
    <string name="category_name_brightness" msgid="8520372392029305084">"Luminosité"</string>
    <string name="category_name_lock_display" msgid="8310402558217129670">"Affichage de l\'écran de verrouillage"</string>
    <string name="category_name_appearance" msgid="8287486771764166805">"Apparence"</string>
    <string name="category_name_color" msgid="937514550918977151">"Couleur"</string>
    <string name="category_name_display_controls" msgid="7046581691184725216">"Autres paramètres d\'affichage"</string>
    <string name="category_name_general" msgid="7737273712848115886">"Général"</string>
    <string name="dark_theme_main_switch_title" msgid="4045147031947562280">"Utiliser le thème sombre"</string>
    <string name="bluetooth_main_switch_title" msgid="8409835540311309632">"Utiliser le Bluetooth"</string>
    <string name="prevent_ringing_main_switch_title" msgid="4726252811262086643">"Utiliser le blocage de la sonnerie"</string>
    <string name="use_wifi_hotsopt_main_switch_title" msgid="3909731167290690539">"Utiliser le point d\'accès Wi-Fi"</string>
    <string name="app_pinning_main_switch_title" msgid="5465506660064032876">"Utiliser l\'épinglage d\'application"</string>
    <string name="developer_options_main_switch_title" msgid="1720074589554152501">"Utiliser les options pour les développeurs"</string>
    <string name="default_print_service_main_switch_title" msgid="4697133737128324036">"Utiliser le service d\'impression"</string>
    <string name="multiple_users_main_switch_title" msgid="6686858308083037810">"Autoriser plusieurs utilisateurs"</string>
    <string name="multiple_users_main_switch_keywords" msgid="4845954458094134356">"autoriser, plusieurs, utilisateur, permettre, beaucoup"</string>
    <string name="wireless_debugging_main_switch_title" msgid="8463499572781441719">"Utiliser le débogage sans fil"</string>
    <string name="graphics_driver_main_switch_title" msgid="6125172901855813790">"Utiliser les préférences du pilote graphique"</string>
    <string name="night_light_main_switch_title" msgid="3428298022467805219">"Utiliser le mode Éclairage nocturne"</string>
    <string name="nfc_main_switch_title" msgid="6295839988954817432">"Utiliser la technologie CCP"</string>
    <string name="adaptive_brightness_main_switch_title" msgid="2681666805191642737">"Utiliser la luminosité adaptative"</string>
    <string name="wifi_calling_main_switch_title" msgid="4070224008346815634">"Utiliser les appels Wi-Fi"</string>
    <string name="default_see_all_apps_title" msgid="7481113230662612178">"Afficher toutes les applications"</string>
    <string name="smart_forwarding_title" msgid="8368634861971949799">"Transfert d\'appels intelligent"</string>
    <string name="smart_forwarding_summary_enabled" msgid="3341062878373185604">"Le transfert d\'appels intelligent est activé"</string>
    <string name="smart_forwarding_summary_disabled" msgid="5033880700091914809">"Le transfert d\'appels intelligent est désactivé"</string>
    <string name="smart_forwarding_ongoing_title" msgid="962226849074401228">"Paramètres d\'appel"</string>
    <string name="smart_forwarding_ongoing_text" msgid="2189209372407117114">"Mise à jour des paramètres en cours…"</string>
    <string name="smart_forwarding_failed_title" msgid="1859891191023516080">"Erreur des paramètres d\'appel"</string>
    <string name="smart_forwarding_failed_text" msgid="8682640643264071789">"Erreur de réseau ou de carte SIM."</string>
    <string name="smart_forwarding_failed_not_activated_text" msgid="997396203001257904">"La carte SIM n\'est pas activée."</string>
    <string name="smart_forwarding_input_mdn_title" msgid="5105463748849841763">"Entrer les numéros de téléphone"</string>
    <string name="smart_forwarding_input_mdn_dialog_title" msgid="7542216086697868415">"Entrer le numéro de téléphone"</string>
    <string name="smart_forwarding_missing_mdn_text" msgid="2907314684242542226">"Le numéro de téléphone est manquant."</string>
    <string name="smart_forwarding_missing_alert_dialog_text" msgid="7870419247987316112">"OK"</string>
    <string name="enable_2g_title" msgid="8184757884636162942">"Autoriser les réseaux 2G"</string>
    <string name="enable_2g_summary" msgid="2794534052372565914">"La 2G est moins sécurisée, mais elle peut améliorer votre connexion à certains endroits. La 2G est toujours autorisée pour effectuer des appels d\'urgence."</string>
    <string name="enable_2g_summary_disabled_carrier" msgid="8141118453219482762">"<xliff:g id="CARRIER_NAME_2G">%1$s</xliff:g> requiert que la 2G soit activée"</string>
    <string name="require_cellular_encryption_title" msgid="7516008146269371585">"Exiger le chiffrement"</string>
    <string name="require_cellular_encryption_summary" msgid="4813823321032908641">"Le chiffrement est plus sécurisé, mais il se peut que vous ne puissiez pas vous connecter dans certains endroits. Pour les appels d\'urgence, le chiffrement n\'est jamais requis."</string>
    <string name="app_info_all_services_label" msgid="1487070364839071105">"Tous les services"</string>
    <string name="show_clip_access_notification" msgid="7782300987639778542">"Afficher l\'accès au presse-papiers"</string>
    <string name="show_clip_access_notification_summary" msgid="474090757777203207">"Afficher un message lorsque les applications accèdent à du texte, à des images ou à d\'autres contenus que vous avez copiés"</string>
    <string name="all_apps" msgid="3054120149509114789">"Toutes les applications"</string>
    <string name="request_manage_bluetooth_permission_dont_allow" msgid="8798061333407581300">"Ne pas autoriser"</string>
    <string name="uwb_settings_title" msgid="8578498712312002231">"Bande ultralarge (BUL)"</string>
    <string name="uwb_settings_summary" msgid="3074271396764672268">"Aide à déterminer la position relative des appareils à proximité qui utilisent la connectivité à bande ultralarge"</string>
    <string name="uwb_settings_summary_airplane_mode" msgid="1328864888135086484">"Désactivez le mode Avion pour utiliser la connectivité à bande ultralarge"</string>
    <string name="camera_toggle_title" msgid="8952668677727244992">"Accès à l\'appareil photo"</string>
    <string name="mic_toggle_title" msgid="265145278323852547">"Accès au microphone"</string>
    <string name="perm_toggle_description" msgid="5754629581767319022">"Pour les applications et les services"</string>
    <string name="mic_toggle_description" msgid="484139688645092237">"Pour les applications et les services. Si ce paramètre est désactivé, il est possible que les données du microphone soient partagées lorsque vous appelez un numéro d\'urgence."</string>
    <string name="previous_page_content_description" msgid="6438292457923282991">"Précédent"</string>
    <string name="next_page_content_description" msgid="1641835099813416294">"Suivant"</string>
    <string name="colors_viewpager_content_description" msgid="2591751086138259565">"Aperçu de la couleur"</string>
    <string name="bluetooth_sim_card_access_notification_title" msgid="7351015416346359536">"Demande d\'accès à la carte SIM"</string>
    <string name="bluetooth_sim_card_access_notification_content" msgid="8685623260103018309">"Un appareil souhaite accéder à votre carte SIM. Touchez pour en savoir plus."</string>
    <string name="bluetooth_sim_card_access_dialog_title" msgid="5616323725563125179">"Autoriser l\'accès à la carte SIM?"</string>
    <string name="bluetooth_sim_card_access_dialog_content" msgid="6281997628405909566">"Un appareil Bluetooth, <xliff:g id="DEVICE_NAME_0">%1$s</xliff:g>, souhaite accéder à vos données par l\'intermédiaire de votre carte SIM. Parmi celles-ci figurent vos contacts.\n\nPendant qu\'il est connecté, l\'appareil <xliff:g id="DEVICE_NAME_1">%2$s</xliff:g> recevra tous les appels passés au numéro <xliff:g id="PHONE_NUMBER">%3$s</xliff:g>."</string>
    <string name="bluetooth_connect_access_notification_title" msgid="2573547043170883947">"Appareil Bluetooth accessible"</string>
    <string name="bluetooth_connect_access_notification_content" msgid="1328465545685433304">"Un appareil veut se connecter. Touchez l\'écran pour en savoir plus."</string>
    <string name="bluetooth_connect_access_dialog_title" msgid="1948056782712451381">"Se connecter à un appareil Bluetooth?"</string>
    <string name="bluetooth_connect_access_dialog_content" msgid="4336436466468405850">"<xliff:g id="DEVICE_NAME_0">%1$s</xliff:g> veut se connecter à ce téléphone.\n\nVous ne vous êtes jamais connecté à <xliff:g id="DEVICE_NAME_1">%2$s</xliff:g> auparavant."</string>
    <string name="bluetooth_connect_access_dialog_negative" msgid="4944672755226375059">"Ne pas se connecter"</string>
    <string name="bluetooth_connect_access_dialog_positive" msgid="3630561675207269710">"Se connecter"</string>
    <string name="tare_settings" msgid="3788654800004869077">"Paramètres TARE"</string>
    <string name="tare_on" msgid="2386073225978684535">"Activée"</string>
    <string name="tare_off" msgid="6305694402929756726">"Désactivée"</string>
    <string name="tare_revert" msgid="3855325741125236638">"Rétablir les paramètres par défaut"</string>
    <string name="tare_settings_reverted_toast" msgid="8189887409285176731">"Les paramètres rétablis par défaut."</string>
    <string name="tare_max_satiated_balance" msgid="3914973999573150340">"Solde maximal lors de la charge complète"</string>
    <string name="tare_balances" msgid="731881382594747961">"Soldes"</string>
    <string name="tare_consumption_limits" msgid="3230949387874396382">"Limites de consommation"</string>
    <string name="tare_initial_consumption_limit" msgid="2921646306374048384">"Limite de consommation initiale"</string>
    <string name="tare_min_consumption_limit" msgid="3293145670921755789">"Limite de consommation minimale"</string>
    <string name="tare_max_consumption_limit" msgid="8335700580111808823">"Limite de consommation maximale"</string>
    <string name="tare_modifiers" msgid="8919975635360280820">"Modificateurs"</string>
    <string name="tare_actions_ctp" msgid="5110104015354916401">"Actions (coût de production)"</string>
    <string name="tare_actions_base_price" msgid="3300967942666376589">"Actions (prix de base)"</string>
    <string name="tare_rewards_instantaneous" msgid="8358683519945340874">"Récompenses par événement individuel"</string>
    <string name="tare_rewards_ongoing" msgid="7657030286658143416">"Récomp. par seconde de durée de l\'évén."</string>
    <string name="tare_rewards_max" msgid="5283055625642837010">"Maximum de récompenses par jour"</string>
    <string name="tare_app_install" msgid="7955806910408116882">"Installation d\'applications"</string>
    <string name="tare_top_activity" msgid="7266560655483385757">"Activité principale"</string>
    <string name="tare_notification_seen" msgid="7829963536020087742">"Notification vue"</string>
    <string name="tare_notification_seen_15_min" msgid="832174185809497764">"Notification vue dans les 15 minutes"</string>
    <string name="tare_notification_interaction" msgid="3806204222322830129">"Interaction avec la notification"</string>
    <string name="tare_widget_interaction" msgid="2260701564089214184">"Interactions avec le widget"</string>
    <string name="tare_other_interaction" msgid="8069163421115212751">"Autre interaction avec l\'utilisateur"</string>
    <string name="tare_job_max_start" msgid="1586399578665940836">"Démarrage de tâche à priorité maximale"</string>
    <string name="tare_job_max_running" msgid="2897217372986518495">"Tâche à priorité maximale en cours…"</string>
    <string name="tare_job_high_start" msgid="7464143754932031022">"Démarrage de la tâche à priorité élevée"</string>
    <string name="tare_job_high_running" msgid="6541171046405088669">"Tâche à priorité élevée en cours…"</string>
    <string name="tare_job_default_start" msgid="6744427210148953151">"Démarrage de la tâche par défaut"</string>
    <string name="tare_job_default_running" msgid="8429081804128945217">"Tâche par défaut en cours…"</string>
    <string name="tare_job_low_start" msgid="4605440035856891746">"Démarrage de la tâche à priorité faible"</string>
    <string name="tare_job_low_running" msgid="831668616902849604">"Tâche à priorité faible en cours…"</string>
    <string name="tare_job_min_start" msgid="6508233901992538188">"Démarrage de tâche à priorité minimale"</string>
    <string name="tare_job_min_running" msgid="6167128996320622604">"Tâche à priorité minimale en cours…"</string>
    <string name="tare_job_timeout_penalty" msgid="7644332836795492506">"Pénalité expiration du délai de la tâche"</string>
    <string name="tare_min_balance_exempted" msgid="6693710075762973485">"Solde minimal avec une charge complète (exemptée)"</string>
    <string name="tare_min_balance_headless_app" msgid="6906353766678577244">"Solde minimal avec une charge complète (application système sans interface)"</string>
    <string name="tare_min_balance_other_app" msgid="3404774196832506476">"Solde minimal avec une charge complète (applications restantes)"</string>
    <string name="tare_min_balance_addition_app_updater" msgid="5391956072471201269">"Ajout de solde minimal avec une charge complète (outil de mise à jour de l\'application)"</string>
  <string-array name="tare_modifiers_subfactors">
    <item msgid="3325940509857535498">"Recharge"</item>
    <item msgid="658627268149681677">"Sieste"</item>
    <item msgid="1599558140284643834">"Mode Économie d\'énergie"</item>
    <item msgid="588427840913221601">"État du traitement"</item>
  </string-array>
    <string name="tare_dialog_confirm_button_title" msgid="9179397559760203348">"Confirmer"</string>
    <string name="dream_preview_button_title" msgid="6637456541851795952">"Aperçu"</string>
    <string name="dream_picker_category" msgid="7726447836872744867">"Choisir un écran de veille"</string>
    <string name="dream_complications_toggle_title" msgid="4273232303027449163">"Afficher d\'autres informations"</string>
    <string name="dream_complications_toggle_summary" msgid="8088911054987524904">"Afficher l\'heure, la météo ou d\'autres renseignements sur l\'écran de veille"</string>
    <string name="dream_home_controls_toggle_title" msgid="706799741564479248">"Afficher la domotique"</string>
    <string name="dream_home_controls_toggle_summary" msgid="4102519907917430579">"Affichez le bouton domotique sur l\'écran de veille"</string>
    <string name="dream_more_settings_category" msgid="3119192146760773748">"Plus de paramètres"</string>
    <string name="dream_setup_title" msgid="2458303874255396142">"Choisir votre écran de veille"</string>
    <string name="dream_setup_description" msgid="7508547154038580296">"Choisissez ce que vous voyez à l\'écran lorsque votre tablette est ancrée. Votre appareil peut consommer plus d\'énergie lorsqu\'un écran de veille est utilisé."</string>
    <string name="customize_button_title" msgid="1110284655990203359">"Personnaliser"</string>
    <string name="customize_button_description" msgid="7440248477266126231">"Personnaliser <xliff:g id="SCREENSAVER_NAME">%1$s</xliff:g>"</string>
    <string name="reboot_dialog_enable_freeform_support" msgid="6412591361284929149">"Vous devez redémarrer l\'appareil pour activer la prise en charge des fenêtres de forme libre."</string>
    <string name="reboot_dialog_force_desktop_mode" msgid="2021839270403432948">"Vous devez redémarrer l\'appareil pour forcer le mode Bureau sur des écrans secondaires."</string>
    <string name="reboot_dialog_reboot_now" msgid="235616015988522355">"Redémarrer maintenant"</string>
    <string name="reboot_dialog_reboot_later" msgid="4261717094186904568">"Redémarrer plus tard"</string>
    <string name="bluetooth_details_spatial_audio_title" msgid="1368071116994002707">"Son spatial"</string>
    <string name="bluetooth_details_spatial_audio_summary" msgid="5026859623681482668">"Le son des supports compatibles devient plus immersif"</string>
    <string name="bluetooth_details_head_tracking_title" msgid="5416972521040337799">"Suivi de la tête"</string>
    <string name="bluetooth_details_head_tracking_summary" msgid="3942238746595985395">"Le son est modifié en fonction des mouvements de votre tête pour produire un son plus naturel"</string>
    <string name="ingress_rate_limit_title" msgid="2106694002836274350">"Limitation du taux de téléchargement sur le réseau"</string>
    <string name="ingress_rate_limit_summary" msgid="1097811019742438371">"Configurez la limitation du taux d\'entrée sur la bande passante qui est appliquée à tous les réseaux qui fournissent une connectivité Internet."</string>
    <string name="ingress_rate_limit_dialog_title" msgid="5359461052422633789">"Configurer la limitation du taux de téléchargement sur le réseau"</string>
    <string name="ingress_rate_limit_no_limit_entry" msgid="8741098826008012163">"Aucune limite"</string>
    <string name="disable_phantom_process_monitor_title" msgid="8348108346706188771">"Désactiver les restrict. pour les processus enfant"</string>
    <string name="disable_phantom_process_monitor_summary" msgid="3044464635550256985">"Désactivez les restrictions sur l\'utilisation des ressources système pour les processus d\'application relatifs aux profils pour enfants"</string>
    <string name="bluetooth_broadcast_dialog_title" msgid="9172775308463135884">"Diffusion"</string>
    <string name="bluetooth_broadcast_dialog_broadcast_app" msgid="1016617579194329005">"Diffuser <xliff:g id="CURRENTAPP">%1$s</xliff:g>"</string>
    <string name="bluetooth_broadcast_dialog_find_message" msgid="6621660851669953883">"Écoutez les diffusions en cours à proximité"</string>
    <string name="bluetooth_broadcast_dialog_broadcast_message" msgid="6198264676009094495">"Diffusez des contenus multimédias sur des appareils à proximité ou écoutez la diffusion de quelqu\'un d\'autre"</string>
    <string name="bluetooth_find_broadcast_title" msgid="5385985218699831970">"Diffusions"</string>
    <string name="bluetooth_find_broadcast_summary" msgid="3907899428626210673">"Écoute de"</string>
    <string name="bluetooth_find_broadcast" msgid="1768337775649457586">"Trouver des diffusions"</string>
    <string name="bluetooth_find_broadcast_button_leave" msgid="7881206581147104908">"Quitter la diffusion"</string>
    <string name="bluetooth_find_broadcast_button_scan" msgid="3995664694641895189">"Numériser le code QR"</string>
    <string name="find_broadcast_password_dialog_title" msgid="3176988702535737484">"Entrer le mot de passe"</string>
    <string name="find_broadcast_password_dialog_connection_error" msgid="47873617983439400">"Connexion impossible. Réessayez."</string>
    <string name="find_broadcast_password_dialog_password_error" msgid="243855327674765">"Mot de passe incorrect"</string>
    <string name="find_broadcast_join_broadcast_error" msgid="5486980388774711346">"Impossible d\'accéder à la diffusion"</string>
    <string name="bt_le_audio_scan_qr_code_scanner" msgid="7614569515419813053">"Pour commencer à écouter, centrez le code QR ci-dessous"</string>
    <string name="bt_le_audio_qr_code_is_not_valid_format" msgid="7821837654128137901">"Le format du code QR est incorrect"</string>
    <string name="convert_to_esim_title" msgid="71037864129009206">"Convertir à une carte eSIM"</string>
    <string name="transfer_esim_to_another_device_title" msgid="5286117866086383192">"Transférer la carte eSIM à un autre appareil"</string>
    <string name="background_install_preference_summary" msgid="3065219346519340364">"{count,plural, =1{# application}one{# application}other{# applications}}"</string>
    <string name="background_install_title" msgid="607913515188276168">"Applications installées en arrière-plan"</string>
    <string name="background_install_summary" msgid="3890296129543309666">"Le fabricant de votre appareil peut installer des applications sur votre appareil en arrière-plan, ou autoriser votre fournisseur de services et d\'autres partenaires à le faire.\n\nLes applications répertoriées ici ne sont pas nécessaires au fonctionnement normal de votre appareil. Vous pouvez désinstaller les applications que vous ne voulez pas."</string>
    <string name="background_install_feature_list_no_entry" msgid="2071343281272266154">"Aucune application installée en arrière-plan"</string>
    <string name="background_install_uninstall_button_description" msgid="1189649052911501249">"Désinstaller l\'application"</string>
    <string name="background_install_before" msgid="8608614957688912715">"{count,plural, =1{Applications installées au cours du dernier mois}one{Applications installées au cours du dernier (#) mois}other{Applications installées au cours des # derniers mois}}"</string>
    <string name="background_install_after" msgid="7983488897570908149">"{count,plural, =1{Applications installées il y a plus de # mois}one{Applications installées il y a plus de # mois}other{Applications installées il y a plus de # mois}}"</string>
    <string name="accessibility_fingerprint_label" msgid="5017431423168191733">"Capteur d\'empreintes digitales"</string>
    <string name="flash_notifications_title" msgid="4490438861180492311">"Notifications par flash"</string>
    <string name="flash_notifications_about_title" msgid="9004351252928121214">"À propos des notifications par flash"</string>
    <string name="flash_notifications_summary_off" msgid="6056282996770691461">"Désactivées"</string>
    <string name="flash_notifications_summary_on_camera" msgid="3286405833586333730">"Activées pour le flash de l\'appareil photo"</string>
    <string name="flash_notifications_summary_on_screen" msgid="9040640799633336219">"Activées pour le flash de l\'écran"</string>
    <string name="flash_notifications_summary_on_camera_and_screen" msgid="2326268141063768701">"Activées pour le flash de l\'appareil photo et de l\'écran"</string>
    <string name="flash_notifications_intro" msgid="8409873413480928249">"Faites clignoter l\'écran ou la lumière de l\'appareil photo lorsque vous recevez des notifications ou lorsque des alarmes retentissent"</string>
    <!-- no translation found for flash_notifications_intro_without_camera_flash (6297337174487793891) -->
    <skip />
    <string name="flash_notifications_note" msgid="2426125248448055075">"Utilisez les notifications par flash avec précaution si vous êtes sensible à la lumière"</string>
    <string name="flash_notifications_preview" msgid="5320176885050440874">"Aperçu"</string>
    <string name="camera_flash_notification_title" msgid="2475084876382922732">"Flash de l\'appareil photo"</string>
    <string name="screen_flash_notification_title" msgid="3773100725793316708">"Flash de l\'écran"</string>
    <string name="screen_flash_notification_color_title" msgid="7213407653340970790">"Couleur du flash de l\'écran"</string>
    <string name="screen_flash_color_blue" msgid="3585766657607931371">"Bleu"</string>
    <string name="screen_flash_color_azure" msgid="8691198532944992243">"Azur"</string>
    <string name="screen_flash_color_cyan" msgid="6878780006173747267">"Cyan"</string>
    <string name="screen_flash_color_spring_green" msgid="4466548514738457815">"Vert printemps"</string>
    <string name="screen_flash_color_green" msgid="8418019648507964564">"Vert"</string>
    <string name="screen_flash_color_chartreuse_green" msgid="7456381649919010366">"Vert chartreuse"</string>
    <string name="screen_flash_color_yellow" msgid="7413465411615454556">"Jaune"</string>
    <string name="screen_flash_color_orange" msgid="979177126315557656">"Orange"</string>
    <string name="screen_flash_color_red" msgid="8954162219886445491">"Rouge"</string>
    <string name="screen_flash_color_rose" msgid="1216848195972231251">"Rose"</string>
    <string name="screen_flash_color_magenta" msgid="7726221666557102155">"Magenta"</string>
    <string name="screen_flash_color_violet" msgid="1279950780509029495">"Violet"</string>
    <string name="color_selector_dialog_done" msgid="121253968943363376">"Terminé"</string>
    <string name="color_selector_dialog_cancel" msgid="8667350644753900701">"Annuler"</string>
    <string name="dock_multi_instances_not_supported_text" msgid="3513493664467667084">"Cette application ne peut être ouverte que dans une seule fenêtre."</string>
</resources>
