<?xml version="1.0" ?>
<!DOCTYPE translationbundle>
<translationbundle lang="fr">
<translation id="1503959756075098984">Identifiants d'extension et URL de mise à jour à installer en arrière-plan</translation>
<translation id="2463365186486772703">Paramètres régionaux de l'application</translation>
<translation id="1397855852561539316">URL de suggestions de recherche du moteur de recherche par défaut</translation>
<translation id="3347897589415241400">Comportement par défaut des sites dans aucun pack de contenu

          Il s'agit d'une règle utilisée en interne par Chrome.</translation>
<translation id="7040229947030068419">Exemple de valeur :</translation>
<translation id="1213523811751486361">Spécifie l'URL du moteur de recherche utilisé pour fournir des suggestions de recherche. L'URL doit contenir la chaîne &quot;<ph name="SEARCH_TERM_MARKER"/>&quot; qui sera remplacée au moment de la requête par le texte que l'utilisateur aura saisi. 

Cette règle est facultative. Si l'URL n'est pas définie, aucune URL de suggestions de recherche n'est utilisée. 

Cette règle n'est respectée que si la règle &quot;DefaultSearchProviderEnabled&quot; est activée.</translation>
<translation id="6106630674659980926">Activer le gestionnaire de mots de passe</translation>
<translation id="7109916642577279530">Permet d'autoriser ou d'interdire la capture audio.

      Si cette règle est activée ou n'est pas configurée (par défaut), l'utilisateur est invité à accepter
      l'accès à la capture audio, excepté pour les URL configurées dans la
      liste AudioCaptureAllowedUrls qui bénéficient d'un accès instantané.

      Lorsque cette règle est désactivée, l'utilisateur ne reçoit pas de message d'invitation,
      et la capture audio n'est disponible que pour les URL configurées dans AudioCaptureAllowedUrls.

      Cette règle a une incidence sur tous les types d'entrée audio, et pas uniquement sur le micro intégré.</translation>
<translation id="9150416707757015439">Cette règle est obsolète. Veuillez utiliser la règle &quot;IncognitoModeAvailability&quot;. 
Active le mode navigation privée de <ph name="PRODUCT_NAME"/>. 

Si ce paramètre est activé ou n'est pas configuré, les utilisateurs peuvent ouvrir des pages Web en mode navigation privée. 

Si ce paramètre est désactivé, les utilisateurs ne peuvent pas ouvrir de pages Web en mode navigation privée. 

Si cette règle n'est pas configurée, ce paramètre est activé et l'utilisateur est en mesure d'utiliser le mode navigation privée.</translation>
<translation id="4203389617541558220">Limite la durée de fonctionnement de l'appareil en programmant des redémarrages automatiques.

      Lorsque vous définissez cette règle, elle indique la durée de fonctionnement de l'appareil avant la programmation d'un redémarrage automatique.

      Si vous ne la définissez pas, la durée de fonctionnement de l'appareil est illimitée.

      Si vous définissez cette règle, les utilisateurs ne peuvent pas la modifier ni l'ignorer.

      Un redémarrage automatique est programmé à l'heure sélectionnée, mais peut être reporté de 24 heures au maximum si un utilisateur se sert de l'appareil.

      Remarque : Pour le moment, les redémarrages automatiques ne sont activés que lorsque l'écran de connexion est affiché ou qu'une session d'application de kiosque est en cours. Ce fonctionnement va changer prochainement : la règle s'appliquera toujours, qu'une session de n'importe quel type soit en cours ou non.

      La valeur de la règle doit être spécifiée en secondes. Les valeurs doivent être au minimum égales à 3 600 (une heure).</translation>
<translation id="5304269353650269372">Durée pendant laquelle l'utilisateur doit rester inactif avant qu'une boîte de dialogue d'avertissement ne s'affiche (en cas d'utilisation de la batterie).

          Lorsque cette règle est définie, elle spécifie la durée pendant laquelle l'utilisateur doit rester inactif avant que <ph name="PRODUCT_OS_NAME"/> n'affiche une boîte de dialogue l'avertissant que le délai d'inactivité va bientôt être dépassé.

          Lorsque cette règle n'est pas définie, aucun avertissement ne s'affiche.

          Cette valeur, qui doit être inférieure ou égale au délai d'inactivité, est définie en millisecondes.</translation>
<translation id="7818131573217430250">Définir l'état par défaut du mode Contraste élevé sur l'écran de connexion</translation>
<translation id="7614663184588396421">Liste des schémas de protocole désactivés</translation>
<translation id="2309390639296060546">Paramètre de géolocalisation par défaut</translation>
<translation id="1313457536529613143">Indique le pourcentage d'adaptation du délai d'assombrissement de l'écran en cas d'activité de l'utilisateur lors de la réduction de la luminosité ou peu de temps après la désactivation de l'écran.

          Si vous définissez cette règle, elle indique le pourcentage d'adaptation du délai de réduction de la luminosité de l'écran en cas d'activité de l'utilisateur lors de la réduction de la luminosité ou peu de temps après la désactivation de l'écran. En cas d'adaptation de ce délai, les délais de désactivation, de verrouillage et d'inactivité de l'écran sont ajustés pour maintenir le même décalage par rapport au délai d'assombrissement de l'écran initialement configuré.

          Si vous ne la définissez pas, un facteur d'adaptation par défaut est appliqué.

          Ce facteur doit être de 100 % ou plus.</translation>
<translation id="7443616896860707393">Invites d'authentification de base HTTP (Basic Auth) multi-domaine</translation>
<translation id="2337466621458842053">Permet de définir une liste de formats d'URL spécifiant les sites qui sont autorisés à afficher des images. 

Si cette règle n'est pas configurée, la valeur par défaut globale est utilisée pour tous les sites à partir de la règle &quot;DefaultImagesSetting&quot; si elle est configurée, ou à défaut, à partir de la configuration personnelle de l'utilisateur.</translation>
<translation id="4680961954980851756">Activer la saisie automatique</translation>
<translation id="5183383917553127163">Permet de définir les extensions non régies par la liste noire.

          Définir la liste noire sur la valeur * revient à interdire toutes les extensions. Les utilisateurs ne peuvent alors installer que celles expressément répertoriées dans la liste blanche.

          Par défaut, toutes les extensions figurent sur la liste blanche. Toutefois, si toutes les extensions ont été mises sur la liste noire par la stratégie, seules les extensions expressément indiquées dans la liste blanche pourront être utilisées.</translation>
<translation id="5921888683953999946">Définit l'état par défaut de la fonctionnalité d'accessibilité de grand curseur sur l'écran de connexion.

          Si vous définissez cette règle sur &quot;True&quot;, le grand curseur est activé à l'affichage de l'écran de connexion.

          Si vous définissez cette règle sur &quot;False&quot;, il est désactivé à l'affichage de l'écran de connexion.

          Si vous définissez cette règle, les utilisateurs peuvent l'ignorer temporairement en activant ou en désactivant le grand curseur. Toutefois, cette option n'est pas définitive, et la valeur par défaut est restaurée dès que l'écran de connexion est affiché de nouveau ou que l'utilisateur reste inactif pendant une minute sur l'écran de connexion.

          Si vous ne définissez pas cette règle, le grand curseur est désactivé au premier affichage de l'écran de connexion. Les utilisateurs peuvent l'activer ou le désactiver à tout moment, et son état sur l'écran de connexion est appliqué à tous les utilisateurs.</translation>
<translation id="3185009703220253572">depuis la version <ph name="SINCE_VERSION"/></translation>
<translation id="2204753382813641270">Règle pour masquer automatiquement le répertoire</translation>
<translation id="3816312845600780067">Activer le raccourci clavier permettant d'ignorer le processus de connexion automatique</translation>
<translation id="3214164532079860003">Lorsqu'elle est activée, cette règle force l'importation de la page d'accueil à partir du navigateur par défaut actuel. 

Si elle est désactivée, la page d'accueil n'est pas importée. 

Si elle n'est pas configurée, l'utilisateur peut être invité à effectuer l'importation, ou celle-ci peut se faire automatiquement.</translation>
<translation id="5330684698007383292">Autoriser <ph name="PRODUCT_FRAME_NAME"/> à gérer les types de contenu suivants</translation>
<translation id="6647965994887675196">Si cette règle est associée à la valeur &quot;true&quot;, vous pouvez créer et utiliser des comptes utilisateur supervisés.

          Si elle est associée à la valeur &quot;false&quot; ou si elle n'est pas configurée, la création et la connexion des comptes utilisateur supervisés sont désactivées. Tous les utilisateurs supervisés existants sont alors masqués.

          REMARQUE : Le comportement par défaut des appareils grand public diffère de celui des appareils professionnels : sur les appareils grand public, les comptes utilisateur supervisés sont autorisés par défaut, contrairement aux appareils professionnels.</translation>
<translation id="69525503251220566">Paramètre qui active la fonctionnalité de recherche par image pour le moteur de recherche par défaut</translation>
<translation id="5469825884154817306">Bloquer les images sur ces sites</translation>
<translation id="8412312801707973447">Si des contrôles OCSP/CRL en ligne sont effectués</translation>
<translation id="6649397154027560979">Cette règle a été abandonnée. Veuillez utiliser URLBlacklist à la place.

      Désactive les schémas de protocoles répertoriés dans <ph name="PRODUCT_NAME"/>.

      Les URL utilisant un schéma de cette liste ne sont pas chargées et ne sont pas accessibles.

      Si vous ne définissez pas cette règle ou si la liste est vide, tous les schémas sont accessibles dans <ph name="PRODUCT_NAME"/>.</translation>
<translation id="3213821784736959823">Définit si le client DNS intégré est utilisé dans <ph name="PRODUCT_NAME"/>.

      Si cette règle est définie sur &quot;True&quot;, le client DNS intégré est utilisé, si disponible.

      Si cette règle est définie sur &quot;False&quot;, le client DNS intégré n'est jamais utilisé.

      Si cette règle n'est pas configurée, l'utilisateur peut choisir si le client DNS intégré doit être utilisé ou non, soit en modifiant chrome://flags, soit à l'aide d'un indicateur de ligne de commande.</translation>
<translation id="2908277604670530363">Nombre maximal de connexions simultanées au serveur proxy</translation>
<translation id="556941986578702361">Définit si le répertoire <ph name="PRODUCT_OS_NAME"/> doit être masqué automatiquement ou non.

      Si cette règle est définie sur &quot;AlwaysAutoHideShelf&quot;, le répertoire est toujours masqué automatiquement.

      Si cette règle est définie sur &quot;NeverAutoHideShelf&quot;, le répertoire n'est jamais masqué automatiquement.

      Si cette règle est configurée, l'utilisateur ne peut ni la modifier, ni la contourner.

      Si cette règle n'est pas configurée, l'utilisateur peut choisir de masquer automatiquement le répertoire ou non.</translation>
<translation id="4838572175671839397">Contient une expression régulière qui est utilisée pour déterminer quels utilisateurs peuvent se connecter à <ph name="PRODUCT_NAME"/>.

      Un message d'erreur approprié s'affiche lorsqu'un utilisateur tente de se connecter avec un nom qui ne correspond pas à ce schéma.

      Si cette règle est laissée vide ou n'est pas définie, n'importe quel utilisateur peut alors se connecter à <ph name="PRODUCT_NAME"/>.</translation>
<translation id="2892225385726009373">Lorsque ce paramètre est activé, <ph name="PRODUCT_NAME"/> exécute toujours une vérification de la révocation des certificats de serveur qui sont correctement validés et qui sont signés par des certificats CA installés localement.

      S'il est impossible d'obtenir des informations relatives à l'état de la révocation par le biais de <ph name="PRODUCT_NAME"/>, ces certificats seront considérés comme révoqués (&quot;échec&quot;).

      Si cette règle n'est pas définie ou si elle est définie sur &quot;False&quot;, les paramètres de vérification en ligne de la révocation sont alors utilisés dans Chrome.</translation>
<translation id="1438955478865681012">Configure les règles relatives aux extensions. L'utilisateur n'est pas autorisé à installer les extensions inscrites sur la liste noires, sauf si elles figurent sur la liste blanche. Vous pouvez également forcer <ph name="PRODUCT_NAME"/> à installer des extensions. Pour ce faire, dressez la liste de ces extensions dans <ph name="EXTENSIONINSTALLFORCELIST_POLICY_NAME"/>. La liste noire est prioritaire sur la liste des extensions dont l'installation est forcée.</translation>
<translation id="3516856976222674451">Limite la durée maximale d'une session utilisateur.

      Lorsque cette règle est configurée, elle indique au bout de combien de temps un utilisateur est automatiquement déconnecté, ce qui met fin à la session. Un compte à rebours, qui s'affiche dans la barre d'état système, informe l'utilisateur du temps qu'il lui reste.

      Lorsque cette règle n'est pas configurée, la session n'est pas limitée dans le temps.

      Si cette règle est configurée, l'utilisateur ne peut ni la modifier, ni la contourner.

      La valeur de la règle doit être indiquée en millisecondes. Les valeurs doivent être comprises entre 30 secondes et 24 heures.</translation>
<translation id="9200828125069750521">Paramètres pour l'URL d'image utilisant POST</translation>
<translation id="2769952903507981510">Configurer le nom de domaine requis pour les hôtes d'accès à distance</translation>
<translation id="3478024346823118645">Effacer les données utilisateur à la déconnexion</translation>
<translation id="8668394701842594241">Répertorie les plug-ins activés dans <ph name="PRODUCT_NAME"/> et empêche les utilisateurs de modifier ce paramètre. 

Les caractères génériques &quot;*&quot; et &quot;?&quot; remplacent des séquences de caractères arbitraires. &quot;*&quot; correspond à un nombre aléatoire de caractères, tandis que &quot;?&quot; représente un caractère unique facultatif, c'est-à-dire qu'il remplace zéro ou un caractère. Placé devant les caractères &quot;*&quot;, &quot;?&quot; ou &quot;\&quot;, le caractère d'échappement &quot;\&quot; permet de rechercher ces caractères eux-mêmes.

La liste de plug-ins indiquée est toujours utilisée dans <ph name="PRODUCT_NAME"/> si ceux-ci sont installés. Les plug-ins sont marqués comme activés dans &quot;about:plugins&quot; et les utilisateurs ne peuvent pas les désactiver. 

Notez que cette règle remplace à la fois &quot;DisabledPlugins&quot; et &quot;DisabledPluginsExceptions&quot;. 

Si cette règle n'est pas configurée, l'utilisateur peut désactiver n'importe quel plug-in installé sur le système.</translation>
<translation id="653608967792832033">Indiquer le délai d'inactivité au terme duquel l'écran est verrouillé en cas d'utilisation de la batterie

          Lorsque cette règle est définie sur une valeur supérieure à zéro, elle indique la durée pendant laquelle l'utilisateur doit rester inactif avant que <ph name="PRODUCT_OS_NAME"/> verrouille l'écran.

          Lorsque cette règle est définie sur zéro, <ph name="PRODUCT_OS_NAME"/> ne verrouille pas l'écran en cas d'inactivité de l'utilisateur.

          Si cette règle n'est pas définie, une durée par défaut est utilisée.

          Pour verrouiller l'écran en cas d'inactivité, il est recommandé d'activer le verrouillage de l'écran en cas d'arrêt et de paramétrer l'arrêt de <ph name="PRODUCT_OS_NAME"/> au terme du délai d'inactivité. Cette règle ne doit être utilisée que lorsque le verrouillage de l'écran n'est nécessaire qu'un certain laps de temps avant l'arrêt, ou lorsque l'arrêt en cas d'inactivité n'est pas souhaité.

          La valeur de cette règle doit être indiquée en millisecondes. Les valeurs doivent être inférieures au délai d'inactivité.</translation>
<translation id="4157003184375321727">Indiquer la version du système d'exploitation et du micrologiciel</translation>
<translation id="4752214355598028025">Le service de navigation sécurisée affiche une page d'avertissement lorsque les utilisateurs essaient d'accéder à des sites potentiellement malveillants. L'activation de ce paramètre empêche les utilisateurs de poursuivre leur navigation sur ces sites lorsqu'un tel message apparaît.

      En cas de désactivation ou de non-configuration de ce paramètre, les utilisateurs ont la possibilité d'accéder aux sites potentiellement malveillants après l'affichage de l'avertissement.</translation>
<translation id="5255162913209987122">Peut être recommandée</translation>
<translation id="1861037019115362154">Spécifie une liste de plug-ins désactivés dans <ph name="PRODUCT_NAME"/> et empêche les utilisateurs de modifier ce paramètre.

      Les caractères génériques &quot;*&quot; et &quot;?&quot; peuvent être utilisés pour représenter des séquences de caractères arbitraires. &quot;*&quot; représente un nombre arbitraire de caractères tandis que &quot;?&quot; représente un caractère unique facultatif. Ce dernier correspond soit à un seul caractère, soit à aucun caractère. Pour représenter les caractères &quot;*&quot;, &quot;?&quot; ou &quot;\&quot; eux-mêmes, le caractère d'échappement &quot;\&quot; doit être placé devant eux.

      En cas d'activation de ce paramètre, la liste de plug-ins définie n'est jamais utilisée dans <ph name="PRODUCT_NAME"/>. Les plug-ins sont marqués comme désactivés dans &quot;about:plugins&quot;, et les utilisateurs n'ont pas la possibilité de les activer.

      Notez que cette règle peut être remplacée par EnabledPlugins et DisabledPluginsExceptions.

      En cas de non-configuration de ce paramètre, l'utilisateur peut utiliser n'importe quel plug-in installé sur le système, à l'exception des plug-ins codés en dur incompatibles, et des plug-ins obsolètes ou dangereux.</translation>
<translation id="9197740283131855199">Pourcentage d'adaptation du délai d'assombrissement de l'écran si l'utilisateur devient actif après la réduction de la luminosité</translation>
<translation id="1492145937778428165">Indique la fréquence en millisecondes à laquelle le service de gestion des appareils est interrogé sur les informations concernant les règles relatives aux appareils. 

       La définition de cette règle remplace la valeur par défaut de 3 heures. Les valeurs valides pour cette règle sont comprises entre 1 800 000 (30 minutes) et 86,4 millions (1 jour). Toutes les valeurs non comprises dans cette plage seront nivelées à la limite respective. 

       Si cette règle n'est pas définie, <ph name="PRODUCT_OS_NAME"/> utilise la valeur par défaut de 3 heures.</translation>
<translation id="3765260570442823273">Durée du message d'avertissement avant la déconnexion pour cause d'inactivité</translation>
<translation id="7302043767260300182">Délai de verrouillage de l'écran (secteur)</translation>
<translation id="7331962793961469250">Si cette option est définie sur &quot;True&quot;, les publicités pour les applications Chrome Web Store ne s'affichent pas sur la page Nouvel onglet.

Si elle est définie sur &quot;False&quot; ou si elle n'est pas configurée, ces publicités s'affichent sur la page Nouvel onglet.</translation>
<translation id="7271085005502526897">Importer la page d'accueil du navigateur par défaut à la première exécution</translation>
<translation id="6036523166753287175">Activer la traversée de pare-feu depuis l'hôte d'accès à distance</translation>
<translation id="1096105751829466145">Moteur de recherche par défaut</translation>
<translation id="7567380065339179813">Autoriser les plug-ins sur ces sites</translation>
<translation id="1617235075406854669">Activer la suppression de l'historique du navigateur et de l'historique des téléchargements</translation>
<translation id="5290940294294002042">Répertorier les plug-ins pouvant être activés ou désactivés par l'utilisateur</translation>
<translation id="3153348162326497318">Vous permet de spécifier les extensions que les utilisateurs ne peuvent PAS installer. Les extensions déjà installées seront supprimées si elles sont ajoutées à la liste noire. 

La valeur &quot;*&quot; en liste noire signifie que toutes les extensions sont sur la liste noire, sauf si elles sont explicitement répertoriées dans la liste blanche. 

Si cette règle n'est pas configurée, l'utilisateur peut installer n'importe quelle extension dans <ph name="PRODUCT_NAME"/>.</translation>
<translation id="3067188277482006117">Si la valeur est définie sur &quot;true&quot;, l'utilisateur peut utiliser le matériel sur des appareils Chrome afin d'attester, à distance, de son identité auprès de l'autorité de certification de la confidentialité par le biais de l'API Enterprise Platform Keys &quot;chrome.enterprise.platformKeysPrivate.challengeUserKey()&quot;.

          Si la valeur est définie sur &quot;false&quot;, ou si elle n'est pas définie, les appels vers l'API échouent, et un code d'erreur est renvoyé.</translation>
<translation id="5809728392451418079">Définir le nom affiché pour les comptes locaux des appareils</translation>
<translation id="1427655258943162134">Adresse ou URL du serveur proxy</translation>
<translation id="1827523283178827583">Utiliser des serveurs proxy déterminés</translation>
<translation id="3021409116652377124">Désactiver l'outil de recherche de plug-ins</translation>
<translation id="7236775576470542603">Définit le type de loupe par défaut activée sur l'écran de connexion.

          Si vous définissez cette règle, elle contrôle le type de loupe qui est activée à l'affichage de l'écran de connexion. Définissez la règle sur &quot;Aucun&quot; pour désactiver la loupe.

          Si vous définissez cette règle, les utilisateurs peuvent l'ignorer temporairement en activant ou en désactivant la loupe. Toutefois, cette option n'est pas définitive, et la valeur par défaut est restaurée dès que l'écran de connexion est affiché de nouveau ou que l'utilisateur reste inactif pendant une minute sur l'écran de connexion.

          Si vous ne définissez pas cette règle, la loupe est désactivée au premier affichage de l'écran de connexion. Les utilisateurs peuvent l'activer ou la désactiver à tout moment, et son état sur l'écran de connexion est appliqué à tous les utilisateurs.</translation>
<translation id="5423001109873148185">Lorsqu'elle est activée, cette règle force l'importation des moteurs de recherche à partir du navigateur par défaut actuel. Si cette règle est activée, elle affecte également la boîte de dialogue d'importation. 

Si elle est désactivée, le moteur de recherche par défaut n'est pas importé. 

Si elle n'est pas configurée, l'utilisateur peut être invité à effectuer l'importation, ou celle-ci peut se faire automatiquement.</translation>
<translation id="3288595667065905535">Version disponible</translation>
<translation id="2785954641789149745">Active la fonctionnalité de navigation sécurisée de <ph name="PRODUCT_NAME"/> et empêche les utilisateurs de modifier ce paramètre.

      Si vous activez ce paramètre, la navigation sécurisée est toujours active.

      Si vous désactivez ce paramètre, la navigation sécurisée n'est jamais active.

      Si vous activez ou désactivez ce paramètre, les utilisateurs ne peuvent pas modifier ni ignorer le paramètre &quot;Activer la protection contre le phishing et les logiciels malveillants&quot; dans <ph name="PRODUCT_NAME"/>.

      Si vous ne définissez pas cette règle, la navigation sécurisée est activée, mais les utilisateurs peuvent la modifier.</translation>
<translation id="8369602308428138533">Délai d'arrêt de l'écran (secteur)</translation>
<translation id="6513756852541213407">Permet de définir le serveur proxy utilisé par <ph name="PRODUCT_NAME"/> et empêche les utilisateurs de modifier les paramètres du proxy. 

Si vous choisissez de ne jamais utiliser de serveur proxy et de demander une connexion directe systématique, toutes les autres options sont ignorées. 

Si vous décidez d'utiliser les paramètres de proxy du système ou de demander la détection automatique du serveur proxy, toutes les autres options sont ignorées. 

Si vous choisissez le mode serveur proxy déterminé, vous pouvez définir des options supplémentaires dans &quot;Adresse ou URL du serveur proxy&quot; et &quot;Liste de règles de contournement de proxy séparées par des virgules&quot;. 

Si vous décidez d'utiliser un script de proxy .pac, vous devez indiquer l'URL du script dans &quot;URL d'un fichier .pac de proxy&quot;. 

Pour consulter des exemples détaillés, accédez à : 
<ph name="PROXY_HELP_URL"/>.

Si vous activez ce paramètre, <ph name="PRODUCT_NAME"/> ignore toutes les options de proxy spécifiées sur la ligne de commande.

Si cette règle n'est pas configurée, les utilisateurs sont autorisés à sélectionner eux-mêmes les paramètres du proxy.</translation>
<translation id="7763311235717725977">Permet de déterminer si les sites Web sont autorisés à afficher les images. L'affichage des images peut être soit autorisé, soit refusé pour tous les sites. 

Si cette règle n'est pas configurée, la règle &quot;AllowImages&quot; est utilisée, et l'utilisateur est  en mesure de la modifier.</translation>
<translation id="5630352020869108293">Restaurer la dernière session</translation>
<translation id="4980635395568992380">Type de données :</translation>
<translation id="3096595567015595053">Liste des plug-ins activés</translation>
<translation id="3048744057455266684">Si cette règle est définie et que la chaîne de requête ou l'identifiant du fragment d'une URL de recherche suggérée à partir de l'Omnibox contient ce paramètre, la suggestion affiche les termes et le moteur de recherche, et non l'URL de recherche brute.

          Cette règle est facultative. Si vous ne la définissez pas, aucun remplacement des termes de recherche n'est effectué.

          Cette règle ne s'applique que si la règle 'DefaultSearchProviderEnabled' est activée.</translation>
<translation id="5912364507361265851">Permet aux utilisateurs d'afficher les mots de passe dans le gestionnaire de mots de passe.</translation>
<translation id="510186355068252378">Désactive la synchronisation des données dans <ph name="PRODUCT_NAME"/> en utilisant les services de synchronisation hébergés par Google et empêche les utilisateurs de modifier ce paramètre. 

Si vous activez ce paramètre, les utilisateurs ne peuvent pas le modifier, ni le remplacer dans <ph name="PRODUCT_NAME"/>. 

Si cette règle n'est pas configurée, Google Sync est disponible et l'utilisateur décide de l'utiliser ou non.</translation>
<translation id="7953256619080733119">Hôtes d'exception manuelle des utilisateurs gérés</translation>
<translation id="7412982067535265896">Permet de définir une liste de schémas d'URL qui déterminent les sites autorisés à créer des cookies spécifiques à chaque session.

           Si cette règle n'est pas définie, la valeur globale par défaut est utilisée pour tous les sites. Celle-ci provient soit de la règle &quot;DefaultCookiesSetting&quot; (si celle-ci est définie), soit de la configuration personnelle de l'utilisateur (le cas échéant).

           Si la règle &quot;RestoreOnStartup&quot; est définie de manière à restaurer les URL des sessions précédentes, elle ne sera pas respectée. Les cookies seront stockés de façon permanente pour ces sites.</translation>
<translation id="8828766846428537606">Configure la page d'accueil par défaut de <ph name="PRODUCT_NAME"/> et empêche les utilisateurs de modifier cette dernière.

      Les paramètres de page d'accueil de l'utilisateur ne sont complètement verrouillés que si vous définissez la page &quot;Nouvel onglet&quot; ou une URL spécifique comme page d'accueil. Si vous ne précisez pas l'URL de la page d'accueil, l'utilisateur est toujours en mesure de définir la page d'accueil sur la page &quot;Nouvel onglet&quot; au moyen de la valeur &quot;chrome://newtab&quot;.</translation>
<translation id="2231817271680715693">Importer l'historique de navigation du navigateur par défaut à la première exécution</translation>
<translation id="1353966721814789986">Pages d'accueil</translation>
<translation id="1841130111523795147">Permet à l'utilisateur de se connecter à <ph name="PRODUCT_NAME"/> sans l'autoriser à modifier ce paramètre.

      En définissant cette règle, vous autorisez l'utilisateur à se connecter à <ph name="PRODUCT_NAME"/> ou non.</translation>
<translation id="5564962323737505851">Configure le gestionnaire de mots de passe. Si le gestionnaire de mots de passe est activé, vous pouvez activer ou désactiver la stratégie permettant à l'utilisateur d'afficher en texte clair les mots de passe enregistrés.</translation>
<translation id="4668325077104657568">Paramètres d'images par défaut</translation>
<translation id="4492287494009043413">Désactiver les captures d'écran</translation>
<translation id="6368403635025849609">Autoriser JavaScript sur ces sites</translation>
<translation id="6074963268421707432">Interdire à tous les sites d'afficher des notifications sur le Bureau</translation>
<translation id="8614804915612153606">Désactive les mises à jour automatiques</translation>
<translation id="382476126209906314">Configurer le préfixe TalkGadget pour les hôtes d'accès à distance</translation>
<translation id="6561396069801924653">Afficher les options d'accessibilité dans le menu de la barre système</translation>
<translation id="8104962233214241919">Sélectionner automatiquement des certificats client pour ces sites</translation>
<translation id="2906874737073861391">Liste des extensions AppPack</translation>
<translation id="3758249152301468420">Désactiver les outils de développement</translation>
<translation id="8665076741187546529">Configurer la liste des extensions dont l'installation est forcée</translation>
<translation id="410478022164847452">Indiquer le délai d'inactivité au terme duquel l'action d'inactivité est appliquée en cas d'utilisation de l'alimentation secteur

                      Lorsque cette règle est définie, elle indique la durée pendant laquelle l'utilisateur doit rester inactif avant que <ph name="PRODUCT_OS_NAME"/> applique l'action d'inactivité, configurable séparément.

                      Si cette règle n'est pas définie, une durée par défaut est utilisée.

                      La valeur de cette règle doit être indiquée en millisecondes.</translation>
<translation id="1675391920437889033">Définit quels types d'extensions ou d'applications sont autorisés à être installés.

          Ce paramètre ajoute à la liste blanche les types d'extensions ou d'applications qui sont autorisés à être installés dans <ph name="PRODUCT_NAME"/>. Il s'agit d'une liste de chaînes qui peuvent prendre les valeurs suivantes : &quot;extension&quot;, &quot;theme&quot;, &quot;user_script&quot;, &quot;hosted_app&quot;, &quot;legacy_packaged_app&quot; ou &quot;platform_app&quot;. Pour obtenir davantage d'informations sur ces types, veuillez consulter la documentation relative aux extensions de Google Chrome.

          Sachez que cette règle force également l'installation des extensions et des applications via ExtensionInstallForcelist.

          Si ce paramètre est configuré, les extensions ou les applications dont le type ne figure par sur la liste ne sont pas installées.

          Si ce paramètre n'est pas configuré, aucune restriction n'est imposée concernant les types d'extensions ou d'applications pouvant être installés.</translation>
<translation id="6378076389057087301">Indiquer si l'activité audio a une incidence sur la gestion de l'alimentation</translation>
<translation id="8818173863808665831">Permet d'indiquer l'emplacement géographique de l'appareil.

      Si cette règle n'est pas définie, ou si la valeur &quot;false&quot; lui est attribuée, l'emplacement n'est pas indiqué.</translation>
<translation id="4899708173828500852">Activer la navigation sécurisée</translation>
<translation id="4442582539341804154">Activer le verrouillage lorsque l'appareil est inactif ou en veille</translation>
<translation id="7719251660743813569">Détermine si les statistiques d'utilisation doivent être envoyées à Google. Si cette règle est définie sur &quot;true&quot;, <ph name="PRODUCT_OS_NAME"/> elles le sont. Si cette règle n'est pas configurée ou si elle est définie sur &quot;false&quot;, les rapports sur les statistiques ne sont pas envoyés.</translation>
<translation id="2372547058085956601">Détermine le délai de connexion automatique à une session publique.

      Si la règle |DeviceLocalAccountAutoLoginId| n'est pas définie, elle n'a aucune incidence.

      Si cette règle est définie, elle détermine la durée pendant laquelle l'utilisateur doit rester inactif avant que le système ne se connecte automatiquement à la session publique définie dans la règle |DeviceLocalAccountAutoLoginId|.

      Si elle n'est pas définie, le délai de connexion s'élève à 0 milliseconde.

      Cette règle est définie en millisecondes.</translation>
<translation id="7275334191706090484">Favoris gérés</translation>
<translation id="3570008976476035109">Bloquer les plug-ins sur ces sites</translation>
<translation id="8749370016497832113">Permet la suppression de l'historique du navigateur et de l'historique des téléchargements dans <ph name="PRODUCT_NAME"/> sans permettre à l'utilisateur de modifier ce paramètre.

      Sachez que, même si cette règle est désactivée, il n'est pas garanti que l'historique du navigateur et l'historique des téléchargements soient conservés. Les utilisateurs peuvent, dans certains cas, modifier ou supprimer directement les fichiers de base de données de ces historiques. De même, le navigateur peut expirer ou archiver à tout moment des éléments de l'historique.

      Si ce paramètre est activé ou s'il n'est pas défini, la suppression de l'historique du navigateur et de l'historique des téléchargements est possible.

      Si ce paramètre est désactivé, la suppression de l'historique du navigateur et de l'historique des téléchargements n'est pas possible.</translation>
<translation id="2884728160143956392">Autoriser les cookies limités à la session sur ces sites</translation>
<translation id="3021272743506189340">Désactive la synchronisation de Google Drive dans l'application Fichiers de Chrome OS lors de l'utilisation d'une connexion mobile lorsque la valeur est définie sur &quot;true&quot;. Dans ce cas, les données ne sont synchronisées avec Google Drive qu'avec une connexion via Wi-Fi ou Ethernet.

          Si cette valeur n'est pas définie, ou si elle définie sur &quot;false&quot;, les utilisateurs peuvent transférer des fichiers vers Google Drive via une connexion mobile.</translation>
<translation id="4655130238810647237">Active ou désactive la modification des favoris dans <ph name="PRODUCT_NAME"/>. 

Si vous activez ce paramètre, il est possible d'ajouter, de supprimer ou de modifier des favoris. Il s'agit de l'option par défaut, même lorsque cette règle n'est pas configurée. 

Si vous désactivez ce paramètre, il est impossible d'ajouter, de supprimer ou de modifier des favoris. Les favoris existants restent disponibles.</translation>
<translation id="3496296378755072552">Gestionnaire de mots de passe</translation>
<translation id="2565967352111237512">Permet la déclaration anonyme des données d'utilisation et d'erreur concernant <ph name="PRODUCT_NAME"/> à Google et empêche les utilisateurs de modifier ce paramètre. 

Si vous activez ce paramètre, la déclaration anonyme des données d'utilisation et d'erreur est envoyée à Google. 

Si vous désactivez ce paramètre, la déclaration anonyme des données d'utilisation et d'erreur n'est jamais envoyée à Google. 

Dans les deux cas, les utilisateurs ne peuvent pas le modifier, ni le remplacer dans <ph name="PRODUCT_NAME"/>. 

Si cette règle n'est pas configurée, le paramètre est défini sur l'option que l'utilisateur a choisie lors de l'installation ou de la première exécution.</translation>
<translation id="6256787297633808491">Options système à appliquer au démarrage de Google Chrome</translation>
<translation id="2516600974234263142">Active les fonctionnalités d'impression pour <ph name="PRODUCT_NAME"/> et interdit à l'utilisateur de changer ce paramètre.

      Si ce paramètre est activé ou s'il n'est pas configuré, l'utilisateur peut se servir des fonctionnalités d'impression.

      Si ce paramètre est désactivé, l'utilisateur ne peut pas imprimer depuis <ph name="PRODUCT_NAME"/>. Les fonctionnalités d'impression sont désactivées dans le menu clé à molette, les extensions, les applications JavaScript, etc. L'impression est toujours possible à partir de plug-ins qui contournent <ph name="PRODUCT_NAME"/>. Par exemple, certaines applications Flash proposent, dans leur menu contextuel, des fonctionnalités d'impression qui ne sont pas affectées par cette règle.</translation>
<translation id="9135033364005346124">Activer le proxy <ph name="CLOUD_PRINT_NAME"/></translation>
<translation id="4519046672992331730">Activer les suggestions de recherche dans l'Omnibox de <ph name="PRODUCT_NAME"/> et empêcher les utilisateurs de modifier ce paramètre

            Si vous activez ce paramètre, les suggestions de recherche sont utilisées. 

            Si vous le désactivez, les suggestions de recherche ne sont jamais utilisées. 

            Dans les deux cas, les utilisateurs ne peuvent pas le modifier, ni le remplacer dans <ph name="PRODUCT_NAME"/>.

            Si cette règle n'est pas configurée, ce paramètre est activé, mais l'utilisateur est en mesure de le modifier.</translation>
<translation id="6943577887654905793">Nom de préférence Mac/Linux :</translation>
<translation id="6925212669267783763">Configure le répertoire que <ph name="PRODUCT_FRAME_NAME"/> utilise pour stocker les données utilisateur.

      Si vous définissez cette règle, <ph name="PRODUCT_FRAME_NAME"/> utilise le répertoire fourni.

      Consultez une liste des variables utilisables à l'adresse http://www.chromium.org/administrators/policy-list-3/user-data-directory-variables.

      Si vous ne définissez pas ce paramètre, le répertoire de profil par défaut est utilisé.</translation>
<translation id="8906768759089290519">Activer le mode invité</translation>
<translation id="2168397434410358693">Délai d'inactivité (secteur)</translation>
<translation id="838870586332499308">Activer l'itinérance des données</translation>
<translation id="3234167886857176179">Voici la liste des règles suivies par <ph name="PRODUCT_NAME"/>.

      Vous n'avez pas besoin de modifier ces paramètres manuellement. Vous pouvez télécharger des modèles faciles à utiliser à l'adresse suivante :
      <ph name="POLICY_TEMPLATE_DOWNLOAD_URL"/>

      La liste des règles compatibles est la même pour Chromium et Google Chrome.

      Ces règles sont strictement prévues pour être utilisées dans le cadre de la configuration de copies de Chrome internes à votre entreprise. Si elles sont utilisées à l'extérieur de votre entreprise (dans le cadre d'un programme distribué publiquement, par exemple), cela est considéré comme une activité de logiciel malveillant. Sachez que Google et les distributeurs de logiciels antivirus sont susceptibles de signaler cette activité comme étant le fait d'un logiciel malveillant.

      Remarque : À partir de la version 28 de Chrome, les règles sont chargées directement depuis l'API Group Policy sous Windows. Les règles rédigées manuellement dans le registre sont ignorées. Pour en savoir plus, accédez à l'adresse http://crbug.com/259236.</translation>
<translation id="2292084646366244343"><ph name="PRODUCT_NAME"/> peut utiliser un service Web de Google pour corriger les erreurs d'orthographe. En cas d'activation de ce paramètre, ce service est toujours utilisé. En cas de désactivation de ce paramètre, il n'est jamais utilisé.

      Il reste toutefois possible de procéder à la correction orthographique à l'aide d'un dictionnaire téléchargé. Cette règle ne contrôle que l'utilisation du service en ligne.

      En cas de non-configuration de ce paramètre, les utilisateurs peuvent décider d'utiliser le service de correction orthographique ou non.</translation>
<translation id="8782750230688364867">Indique le pourcentage d'adaptation du délai d'assombrissement de l'écran lorsque l'appareil est en mode Présentation.

          Si vous définissez cette règle, elle indique le pourcentage d'adaptation du délai d'assombrissement de l'écran lorsque l'appareil est en mode Présentation. En cas d'adaptation de ce délai, les délais de désactivation, de verrouillage et de mise en veille de l'écran sont ajustés pour maintenir le même décalage par rapport au délai d'assombrissement de l'écran initialement configuré.

          Si vous ne la définissez pas, un facteur d'adaptation par défaut est appliqué.

          Ce facteur doit être de 100 % ou plus. Les valeurs qui auraient pour conséquence de rendre le délai d'assombrissement de l'écran en mode Présentation plus court que le délai d'assombrissement de l'écran standard ne sont pas autorisées.</translation>
<translation id="254524874071906077">Définir Chrome comme navigateur par défaut</translation>
<translation id="8764119899999036911">Indique si le SPN Kerberos généré est basé sur le nom DNS canonique ou sur le nom d'origine saisi. 

Si vous activez ce paramètre, la recherche du CNAME sera ignorée et le nom du serveur sera utilisé tel qu'il a été saisi. 

Si vous désactivez ce paramètre ou s'il n'est pas défini, le nom canonique du serveur sera déterminé par le biais de la recherche du CNAME.</translation>
<translation id="5056708224511062314">Loupe désactivée</translation>
<translation id="4377599627073874279">Autoriser tous les sites à afficher toutes les images</translation>
<translation id="7195064223823777550">Indiquer l'action à effectuer lorsque l'utilisateur ferme le couvercle

          Lorsque cette règle est définie, elle indique l'action effectuée par <ph name="PRODUCT_OS_NAME"/> lorsque l'utilisateur ferme le couvercle de l'appareil.

          Si cette règle n'est pas définie, l'action par défaut est effectuée, à savoir l'arrêt.

          Dans ce cas, <ph name="PRODUCT_OS_NAME"/> peut être configuré séparément pour verrouiller ou non l'écran avant l'arrêt.</translation>
<translation id="3915395663995367577">URL d'un fichier .pac de proxy</translation>
<translation id="1022361784792428773">Identifiants d'extension que l'utilisateur ne doit pas être autorisé à installer (ou * pour tous)</translation>
<translation id="5499375345075963939">Cette règle n'est active qu'en mode &quot;point de vente&quot;.

      Lorsque sa valeur est configurée, et si elle ne correspond pas à 0, l'utilisateur connecté en mode démonstration est déconnecté automatiquement après la durée d'inactivité définie.

      Notez que la valeur de cette règle se mesure en millisecondes.</translation>
<translation id="7683777542468165012">Actualisation dynamique des stratégies</translation>
<translation id="1160939557934457296">Désactiver l'accès au site lors de l'affichage de la page d'avertissement par le service de navigation sécurisée</translation>
<translation id="8987262643142408725">Désactiver le fractionnement des enregistrements SSL</translation>
<translation id="4529945827292143461">Personnalisez la liste des formats d'URL qui doivent toujours être affichés par le navigateur hôte. 


Si cette règle n'est pas configurée, le moteur de rendu par défaut sera utilisé pour tous les sites, tel que spécifié par la règle &quot;ChromeFrameRendererSettings&quot;. 

Pour voir des exemples de format, accédez à http://www.chromium.org/developers/how-tos/chrome-frame-getting-started.</translation>
<translation id="8044493735196713914">Indiquer le mode de démarrage de l'appareil</translation>
<translation id="2746016768603629042">Cette règle est obsolète. Veuillez plutôt utiliser la règle &quot;DefaultJavaScriptSetting&quot;.

      Vous pouvez utiliser cette règle pour désactiver JavaScript dans <ph name="PRODUCT_NAME"/>.

      Si vous désactivez ce paramètre, les pages Web ne peuvent pas utiliser JavaScript et l'utilisateur n'est pas en mesure de le modifier.

      Si vous activez ce paramètre ou si vous ne le définissez pas, les pages Web peuvent utiliser JavaScript, mais l'utilisateur n'est pas en mesure de le modifier.</translation>
<translation id="4047207703890139433">Définit le format d'horloge à utiliser pour l'appareil. Les utilisateurs peuvent le remplacer pour la session en cours. Il est cependant défini de nouveau sur la valeur spécifiée lorsqu'ils se déconnectent. Si une chaîne vide est fournie, la préférence définie par le propriétaire de l'appareil est utilisée.</translation>
<translation id="1942957375738056236">Vous pouvez spécifier ici l'URL du serveur proxy. 

Cette règle ne prend effet que si vous avez sélectionné les paramètres de proxy manuels dans l'option &quot;Sélectionner le mode de spécification des paramètres de serveur proxy&quot;. 

Vous ne devriez pas configurer cette règle si vous avez sélectionné un autre mode de spécification des règles de proxy. 

Pour plus d'options et obtenir des exemples détaillés, accédez au site : 
<ph name="PROXY_HELP_URL"/></translation>
<translation id="6076008833763548615">Désactive le montage de périphériques de stockage externe.

      Lorsque cette règle est définie sur &quot;True&quot;, le navigateur de fichiers n'offre pas la possibilité de procéder à un stockage externe.

      Cette règle concerne tous les types de support de stockage (clés USB, disques durs externes, cartes SD, autres cartes mémoire, etc.). Elle ne concerne pas Google Drive ni le stockage interne. Dès lors, les fichiers enregistrés dans le dossier de téléchargement restent accessibles.

      En cas de désactivation ou de non-configuration de ce paramètre, l'appareil fonctionne avec tous les supports de stockage externe compatibles.</translation>
<translation id="6936894225179401731">Indique le nombre maximal de connexions simultanées au serveur proxy.

      Certains serveurs proxy ne peuvent pas gérer un grand nombre de connexions simultanées par client. La définition d'une valeur inférieure pour cette règle peut résoudre ce problème.

      La valeur de cette règle doit être inférieure à 100 et supérieure à 6. La valeur par défaut est 32.

      Certaines applications Web consomment de nombreuses connexions avec blocage des opérations GET. Par conséquent, le fait de définir une valeur inférieure à 32 peut entraîner des blocages de l'accès réseau du navigateur si un trop grand nombre d'applications Web de ce type sont ouvertes. Il est déconseillé de définir une valeur inférieure à la valeur par défaut.

      En cas de non-configuration de cette règle, la valeur par défaut de 32 est utilisée.</translation>
<translation id="5395271912574071439">Active la protection des hôtes d'accès à distance lorsqu'une connexion est en cours.

          En cas d'activation de ce paramètre, les appareils d'entrée et de sortie physiques des hôtes sont désactivés tant qu'une connexion est en cours.

          En cas de désactivation ou de non-configuration de ce paramètre, l'utilisateur local ainsi que l'utilisateur à distance peuvent interagir avec l'hôte tant que ce celui-ci est partagé.</translation>
<translation id="1426410128494586442">Oui</translation>
<translation id="4897928009230106190">Spécifie les paramètres utilisés pour la recherche de suggestions avec POST. Il s'agit de paires de noms et de valeurs séparées par une virgule. Si une valeur est équivalente à un paramètre modèle, comme &quot;{searchTerms}&quot; dans l'exemple ci-dessus, elle est remplacée par des termes de recherche réels.

          Cette règle est facultative. Si elle n'est pas définie, la suggestion de requête de recherche sera envoyée à l'aide la méthode GET.

          Cette règle n'est respectée que si la règle &quot;DefaultSearchProviderEnabled&quot; est activée.</translation>
<translation id="4962195944157514011">Spécifie l'URL du moteur de recherche utilisé lorsque vous faites une recherche par défaut. L'URL doit contenir la chaîne &quot;<ph name="SEARCH_TERM_MARKER"/>&quot; qui sera remplacée au moment de la requête par les termes que l'utilisateur recherche. 

Cette option doit être définie lorsque la règle &quot;DefaultSearchProviderEnabled&quot; est activée et ne sera respectée que si c'est le cas.</translation>
<translation id="6009903244351574348">Autorisez <ph name="PRODUCT_FRAME_NAME"/> à gérer les types de contenu répertoriés. 

Si cette règle n'est pas configurée, le moteur de rendu par défaut est utilisé pour tous les sites, tel que spécifié par la règle &quot;ChromeFrameRendererSettings&quot;.</translation>
<translation id="3381968327636295719">Utiliser le navigateur hôte par défaut</translation>
<translation id="3627678165642179114">Activer ou désactiver le service Web de correction orthographique</translation>
<translation id="6520802717075138474">Importer les moteurs de recherche du navigateur par défaut à la première exécution</translation>
<translation id="4039085364173654945">Contrôle si un sous-contenu tiers sur une page est autorisé à ouvrir une boîte de dialogue d'authentification de base HTTP ( Basic Auth) dans une fenêtre pop-up. 

Cette option est habituellement désactivée dans le cadre de la protection contre le phishing. Si cette règle n'est pas configurée, cette option est désactivée et le sous-contenu tiers n'est pas autorisé à afficher une boîte de dialogue d'authentification de base HTTP.</translation>
<translation id="4946368175977216944">Spécifie les options à appliquer à Google Chrome au démarrage. Ces options sont appliquées avant le démarrage de Google Chrome (avant même l'affichage de l'écran de connexion).</translation>
<translation id="7447786363267535722">Permet d'enregistrer les mots de passe et d'utiliser des mots de passe sauvegardés dans <ph name="PRODUCT_NAME"/>. 

Si vous activez ce paramètre, les utilisateurs peuvent demander à <ph name="PRODUCT_NAME"/> de mémoriser leurs mots de passe et de leur fournir automatiquement lors de leur prochaine connexion à un site. 

Si vous le désactivez, les utilisateurs ne sont pas en mesure d'enregistrer les mots de passe, ni d'utiliser des mots de passe déjà enregistrés. 

Dans les deux cas, les utilisateurs ne peuvent pas le modifier, ni le remplacer dans <ph name="PRODUCT_NAME"/>. 

Si cette règle n'est pas configurée, ce paramètre est activé, mais l'utilisateur est en mesure de le modifier.</translation>
<translation id="1138294736309071213">Cette règle n'est active qu'en mode Point de vente.

       Détermine pour les appareils en mode Point de vente la durée d'inactivité préalable à l'affichage de l'économiseur d'écran sur l'écran de connexion.

       La valeur de cette règle est définie en millisecondes.</translation>
<translation id="6368011194414932347">Configurer l'URL de la page d'accueil</translation>
<translation id="2877225735001246144">Désactiver la consultation CNAME lors de la négociation de l'authentification Kerberos</translation>
<translation id="9120299024216374976">Indique le fuseau horaire à utiliser sur l'appareil. Les utilisateurs peuvent modifier le fuseau horaire spécifié pendant la session en cours. Cependant, le paramètre est de nouveau défini sur le fuseau horaire spécifié lors de la déconnexion. Si une valeur non valide est utilisée, la règle est toutefois activée avec le fuseau horaire &quot;GMT&quot;. Si une chaîne vide est utilisée, cette règle est ignorée.

      Si la règle n'est pas appliquée, le fuseau horaire actif continue d'être utilisé. Cependant, les utilisateurs peuvent modifier le fuseau horaire, et cette modification est permanente. En conséquence, toute modification apportée par un utilisateur a une incidence sur l'écran de connexion de tous les autres utilisateurs.

      Le fuseau horaire est défini sur &quot;États-Unis/Pacifique&quot; pour tous les nouveaux appareils.

      Le format de la valeur correspond aux noms des fuseaux horaires de la &quot;IANA Time Zone Database&quot; (voir la page &quot;http://en.wikipedia.org/wiki/List_of_tz_database_time&quot;). La plupart des fuseaux horaires se présentent sous la forme &quot;continent/grande_ville&quot; ou &quot;océan/grande_ville&quot;.</translation>
<translation id="3646859102161347133">Définir le type de loupe</translation>
<translation id="3528000905991875314">Activer les pages d'erreur alternatives</translation>
<translation id="1283072268083088623">Indique si les modèles d'authentification HTTP sont compatibles avec <ph name="PRODUCT_NAME"/>. 

Les valeurs possibles sont &quot;basic&quot;, &quot;digest&quot;, &quot;NTLM&quot; et &quot;negotiate&quot;. Séparez les valeurs à l'aide de virgules. 

Si cette règle n'est pas configurée, les quatre modèles seront utilisés.</translation>
<translation id="4914647484900375533">Active la fonctionnalité de recherche instantanée de <ph name="PRODUCT_NAME"/> et empêche les utilisateurs de modifier ce paramètre.

      Si vous activez ce paramètre, la recherche instantanée de <ph name="PRODUCT_NAME"/> est activée.

      Si vous désactivez ce paramètre, la recherche instantanée de <ph name="PRODUCT_NAME"/> est désactivée.

      Si vous activez ou désactivez ce paramètre, les utilisateurs ne peuvent pas le modifier ni l'ignorer.

      Si vous ne définissez pas ce paramètre, les utilisateurs peuvent choisir d'appliquer cette fonctionnalité ou non.

      Ce paramètre a été supprimé de Chrome 29 et versions ultérieures.</translation>
<translation id="6114416803310251055">obsolète</translation>
<translation id="8493645415242333585">Désactiver l'enregistrement de l'historique du navigateur</translation>
<translation id="5319306267766543020">Configurer la gestion de l'alimentation dans <ph name="PRODUCT_OS_NAME"/>

      Ces règles vous permettent de configurer le comportement de <ph name="PRODUCT_OS_NAME"/> lorsque l'utilisateur est inactif pendant un certain temps.</translation>
<translation id="2747783890942882652">Configure le nom de domaine hôte obligatoire pour les hôtes d'accès à distance et empêche les utilisateurs de le modifier.

          En cas d'activation de ce paramètre, le partage des hôtes n'est possible que si les comptes utilisés sont enregistrés auprès du nom de domaine spécifié.

          En cas de désactivation ou de non-configuration de ce paramètre, le partage des hôtes est possible avec tous les comptes.</translation>
<translation id="6417861582779909667">Permet de définir une liste de formats d'URL spécifiant les sites qui ne sont pas autorisés à définir des cookies. 

Si cette règle n'est pas configurée, la valeur par défaut globale est utilisée pour tous les sites à partir de la règle &quot;DefaultCookiesSetting &quot;, ou à défaut, à partir de la configuration personnelle de l'utilisateur.</translation>
<translation id="5457296720557564923">Permet aux pages d'accéder aux statistiques JavaScript d'utilisation de la mémoire. Grâce à ce paramètre, les pages Web ont accès aux statistiques sur la mémoire issues du panneau &quot;Profils&quot; des outils de développement.</translation>
<translation id="5776485039795852974">Demander confirmation chaque fois qu'un site veut afficher des notifications sur le bureau</translation>
<translation id="5052081091120171147">Lorsqu'elle est activée, cette règle force l'importation de l'historique de navigation à partir du navigateur par défaut actuel. Si elle est activée, elle affecte également la boîte de dialogue d'importation. 

Si elle est désactivée, aucun historique de navigation n'est importé. 

Si elle n'est pas configurée, l'utilisateur peut être invité à effectuer l'importation, ou celle-ci peut se faire automatiquement.</translation>
<translation id="6786747875388722282">Extensions</translation>
<translation id="8947415621777543415">Indiquer l'emplacement de l'appareil</translation>
<translation id="1655229863189977773">Définir la taille du cache du disque en octets</translation>
<translation id="6376842084200599664">Vous permet de spécifier une liste d'extensions installées en tâche de fond, sans intervention de l'utilisateur.

          Chaque élément de la liste est une chaîne constituée d'un identifiant d'extension et d'une URL de mise à jour séparés par un point-virgule (<ph name="SEMICOLON"/>). L'identifiant d'extension est la chaîne de 32 lettres que vous pouvez trouver par exemple sur <ph name="CHROME_EXTENSIONS_LINK"/> en mode développeur. L'URL de mise à jour doit rediriger vers un document XML de manifeste de mise à jour tel qu'il est décrit à l'adresse <ph name="LINK_TO_EXTENSION_DOC1"/>. Notez que l'URL de mise à jour définie dans cette règle est utilisée uniquement pour la première installation. Les mises à jour ultérieures de l'extension utilisent l'URL de mise à jour spécifiée dans le manifeste de l'extension.

          Pour chaque élément, <ph name="PRODUCT_NAME"/> récupère l'extension désignée par l'identifiant d'extension du service de mise à jour à l'adresse URL spécifiée, puis installe l'extension en arrière-plan.

          Par exemple, <ph name="EXTENSION_POLICY_EXAMPLE"/> installe l'extension <ph name="EXTENSION_POLICY_EXAMPLE_EXTENSION_NAME"/> depuis l'URL de mise à jour standard du Chrome Web Store. Pour en savoir plus sur l'hébergement des extensions, reportez-vous à l'adresse suivante : <ph name="LINK_TO_EXTENSION_DOC2"/>.

          Les utilisateurs ne peuvent pas désinstaller les extensions installées par le biais de cette règle. Lorsque vous supprimez une extension de la liste, <ph name="PRODUCT_NAME"/> la désinstalle automatiquement. Les extensions indiquées dans cette liste sont automatiquement placées en liste blanche pour l'installation. La liste &quot;ExtensionInstallBlacklist&quot; n'a aucun effet sur elles.

          Si vous ne définissez pas cette règle, l'utilisateur peut désinstaller n'importe quelle extension dans <ph name="PRODUCT_NAME"/>.</translation>
<translation id="6899705656741990703">Détecter automatiquement les paramètres de proxy</translation>
<translation id="7003334574344702284">Lorsqu'elle est activée, cette règle force l'importation des mots de passe enregistrés à partir du navigateur par défaut précédent. Si elle est activée, cette politique affecte également la boîte de dialogue d'importation. 

Si elle est désactivée, les mots de passe enregistrés ne sont pas importés. 

Si elle n'est pas configurée, l'utilisateur peut être invité à effectuer l'importation, ou celle-ci peut se faire automatiquement.</translation>
<translation id="6258193603492867656">Indique si le SPN Kerberos généré doit inclure un port non standard. 

Si vous activez ce paramètre et qu'un port non standard (c'est-à-dire, un port autre que 80 ou 443) est indiqué, ce port est inclus dans le SPN Kerberos généré. 

Si vous désactivez ce paramètre ou si vous ne le configurez pas, le SPN Kerberos généré ne comprend aucun port.</translation>
<translation id="3236046242843493070">Formats d'URL à partir desquelles autoriser les sources d'installation des extensions, des applications et des scripts d'utilisateur</translation>
<translation id="2498238926436517902">Toujours masquer automatiquement le répertoire</translation>
<translation id="253135976343875019">Délai d'inactivité avant l'affichage d'un avertissement (en cas de connexion secteur)</translation>
<translation id="6997592395211691850">Définit si les vérifications en ligne OCSP/CRL sont requises pour les ancres d'approbation locales.</translation>
<translation id="152657506688053119">Liste d'URL alternatives pour le moteur de recherche par défaut</translation>
<translation id="8992176907758534924">Interdire à tous les sites d'afficher des images</translation>
<translation id="262740370354162807">Activer l'envoi de documents à <ph name="CLOUD_PRINT_NAME"/></translation>
<translation id="7717938661004793600">Permet de configurer les fonctionnalités d'accessibilité de <ph name="PRODUCT_OS_NAME"/>.</translation>
<translation id="5182055907976889880">Configurer Google Drive dans <ph name="PRODUCT_OS_NAME"/></translation>
<translation id="8704831857353097849">Liste des plug-ins désactivés</translation>
<translation id="8391419598427733574">Indiquer la version du système d'exploitation et du micrologiciel des appareils inscrits. Si ce paramètre est défini sur &quot;True&quot;, la version du système d'exploitation et celle du micrologiciel sont régulièrement communiquées par les appareils inscrits. Si ce paramètre n'est pas défini, ou s'il est défini sur &quot;False&quot;, ces informations ne sont pas transmises.</translation>
<translation id="467449052039111439">Ouvrir une liste d'URL</translation>
<translation id="5883015257301027298">Paramètre de cookies par défaut</translation>
<translation id="5017500084427291117">Bloque l'accès aux URL répertoriées.

      Cette règle empêche l'utilisateur de charger des pages Web à partir d'URL figurant sur la liste noire.

      Une URL utilise le format &quot;schéma://hôte:port/chemin&quot;. 
      Le schéma facultatif peut être http, https ou ftp. Seul ce schéma sera bloqué. Si aucun schéma n'est spécifié, tous les schémas sont bloqués.
      L'hôte peut être un nom d'hôte ou une adresse IP. Les sous-domaines d'un nom d'hôte sont également bloqués. Afin d'éviter le blocage des sous-domaines, ajoutez un point (.) avant le nom d'hôte. Le nom d'hôte spécial &quot;*&quot; bloque tous les domaines. 
      Le port facultatif est un numéro de port valide de 1 à 65 535. Si aucun n'est spécifié, tous les ports sont bloqués. 
      Si le chemin facultatif est spécifié, seuls les chemins contenant ce préfixe sont bloqués. 

      Vous pouvez définir des exceptions dans la règle des URL sur liste blanche. Ces règles étant limitées à 1 000 entrées, les entrées suivantes sont ignorées.

      Si vous ne définissez pas cette règle, aucune URL n'est mise sur liste noire dans le navigateur.</translation>
<translation id="2762164719979766599">Indique la liste des comptes locaux de l'appareil devant être affichés sur l'écran de connexion.

      Chaque entrée de la liste indique un identifiant, qui est utilisé de façon interne pour différencier les comptes locaux de l'appareil.</translation>
<translation id="8955719471735800169">Haut de page</translation>
<translation id="2534584045044686957">Configure la taille du cache utilisé par <ph name="PRODUCT_NAME"/> pour stocker les fichiers multimédias en cache sur le disque.

      En cas d'activation de cette règle, <ph name="PRODUCT_NAME"/> utilise la taille configurée pour le cache, que l'utilisateur ait défini l'indicateur &quot;--media-cache-size&quot; ou non.

      Si la valeur de cette règle correspond à 0, la taille par défaut du cache est utilisée. Dans ce cas, l'utilisateur n'a pas la possibilité de la modifier.

      En cas de non-configuration de cette règle, la taille par défaut du cache est utilisée. L'utilisateur peut toutefois la modifier à l'aide de l'indicateur &quot;--media-cache-size&quot;.</translation>
<translation id="3723474915949495925">Spécifie une liste de plug-ins que les utilisateurs peuvent activer ou désactiver dans <ph name="PRODUCT_NAME"/>.

      Les caractères génériques &quot;*&quot; et &quot;?&quot; peuvent être utilisés pour représenter des séquences de caractères arbitraires. &quot;*&quot; représente un nombre arbitraire de caractères tandis que &quot;?&quot; représente un caractère unique facultatif. Ce dernier correspond soit à un seul caractère, soit à aucun caractère. Pour représenter les caractères &quot;*&quot;, &quot;?&quot; ou &quot;\&quot; eux-mêmes, le caractère d'échappement &quot;\&quot; doit être placé devant eux.

      En cas d'activation de ce paramètre, la liste de plug-ins définie peut être utilisée dans <ph name="PRODUCT_NAME"/>. Les utilisateurs peuvent activer ou désactiver ces plug-ins dans &quot;about:plugins&quot;, même s'ils sont répertoriés dans DisabledPlugins. Ils peuvent également activer ou désactiver les plug-ins non répertoriés dans DisabledPlugins, DisabledPluginsExceptions et EnabledPlugins.

      Cette règle permet à l'administrateur de définir des exceptions pour les plug-ins répertoriés dans la liste &quot;DisabledPlugins&quot; lorsque les entrées correspondantes contiennent des caractères génériques (par exemple, &quot;*&quot; qui permet de désactiver tous les plug-ins ou &quot;*Java*&quot; qui permet de désactiver tous les plug-ins Java). Si l'administrateur souhaite activer des versions spécifiques de ces plug-ins (&quot;IcedTea Java 2.3&quot;, par exemple), cette règle le permet.

      En cas de non-configuration de cette règle, tous les plug-ins répertoriés dans &quot;DisabledPlugins&quot; sont désactivés et verrouillés. Les utilisateurs n'ont pas la possibilité de les activer.</translation>
<translation id="546726650689747237">Délai d'assombrissement de l'écran (secteur)</translation>
<translation id="4988291787868618635">Action à effectuer au terme du délai d'inactivité</translation>
<translation id="5316405756476735914">Permet de spécifier si les sites Web sont autorisés à définir des données locales. La définition de données locales peut être soit autorisée pour tous les sites, soit refusée pour tous les sites. 

Si cette règle n'est pas configurée, le paramètre &quot;AllowCookies&quot; est utilisé et l'utilisateur est en mesure de le modifier.</translation>
<translation id="4250680216510889253">Non</translation>
<translation id="1522425503138261032">Autoriser les sites à suivre la position géographique des utilisateurs</translation>
<translation id="6467433935902485842">Permet de définir une liste de formats d'URL spécifiant les sites qui ne sont pas autorisés à exécuter des plug-ins. 

Si cette règle n'est pas configurée, la valeur par défaut globale est utilisée pour tous les sites à partir de la règle &quot;DefaultPluginsSetting&quot;, si elle est définie, ou à défaut, à partir de la configuration personnelle de l'utilisateur.</translation>
<translation id="4423597592074154136">Spécifier manuellement les paramètres de proxy</translation>
<translation id="209586405398070749">Version stable</translation>
<translation id="8170878842291747619">Active le service Google Traduction intégré sur <ph name="PRODUCT_NAME"/>. 

Si vous activez ce paramètre, <ph name="PRODUCT_NAME"/> affichera, le cas échéant, une offre intégrée à la barre d'outils de traduction de la page. 

Si vous le désactivez, les utilisateurs ne verront jamais la barre de traduction. 

Dans les deux cas, les utilisateurs ne peuvent pas le modifier ou le remplacer dans <ph name="PRODUCT_NAME"/>. 

Si ce paramètre n'est pas défini, l'utilisateur peut décider d'utiliser cette fonction ou non.</translation>
<translation id="9035964157729712237">Identifiants d'extension à exclure de la liste noire</translation>
<translation id="8244525275280476362">Délai maximal de récupération après le rejet d'une règle</translation>
<translation id="8587229956764455752">Autoriser la création de comptes utilisateur</translation>
<translation id="7417972229667085380">Pourcentage d'adaptation du délai d'inactivité en mode Présentation (abandonné)</translation>
<translation id="3964909636571393861">Permet d'accéder à une liste d'URL.</translation>
<translation id="3450318623141983471">Indiquer l'état de l'interrupteur du mode développeur au moment du démarrage. Si la règle n'est pas définie, ou si elle est définie sur &quot;False&quot;, l'état de l'interrupteur du mode développeur n'est pas communiqué.</translation>
<translation id="1811270320106005269">Activer le verrouillage lorsque les appareils utilisant <ph name="PRODUCT_OS_NAME"/> sont inactifs ou en veille. 

       Si vous activez ce paramètre, les utilisateurs sont invités à fournir un mot de passe pour réactiver l'appareil lorsqu'il est en veille.

       Si vous désactivez ce paramètre, les utilisateurs n'ont pas de mot de passe à fournir pour réactiver l'appareil lorsqu'il est en veille.

       Dans les deux cas, les utilisateurs ne peuvent pas modifier ou remplacer ce paramètre.

       Si cette règle n'est pas définie, l'utilisateur peut décider s'il souhaite être invité à saisir un mot de passe pour déverrouiller l'appareil ou non.</translation>
<translation id="6022948604095165524">Action au démarrage</translation>
<translation id="9042911395677044526">Permet de transférer l'application de la configuration réseau par utilisateur vers un appareil utilisant <ph name="PRODUCT_OS_NAME"/>. La configuration réseau correspond à une chaîne formatée par JSON conformément au format de configuration de réseau ouvert, décrit sous <ph name="ONC_SPEC_URL"/>.</translation>
<translation id="7128918109610518786">Permet de répertorier les identifiants des applications épinglées que <ph name="PRODUCT_OS_NAME"/> affiche dans la barre du lanceur d'applications.

      Si cette règle est configurée, le groupe d'applications est figé et ne peut plus être modifié par l'utilisateur.

      Si cette règle n'est pas configurée, l'utilisateur a la possibilité de modifier la liste des applications épinglées dans le lanceur d'applications.</translation>
<translation id="1679420586049708690">Session publique pour la connexion automatique</translation>
<translation id="7625444193696794922">Indique le canal de distribution sur lequel cet appareil devrait être verrouillé.</translation>
<translation id="2552966063069741410">Fuseau horaire</translation>
<translation id="2240879329269430151">Permet de définir si les sites Web sont autorisés à afficher les pop-ups. L'affichage des pop-ups peut être soit autorisé pour tous les sites, soit refusé pour tous les sites. 

Si cette règle n'est pas configurée, le paramètre &quot;BlockPopups&quot; est utilisé et l'utilisateur est en mesure de le modifier.</translation>
<translation id="2529700525201305165">Ne pas autoriser certains utilisateurs à se connecter à <ph name="PRODUCT_NAME"/></translation>
<translation id="8971221018777092728">Minuteur de connexion automatique à la session publique</translation>
<translation id="8285435910062771358">Loupe plein écran activée</translation>
<translation id="5141670636904227950">Activer la loupe plein écran sur l'écran de connexion</translation>
<translation id="3864818549971490907">Paramètre de plug-ins par défaut</translation>
<translation id="7151201297958662315">Détermine si un processus de <ph name="PRODUCT_NAME"/> doit être démarré dès la connexion au système d'exploitation et s'il doit continuer en arrière-plan jusqu'à la fermeture de la dernière fenêtre du navigateur. Le processus exécuté en arrière-plan affiche une icône dans la barre d'état du système et peut être fermé à tout moment à partir de cet emplacement.

       Si cette règle est définie sur &quot;true&quot;, le mode arrière-plan est activé et ne peut pas être contrôlé par l'utilisateur dans les paramètres du navigateur.

       Si cette règle est définie sur &quot;false&quot;, le mode arrière-plan est désactivé et ne peut pas être contrôlé par l'utilisateur dans les paramètres du navigateur.

       Si cette règle n'est pas définie, le mode arrière-plan est désactivé initialement et peut être contrôlé par l'utilisateur dans les paramètres de votre navigateur.</translation>
<translation id="4320376026953250541">Microsoft Windows XP SP2 ou version ultérieure</translation>
<translation id="5148753489738115745">Permet de spécifier les paramètres supplémentaires utilisés lorsque <ph name="PRODUCT_FRAME_NAME"/> lance <ph name="PRODUCT_NAME"/>.

          Si cette règle n'est pas configurée, la ligne de commande par défaut est utilisée.</translation>
<translation id="2646290749315461919">Permet de définir si les sites Web sont autorisés à suivre la position géographique des utilisateurs. Ce suivi peut être autorisé par défaut, refusée par défaut, ou l'utilisateur peut recevoir un message chaque fois qu'un site Web demande sa position géographique. 

Si cette règle n'est pas configurée, le paramètre &quot;AskGeolocation&quot; est utilisé et l'utilisateur est en mesure de le modifier.</translation>
<translation id="6394350458541421998">Cette règle a été supprimée à partir de la version 29 de <ph name="PRODUCT_OS_NAME"/>. Veuillez utiliser la règle PresentationScreenDimDelayScale à la place.</translation>
<translation id="5770738360657678870">Version en développement (peut être instable)</translation>
<translation id="2959898425599642200">Règles de contournement de proxy</translation>
<translation id="228659285074633994">Indique la durée pendant laquelle l'utilisateur doit rester inactif avant qu'une boîte de dialogue d'avertissement ne s'affiche (en cas connexion sur le secteur).

          Lorsque cette règle est définie, elle spécifie la durée pendant laquelle l'utilisateur doit rester inactif avant que <ph name="PRODUCT_OS_NAME"/> n'affiche une boîte de dialogue l'avertissant que le délai d'inactivité va bientôt être dépassé.

          Lorsque cette règle n'est pas définie, aucun avertissement ne s'affiche.

          Cette valeur, qui doit être inférieure ou égale au délai d'inactivité, est définie en millisecondes.</translation>
<translation id="1098794473340446990">Indiquer les périodes d'activité de l'appareil. Si ce paramètre est défini sur &quot;True&quot;, les périodes durant lesquelles l'appareil inscrit est utilisé sont régulièrement communiquées par celui-ci. Si ce paramètre n'est pas défini, ou s'il est défini sur &quot;False&quot;, les périodes d'activité ne sont ni enregistrées, ni communiquées.</translation>
<translation id="7937766917976512374">Autoriser ou interdire la capture vidéo</translation>
<translation id="427632463972968153">Spécifie les paramètres utilisés pour la recherche d'image avec POST. Il s'agit de paires de noms et de valeurs séparées par une virgule. Si une valeur est équivalente à un paramètre modèle, comme &quot;{imageThumbnail}&quot; dans l'exemple ci-dessus, elle est remplacée par des miniatures d'images réelles.

          Cette règle est facultative. Si elle n'est pas définie, la suggestion de requête de recherche d'image sera envoyée à l'aide la méthode GET.

          Cette règle n'est respectée que si la règle &quot;DefaultSearchProviderEnabled&quot; est activée.</translation>
<translation id="8818646462962777576">Les modèles de cette liste seront mis en correspondance avec la source de sécurité
      de l'URL à l'origine de la demande. En cas de correspondance, l'accès aux
      appareils de capture audio est autorisé sans avis préalable.

      REMARQUE : Cette règle est n'acceptée qu'en mode Borne pour le moment.</translation>
<translation id="489803897780524242">Paramètre contrôlant le positionnement des termes de recherche pour le moteur de recherche par défaut</translation>
<translation id="316778957754360075">Ce paramètre a été supprimé à partir de la version 29 de <ph name="PRODUCT_NAME"/>. Pour configurer des collections d'extensions et d'applications hébergées par l'organisation, il est recommandé d'inclure le site hébergeant les packages CRX dans ExtensionInstallSources et d'insérer des liens directs de téléchargement dans les packages sur une page Web. Il est possible de créer un lanceur d'applications pour cette page à l'aide de la règle ExtensionInstallForcelist.</translation>
<translation id="6401669939808766804">Déconnecter l'utilisateur</translation>
<translation id="4826326557828204741">Définit l'action à effectuer si le délai d'inactivité est atteint lorsque l'appareil fonctionne sur batterie.</translation>
<translation id="7912255076272890813">Configurer les types d'applications ou d'extensions autorisés</translation>
<translation id="817455428376641507">Permet d'accéder aux URL répertoriées comme des exceptions à la liste noire des URL.

      Consultez la description des règles de liste noire d'URL pour connaître le format des entrées de cette liste.

      Cette règle peut être utilisée pour ouvrir des exceptions aux listes noires restrictives. Par exemple, &quot;*&quot; peut figurer sur la liste noire pour bloquer toutes les demandes, et cette règle peut être utilisée pour autoriser l'accès à une liste limitée d'adresses URL. Elle peut être utilisée pour ouvrir des exceptions à certains schémas, à des sous-domaines d'autres domaines, à des ports, ou à des chemins spécifiques.

      Le filtre le plus spécifique permet de déterminer si une URL est bloquée ou non. La liste blanche est prioritaire sur la liste noire.

      Cette règle étant limitée à 1 000 entrées, les entrées suivantes sont ignorées.

      Si vous ne définissez pas cette règle, il n'y a pas d'exceptions à la liste noire définie par la règle &quot;URLBlacklist&quot;.</translation>
<translation id="4163644371169597382">Les administrateurs informatiques des appareils d'entreprise peuvent utiliser cet indicateur pour autoriser ou non les utilisateurs à profiter de leurs offres via le service d'enregistrement de Chrome OS.

      Si cette politique est définie sur True ou si elle n'est pas définie, les utilisateurs pourront profiter de leurs offres via ce service.

      Si elle est définie sur False, les utilisateurs ne pourront pas profiter de leurs offres.</translation>
<translation id="8148901634826284024">Active la fonctionnalité d'accessibilité du mode Contraste élevé.

          Si vous définissez cette règle sur &quot;True&quot;, le mode Contraste élevé est activé en permanence.

          Si vous définissez cette règle sur &quot;False&quot;, ce mode est désactivé en permanence.

          Si vous définissez cette règle, les utilisateurs ne peuvent pas la modifier ni l'ignorer.

          Si vous ne définissez pas cette règle, le mode Contraste élevé est désactivé au départ, mais peut ensuite être activé à tout moment par l'utilisateur.</translation>
<translation id="6177482277304066047">Définit une version cible pour les mises à jour automatiques.

      Indique le préfixe de la version cible dans laquelle la mise à jour de <ph name="PRODUCT_OS_NAME"/> doit se faire. Si l'appareil utilise une version antérieure au préfixe défini, la mise à jour installe la toute dernière version comportant le préfixe donné. Si la version de l'appareil est ultérieure au préfixe défini, aucune mise à jour n'est effectuée : l'appareil conserve la version actuelle. Le format du préfixe dépend du composant, conformément à l'exemple suivant :

      &quot;&quot; (ou règle non configurée) : installation de la dernière mise à jour disponible
      &quot;1412.&quot; : installation de toutes les mises à jour mineures de la version 1412 (1412.24.34 ou 1412.60.2, par exemple)
      &quot;1412.2.&quot; : installation de toutes les mises à jour mineures de la version 1412.2 (1412.2.34 ou 1412.2.2, par exemple)
      &quot;1412.24.34&quot; : installation de cette mise à jour spécifique</translation>
<translation id="8102913158860568230">Paramètre MediaStream par défaut</translation>
<translation id="6641981670621198190">Désactiver la prise en charge des API 3D graphics</translation>
<translation id="7929480864713075819">Activer l'envoi d'informations sur la mémoire (taille du tas JS) à la page</translation>
<translation id="5703863730741917647">Définit l'action à effectuer lorsque le délai d'inactivité est atteint.

          Veuillez noter que cette règle est obsolète et qu'elle sera supprimée ultérieurement.

          Cette règle définit une valeur de remplacement pour les règles plus spécifiques de <ph name="IDLEACTIONAC_POLICY_NAME"/> et de <ph name="IDLEACTIONBATTERY_POLICY_NAME"/>. Si cette règle est définie, sa valeur est utilisée lorsque les règles plus spécifiques respectives ne le sont pas.

          Lorsqu'elle n'est pas définie, le comportement des règles plus spécifiques demeure inchangé.</translation>
<translation id="5997543603646547632">Utiliser le format d'horloge 24 h par défaut</translation>
<translation id="7003746348783715221">Préférences de <ph name="PRODUCT_NAME"/></translation>
<translation id="4723829699367336876">Activer la traversée de pare-feu depuis le client d'accès à distance</translation>
<translation id="6367755442345892511">Autoriser ou verrouiller la configuration de la version par l'utilisateur</translation>
<translation id="4035570660718398959">Autoriser les utilisateurs à profiter de leurs offres via le service d'enregistrement Chrome OS</translation>
<translation id="3868347814555911633">Cette règle n'est active qu'en mode &quot;point de vente&quot;.

       Elle répertorie les extensions qui sont automatiquement installées pour l'utilisateur de la démonstration sur les appareils en mode &quot;point de vente&quot;. Celles-ci sont enregistrées dans l'appareil. Elles peuvent être installées hors connexion, une fois l'installation terminée.

       Chaque entrée de la liste contient un dictionnaire qui doit inclure l'identifiant d'extension dans le champ &quot;extension-id&quot;, ainsi que son adresse URL dans le champ &quot;update-url&quot;.</translation>
<translation id="9096086085182305205">Liste blanche des serveurs d'authentification</translation>
<translation id="4980301635509504364">Permet d'autoriser ou d'interdire la capture vidéo.

      Si cette règle est activée ou n'est pas configurée (par défaut), l'utilisateur est invité à accepter
      l'accès à la capture vidéo, excepté pour les URL configurées dans la
      liste VideoCaptureAllowedUrls qui bénéficient d'un accès instantané.

      Lorsque cette règle est désactivée, l'utilisateur ne reçoit pas de message d'invitation,
       et la capture vidéo n'est disponible que pour les URL configurées dans VideoCaptureAllowedUrls.

      Cette règle a une incidence sur tous les types d'entrée vidéo, et pas uniquement sur la caméra intégrée.</translation>
<translation id="7063895219334505671">Autoriser les fenêtres pop-up sur ces sites</translation>
<translation id="4052765007567912447">Contrôle si l'utilisateur peut afficher les mots de passe en texte clair dans le gestionnaire de mots de passe. 

Si vous désactivez ce paramètre, le gestionnaire de mots de passe ne permet pas d'afficher les mots de passe stockés en texte clair dans la fenêtre du gestionnaire de mots de passe. 

Si vous activez cette règle ou si vous ne la configurez pas, les utilisateurs peuvent afficher leurs mots de passe en texte clair dans le gestionnaire de mots de passe.</translation>
<translation id="5213629107215526747">URL autorisées à accéder aux appareils de capture vidéo sans avis préalable</translation>
<translation id="5936622343001856595">SafeSearch est obligatoirement activé pour les recherches sur le Web Google et ce paramètre ne peut être modifié par l'utilisateur.

     Si vous activez ce paramètre, SafeSearch est toujours activé dans la recherche Google.

      Si vous désactivez ce paramètre ou ne définissez pas de valeur, SafeSearch n'est pas activé dans la recherche Google.</translation>
<translation id="6017568866726630990">Affiche la boîte de dialogue d'impression du système au lieu de l'aperçu avant impression.

      Lorsque ce paramètre est activé, <ph name="PRODUCT_NAME"/> ouvre la boîte de dialogue d'impression du système au lieu de l'aperçu avant impression intégré lorsqu'un utilisateur souhaite imprimer une page.

      Si cette règle n'est pas configurée ou si elle est définie sur &quot;False&quot;, les commandes d'impressions génèrent un aperçu avant impression.</translation>
<translation id="2824715612115726353">Activer le mode navigation privée</translation>
<translation id="1057535219415338480">Active la prédiction de réseau dans <ph name="PRODUCT_NAME"/> et empêche les utilisateurs de modifier ce paramètre.

      Cela contrôle non seulement la prélecture des DNS, mais également la préconnexion et le préchargement TCP et SSL des pages Web. Le nom de la règle fait référence à la prélecture des DNS pour des raisons historiques.

      Que vous activiez ou désactiviez ce paramètre, les utilisateurs ne peuvent pas le modifier ni le remplacer dans <ph name="PRODUCT_NAME"/>.

      Si vous ne définissez pas cette règle, ce paramètres est activé, mais les utilisateurs sont en mesure de le modifier.</translation>
<translation id="4541530620466526913">Comptes locaux de l'appareil</translation>
<translation id="5815129011704381141">Redémarrer automatiquement après une mise à jour</translation>
<translation id="1757688868319862958">Permet à <ph name="PRODUCT_NAME"/> d'exécuter les plug-ins qui nécessitent une autorisation. Si vous activez ce paramètre, les plug-ins non obsolètes sont toujours exécutés. Si ce paramètre est désactivé ou n'est pas configuré, les utilisateurs doivent donner leur permission pour l'exécution des plug-ins qui nécessitent une autorisation. Ceux-ci présentent un risque de sécurité.</translation>
<translation id="6392973646875039351">Active la fonction de saisie automatique de <ph name="PRODUCT_NAME"/> et permet aux utilisateurs de remplir automatiquement des formulaires Web à l'aide de données stockées précédemment, telles qu'une adresse ou des informations de carte de crédit. 

Si vous désactivez ce paramètre, la fonction de saisie automatique n'est pas accessible aux utilisateurs. 

Si vous activez ce paramètre ou ne définissez pas de valeur, la fonction de saisie automatique peut être contrôlée par les utilisateurs. Ces derniers peuvent ainsi configurer des profils de saisie automatique et activer ou désactiver la fonction de saisie automatique à leur guise.</translation>
<translation id="6157537876488211233">Liste de règles de contournement de proxy séparées par des virgules</translation>
<translation id="7788511847830146438">Par profil</translation>
<translation id="2516525961735516234">Indique si l'activité vidéo a une incidence sur la gestion de l'alimentation.

          Lorsque cette règle est définie sur &quot;True&quot; ou si elle n'est pas définie, l'utilisateur n'est pas considéré comme inactif pendant la lecture de la vidéo. Le délai d'inactivité, d'assombrissement, d'arrêt ou de verrouillage de l'écran ne peuvent donc pas être atteints et aucune des actions correspondantes n'est effectuée.

          Si cette règle est définie sur &quot;False&quot;, l'activité vidéo n'empêche pas l'utilisateur d'être considéré comme inactif.</translation>
<translation id="3965339130942650562">Délai avant exécution de la déconnexion de l'utilisateur en cas d'inactivité</translation>
<translation id="5814301096961727113">Définir l'état par défaut des commentaires audio sur l'écran de connexion</translation>
<translation id="9084985621503260744">Indiquer si l'activité vidéo a une incidence sur la gestion de l'alimentation</translation>
<translation id="7091198954851103976">Toujours exécuter les plug-ins qui nécessitent une autorisation</translation>
<translation id="1708496595873025510">Définir la restriction liée à la récupération de la valeur de départ des variantes</translation>
<translation id="8870318296973696995">Page d'accueil</translation>
<translation id="1240643596769627465">Spécifie l'URL du moteur de recherche utilisé pour fournir des résultats instantanés. L'URL doit contenir la chaîne <ph name="SEARCH_TERM_MARKER"/> qui sera remplacée au moment de la requête par le texte que l'utilisateur a saisi jusqu'ici. 

Cette règle est facultative. Si elle n'est pas configurée, aucun résultat de recherche instantanée n'est fourni. 

Cette règle n'est respectée que si la règle &quot;DefaultSearchProviderEnabled&quot; est activée.</translation>
<translation id="6693751878507293182">Si vous activez ce paramètre, la recherche et l'installation automatique des plug-ins manquants seront désactivées dans <ph name="PRODUCT_NAME"/>. 

Si vous désactivez cette option ou si vous ne la définissez pas, l'outil de recherche de plug-ins est activé.</translation>
<translation id="2650049181907741121">Action à effectuer lorsque l'utilisateur ferme le couvercle</translation>
<translation id="7880891067740158163">Permet de spécifier une liste de formats d'URL spécifiant les sites pour lesquels <ph name="PRODUCT_NAME"/> doit sélectionner automatiquement un certificat client, si le site demande un certificat. 

Si cette règle n'est pas configurée, aucune sélection automatique n'est effectuée pour aucun site.</translation>
<translation id="3866249974567520381">Description</translation>
<translation id="5192837635164433517">Permet l'utilisation de pages d'erreur alternatives qui sont intégrées à <ph name="PRODUCT_NAME"/> (comme &quot;page introuvable&quot;) et empêche les utilisateurs de modifier ce paramètre. 

Si vous activez ce paramètre, les pages d'erreur alternatives sont utilisées. 

Si vous le désactivez, les pages d'erreur alternatives ne sont jamais utilisées. 

Dans les deux cas, les utilisateurs ne peuvent pas modifier, ni remplacer ce paramètre dans <ph name="PRODUCT_NAME"/>. 

Si cette règle n'est pas configurée, ce paramètre est activé, mais l'utilisateur est en mesure de le modifier.</translation>
<translation id="2236488539271255289">Interdire à tous les sites de définir des données locales</translation>
<translation id="4467952432486360968">Bloquer les cookies tiers</translation>
<translation id="2041396837791669429">Bloquer l'accès aux sites en dehors des packs de contenu</translation>
<translation id="1305864769064309495">URL de mappage de dictionnaire vers un indicateur booléen indiquant si l'accès à l'hôte doit être autorisé (&quot;true&quot;) ou bloqué (&quot;false&quot;).

          Il s'agit d'une règle utilisée en interne par Chrome.</translation>
<translation id="5586942249556966598">Ne rien faire</translation>
<translation id="131353325527891113">Afficher les noms d'utilisateur sur l'écran de connexion</translation>
<translation id="5317965872570843334">Permet l'utilisation de serveurs STUN et relais lorsque les clients distants tentent d'établir une connexion à cette machine. 

Si ce paramètre est activé, alors les clients distants peuvent découvrir et se connecter à cette machine, même s'ils sont séparés par un pare-feu. 

Si ce paramètre est désactivé et si les connexions UDP sortantes sont filtrées par le pare-feu, alors cette machine autorise uniquement les connexions des machines clientes au sein du réseau local. 

Si cette règle n'est pas configurée, le paramètre est activé.</translation>
<translation id="5365946944967967336">Afficher le bouton Accueil sur la barre d'outils</translation>
<translation id="3709266154059827597">Configurer la liste noire d'installation des extensions</translation>
<translation id="8451988835943702790">Utiliser la page &quot;Nouvel onglet&quot; comme page d'accueil</translation>
<translation id="8469342921412620373">Permet l'utilisation d'un moteur de recherche par défaut. 

Si vous activez ce paramètre, une recherche par défaut est effectuée lorsque l'utilisateur saisit un texte autre qu'une URL dans l'Omnibox. 

Vous pouvez spécifier le moteur de recherche par défaut à utiliser en définissant le reste des règles de recherche par défaut. Si ces dernières ne sont pas configurées, l'utilisateur peut sélectionner le moteur par défaut.

Si vous désactivez ce paramètre, aucune recherche n'est effectuée lorsque l'utilisateur entre un texte autre qu'une URL dans l'Omnibox. 

Dans les deux cas, les utilisateurs ne peuvent pas le modifier, ni le remplacer dans <ph name="PRODUCT_NAME"/>. 

Si cette règle n'est pas configurée, le moteur de recherche par défaut est activé et l'utilisateur est en mesure de définir la liste des moteurs de recherche.</translation>
<translation id="4791031774429044540">Active la fonctionnalité d'accessibilité de grand curseur.

          Si vous définissez cette règle sur &quot;True&quot;, le grand curseur est activé en permanence.

          Si vous définissez cette règle sur &quot;False&quot;, il est toujours désactivé.

          Si vous définissez cette règle, les utilisateurs ne peuvent pas la modifier ni l'ignorer.

          Si vous ne définissez pas cette règle, le grand curseur est désactivé au départ, mais peut ensuite être activé à tout moment par les utilisateurs.</translation>
<translation id="2633084400146331575">Activer les commentaires audio</translation>
<translation id="7712008868843631413">Activer les utilisateurs supervisés</translation>
<translation id="8731693562790917685">L'option &quot;Paramètres de contenu&quot; permet d'indiquer la manière dont le contenu d'un type spécifique (par exemple, Cookies, Images ou JavaScript) est géré.</translation>
<translation id="2411919772666155530">Bloquer les notifications sur ces sites</translation>
<translation id="6923366716660828830">Indique le nom du moteur de recherche par défaut. Si cette règle n'est pas configurée, le nom d'hôte spécifié par l'URL de recherche est utilisé. 

Cette règle n'est prise en compte que si la règle &quot;DefaultSearchProviderEnabled&quot; est activée.</translation>
<translation id="4869787217450099946">Indique si les WakeLock forçant l'activation de l'écran sont autorisés. Ces WakeLock peuvent être demandés par des extensions par le biais de l'API d'extension de gestion de l'alimentation.

          Si cette règle est définie sur &quot;true&quot; ou si elle n'est pas définie, les WakeLock forçant l'activation de l'écran sont pris en compte pour la gestion de l'alimentation.

          Si cette règle est définie sur &quot;false&quot;, les demandes des WakeLock sont ignorées.</translation>
<translation id="467236746355332046">Fonctionnalités compatibles :</translation>
<translation id="7632724434767231364">Nom de la bibliothèque GSSAPI</translation>
<translation id="3038323923255997294">Poursuivre l'exécution des applications en arrière-plan après la fermeture de <ph name="PRODUCT_NAME"/></translation>
<translation id="4652284479838524692">Activer l'attestation à distance pour l'appareil</translation>
<translation id="8909280293285028130">Indiquer le délai d'inactivité au terme duquel l'écran est verrouillé en cas d'utilisation de l'alimentation secteur

                      Lorsque cette règle est définie sur une valeur supérieure à zéro, elle indique la durée pendant laquelle l'utilisateur doit rester inactif avant que <ph name="PRODUCT_OS_NAME"/> verrouille l'écran.

                      Si cette règle est définie sur zéro, <ph name="PRODUCT_OS_NAME"/> ne verrouille pas l'écran en cas d'inactivité.

                      Si cette règle n'est pas définie, une durée par défaut est utilisée.

                      Pour verrouiller l'écran en cas d'inactivité, il est recommandé d'activer le verrouillage de l'écran en cas d'arrêt et de paramétrer l'arrêt de <ph name="PRODUCT_OS_NAME"/> au terme du délai d'inactivité. Cette règle ne doit être utilisée que lorsque le verrouillage de l'écran n'est nécessaire qu'un certain laps de temps avant l'arrêt ou lorsque l'arrêt en cas d'inactivité n'est pas souhaité.

                      La valeur de cette règle doit être indiquée en millisecondes. Les valeurs doivent être inférieures au délai d'inactivité.</translation>
<translation id="7651739109954974365">Détermine si l'itinérance des données doit être activée pour l'appareil. Si cette règle est définie sur &quot;true&quot;, l'itinérance des données est autorisée. Si cette règle n'est pas configurée ou si elle est définie sur &quot;false&quot;, l'itinérance des données n'est pas possible.</translation>
<translation id="6244210204546589761">URL à ouvrir au démarrage</translation>
<translation id="7468416082528382842">Emplacement dans le registre Windows :</translation>
<translation id="1808715480127969042">Bloquer les cookies sur ces sites</translation>
<translation id="1908884158811109790">Désactive Google Drive sur les connexions mobiles dans l'application Fichiers de Chrome OS.</translation>
<translation id="7340034977315324840">Indiquer les périodes d'activité de l'appareil</translation>
<translation id="4928632305180102854">Permet de spécifier si <ph name="PRODUCT_OS_NAME"/> autorise la création de comptes utilisateur. Si cette règle est définie sur &quot;false&quot;, les utilisateurs qui n'ont pas de compte ne pourront pas se connecter.

       Si cette règle est définie sur &quot;true&quot; ou si elle n'est pas configurée, la création de comptes utilisateur est autorisée à condition que <ph name="DEVICEUSERWHITELISTPROTO_POLICY_NAME"/> n'empêche pas l'utilisateur de se connecter.</translation>
<translation id="4389091865841123886">Configurer l'attestation à distance avec le mécanisme TPM</translation>
<translation id="8256688113167012935">Définit quel nom de compte s'affiche sur l'écran de connexion de <ph name="PRODUCT_OS_NAME"/> pour le compte local de l'appareil correspondant.

      Si cette règle est définie, l'écran de connexion affiche la chaîne spécifiée dans le sélecteur de comptes reposant sur les images, pour le compte local de l'appareil correspondant.

      Si la règle n'est pas définie, le nom affiché sur l'écran de connexion de <ph name="PRODUCT_OS_NAME"/> correspond à l'identifiant de l'adresse e-mail utilisée pour le compte local de l'appareil.

      Cette règle est ignorée pour les comptes utilisateur classiques.</translation>
<translation id="267596348720209223">Spécifie les codages de caractères compatibles avec le moteur de recherche. Les codages sont des noms de page de code, comme UTF-8, GB2312 et ISO-8859-1. Ils sont testés dans l'ordre indiqué. 

Cette règle est facultative. Si elle n'est pas configurée, la valeur par défaut UTF-8 est utilisée. 

Cette règle n'est respectée que si la règle &quot;DefaultSearchProviderEnabled&quot; est activée.</translation>
<translation id="1349276916170108723">Désactive la synchronisation de Google Drive dans l'application Fichiers de Chrome OS lorsque ce paramètre est défini sur &quot;true&quot;. Dans ce cas, aucune donnée n'est transférée sur Google Drive.

          Si ce paramètre est défini sur &quot;false&quot;, ou s'il n'est pas défini, les utilisateurs ont la possibilité de transférer des fichiers sur Google Drive.</translation>
<translation id="1964634611280150550">Mode navigation privée désactivé</translation>
<translation id="5971128524642832825">Désactive Google Drive dans l'application Fichiers de Chrome OS.</translation>
<translation id="1847960418907100918">Spécifie les paramètres utilisés pour la recherche instantanée avec POST. Il s'agit de paires de noms et de valeurs séparées par une virgule. Si une valeur est équivalente à un paramètre modèle, comme &quot;{searchTerms}&quot; dans l'exemple ci-dessus, elle est remplacée par des termes de recherche réels.

          Cette règle est facultative. Si elle n'est pas définie, la requête de recherche instantanée sera envoyée à l'aide la méthode GET.

          Cette règle n'est respectée que si la règle &quot;DefaultSearchProviderEnabled&quot; est activée.</translation>
<translation id="1454846751303307294">Permet de définir une liste de formats d'URL spécifiant les sites qui ne sont pas autorisés à exécuter JavaScript. 

Si cette règle n'est pas configurée, la valeur par défaut globale sera utilisée pour tous les sites à partir de la règle &quot;DefaultJavaScriptSetting&quot;, si elle est définie, ou à défaut, à partir de la configuration personnelle de l'utilisateur.</translation>
<translation id="538108065117008131">Autoriser <ph name="PRODUCT_FRAME_NAME"/> à gérer les types de contenus suivants.</translation>
<translation id="2312134445771258233">Vous permet de configurer les pages chargées au démarrage.

      Le contenu de la liste &quot;URL à ouvrir au démarrage&quot; est ignoré, sauf si vous sélectionnez &quot;Ouvrir les pages suivantes&quot; dans &quot;Action au démarrage&quot;.</translation>
<translation id="243972079416668391">Définit l'action à effectuer lorsque le délai d'inactivité est atteint en cas de fonctionnement de l'appareil sur une source d'alimentation CA.

          Lorsque la règle est définie, elle indique l'action à effectuer sous <ph name="PRODUCT_OS_NAME"/> lorsque l'utilisateur reste inactif au-delà du délai d'inactivité, qui peut être configuré séparément.

          Lorsque cette règle n'est pas définie, l'action par défaut est appliquée, soit la mise en veille.

          Si l'action est la mise en veille, <ph name="PRODUCT_OS_NAME"/> peut être configuré séparément pour que l'écran soit verrouillé ou non avant la mise en veille.</translation>
<translation id="7750991880413385988">Ouvrir la page Nouvel onglet</translation>
<translation id="741903087521737762">Permet de définir le comportement du navigateur au démarrage.

          Si vous sélectionnez l'option &quot;Ouvrir la page Nouvel onglet&quot;, celle-ci s'affiche à chaque fois que vous lancez <ph name="PRODUCT_NAME"/>.

          Si vous sélectionnez l'option &quot;Restaurer la dernière session&quot;, les pages restées ouvertes lorsque <ph name="PRODUCT_NAME"/> a été fermé pour la dernière fois s'affichent de nouveau. La session de navigation est restaurée telle que vous l'avez laissée.
          La sélection de cette option entraîne la désactivation de certains paramètres basés sur les sessions de navigation ou qui effectuent des actions lors de la fermeture du navigateur (telles que la suppression des données de navigation ou des cookies d'une session).

          Si vous sélectionnez l'option &quot;Ouvrir les pages suivantes&quot;, les pages à charger au démarrage s'ouvrent lorsque utilisateur lance <ph name="PRODUCT_NAME"/>.

          Si vous activez ce paramètre, les utilisateurs ne pourront pas le modifier ni le remplacer dans <ph name="PRODUCT_NAME"/>.

          La désactivation de ce paramètre équivaut à ne pas le configurer. L'utilisateur pourra toujours le modifier dans <ph name="PRODUCT_NAME"/>.</translation>
<translation id="8161570238552664224">Autoriser la lecture audio

      Lorsque cette règle est définie sur &quot;False&quot;, la sortie audio n'est pas disponible sur l'appareil tant que l'utilisateur est connecté.

      Cette règle s'applique à tous les types de sortie audio et pas seulement aux haut-parleurs intégrés. Elle désactive également les fonctionnalités d'accessibilité audio. Veuillez ne pas activer cette règle si l'utilisateur a besoin d'utiliser un lecteur d'écran.

      Si ce paramètre est défini sur &quot;True&quot; ou s'il n'est pas configuré, les utilisateurs peuvent se servir de toutes les sorties audio compatibles sur leur appareil.</translation>
<translation id="5761030451068906335">Configurer les paramètres de proxy pour <ph name="PRODUCT_NAME"/>. Cette règle n'est pas encore prête, veuillez donc ne pas l'utiliser pour le moment.</translation>
<translation id="3006443857675504368">Permet d'afficher les options d'accessibilité de <ph name="PRODUCT_OS_NAME"/> dans le menu système.

          Si cette règle est définie sur &quot;True&quot;, les options d'accessibilité s'affichent toujours dans le menu de la barre système.

          Si elle est définie sur &quot;False&quot;, les options d'accessibilité ne s'affichent jamais dans le menu de la barre système.

          Si vous définissez cette règle, les utilisateurs ne peuvent pas la modifier ni la remplacer.

          Si vous ne la définissez pas, les options d'accessibilité ne s'affichent pas dans le menu de la barre système, mais l'utilisateur peut en activer l'affichage via la page &quot;Paramètres&quot;.</translation>
<translation id="8344454543174932833">Importer les favoris du navigateur par défaut à la première exécution</translation>
<translation id="1019101089073227242">Définir le répertoire de données utilisateur</translation>
<translation id="5826047473100157858">Indique si l'utilisateur peut ouvrir des pages en mode navigation privée dans <ph name="PRODUCT_NAME"/>. 

Si l'option &quot;Activé&quot; est sélectionnée ou si la règle n'est pas configurée, les pages peuvent être ouvertes en mode navigation privée. 

Si l'option &quot;Désactivé&quot; est sélectionnée, les pages ne peuvent pas être ouvertes en mode navigation privée. 

Si l'option &quot;Forcé&quot; est sélectionnée, les pages peuvent être ouvertes UNIQUEMENT en mode navigation privée.</translation>
<translation id="2988031052053447965">Masque l'application Chrome Web Store et le lien de bas de page sur la page Nouvel onglet et dans le lanceur d'applications de Chrome OS.

      Lorsque cette règle est définie sur &quot;True&quot;, les icônes sont masquées.

      Lorsque cette règle est définie sur &quot;False&quot; ou si elle n'est pas configurée, les icônes sont visibles.</translation>
<translation id="8401282319420373133">Extensions autorisées à utiliser l'API d'attestation à distance</translation>
<translation id="5085647276663819155">Désactiver l'aperçu avant impression</translation>
<translation id="8672321184841719703">Cibler une version pour les mises à jour automatiques</translation>
<translation id="1689963000958717134">Permet de transférer l'application de la configuration réseau à tous les utilisateurs d'un appareil fonctionnant avec <ph name="PRODUCT_OS_NAME"/>. La configuration réseau correspond à une chaîne formatée par JSON conformément au format de configuration de réseau ouvert, décrit à l'adresse <ph name="ONC_SPEC_URL"/>.</translation>
<translation id="6699880231565102694">Activer l'authentification forte pour les hôtes d'accès à distance</translation>
<translation id="2030905906517501646">Mot clé du moteur de recherche par défaut</translation>
<translation id="3072045631333522102">Economiseur d'écran à utiliser sur l'écran de connexion en mode Point de vente</translation>
<translation id="4550478922814283243">Activer ou désactiver l'authentification sans code d'accès</translation>
<translation id="7712109699186360774">Demander chaque fois qu'un site essaie d'accéder à la caméra et/ou au microphone</translation>
<translation id="350797926066071931">Activer Google Traduction</translation>
<translation id="3711895659073496551">Arrêter</translation>
<translation id="4010738624545340900">Autoriser l'appel des boîtes de dialogue de sélection de fichiers</translation>
<translation id="4518251772179446575">Demander chaque fois qu'un site veut suivre la position géographique des utilisateurs</translation>
<translation id="402759845255257575">Interdire à tous les sites d'exécuter JavaScript</translation>
<translation id="5457924070961220141">Permet de configurer le moteur de rendu HTML par défaut lorsque <ph name="PRODUCT_FRAME_NAME"/> est installé. 

Lorsque cette règle n'est pas configurée, le paramètre par défaut utilisé consiste à permettre au navigateur d'accueil d'effectuer le rendu. Mais vous avez la possibilité de remplacer ce paramètre et de demander que les pages HTML soient affichées par <ph name="PRODUCT_FRAME_NAME"/> par défaut.</translation>
<translation id="706669471845501145">Autoriser les sites à afficher des notifications sur le bureau</translation>
<translation id="7529144158022474049">Facteur de dispersion des mises à jour automatiques</translation>
<translation id="2188979373208322108">Active la barre des favoris sur <ph name="PRODUCT_NAME"/>. 

Si vous activez ce paramètre, <ph name="PRODUCT_NAME"/> affiche une barre de favoris. 

Si vous le désactivez, les utilisateurs ne verront jamais la barre des favoris. 

Dans les deux cas, les utilisateurs ne peuvent pas le modifier, ni le remplacer dans <ph name="PRODUCT_NAME"/>. 

Si ce paramètre n'est pas défini, l'utilisateur peut décider d'utiliser cette fonction ou non.</translation>
<translation id="5475361623548884387">Activer l'impression</translation>
<translation id="7287359148642300270">Indique les serveurs autorisés pour l'authentification intégrée. L'authentification intégrée ne s'active que lorsque <ph name="PRODUCT_NAME"/> reçoit une demande d'authentification d'un proxy ou d'un serveur faisant partie de la liste blanche.

          Si vous utilisez plusieurs serveurs, séparez leur nom par une virgule. Les caractères génériques (*) sont autorisés.

          Si vous ne définissez pas cette règle, Google Chrome tente d'identifier si le serveur est sur l'Intranet, auquel cas il répond aux requêtes IWA. Si le serveur est sur Internet, les requêtes IWA sont ignorées par Google Chrome.</translation>
<translation id="3653237928288822292">Icône du moteur de recherche par défaut</translation>
<translation id="2872961005593481000">Éteindre</translation>
<translation id="4445684791305970001">Désactive les outils de développement et la console JavaScript. 

Si vous activez ce paramètre, les outils de développement ne sont plus accessibles et les éléments du site Web ne peuvent plus être  inspectés. Tous les raccourcis clavier et toutes les entrées de menu ou de menu contextuel permettant d'ouvrir les outils de développement ou la console JavaScript sont désactivés. 

Si vous désactivez cette option ou si vous ne la configurez pas, l'utilisateur peut utiliser les outils de développement et la console JavaScript.</translation>
<translation id="9203071022800375458">Désactive les captures d'écran.

      En cas d'activation de cette règle, il n'est pas possible d'utiliser des raccourcis clavier ou des API d'extension pour effectuer des captures d'écran.

      En cas de désactivation ou de non-configuration de cette règle, les captures d'écran sont autorisées.</translation>
<translation id="4632343302005518762">Autoriser <ph name="PRODUCT_FRAME_NAME"/> à gérer les types de contenu répertoriés</translation>
<translation id="13356285923490863">Nom de stratégie</translation>
<translation id="557658534286111200">Active ou désactive la modification des favoris</translation>
<translation id="5378985487213287085">Permet de définir si les sites Web sont autorisés à afficher des notifications de bureau. L'affichage des notifications de bureau peut être autorisé par défaut, refusé par défaut, ou l'utilisateur peut recevoir un message chaque fois qu'un site veut afficher des notifications de bureau. 

Si cette règle n'est pas configurée, le paramètre &quot;AskNotifications&quot; est utilisé et l'utilisateur est en mesure de le modifier.</translation>
<translation id="2386362615870139244">Autoriser les WakeLock forçant l'activation de l'écran</translation>
<translation id="6908640907898649429">Configure le moteur de recherche par défaut. Vous pouvez définir le moteur de recherche par défaut dont se servira l'utilisateur ou choisir de désactiver le moteur de recherche par défaut.</translation>
<translation id="6544897973797372144">Si cette règle est définie sur &quot;True&quot;, et si la règle ChromeOsReleaseChannel n'est pas spécifiée, les utilisateurs du domaine correspondant sont autorisés à modifier la version de l'appareil. Si elle est définie sur &quot;False&quot;, l'appareil est verrouillé sur la dernière version configurée.

      La règle ChromeOsReleaseChannel prévaut sur la version sélectionnée par l'utilisateur. Toutefois, si cette dernière est plus stable que la version installée sur l'appareil, elle n'est remplacée qu'une fois que la version la plus stable atteint un numéro supérieur à celui de la version installée sur l'appareil.</translation>
<translation id="389421284571827139">Permet de spécifier le serveur proxy utilisé par <ph name="PRODUCT_NAME"/> et empêche les utilisateurs de modifier les paramètres du proxy. 

Si vous choisissez de ne jamais utiliser de serveur proxy et de toujours vous connecter directement, toutes les autres options sont ignorées. 

Si vous choisissez de détecter automatiquement le serveur proxy, toutes les autres options sont ignorées. 

Pour des exemples détaillés, accédez au site : 
<ph name="PROXY_HELP_URL"/> 

Si vous activez ce paramètre, <ph name="PRODUCT_NAME"/> ignore toutes les options liées au proxy spécifiées à partir de la ligne de commande. 

Le fait de ne pas définir ces règles permet aux utilisateurs de sélectionner eux-mêmes les paramètres du proxy.</translation>
<translation id="681446116407619279">Modèles d'authentification compatibles</translation>
<translation id="4027608872760987929">Activer le moteur de recherche par défaut</translation>
<translation id="2223598546285729819">Paramètre de notification par défaut</translation>
<translation id="6158324314836466367">Nom de boutique en ligne d'entreprise (abandonné)</translation>
<translation id="3984028218719007910">Détermine si <ph name="PRODUCT_OS_NAME"/> doit conserver les données locales des comptes après la déconnexion. Si cette règle est définie sur &quot;true&quot;, aucun compte persistant n'est conservé par <ph name="PRODUCT_OS_NAME"/>. Par ailleurs, toutes les données de la session utilisateur sont supprimées après la déconnexion. Si cette règle est définie sur &quot;false&quot; ou si elle n'est pas configurée, l'appareil peut conserver des données utilisateur locales (chiffrées).</translation>
<translation id="3793095274466276777">Configure les vérifications du navigateur par défaut dans <ph name="PRODUCT_NAME"/> et empêche les utilisateurs de les modifier.

      Si vous activez ce paramètre, <ph name="PRODUCT_NAME"/> vérifiera toujours au démarrage s'il s'agit du navigateur par défaut et s'enregistrera automatiquement si possible.

      Si ce paramètre est désactivé, <ph name="PRODUCT_NAME"/> ne vérifiera jamais s'il s'agit du navigateur par défaut et désactivera les contrôles utilisateur pour définir cette option.

      Si ce paramètre n'est pas défini, <ph name="PRODUCT_NAME"/> autorisera l'utilisateur à déterminer s'il s'agit du navigateur par défaut et si des notifications aux utilisateurs doivent être affichées dans le cas contraire.</translation>
<translation id="3504791027627803580">Spécifie l'URL du moteur de recherche utilisé pour la recherche d'image. Les requêtes de recherche seront envoyées à l'aide la méthode GET. Si la règle &quot;DefaultSearchProviderImageURLPostParams&quot; est activée, elles seront envoyées à l'aide la méthode POST à la place de GET.

          Cette règle est facultative. Si elle n'est pas définie, aucune recherche d'image ne sera utilisée.

          Cette règle n'est respectée que si la règle &quot;DefaultSearchProviderEnabled&quot; est activée.</translation>
<translation id="7529100000224450960">Permet de définir une liste de formats d'URL spécifiant les sites qui sont autorisés à ouvrir des pop-ups. 

Si cette règle n'est pas configurée, la valeur par défaut globale sera utilisée pour tous les sites à partir de la règle &quot;DefaultPopupsSetting&quot;, si elle est définie, ou à défaut, à partir de la configuration personnelle de l'utilisateur.</translation>
<translation id="6155936611791017817">Définir l'état par défaut du grand curseur sur l'écran de connexion</translation>
<translation id="1530812829012954197">Toujours rendre les formats d'URL suivants dans le navigateur hôte</translation>
<translation id="9026000212339701596">Dictionnaire qui mappe les noms d'hôte vers un indicateur booléen qui détermine si l'accès à l'hôte est autorisé (&quot;true&quot;) ou bloqué (&quot;false&quot;).

          Il s'agit d'une règle utilisée en interne par Chrome.</translation>
<translation id="913195841488580904">Bloquer l'accès à une liste d'URL</translation>
<translation id="3292147213643666827">Permet à <ph name="PRODUCT_NAME"/> de faire office de proxy entre <ph name="CLOUD_PRINT_NAME"/> et les imprimantes existantes connectées à la machine.

      Si ce paramètre est activé ou s'il n'est pas configuré, l'utilisateur peut activer le proxy d'impression sur le cloud en se connectant à son compte Google.

      Si ce paramètre est désactivé, l'utilisateur ne peut pas activer le proxy et la machine n'est pas autorisée à partager ses imprimantes avec <ph name="CLOUD_PRINT_NAME"/>.</translation>
<translation id="6373222873250380826">Désactive les mises à jour automatiques lorsque cette règle est définie sur &quot;true&quot;.

       Les appareils <ph name="PRODUCT_OS_NAME"/> recherchent automatiquement les mises à jour lorsque ce paramètre n'est pas configuré ou lorsqu'il est défini sur &quot;false&quot;.</translation>
<translation id="6190022522129724693">Paramètre de fenêtres pop-up par défaut</translation>
<translation id="847472800012384958">Interdire à tous les sites d'afficher des fenêtres pop-up</translation>
<translation id="4733471537137819387">Stratégies liées à l'authentification HTTP intégrée</translation>
<translation id="8951350807133946005">Définir le répertoire du cache disque</translation>
<translation id="603410445099326293">Paramètres pour l'URL de suggestion utilisant POST</translation>
<translation id="2592091433672667839">Durée d'inactivité préalable à l'affichage de l'économiseur d'écran sur l'écran de connexion en mode Point de vente</translation>
<translation id="166427968280387991">Serveur proxy</translation>
<translation id="2805707493867224476">Autoriser tous les sites à afficher des fenêtres pop-up</translation>
<translation id="1727394138581151779">Bloquer tous les plug-ins</translation>
<translation id="8118665053362250806">Définir la taille du cache disque de support</translation>
<translation id="7079519252486108041">Bloquer les fenêtres pop-up sur ces sites</translation>
<translation id="1859633270756049523">Limiter la durée de la session</translation>
<translation id="7433714841194914373">Activer la recherche instantanée</translation>
<translation id="4983201894483989687">Autoriser l'exécution de plug-ins obsolètes</translation>
<translation id="443665821428652897">Effacer les données de sites à la fermeture du navigateur (obsolète)</translation>
<translation id="3823029528410252878">Désactive l'enregistrement de l'historique de navigation dans <ph name="PRODUCT_NAME"/> et empêche les utilisateurs de modifier ce paramètre. 

Si ce paramètre est activé, l'historique de navigation n'est pas enregistré. 

S'il est désactivé ou s'il n'est pas configuré, l'historique de navigation est enregistré.</translation>
<translation id="3844092002200215574">Configure le répertoire que <ph name="PRODUCT_NAME"/> utilise pour stocker les fichiers mis en cache sur le disque.

      Si vous définissez cette règle, <ph name="PRODUCT_NAME"/> utilise le répertoire fourni, que l'utilisateur ait spécifié l'indicateur &quot;--disk-cache-dir&quot; ou non.

      Consultez une liste des variables utilisables à l'adresse http://www.chromium.org/administrators/policy-list-3/user-data-directory-variables.

      Si vous ne définissez pas cette règle, le répertoire de cache par défaut est utilisé et l'utilisateur est en mesure de le remplacer à l'aide de l'indicateur de ligne de commande &quot;--disk-cache-dir&quot;.</translation>
<translation id="3034580675120919256">Permet de définir si les sites Web sont autorisés à exécuter JavaScript. L'exécution de JavaScript peut être soit autorisée pour tous les sites, soit refusée pour tous les sites. 

Si cette règle n'est pas configurée, le paramètre &quot;AllowJavaScript&quot; est utilisé et l'utilisateur est en mesure de le modifier.</translation>
<translation id="193900697589383153">Ajoute un bouton de déconnexion dans la barre d'état système.

      Si l'option est activée, un gros bouton rouge de déconnexion s'affiche dans la barre d'état système pendant que la session est active et que l'écran n'est pas verrouillé.

      Si l'option est désactivée ou si elle n'est pas configurée, aucun gros bouton rouge de déconnexion ne s'affiche dans la barre d'état système.</translation>
<translation id="5111573778467334951">Définit l'action à effectuer lorsque le délai d'inactivité est atteint en cas de fonctionnement de l'appareil sur batterie

          Lorsque la règle est définie, elle indique l'action à effectuer sous <ph name="PRODUCT_OS_NAME"/> lorsque l'utilisateur reste inactif au-delà du délai d'inactivité, qui peut être configuré séparément.


          Lorsque cette règle n'est pas définie, l'action par défaut est appliquée, soit la mise en veille.


          Si la mesure est la mise en veille, <ph name="PRODUCT_OS_NAME"/> peut être configuré séparément pour que l'écran soit verrouillé ou non avant la mise en veille.</translation>
<translation id="3195451902035818945">Indiquer si le fractionnement des enregistrements SSL doit être désactivé. Le fractionnement des enregistrements est une solution de contournement appliquée en raison d'une vulnérabilité des protocoles SSL 3.0 et TLS 1.0. Il peut toutefois entraîner des problèmes de compatibilité avec certains serveurs et proxys HTTPS. Si la règle n'est pas définie, ou si elle est définie sur &quot;False&quot;, le fractionnement des enregistrements sera utilisé pour les connexions SSL/TLS qui utilisent les suites de chiffrement CBC.</translation>
<translation id="6903814433019432303">Cette politique n'est active qu'en mode Point de vente.

       Détermine l'ensemble d'URL à charger au démarrage de la session de démonstration. Cette règle remplace tout autre mécanisme de définition de l'URL initiale et ne peut dès lors être appliquée qu'à une session non associée à un utilisateur particulier.</translation>
<translation id="5868414965372171132">Configuration réseau au niveau de l'utilisateur</translation>
<translation id="8519264904050090490">URL d'exception manuelle des utilisateurs gérés</translation>
<translation id="4480694116501920047">Forcer SafeSearch</translation>
<translation id="465099050592230505">URL de boutique en ligne d'entreprise (abandonné)</translation>
<translation id="1221359380862872747">Charger les URL spécifiées lors de la connexion à la démonstration</translation>
<translation id="2431811512983100641">Détermine si l'extension des certificats TLS liés à des domaines doit être activée.

       Ce paramètre est utilisé pour activer l'extension des certificats TLS liés à des domaines afin de les tester. Comme il est expérimental, il sera supprimé ultérieurement.</translation>
<translation id="8711086062295757690">Indique le mot clé qui est le raccourci utilisé dans l'Omnibox pour déclencher la recherche de ce moteur.

Cette règle est facultative. Si elle n'est pas configurée, aucun mot clé n'active le moteur de recherche. 

Cette règle n'est prise en compte que si la règle &quot;DefaultSearchProviderEnabled&quot; est activée.</translation>
<translation id="5774856474228476867">URL de recherche du moteur de recherche par défaut</translation>
<translation id="4650759511838826572">Désactiver les schémas de protocole d'URL</translation>
<translation id="7831595031698917016">Spécifie le délai maximal en millisecondes entre la réception du rejet d'une règle et la récupération de la nouvelle règle auprès du service de gestion de l'appareil.

      La définition de cette règle remplace la valeur par défaut de 5 000 millisecondes. Les valeurs valides pour cette règle sont comprises entre 1 000 millisecondes (1 seconde) et 300 000 millisecondes (5 minutes). Toute valeur se situant hors de cette plage sera rapportée à la valeur limite la plus proche.

      En l'absence de définition de cette règle, la valeur par défaut de 5 000 millisecondes est utilisée dans <ph name="PRODUCT_NAME"/>.</translation>
<translation id="8099880303030573137">Délai d'inactivité (batterie)</translation>
<translation id="2761483219396643566">Délai d'inactivité avant l'affichage d'un avertissement (en cas d'utilisation de la batterie)</translation>
<translation id="1468307069016535757">Définit l'état par défaut de la fonctionnalité d'accessibilité du mode Contraste élevé sur l'écran de connexion.

          Si vous définissez cette règle sur &quot;True&quot;, le mode Contraste élevé est activé à l'affichage de l'écran de connexion.

          Si vous définissez cette règle sur &quot;False&quot;, il est désactivé à l'affichage de l'écran de connexion.

          Si vous définissez cette règle, les utilisateurs peuvent l'ignorer temporairement en activant ou en désactivant le mode Contraste élevé. Toutefois, cette option n'est pas définitive, et la valeur par défaut est restaurée dès que l'écran de connexion est affiché de nouveau ou que l'utilisateur reste inactif pendant une minute sur l'écran de connexion.

          Si vous ne définissez pas cette règle, le mode Contraste élevé est désactivé au premier affichage de l'écran de connexion. Les utilisateurs peuvent l'activer ou le désactiver à tout moment, et son état sur l'écran de connexion est appliqué à tous les utilisateurs.</translation>
<translation id="8580857153747395000">Prévenir lors de la consultation de sites en dehors des packs de contenu</translation>
<translation id="350796261613621561">Autoriser la création de comptes utilisateur supervisés</translation>
<translation id="602728333950205286">URL de recherche instantanée du moteur de recherche par défaut</translation>
<translation id="3030000825273123558">Activer la génération de rapports sur les statistiques</translation>
<translation id="8465065632133292531">Paramètres pour l'URL instantanée utilisant POST</translation>
<translation id="6559057113164934677">Interdire à tous les sites d'accéder à la caméra et au microphone</translation>
<translation id="7273823081800296768">Si ce paramètre est activé ou qu'il n'est pas configuré, les utilisateurs peuvent alors choisir d'associer les clients et les hôtes au moment de la connexion, ce qui permet d'éliminer la nécessité de saisir systématiquement un code d'accès.

          S'il est désactivé, cette fonctionnalité est alors indisponible.</translation>
<translation id="1675002386741412210">Compatible avec :</translation>
<translation id="3547954654003013442">Paramètres de proxy</translation>
<translation id="4482640907922304445">Affiche le bouton &quot;Accueil&quot; sur la barre d'outils <ph name="PRODUCT_NAME"/>. 

Si vous activez ce paramètre, le bouton &quot;Accueil&quot; est toujours affiché. 

Si vous le désactivez, le bouton &quot;Accueil&quot; ne s'affiche jamais. 

Dans les deux cas, les utilisateurs ne peuvent pas le modifier, ni le remplacer dans <ph name="PRODUCT_NAME"/>. 

Si cette règle n'est pas configurée, l'utilisateur peut décider d'afficher ou non le bouton &quot;Accueil&quot;.</translation>
<translation id="6897718480289510689">Autoriser l'accès aux sites en dehors des packs de contenu</translation>
<translation id="2518231489509538392">Autoriser la lecture audio</translation>
<translation id="7301543427086558500">Spécifie une liste d'URL alternatives pouvant être utilisées pour extraire des termes de recherche du moteur de recherche. Les URL doivent contenir la chaîne &quot;<ph name="SEARCH_TERM_MARKER"/>&quot;, qui est utilisée pour extraire les termes de recherche.

          Cette règle est facultative. Si vous ne la définissez pas, aucune URL alternative n'est utilisée pour extraire les termes de recherche.

          Cette règle n'est respectée que si la règle &quot;DefaultSearchProviderEnabled&quot; est activée.</translation>
<translation id="436581050240847513">Générer un rapport sur les interfaces réseau de l'appareil</translation>
<translation id="6282799760374509080">Autoriser ou interdire la capture audio</translation>
<translation id="8864975621965365890">Supprime l'invite de fermeture qui s'affiche lors du rendu d'un site par <ph name="PRODUCT_FRAME_NAME"/>.</translation>
<translation id="3264793472749429012">Codages du moteur de recherche par défaut</translation>
<translation id="285480231336205327">Activer le mode Contraste élevé</translation>
<translation id="5366977351895725771">Si cette règle est associée à la valeur &quot;false&quot;, la création de comptes utilisateur supervisés par cet utilisateur est désactivée. Les utilisateurs supervisés existants restent disponibles.

          Si elle est associée à la valeur &quot;true&quot; ou si elle n'est pas configurée, cet utilisateur peut créer et gérer des comptes utilisateur supervisés.</translation>
<translation id="8101760444435022591">Étant donné que les contrôles de révocation en ligne, parfois sujets à erreur, ne présentent aucun avantage concret en termes de sécurité, ils sont désactivés par défaut dans les versions 19 et ultérieures de <ph name="PRODUCT_NAME"/>. L'activation de cette règle restaure le comportement précédent. Des contrôles OCSP/CRL sont alors effectués.

       Si cette règle n'est pas définie ou si elle est définie sur &quot;false&quot;, Google Chrome n'effectue aucun contrôle de révocation en ligne dans les versions 19 et ultérieures.</translation>
<translation id="5469484020713359236">Permet de définir une liste de formats d'URL spécifiant les sites qui sont autorisés à définir des cookies. 

Si cette règle n'est pas configurée, la valeur par défaut globale sera utilisée pour tous les sites à partir de la règle &quot;DefaultCookiesSetting&quot;, si elle est définie, ou à défaut, à partir de la configuration personnelle de l'utilisateur.</translation>
<translation id="1504431521196476721">Attestation à distance</translation>
<translation id="1881299719020653447">Masquer le Chrome Web Store sur la page Nouvel onglet et dans le lanceur d'applications</translation>
<translation id="930930237275114205">Définir le répertoire de données utilisateur de <ph name="PRODUCT_FRAME_NAME"/></translation>
<translation id="244317009688098048">Activer le raccourci clavier permettant d'ignorer le processus de connexion automatique

      Si cette règle n'est pas définie, ou si elle est définie sur &quot;true&quot;, et qu'un compte local de l'appareil est configuré pour une connexion automatique sans délai d'expiration, le raccourci clavier Ctrl + Alt + S est pris en compte dans <ph name="PRODUCT_OS_NAME"/> pour ignorer la connexion automatique et afficher l'écran de connexion.

      Si cette règle est définie sur &quot;false&quot;, la connexion automatique sans délai d'expiration (si elle est configurée) ne peut pas être ignorée.</translation>
<translation id="5208240613060747912">Permet de définir une liste de formats d'URL spécifiant les sites qui ne sont pas autorisés à afficher des notifications. 

Si cette règle n'est pas configurée, la valeur par défaut globale sera utilisée pour tous les sites à partir de la règle &quot;DefaultNotificationsSetting&quot;, si elle est définie, ou à défaut, à partir de la configuration personnelle de l'utilisateur.</translation>
<translation id="7927140259706020912">URL autorisées à accéder aux appareils de capture audio sans avis préalable</translation>
<translation id="4600786265870346112">Activer le grand curseur</translation>
<translation id="8592105098257899882">Configure la taille du cache que <ph name="PRODUCT_NAME"/> va utiliser pour stocker les fichiers mis en cache sur le disque. 

Si vous définissez cette règle, <ph name="PRODUCT_NAME"/> utilise la taille du cache indiquée, que l'utilisateur ait ou non spécifié l'indicateur &quot;–disk–cache–size&quot;. 

Si cette règle est définie sur 0, la taille du cache par défaut est utilisée, mais l'utilisateur n'est pas en mesure de la modifier. 

Si cette règle n'est pas configurée, la taille par défaut est utilisée et l'utilisateur est en mesure de la remplacer à l'aide de l'indicateur &quot;–disk–cache–size&quot;.</translation>
<translation id="5887414688706570295">Configure le préfixe TalkGadget utilisé par les hôtes d'accès à distance et empêche les utilisateurs de le modifier.

          S'il est défini, ce préfixe est ajouté au nom TalkGadget de base afin de créer un nom de domaine TalkGadget complet. Le nom de domaine TalkGadget de base est &quot;.talkgadget.google.com&quot;.

          En cas d'activation de ce paramètre, les hôtes utilisent le nom de domaine personnalisé, et non le nom de domaine par défaut, lorsqu'ils accèdent à TalkGadget.

          En cas de désactivation ou de non-configuration de ce paramètre, le nom de domaine TalkGadget par défaut (&quot;chromoting-host.talkgadget.google.com&quot;) est utilisé pour tous les hôtes.

          Les clients d'accès à distance ne sont pas concernés par la configuration de cette règle. Ils utilisent toujours &quot;chromoting-client.talkgadget.google.com&quot; pour accéder à TalkGadget.</translation>
<translation id="5765780083710877561">Description :</translation>
<translation id="6915442654606973733">Active la fonctionnalité d'accessibilité de commentaires audio.

          Si vous définissez cette règle sur &quot;True&quot;, la fonctionnalité de commentaires audio est activée en permanence.

          Si vous définissez cette règle sur &quot;False&quot;, elle est toujours désactivée.

          Si vous définissez cette règle, les utilisateurs ne peuvent pas la modifier ni l'ignorer.

          Si vous ne définissez pas cette règle, la fonctionnalité de commentaires audio est désactivée au départ, mais peut ensuite être activée à tout moment par les utilisateurs.</translation>
<translation id="7796141075993499320">Permet de définir une liste de formats d'URL spécifiant les sites qui sont autorisés à exécuter des plug-ins. 

Si cette règle n'est pas configurée, la valeur par défaut globale est utilisée pour tous les sites à partir de la règle &quot;DefaultPluginsSetting&quot;, si elle est définie, ou à défaut, à partir de la configuration personnelle de l'utilisateur.</translation>
<translation id="3809527282695568696">Si l'option &quot;Ouvrir une liste d'URL&quot; est sélectionnée comme action de démarrage, vous pouvez spécifier la liste des URL qui sont ouvertes. Si cette règle n'est pas configurée, aucune URL ne sera ouverte au démarrage. 

Cette règle ne fonctionne que si la règle &quot;RestoreOnStartup&quot; est définie sur &quot;RestoreOnStartupIsURLs&quot;.</translation>
<translation id="649418342108050703">Désactive la disponibilité des API de graphisme 3D. 

Lorsque ce paramètre est activé, les pages Web ne peuvent pas accéder au processeur graphique (GPU). Plus précisément, les pages Web ne peuvent pas accéder à l'API WebGL et les plug-ins ne peuvent pas utiliser l'API Pepper 3D. 

Si vous désactivez ce paramètre ou si vous omettez de le configurer, les pages Web peuvent utiliser l'API WebGL et les plug-ins ont accès à l'API Pepper 3D. La transmission d'arguments de ligne de commande aux paramètres par défaut du navigateur peut toutefois être nécessaire pour utiliser ces API.</translation>
<translation id="2077273864382355561">Délai d'arrêt de l'écran (batterie)</translation>
<translation id="909184783177222836">Gestion de l'alimentation</translation>
<translation id="3417418267404583991">Si cette règle est définie sur &quot;true&quot; ou si elle n'est pas configurée, <ph name="PRODUCT_OS_NAME"/> autorise les connexions en mode invité. Les connexions en mode invité correspondent à des sessions utilisateur anonymes et ne nécessitent pas de mot de passe.

       Si cette règle est définie sur &quot;false&quot;, <ph name="PRODUCT_OS_NAME"/> n'autorise pas les sessions en mode invité.</translation>
<translation id="8329984337216493753">Cette règle n'est active qu'en mode Point de vente.

       Lorsque la valeur &quot;DeviceIdleLogoutTimeout&quot; est spécifiée, cette règle définit la durée de la boîte d'avertissement avec un compte à rebours qui s'affiche avant l'exécution de la déconnexion.

       La valeur de cette règle est définie en millisecondes.</translation>
<translation id="237494535617297575">Permet de définir une liste de formats d'URL spécifiant les sites qui sont autorisés à afficher des notifications. 

Si cette règle n'est pas configurée, la valeur par défaut globale sera utilisée pour tous les sites à partir de la règle &quot;DefaultNotificationsSetting&quot;, si elle est définie, ou à défaut, à partir de la configuration personnelle de l'utilisateur.</translation>
<translation id="7258823566580374486">Activer la protection des hôtes d'accès à distance</translation>
<translation id="5560039246134246593">Permet d'ajouter un paramètre à la récupération de la valeur de départ des variantes dans <ph name="PRODUCT_NAME"/>.

      Si cette règle est spécifiée, un paramètre de requête &quot;restrict&quot; est ajouté à l'URL utilisée pour récupérer la valeur de départ des variantes. La valeur de ce paramètre correspond à la valeur définie dans cette règle.

      Si elle n'est pas spécifiée, l'URL utilisée pour récupérer la valeur de départ des variantes n'est pas modifiée.</translation>
<translation id="944817693306670849">Définir la taille du cache disque</translation>
<translation id="8544375438507658205">Moteur de rendu HTML par défaut pour <ph name="PRODUCT_FRAME_NAME"/></translation>
<translation id="2371309782685318247">Indique la fréquence en millisecondes à laquelle le service de gestion des appareils est interrogé sur les informations concernant les règles utilisateur. 

       La définition de cette règle remplace la valeur par défaut de 3 heures. Les valeurs valides pour cette règle sont comprises entre 1 800 000 (30 minutes) et 86,4 millions (1 jour). Toutes les valeurs non comprises dans cette plage seront nivelées à la limite respective. 

       Si cette règle n'est pas configurée, <ph name="PRODUCT_NAME"/> utilise la valeur par défaut de 3 heures.</translation>
<translation id="7424751532654212117">Liste des exceptions à la liste des plug-ins désactivés</translation>
<translation id="6233173491898450179">Définir le répertoire de téléchargement</translation>
<translation id="78524144210416006">Configure la gestion de l'alimentation sur l'écran de connexion sous <ph name="PRODUCT_OS_NAME"/>

      Cette règle vous permet de configurer le comportement de <ph name="PRODUCT_OS_NAME"/> lorsque l'utilisateur reste inactif pendant un certain temps lors de l'affichage de l'écran de connexion. Elle contrôle de nombreux paramètres. Pour connaître la signification et les plages de valeurs de ces paramètres, consultez les règles correspondantes qui contrôlent la gestion de l'alimentation au cours d'une session. Les seules dérogations à ces règles sont les suivantes :
      * L'action à effectuer en cas d'inactivité ou de fermeture du capot ne peut pas être la fermeture de la session.
      * L'action à effectuer par défaut en cas d'inactivité lors du fonctionnement sur une source d'alimentation CA est la fermeture.

      La règle doit être spécifiée sous forme de chaîne exprimant les paramètres individuels au format JSON, en suivant le schéma suivant :
      {
        &quot;type&quot;: &quot;object&quot;,
        &quot;properties&quot;: {
          &quot;AC&quot;: {
            &quot;description&quot;: &quot;Paramètres de gestion de l'alimentation applicables uniquement en cas de fonctionnement sur une source d'alimentation CA&quot;,
            &quot;type&quot;: &quot;object&quot;,
            &quot;properties&quot;: {
              &quot;Delays&quot;: {
                &quot;type&quot;: &quot;object&quot;,
                &quot;properties&quot;: {
                  &quot;ScreenDim&quot;: {
                    &quot;description&quot;: &quot;Délai d'inactivité de l'utilisateur avant que l'écran ne s'estompe, en millisecondes&quot;,
                    &quot;type&quot;: &quot;integer&quot;,
                    &quot;minimum&quot;: 0
                  },
                  &quot;ScreenOff&quot;: {
                    &quot;description&quot;: &quot;Délai d'inactivité de l'utilisateur avant la désactivation de l'écran, en millisecondes&quot;,
                    &quot;type&quot;: &quot;integer&quot;,
                    &quot;minimum&quot;: 0
                  },
                  &quot;Idle&quot;: {
                    &quot;description&quot;: &quot;Délai d'inactivité de l'utilisateur avant le déclenchement de l'action pour inactivité, en millisecondes&quot;,
                    &quot;type&quot;: &quot;integer&quot;,
                    &quot;minimum&quot;: 0
                  }
                }
              },
              &quot;IdleAction&quot;: {
                &quot;description&quot;: &quot;Action à effectuer lorsque le délai d'inactivité est atteint&quot;,
                &quot;enum&quot;: [ &quot;Suspend&quot;, &quot;Shutdown&quot;, &quot;DoNothing&quot; ]
              }
            }
          },
          &quot;Battery&quot;: {
            &quot;description&quot;: &quot;Paramètres de gestion de l'alimentation applicables uniquement en cas de fonctionnement sur batterie&quot;,
            &quot;type&quot;: &quot;object&quot;,
            &quot;properties&quot;: {
              &quot;Delays&quot;: {
                &quot;type&quot;: &quot;object&quot;,
                &quot;properties&quot;: {
                  &quot;ScreenDim&quot;: {
                    &quot;description&quot;: &quot;Délai d'inactivité de l'utilisateur avant que l'écran ne s'estompe, en millisecondes&quot;,
                    &quot;type&quot;: &quot;integer&quot;,
                    &quot;minimum&quot;: 0
                  },
                  &quot;ScreenOff&quot;: {
                    &quot;description&quot;: &quot;Délai d'inactivité de l'utilisateur avant la désactivation de l'écran, en millisecondes&quot;,
                    &quot;type&quot;: &quot;integer&quot;,
                    &quot;minimum&quot;: 0
                  },
                  &quot;Idle&quot;: {
                    &quot;description&quot;: &quot;Délai d'inactivité de l'utilisateur avant le déclenchement de l'action pour inactivité, en millisecondes&quot;,
                    &quot;type&quot;: &quot;integer&quot;,
                    &quot;minimum&quot;: 0
                  }
                }
              },
              &quot;IdleAction&quot;: {
                &quot;description&quot;: &quot;Action à effectuer lorsque le délai d'inactivité est atteint&quot;,
                &quot;enum&quot;: [ &quot;Suspend&quot;, &quot;Shutdown&quot;, &quot;DoNothing&quot; ]
              }
            }
          },
          &quot;LidCloseAction&quot;: {
            &quot;description&quot;: &quot;Action à effectuer à la fermeture du capot&quot;,
            &quot;enum&quot;: [ &quot;Suspend&quot;, &quot;Shutdown&quot;, &quot;DoNothing&quot; ]
          },
          &quot;UserActivityScreenDimDelayScale&quot;: {
            &quot;description&quot;: &quot;Pourcentage d'adaptation du délai d'estompage de l'écran en cas d'activité de l'utilisateur lorsque l'écran s'estompe ou peu de temps après la désactivation de l'écran&quot;,
            &quot;type&quot;: &quot;integer&quot;,
            &quot;minimum&quot;: 100
          }
        }
      }

      Si un paramètre n'est pas défini, la valeur par défaut est utilisée.

      Si cette règle n'est pas définie, les valeurs par défaut sont utilisées pour tous les paramètres.</translation>
<translation id="8908294717014659003">Vous permet de définir si les sites Web sont autorisés à accéder aux périphériques de capture multimédia. L'accès aux périphériques de capture multimédia peut être autorisé par défaut, ou l'utilisateur doit confirmer son autorisation chaque fois qu'un site Web souhaite accéder à ceux-ci.

          En cas de non-configuration de cette règle, PromptOnAccess prévaut. L'utilisateur peut la modifier.</translation>
<translation id="2299220924812062390">Indiquer une liste de plug-ins activés</translation>
<translation id="4325690621216251241">Ajouter un bouton de déconnexion dans la barre d'état système</translation>
<translation id="924557436754151212">Importer les mots de passe enregistrés du navigateur par défaut à la première exécution</translation>
<translation id="1465619815762735808">Cliquer pour lire</translation>
<translation id="7227967227357489766">Définit la liste des utilisateurs autorisés à se connecter à l'appareil. Les entrées se présentent sous la forme suivante : <ph name="USER_WHITELIST_ENTRY_FORMAT"/> (<ph name="USER_WHITELIST_ENTRY_EXAMPLE"/>, par exemple). Pour autoriser des utilisateurs arbitraires sur un domaine, utilisez les entrées sous la forme suivante : <ph name="USER_WHITELIST_ENTRY_WILDCARD"/>.

       En cas de non-configuration de cette règle, aucune restriction ne s'applique quant aux utilisateurs autorisés à se connecter. Notez que la création d'utilisateurs nécessite toujours une configuration correcte de la règle <ph name="DEVICEALLOWNEWUSERS_POLICY_NAME"/>.</translation>
<translation id="8135937294926049787">Indiquer le délai d'inactivité au terme duquel l'écran s'éteint en cas d'utilisation de l'alimentation secteur.

          Lorsque cette règle est définie sur une valeur supérieure à zéro, elle indique la durée pendant laquelle l'utilisateur doit rester inactif avant que <ph name="PRODUCT_OS_NAME"/> éteigne l'écran.

          Si cette règle est définie sur zéro, <ph name="PRODUCT_OS_NAME"/> n'arrête pas l'écran en cas d'inactivité de l'utilisateur.

          Si elle n'est pas définie, la durée par défaut est utilisée.

          La valeur de cette règle doit être indiquée en millisecondes. Les valeurs doivent être inférieures ou égales au délai d'inactivité.</translation>
<translation id="1897365952389968758">Autoriser tous les sites à exécuter JavaScript</translation>
<translation id="5244714491205147861">Gestion de l'alimentation sur l'écran de connexion</translation>
<translation id="922540222991413931">Configurer les sources d'installation des extensions, des applications et des scripts d'utilisateur</translation>
<translation id="7323896582714668701">Paramètres de ligne de commande supplémentaires pour <ph name="PRODUCT_NAME"/></translation>
<translation id="6931242315485576290">Désactiver la synchronisation des données avec Google</translation>
<translation id="7006788746334555276">Paramètres de contenu</translation>
<translation id="5142301680741828703">Toujours rendre les formats d'URL suivants dans <ph name="PRODUCT_FRAME_NAME"/></translation>
<translation id="4625915093043961294">Configurer la liste blanche d'installation des extensions</translation>
<translation id="187819629719252111">Autorise l'accès aux fichiers locaux de la machine en autorisant <ph name="PRODUCT_NAME"/> à afficher des boîtes de dialogue de sélection de fichiers. 

Si vous activez ce paramètre, les utilisateurs peuvent ouvrir normalement les boîtes de dialogue de sélection de fichiers. 

Si vous désactivez ce paramètre, chaque fois que l'utilisateur effectue une action entraînant l'ouverture d'une boîte de dialogue de sélection de fichiers (par exemple, une importation de favoris, un téléchargement de fichiers, l'enregistrement de liens, etc.), un message s'affiche à la place et l'utilisateur est supposé avoir cliqué sur &quot;Annuler&quot; dans la boîte de dialogue de sélection de fichiers. 

Si ce paramètre n'est pas défini, les utilisateurs peuvent ouvrir normalement les boîtes de dialogue de sélection de fichiers.</translation>
<translation id="4507081891926866240">Personnalise la liste des formats d'URL qui doivent toujours être affichés par <ph name="PRODUCT_FRAME_NAME"/>. 

Si cette règle n'est pas configurée, le moteur de rendu par défaut est utilisé pour tous les sites, tel que spécifié par la règle &quot;ChromeFrameRendererSettings&quot;. 

Pour voir des exemples de formats, accédez à l'adresse http://www.chromium.org/developers/how-tos/chrome-frame-getting-started.</translation>
<translation id="3101501961102569744">Sélectionner le mode de spécification des paramètres de serveur proxy</translation>
<translation id="1803646570632580723">Liste des applications épinglées à afficher dans le lanceur d'applications</translation>
<translation id="7774768074957326919">Utiliser les paramètres proxy du système</translation>
<translation id="3891357445869647828">Activer JavaScript</translation>
<translation id="868187325500643455">Autoriser tous les sites à exécuter automatiquement les plug-ins</translation>
<translation id="7421483919690710988">Définir la taille du cache du disque de support en octets</translation>
<translation id="5226033722357981948">Indiquer si l'outil de recherche de plug-ins doit être désactivé</translation>
<translation id="4890209226533226410">Définit le type de loupe activé.

          Si vous définissez cette règle, elle contrôle le type de loupe qui est activée. Définissez la règle sur &quot;Aucun&quot; pour désactiver la loupe.

          Si vous définissez cette règle, les utilisateurs ne peuvent pas la modifier ni l'ignorer.

          Si vous ne définissez pas cette règle, la loupe est désactivée au départ, mais peut ensuite être activée à tout moment par les utilisateurs.</translation>
<translation id="3428247105888806363">Activer la prédiction réseau</translation>
<translation id="6145799962557135888">Permet de définir une liste de formats d'URL spécifiant les sites qui sont autorisés à exécuter JavaScript. 

Si cette règle n'est pas configurée, la valeur par défaut globale sera utilisée pour tous les sites à partir de la règle &quot;DefaultJavaScriptSetting&quot;, si elle est définie, ou à défaut, à partir de la configuration personnelle de l'utilisateur.</translation>
<translation id="2757054304033424106">Types d'extensions ou d'applications autorisés à être installés</translation>
<translation id="7053678646221257043">Lorsqu'elle est activée, cette règle force l'importation des favoris à partir du navigateur par défaut actuel. Si elle est activée, elle affecte également la boîte de dialogue d'importation. 

Si elle est désactivée, les favoris ne sont pas importés. 

Si elle n'est pas configurée, l'utilisateur peut être invité à effectuer l'importation, ou celle-ci peut se faire automatiquement.</translation>
<translation id="5757829681942414015">Configure le répertoire que <ph name="PRODUCT_NAME"/> utilise pour stocker les données utilisateur.

      Si vous définissez cette règle, <ph name="PRODUCT_NAME"/> utilise le répertoire fourni, que l'utilisateur ait spécifié l'indicateur &quot;--user-data-dir&quot; ou non.

      Consultez une liste des variables utilisables à l'adresse http://www.chromium.org/administrators/policy-list-3/user-data-directory-variables.

      Si vous ne définissez pas cette règle, le chemin d'accès du profil par défaut est utilisé, et l'utilisateur est en mesure de le remplacer à l'aide de l'indicateur de ligne de commande &quot;--user-data-dir&quot;.</translation>
<translation id="5067143124345820993">Liste des utilisateurs autorisés à se connecter</translation>
<translation id="2514328368635166290">Indique l'URL de l'icône favorite du moteur de recherche par défaut. 

Cette règle est facultative. Si elle n'est pas définie, aucune icône ne sera présente pour le moteur de recherche. 

Cette règle n'est respectée que si la règle &quot;DefaultSearchProviderEnabled&quot; est activée.</translation>
<translation id="7194407337890404814">Nom du moteur de recherche par défaut</translation>
<translation id="1843117931376765605">Fréquence d'actualisation des règles relatives aux utilisateurs</translation>
<translation id="5535973522252703021">Liste blanche des serveurs de délégation Kerberos</translation>
<translation id="4578030379102330182">Activer l'attestation à distance pour l'utilisateur</translation>
<translation id="9187743794267626640">Désactiver le montage de périphériques de stockage externe</translation>
<translation id="6353901068939575220">Spécifie les paramètres utilisés pour la recherche d'URL avec POST. Il s'agit de paires de noms et de valeurs séparées par une virgule. Si une valeur est équivalente à un paramètre modèle, comme &quot;{searchTerms}&quot; dans l'exemple ci-dessus, elle est remplacée par des termes de recherche réels.

          Cette règle est facultative. Si elle n'est pas définie, la requête de recherche sera envoyée à l'aide la méthode GET.

          Cette règle n'est respectée que si la règle &quot;DefaultSearchProviderEnabled&quot; est activée.</translation>
<translation id="5307432759655324440">Disponibilité du mode navigation privée</translation>
<translation id="4056910949759281379">Désactiver le protocole SPDY</translation>
<translation id="3808945828600697669">Répertorier les plug-ins désactivés</translation>
<translation id="4525521128313814366">Permet de définir une liste de formats d'URL spécifiant les sites qui ne sont pas autorisés à afficher des images. 

Si cette règle n'est pas configurée, la valeur par défaut globale est utilisée pour tous les sites à partir de la règle &quot;DefaultImagesSetting&quot; si elle est configurée, ou à défaut, à partir de la configuration personnelle de l'utilisateur.</translation>
<translation id="8499172469244085141">Paramètres par défaut (les utilisateurs peuvent les contourner)</translation>
<translation id="8693243869659262736">Utiliser le client DNS intégré</translation>
<translation id="3072847235228302527">Définir les conditions d'utilisation d'un compte local de l'appareil</translation>
<translation id="5523812257194833591">Session publique à laquelle le système se connecte automatiquement après l'expiration du délai d'inactivité de l'utilisateur.

      Si cette règle est définie, le système se connecte automatiquement à la session spécifiée après expiration du délai d'inactivité. La session publique doit être configurée au préalable (voir |DeviceLocalAccounts|).

      Si cette règle n'est pas définie, aucune connexion automatique n'a lieu.</translation>
<translation id="5983708779415553259">Comportement par défaut des sites ne figurant dans aucun pack de contenu</translation>
<translation id="3866530186104388232">Si cette règle est définie sur &quot;true&quot; ou si elle n'est pas configurée, <ph name="PRODUCT_OS_NAME"/> affiche les utilisateurs existants sur l'écran de connexion et permet d'en choisir un. Si cette règle est définie sur &quot;false&quot;, <ph name="PRODUCT_OS_NAME"/> affiche une boîte de dialogue demandant le nom d'utilisateur et le mot de passe pour se connecter.</translation>
<translation id="2098658257603918882">Autoriser l'envoi de statistiques d'utilisation et de rapports d'erreur</translation>
<translation id="2324547593752594014">Autoriser la connexion à Chrome</translation>
<translation id="172374442286684480">Autoriser tous les sites à définir des données locales</translation>
<translation id="1151353063931113432">Autoriser les images sur ces sites</translation>
<translation id="1297182715641689552">Utiliser un script de proxy .pac</translation>
<translation id="2976002782221275500">Indiquer le délai d'inactivité au terme duquel l'écran s'assombrit en cas d'utilisation de la batterie

                      Lorsque cette règle est définie sur une valeur supérieure à zéro, elle indique la durée pendant laquelle l'utilisateur doit rester inactif avant que <ph name="PRODUCT_OS_NAME"/> assombrisse l'écran.

                      Si cette règle est définie sur zéro, <ph name="PRODUCT_OS_NAME"/> n'assombrit pas l'écran en cas d'inactivité de l'utilisateur.

                      Si elle n'est pas définie, la durée par défaut est utilisée.

                      La valeur de cette règle doit être indiquée en millisecondes. Les valeurs doivent être inférieures ou égales au délai d'arrêt de l'écran (le cas échéant) et au délai d'inactivité.</translation>
<translation id="8631434304112909927">jusqu'à la version <ph name="UNTIL_VERSION"/></translation>
<translation id="7469554574977894907">Activer les suggestions de recherche</translation>
<translation id="4906194810004762807">Fréquence d'actualisation des règles de l'appareil</translation>
<translation id="8922668182412426494">Serveurs susceptibles d'être utilisés par <ph name="PRODUCT_NAME"/>.

          Si vous utilisez plusieurs serveurs, séparez leur nom par une virgule. Les caractères génériques (*) sont autorisés.

          Si cette règle n'est pas définie, Google Chrome ne transmet pas les identifiants de l'utilisateur, même si le serveur est identifié comme faisant partie de l'Intranet.</translation>
<translation id="1398889361882383850">Permet d'indiquer si les sites Web sont autorisés à exécuter des plug-ins automatiquement. L'exécution automatique des plug-ins peut-être soit autorisée pour tous les sites Web, soit refusée pour tous les sites Web.

          L'option &quot;Cliquer pour lire&quot; autorise l'exécution des plug-ins, mais l'utilisateur doit cliquer dessus pour les lancer.

          Si cette règle n'est pas configurée, le paramètre &quot;AllowPlugins&quot; est utilisé, et l'utilisateur est en mesure de le modifier.</translation>
<translation id="7974114691960514888">Cette règle n'est plus disponible. 
Permet l'utilisation de serveurs STUN et relais lors de la connexion à un client distant. 

Si ce paramètre est activé, cette machine peut découvrir et se connecter à des machines hôte distantes, même si elles sont séparées par un pare-feu. 

Si ce paramètre est désactivé et que les connexions UDP sortantes sont filtrées par le pare-feu, cette machine peut uniquement se connecter aux machines hôte au sein du réseau local.</translation>
<translation id="7694807474048279351">Planifie un démarrage automatique après une mise à jour de <ph name="PRODUCT_OS_NAME"/>.

      Si vous définissez cette règle sur &quot;True&quot;, un démarrage automatique est planifié après la mise à jour de <ph name="PRODUCT_OS_NAME"/> et le redémarrage de l'appareil. Le redémarrage est planifié immédiatement, mais peut être reporté de 24 heures
au maximum si un utilisateur se sert de l'appareil.

      Si vous définissez cette règle sur &quot;False&quot;, aucun redémarrage automatique n'est planifié après la mise à jour de <ph name="PRODUCT_OS_NAME"/>. La mise à jour est terminée lorsque l'utilisateur redémarre l'appareil.

      Si vous définissez cette règle, les utilisateurs ne peuvent pas la modifier ni l'ignorer.

      Remarque : Pour le moment, les redémarrages automatiques ne sont activés que lorsque l'écran de connexion est affiché ou qu'une session d'application de kiosque est en cours. Ce fonctionnement va changer prochainement : la règle s'appliquera toujours, qu'une session de n'importe quel type soit en cours ou non.</translation>
<translation id="5511702823008968136">Activer le barre de favoris</translation>
<translation id="5105313908130842249">Délai de verrouillage de l'écran (batterie)</translation>
<translation id="7882585827992171421">Cette règle n'est active qu'en mode &quot;point de vente&quot;.

       Détermine l'identifiant de l'extension à utiliser comme économiseur d'écran sur l'écran de connexion. L'extension doit faire partie de l'AppPack configuré pour ce domaine via la règle DeviceAppPack.</translation>
<translation id="7736666549200541892">Activer l'extension des certificats TLS liés à des domaines</translation>
<translation id="1796466452925192872">Vous permet d'indiquer les URL qui sont autorisées à installer des extensions, des applications et des thèmes.

          À partir de Google Chrome 21, il sera plus difficile d'installer des extensions, des applications et des scripts d'utilisateurs en dehors du Chrome Web Store. Auparavant, les utilisateurs pouvaient cliquer sur un lien redirigeant vers un fichier *.crx, et Google Chrome installait le fichier après quelques avertissements. À partir de Google Chrome 21, ces fichiers devront être téléchargés et déplacés vers la page des paramètres Google Chrome. Ceci permet à certaines URL de bénéficier de l'ancienne procédure d'installation, plus facile à suivre.

          Chaque élément de cette liste est un schéma de correspondance de style extension (voir http://code.google.com/chrome/extensions/match_patterns.html). Les utilisateurs pourront facilement installer des éléments depuis n'importe quelle URL correspondant à un élément de cette liste. L'emplacement du fichier *.crx et la page de téléchargement (page de provenance) doivent tous deux être autorisés par ces schémas.

          ExtensionInstallBlacklist prévaut sur cette règle : une extension figurant dans la liste noire ne sera pas installée, même si elle provient d'un site mentionné dans cette liste.</translation>
<translation id="2113068765175018713">Limiter le temps de fonctionnement de l'appareil en redémarrant automatiquement</translation>
<translation id="7848840259379156480">Permet de configurer le moteur de rendu HTML par défaut lorsque <ph name="PRODUCT_FRAME_NAME"/> est installé.
      Le paramétrage par défaut de cette stratégie autorise le navigateur hôte à effectuer le rendu. Toutefois, vous pouvez
      remplacer ce paramétrage pour que <ph name="PRODUCT_FRAME_NAME"/> assure le rendu des pages HTML pages par défaut.</translation>
<translation id="186719019195685253">Indique l'action à effectuer lorsque le délai d'inactivité est atteint en cas de fonctionnement sur une source d'alimentation CA.</translation>
<translation id="7890264460280019664">Génére une liste d'interfaces réseau, avec leur type et leur adresse matérielle sur le serveur.

      Si la règle n'est pas définie ou si elle est définie sur &quot;False&quot;, la liste d'interfaces ne sera pas générée.</translation>
<translation id="4121350739760194865">Empêcher les promotions pour des applications de s'afficher sur la page Nouvel onglet</translation>
<translation id="2127599828444728326">Autoriser les notifications sur ces sites</translation>
<translation id="3973371701361892765">Ne jamais masquer automatiquement le répertoire</translation>
<translation id="7635471475589566552">Configure les paramètres régionaux de l'application dans <ph name="PRODUCT_NAME"/> et empêche les utilisateurs de modifier ces paramètres. 

Si vous activez ce paramètre, <ph name="PRODUCT_NAME"/> utilise les paramètres régionaux spécifiés. Si les paramètres régionaux configurés ne sont pas compatibles, le navigateur applique la valeur &quot;en-US&quot;. 

Si ce paramètre est désactivé ou s'il n'est pas configuré, <ph name="PRODUCT_NAME"/> utilise les paramètres régionaux favoris de l'utilisateur (s'ils ont été configurés), les paramètres régionaux du système ou les paramètres régionaux de remplacement (&quot;en-US&quot;).</translation>
<translation id="2948087343485265211">Indiquer si l'activité audio a une incidence sur la gestion de l'alimentation

                     Lorsque cette règle est définie sur True ou si elle n'est pas définie, l'utilisateur n'est pas considéré comme inactif pendant la lecture audio. Le délai d'inactivité ne peut ainsi pas être atteint et l'action à prendre en cas d'inactivité n'est pas appliquée. L'assombrissement, l'arrêt et le verrouillage de l'écran sont toutefois appliqués au terme des délais configurés, indépendamment de l'activité audio.

                    Si cette règle est définie sur False, l'activité audio n'empêche pas l'utilisateur d'être considéré comme inactif.</translation>
<translation id="7842869978353666042">Configurer les options Google Drive</translation>
<translation id="718956142899066210">Types de connexion autorisés pour les mises à jour</translation>
<translation id="1734716591049455502">Configurer les options d'accès à distance</translation>
<translation id="7336878834592315572">Conserver les cookies pendant toute la durée de la session</translation>
<translation id="7715711044277116530">Pourcentage d'adaptation du délai d'assombrissement de l'écran en mode Présentation</translation>
<translation id="8777120694819070607">Permet à <ph name="PRODUCT_NAME"/> d'exécuter des plug-ins obsolètes.

      Si vous activez ce paramètre, les plug-ins obsolètes sont utilisés comme des plug-ins normaux.

      Si vous désactivez ce paramètre, les plug-ins obsolètes ne seront pas utilisés et l'autorisation des utilisateurs ne sera pas requise pour leur exécution.

      Si ce paramètre n'est pas défini, l'autorisation des utilisateurs sera requise pour l'exécution des plug-ins obsolètes.</translation>
<translation id="2629448496147630947">Configurer les options d'accès à distance dans <ph name="PRODUCT_NAME"/>. Ces fonctionnalités sont ignorées, sauf si l'application Web d'accès à distance est installée.</translation>
<translation id="1310699457130669094">Vous pouvez spécifier ici une URL pointant vers un fichier .pac de proxy. 

Cette règle ne prend effet que si vous avez sélectionné les paramètres de proxy manuels pour l'option &quot;Sélectionner le mode de spécification des paramètres de serveur proxy&quot;. 

Vous ne devriez pas configurer cette règle si vous avez sélectionné un autre mode de spécification des règles de proxy. 

Pour voir plus d'options et des exemples détaillés, accédez à l'adresse : 
<ph name="PROXY_HELP_URL"/></translation>
<translation id="1509692106376861764">Cette règle a été supprimée à partir de la version 29 de <ph name="PRODUCT_NAME"/>.</translation>
<translation id="5464816904705580310">Configurer les paramètres des utilisateurs gérés</translation>
<translation id="3219421230122020860">Mode navigation privée disponible</translation>
<translation id="7690740696284155549">Configure le répertoire que <ph name="PRODUCT_NAME"/> utilise pour télécharger les fichiers.

      Si vous définissez cette règle, <ph name="PRODUCT_NAME"/> utilise le répertoire fourni, que l'utilisateur en ait spécifié un ou non, ou qu'il ait ou non activé l'indicateur permettant d'être invité à renseigner l'emplacement du téléchargement à chaque fois.

      Consultez une liste des variables utilisables à l'adresse http://www.chromium.org/administrators/policy-list-3/user-data-directory-variables.

      Si vous ne définissez pas cette règle, le répertoire de téléchargement par défaut est utilisé et l'utilisateur est en mesure de le modifier.</translation>
<translation id="7381326101471547614">Désactiver l'utilisation du protocole SPDY dans <ph name="PRODUCT_NAME"/>. Si cette règle est activée, le protocole SPDY ne sera pas disponible dans <ph name="PRODUCT_NAME"/>. La désactivation de cette règle permet l'utilisation du protocole SPDY. En outre, si cette règle n'est pas définie, le protocole SPDY sera disponible.</translation>
<translation id="2208976000652006649">Paramètres pour l'URL de recherche utilisant POST</translation>
<translation id="1583248206450240930">Utiliser <ph name="PRODUCT_FRAME_NAME"/> par défaut</translation>
<translation id="1047128214168693844">Interdire à tous les sites de suivre la position géographique des utilisateurs</translation>
<translation id="4101778963403261403">Configure le type de la page d'accueil par défaut dans <ph name="PRODUCT_NAME"/> et empêche les utilisateurs de modifier les préférences de la page d'accueil. La page d'accueil peut être définie soit sur une URL que vous spécifiez, soit sur la page Nouvel onglet. 

Si vous activez ce paramètre, la page Nouvel onglet est toujours utilisée pour la page d'accueil, et l'adresse URL de la page d'accueil est ignorée. 

Si vous désactivez ce paramètre, la page d'accueil de l'utilisateur ne sera jamais la page Nouvel onglet, sauf si son URL est définie sur &quot;chrome://newtab&quot;. 

Dans les deux cas, les utilisateurs ne peuvent pas changer leur type de page d'accueil dans <ph name="PRODUCT_NAME"/>. 

Si cette règle n'est pas configurée, l'utilisateur peut choisir lui-même de définir la page Nouvel onglet comme page d'accueil.</translation>
<translation id="8970205333161758602">Supprimer l'invite de fermeture de <ph name="PRODUCT_FRAME_NAME"/></translation>
<translation id="3273221114520206906">Paramètre JavaScript par défaut</translation>
<translation id="4025586928523884733">Bloque les cookies tiers. 

L'activation de ce paramètre empêche que des cookies ne soient définis par des éléments de page Web qui ne font pas partie du domaine indiqué dans la barre d'adresse du navigateur. 

La désactivation de ce paramètre autorise que des cookies soient définis par des éléments de page Web qui ne font pas partie du domaine indiqué dans la barre d'adresse du navigateur, sans que les utilisateurs puissent modifier ce réglage. 

Si cette règle n'est pas configurée, les cookies tiers sont activés, mais l'utilisateur est en mesure de modifier cette situation.</translation>
<translation id="6810445994095397827">Bloquer JavaScript sur ces sites</translation>
<translation id="6672934768721876104">Cette règle est obsolète. Utilisez plutôt ProxyMode. 

Permet de spécifier le serveur proxy utilisé par <ph name="PRODUCT_NAME"/> et empêche les utilisateurs de modifier les paramètres du proxy. 

Si vous choisissez de ne jamais utiliser de serveur proxy et de toujours vous connecter directement, toutes les autres options sont ignorées. 

Si vous choisissez d'utiliser les paramètres proxy du système ou la détection automatique du serveur proxy, toutes les autres options sont ignorées. 

Si vous sélectionnez les paramètres de proxy manuels, vous pouvez spécifier des options supplémentaires dans &quot;Adresse ou URL du serveur proxy&quot;, &quot;URL d'un fichier .pac de proxy&quot; et &quot;Liste de règles de contournement de proxy séparées par des virgules&quot;. 

Pour des exemples détaillés, accédez au site : 
<ph name="PROXY_HELP_URL"/> 

Si vous activez ce paramètre, <ph name="PRODUCT_NAME"/> ignore toutes les options liées au proxy spécifiées à partir de la ligne de commande. 

Si cette règle n'est pas configurée, les utilisateurs peuvent choisir eux-mêmes leurs paramètres de proxy.</translation>
<translation id="3780152581321609624">Inclure un port non standard dans le SPN Kerberos</translation>
<translation id="1749815929501097806">Définir les conditions d'utilisation que l'utilisateur doit accepter avant d'ouvrir une session d'un compte local de l'appareil

      Si cette règle est définie, <ph name="PRODUCT_OS_NAME"/> télécharge les conditions d'utilisation et les présente à l'utilisateur dès ouverture d'une session d'un compte local de l'appareil. L'utilisateur ne peut ouvrir cette session qu'après acceptation desdites conditions d'utilisation.

      Si cette règle n'est pas définie, les conditions d'utilisation ne sont pas présentées à l'utilisateur.

      La règle doit être définie sur une URL à partir de laquelle <ph name="PRODUCT_OS_NAME"/> peut télécharger les conditions d'utilisation. Ces conditions doivent être en texte brut, et proposées au format texte/brut au type MIME. Aucun balisage n'est autorisé.</translation>
<translation id="2660846099862559570">Ne jamais utiliser de proxy</translation>
<translation id="1435659902881071157">Configuration réseau au niveau de l'appareil</translation>
<translation id="2131902621292742709">Délai d'assombrissement de l'écran (batterie)</translation>
<translation id="5781806558783210276">Indiquer le délai d'inactivité au terme duquel l'action d'inactivité est appliquée en cas d'utilisation de la batterie

                      Lorsque cette règle est définie, elle indique le délai d'inactivité au terme duquel <ph name="PRODUCT_OS_NAME"/> applique l'action d'inactivité, configurable séparément.

                      Si cette règle n'est pas définie, une durée par défaut est utilisée.

                      La valeur de cette règle doit être indiquée en millisecondes.</translation>
<translation id="5512418063782665071">URL de la page d'accueil</translation>
<translation id="2948381198510798695"><ph name="PRODUCT_NAME"/> contournera tout serveur proxy pour la liste d'hôtes spécifiée ici. 

Cette règle ne prend effet que si vous avez sélectionné les paramètres de proxy manuels dans l'option &quot;Sélectionner le mode de spécification des paramètres de serveur proxy&quot;. 

Vous ne devriez pas configurer cette règle si vous avez sélectionné un autre mode de spécification des règles de proxy. 

Pour plus d'exemples détaillés, accédez à l'adresse : 
<ph name="PROXY_HELP_URL"/></translation>
<translation id="6658245400435704251">Indique le nombre maximal de secondes pendant lesquelles un appareil peut retarder de façon aléatoire le téléchargement d'une mise à jour à partir du moment où celle-ci est disponible sur le serveur. L'appareil peut attendre pendant une certaine partie de ce temps en termes de temps de l'horloge et pendant la partie restante en termes de nombre de recherches de mise à jour. Dans tous les cas, le facteur de dispersion est limité à une quantité de temps constante, de sorte qu'un appareil ne reste jamais bloqué dans l'attente d'une mise à jour.</translation>
<translation id="523505283826916779">Paramètres d'accessibilité</translation>
<translation id="1948757837129151165">Stratégies d'authentification HTTP</translation>
<translation id="5946082169633555022">Version bêta</translation>
<translation id="7187256234726597551">Si cette règle est définie sur &quot;True&quot;, l'attestation à distance est autorisée pour l'appareil, et un certificat est automatiquement généré et importé sur le serveur de gestion des appareils.

          Si la règle est définie sur &quot;False&quot;, ou si vous ne l'avez pas définie, aucun certificat n'est généré et les appels vers l'API d'extension enterprise.platformKeysPrivate échouent.</translation>
<translation id="5242696907817524533">Configure une liste de favoris gérés

      La règle est une liste de favoris, et chaque favori est un dictionnaire comprenant le nom du favori et l'URL cible.

      Ces favoris sont placés dans un dossier &quot;Favoris gérés&quot; dans les favoris du mobile. Ils ne peuvent pas être modifiés par l'utilisateur.

      Lorsque la règle est définie, le dossier &quot;Favoris gérés&quot; est le dossier ouvert par défaut lors de l'affichage des favoris dans Chrome.

      Ils ne sont pas synchronisés avec le compte de l'utilisateur.</translation>
<translation id="8303314579975657113">Indique la bibliothèque GSSAPI à utiliser pour l'authentification HTTP. Vous pouvez indiquer un nom de bibliothèque seul ou son chemin d'accès complet. 

Si aucun paramètre n'est défini, <ph name="PRODUCT_NAME"/> utilise un nom de bibliothèque par défaut.</translation>
<translation id="7749402620209366169">Active l'authentification forte pour les hôtes d'accès à distance au lieu d'un code d'accès défini par l'utilisateur.

          En cas d'activation de ce paramètre, tout utilisateur accédant à un hôte doit fournir un code d'authentification forte.

          En cas de désactivation ou de non-configuration de ce paramètre, l'authentification forte n'est pas activée. Un code d'accès défini par l'utilisateur est alors demandé.</translation>
<translation id="7329842439428490522">Indiquer le délai d'inactivité au terme duquel l'écran s'éteint en cas d'utilisation de la batterie

                      Lorsque cette règle est définie sur une valeur supérieure à zéro, elle indique la durée pendant laquelle l'utilisateur doit rester inactif avant que <ph name="PRODUCT_OS_NAME"/> éteigne l'écran.

                      Si cette règle est définie sur zéro, <ph name="PRODUCT_OS_NAME"/> n'éteint pas l'écran en cas d'inactivité de l'utilisateur.

                      Si elle n'est pas définie, la durée par défaut est utilisée.

                      La valeur de cette règle doit être indiquée en millisecondes. Les valeurs doivent être inférieures ou égales au délai d'inactivité.</translation>
<translation id="384743459174066962">Permet de définir une liste de formats d'URL spécifiant les sites qui ne sont pas autorisés à ouvrir des pop-ups. 

Si cette règle n'est pas configurée, la valeur par défaut globale sera utilisée pour tous les sites à partir de la règle &quot;DefaultPopupsSetting&quot;, si elle est définie, ou à défaut, à partir de la configuration personnelle de l'utilisateur.</translation>
<translation id="5645779841392247734">Autoriser les cookies sur ces sites</translation>
<translation id="4043912146394966243">Types de connexions autorisés pour les mises à jour du système d'exploitation. En raison de leur taille, les mises à jour du système d'exploitation peuvent considérablement ralentir la connexion et impliquent parfois des frais supplémentaires. C'est pourquoi elles ne sont pas activées par défaut pour les types de connexion jugés onéreux, tels que WiMax, Bluetooth et mobile.

      Les identifiants des types de connexion reconnus sont &quot;ethernet&quot;, &quot;wifi&quot;, &quot;wimax&quot;, &quot;bluetooth&quot; et &quot;mobile&quot;.</translation>
<translation id="6652197835259177259">Paramètres des utilisateurs gérés en local</translation>
<translation id="3243309373265599239">Indiquer le délai d'inactivité au terme duquel l'écran s'assombrit en cas d'utilisation de l'alimentation secteur

                      Lorsque cette règle est définie sur une valeur supérieure à zéro, elle indique la durée pendant laquelle l'utilisateur doit rester inactif avant que <ph name="PRODUCT_OS_NAME"/> assombrisse l'écran.

                      Si cette règle est définie sur zéro, <ph name="PRODUCT_OS_NAME"/> n'assombrit pas l'écran en cas d'inactivité de l'utilisateur.

                      Si elle n'est pas définie, la durée par défaut est utilisée.

                      La valeur de cette règle doit être indiquée en millisecondes. Les valeurs doivent être inférieures ou égales au délai d'arrêt de l'écran (le cas échéant) et au délai d'inactivité.</translation>
<translation id="3859780406608282662">Permet d'ajouter un paramètre à la récupération de la valeur de départ des variantes dans <ph name="PRODUCT_OS_NAME"/>.

      Si cette option est spécifiée, un paramètre de requête appelé &quot;restrict&quot; est ajouté à l'URL utilisée pour récupérer la valeur de départ des variantes. La valeur du paramètre est celle indiquée dans cette règle.

      Si cette option n'est pas spécifiée, l'URL de la valeur de départ des variantes n'est pas modifiée.</translation>
<translation id="7049373494483449255">Permet à <ph name="PRODUCT_NAME"/> d'envoyer des documents à <ph name="CLOUD_PRINT_NAME"/> en vue d'une impression. REMARQUE : Cette règle affecte uniquement la disponibilité de <ph name="CLOUD_PRINT_NAME"/> dans <ph name="PRODUCT_NAME"/>. Elle n'empêche pas les utilisateurs de soumettre des travaux d'impression sur des sites Web. 

Si ce paramètre est activé ou non configuré, les utilisateurs peuvent imprimer sur <ph name="CLOUD_PRINT_NAME"/> depuis la boîte de dialogue d'impression de <ph name="PRODUCT_NAME"/>. 

Si ce paramètre est désactivé, les utilisateurs ne peuvent pas imprimer sur <ph name="CLOUD_PRINT_NAME"/> depuis la boîte de dialogue d'impression de <ph name="PRODUCT_NAME"/>.</translation>
<translation id="4088589230932595924">Mode navigation privée forcé</translation>
<translation id="5862253018042179045">Définir l'état par défaut de la fonctionnalité d'accessibilité de commentaires audio sur l'écran de connexion

          Si vous définissez cette règle sur &quot;True&quot;, les commentaires audio sont activés à l'affichage de l'écran de connexion.

          Si vous définissez cette règle sur &quot;False&quot;, ils sont désactivés à l'affichage de l'écran de connexion.

          Si vous définissez cette règle, les utilisateurs peuvent l'ignorer temporairement en activant ou en désactivant les commentaires audio. Toutefois, cette option n'est pas définitive, et la valeur par défaut est restaurée dès que l'écran de connexion est affiché de nouveau ou que l'utilisateur reste inactif pendant une minute sur l'écran de connexion.

          Si vous ne définissez pas cette règle, les commentaires audio sont désactivés au premier affichage de l'écran de connexion. Les utilisateurs peuvent les activer ou les désactiver à tout moment, et leur état sur l'écran de connexion est appliqué à tous les utilisateurs.</translation>
<translation id="8197918588508433925">Cette règle définit les extensions autorisées à utiliser l'API Enterprise Platform Keys &quot;chrome.enterprise.platformKeysPrivate.challengeUserKey()&quot; pour l'attestation à distance. Pour pouvoir utiliser l'API, les extensions doivent être ajoutées à cette liste.

          Si une extension ne figure pas dans la liste, ou si la liste n'est pas définie, l'appel vers l'API échoue, et un code d'erreur est renvoyé.</translation>
<translation id="7649638372654023172">Configurer l'URL de la page d'accueil par défaut dans <ph name="PRODUCT_NAME"/> et empêcher les utilisateurs de la modifier

          La page d'accueil est la page qui s'ouvre lorsque l'utilisateur clique sur le bouton &quot;Accueil&quot;. Les pages qui s'affichent au démarrage sont gérées par les règles RestoreOnStartup.

          La page d'accueil peut être une URL, que vous définissez ici, ou une page Nouvel onglet. Dans ce dernier cas, cette règle ne s'applique pas.

          Si vous activez ce paramètre, les utilisateurs ne peuvent pas modifier l'URL de leur page d'accueil dans <ph name="PRODUCT_NAME"/>, mais ils peuvent toujours choisir la page Nouvel onglet comme page d'accueil.

          Si cette règle n'est pas définie, l'utilisateur peut choisir lui-même sa page d'accueil à condition que la règle HomepageIsNewTabPage ne soit pas également configurée.</translation>
</translationbundle>