<?xml version="1.0" ?>
<!DOCTYPE translationbundle>
<translationbundle lang="it">
<translation id="1002439864875515590">Se questa norma non viene configurata o se viene impostata una stringa vuota, non verrà mostrata un'opzione di completamento automatico durante il flusso di accesso dell'utente in <ph name="PRODUCT_OS_NAME" />.
      Se per questa norma viene impostata una stringa che rappresenta un nome di dominio, durante l'accesso dell'utente in <ph name="PRODUCT_OS_NAME" /> verrà mostrata un'opzione di completamento automatico che consentirà all'utente di digitare soltanto il nome utente senza l'estensione del nome di dominio.  L'utente potrà sovrascrivere l'estensione del nome di dominio.
      Se il valore della norma non è un dominio valido, la norma non sarà applicata.</translation>
<translation id="101438888985615157">Ruota lo schermo di 180°</translation>
<translation id="1016912092715201525">Configura i controlli del browser predefinito in <ph name="PRODUCT_NAME" /> e impedisce agli utenti di modificarli.

      Se attivi questa impostazione, <ph name="PRODUCT_NAME" /> verifica sempre all'avvio di essere il browser predefinito e, se possibile, si registra automaticamente.

      Se l'impostazione è disattivata, <ph name="PRODUCT_NAME" /> non potrà mai verificare di essere il browser predefinito e disattiva i controlli utente per rendere attiva l'opzione.

      Se l'impostazione non è configurata, <ph name="PRODUCT_NAME" /> consente all'utente di controllare se è impostato come browser predefinito e, in caso contrario, se devono essere mostrate le notifiche per gli utenti.

      Nota per gli amministratori di <ph name="MS_WIN_NAME" />: l'attivazione di questa impostazione vale solo per i computer con Windows 7. Per le versioni di Windows a partire dalla 8, devi distribuire un file di "associazioni applicazioni predefinite" che imposti <ph name="PRODUCT_NAME" /> come gestore dei protocolli <ph name="HHTPS_PROTOCOL" /> e <ph name="HTTP_PROTOCOL" /> (ed eventualmente anche del protocollo <ph name="FTP_PROTOCOL" /> e dei formati file <ph name="HTML_EXTENSION" />, <ph name="HTM_EXTENSION" />, <ph name="PDF_EXTENSION" />, <ph name="SVG_EXTENSION" />, <ph name="WEBP_EXTENSION" /> e così via). Per ulteriori informazioni, consulta <ph name="SUPPORT_URL" />.</translation>
<translation id="1017967144265860778">Gestione dell'alimentazione nella schermata di accesso</translation>
<translation id="1019101089073227242">Imposta directory dati utente</translation>
<translation id="1022361784792428773">ID delle estensioni (oppure * per tutte le estensioni) per cui non è consentita l'installazione</translation>
<translation id="102492767056134033">Impostazione stato predefinito della tastiera sullo schermo nella schermata di accesso</translation>
<translation id="1027000705181149370">Consente di specificare se trasferire o meno al profilo dell'utente i cookie di autenticazione impostati da un IdP SAML durante l'accesso.

      Se durante l'accesso un utente esegue l'autenticazione tramite un IdP SAML, i cookie impostati dall'IdP vengono scritti innanzitutto in un profilo temporaneo. Questi cookie possono essere trasferiti al profilo dell'utente per far avanzare lo stato dell'autenticazione.

      Se questa norma viene impostata su true, i cookie impostati dall'IdP vengono trasferiti al profilo dell'utente ogni volta che l'utente esegue l'autenticazione tramite l'IdP SAML durante l'accesso.

      Se questa norma viene impostata su false o non viene impostata, i cookie impostati dall'IdP vengono trasferiti al profilo dell'utente soltanto durante il primo accesso su un dispositivo.

      . Questa norma è valida soltanto per gli utenti il cui dominio corrisponde al dominio di registrazione del dispositivo. Per tutti gli altri utenti, i cookie impostati dall'IdP vengono trasferiti al profilo dell'utente soltanto durante il primo accesso sul dispositivo.</translation>
<translation id="1029052664284722254">Forza il riavvio del dispositivo all'uscita dell'utente</translation>
<translation id="1030120600562044329">Questa norma consente di attivare la segnalazione anonima a Google dei dati sull'utilizzo e sugli arresti anomali di <ph name="PRODUCT_NAME" /> e di impedire agli utenti di modificare questa impostazione.

      Se questa impostazione è attiva, a Google vengono inviati rapporti anonimi
      di dati sull'utilizzo e sugli arresti anomali.  Se l'impostazione è disattivata, queste informazioni non vengono inviate
      a Google.  In entrambi i casi, gli utenti non possono modificare o sostituire questa impostazione.
      Se la norma non viene impostata, verrà utilizzata l'impostazione scelta dall'utente
      in fase di installazione/prima esecuzione.

      Questa norma è disponibile esclusivamente per le istanze di Windows che fanno parte di un dominio <ph name="MS_AD_NAME" /> così come per le istanze di Windows 10 Pro o Enterprise registrate per la gestione dei dispositivi.
      Per Chrome OS, vedi DeviceMetricsReportingEnabled.</translation>
<translation id="1035385378988781231">Questa norma consente di stabilire se usare o meno l'autenticazione NTLM per la funzionalità Condivisioni file di rete di <ph name="PRODUCT_NAME" />.

      Se questa norma viene impostata su True, verrà usata l'autenticazione NTLM per le condivisioni SMB, se necessario.
      Se questa norma viene impostata su False, l'autenticazione NTLM per le condivisioni SMB viene disattivata.

      Se la norma non viene impostata, per impostazione predefinita la norma viene disattivata per gli utenti gestiti dall'azienda, mentre viene attivata per gli utenti non gestiti.</translation>
<translation id="1040446814317236570">Attiva la rimozione per gli URL PAC (https://)</translation>
<translation id="1044878202534415707">Consente di segnalare statistiche relative all'hardware, ad esempio l'utilizzo di CPU/RAM.

      Se la norma viene impostata su false, le statistiche non vengono segnalate.
      Se viene impostata su true o non viene impostata, le statistiche vengono segnalate.</translation>
<translation id="1046484220783400299">Consente di attivare le funzioni della piattaforma web obsolete per un periodo di tempo limitato</translation>
<translation id="1047128214168693844">Non consentire ad alcun sito di monitorare la posizione fisica degli utenti</translation>
<translation id="1049138910114524876">Consente di configurare la lingua da utilizzare per la schermata di accesso di <ph name="PRODUCT_OS_NAME" />.

      Se questa norma viene impostata, la schermata di accesso verrà sempre visualizzata nella lingua stabilita dal primo valore di questa norma (la norma viene definita come elenco per la compatibilità con le versioni successive). Se la norma non viene impostata o se viene impostato un elenco vuoto, la schermata di accesso verrà visualizzata nella lingua dell'ultima sessione utente. Se la norma viene impostata su un valore non corrispondente a una lingua valida, la schermata di accesso verrà visualizzata in una lingua di riserva (attualmente en-US).</translation>
<translation id="1052499923181221200">Questo criterio non ha effetti a meno che SamlInSessionPasswordChangeEnabled sia impostato su true.
      Se quel criterio è impostato su true e questo criterio è impostato su (ad esempio) 14, significa che gli utenti SAML riceveranno una notifica che li informa con 14 giorni di anticipo che la password scadrà in una determinata data.
      Quindi, gli utenti possono organizzarsi immediatamente, effettuare una modifica della password all'interno della sessione e aggiornarla prima della scadenza.
      Tuttavia, queste notifiche verranno mostrate solo se le informazioni sulla scadenza della password vengono inviate al dispositivo dal provider di identità SAML durante il flusso di accesso SAML.
      Se imposti il criterio su zero, gli utenti non riceveranno nessuna notifica in anticipo, ma verranno avvisati una volta che la password è scaduta.

      Se questo criterio viene impostato, l'utente non può modificarlo o sovrascriverlo.</translation>
<translation id="1062011392452772310">Attivazione dell'attestazione da remoto per il dispositivo</translation>
<translation id="1062407476771304334">Sostituisci</translation>
<translation id="1079801999187584280">Non consentire l'utilizzo degli Strumenti per sviluppatori</translation>
<translation id="1087437665304381368">Questa norma consente di controllare esclusivamente la modalità sviluppatore di <ph name="PRODUCT_OS_NAME" />. Se vuoi impedire l'accesso alle Opzioni sviluppatore Android, devi impostare la norma <ph name="DEVELOPER_TOOLS_DISABLED_POLICY_NAME" />.</translation>
<translation id="1093082332347834239">Se l'impostazione viene attivata, l'host per l'assistenza remota viene eseguito in un processo con le autorizzazioni <ph name="UIACCESS_PERMISSION_NAME" />. In questo modo gli utenti remoti possono interagire con finestre con privilegi più elevati sul desktop dell'utente locale.

          Se l'impostazione viene disattivata o non configurata, l'host dell'assistenza remota viene eseguito nel contesto dell'utente e gli utenti remoti non possono interagire con finestre con privilegi più elevati sul desktop.</translation>
<translation id="1096105751829466145">Provider di ricerca predefinito</translation>
<translation id="1099282607296956954">Attiva isolamento sito per ogni sito</translation>
<translation id="1100570158310952027">
      Questa norma consente di specificare un elenco di origini (URL) o di schemi di nomi host (ad esempio "*.example.com") a cui non vengono applicate limitazioni di sicurezza previste per le origini non sicure.

Lo scopo è consentire alle organizzazioni di configurare le origini della whitelist per le applicazioni precedenti che non possono eseguire il deployment di TLS o configurare un server di gestione temporanea per gli sviluppi web interni, di modo che gli sviluppatori possano testare le funzioni che richiedono contesti sicuri senza dover eseguire il deployment di TLS sul server di gestione temporanea. Questa norma impedisce inoltre che l'origine venga contrassegnata come "Non sicura" nella omnibox.

L'impostazione di un elenco di URL in questa norma ha lo stesso effetto dell'impostazione del flag della riga di comando "--unsafely-treat-insecure-origin-as-secure" su un elenco separato da virgole degli stessi URL. Se viene impostata, questa norma sostituisce il flag della riga di comando.

Questa norma sostituirà UnsafelyTreatInsecureOriginAsSecure, se presente.

Per ulteriori informazioni sui contesti sicuri, visita il sito https://www.w3.org/TR/secure-contexts/.
      </translation>
<translation id="1107764601871839136">Questa norma consente di specificare la durata in ore della cache dell'Oggetto Criteri di gruppo (GPO). Invece di scaricare di nuovo i GPO a ogni recupero della norma, il sistema può riutilizzare i GPO memorizzati nella cache finché la loro versione non viene modificata. Questa norma consente di specificare per quanto tempo è possibile riutilizzare i GPO memorizzati nella cache prima che vengano scaricati di nuovo. Se esegui il riavvio ed esci, la cache verrà svuotata.

      Se la norma non viene impostata, i GPO memorizzati nella cache possono essere riutilizzati per un periodo massimo di 25 ore.

      Se la norma è impostata su 0, la memorizzazione nella cache del GPO è disattivata. Tieni presente che in questo modo aumenterà il carico del server perché i GPO verranno scaricati nuovamente a ogni recupero della norma, anche se non sono stati modificati.</translation>
<translation id="1117462881884985156"><ph name="PRODUCT_NAME" /> aggirerà qualsiasi proxy per l'elenco di host fornito.

          Questa norma viene applicata solo se hai selezionato manualmente le impostazioni proxy in "Scegli come specificare le impostazioni del server proxy" e se la norma <ph name="PROXY_SETTINGS_POLICY_NAME" /> non è stata specificata.

          Devi lasciare questa norma non impostata se hai selezionato una qualsiasi altra modalità per l'impostazione delle norme relative al proxy.

          Per esempi più dettagliati, visita:
          <ph name="PROXY_HELP_URL" />.</translation>
<translation id="1117535567637097036">I gestori di protocollo impostati tramite questa norma non sono utilizzati durante la gestione degli intent di Android.</translation>
<translation id="1118093128235245168">Consenti ai siti di chiedere all'utente di concedere l'accesso a un dispositivo USB collegato</translation>
<translation id="1128903365609589950">Consente di configurare la directory che <ph name="PRODUCT_NAME" /> utilizza per archiviare i file memorizzati nella cache sul disco.

      Se la norma viene impostata, <ph name="PRODUCT_NAME" /> utilizza la directory fornita, indipendentemente dal fatto che l'utente abbia specificato o meno il flag "--disk-cache-dir". Per evitare perdite di dati o altri errori imprevisti, la norma non deve essere impostata su una directory radice del volume o su una directory utilizzata per altri scopi, poiché <ph name="PRODUCT_NAME" /> gestisce i relativi contenuti.

      Vai alla pagina https://www.chromium.org/administrators/policy-list-3/user-data-directory-variables per consultare un elenco delle variabili che possono essere utilizzate.

      Se la norma non viene impostata, viene utilizzata la directory della cache predefinita e l'utente può ignorarla con il flag della riga di comando "--disk-cache-dir".</translation>
<translation id="113521240853905588">Configura le lingue che possono essere utilizzate come lingue preferite di <ph name="PRODUCT_OS_NAME" />.

      Se questa norma viene impostata, l'utente può solo aggiungere una delle lingue elencate in questa norma all'elenco delle lingue preferite. Se questa norma non viene impostata o viene impostata su un elenco vuoto, l'utente può specificare qualsiasi lingua come preferita. Se questa norma viene impostata su un elenco con valori non validi, tutti i valori non validi verranno ignorati. Se un utente ha aggiunto in precedenza all'elenco di lingue preferite alcune lingue non consentite da questa norma, le lingue non consentite verranno rimosse. Se l'utente ha configurato <ph name="PRODUCT_OS_NAME" /> in precedenza per essere visualizzato in una delle lingue non consentite da questa norma, all'accesso successivo la lingua di visualizzazione passerà a una lingua di interfaccia consentita. In caso contrario, <ph name="PRODUCT_OS_NAME" /> passerà al primo valore valido specificato da questa norma o a un'impostazione internazionale di riserva (attualmente inglese, Stati Uniti), se questa norma contiene solo voci non valide.</translation>
<translation id="1135264353752122851">Consente di configurare i layout da tastiera consentiti per le sessioni utente di <ph name="PRODUCT_OS_NAME" />.

      Se questa norma viene impostata, l'utente potrà scegliere soltanto uno dei metodi di immissione specificati al suo interno. Se la norma non viene impostata o viene impostato un elenco vuoto, l'utente potrà selezionare tutti i metodi di immissione supportati. Se il metodo di immissione corrente non è consentito da questa norma, verrà sostituito dal layout della tastiera hardware (se consentito) o dalla prima voce valida di questo elenco. Tutti i metodi di immissione non validi o non supportati di questo elenco verranno ignorati.</translation>
<translation id="1138294736309071213">Questa norma è attiva soltanto in modalità retail.

      Consente di stabilire il periodo di tempo che deve trascorrere prima della visualizzazione dello screensaver nella schermata di accesso dei dispositivi in modalità retail.

      Il valore della norma deve essere specificato in millisecondi.</translation>
<translation id="1141767714195601945">Questa norma consente di gestire i parametri della riga di comando di Chrome da Internet Explorer.

      Se il componente aggiuntivo "Supporto dei browser precedenti" per Internet Explorer non è installato, questa norma non viene applicata.

      Se questa norma non viene impostata, Internet Explorer trasmette a Chrome soltanto l'URL sotto forma di parametro della riga di comando.

      Se per questa norma viene impostato un elenco di stringhe, queste ultime vengono unite usando spazi e trasmesse a Chrome sotto forma di parametri della riga di comando.

      Se un elemento contiene ${url}, tale valore viene sostituito con l'URL della pagina da aprire.

      Se nessun elemento contiene ${url}, l'URL viene aggiunto alla fine della riga di comando.

      Le variabili di ambiente vengono espanse. Su Windows, il valore %ABC% viene sostituito con il valore della variabile di ambiente ABC.</translation>
<translation id="1151353063931113432">Consenti immagini su questi siti</translation>
<translation id="1152117524387175066">Consente di indicare lo stato dello switch dev del dispositivo all'avvio. Se la norma viene impostata su False, lo stato dello switch dev non viene indicato.</translation>
<translation id="1160479894929412407">Consenti protocollo QUIC</translation>
<translation id="1160939557934457296">Disattiva procedendo dalla pagina di avviso Navigazione sicura</translation>
<translation id="1189817621108632689">Questa norma consente di impostare un elenco di pattern URL che specificano i siti in cui non è consentita la visualizzazione di immagini.

          Se questa norma non viene impostata, per tutti i siti verrà utilizzato il valore predefinito globale della norma "DefaultImagesSetting", se è impostata, oppure verrà utilizzata la configurazione personale dell'utente.

          Tieni presente che in precedenza questa norma è stata erroneamente abilitata su Android, ma questa funzione non è mai stata completamente supportata su Android.</translation>
<translation id="1194005076170619046">Se la norma è attivata, nella barra delle applicazioni appare un grosso pulsante di uscita rosso quando è attiva una sessione e lo schermo non è bloccato.

      Se la norma è disattivata o non è specificata, nella barra delle applicazioni non appare il grosso pulsante di uscita rosso.</translation>
<translation id="1197437816436565375">Non puoi forzare le app Android a utilizzare un proxy. Un sottoinsieme di impostazioni relative al proxy viene messo a disposizione delle app Android, che possono decidere volontariamente se rispettarlo o meno. Consulta la norma <ph name="PROXY_MODE_POLICY_NAME" /> per ulteriori dettagli.</translation>
<translation id="1198465924256827162">Consente di stabilire la frequenza di invio, in millisecondi, dei caricamenti dello stato del dispositivo.

      Se questa norma non viene impostata, la frequenza predefinita è pari a tre ore. La frequenza minima consentita è pari a 60 secondi.</translation>
<translation id="1204263402976895730">Stampanti aziendali attive</translation>
<translation id="1216919699175573511">Attiva il supporto per Signed HTTP Exchange (SXG)</translation>
<translation id="1219695476179627719">Consente di specificare se il dispositivo deve eseguire il rollback alla versione impostata da <ph name="DEVICE_TARGET_VERSION_PREFIX_POLICY_NAME" /> nel caso in cui sia già in esecuzione una versione successiva.

      L'impostazione predefinita è RollbackDisabled.</translation>
<translation id="1221359380862872747">Carica gli URL specificati all'accesso demo</translation>
<translation id="1223789468190631420">Stato attivazione Navigazione sicura per origini attendibili</translation>
<translation id="122899932962115297">Una whitelist che consente di stabilire quali modalità di sblocco rapido possono essere configurate e usate dagli utenti per sbloccare la schermata di blocco.

          Il valore è un elenco di stringhe; le voci valide sono "tutte", "PIN" e "IMPRONTA". Se viene aggiunto il valore "tutte" all'elenco, sono disponibili tutte le modalità di sblocco rapido, incluse quelle implementate in futuro. In caso contrario, saranno disponibili solo le modalità indicate nell'elenco.

          Ad esempio, per consentire ogni modalità di sblocco rapido, usa ["tutte"]. Per consentire solo lo sblocco tramite PIN, usa ["PIN"]. Per consentire l'uso del PIN e dell'impronta, usa ["PIN", "IMPRONTA"]. Per disattivare tutte le modalità di sblocco rapido, usa [].

          Per impostazione predefinita, non ci sono modalità di sblocco rapido disponibili per i dispositivi gestiti.</translation>
<translation id="123081309365616809">Attiva la trasmissione di contenuti al dispositivo</translation>
<translation id="1231349879329465225">Consente di attivare o disattivare Fast Transition.
      La scelta è valida per tutti gli utenti e per tutte le interfacce sul dispositivo.
      Per poter usare Fast Transition è necessario attivare sia questa impostazione, sia la proprietà ONC per ogni rete.
      Una volta impostato, Fast Transition rimane valido fino alla modifica della norma per disattivarlo.

      Se la norma non è impostata o è impostata su false, Fast Transition non viene utilizzato.
      Se è impostata su true, Fast Transition viene utilizzato quando il punto di accesso wireless lo supporta.</translation>
<translation id="1243570869342663665">Controlla il filtro dei contenuti per adulti di SafeSites.</translation>
<translation id="1257550411839719984">Imposta directory di download predefinita</translation>
<translation id="1265053460044691532">Limita il tempo per cui un utente autenticato tramite SAML può eseguire l'accesso offline</translation>
<translation id="1290634681382861275">Consente di gestire varie impostazioni, tra cui USB, Bluetooth, aggiornamento delle norme, modalità sviluppatore e altre ancora.</translation>
<translation id="1291880496936992484">Avviso. RC4 sarà rimosso completamente da <ph name="PRODUCT_NAME" /> dopo la versione 52 (nel periodo di settembre 2016), dopodiché questa norma non sarà più attiva.

      Se la norma non viene impostata o se viene impostata su false, i pacchetti di crittografia RC4 in TLS non saranno attivati. In alternativa, la norma può essere impostata su true per mantenere la compatibilità con un server obsoleto. Si tratta di una soluzione temporanea ed è necessario configurare nuovamente il server.</translation>
<translation id="1297182715641689552">Utilizza uno script proxy .pac</translation>
<translation id="1304973015437969093">ID app/estensioni e URL di aggiornamento da installare automaticamente</translation>
<translation id="1307454923744766368">Origini o schemi di nomi host a cui non dovrebbero essere applicate limitazioni previste per le origini non sicure.</translation>
<translation id="1312799700549720683">Consente di gestire le impostazioni di visualizzazione.</translation>
<translation id="131353325527891113">Mostra nomi utente nella schermata di accesso</translation>
<translation id="1327466551276625742">Attivazione richiesta di configurazione della rete offline</translation>
<translation id="1330145147221172764">Attiva tastiera sullo schermo</translation>
<translation id="13356285923490863">Nome norma</translation>
<translation id="1347198119056266798">Questa norma è obsoleta, al suo posto usa <ph name="FORCE_GOOGLE_SAFE_SEARCH_POLICY_NAME" /> e <ph name="FORCE_YOUTUBE_RESTRICT_POLICY_NAME" />. Questa norma viene ignorata se sono impostate le norme <ph name="FORCE_GOOGLE_SAFE_SEARCH_POLICY_NAME" />, <ph name="FORCE_YOUTUBE_RESTRICT_POLICY_NAME" /> o la norma (obsoleta) <ph name="FORCE_YOUTUBE_SAFETY_MODE_POLICY_NAME" />.

      Forza l'esecuzione delle query in Ricerca Google con l'opzione SafeSearch attiva e impedisce agli utenti di modificare questa impostazione. Questa impostazione forza anche il livello medio della Modalità con restrizioni su YouTube.

      Se attivi questa impostazione, la funzione SafeSearch della Ricerca Google e il livello medio della Modalità con restrizioni su YouTube saranno sempre attivi.

      Se disattivi questa impostazione o non imposti un valore, la funzione SafeSearch della Ricerca Google e la Modalità con restrizioni di YouTube non verranno applicate.</translation>
<translation id="1352174694615491349">Questa norma consente la coalescenza di connessioni HTTP/2 quando sono in uso i certificati client. Per ottenere la coalescenza delle connessioni, i nomi host della nuova potenziale connessione e della connessione esistente devono corrispondere a uno o più schemi descritti da questa norma. La norma è un elenco di host che utilizzano il formato del filtro URLBlacklist: "example.com" corrispondente a "example.com" e tutti i sottodomini (ad esempio "sub.example.com"), mentre ".example.net" corrisponde esattamente a "example.net".

Le richieste di coalescenza indirizzate a diversi host tra connessioni che utilizzano certificati client possono creare problemi di privacy o di sicurezza, perché l'ambient authority viene comunicata a tutte le richieste anche se l'utente non ha dato alcuna autorizzazione esplicita. Questa norma è provvisoria e verrà rimossa in una release futura. Consulta il sito https://crbug.com/855690.

Se questa norma non viene impostata, verrà applicato il comportamento predefinito che non consente la coalescenza di connessioni HTTP/2 per le connessioni che utilizzano certificati client.</translation>
<translation id="1354424209129232709">Massimo:</translation>
<translation id="1354452738176731363">Quando questa norma è impostata su false, l'uscita audio non sarà disponibile sul dispositivo dopo che l'utente ha eseguito l'accesso.

      Questa norma si applica a tutti i tipi di uscite audio e non solo agli altoparlanti integrati. Anche le funzioni di accessibilità audio vengono bloccate da questa norma. Non attivare questa norma se l'utente deve utilizzare uno screen reader.

      Se questa impostazione viene impostata su true o non viene configurata, gli utenti potranno utilizzare tutte le uscite audio supportate sul loro dispositivo.</translation>
<translation id="1359553908012294236">Se questa norma viene impostata su true o non viene configurata, in <ph name="PRODUCT_NAME" /> verranno attivati gli accessi come ospite, che sono profili <ph name="PRODUCT_NAME" /> in cui tutte le finestre sono in modalità di navigazione in incognito.

      Se questa norma viene impostata su false, in <ph name="PRODUCT_NAME" /> non sarà possibile avviare profili ospite.</translation>
<translation id="1363275621236827384">Attiva le query in Quirks Server per i profili hardware</translation>
<translation id="1363612796557848469">Questa norma consente all'Assistente Google di accedere al contesto dello schermo e di inviare le informazioni al server.
      Se la norma viene attivata, l'Assistente Google potrà accedere al contesto dello schermo.
      Se la norma viene disattivata, l'Assistente Google non potrà accedere al contesto dello schermo.
      Se non viene impostata, gli utenti possono decidere se consentire o meno all'Assistente Google di accedere al contesto dello schermo.</translation>
<translation id="1376119291123231789">Attiva modalità di ricarica avanzata della batteria</translation>
<translation id="1383493480903114193">Questa norma forza l'esecuzione del codice di networking nel processo del browser.

      Questa norma è disattivata per impostazione predefinita e, se attivata, rende gli utenti vulnerabili ai problemi di sicurezza dopo che il processo di networking viene limitato tramite sandbox.

      Questa norma è pensata per offrire alle aziende la possibilità di migrare a software di terze parti che non dipendono dalla combinazione delle API di networking. I server proxy sono consigliati negli LSP e nelle patching API di Win32.

      Se questa norma non è impostata, il codice di networking potrebbe essere eseguito al di fuori del processo di browser, a seconda delle prove sul campo dell'esperimento NetworkService.</translation>
<translation id="1384459581748403878">Riferimento: <ph name="REFERENCE_URL" /></translation>
<translation id="1384653327213929024">Consenti agli utenti di gestire i certificati installati.</translation>
<translation id="1393485621820363363">Stampanti aziendali associate ai dispositivi attive</translation>
<translation id="1397855852561539316">URL di suggerimento del provider di ricerca predefinito</translation>
<translation id="1404043648050567997">Il servizio Navigazione sicura mostra una pagina di avviso quando gli utenti visitano siti che sono segnalati come potenzialmente dannosi. L'attivazione di questa impostazione impedisce agli utenti di proseguire dalla pagina di avviso al sito dannoso.

      Questa norma impedisce agli utenti di proseguire solo in presenza degli avvisi di Navigazione sicura (ad es. malware e phishing) e non nell'eventualità di problematiche relative al certificato SSL, come nei casi di certificati scaduti o non validi.

      Se questa impostazione è disattivata o non è configurata, gli utenti possono scegliere di proseguire al sito segnalato dopo che è stato mostrato l'avviso.

      Visita il sito https://developers.google.com/safe-browsing per avere ulteriori informazioni sulla funzione Navigazione sicura.</translation>
<translation id="1413936351612032792">Segnala informazioni sull'utilizzo delle app Linux</translation>
<translation id="142346659686073702">Consenti agli utenti non affiliati di usare Crostini</translation>
<translation id="1426410128494586442">Sì</translation>
<translation id="1427655258943162134">Indirizzo o URL del server proxy</translation>
<translation id="1431272318313028342">Consente di attivare la funzione Navigazione sicura di <ph name="PRODUCT_NAME" /> e di impedire agli utenti di modificare questa impostazione.

      Se attivi questa impostazione, la Navigazione sicura è sempre attiva.

      Se la disattivi, la Navigazione sicura non è mai attiva.

      Se attivi o disattivi l'impostazione, gli utenti non possono modificare o sostituire l'opzione "Attiva protezione contro phishing e malware" in <ph name="PRODUCT_NAME" />.

     Se questa norma non viene impostata, l'impostazione verrà attivata ma gli utenti potranno modificarla.

      Visita il sito https://developers.google.com/safe-browsing per avere ulteriori informazioni sulla funzione Navigazione sicura.

      Questa norma è disponibile esclusivamente per le istanze di Windows che fanno parte di un dominio <ph name="MS_AD_NAME" /> così come per le istanze di Windows 10 Pro o Enterprise registrate per la gestione dei dispositivi.</translation>
<translation id="1432194160771348078">
      Specifica un elenco di app che sono installate automaticamente sulla schermata di accesso,
      senza interazione dell'utente, e che non possono essere disinstallate.
      Tutte le autorizzazioni richieste dalle app vengono concesse
      implicitamente senza interazione dell'utente, comprese le eventuali autorizzazioni
      aggiuntive richieste dalle future versioni delle app.

      Tieni presente che, per motivi di sicurezza e privacy, non è consentita l'installazione di estensioni utilizzando questa norma. Inoltre, i dispositivi sul canale stabile installeranno solo le app autorizzate, raggruppate in<ph name="PRODUCT_NAME" />. Qualsiasi elemento che non risponda a queste condizioni verrà ignorato.

      Se un'app di cui era stata precedentemente forzata l'installazione viene rimossa da questo elenco, verrà automaticamente disinstallata da <ph name="PRODUCT_NAME" />.

      Ogni voce dell'elenco della norma è una stringa che contiene un ID estensione e un URL "di aggiornamento" delimitati da un punto e virgola (<ph name="SEMICOLON" />). L'ID estensione è una stringa di 32 lettere che si trova ad es. su <ph name="CHROME_EXTENSIONS_LINK" /> in modalità sviluppatore. L'URL "di aggiornamento" deve rimandare a un documento XML del file manifest di aggiornamento come descritto all'indirizzo <ph name="LINK_TO_EXTENSION_DOC1" />. Tieni presente che l'URL "di aggiornamento" impostato in questa norma viene utilizzato soltanto per l'installazione iniziale; per i successivi aggiornamenti dell'estensione viene utilizzato l'URL di aggiornamento indicato nel file manifest dell'estensione.

      Ad esempio, <ph name="EXTENSION_POLICY_EXAMPLE" /> installa l'app <ph name="EXTENSION_POLICY_EXAMPLE_EXTENSION_NAME" /> dell'URL "di aggiornamento" standard del Chrome Web Store. Per ulteriori informazioni sull'hosting di estensioni, visita: <ph name="LINK_TO_EXTENSION_DOC2" />.</translation>
<translation id="1435659902881071157">Configurazione di rete a livello di dispositivo</translation>
<translation id="1438739959477268107">Impostazione generazione di chiavi predefinite</translation>
<translation id="1454846751303307294">Consente di impostare un elenco di pattern URL che specificano i siti in cui non è consentita l'esecuzione di JavaScript. Se questa norma non viene impostata, per tutti i siti verrà utilizzato il valore predefinito globale della norma "DefaultJavaScriptSetting", se è impostata, oppure verrà utilizzata la configurazione personale dell'utente.</translation>
<translation id="1456822151187621582">Windows (client <ph name="PRODUCT_OS_NAME" />):</translation>
<translation id="1458547592473993238">Questa norma è obsoleta. Usa <ph name="DEFAULT_PLUGINS_SETTING_POLICY_NAME" /> per controllare la disponibilità del plug-in Flash e <ph name="ALWAYS_OPEN_PDF_EXTERNALLY_POLICY_NAME" /> per controllare se si deve utilizzare il visualizzatore PDF integrato per aprire i file PDF.

      Specifica un elenco di plug-in disattivati in <ph name="PRODUCT_NAME" /> e impedisce agli utenti di modificare questa impostazione.

      È possibile utilizzare i caratteri jolly "*" e "?" in corrispondenza delle sequenze di caratteri arbitrari. "*" corrisponde a un numero arbitrario di caratteri, mentre "?" specifica un singolo carattere facoltativo, ossia corrisponde a zero caratteri o a uno solo. Il carattere di escape è "\", quindi per rappresentare i caratteri "*", "?" o "\" effettivi puoi farli precedere da un "\".

      Se attivi questa impostazione, l'elenco di plug-in specificato non verrà mai usato in <ph name="PRODUCT_NAME" />. I plug-in vengono contrassegnati come disattivati in "about:plugins" e gli utenti non possono attivarli.

      Tieni presente che questa norma può essere sostituita da EnabledPlugins e da DisabledPluginsExceptions.

      Se la norma non viene impostata, l'utente potrà usare qualsiasi plug-in installato sul sistema ad eccezione di quelli hardcoded incompatibili, obsoleti o pericolosi.</translation>
<translation id="1464848559468748897">Consente di controllare il comportamento degli utenti in una sessione multiprofilo su dispositivi <ph name="PRODUCT_OS_NAME" />.

      Se questa norma viene impostata su "MultiProfileUserBehaviorUnrestricted", l'utente può essere l'utente principale o secondario di una sessione multiprofilo.

      Se questa norma viene impostata su "MultiProfileUserBehaviorMustBePrimary", l'utente può essere soltanto l'utente principale di una sessione multiprofilo.

      Se questa norma viene impostata su "MultiProfileUserBehaviorNotAllowed", l'utente non può fare parte di una sessione multiprofilo.

      Se questa norma viene impostata, gli utenti non possono cambiarla o sostituirla.

      Se l'impostazione viene cambiata e l'utente ha eseguito l'accesso in una sessione multiprofilo, tutti gli utenti della sessione verranno confrontati con le relative impostazioni corrispondenti. La sessione viene chiusa se uno degli utenti non può più fare parte della sessione.

      Se la norma non viene impostata, per gli utenti gestiti dall'azienda viene applicato il valore predefinito "MultiProfileUserBehaviorMustBePrimary", mentre per gli utenti non gestiti viene applicato il valore "MultiProfileUserBehaviorUnrestricted".</translation>
<translation id="1465619815762735808">Click to play</translation>
<translation id="1468307069016535757">Consente di impostare lo stato predefinito della funzione di accessibilità della modalità ad alto contrasto nella schermata di accesso.

Se la norma viene impostata su true, la modalità ad alto contrasto verrà attivata quando viene visualizzata la schermata di accesso.

Se la norma viene impostata su false, la modalità ad alto contrasto verrà disattivata quando viene visualizzata la schermata di accesso.

Se la norma viene impostata, gli utenti possono ignorarla temporaneamente attivando o disattivando la modalità ad alto contrasto. La scelta dell'utente non è però permanente e viene ripristinato il valore predefinito quando viene visualizzata di nuovo la schermata di accesso o quando l'utente rimane inattivo nella schermata di accesso per un minuto.

Se la norma non viene impostata, la modalità ad alto contrasto viene disattivata alla prima visualizzazione della schermata di accesso. Gli utenti possono attivare o disattivare la modalità ad alto contrasto in qualsiasi momento e il relativo stato nella schermata di accesso persiste per tutti gli utenti.</translation>
<translation id="1468707346106619889">Se le norme sono impostate su "true", la modalità Desktop unificato è consentita e
      attivata per impostazione predefinita, il che significa che le applicazioni includono diverse visualizzazioni.
      L'utente può disattivare la modalità Desktop unificato per le singole visualizzazioni deselezionandola
      nelle impostazioni di visualizzazione.

      Se le norme sono impostate su "false" o non sono impostate, la modalità Desktop unificato
      sarà disattivata. In questo caso, l'utente non potrà attivare la funzione.</translation>
<translation id="1474273443907024088">Disattiva TLS False Start</translation>
<translation id="1477934438414550161">TLS 1.2</translation>
<translation id="1502843533062797703">Attiva blocco inserimento da software di terze parti</translation>
<translation id="1504431521196476721">Attestazione da remoto</translation>
<translation id="1507382822467487898">
          Consente di configurare quale indirizzo MAC (media access control) verrà utilizzato quando il dispositivo è inserito in un dock.

          Quando alcuni modelli di dispositivi vengono inseriti in un dock, per impostazione predefinita l'indirizzo MAC designato per il dispositivo viene utilizzato per identificare il dispositivo su Ethernet. Questo criterio consente all'amministratore di modificare l'origine dell'indirizzo MAC mentre il dispositivo è inserito nel dock.

          Se "DeviceDockMacAddress" è selezionato o se il criterio non è impostato, verrà utilizzato l'indirizzo MAC designato del dock.

          Se "DeviceNicMacAddress" è selezionato, verrà utilizzato l'indirizzo MAC NIC (network interface controller).

          Se "DockNicMacAddress" è selezionato, verrà utilizzato l'indirizzo MAC NIC del dock.

          Questa impostazione non può essere modificata dall'utente.</translation>
<translation id="1507957856411744193">Se questa norma è impostata su True, <ph name="PRODUCT_NAME" /> si connetterà ai dispositivi di trasmissione su tutti gli indirizzi IP, non soltanto su indirizzi privati RFC1918/RFC4913.

          Se questa norma è impostata su False, <ph name="PRODUCT_NAME" /> si connetterà ai dispositivi di trasmissione soltanto su indirizzi privati RFC1918/RFC4913.

          Se questa norma non è impostata, <ph name="PRODUCT_NAME" /> si connetterà ai dispositivi di trasmissione soltanto su indirizzi privati RFC1918/RFC4913, a meno che non sia attiva la funzione CastAllowAllIPs.

          Se la norma "EnableMediaRouter" è impostata su False, allora il valore di questa norma non produrrà alcun effetto.</translation>
<translation id="1509692106376861764">Questa norma non è più supportata a partire dalla versione 29 di <ph name="PRODUCT_NAME" />.</translation>
<translation id="1514888685242892912">Attiva <ph name="PRODUCT_NAME" /></translation>
<translation id="1522425503138261032">Consenti ai siti di monitorare la posizione fisica degli utenti</translation>
<translation id="1523774894176285446">Browser alternativo da aprire per i siti web configurati.</translation>
<translation id="152657506688053119">Elenco di URL alternativi per il fornitore del servizio di ricerca predefinito</translation>
<translation id="1530812829012954197">Visualizza sempre i seguenti schemi URL nel browser host</translation>
<translation id="1541170838458414064">Limita le dimensioni delle pagine di stampa</translation>
<translation id="1553684822621013552">Quando questo criterio è impostato su true, ARC è attivato (soggetto ad altri controlli delle impostazioni dei criteri - ARC continuerà a essere disattivato se nella sessione utente corrente è attivata la modalità temporanea o l'accesso simultaneo).

Se l'impostazione è disattivata o non è stata configurata, gli utenti aziendali non potranno utilizzare ARC.</translation>
<translation id="1559980755219453326">Questa norma consente di stabilire se segnalare o meno i dati delle estensioni e dei plug-in.

      Se questa norma non viene impostata o viene impostata su True, i dati delle estensioni e dei plug-in vengono raccolti.
      Se questa norma viene impostata su False, i dati delle estensioni e dei plug-in non vengono raccolti.

      Questa norma viene applicata soltanto se viene attivata l'estensione <ph name="CHROME_REPORTING_EXTENSION_NAME" /> e il computer viene registrato con la norma <ph name="MACHINE_LEVEL_USER_CLOUD_POLICY_ENROLLMENT_TOKEN_POLICY_NAME" />.</translation>
<translation id="1561424797596341174">La norma sostituisce le build di debug dell'host di accesso remoto</translation>
<translation id="1561967320164410511">U2F più estensioni per singola attestazione</translation>
<translation id="1574554504290354326">Questa impostazione è obsoleta. Utilizza invece SafeBrowsingExtendedReportingEnabled. L'attivazione o la disattivazione di SafeBrowsingExtendedReportingEnabled equivale a impostare SafeBrowsingExtendedReportingOptInAllowed su False.

      L'impostazione di questa norma su False impedisce agli utenti di decidere di inviare ai server di Google alcune informazioni di sistema e i contenuti della pagina. Se questa impostazione viene configurata su True o non viene configurata, gli utenti potranno inviare alcune informazioni di sistema e i contenuti della pagina a Navigazione sicura per contribuire a rilevare app e siti pericolosi.

      Visita il sito https://developers.google.com/safe-browsing per avere ulteriori informazioni sulla funzione Navigazione sicura.</translation>
<translation id="1583248206450240930">Utilizza <ph name="PRODUCT_FRAME_NAME" /> per impostazione predefinita</translation>
<translation id="1599424828227887013">Attiva isolamento dei siti per origini specificate su dispositivi Android</translation>
<translation id="1608755754295374538">URL a cui verrà concesso l'accesso ai dispositivi di acquisizione audio senza richieste</translation>
<translation id="1615221548356595305">Consenti la coalescenza di connessioni HTTP/2 per questi host anche quando sono in uso i certificati client</translation>
<translation id="1615855314789673708">Consente di specificare la configurazione del controller DTC (Diagnostics and Telemetry Controller) wilco.

      Questa norma consente di specificare la configurazione del controller DTC wilco e può essere applicata se il controller DTC wilco è disponibile sul dispositivo e consentito dalla norma. La dimensione della configurazione non deve superare 1 MB (1.000.000 di byte) e deve essere codificata in JSON. Il controller DTC wilco è responsabile della gestione. L'hash di crittografia viene utilizzato per verificare l'integrità del download.

      La configurazione viene scaricata e memorizzata nella cache. Verrà scaricata nuovamente ogni volta che l'URL o l'hash vengono modificati.

      Se imposti questa norma, gli utenti non potranno modificarla o sostituirla.</translation>
<translation id="1617235075406854669">Attiva eliminazione cronologia del browser e dei download</translation>
<translation id="163200210584085447">I pattern di questo elenco verranno confrontati con l'origine di sicurezza dell'URL richiedente. Se viene trovata una corrispondenza, l'accesso ai dispositivi di acquisizione video verrà concesso sulle pagine di accesso SAML. In caso contrario, l'accesso verrà automaticamente negato. Non sono consentite sequenze con caratteri jolly.</translation>
<translation id="1634989431648355062">Consenti il plug-in <ph name="FLASH_PLUGIN_NAME" /> su questi siti</translation>
<translation id="1653229475925941921">Se questa norma viene impostata, consente di controllare il tipo di lente di ingrandimento che viene attivata. Se imposti la norma su "None", la lente di ingrandimento viene disatttivata.

          Se imposti questa norma, gli utenti non potranno modificarla o sostituirla.

          Se questa norma non è impostata, all'inizio la lente di ingrandimento viene disattivata ma l'utente può attivarla in qualsiasi momento.</translation>
<translation id="1655229863189977773">Imposta le dimensioni della cache su disco in byte</translation>
<translation id="166427968280387991">Server proxy</translation>
<translation id="1668836044817793277">Consente o meno all'app kiosk avviata automaticamente senza ritardo di controllare la versione di <ph name="PRODUCT_OS_NAME" />.

Questa norma consente o meno all'app kiosk avviata automaticamente senza ritardo di controllare la versione di <ph name="PRODUCT_OS_NAME" />, dichiarando il valore required_platform_version nel relativo file manifest e utilizzandolo come prefisso per la versione target relativa agli aggiornamenti automatici.

Se la norma viene impostata su true, il valore della chiave manifest required_platform_version dell'app kiosk avviata automaticamente senza ritardo viene utilizzato come prefisso per la versione target relativa agli aggiornamenti automatici.

Se la norma non viene configurata o viene impostata su false, la chiave manifest required_platform_version viene ignorata e l'aggiornamento automatico prosegue normalmente.

Avviso. Non è consigliato delegare il controllo della versione di <ph name="PRODUCT_OS_NAME" /> a un'app kiosk, poiché potrebbe impedire al dispositivo di ricevere aggiornamenti software e correzioni di sicurezza fondamentali. Delegare il controllo della versione di <ph name="PRODUCT_OS_NAME" /> potrebbe mettere a rischio gli utenti.</translation>
<translation id="1675002386741412210">Supportato su:</translation>
<translation id="1689963000958717134">Consente di forzare l'applicazione della configurazione di rete per tutti gli utenti di un dispositivo <ph name="PRODUCT_OS_NAME" />. La configurazione di rete è una stringa in formato JSON definita secondo il formato Open Network Configuration descritto all'indirizzo <ph name="ONC_SPEC_URL" />.</translation>
<translation id="1704516734140344991">Consente di configurare disponibilità e comportamento della funzionalità di aggiornamento del firmware <ph name="TPM_FIRMWARE_UPDATE_TPM" />.

      Le impostazioni individuali possono essere specificate nelle proprietà JSON:

      <ph name="TPM_FIRMWARE_UPDATE_SETTINGS_ALLOW_USER_INITIATED_POWERWASH" />: se viene impostata l'opzione <ph name="TPM_FIRMWARE_UPDATE_SETTINGS_ALLOW_USER_INITIATED_POWERWASH_TRUE" />, gli utenti potranno attivare il flusso della funzione Powerwash per l'installazione di un aggiornamento del firmware <ph name="TPM_FIRMWARE_UPDATE_TPM" />.

      <ph name="TPM_FIRMWARE_UPDATE_SETTINGS_ALLOW_USER_INITIATED_PRESERVE_DEVICE_STATE" />: se viene impostata l'opzione <ph name="TPM_FIRMWARE_UPDATE_SETTINGS_ALLOW_USER_INITIATED_PRESERVE_DEVICE_STATE_TRUE" />, gli utenti potranno richiamare il flusso di aggiornamento del firmware <ph name="TPM_FIRMWARE_UPDATE_TPM" /> che conserverà lo stato a livello di dispositivo (registrazione aziendale compresa), ma che comporta la perdita dei dati degli utenti. Questo flusso di aggiornamento è disponibile a partire dalla versione 68.

      <ph name="TPM_FIRMWARE_UPDATE_SETTINGS_AUTO_UPDATE_MODE" />: consente di controllare in che modo gli aggiornamenti automatici del firmware <ph name="TPM_FIRMWARE_UPDATE_TPM" /> vengono applicati per contrastare la vulnerabilità del firmware <ph name="TPM_FIRMWARE_UPDATE_TPM" />. Tutti i flussi conservano lo stato del dispositivo locale.
        Se la norma viene impostata su 1 o non viene impostata, gli aggiornamenti del firmware TPM non vengono applicati.
        Se la norma viene impostata su 2, il firmware <ph name="TPM_FIRMWARE_UPDATE_TPM" /> verrà aggiornato al riavvio successivo, in seguito alla conferma dell'aggiornamento da parte dell'utente.
        Se la norma viene impostata su 3, il firmware <ph name="TPM_FIRMWARE_UPDATE_TPM" /> viene aggiornato al riavvio successivo.
        Se la norma viene impostata su 4, il firmware <ph name="TPM_FIRMWARE_UPDATE_TPM" /> verrà aggiornato in seguito alla registrazione, prima dell'accesso dell'utente.
        Questa opzione è disponibile a partire dalla versione 74.

      Se la norma non viene impostata, la funzionalità di aggiornamento del firmware <ph name="TPM_FIRMWARE_UPDATE_TPM" /> non sarà disponibile.</translation>
<translation id="1708496595873025510">Imposta la limitazione sul recupero del numero di inizializzazione delle varianti</translation>
<translation id="1717817358640580294">Se questa norma non viene impostata, nel caso in cui Chrome Software Cleaner dovesse rilevare software indesiderato, a Google potrebbero essere segnalati metadati relativi alla scansione in base alla norma stabilita da SafeBrowsingExtendedReportingEnabled. Chrome Software Cleaner chiederà poi all'utente se vuole ripulire il software indesiderato. L'utente può scegliere se condividere i risultati della pulizia con Google per facilitare l'identificazione di software indesiderato in futuro. Questi risultati contengono metadati di file, estensioni installate automaticamente e chiavi del registro di sistema, come spiegato nel Whitepaper sulla privacy di Chrome.

      Se la norma viene disattivata, nel caso in cui Chrome Software Cleaner dovesse rilevare software indesiderato, a Google non verranno segnalati metadati relativi alla scansione, ignorando qualsiasi norma stabilita da SafeBrowsingExtendedReportingEnabled. Chrome Software Cleaner chiederà all'utente se vuole ripulire il software indesiderato.  I risultati della pulizia non verranno segnalati a Google e l'utente non avrà la possibilità di segnalarli.

      Se questa norma viene attivata, nel caso in cui Chrome Software Cleaner dovesse rilevare software indesiderato, a Google potrebbero essere segnalati metadati relativi alla scansione in base alla norma stabilita da SafeBrowsingExtendedReportingEnabled. Chrome Software Cleaner chiederà all'utente se vuole ripulire il software indesiderato.  I risultati della pulizia verranno segnalati a Google e l'utente non avrà la possibilità di impedire la segnalazione.

      Questa norma è disponibile esclusivamente per le istanze di Windows che fanno parte di un dominio <ph name="MS_AD_NAME" /> così come per le istanze di Windows 10 Pro o Enterprise registrate per la gestione dei dispositivi.</translation>
<translation id="172374442286684480">Consenti a tutti i siti di impostare i dati locali</translation>
<translation id="1736269219679256369">Consenti di proseguire dalla pagina di avviso SSL</translation>
<translation id="1745780278307622857">Questa norma determina se <ph name="PRODUCT_NAME" /> può consentire il download senza che Navigazione sicura effettui controlli nel caso in cui la fonte sia attendibile.

      Se la norma è impostata su false, i file scaricati da una fonte sicura non verranno inviati a Navigazione sicura per l'analisi.

      Se la norma non viene impostata o è impostata su true, i file scaricati vengono inviati a Navigazione sicura per l'analisi anche se la fonte è attendibile.

      Tieni presente che tali limitazioni vengono applicate ai download attivati dai contenuti delle pagine web, nonché all'opzione del menu contestuale "Scarica link...". Tali limitazioni non vengono applicate al salvataggio o al download della pagina visualizzata né all'opzione di stampa relativa al salvataggio in PDF.

      Questa norma è disponibile esclusivamente per le istanze di Windows che fanno parte di un dominio <ph name="MS_AD_NAME" /> così come per le istanze di Windows 10 Pro o Enterprise registrate per la gestione dei dispositivi.</translation>
<translation id="1749815929501097806">Consente di impostare i Termini di servizio che l'utente deve accettare per poter avviare una sessione con l'account locale del dispositivo.

Se questa norma viene impostata, <ph name="PRODUCT_OS_NAME" /> scaricherà i Termini di servizio e li presenterà all'utente all'avvio di una sessione con l'account locale del dispositivo. L'utente potrà avviare la sessione soltanto dopo avere accettato i Termini di servizio.

Se questa norma non viene impostata, i Termini di servizio non verranno visualizzati.

Per la norma dovrebbe essere impostato un URL da cui <ph name="PRODUCT_OS_NAME" /> possa scaricare i Termini di servizio. I Termini di servizio devono essere in testo normale e pubblicati come testo di tipo MIME/semplice. Il markup non è consentito.</translation>
<translation id="1750315445671978749">Blocca tutti i download</translation>
<translation id="1781356041596378058">Questa norma controlla anche l'accesso alle Opzioni sviluppatore di Android. Se la norma viene impostata su true, gli utenti non possono accedere alle Opzioni sviluppatore. Se la norma viene impostata su false o non viene impostata, gli utenti possono accedere alle Opzioni sviluppatore toccando sette volte il numero di build nell'app Impostazioni di Android.</translation>
<translation id="1793346220873697538">Disattiva la stampa PIN per impostazione predefinita</translation>
<translation id="1797233582739332495">Mostra un messaggio ricorrente all'utente in cui indica che è necessario un riavvio</translation>
<translation id="1798559516913615713">Durata della cache del GPO</translation>
<translation id="1803646570632580723">Elenco di applicazioni bloccate da visualizzare in Avvio applicazioni</translation>
<translation id="1808715480127969042">Blocca cookie su questi siti</translation>
<translation id="1810261428246410396">Consenti l'uso del tethering istantaneo.</translation>
<translation id="1817685358399181673">Questa norma consente di specificare l'immagine <ph name="PLUGIN_VM_NAME" /> per un utente. Per impostare la norma, è necessario specificare l'URL da cui scaricare l'immagine e specificare l'hash SHA-256 utilizzato per verificare l'integrità del download.

      La norma deve essere specificata sotto forma di stringa contenente l'URL e l'hash in formato JSON.</translation>
<translation id="1827523283178827583">Utilizza server proxy definiti</translation>
<translation id="1831495419375964631">Questa norma è un URL che rimanda a un file XML nello stesso formato della norma <ph name="IEEM_SITELIST_POLICY" /> di Internet Explorer. Se viene impostata, le regole vengono caricate da un file XML senza essere condivise con Internet Explorer.

      Se non viene impostata o non è impostata su un URL valido, <ph name="PRODUCT_NAME" /> non utilizza tale URL come fonte di regole per il cambio di browser.

      Se è impostata su un URL valido, <ph name="PRODUCT_NAME" /> scarica l'elenco dei siti da tale URL e applica le regole come se fossero state configurate con la norma <ph name="SITELIST_POLICY_NAME" />.

      Per ulteriori informazioni sulla norma <ph name="IEEM_SITELIST_POLICY" /> di Internet Explorer: https://docs.microsoft.com/internet-explorer/ie11-deploy-guide/what-is-enterprise-mode</translation>
<translation id="1839060937202387559">Consente di segnalare statistiche hardware e identificatori relativi ai dispositivi di archiviazione.

      Se la norma viene impostata su false, le statistiche non vengono segnalate.
      Se viene impostata su true o non viene impostata, le statistiche vengono segnalate.</translation>
<translation id="1843117931376765605">Frequenza di aggiornamento criteri relativi agli utenti</translation>
<translation id="1844620919405873871">Consente di configurare le norme relative allo sblocco rapido.</translation>
<translation id="1845405905602899692">Impostazioni kiosk</translation>
<translation id="1845429996559814839">Limita la modalità di stampa PIN</translation>
<translation id="1847960418907100918">Consente di specificare i parametri utilizzati durante la ricerca istantanea con POST. Si tratta di coppie di nome/valore separate da virgole. Se un valore è il parametro di un modello, come {searchTerms} nell'esempio precedente, verrà sostituito con i dati dei termini di ricerca reali.

Questa norma è facoltativa. Se non viene impostata, la richiesta di ricerca istantanea verrà inviata utilizzando il metodo GET.

Questa norma viene rispettata soltanto se la norma "DefaultSearchProviderEnabled" è attiva.</translation>
<translation id="1852294065645015766">Consenti la riproduzione automatica dei contenuti multimediali</translation>
<translation id="1857152770025485173">Questa norma impedisce agli utenti di caricare le pagine web degli URL vietati. Nella lista nera è presente un elenco di pattern URL che indicano gli URL vietati.

      Un pattern URL deve essere nel formato indicato all'indirizzo https://www.chromium.org/administrators/url-blacklist-filter-format.

      È possibile definire eccezioni nella norma relativa alla whitelist di URL. Per queste norme è possibile definire massimo 1000 voci; le voci in più vengono ignorate.

      È sconsigliato bloccare gli URL "chrome://*" interni perché ciò potrebbe generare errori imprevisti.

      Dalla versione M73 è possibile bloccare gli URL "javascript://*" . Tuttavia, interessa solo il codice JavaScript digitato nella barra degli indirizzi (o, ad esempio, nei bookmarklet). Tieni presente che gli URL JavaScript in-page, in presenza di un caricamento dinamico dei dati, non sono soggetti a questa norma. Ad esempio, se blocchi "example.com/abc", la pagina "example.com" continuerà a caricare "example.com/abc" tramite XMLHTTPRequest.

      Se questa norma non viene impostata, non sarà vietato alcun URL nel browser.</translation>
<translation id="1859859319036806634">Avviso. Il fallback della versione TLS sarà rimosso da <ph name="PRODUCT_NAME" /> dopo la versione 52 (nel periodo settembre 2016), dopodiché questa norma non sarà più attiva.

      Se lo handshake TLS non riesce, <ph name="PRODUCT_NAME" /> proverà a stabilire una connessione con una versione precedente di TLS per risolvere i bug nei server HTTPS. Con questa impostazione viene configurata la versione in cui si interrompe il processo di fallback. Se un server esegue correttamente la negoziazione della versione (cioè senza interrompere la connessione), questa impostazione non viene applicata. In ogni caso, la connessione risultante deve essere conforme a SSLVersionMin.

      Se questa norma non è configurata o se viene impostata su "tls1.2", <ph name="PRODUCT_NAME" /> non eseguirà più il fallback. Il supporto per le versioni precedenti di TLS non viene disattivato, solo se <ph name="PRODUCT_NAME" /> eviterà i server che presentano errori e che non sono in grado di trattare correttamente le versioni.

      In caso contrario, se è necessario mantenere la compatibilità con un server con errori, è possibile impostare la norma su "tls1.1". Si tratta di una misura temporanea ed è necessario correggere rapidamente il server.</translation>
<translation id="1864382791685519617">Consente la previsione della rete in <ph name="PRODUCT_NAME" /> e impedisce agli utenti di modificare questa impostazione.

      Controlla il precaricamento DNS, la preconnessione TCP ed SSL e il prerendering delle pagine web.

      Se imposti questa norma, gli utenti non potranno modificare né sostituire questa impostazione in <ph name="PRODUCT_NAME" />.

      Se questa norma non viene impostata, la previsione di rete verrà attivata ma l'utente potrà modificarla.</translation>
<translation id="1865417998205858223">Autorizzazioni chiave</translation>
<translation id="186719019195685253">Azione da compiere quando il ritardo di inattività viene raggiunto durante l'utilizzo della corrente CA</translation>
<translation id="187819629719252111">Consente di accedere ai file locali presenti sul computer, permettendo a <ph name="PRODUCT_NAME" /> di visualizzare le finestre di dialogo di selezione dei file. Se attivi questa impostazione, gli utenti potranno aprire le finestre di dialogo di selezione dei file come di consueto. Se disattivi questa impostazione, ogni volta che l'utente eseguirà un'azione che apre una finestra di dialogo di selezione file (ad esempio importazione di Preferiti, caricamento di file, salvataggio di link e così via), verrà visualizzato un messaggio e il sistema presupporrà che l'utente abbia fatto clic sul pulsante Annulla della finestra di dialogo stessa. Se questa impostazione non viene impostata, gli utenti potranno aprire le finestre di dialogo di selezione file come di consueto.</translation>
<translation id="1885782360784839335">Attiva la visualizzazione di contenuti promozionali a scheda intera</translation>
<translation id="1888871729456797026">Il token di registrazione della norma relativa alla cloud su desktop</translation>
<translation id="1897365952389968758">Consenti l'esecuzione di JavaScript in tutti i siti</translation>
<translation id="1906888171268104594">Consente di stabilire se riferire o meno le metriche sull'utilizzo e i dati diagnostici, inclusi i rapporti sugli arresti anomali, a Google.

      Se la norma viene impostata su true, <ph name="PRODUCT_OS_NAME" /> riferirà le metriche sull'utilizzo e i dati diagnostici.

      Se viene impostata su false, i rapporti sulle metriche e sui dati diagnostici verranno disattivati.

      Se non viene configurata, i rapporti sulle metriche e sui dati diagnostici verranno disattivati sui dispositivi non gestiti e attivati sui dispositivi gestiti.</translation>
<translation id="1907431809333268751">Consente di configurare l'elenco di URL di accesso aziendale (solo schemi HTTP e HTTPS). L'impronta digitale della password sarà acquisita su questi URL e utilizzata successivamente per il rilevamento del riutilizzo della password.
      Affinché <ph name="PRODUCT_NAME" /> possa acquisire correttamente le impronte digitali delle password, assicurati che le pagine di accesso rispettino le linee guida all'indirizzo https://www.chromium.org/developers/design-documents/create-amazing-password-forms.

      Se questa impostazione è attiva, il servizio di protezione tramite password acquisisce l'impronta della password su questi URL ai fini del rilevamento del riutilizzo della password.
      Se questa impostazione è disattivata o non configurata, il servizio di protezione tramite password acquisirà l'impronta della password solo all'indirizzo https://accounts.google.com.
      Questa norma è disponibile esclusivamente per le istanze di Windows che fanno parte di un dominio <ph name="MS_AD_NAME" /> così come per le istanze di Windows 10 Pro o Enterprise registrate per la gestione dei dispositivi.</translation>
<translation id="1914840757300882918">Se questa norma è impostata, l'host utilizzerà un certificato client con il nome comune dell'emittente indicato per eseguire l'autenticazione su RemoteAccessHostTokenValidationUrl. Impostare la norma su "*" per utilizzare qualsiasi certificato client disponibile.

          Questa funzione è attualmente disattivata lato server.</translation>
<translation id="1919802376548418720">Utilizza la norma KDC per delegare credenziali.</translation>
<translation id="1920046221095339924">Consenti la sessione gestita sul dispositivo</translation>
<translation id="1929709556673267855">Consente di specificare le configurazioni delle stampanti aziendali associate ai dispositivi.

      Questa norma ti consente di specificare le configurazioni delle stampanti per i dispositivi <ph name="PRODUCT_OS_NAME" />. Il formato corrisponde a quello del dizionario NativePrinters, con un campo "id" o "guid" aggiuntivo obbligatorio per ciascuna stampante ai fini dell'autorizzazione o della negazione della stessa.

       Le dimensioni del file non devono superare 5 MB e il file deve essere codificato in JSON. È stato stimato che un file contenente circa 21.000 stampanti viene codificato come file di 5 MB. L'hash crittografico viene usato per verificare l'integrità del download.

      Il file viene scaricato e memorizzato nella cache. Verrà scaricato di nuovo ogni volta che cambierà l'URL o l'hash.

      Se questa norma viene impostata, <ph name="PRODUCT_OS_NAME" /> scaricherà il file per le configurazioni delle stampanti e renderà disponibili le stampanti in base alle norme <ph name="DEVICE_PRINTERS_ACCESS_MODE" />, <ph name="DEVICE_PRINTERS_WHITELIST" /> e <ph name="DEVICE_PRINTERS_BLACKLIST" />.

      Questa norma non influisce sulla capacità degli utenti di configurare le stampanti su singoli dispositivi. È supplementare alla configurazione di stampanti da parte dei singoli utenti.

       Si tratta di una norma aggiuntiva alla norma <ph name="BULK_PRINTERS_POLICY" />.

      Se questa norma non viene impostata, non ci saranno stampanti per i dispositivi e le altre norme <ph name="DEVICE_PRINTERS_POLICY_PATTERN" /> verranno ignorate.
      </translation>
<translation id="193259052151668190">Whitelist di dispositivi USB scollegabili</translation>
<translation id="1933378685401357864">Immagine di sfondo</translation>
<translation id="1956493342242507974">Questa norma consente di configurare la gestione dell'alimentazione in relazione alla schermata di accesso di <ph name="PRODUCT_OS_NAME" />.

      Questa norma consente di configurare il comportamento di <ph name="PRODUCT_OS_NAME" /> quando non c'è attività dell'utente per un periodo di tempo mentre è visualizzata la schermata di accesso. La norma consente di controllare diverse impostazioni. Per conoscere la semantica e gli intervalli di valori di ogni impostazione, leggi le norme corrispondenti che consentono di controllare la gestione dell'alimentazione all'interno di una sessione. Le uniche differenze rispetto a queste norme sono:
      * Le azioni da compiere in caso di inattività o chiusura del coperchio non possono essere l'interruzione della sessione.
      * L'azione predefinita compiuta in caso di inattività durante l'alimentazione con corrente alternata è lo spegnimento.

      Se un'impostazione non viene specificata, viene utilizzato un valore predefinito.

      Se questa norma non viene impostata, vengono utilizzati i valori predefiniti per tutte le impostazioni.</translation>
<translation id="1958138414749279167">Consente di attivare la funzione Compilazione automatica di <ph name="PRODUCT_NAME" /> e permette agli utenti di eseguire il completamento automatico dell'indirizzo nei moduli web utilizzando informazioni memorizzate in precedenza.

      Se questa impostazione è disattivata, la funzione Compilazione automatica non suggerirà o non inserirà mai i dati relativi all'indirizzo, né salverà altre informazioni relative ad altri indirizzi che l'utente potrebbe inviare durante la navigazione sul Web.

      Se questa impostazione è attivata o non è impostata su alcun valore, l'utente potrà gestire la funzione Compilazione automatica per gli indirizzi nell'interfaccia utente.</translation>
<translation id="1962273523772270623">Consenti la raccolta di log eventi WebRTC dai servizi Google</translation>
<translation id="1964634611280150550">Modalità di navigazione in incognito non attiva</translation>
<translation id="1964802606569741174">Questa norma non ha effetto sull'app YouTube per Android. Se è necessario applicare la modalità di protezione di YouTube, l'installazione dell'app YouTube per Android non deve essere consentita.</translation>
<translation id="1969212217917526199">Sostituisce le build di debug dell'host di accesso remoto.

          Il valore viene analizzato come un dizionario JSON di associazioni tra nomi e valori di norme.</translation>
<translation id="1969808853498848952">Esegue sempre i plug-in che richiedono l'autorizzazione (ritirata)</translation>
<translation id="1988371335297483117">I payload di aggiornamento automatico su <ph name="PRODUCT_OS_NAME" /> possono essere scaricati tramite HTTP anziché tramite HTTPS. Ciò consente la memorizzazione nella cache HTTP trasparente dei download HTTP.

      Se questa norma viene impostata su true, <ph name="PRODUCT_OS_NAME" /> tenterà di scaricare payload di aggiornamento automatico tramite HTTP. Se la norma viene impostata su false o non viene impostata, per il download di payload di aggiornamento automatico verrà utilizzato HTTPS.</translation>
<translation id="199764499252435679">Consenti gli aggiornamenti dei componenti in <ph name="PRODUCT_NAME" /></translation>
<translation id="1997994951395619441">Se attivi questa impostazione, in <ph name="PRODUCT_NAME" /> verrà visualizzata una barra dei Preferiti.

      Se disattivi questa impostazione, gli utenti non visualizzeranno mai la barra dei Preferiti.

      Se attivi o disattivi questa impostazione, gli utenti non potranno modificarla o sostituirla in <ph name="PRODUCT_NAME" />.

      Se questa impostazione non è impostata, l'utente può decidere se usare o meno tale funzione.</translation>
<translation id="2006530844219044261">Gestione dell'alimentazione</translation>
<translation id="2014757022750736514">Consente di stabilire il comportamento della schermata di accesso, da cui gli utenti possono accedere ai propri account. Le impostazioni consentono di decidere chi può accedere, che tipi di account sono consentiti, quali metodi di autenticazione devono essere usati. Sono disponibili anche impostazioni generali relative ad accessibilità, metodo di immissione e lingue.</translation>
<translation id="201557587962247231">Frequenza dei caricamenti del rapporto sullo stato del dispositivo</translation>
<translation id="2017301949684549118">URL per abb web da installare automaticamente.</translation>
<translation id="2018836497795982119">Consente di specificare in millisecondi il periodo di tempo per cui vengono richieste informazioni sui criteri relativi agli utenti al servizio di gestione del dispositivo.

      Se questo criterio viene impostato, il valore predefinito di tre ore viene ignorato. L'intervallo dei valori validi per questo criterio è compreso tra 1800000 (30 minuti) e 86400000 (un giorno). I valori non compresi in questo intervallo verranno bloccati al relativo limite. Se la piattaforma supporta le notifiche relative ai criteri, il ritardo dell'aggiornamento verrà impostato su 24 ore perché è previsto che le notifiche relative ai criteri forzino l'aggiornamento automatico quando cambiano i criteri.

      Se questo criterio non viene impostato, <ph name="PRODUCT_NAME" /> utilizzerà il valore predefinito di tre ore.

      Se la piattaforma supporta le notifiche relative ai criteri, il ritardo dell'aggiornamento verrà impostato su 24 ore (vengono ignorati tutti i valori predefiniti e il valore di questo criterio) perché è previsto che le notifiche relative ai criteri forzino l'aggiornamento automatico quando cambiano i criteri, rendendo superflui aggiornamenti più frequenti.</translation>
<translation id="2024476116966025075">Configura il nome di dominio richiesto per i client di accesso remoto</translation>
<translation id="2030905906517501646">Parola chiave del provider di ricerca predefinito</translation>
<translation id="203096360153626918">Questa norma non ha effetto sulle app Android, che saranno in grado di entrare in modalità a schermo intero anche se la norma viene impostata su <ph name="FALSE" />.</translation>
<translation id="2043770014371753404">Stampanti aziendali disattivate</translation>
<translation id="2050629715135525072">Controlla la capacità di un utente connesso a un host di accesso remoto di trasferire file dal client all'host e viceversa. Questa norma non si applica alle connessioni di assistenza remota, le quali non supportano il trasferimento di file.

          Se questa impostazione è disattivata, il trasferimento di file non sarà concesso. Se questa impostazione è attivata o non configurata, il trasferimento di file sarà concesso.</translation>
<translation id="2057317273526988987">Consenti l'accesso a un elenco di URL</translation>
<translation id="2061810934846663491">Configura i nomi di dominio richiesti per gli host di accesso remoto</translation>
<translation id="206623763829450685">Consente di specificare gli schemi di autenticazione HTTP supportati da <ph name="PRODUCT_NAME" />.

          I valori possibili sono "basic", "digest", "ntlm" e "negotiate". Separa i valori con la virgola.

          Se questa norma non viene impostata, vengono utilizzati tutti e quattro gli schemi.</translation>
<translation id="2067011586099792101">Blocca l'accesso ai siti non presenti nei pacchetti di contenuti</translation>
<translation id="2073552873076775140">Consenti di eseguire l'accesso a <ph name="PRODUCT_NAME" /></translation>
<translation id="2077129598763517140">Usa accelerazione hardware quando disponibile</translation>
<translation id="2077273864382355561">Ritardo disattivazione schermo in caso di utilizzo della batteria</translation>
<translation id="2082205219176343977">Configura la versione minima di Chrome consentita per il dispositivo.</translation>
<translation id="209586405398070749">Canale stabile</translation>
<translation id="2098658257603918882">Attiva rapporti sull'utilizzo e sui dati relativi agli arresti anomali</translation>
<translation id="2104418465060359056">Segnala i dati delle estensioni e dei plug-in</translation>
<translation id="2106627642643925514">Consente di sostituire la modalità di stampa PIN predefinita. Se la modalità non è disponibile, questa norma viene ignorata.</translation>
<translation id="2107601598727098402">
        La norma è obsoleta in M72. Utilizza invece CloudManagementEnrollmentToken.
        </translation>
<translation id="2111016292707172233">Consente di attivare la disponibilità della funzione Tocca per cercare nella visualizzazione contenuti di <ph name="PRODUCT_NAME" />.

      Se attivi questa impostazione, la funzione Tocca per cercare sarà a disposizione degli utenti, che potranno scegliere se attivarla o disattivarla.

      Se disattivi questa impostazione, la funzione Tocca per cercare verrà disattivata completamente.

      Non impostare questa norma equivale ad attivarla; leggi la descrizione precedente.</translation>
<translation id="2113068765175018713">Limita il tempo di attività del dispositivo riavviandolo automaticamente</translation>
<translation id="2116790137063002724">Questa norma consente di stabilire se segnalare o meno informazioni che possono essere usate per identificare gli utenti, ad esempio i dati di accesso al sistema operativo, i dati di accesso del profilo <ph name="PRODUCT_NAME" />, il nome del profilo <ph name="PRODUCT_NAME" />, il percorso del profilo <ph name="PRODUCT_NAME" /> e il percorso eseguibile di <ph name="PRODUCT_NAME" />.

      Se questa norma non viene impostata o viene impostata su True, vengono raccolte le informazioni che possono essere usate per identificare gli utenti.
      Se questa norma viene impostata su False, non vengono raccolte le informazioni che possono essere usate per identificare gli utenti.

      Questa norma viene applicata soltanto se viene attivata l'estensione <ph name="CHROME_REPORTING_EXTENSION_NAME" /> e il computer viene registrato con la norma <ph name="MACHINE_LEVEL_USER_CLOUD_POLICY_ENROLLMENT_TOKEN_POLICY_NAME" />.</translation>
<translation id="2127599828444728326">Consenti notifiche su questi siti</translation>
<translation id="2131902621292742709">Ritardo oscuramento schermo in caso di utilizzo della batteria</translation>
<translation id="2134437727173969994">Consenti blocco dello schermo</translation>
<translation id="2137064848866899664">Se la norma viene impostata, ogni schermo viene ruotato secondo l'orientamento specificato, a ogni riavvio e la prima volta che viene collegato in seguito alla modifica della norma. Dopo aver eseguito l'accesso, gli utenti possono modificare la rotazione dello schermo tramite la pagina delle impostazioni ma, al successivo riavvio, la loro impostazione viene sostituita dal valore della norma.

      La norma si applica allo schermo principale e a tutti gli schermi secondari.

      Se la norma non viene impostata, il valore predefinito è 0° e l'utente può modificarlo liberamente. In questo caso, il valore predefinito non viene applicato nuovamente al riavvio.</translation>
<translation id="2138449619211358657">Questa norma consente a <ph name="PRODUCT_OS_NAME" /> di aggirare qualsiasi proxy per l'autenticazione tramite captive portal.

      Questa norma viene applicata soltanto se viene configurato un proxy (ad esempio tramite la norma, dall'utente in chrome://settings o dalle estensioni).

      Se attivi questa impostazione, qualsiasi pagina di autenticazione tramite captive portal (ossia tutte le pagine web per cui viene inizialmente visualizzata una pagina di accesso tramite captive portal finché <ph name="PRODUCT_NAME" /> rileva una connessione Internet attiva) verrà visualizzata in una finestra separata e vengono ignorate tutte le impostazioni delle norme e le restrizioni relative all'utente corrente.

      Se disattivi questa impostazione o non la configuri, qualsiasi pagina di autenticazione tramite captive portal verrà visualizzata in una scheda del browser nuova (e normale) utilizzando le impostazioni proxy dell'utente corrente.</translation>
<translation id="21394354835637379">Consente di specificare quali URL sono autorizzati a installare estensioni, applicazioni e temi.

          A partire da <ph name="PRODUCT_NAME" /> 21, è più difficile installare estensioni, applicazioni e script utente dal di fuori del Chrome Web Store. In passato, gli utenti potevano fare clic su un link a un file *.crx e <ph name="PRODUCT_NAME" /> avrebbe proposto di installare il file dopo alcuni avvisi. Dopo <ph name="PRODUCT_NAME" /> 21, tali file devono essere scaricati e trascinati nella pagina delle impostazioni di <ph name="PRODUCT_NAME" />. Questa impostazione consente a URL specifici di utilizzare il precedente flusso di installazione semplificato.

          Ogni voce di questo elenco è un pattern di corrispondenza in stile di estensione (vedi https://developer.chrome.com/extensions/match_patterns). Gli utenti potranno installare facilmente elementi da qualsiasi URL che corrisponda a una voce nell'elenco. Questi pattern devono consentire sia la posizione del file *.crx sia la pagina da cui viene avviato il download (ossia il referrer).

          <ph name="EXTENSION_INSTALL_BLACKLIST_POLICY_NAME" /> ha la precedenza su questa norma. Ciò significa che un'estensione presente nella lista nera non verrà installata, anche se è di un sito presente in questo elenco.</translation>
<translation id="214901426630414675">Limita la modalità di stampa fronte/retro</translation>
<translation id="2149330464730004005">Attiva la stampa a colori</translation>
<translation id="2156132677421487971">Consente di configurare le norme per <ph name="PRODUCT_NAME" />, una funzione che permette agli utenti di inviare i contenuti di schede, siti o del desktop dal browser a schermi remoti e sistemi audio.</translation>
<translation id="2166472654199325139">Non filtrare i siti di contenuti per adulti</translation>
<translation id="2168397434410358693">Ritardo inattività in caso di utilizzo di CA</translation>
<translation id="217013996107840632">Parametri della riga di comando per cambiare il browser alternativo.</translation>
<translation id="2170233653554726857">Attiva ottimizzazione WPAD</translation>
<translation id="2176565653304920879">Se questa norma viene impostata, il flusso di rilevamento automatico del fuso orario sarà uno dei seguenti, a seconda del valore dell'impostazione:

      Se la norma viene impostata su TimezoneAutomaticDetectionUsersDecide, gli utenti potranno controllare il rilevamento automatico del fuso orario tramite i normali controlli alla pagina chrome://settings.

      Se la norma viene impostata su TimezoneAutomaticDetectionDisabled, i controlli per il rilevamento automatico del fuso orario alla pagina chrome://settings saranno disattivati. Il rilevamento automatico del fuso orario sarà sempre disattivato.

      Se la norma viene impostata su TimezoneAutomaticDetectionIPOnly, i controlli per il rilevamento automatico del fuso orario alla pagina chrome://settings saranno disattivati. Il rilevamento automatico del fuso orario sarà sempre attivo. La funzione di rilevamento del fuso orario utilizzerà il metodo Solo IP per stabilire la posizione.

      Se la norma viene impostata su TimezoneAutomaticDetectionSendWiFiAccessPoints, i controlli per il rilevamento automatico del fuso orario alla pagina chrome://settings saranno disattivati. Il rilevamento automatico del fuso orario sarà sempre attivo. L'elenco dei punti di accesso Wi-Fi visibili sarà sempre inviato al server dell'API di geolocalizzazione per rilevare il fuso orario con precisione.

      Se la norma viene impostata su TimezoneAutomaticDetectionSendAllLocationInfo, i controlli per il rilevamento automatico del fuso orario alla pagina chrome://settings saranno disattivati. Il rilevamento automatico del fuso orario sarà sempre attivo. Le informazioni sulla posizione (ad esempio, punti di accesso Wi-Fi, torri radio raggiungibili, GPS) saranno inviate a un server per rilevare il fuso orario con precisione.

      Se la norma non viene impostata, verrà gestita come se fosse impostata su TimezoneAutomaticDetectionUsersDecide.

      Se la norma SystemTimezone è impostata, sostituisce questa norma. In questo caso il rilevamento automatico del fuso orario viene completamente disattivato.</translation>
<translation id="2178899310296064282">Imponi almeno il Livello medio della Modalità con restrizioni su YouTube</translation>
<translation id="2182291258410176649">L'utente decide se abilitare il backup e il ripristino</translation>
<translation id="2183294522275408937">Questa impostazione consente di stabilire la frequenza della richiesta di inserimento della password nella schermata di blocco per poter continuare a utilizzare lo sblocco rapido. Se il periodo di tempo trascorso dall'ultima volta che è stata inserita la password è superiore alla frequenza impostata, lo sblocco rapido non sarà disponibile quando si accede alla schermata di blocco. Se l'utente rimane nella schermata di blocco per un periodo superiore a quello impostato, verrà richiesta la password la volta successiva che l'utente inserirà il codice sbagliato o accederà di nuovo alla schermata di blocco.

      Se questa impostazione viene configurata, gli utenti che usano lo sblocco rapido devono inserire le proprie password nella schermata di blocco in base a questa impostazione.

      Se questa impostazione non viene configurata, gli utenti che usano lo sblocco rapido devono inserire ogni giorno la propria password nella schermata di blocco.</translation>
<translation id="2194470398825717446">Questa norma è stata ritirata in M61. Usa la norma EcryptfsMigrationStrategy.

      Consente di specificare come deve comportarsi un dispositivo con ecryptfs e come deve passare alla crittografia ext4.

      Se questa norma viene impostata su "DisallowArc", le app Android verranno disattivate per tutti gli utenti configurati sul dispositivo (inclusi quelli che hanno già la crittografia ext4) e gli utenti non avranno la possibilità di eseguire la migrazione da ecryptfs alla crittografia ext4.

      Se questa norma viene impostata su "AllowMigration", gli utenti con directory principali ecryptfs avranno la possibilità di eseguire la migrazione di queste directory alla crittografia ext4, se necessario (attualmente quando Android N diventa disponibile sul dispositivo).

      Questa norma non viene applicata alle app kiosk, di cui viene eseguita la migrazione automatica. Se questa norma non viene impostata, il dispositivo si comporterà come se fosse stata scelta l'opzione "DisallowArc".</translation>
<translation id="2195032660890227692">Questa norma è stata rimossa in <ph name="PRODUCT_NAME" /> 68 e sostituita da <ph name="ARC_BR_POLICY_NAME" />.</translation>
<translation id="219720814106081560">Se la norma è attivata o non configurata (impostazione predefinita), all'utente verrà richiesto
      l'accesso all'acquisizione video ad accezione degli URL configurati
      nell'elenco VideoCaptureAllowedUrls, per i quali verrà concesso l'accesso senza richiesta.

      Quando questa norma è disattivata, all'utente non verrà mai richiesto nulla e l'accesso all'acquisizione
      video sarà disponibile solo per gli URL configurati in VideoCaptureAllowedUrls.

      Questa norma si applica a tutti i tipi di ingressi video e non solo alla fotocamera integrata.</translation>
<translation id="2201555246697292490">Configura whitelist messaggi nativi</translation>
<translation id="2204753382813641270">Controlla la visualizzazione automatica dello shelf</translation>
<translation id="2208976000652006649">Parametri per l'URL di ricerca che utilizza POST</translation>
<translation id="2214880135980649323">Se questa norma viene attivata, le estensioni installate in base alle norme aziendali possono usare l'API Enterprise Hardware Platform.
      Se questa norma viene disattivata e non viene impostata, nessuna estensione può usare l'API Enterprise Hardware Platform.
      Questa norma si applica anche a estensioni di componenti come l'estensione Hangout Services.</translation>
<translation id="2223598546285729819">Impostazione di notifica predefinita</translation>
<translation id="2231817271680715693">Importa cronologia di navigazione dal browser predefinito alla prima esecuzione</translation>
<translation id="2236488539271255289">Non consentire ai siti di impostare i dati locali</translation>
<translation id="2240879329269430151">Permette di stabilire se consentire o meno la visualizzazione dei popup nei siti web. La visualizzazione dei popup può essere consentita o negata per tutti i siti web. Se questa norma non viene impostata, verrà utilizzato il valore "BlockPopups", che potrà essere modificato dagli utenti.</translation>
<translation id="2255326053989409609">L'attivazione di questa impostazione impedisce alle pagine web di accedere alla GPU (Graphics Processing Unit). Nello specifico, le pagine web non possono avere accesso all'API WebGL e i plug-in non possono usare l'API Pepper 3D.

      Se questa impostazione viene disattivata o non viene impostata, le pagine web potranno utilizzare l'API WebGL e i plug-in potranno utilizzare l'API Pepper 3D. Le impostazioni predefinite del browser possono comunque richiedere la convalida di argomenti della riga di comando per utilizzare queste API.

      Se HardwareAccelerationModeEnabled è impostato su false, Disable3DAPIs verrà ignorata ed equivale all'impostazione su true di Disable3DAPIs.</translation>
<translation id="2258126710006312594">Consenti l'accesso remoto agli utenti per trasferire file da/verso l'host</translation>
<translation id="2265214338421787313">Questa norma consente all'amministratore di specificare che una pagina può mostrare i popup durante l'unload.

      Quando la norma è impostata su attivata, le pagine possono mostrare i popup mentre viene eseguito l'unload.

      Quando la norma è impostata su disattivata o non impostata, le pagine non possono mostrare i popup mentre viene eseguito l'unload, come da specifiche (https://html.spec.whatwg.org/#apis-for-creating-and-navigating-browsing-contexts-by-name).

      Nella versione 82 di Chrome, questa norma verrà rimossa.

      Consulta https://www.chromestatus.com/feature/5989473649164288 .</translation>
<translation id="2269319728625047531">Abilita la visualizzazione del consenso alla sincronizzazione durante l'accesso</translation>
<translation id="2274864612594831715">Questa norma consente di configurare l'attivazione della tastiera virtuale come dispositivo di immissione su Chrome OS. Gli utenti non possono sostituire questa norma.

      Se la norma viene impostata su true, la tastiera virtuale sullo schermo sarà sempre attiva.

      Se viene impostata su false, la tastiera virtuale sullo schermo sarà sempre disattivata.

      Se imposti questa norma, gli utenti non possono cambiarla o sostituirla. Potranno, però, attivare/disattivare una tastiera sullo schermo di accessibilità che ha la precedenza sulla tastiera virtuale controllata da questa norma. Leggi la norma |VirtualKeyboardEnabled| per il controllo della tastiera sullo schermo di accessibilità.

      Se questa norma non viene impostata, la tastiera sullo schermo viene inizialmente disattivata ma può essere attivata dall'utente in qualsiasi momento. Potrebbero anche essere utilizzate regole euristiche per stabilire quando visualizzare la tastiera.</translation>
<translation id="2292084646366244343"><ph name="PRODUCT_NAME" /> può utilizzare un servizio web Google per correggere gli errori di ortografia. Se questa impostazione è abilitata, il servizio viene sempre utilizzato. Se questa impostazione è disabilitata, il servizio non viene mai utilizzato.

      Il controllo ortografico può essere comunque effettuato utilizzando un dizionario scaricato; questa norma controlla soltanto l'utilizzo del servizio online.

      Se questa impostazione non è configurata, gli utenti possono scegliere se utilizzare o meno il servizio di controllo ortografico.</translation>
<translation id="2294283832646774959">Consente di configurare un elenco di stampanti.

      Questa norma consente agli amministratori di fornire configurazioni delle stampanti
      ai propri utenti.

      <ph name="PRINTER_DISPLAY_NAME" /> e <ph name="PRINTER_DESCRIPTION" /> sono stringhe in formato libero che è possibile personalizzare per selezionare facilmente le stampanti. I valori <ph name="PRINTER_MANUFACTURER" /> e <ph name="PRINTER_MODEL" />, che rappresentano il produttore e il modello della stampante, consentono agli utenti finali di identificare più facilmente le stampanti. Il valore <ph name="PRINTER_URI" /> deve essere un indirizzo raggiungibile da un computer client che includa <ph name="URI_SCHEME" />, <ph name="URI_PORT" /> e <ph name="URI_QUEUE" />. Il valore <ph name="PRINTER_UUID" /> è facoltativo, ma se viene specificato viene utilizzato per consentire la deduplicazione delle stampanti <ph name="ZEROCONF_DISCOVERY" />.

      Il valore <ph name="PRINTER_EFFECTIVE_MODEL" /> deve corrispondere a una delle stringhe che rappresentano una stampante supportata da <ph name="PRODUCT_NAME" />. La stringa verrà usata per identificare e installare il file PPD appropriato per la stampante. È possibile trovare ulteriori informazioni all'indirizzo https://support.google.com/chrome?p=noncloudprint.

      La configurazione viene completata al primo utilizzo della stampante. I file PPD vengono scaricati soltanto quando viene utilizzata la stampante. Dopodiché, i PPD utilizzati più spesso vengono memorizzati nella cache.

      Questa norma non influisce sulla possibilità per gli utenti di configurare le stampanti su singoli dispositivi. È supplementare alla configurazione di stampanti da parte dei singoli utenti.

      Per i dispositivi Active Directory gestiti, questa norma supporta l'espansione di <ph name="MACHINE_NAME_VARIABLE" /> al nome della macchina Active Directory oppure a una sua sottostringa. Ad esempio, se il nome della macchina è <ph name="MACHINE_NAME_EXAMPLE" />, allora la variabile <ph name="MACHINE_NAME_VARIABLE_EXAMPLE" /> verrà sostituita dai quattro caratteri che iniziano dopo la sesta posizione, ad esempio, <ph name="MACHINE_NAME_PART_EXAMPLE" />. Tieni presente che la posizione è in base zero.
      </translation>
<translation id="2294382669900758280">Il video riprodotto nelle app Android non viene considerato, anche se la norma viene impostata su <ph name="TRUE" />.</translation>
<translation id="2299220924812062390">Consente di specificare un elenco dei plug-in attivati</translation>
<translation id="2303795211377219696">Attiva la Compilazione automatica per le carte di credito</translation>
<translation id="2309390639296060546">Impostazione di geolocalizzazione predefinita</translation>
<translation id="2327252517317514801">Definisci i domini autorizzati ad accedere a G Suite</translation>
<translation id="2356878440219553005">Consente di specificare il criterio di gestione della modalità di ricarica della batteria.

          Controlla in modo dinamico la carica della batteria per minimizzarne l'usura dovuta alle sollecitazioni dell'utilizzo e aumentarne la durata.

          Se la modalità di ricarica personalizzata della batteria è selezionata, è necessario specificare DeviceBatteryChargeCustomStartCharging e DeviceBatteryChargeCustomStopCharging.

          Se questo criterio è impostato, la modalità di ricarica della batteria verrà applicata se supportata sul dispositivo.

          Se questo criterio non viene impostato e il criterio è supportato sul dispositivo, verrà applicata la modalità di ricarica standard della batteria e l'impostazione non potrà essere modificata dall'utente.

          Nota: <ph name="DEVICE_ADVANCED_BATTERY_CHARGE_MODE_ENABLED_NAME" /> sovrascrive questo criterio se il primo è specificato.</translation>
<translation id="237494535617297575">Consente di impostare un elenco di pattern URL che specificano i siti autorizzati a visualizzare notifiche. Se questa norma non viene impostata, per tutti i siti verrà utilizzato il valore predefinito globale della norma "DefaultNotificationsSetting", se è impostata, oppure verrà utilizzata la configurazione personale dell'utente.</translation>
<translation id="2386362615870139244">Consenti Wakelock dello schermo</translation>
<translation id="2411817661175306360">L'avviso di protezione tramite password non è attivo</translation>
<translation id="2411919772666155530">Blocca le notifiche su questi siti</translation>
<translation id="2418507228189425036">Consente di disattivare il salvataggio della cronologia del browser in <ph name="PRODUCT_NAME" /> e di impedire agli utenti di modificare questa impostazione.

      Se questa impostazione è attivata, la cronologia di navigazione non viene salvata. Con questa impostazione viene disattivata anche la sincronizzazione delle schede.

      Se questa impostazione è disattivata o non viene impostata, la cronologia di navigazione viene salvata.</translation>
<translation id="2426782419955104525">Consente di attivare la funzione Instant di <ph name="PRODUCT_NAME" /> e di impedire agli utenti di modificare l'impostazione.

      Se l'impostazione viene attivata, la funzione Instant di <ph name="PRODUCT_NAME" /> viene attivata.

      Se l'impostazione viene disattivata, la funzione Instant di <ph name="PRODUCT_NAME" /> viene disattivata.

      Se l'impostazione viene attivata o disattivata, gli utenti non potranno modificarla o ignorarla.

      Se l'impostazione non viene impostata, l'utente può decidere se utilizzare o meno la funzione.

      L'impostazione è stata rimossa da <ph name="PRODUCT_NAME" /> 29 e versioni successive.</translation>
<translation id="2433412232489478893">Questa norma controlla se per un utente è consentita o meno la funzione Condivisioni file di rete per <ph name="PRODUCT_NAME" />.

      Quando questa norma non è configurata o è impostata su True, gli utenti possono utilizzare la funzione Condivisioni file di rete.

      Quando questa norma è impostata su False, gli utenti non possono utilizzare la funzione Condivisioni file di rete.</translation>
<translation id="2438609638493026652">Attiva la segnalazione di eventi chiave durante l'installazione di app Android a Google. Gli eventi vengono acquisiti solo per le app la cui installazione è stata lanciata tramite norma.

      Se la norma viene impostata su True, gli eventi saranno registrati.
      Se la norma viene impostata su False o non viene impostata, gli eventi non saranno registrati.</translation>
<translation id="244317009688098048">Attiva scorciatoia da tastiera bailout per accesso automatico.

      Se questa norma non è impostata o è impostata su True e un account dispositivo locale è configurato per l'accesso automatico senza ritardo, <ph name="PRODUCT_OS_NAME" /> rispetterà la scorciatoia da tastiera Ctrl+Alt+S per bypassare l'accesso automatico e la visualizzazione della schermata di accesso.

      Se questa norma è impostata su False, l'accesso automatico senza ritardo (se configurato) non può essere bypassato.</translation>
<translation id="2454228136871844693">Ottimizza per aumentare la stabilità.</translation>
<translation id="2463034609187171371">Attiva i pacchetti di crittografia DHE in TLS</translation>
<translation id="2463365186486772703">Lingua dell'applicazione</translation>
<translation id="2466131534462628618">L'autenticazione tramite captive portal ignora il proxy</translation>
<translation id="2482676533225429905">Messaggi nativi</translation>
<translation id="2483146640187052324">Prevedi le azioni di rete su qualsiasi connessione di rete</translation>
<translation id="2484208301968418871">Questa norma consente di gestire l'applicazione del filtro di URL di SafeSites.
      Questo filtro usa l'API Google SafeSearch per classificare gli URL come pornografici o meno.

      Se questa norma non viene configurata o viene impostata su "Non filtrare i siti di contenuti per adulti", i siti non verranno filtrati.

      Se questa norma viene impostata su "Filtra i siti di contenuti per adulti di primo livello", i siti classificati come pornografici verranno filtrati.</translation>
<translation id="2486371469462493753">Disattiva l'imposizione dei requisiti di Certificate Transparency per gli URL elencati.

      Questa norma consente ai certificati per i nomi host negli URL specificati di non essere resi pubblici tramite Certificate Transparency. Consente ai certificati che altimenti sarebbero considerati inattendibili, in quanto non appropriatamente resi pubblici, di continuare a essere utilizzati. Tuttavia, la norma rende più difficile il rilevamento di certificati emessi in modo scorretto per questi host.

      Un pattern URL è nel formato indicato all'indirizzo https://www.chromium.org/administrators/url-blacklist-filter-format. Tuttavia, siccome i certificati sono validi per un determinato nome host indipendente dallo schema, dalla porta o dal percorso, viene considerata solo la parte del nome host dell'URL. Gli host jolly non sono supportati.

      Se questa norma non viene impostata, i certificati che devono essere resi pubblici tramite Certificate Transparency verranno considerati come inaffidabili in quanto non sono sono resi pubblici come previsto dalle norme di Certificate Transparency.</translation>
<translation id="2488010520405124654">Consente di attivare la richiesta di configurazione della rete in modalità offline.

      Se questa norma non viene impostata o viene impostata su True, se un account locale sul dispositivo è configurato per l'accesso automatico senza ritardo e il dispositivo non ha accesso a Internet, in <ph name="PRODUCT_OS_NAME" /> viene visualizzata una richiesta di configurazione della rete.

      Se questa norma viene impostata su False, verrà visualizzato un messaggio di errore anziché la richiesta di configurazione della rete.</translation>
<translation id="2498238926436517902">Nascondi sempre automaticamente lo shelf</translation>
<translation id="2514328368635166290">Consente di specificare l'URL dell'icona preferita del provider di ricerca predefinito. Questa norma è facoltativa. Se non viene impostata, per il provider di ricerca non verrà visualizzata alcuna icona. Questa norma viene rispettata soltanto se è attiva la norma "DefaultSearchProviderEnabled".</translation>
<translation id="2516600974234263142">Consente di attivare la stampa in <ph name="PRODUCT_NAME" /> e impedisce agli utenti di modificare questa impostazione.

      Se l'impostazione è attivata o non è configurata, gli utenti possono stampare.

      Se l'impostazione è disattivata, gli utenti non possono stampare da <ph name="PRODUCT_NAME" />. La stampa è disattivata nel menu Strumenti, nelle estensioni, nelle app JavaScript e così via. È possibile stampare da plug-in che ignorano <ph name="PRODUCT_NAME" /> durante la stampa. Ad esempio, alcune app Flash presentano l'opzione di stampa nel loro menu contestuale, che non è analizzato in questo criterio.</translation>
<translation id="2518231489509538392">Consenti riproduzione audio</translation>
<translation id="2521581787935130926">Mostra la scorciatoia per le app nella barra dei Preferiti</translation>
<translation id="2529659024053332711">Consente di specificare il comportamento all'avvio.

          Se viene selezionata l'opzione "Apri la pagina Nuova scheda", all'avvio di <ph name="PRODUCT_NAME" /> verrà sempre aperta la pagina Nuova scheda.

         Se viene selezionata l'opzione "Ripristina l'ultima sessione", verranno riaperti gli URL che erano aperti l'ultima volta che è stato chiuso <ph name="PRODUCT_NAME" /> e la sessione di navigazione verrà ripristinata così com'era.
          La selezione di questa opzione comporta la disattivazione di alcune impostazioni basate sulle sessioni o che compiono azioni all'uscita, ad esempio la cancellazione dei dati di navigazione alla chiusura o dei cookie della sessione.

          Se selezioni "Apri un elenco di URL", quando un utente avvia <ph name="PRODUCT_NAME" /> viene aperto l'elenco di "URL da aprire all'avvio".

          Se attivi questa impostazione, gli utenti non potranno modificarla o ignorarla in <ph name="PRODUCT_NAME" />.

         Disattivare questa impostazione equivale a non configurarla. Gli utenti potranno ancora modificarla in <ph name="PRODUCT_NAME" />.

          Questa norma è disponibile esclusivamente per le istanze di Windows che fanno parte di un dominio <ph name="MS_AD_NAME" />così come per le istanze di Windows 10 Pro o Enterprise registrate per la gestione dei dispositivi.</translation>
<translation id="2529880111512635313">Configura l'elenco di estensioni e app con installazione imposta</translation>
<translation id="253135976343875019">Ritardo avviso inattività in caso di utilizzo di CA</translation>
<translation id="2536525645274582300">L'utente decide se abilitare i servizi di geolocalizzazione di Google</translation>
<translation id="254653220329944566">Consente di attivare il reporting su cloud di <ph name="PRODUCT_NAME" /></translation>
<translation id="2548572254685798999">Segnala dati di Navigazione sicura</translation>
<translation id="2550593661567988768">Solo stampa su un lato</translation>
<translation id="2552966063069741410">Fuso orario</translation>
<translation id="2562339630163277285">Consente di specificare l'URL del motore di ricerca utilizzato per fornire risultati immediati. L'URL deve contenere la stringa <ph name="SEARCH_TERM_MARKER" />, che verrà sostituita in fase di query dal testo inserito dall'utente fino a quel momento.

          Questa norma è facoltativa. Se non viene impostata, non verranno restituiti risultati di ricerca immediati.

          L'URL per i risultati immediati di Google può essere specificato come segue: <ph name="GOOGLE_INSTANT_SEARCH_URL" />.

          Questa norma viene rispettata soltanto se è attiva la norma "DefaultSearchProviderEnabled".</translation>
<translation id="2569647487017692047">Se questa norma viene impostata su false, il Bluetooth verrà disattivato in <ph name="PRODUCT_OS_NAME" /> e l'utente non potrà riattivarlo.

      Se questa norma viene impostata su true o non viene impostata, l'utente potrà attivare o disattivare il Bluetooth come preferisce.

      Se questa norma viene impostata, l'utente non potrà modificarla o eseguirne l'override.

      Dopo avere attivato il Bluetooth, l'utente deve uscire e accedere di nuovo per applicare le modifiche (questa operazione non è necessaria se il Bluetooth viene disattivato).</translation>
<translation id="2571066091915960923">Consente di attivare o disattivare il proxy di compressione dei dati e di impedire agli utenti di cambiare questa impostazione.

Se attivi o disattivi questa impostazione, gli utenti non potranno cambiarla o ignorarla.

Se questa norma non viene impostata, l'utente potrà scegliere se utilizzare o meno la funzione proxy di compressione dei dati.</translation>
<translation id="257788512393330403">Richiedi inserimento della password ogni sei ore</translation>
<translation id="2587719089023392205">Imposta <ph name="PRODUCT_NAME" /> come browser predefinito</translation>
<translation id="2592091433672667839">Durata inattività prima della visualizzazione dello screensaver nella schermata di accesso in modalità retail</translation>
<translation id="2592162121850992309">Se questa norma è impostata su true o non è impostata, verrà attivata l'accelerazione hardware a meno che una determinata funzione della GPU non sia stata inserita nella lista nera.

      Se la norma è impostata su false, l'accelerazione hardware verrà disattivata.</translation>
<translation id="2596260130957832043">Consente di stabilire se attivare o meno l'autenticazione NTLMv2.

          Tutte le versioni recenti dei server Samba e Windows supportano l'autenticazione NTLMv2, che deve essere disattivata solo per garantire la compatibilità con le versioni precedenti, in quanto riduce la sicurezza dell'autenticazione.

          Se questa norma non viene impostata, l'impostazione predefinita è true e l'autenticazione NTLMv2 è attivata.</translation>
<translation id="2604182581880595781">Configura le norme relative alla funzione Condivisioni file di rete</translation>
<translation id="2623014935069176671">Attesa dell'attività iniziale dell'utente</translation>
<translation id="262740370354162807">Attiva l'invio di documenti a <ph name="CLOUD_PRINT_NAME" /></translation>
<translation id="2627554163382448569">Consente di specificare le configurazioni delle stampanti aziendali.

      Questa norma ti consente di specificare le configurazioni delle stampanti per i dispositivi <ph name="PRODUCT_OS_NAME" />. Il formato corrisponde a quello del dizionario NativePrinters, con un campo "id" o "guid" aggiuntivo obbligatorio per ciascuna stampante ai fini dell'autorizzazione o della negazione della stessa.

      Le dimensioni del file non devono superare 5 MB e il file deve essere codificato in JSON. È stato stimato che un file contenente circa 21.000 stampanti viene codificato come file di 5 MB. L'hash crittografico viene usato per verificare l'integrità del download.

      Il file viene scaricato e memorizzato nella cache. Verrà scaricato di nuovo ogni volta che cambierà l'URL o l'hash.

      Se questa norma viene impostata, <ph name="PRODUCT_OS_NAME" /> scaricherà il file per le configurazioni delle stampanti e renderà disponibili le stampanti in base alle norme <ph name="BULK_PRINTERS_ACCESS_MODE" />, <ph name="BULK_PRINTERS_WHITELIST" /> e <ph name="BULK_PRINTERS_BLACKLIST" />.

      Se imposti questa norma, gli utenti non possono modificarla o ignorarla.

      Questa norma non influisce sulla capacità degli utenti di configurare le stampanti su singoli dispositivi. È supplementare alla configurazione di stampanti da parte dei singoli utenti.
      </translation>
<translation id="2633084400146331575">Attiva la funzione di lettura vocale</translation>
<translation id="2646290749315461919">Permette di stabilire se consentire o meno il monitoraggio della posizione fisica degli utenti da parte dei siti web. Il monitoraggio della posizione fisica degli utenti può essere consentito o negato per impostazione predefinita oppure l'utente può ricevere una richiesta ogni volta che un sito web desidera conoscere la posizione fisica. Se questa norma non viene impostata, verrà utilizzato il valore "AskGeolocation", che potrà essere modificato dagli utenti.</translation>
<translation id="2647069081229792812">Attiva o disattiva la funzione di modifica dei preferiti</translation>
<translation id="2649896281375932517">Consenti agli utenti di decidere</translation>
<translation id="2650049181907741121">Azione da compiere quando l'utente chiude il coperchio</translation>
<translation id="2655233147335439767">Consente di specificare l'URL del motore di ricerca utilizzato per eseguire una ricerca per impostazione predefinita. L'URL deve contenere la stringa "<ph name="SEARCH_TERM_MARKER" />", che verrà sostituita in fase di query dai termini di ricerca inseriti dall'utente.

          L'URL per la ricerca di Google può essere specificato come segue: <ph name="GOOGLE_SEARCH_URL" />.

          Questa opzione deve essere impostata quando la norma "DefaultSearchProviderEnabled" è attiva e verrà rispettata soltanto in questo caso.</translation>
<translation id="2659019163577049044">Se questa impostazione viene attivata, gli utenti potranno configurare il proprio dispositivo in modo da sincronizzare i messaggi SMS tra i telefoni e i Chromebooks. Tieni presente che se questa norma viene consentita, gli utenti devono attivare in modo esplicito questa funzione tramite il completamento del flusso di configurazione. Una volta completato il flusso di configurazione, gli utenti potranno inviare e ricevere messaggi SMS sui loro Chromebook.

      Se questa impostazione è disattivata, gli utenti non potranno configurare la sincronizzazione degli SMS.

      Se questa norma non viene impostata, per impostazione predefinita non sarà disponibile per gli utenti gestiti, mentre lo sarà invece per gli utenti non gestiti.</translation>
<translation id="2660846099862559570">Non utilizzare mai un proxy</translation>
<translation id="2663739737868438950">Questo criterio si applica alla schermata di accesso. Vedi anche il criterio <ph name="SITE_PER_PROCESS_POLICY_NAME" /> che viene applicato alla sessione utente. È consigliabile impostare lo stesso valore per entrambi i criteri. Se i valori non corrispondono, può verificarsi un ritardo quando si accede a una sessione utente mentre viene applicato il valore specificato dai criteri relativi agli utenti.
      Potresti considerare l'impostazione del criterio IsolateOrigins per ottenere sia l'isolamento sia un impatto limitato per gli utenti. Usa IsolateOrigins con un elenco dei siti che vuoi isolare. Questa impostazione, SitePerProcess, isola tutti i siti.
      Se il criterio è attivato, ciascun sito verrà eseguito nel proprio processo.
      Se il criterio è disattivato, le funzionalità IsolateOrigins e SitePerProcess saranno entrambe disattivate. Gli utenti potranno ancora attivare SitePerProcess manualmente, tramite flag da riga di comando.
      Se il criterio non è configurato, l'utente potrà modificare questa impostazione.</translation>
<translation id="2672012807430078509">Controlla l'attivazione del protocollo di autenticazione NTLM per i montaggi SMB</translation>
<translation id="267596348720209223">Consente di specificare le codifiche dei caratteri supportate dal provider di ricerca. Le codifiche sono nomi di pagine codificati come UTF-8, GB2312 e ISO-8859-1. Vengono provate nell'ordine indicato. Questa norma è facoltativa. Se non viene impostata viene utilizzato il valore predefinito UTF-8. Questa norma viene rispettata soltanto se è attiva la norma "DefaultSearchProviderEnabled".</translation>
<translation id="268577405881275241">Attiva la funzione proxy di compressione dei dati</translation>
<translation id="2693108589792503178">Configura l'URL di modifica della password.</translation>
<translation id="2706708761587205154">Consenti la stampa solo con PIN</translation>
<translation id="2710534340210290498">Se la norma viene impostata su false, gli utenti non potranno bloccare lo schermo (sarà possibile solo la disconnessione dalla sessione utente). Se l'impostazione viene impostata su true o non viene configurata, gli utenti autenticati mediante password potranno bloccare lo schermo.</translation>
<translation id="2731627323327011390">Disattiva l'utilizzo dei certificati <ph name="PRODUCT_OS_NAME" /> per le app ARC</translation>
<translation id="2742843273354638707">Consente di nascondere l'app Chrome Web Store e il link nel piè di pagina nella pagina Nuova scheda e in Avvio applicazioni di <ph name="PRODUCT_OS_NAME" />.

      Quando questa norma è impostata su true, le icone sono nascoste.

      Quando questa norma è impostata su false o non è configurata, le icone sono visibili.</translation>
<translation id="2744751866269053547">Registra gestori protocolli</translation>
<translation id="2746016768603629042">Questa norma è obsoleta; utilizza invece DefaultJavaScriptSetting.

      Può essere utilizzata per disattivare JavaScript in <ph name="PRODUCT_NAME" />.

      Se questa impostazione viene disattivata, le pagine web non potranno utilizzare JavaScript e l'utente non potrà modificare tale impostazione.

      Se questa impostazione viene attivata o non è impostata, le pagine web potranno utilizzare JavaScript ma l'utente potrà modificare tale impostazione.</translation>
<translation id="2747157663401642394">Consente di configurare le impostazioni di gestione delle estensioni per <ph name="PRODUCT_NAME" />.

          Questa norma controlla più impostazioni, tra cui quelle controllate da norme correlate alle estensioni già presenti. Questa norma sostituisce tutte le norme precedenti se vengono impostate entrambe.

          Questa norma consente di mappare un ID estensione o un URL di aggiornamento alla relativa configurazione. Con un ID estensione, la configurazione viene applicata solo all'estensione specificata. È possibile impostare una configurazione predefinita per l'ID speciale <ph name="DEFAULT_SCOPE" />, che verrà applicato a tutte le estensioni per cui non è impostata una configurazione personalizzata in questa norma. Con un URL di aggiornamento, la configurazione verrà applicata a tutte le estensioni con l'esatto URL di aggiornamento indicato nel file manifest dell'estensione, come descritto all'indirizzo <ph name="LINK_TO_EXTENSION_DOC1" />.

          Per le istanze di Windows che non fanno parte di un dominio <ph name="MS_AD_NAME" />, l'installazione forzata è limitata alle app e alle estensioni elencate nel Chrome Web Store.

          Per una descrizione completa delle possibili impostazioni e della struttura di questa norma, visita la pagina https://www.chromium.org/administrators/policy-list-3/extension-settings-full
          </translation>
<translation id="2753637905605932878">Limita l'intervallo di porte UDP locali utilizzato da WebRTC</translation>
<translation id="2757054304033424106">Tipi di estensioni/app che possono essere installati</translation>
<translation id="2758084448533744848">Consente di specificare il fuso orario da usare obbligatoriamente per il dispositivo. Se questa norma viene impostata, gli utenti del dispositivo non possono sostituire il fuso orario specificato. Se viene specificato un valore non valido, la norma viene attivata comunque usando il valore "GMT". Se viene specificata una stringa vuota, la norma viene ignorata.

      Se la norma non viene utilizzata, rimane in uso il fuso orario attivo corrente, ma gli utenti possono modificarlo.

      Sui nuovi dispositivi è impostato il fuso orario "US/Pacific".

      Il formato del valore segue quello dei nomi dei fusi orari dello "IANA Time Zone Database" (visita la pagina "https://en.wikipedia.org/wiki/Tz_database"). In particolare, gran parte dei fusi orari può essere indicata come "continent/large_city" o "ocean/large_city".

      Se questa norma viene impostata, la scelta automatica del fuso orario in base alla posizione del dispositivo viene completamente disattivata. Sostituisce anche la norma SystemTimezoneAutomaticDetection.</translation>
<translation id="2759224876420453487">Controlla il comportamento dell'utente in una sessione profilo multiplo</translation>
<translation id="2761483219396643566">Ritardo avviso inattività in caso di utilizzo della batteria</translation>
<translation id="2762164719979766599">Specifica l'elenco di account del dispositivo da visualizzare nella schermata di accesso.

      Ogni voce in elenco specifica un identificatore che viene utilizzato internamente per distinguere i vari account del dispositivo.</translation>
<translation id="2769952903507981510">Configura il nome di dominio richiesto per gli host di accesso remoto</translation>
<translation id="2787173078141616821">Segnala informazioni sullo stato di Android</translation>
<translation id="2799297758492717491">Consenti la riproduzione automatica dei contenuti multimediali per una whitelist di pattern URL</translation>
<translation id="2801155097555584385">Imposta il valore personalizzato espresso in percentuale raggiunto il quale la batteria avvia la ricarica</translation>
<translation id="2801230735743888564">Consente di attivare il gioco del dinosauro quando il dispositivo è offline.

      Se questa norma viene impostata su False, gli utenti non potranno giocare al gioco del dinosauro quando il dispositivo è offline. Se viene impostata su True, gli utenti potranno giocare. Se la norma non viene impostata, gli utenti non potranno giocare al gioco del dinosauro su sistemi Chrome OS registrati, ma potranno giocarvi in altre circostanze.</translation>
<translation id="2802085784857530815">Ti consente di stabilire se permettere o meno agli utenti di accedere a stampanti non aziendali

      Se la norma viene impostata su True o non viene impostata, gli utenti potranno aggiungere, configurare e usare le proprie stampanti native.

      Se la norma viene impostata su False, gli utenti non potranno aggiungere e configurare le proprie stampanti native. Non potranno neanche stampare con eventuali stampanti native configurate in precedenza.
      </translation>
<translation id="2805707493867224476">Consenti la visualizzazione di popup in tutti i siti</translation>
<translation id="2808013382476173118">Consente di attivare l'utilizzo di server STUN quando i client remoti tentano di stabilire una connessione con questo computer.

          Se questa impostazione viene attivata, i client remoti possono rilevare questo computer e collegarsi a esso anche se sono separati da un firewall.

          Se questa impostazione viene disattivata e le connessioni UDP in uscita vengono filtrate dal firewall, questo computer consentirà soltanto connessioni da computer client all'interno della rete locale.

          Se questa norma non viene impostata l'impostazione verrà attivata.</translation>
<translation id="2813281962735757923">Questa norma consente di regolare gli intervalli di tempo durante i quali al dispositivo <ph name="PRODUCT_OS_NAME" /> non è consentito verificare automaticamente la disponibilità di aggiornamenti.
      Quando questa norma è impostata su un elenco valido di intervalli di tempo:
      Ai dispositivi non sarà consentito verificare automaticamente la disponibilità di aggiornamenti durante gli intervalli di tempo specificati. A causa di possibili problemi di sicurezza, questa norma non avrà conseguenze sui dispositivi che richiedono il rollback o dispongono di una versione inferiore alla versione minima di <ph name="PRODUCT_OS_NAME" />. Inoltre, questa norma non impedirà le verifiche degli aggiornamenti richieste dagli utenti o dagli amministratori.
      Quando la norma non viene impostata o non contiene intervalli di tempo:
      Le verifiche automatiche degli aggiornamenti non verranno bloccate da questa norma, ma potrebbero essere bloccate da altre norme. Questa funzionalità è attiva solo sui dispositivi Chrome configurati come kiosk ad avvio automatico. Gli altri dispositivi non risulteranno limitati da questa norma.</translation>
<translation id="2823870601012066791">Posizione del Registro di sistema di Windows per client <ph name="PRODUCT_OS_NAME" />:</translation>
<translation id="2824715612115726353">Attiva modalità di navigazione in incognito</translation>
<translation id="2836621397261130126">Controlla se l'approvazione della norma KDC viene rispettata per decidere se delegare i ticket <ph name="KERBEROS" />.

          Se questa norma viene impostata su true, l'autenticazione HTTP rispetta l'approvazione da parte della norma KDC, ad esempio Chrome delega solo le credenziali se il KDC imposta <ph name="OK_AS_DELEGATE" /> su un ticket di servizio. Per ulteriori informazioni, visita la pagina https://tools.ietf.org/html/rfc5896.html. Il servizio deve corrispondere anche alla norma "AuthNegotiateDelegateWhitelist".

          Se questa norma non viene impostata o viene impostata su false, la norma KDC viene ignorata sulle piattaforme supportate e solo la norma "AuthNegotiateDelegateWhitelist" viene rispettata.

          Su Windows la norma KDC viene sempre rispettata.</translation>
<translation id="283695852388224413">Se la norma è impostata, viene applicata la lunghezza di PIN massima configurata. Un valore uguale a 0 o inferiore indica che non esiste una lunghezza massima; in questo caso l'utente può impostare un PIN della lunghezza che preferisce. Se questa impostazione è minore di <ph name="PIN_UNLOCK_MINIMUM_LENGTH_POLICY_NAME" /> ma maggiore di 0, allora la lunghezza massima corrisponde a quella minima.

          Se questa norma non viene impostata, non è applicata alcuna lunghezza massima.</translation>
<translation id="2838830882081735096">Non consentire migrazione dei dati e ARC</translation>
<translation id="2839294585867804686">Impostazioni di Condivisioni file di rete</translation>
<translation id="2840269525054388612">Consente di specificare le stampanti utilizzabili dagli utenti.

      Questa norma viene usata soltanto se viene selezionata l'opzione <ph name="PRINTERS_WHITELIST" /> per la norma <ph name="DEVICE_PRINTERS_ACCESS_MODE" />.

      Se viene usata questa norma, solo le stampanti con ID corrispondenti ai valori della norma saranno disponibili per gli utenti. Gli ID devono corrispondere ai campi "id" o "guid" del file specificato nella norma <ph name="DEVICE_PRINTERS_POLICY" />.
      </translation>
<translation id="2842152347010310843">Controlla la whitelist dei pattern URL su cui è sempre attivata la riproduzione automatica.

      Se la riproduzione automatica è attivata, in <ph name="PRODUCT_NAME" /> i video possono essere riprodotti automaticamente (ovvero senza il consenso dell'utente) assieme ai contenuti audio.

      Esempi di specifiche di pattern URL valide:

      - [*.]domain.tld (corrisponde a domain.tld e a tutti i sottodomini)

      - host (corrisponde a un preciso nome host)

      - scheme://host:port (schemi supportati: http,https)

      - scheme://[*.]domain.tld:port (schemi supportati: http,https)

      - file://path (il percorso deve essere un percorso assoluto e iniziare con "/")

      - a.b.c.d (corrisponde a un preciso ip IPv4)

      - [a:b:c:d:e:f:g:h] (corrisponde a un preciso ip IPv6)

      Se la norma AutoplayAllowed è impostata su True, questa norma non avrà effetto.

      Se la norma AutoplayAllowed è impostata su False, i pattern URL configurati in questa norma potranno ancora essere riprodotti.

      Tieni presente che, se <ph name="PRODUCT_NAME" /> è in esecuzione e la norma cambia, sarà applicata solo alle nuove schede aperte. Pertanto alcune schede potrebbero continuare a osservare il comportamento precedente.</translation>
<translation id="285480231336205327">Attiva modalità ad alto contrasto</translation>
<translation id="2854919890879212089">Consente di impostare in <ph name="PRODUCT_NAME" /> l'uso della stampante predefinita del sistema, anziché della stampante usata più di recente, come opzione predefinita della finestra Anteprima di stampa.

      Se disattivi o non configuri questa impostazione, in Anteprima di stampa viene indicata la stampante utilizzata più di recente come destinazione predefinita.

      Se attivi questa impostazione, in Anteprima di stampa viene usata la stampante predefinita del sistema operativo come destinazione predefinita.</translation>
<translation id="285627849510728211">Imposta la modalità di configurazione giornaliera per la ricarica avanzata della batteria</translation>
<translation id="2856674246949497058">Esegui il rollback e rimani nella versione target se la versione del sistema operativo è più recente di quella target. Esegui un powerwash durante la procedura.</translation>
<translation id="2872961005593481000">Spegni</translation>
<translation id="2873651257716068683">Consente di eseguire l'override delle dimensioni predefinite delle pagine di stampa. Se le dimensioni della pagina non sono disponibili, questa norma viene ignorata.</translation>
<translation id="2874209944580848064">Nota per i dispositivi <ph name="PRODUCT_OS_NAME" /> che supportano le app Android:</translation>
<translation id="2877225735001246144">Disabilita ricerca CNAME durante la negoziazione con Kerberos</translation>
<translation id="2890645751406497668">Concede automaticamente a questi siti l'autorizzazione a connettersi a dispositivi USB usando gli ID fornitore e prodotto forniti.</translation>
<translation id="2892414556511568464">Consente di limitare la modalità di stampa fronte/retro. Se la norma non viene impostata o viene lasciata vuota non vengono applicate limitazioni.</translation>
<translation id="2893546967669465276">Consente di inviare log di sistema al server di gestione</translation>
<translation id="2899002520262095963">Le app Android possono utilizzare le configurazioni di rete e i certificati CA impostati tramite questa norma ma non hanno accesso ad alcune opzioni di configurazione.</translation>
<translation id="290002216614278247">Questa norma consente di bloccare la sessione dell'utente in base al tempo del client o alla quota di utilizzo del giorno.

          |time_window_limit| consente di specificare un periodo giornaliero in cui la sessione dell'utente deve essere bloccata. Supportiamo solo una regola per ogni giorno della settimana, quindi la matrice |entries| potrebbe variare da 0 a 7. |starts_at| e |ends_at| corrispondono all'inizio e alla fine del limite del periodo. Quando |ends_at| è inferiore a |starts_at| significa che il periodo |time_limit_window| termina il giorno successivo. |last_updated_millis| è il timestamp UTC relativo all'ultimo aggiornamento della voce in questione, che viene inviato sotto forma di stringa perché non si adatta a un numero intero.

          |time_usage_limit| consente di specificare una quota giornaliera di utilizzo dello schermo che, una volta raggiunta, blocca la sessione dell'utente. Esiste una proprietà per ogni giorno della settimana, che dovrebbe essere impostata solo se esiste una quota attiva per il giorno in questione. |usage_quota_mins| indica per quanto tempo è possibile usare il dispositivo gestito nell'arco di una giornata, mentre |reset_at| indica il momento in cui viene rinnovata la quota di utilizzo. Il valore predefinito di |reset_at| è mezzanotte ({'hour': 0, 'minute': 0}). |last_updated_millis| è il timestamp UTC relativo all'ultimo aggiornamento della voce in questione, che viene inviato sotto forma di stringa perché non si adatta a un numero intero.

          Il valore |overrides| viene fornito per invalidare temporaneamente una o più regole precedenti.
          * Se non sono attivi né time_window_limit né time_usage_limit, è possibile usare |LOCK| per bloccare il dispositivo.
          * |LOCK| consente di bloccare temporaneamente una sessione utente fino all'inizio dei valori time_window_limit o time_usage_limit successivi.
          * |UNLOCK| consente di sbloccare la sessione di un utente bloccata in base a time_window_limit o time_usage_limit.
          |created_time_millis| è il timestamp UTC per la creazione dell'override che viene inviato sotto forma di stringa perché non si adatta a un numero intero. Viene usato per stabilire se applicare ancora l'override o meno. Se la funzione del limite di tempo attivo corrente (limite di tempo di utilizzo o limite della finestra temporale) è iniziata dopo la creazione dell'override, non dovrebbe essere applicata. Inoltre, se l'override è stato creato prima dell'ultima modifica dei valori time_window_limit o time_usage_window attivi, non dovrebbe essere applicato.

          È possibile inviare più override; viene applicata la voce valida più recente.</translation>
<translation id="2905984450136807296">Durata dei dati di autenticazione nella cache</translation>
<translation id="2906874737073861391">Elenco di estensioni AppPack</translation>
<translation id="2907992746861405243">Consente di stabilire quali stampanti della norma <ph name="BULK_PRINTERS_POLICY" /> mettere a disposizione degli utenti.

      Determina quale norma di accesso usare per la configurazione collettiva delle stampanti. Se viene selezionata l'opzione <ph name="PRINTERS_ALLOW_ALL" />, vengono mostrate tutte le stampanti. Se viene selezionata l'opzione <ph name="PRINTERS_BLACKLIST" />, viene usata la norma <ph name="BULK_PRINTERS_BLACKLIST" /> per limitare l'accesso a stampanti specifiche. Se viene selezionata l'opzione <ph name="PRINTERS_WHITELIST" />, la norma <ph name="BULK_PRINTERS_WHITELIST" /> stabilisce soltanto le stampanti selezionabili.

      Se questa norma non viene impostata, viene usata l'opzione <ph name="PRINTERS_ALLOW_ALL" />.
      </translation>
<translation id="2908277604670530363">Numero massimo di connessioni simultanee al server proxy</translation>
<translation id="2948463916588961959">Forza l'attivazione delle lingue per correttore ortografico. Le lingue non riconosciute di quell'elenco verranno ignorate.

      Se attivi questa norma, il correttore ortografico verrà attivato per le lingue specificate, oltre alle lingue per le quali l'utente ha attivato il correttore ortografico.

      Se non imposti la norma o la disattivi, le preferenze sul correttore ortografico dell'utente rimarranno invariate.

      Questa norma non verrà applicata se la norma SpellcheckEnabled è disattivata.

      Se una lingua è inclusa sia in questa norma che nella norma SpellcheckLanguageBlacklist, questa norma ha la priorità e verrà attivata la lingua per il correttore ortografico.

      Le lingue attualmente supportate sono: af, bg, ca, cs, da, de, el, en-AU, en-CA, en-GB, en-US, es, es-419, es-AR, es-ES, es-MX, es-US, et, fa, fo, fr, he, hi, hr, hu, id, it, ko, lt, lv, nb, nl, pl, pt-BR, pt-PT, ro, ru, sh, sk, sl, sq, sr, sv, ta, tg, tr, uk, vi.</translation>
<translation id="2952347049958405264">Limitazioni:</translation>
<translation id="2956777931324644324">Questa norma è stata ritirata a partire dalla versione 36 di <ph name="PRODUCT_NAME" />.

      Consente di specificare se attivare o meno l'estensione di certificati associati al dominio TLS.

      Questa impostazione viene utilizzata per attivare l'estensione di certificati associati al dominio TLS per l'esecuzione di test. Questa impostazione sperimentale verrà rimossa in futuro.</translation>
<translation id="2957506574938329824">Non consentire ad alcun sito di richiedere l'accesso ai dispositivi Bluetooth tramite l'API Web Bluetooth</translation>
<translation id="2957513448235202597">Tipo di account per l'autenticazione <ph name="HTTP_NEGOTIATE" /></translation>
<translation id="2959469725686993410">Invia sempre i punti di accesso Wi-Fi al server durante le operazioni per stabilire il fuso orario</translation>
<translation id="2959898425599642200">Regole di bypass proxy</translation>
<translation id="2960128438010718932">Il programma di gestione temporanea per l'applicazione di nuovi aggiornamenti</translation>
<translation id="2960691910306063964">Consente di attivare o disattivare l'autenticazione senza PIN per gli host di accesso remoto</translation>
<translation id="2976002782221275500">Consente di specificare il periodo di tempo senza input dell'utente trascorso il quale lo schermo viene oscurato quando viene utilizzata la batteria.

Se questa norma viene impostata su un valore maggiore di zero, consente di specificare il periodo di tempo per cui l'utente deve rimanere inattivo prima che <ph name="PRODUCT_OS_NAME" /> oscuri lo schermo.

Se questa norma viene impostata su zero, <ph name="PRODUCT_OS_NAME" /> non oscura lo schermo quando l'utente diventa inattivo.

Se questa norma non viene impostata, viene utilizzato un periodo di tempo predefinito.

Il valore della norma deve essere specificato in millisecondi. I valori devono essere inferiori o uguali al ritardo di disattivazione dello schermo (se impostato) e al ritardo di inattività.</translation>
<translation id="2977997796833930843">Tieni presente che questa norma è obsoleta e sarà rimossa.

          Questa norma fornisce un valore di riserva per le norme più specifiche <ph name="IDLE_ACTION_AC_POLICY_NAME" /> e <ph name="IDLE_ACTION_BATTERY_POLICY_NAME" />. Se questa norma viene impostata, il suo valore viene utilizzato se non viene impostata la rispettiva norma più specifica.

          Quando questa norma non viene impostata, il comportamento delle norme più specifiche rimane invariato.</translation>
<translation id="2987155890997901449">Attiva ARC</translation>
<translation id="2987227569419001736">Controlla l'utilizzo dell'API Web Bluetooth</translation>
<translation id="3011301228198307065">Consente di configurare l'URL della home page predefinita di <ph name="PRODUCT_NAME" /> e di impedire agli utenti di modificarlo.

          La home page è la pagina che viene aperta facendo clic sul pulsante Home. Le pagine che si aprono all'avvio vengono stabilite dalle norme RestoreOnStartup.

          La home page può essere un URL specificato qui oppure la pagina Nuova scheda. Se selezioni la pagina Nuova scheda, questa norma non viene applicata.

          Se attivi questa impostazione, gli utenti non possono cambiare l'URL della home page di <ph name="PRODUCT_NAME" />, ma possono scegliere come home page la pagina Nuova scheda.

          Se questa norma non viene impostata e non viene impostata neanche la norma HomepageIsNewTabPage, l'utente potrà scegliere la home page che preferisce.

          L'URL deve avere uno schema standard, ad esempio "http://example.com" o "https://example.com".

          Questa norma è disponibile esclusivamente per le istanze di Windows che fanno parte di un dominio <ph name="MS_AD_NAME" /> così come per le istanze di Windows 10 Pro o Enterprise registrate per la gestione dei dispositivi.</translation>
<translation id="3016255526521614822">Autorizza l'uso di app per scrivere note nella schermata di blocco di <ph name="PRODUCT_OS_NAME" /></translation>
<translation id="3021562480854470924">Numero di obiettivi consentiti per il rollback</translation>
<translation id="3023572080620427845">URL di un file XML che contiene gli URL da caricare su un browser alternativo.</translation>
<translation id="3030000825273123558">Attiva rapporti sulle metriche</translation>
<translation id="3033660238345063904">Puoi specificare l'URL del server proxy qui.

          Questa norma viene applicata solo se hai selezionato manualmente le impostazioni proxy in "Scegli come specificare le impostazioni del server proxy" e se la norma <ph name="PROXY_SETTINGS_POLICY_NAME" /> non è stata specificata.

          Devi lasciare questa norma non impostata se hai selezionato una qualsiasi altra modalità per l'impostazione delle norme relative al proxy.

          Per ulteriori opzioni ed esempi dettagliati, visita:
          <ph name="PROXY_HELP_URL" />.</translation>
<translation id="3034580675120919256">Permette di stabilire se consentire o meno l'esecuzione di JavaScript nei siti web. L'esecuzione di JavaScript può essere consentita o negata per tutti i siti web. Se questa norma non viene impostata, verrà utilizzato il valore "AllowJavaScript", che potrà essere modificato dagli utenti.</translation>
<translation id="3038323923255997294">Continua a eseguire applicazioni in background dopo la chiusura di <ph name="PRODUCT_NAME" /></translation>
<translation id="3046192273793919231">Invia pacchetti di rete al server di gestione per monitorare lo stato online</translation>
<translation id="3047732214002457234">Consente di stabilire la modalità di segnalazione dei dati di Chrome Software Cleaner a Google</translation>
<translation id="304775240152542058">Questa norma consente di stabilire i parametri della riga di comando da inviare al browser alternativo.

      Se questa norma non viene impostata, solo l'URL viene passato come parametro della riga di comando.

      Se questa norma viene impostata su un elenco di stringhe, ogni stringa viene passata al browser alternativo come parametro distinto della riga di comando. Su Windows, i parametri vengono uniti mediante spazi. Su Mac OS X e Linux, un parametro può contenere spazi e venire comunque considerato come un singolo parametro.

      Se un elemento contiene ${url}, viene sostituito con l'URL della pagina da aprire.

      Se nessun elemento contiene ${url}, l'URL viene aggiunto alla fine della riga di comando.

      Le variabili d'ambiente vengono espanse. Su Windows, la variabile %ABC% viene sostituita con il valore della variabile d'ambiente ABC. Su Mac OS X e Linux, la variabile ${ABC} viene sostituita con il valore della variabile d'ambiente ABC.</translation>
<translation id="3048744057455266684">Se questa norma viene impostata e un URL di ricerca suggerito dalla omnibox contiene questo parametro nella stringa di ricerca o nell'identificatore del frammento, il suggerimento visualizzerà i termini di ricerca e il fornitore del servizio di ricerca anziché l'URL di ricerca non elaborato.

Questa norma è facoltativa. Se non viene impostata, non verrà effettuata alcuna sostituzione dei termini di ricerca.

Questa norma viene rispettata soltanto se viene attivata la norma "DefaultSearchProviderEnabled".</translation>
<translation id="306887062252197004">Questa norma consente agli utenti della funzione WebDriver di eseguire l'override delle norme che possono interferire con il relativo funzionamento.

      Al momento questa norma disattiva le norme SitePerProcess e IsolateOrigins.

      Se la norma viene attivata, WebDriver potrà eseguire l'override delle norme non compatibili.
      Se la norma viene disattivata o non viene configurata, WebDriver non potrà eseguire l'override delle norme non compatibili.</translation>
<translation id="3069958900488014740">Consente di disattivare l'ottimizzazione WPAD (Web Proxy Auto-Discovery) in <ph name="PRODUCT_NAME" />.

      Se questa norma è impostata su false, l'ottimizzazione WPAD viene disattivata, aumentando così i tempi di attesa da parte di <ph name="PRODUCT_NAME" /> dei server WPAD basati su DNS. Se questa norma non è impostata oppure se è attiva, l'ottimizzazione WPAD è abilitata.

      Indipendentemente da se o come questa norma è impostata, l'utente non può modificare l'impostazione di ottimizzazione di WPAD.</translation>
<translation id="3072045631333522102">Screensaver da utilizzare nella schermata di accesso in modalità retail</translation>
<translation id="3072847235228302527">Imposta i Termini di servizio di un account locale del dispositivo</translation>
<translation id="3077183141551274418">Abilita o disabilita i cicli di vita delle schede</translation>
<translation id="3079417254871857650">Consente di specificare l'azione che deve essere eseguita quando la home directory dell'utente è stata creata con la crittografia ecryptfs.

      Se imposti questo criterio su "DisallowArc", le app Android verranno disattivate per l'utente e non verrà eseguita nessuna migrazione dalla crittografia ecryptfs alla crittografia ext4. Alle app Android non verrà impedita l'esecuzione quando la home directory è già criptata con ext4.

      Se imposti questo criterio su "Migrate", all'accesso le home directory criptate con ecryptfs migreranno automaticamente alla crittografia ext4 senza chiedere l'autorizzazione dell'utente.

      Se imposti questa criterio su "Wipe", le home directory criptate con ecryptfs saranno eliminate all'accesso e al loro posto verranno create nuove home directory criptate con ext4. Avviso: questa operazione rimuove i dati locali dell'utente.

      Se imposti questo criterio su "MinimalMigrate", le home directory criptate con ecryptfs saranno eliminate all'accesso e al loro posto verranno create nuove home directory criptate con ext4. Tuttavia, si cercherà di mantenere i token di accesso per evitare all'utente di dover accedere di nuovo. Avviso: questa operazione rimuove i dati locali dell'utente.

      Se imposti questo criterio su un'opzione non più supportata ("AskUser" o "AskForEcryptfsArcUsers"), verrà tratta come se avessi selezionato "Migrate".

      Questo criterio non si applica agli utenti kiosk. Se questo criterio non è impostata, il dispositivo si comporterà come se fosse stato scelto "DisallowArc".</translation>
<translation id="3086995894968271156">Consente di configurare Cast Receiver in <ph name="PRODUCT_NAME" />.</translation>
<translation id="3088796212846734853">Questa norma consente di impostare un elenco di pattern URL che specificano i siti in cui è consentita la visualizzazione di immagini.

          Se questa norma non viene impostata, per tutti i siti verrà utilizzato il valore predefinito globale della norma "DefaultImagesSetting", se è impostata, oppure verrà utilizzata la configurazione personale dell'utente.

          Tieni presente che in precedenza questa norma è stata erroneamente abilitata su Android, ma questa funzione non è mai stata completamente supportata su Android.</translation>
<translation id="3091832372132789233">Carica la batteria dei dispositivi che sono principalmente collegati a una fonte di alimentazione esterna.</translation>
<translation id="3096595567015595053">Elenco dei plug-in attivati</translation>
<translation id="3101501961102569744">Scegli come specificare le impostazioni del server proxy</translation>
<translation id="3101709781009526431">Data e ora</translation>
<translation id="3117676313396757089">Avviso. DHE sarà rimosso completamente da <ph name="PRODUCT_NAME" /> dopo la versione 57 (nel periodo di marzo 2017), dopodiché questa norma non sarà più attiva.

      Se la norma non viene impostata o se viene impostata su false, i pacchetti di crittografia DHE in TLS non saranno attivati. In alternativa, la norma può essere impostata su true per attivare i pacchetti di crittografia DHE e per mantenere la compatibilità con un server obsoleto. Si tratta di una soluzione temporanea ed è necessario configurare nuovamente il server.

      Si consiglia di effettuare la migrazione dei server ai pacchetti di crittografia ECDHE. Se non sono disponibili, assicurati che siano attivati i pacchetti di crittografia con l'utilizzo dello scambio delle chiavi RSA.</translation>
<translation id="3117706142826400449">Se questa norma viene disattivata, Chrome Software Cleaner non potrà eseguire la scansione del sistema per individuare eventuale software indesiderato e ripulire il sistema. L'attivazione manuale di Chrome Software Cleaner da chrome://settings/cleanup viene disattivata.

      Se la norma viene attivata o non viene impostata, Chrome Software Cleaner eseguirà periodicamente la scansione del sistema per individuare eventuale software indesiderato e, qualora fosse presente, chiederà all'utente se vuole rimuoverlo. L'attivazione manuale di Chrome Software Cleaner da chrome://settings viene attivata.

      Questa norma è disponibile esclusivamente per le istanze di Windows che fanno parte di un dominio <ph name="MS_AD_NAME" /> così come per le istanze di Windows 10 Pro o Enterprise registrate per la gestione dei dispositivi.</translation>
<translation id="3152425128389603870">Rendi disponibile la modalità Desktop unificato e attivala per impostazione predefinita</translation>
<translation id="3159375329008977062">L'utente è abilitato a importare/esportare contenitori Crostini tramite l'interfaccia</translation>
<translation id="3165808775394012744">Queste norme sono incluse qui in modo che sia più facile rimuoverle.</translation>
<translation id="316778957754360075">Questa impostazione non è più supportata a partire dalla versione 29 di <ph name="PRODUCT_NAME" />. Il metodo consigliato per la configurazione di raccolte di estensioni/app ospitate dall'organizzazione consiste nell'includere il sito che ospita i pacchetti CRX in ExtensionInstallSources e inserire link di download diretti per i pacchetti in una pagina web. È possibile creare una funzione Avvio applicazioni per la pagina web utilizzando la norma ExtensionInstallForcelist.</translation>
<translation id="3171369832001535378">Modello del nome host della rete del dispositivo</translation>
<translation id="3172512016079904926">Consente di attivare l'installazione a livello di utente degli host di messaggistica nativi.

          Se l'impostazione viene attivata, <ph name="PRODUCT_NAME" /> consentirà l'utilizzo degli host di messaggistica nativi installati a livello di utente.

          Se l'impostazione viene disattivata, allora <ph name="PRODUCT_NAME" /> utilizzerà solo gli host di messaggistica nativi installati a livello di sistema.

          Se l'impostazione non è specificata, <ph name="PRODUCT_NAME" /> consentirà l'utilizzo degli host di messaggistica nativi a livello di utente.</translation>
<translation id="3177802893484440532">Richiedi controlli OCSP/CRL online per i trust anchor</translation>
<translation id="3185009703220253572">a partire dalla versione <ph name="SINCE_VERSION" /></translation>
<translation id="3187220842205194486">Le app Android non possono accedere alle chiavi aziendali. Questa norma non influisce su di esse.</translation>
<translation id="3205825995289802549">Ingrandisci la prima finestra del browser alla prima esecuzione</translation>
<translation id="3211426942294667684">Impostazioni di accesso al browser</translation>
<translation id="3214164532079860003">Se è attiva, questa norma impone l'importazione della pagina iniziale dal browser predefinito corrente. Se non è attiva, la pagina iniziale non viene importata. Se non viene impostata, all'utente potrebbe essere chiesto se desidera effettuare l'importazione, oppure l'importazione potrebbe avvenire automaticamente.</translation>
<translation id="3219421230122020860">Modalità di navigazione in incognito disponibile</translation>
<translation id="3220624000494482595">Se l'app kiosk è un'app Android, non avrà controllo sulla versione di <ph name="PRODUCT_OS_NAME" />, anche se la norma viene impostata su <ph name="TRUE" />.</translation>
<translation id="3236046242843493070">Pattern URL per consentire installazioni di estensioni, applicazioni e script utente da</translation>
<translation id="3240609035816615922">Norma di accesso alla configurazione delle stampanti.</translation>
<translation id="3240655340884151271">Indirizzo MAC NIC integrato del dock</translation>
<translation id="3243309373265599239">Consente di specificare il periodo di tempo senza input dell'utente trascorso il quale lo schermo viene oscurato quando viene utilizzata la corrente alternata.

Se questa norma viene impostata su un valore maggiore di zero, consente di specificare il periodo di tempo per cui l'utente deve rimanere inattivo prima che <ph name="PRODUCT_OS_NAME" /> oscuri lo schermo.

Se questa norma viene impostata su zero, <ph name="PRODUCT_OS_NAME" /> non oscura lo schermo quando l'utente diventa inattivo.

Se questa norma non viene impostata, viene utilizzato un periodo di tempo predefinito.

Il valore della norma deve essere specificato in millisecondi. I valori devono essere inferiori o uguali al ritardo di disattivazione dello schermo (se impostato) e al ritardo di inattività.</translation>
<translation id="3251500716404598358">Configura le norme per passare da un browser all'altro.

      I siti web configurati verranno aperti automaticamente in un browser diverso da <ph name="PRODUCT_NAME" />.</translation>
<translation id="3264793472749429012">Codifiche del provider di ricerca predefinito</translation>
<translation id="3273221114520206906">Impostazione JavaScript predefinita</translation>
<translation id="3284094172359247914">Controlla l'utilizzo dell'API WebUSB</translation>
<translation id="3288595667065905535">Canale di rilascio</translation>
<translation id="3292147213643666827">Consente a <ph name="PRODUCT_NAME" /> di fungere da proxy tra <ph name="CLOUD_PRINT_NAME" /> e le stampanti preesistenti collegate al computer.

      Se l'impostazione è attivata o non è configurata, gli utenti possono attivare il proxy Cloud Print attraverso l'autenticazione con il proprio Account Google.

      Se l'impostazione è disattivata, gli utenti non possono attivare il proxy e il computer non può condividere le stampanti con <ph name="CLOUD_PRINT_NAME" />.</translation>
<translation id="3312206664202507568">Consente di attivare una pagina su chrome://password-change che permette agli utenti SAML di usare le loro password SAML all'interno della sessione, il che assicura che le password SAML password e quelle per la schermata di blocco rimangano sincronizzate.

      Questo criterio inoltre consente le notifiche che avvisano gli tenti SAML se le loro password SAML stanno per scadere, in modo che possano organizzarsi immediatamente ed effettuare una modifica della password all'interno della sessione.
      Tuttavia, queste notifiche verranno mostrate solo se le informazioni sulla scadenza della password vengono inviate al dispositivo dal provider di identità SAML durante il flusso di accesso SAML.

      Se questo criterio viene impostato, l'utente non può modificarlo o sovrascriverlo.</translation>
<translation id="3322771899429619102">Consente di impostare un elenco di pattern URL che specificano i siti in cui è consentito l'utilizzo della generazione di chiavi. Se un pattern URL è indicato nella norma "KeygenBlockedForUrls", quest'ultima ha la precedenza su queste eccezioni.

          Se questa norma non viene impostata, per tutti i siti verrà utilizzato il valore predefinito globale della norma "DefaultKeygenSetting", se è impostata, oppure verrà utilizzata la configurazione personale dell'utente.</translation>
<translation id="332771718998993005">Consente di stabilire il nome pubblicizzato come destinazione di <ph name="PRODUCT_NAME" />.

          Se questa norma viene impostata su una stringa non vuota, tale stringa verrà usata come nome della destinazione di <ph name="PRODUCT_NAME" />. In caso contrario, il nome della destinazione sarà quello del dispositivo. Se questa norma non viene impostata, il nome della destinazione sarà il nome del dispositivo, che il proprietario (o un utente del dominio che gestisce il dispositivo) potrà cambiare. Il nome può essere formato da massimo 24 caratteri.</translation>
<translation id="3335468714959531450">Questa norma consente di impostare un elenco di pattern URL che specificano i siti autorizzati a impostare cookie.

          Se questa norma non viene impostata, per tutti i siti verrà utilizzato il valore predefinito globale della norma "DefaultCookiesSetting", se è impostata, oppure verrà utilizzata la configurazione personale dell'utente.

          Vedi anche le norme "CookiesBlockedForUrls" e "CookiesSessionOnlyForUrls". Tieni presente che non ci deve essere conflitto di pattern URL tra queste tre norme. Non viene specificato quale norma debba avere la precedenza.</translation>
<translation id="3373364525435227558">Consente di selezionare una o più impostazioni internazionali per una sessione gestita, consentendo agli utenti di sceglierne facilmente una.

      L'utente può scegliere un'impostazione internazionale e un layout tastiera prima di iniziare una sessione gestita. Per impostazione predefinita, tutte le impostazioni internazionali supportate da <ph name="PRODUCT_OS_NAME" /> sono elencate in ordine alfabetico. È possibile utilizzare questa norma per spostare un set di impostazioni internazionali consigliate nella parte superiore dell'elenco.

      Se questa norma non viene impostata, viene preselezionata l'impostazione internazionale corrente per l'interfaccia utente.

      Se questa norma viene impostata, le impostazioni internazionali consigliate verranno spostate nella parte superiore dell'elenco e verranno separate visivamente dalle altre impostazioni internazionali. Le impostazioni internazionali consigliate saranno elencate nell'ordine in cui sono indicate nella norma. Viene preselezionata la prima impostazione internazionale consigliata.

      Se sono presenti più impostazioni internazionali consigliate, si presuppone che gli utenti ne vogliano selezionare una. La selezione dell'impostazione internazionale e del layout tastiera verrà offerta in una posizione più visibile all'avvio di una sessione gestita. In caso contrario, si presuppone che la maggior parte degli utenti vuole utilizzare l'impostazione internazionale preselezionata. La selezione dell'impostazione internazionale e del layout tastiera verrà offerta in una posizione meno visibile all'avvio di una sessione gestita.

      Quando questa norma è impostata ed è abilitato l'accesso automatico (vedere le norme |DeviceLocalAccountAutoLoginId| e |DeviceLocalAccountAutoLoginDelay|), la sessione gestita avviata automaticamente utilizzerà la prima impostazione internazionale consigliata e il layout tastiera più popolare corrispondente a questa impostazione internazionale.

      Il layout tastiera preselezionato sarà sempre il layout più popolare corrispondente all'impostazione internazionale preselezionata.

      Questa norma può essere impostata solo come consigliata. È possibile utilizzare questa norma per spostare un set di impostazioni internazionali consigliate nella parte superiore, ma gli utenti possono sempre scegliere una qualsiasi impostazione internazionale supportata da <ph name="PRODUCT_OS_NAME" /> per la sessione.
      </translation>
<translation id="3381968327636295719">Utilizza il browser host per impostazione predefinita</translation>
<translation id="3384115339826100753">Attiva la norma di gestione della variazione dei picchi energetici.

          Variazione dei picchi è una norma per il risparmio energetico che minimizza l'utilizzo della corrente alternata durante i momenti della giornata di utilizzo più intenso. Per ogni giorno della settimana può essere impostato un orario di inizio e di fine per l'esecuzione della modalità energetica Variazione dei picchi. Nel periodo impostato, il sistema utilizzerà la batteria, anche se è presente il collegamento alla corrente alternata, fino a quando il livello della batteria è superiore al limite specificato. Dopo l'orario di fine specificato, il sistema utilizzerà la corrente alternata, se è presente il collegamento, ma non ricaricherà la batteria. Il sistema funzionerà di nuovo normalmente con la corrente alternata e la ricarica della batteria, dopo l'orario di inizio della ricarica specificato.

          Se questa norma è impostata su true e sono impostate le opzioni DevicePowerPeakShiftBatteryThreshold e DevicePowerPeakShiftDayConfig, allora la variazione dei picchi energetici sarà sempre attiva, se supportata dal dispositivo.

          Se questa norma è impostata su false, la variazione dei picchi energetici sarà sempre disattivata.

          Se imposti questa norma, gli utenti non potranno modificarla o sostituirla.

          Se questa norma non viene impostata, la variazione dei picchi energetici è disattivata da subito e non può essere attivata dall'utente.</translation>
<translation id="3388153794103186066">Consente di impostare un elenco di URL che specifica a quali siti verrà concessa automaticamente l'autorizzazione per accedere a un dispositivo USB con gli ID prodotto e vendor definiti. Perché la norma sia valida, ogni elemento dell'elenco deve contenere sia dispositivi sia URL. Ogni elemento nei dispositivi può contenere un campo ID vendor e un campo ID prodotto. Gli eventuali ID omessi verranno considerati caratteri jolly con l'eccezione che non è possibile specificare un ID prodotto senza aver specificato un ID vendor. In caso contrario, la norma non sarà valida e verrà ignorata.

        Il modello di autorizzazione USB utilizza l'URL del sito richiedente ("URL richiedente") e l'URL del sito frame di livello principale ("URL di incorporamento") per concedere l'autorizzazione all'URL richiedente di accedere al dispositivo USB. L'URL richiedente può essere diverso dall'URL di incorporamento quando il sito richiedente viene caricato in un iframe. Di conseguenza il campo "urls" può contenere fino a due stringhe URL delimitate da virgola per specificare rispettivamente l'URL richiedente e l'URL di incorporamento. Se è specificato un solo URL, l'accesso ai dispositivi USB corrispondenti viene concesso quando l'URL del sito richiedente corrisponde all'URL, a prescindere dallo stato di incorporamento. Gli URL in "urls" devono essere validi, altrimenti la norma viene ignorata.

        Se questa norma non viene impostata, per tutti i siti viene usato il valore predefinito globale dalla norma "DefaultWebUsbGuardSetting" (se impostata) o dalla configurazione personale dell'utente (se non impostata).

        I pattern URL di questa norma non devono essere in conflitto con quelli configurati tramite WebUsbBlockedForUrls. In caso di conflitto, questa norma ha la precedenza su WebUsbBlockedForUrls e WebUsbAskForUrls.</translation>
<translation id="3414260318408232239">Se questa norma non viene configurata, <ph name="PRODUCT_NAME" /> utilizza una versione minima predefinita, ossia TLS 1.0.

      In caso contrario, la norma potrebbe essere impostata su uno dei seguenti valori: "tls1", "tls1.1" o "tls1.2". Se questa norma viene impostata, <ph name="PRODUCT_NAME" /> non utilizzerà versioni SSL/TLS precedenti alla versione specificata. I valori non riconosciuti verranno ignorati.</translation>
<translation id="34160070798637152">Consente di controllare la configurazione di rete a livello di dispositivo.</translation>
<translation id="3417418267404583991">Se questa norma viene impostata su true o non viene configurata, in <ph name="PRODUCT_OS_NAME" /> verranno attivati gli accessi come ospite. Gli accessi come ospite sono sessioni utente anonime che non richiedono password.

      Se questa norma viene impostata su false, in <ph name="PRODUCT_OS_NAME" /> non sarà possibile avviare sessioni Ospite.</translation>
<translation id="3418871497193485241">Consente di imporre su YouTube un livello minimo della Modalità con restrizioni e di impedire agli utenti di scegliere un livello inferiore.

      Se questa impostazione viene impostata su Livello massimo, su YouTube sarà sempre attivo questo livello della Modalità con restrizioni.

      Se questa impostazione viene impostata su Livello medio, l'utente può scegliere il Livello medio o massimo della Modalità con restrizioni su YouTube, ma non può disattivare la modalità.

      Se questa impostazione viene disattivata o non viene impostato alcun valore, la Modalità con restrizioni di YouTube non viene imposta da <ph name="PRODUCT_NAME" />. La Modalità con restrizioni potrebbe essere comunque imposta da norme esterne, ad esempio dalle norme di YouTube.</translation>
<translation id="3428247105888806363">Attiva previsione di rete</translation>
<translation id="3432863169147125747">Consente di gestire le impostazioni di stampa.</translation>
<translation id="3434932177006334880">Il nome di questa impostazione era EnableWebBasedSignin nelle versioni di Chrome precedenti alla versione 42 e a partire dalla versione 43 di Chrome tale impostazione non verrà più supportata.

      Questa impostazione è utile per i clienti aziendali che utilizzano soluzioni SSO non ancora compatibili con il nuovo flusso di accesso incorporato.
      Se attivi questa impostazione, viene utilizzato il precedente flusso di accesso basato sul Web.
      Se disattivi questa impostazione o non la imposti, viene utilizzato per impostazione predefinita il nuovo flusso di accesso incorporato. Gli utenti possono comunque attivare il flusso di accesso precedente basato sul Web tramite il flag della riga di comando --enable-web-based-signin.

      In futuro, quando l'accesso incorporato supporterà completamente tutti i flussi di accesso SSO, questa impostazione sperimentale verrà rimossa.</translation>
<translation id="3437924696598384725">Consente all'utente di gestire le connessioni VPN</translation>
<translation id="3459509316159669723">Stampa</translation>
<translation id="3460784402832014830">Consente di specificare l'URL utilizzato da un motore di ricerca per fornire una pagina Nuova scheda.

Questa norma è facoltativa. Se non viene impostata non verrà fornita una pagina Nuova scheda.

Questa norma viene rispettata soltanto se viene attivata la norma "DefaultSearchProviderEnabled".</translation>
<translation id="3461279434465463233">Segnala lo stato dell'alimentazione</translation>
<translation id="346731943813722404">Consente di specificare se i ritardi di gestione dell'alimentazione e il limite di durata delle sessioni devono iniziare soltanto dopo il rilevamento dell'attività del primo utente in una sessione.

Se questa norma viene impostata su True, i ritardi di gestione dell'alimentazione e il limite di durata delle sessioni non iniziano fino al termine del rilevamento dell'attività del primo utente in una sessione.

Se questa norma viene impostata su False o non viene impostata, i ritardi di gestione dell'alimentazione e il limite di durata delle sessioni iniziano immediatamente all'avvio della sessione.</translation>
<translation id="3478024346823118645">Cancella dati utente all'uscita</translation>
<translation id="3480961938508521469">Batteria completamente carica in tempi standard.</translation>
<translation id="348495353354674884">Attiva tastiera virtuale</translation>
<translation id="3487623755010328395">
        Se è impostata questa norma, <ph name="PRODUCT_NAME" /> proverà a registrarsi e ad applicare a tutti i profili la norma relativa alla cloud associata.

        Il valore di questa norma è un token di registrazione che è possibile recuperare dalla Console amministrazione Google.</translation>
<translation id="3489247539215560634">Se questa impostazione viene attivata, gli utenti possono impostare <ph name="PRODUCT_NAME" /> perché memorizzi le password e le inserisca automaticamente all'accesso successivo a un sito.

          Se invece è disattivata, gli utenti non possono salvare nuove password, ma
          possono comunque utilizzare quelle memorizzate in precedenza.

          Se questa norma viene attivata o disattivata, gli utenti non possono modificarla o sostituirla in <ph name="PRODUCT_NAME" />. Se questa norma non è impostata, è consentito il salvataggio delle password (ma l'utente può disattivarlo).</translation>
<translation id="3496296378755072552">Gestione password</translation>
<translation id="3500732098526756068">Ti consente di controllare l'attivazione dell'avviso di protezione tramite password. La protezione tramite password avvisa gli utenti quando riutilizzano le proprie password protette su siti potenzialmente sospetti.

      Puoi utilizzare le norme "PasswordProtectionLoginURLs" e "PasswordProtectionChangePasswordURL" per configurare la password da proteggere.

      Se questa norma viene impostata su "PasswordProtectionWarningOff", non apparirà alcun avviso di protezione tramite password.
      Se questa norma viene impostata su "PasswordProtectionWarningOnPasswordReuse", l'avviso di protezione tramite password apparirà quando l'utente riutilizza la propria password protetta su un sito non autorizzato.
      Se questa norma viene impostata su "PasswordProtectionWarningOnPhishingReuse", l'avviso di protezione tramite password apparirà quando l'utente riutilizza la propria password protetta su un sito di phishing.
      Se questa norma viene lasciata non impostata, il servizio di protezione tramite password proteggerà esclusivamente le password Google, ma l'utente sarà in grado di modificare questa impostazione.</translation>
<translation id="3502555714327823858">Consenti tutte le modalità fronte/retro</translation>
<translation id="350443680860256679">Configura ARC</translation>
<translation id="3504791027627803580">Consente di specificare l'URL del motore di ricerca utilizzato per la ricerca di immagini. Le richieste di ricerca verranno inviate con il metodo GET. Se viene impostata la norma DefaultSearchProviderImageURLPostParams, per le richieste di ricerca di immagini viene utilizzato il metodo POST.

Questa norma è facoltativa. Se non viene impostata, non verrà utilizzata la ricerca di immagini.

Questa norma viene rispettata soltanto se viene attivata la norma "DefaultSearchProviderEnabled".</translation>
<translation id="350797926066071931">Abilita traduzione</translation>
<translation id="3513655665999652754">Quirks Server fornisce file di configurazione specifici per l'hardware, ad esempio
      profili ICC per regolare la calibrazione del monitor.

      Quando questa norma è impostata su false, il dispositivo non proverà a
      contattare Quirks Server per scaricare i file di configurazione.

      Se questa norma è impostata su true o non è configurata, allora <ph name="PRODUCT_OS_NAME" /> contatterà automaticamente Quirks Server e scaricherà i file di configurazione, se disponibili, e li archivierà sul dispositivo.  Questi file potrebbero essere usati, ad esempio, per migliorare la qualità del display dei monitor collegati.</translation>
<translation id="3524204464536655762">Non consentire ai siti di richiedere l'accesso ai dispositivi USB tramite l'API WebUSB</translation>
<translation id="3526752951628474302">Solo stampa monocromatica</translation>
<translation id="3528000905991875314">Attiva pagine di errore sostitutive</translation>
<translation id="3545457887306538845">Ti consente di stabilire dove è possibile usare gli Strumenti per sviluppatori.

      Se questa norma viene impostata su "DeveloperToolsDisallowedForForceInstalledExtensions" (valore 0, ossia il valore predefinito), in genere è possibile accedere agli Strumenti per sviluppatori e alla console JavaScript, ma non è possibile accedervi nel contesto delle estensioni installate in base a norme aziendali.
      Se questa norma viene impostata su "DeveloperToolsAllowed" (valore 1), gli Strumenti per sviluppatori e la console JavaScript saranno accessibili e utilizzabili in tutti i contesti, incluso il contesto delle estensioni installate in base a norme aziendali.
      Se questa norma viene impostata su "DeveloperToolsDisallowed" (valore 2), gli Strumenti per sviluppatori non saranno accessibili e non sarà più possibile esaminare gli elementi del sito web. Le eventuali scorciatoie da tastiera e le voci dei menu contestuali o di altri menu che consentono di aprire gli Strumenti per sviluppatori o la console JavaScript verranno disattivate.</translation>
<translation id="3547954654003013442">Impostazioni proxy</translation>
<translation id="355118380775352753">Siti web da aprire in un browser alternativo</translation>
<translation id="3554984410014457319">Consente all'Assistente Google di ascoltare la frase di attivazione vocale</translation>
<translation id="356579196325389849">Gli utenti possono configurare il canale di rilascio di Chrome OS</translation>
<translation id="3575011234198230041">Autenticazione HTTP</translation>
<translation id="3577251398714997599">Impostazione annunci per i siti con annunci invasivi</translation>
<translation id="357917253161699596">Consenti agli utenti di gestire i certificati utente</translation>
<translation id="3583230441447348508">Consente di specificare un elenco di condivisioni di file di rete preconfigurate.

      Ogni voce della norma è un oggetto con due componenti: "share_url" e "mode". "share_url" deve essere l'URL della condivisione e "mode" deve essere "drop_down" o "pre_mount". La modalità "drop_down" indica che il valore "share_url" verrà aggiunto al menu a discesa per il rilevamento delle condivisioni. La modalità "pre_mount" indica che il valore "share_url" verrà montato.</translation>
<translation id="3591527072193107424">Attiva la funzionalità Supporto dei browser precedenti.</translation>
<translation id="3591584750136265240">Configura il comportamento di autenticazione dell'accesso</translation>
<translation id="3624171042292187668">Potresti considerare l'impostazione del criterio IsolateOrigins per ottenere sia l'isolamento sia un impatto limitato per gli utenti. Usa IsolateOrigins con un elenco dei siti che vuoi isolare. Questa impostazione, SitePerProcess, isola tutti i siti.
      Se il criterio è attivato, ciascun sito verrà eseguito nel proprio processo.
      Se il criterio è disattivato, le funzionalità IsolateOrigins e SitePerProcess saranno entrambe disattivate. Gli utenti potranno ancora attivare SitePerProcess manualmente, tramite flag da riga di comando.
      Se il criterio non è configurato, l'utente potrà modificare questa impostazione.
      In <ph name="PRODUCT_OS_NAME" />, si consiglia di impostare anche il criterio <ph name="DEVICE_LOGIN_SCREEN_SITE_PER_PROCESS_POLICY_NAME" /> relativo ai dispositivi sullo stesso valore. Se i valori specificati dai due criteri non corrispondono, può verificarsi un ritardo durante l'accesso a una sessione utente mentre viene applicato il valore specificato dai criteri relativi agli utenti.

      NOTA: questo criterio non viene applicato su Android. Per attivare SitePerProcess su Android, utilizza l'impostazione del criterio SitePerProcessAndroid.</translation>
<translation id="3627678165642179114">Attiva o disattiva il servizio web di controllo ortografico</translation>
<translation id="3628480121685794414">Attiva stampa su un lato</translation>
<translation id="3631099945620529777">Se la norma è impostata su false, il pulsante "Termina processo" in Task Manager viene disattivato.

      Se la norma è impostata su true o non è configurata, l'utente può terminare i processi in Task Manager.</translation>
<translation id="3646859102161347133">Impostazione tipo di ingrandimento dello schermo</translation>
<translation id="3653237928288822292">Icona del provider di ricerca predefinito</translation>
<translation id="3660510274595679517">
        Se questo criterio viene impostato su true, la registrazione alla gestione della cloud è obbligatoria e blocca il processo di avvio di Chrome, qualora l'esito fosse negativo.

        Se questo criterio non viene impostato o viene impostato su false, la registrazione alla gestione della cloud è facoltativa e non blocca il processo di avvio di Chrome, anche qualora l'esito fosse negativo.

        Questo criterio viene utilizzato su desktop dalla registrazione con criteri cloud in ambito macchina e può essere impostato tramite il file di criteri registry o GPO su Windows, plist su Mac e JSON su Linux.</translation>
<translation id="3660562134618097814">Trasferisci i cookie dell'IdP SAML durante l'accesso</translation>
<translation id="3668151900457104753">Disinstallare le estensioni nella lista nera</translation>
<translation id="3701121231485832347">Consente di gestire le impostazioni specifiche dei dispositivi <ph name="PRODUCT_OS_NAME" /> gestiti da <ph name="MS_AD_NAME" />.</translation>
<translation id="3702647575225525306"><ph name="POLICY_NAME" /> (Il campo a una sola riga è obsoleto e sarà rimosso a breve. Inizia a usare la casella di testo multiriga qui sotto).</translation>
<translation id="3709266154059827597">Configura blacklist per l'installazione delle estensioni</translation>
<translation id="3711895659073496551">Sospensione</translation>
<translation id="3715569262675717862">Autenticazione basata su certificati client</translation>
<translation id="3734995764843493369">Richiedi inserimento della password ogni giorno (24 ore)</translation>
<translation id="3736879847913515635">Attiva la funzione Aggiungi persona in Gestione utenti</translation>
<translation id="3738723882663496016">Questa norma specifica il codice licenza <ph name="PLUGIN_VM_NAME" /> di questo dispositivo.</translation>
<translation id="3748900290998155147">Consente di specificare se consentire o meno i wakelock. I wakelock possono essere richiesti dalle estensioni tramite l'API dell'estensione di gestione dell'alimentazione e dalle app ARC.

          Se questa norma viene impostata su true o non viene impostata, i wakelock verranno rispettati per la gestione dell'alimentazione.

          Se questa norma viene impostata su false, le richieste di wakelock verranno ignorate.</translation>
<translation id="3750220015372671395">Blocca la generazione di chiavi su questi siti</translation>
<translation id="375266612405883748">Limita l'intervallo di porte UDP utilizzate dall'host di accesso remoto in questo computer.

          Se questa norma non è impostata o se viene impostata una stringa vuota, l'host di accesso remoto potrà utilizzare qualsiasi porta, a meno che la norma <ph name="REMOTE_ACCESS_HOST_FIREWALL_TRAVERSAL_POLICY_NAME" /> sia disattivata; in questo caso l'host di accesso remoto utilizzerà le porte UDP nell'intervallo 12400-12409.</translation>
<translation id="3756011779061588474">Blocca modalità sviluppatore</translation>
<translation id="3758089716224084329">Consente di specificare il server proxy utilizzato da <ph name="PRODUCT_NAME" /> e impedisce agli utenti di modificare le impostazioni proxy.

      Se l'utente sceglie di non utilizzare mai un server proxy e di connettersi sempre direttamente, tutte le altre opzioni vengono ignorate.

      Se l'utente sceglie di rilevare automaticamente il server proxy, tutte le altre opzioni vengono ignorate.

      Per esempi dettagliati, visita il seguente indirizzo:
      <ph name="PROXY_HELP_URL" />.

      Se questa impostazione viene attivata, <ph name="PRODUCT_NAME" /> e le app ARC ignorano tutte le opzioni relative al proxy specificate dalla riga di comando.

      Se queste norme non vengono impostate, gli utenti possono scegliere autonomamente le impostazioni del proxy.</translation>
<translation id="3758249152301468420">Disabilita Strumenti per sviluppatori</translation>
<translation id="3764248359515129699">Disattiva l'applicazione dei requisiti di Certificate Transparency per un elenco di autorità di certificazione precedenti.

      Questa norma consente di disattivare i requisiti di divulgazione di Certificate Transparency per le catene di certificati che contengono certificati con uno degli hash subjectPublicKeyInfo specificati. Fa sì che i certificati che altrimenti sarebbero considerati non attendibili, in quanto non adeguatamente resi pubblici, continuino a essere utilizzati per gli host aziendali.

      Per disattivare l'applicazione dei requisiti di Certificate Transparency quando viene impostata questa norma, l'hash deve far parte di un subjectPublicKeyInfo che compare in un certificato CA riconosciuto come autorità di certificazione (CA) precedente. Una CA precedente è una CA che, per impostazione predefinita, è stata considerata attendibile pubblicamente da uno o più sistemi operativi supportati da <ph name="PRODUCT_NAME" />, ma che non è considerata attendibile da Android Open Source Project o da <ph name="PRODUCT_OS_NAME" />.

      Per specificare un hash subjectPublicKeyInfo è necessario concatenare il nome dell'algoritmo hash, il carattere "/" e la codifica Base64 dell'algoritmo hash applicato al subjectPublicKeyInfo con codifica DER del certificato specificato. La codifica Base64 è nello stesso formato di un'impronta SPKI, come stabilito nella Sezione 2.4 dell'RFC 7469. Gli algoritmi hash non riconosciuti vengono ignorati. Attualmente l'unico algoritmo hash supportato è "sha256".

      Se questa norma non viene impostata, i certificati che devono essere resi pubblici tramite Certificate Transparency verranno considerati non attendibili nel caso in cui non vengano resi pubblici secondo quanto previsto dalle norme di Certificate Transparency.</translation>
<translation id="3765260570442823273">Durata del messaggio di avviso di uscita per inattività</translation>
<translation id="377044054160169374">Applicazione dell'intervento in caso di esperienza intrusiva</translation>
<translation id="3780152581321609624">Includi porta non standard in Kerberos SPN</translation>
<translation id="3780319008680229708">Se il criterio è impostato su true, l'icona Cast della barra degli strumenti sarà sempre visibile nella barra degli strumenti o nel menu extra e gli utenti non potranno rimuoverla.

          Se il criterio è impostato su false o non viene impostato, gli utenti potranno bloccare o rimuovere l'icona tramite il relativo menu contestuale.

          Se il criterio "EnableMediaRouter" è impostato su false, il valore del criterio non avrà effetto e l'icona della barra degli strumenti non sarà mostrata.</translation>
<translation id="3788662722837364290">Impostazioni di gestione dell'alimentazione quando l'utente diventa inattivo</translation>
<translation id="3790085888761753785">Se questa impostazione viene attivata, gli utenti potranno accedere ai propri account con Smart Lock. Questa impostazione è più permissiva rispetto al normale comportamento di Smart Lock che consente agli utenti soltanto di sbloccare lo schermo.

      Se questa impostazione viene disattivata, gli utenti non potranno usare l'accesso tramite Smart Lock.

      Se questa norma non viene impostata, per impostazione predefinita la funzione non è consentita per gli utenti gestiti dall'azienda ed è consentita per gli utenti non gestiti.</translation>
<translation id="379602782757302612">Consente di specificare le estensioni che gli utenti NON possono installare. Se presenti nella lista nera, le estensioni precedentemente installate verranno rimosse, senza che l'utente possa attivarle. Quando un'estensione viene tolta dalla lista nera, viene riattivata automaticamente.

          Un valore di * riportato nella lista nera indica che tutte le estensioni sono state inserite nella lista nera, a meno che non siano esplicitamente elencate nella whitelist.

          Se questa norma non viene impostata, gli utenti potranno installare qualsiasi estensione in <ph name="PRODUCT_NAME" />.</translation>
<translation id="3800626789999016379">Consente di configurare la directory che <ph name="PRODUCT_NAME" /> utilizza per il download dei file.

      Se la norma viene impostata, <ph name="PRODUCT_NAME" /> utilizza la directory fornita, indipendentemente dal fatto che l'utente ne abbia specificata una o abbia attivato il flag da attivare ogni volta per il percorso di download.

      Visita il sito https://www.chromium.org/administrators/policy-list-3/user-data-directory-variables per consultare un elenco di variabili utilizzabili.

      Se la norma non viene impostata, viene utilizzata la directory di download predefinita e l'utente può modificarla.</translation>
<translation id="3805659594028420438">Attiva estensione di certificati associati al dominio TLS (obsoleta)</translation>
<translation id="3808945828600697669">Specifica un elenco dei plug-in disattivati</translation>
<translation id="3811562426301733860">Consenti annunci su tutti i siti</translation>
<translation id="3816312845600780067">Attivazione scorciatoia da tastiera bailout per accesso automatico</translation>
<translation id="3820526221169548563">Attiva la funzione di accessibilità della tastiera sullo schermo.

          Se questa norma viene impostata su true, la tastiera sullo schermo sarà sempre attivata.

          Se questa norma viene impostata su false, la tastiera sullo schermo sarà sempre disattivata.

          Se questa norma viene viene impostata, gli utenti non potranno modificarla o sostituirla.

          Se questa norma non viene impostata, inizialmente la tastiera sullo schermo è disattivata, ma l'utente la può attivare in qualsiasi momento.</translation>
<translation id="382476126209906314">Configura il prefisso TalkGadget per gli host di accesso remoto</translation>
<translation id="3824972131618513497">Consente di controllare le impostazioni relative alla gestione dell'alimentazione e al riavvio.</translation>
<translation id="3826475866868158882">Servizi di geolocalizzazione di Google abilitati</translation>
<translation id="3831054243924627613">Questo criterio controlla lo stato iniziale del backup e ripristino di Android.

      Se questo criterio non è configurato o non è impostato su <ph name="BR_DISABLED" />, il backup e ripristino di Android viene inizialmente disattivato.

      Se il criterio è impostato su <ph name="BR_ENABLED" />, il backup e ripristino di Android viene inizialmente attivato.

      Se il criterio è impostato su <ph name="BR_UNDER_USER_CONTROL" />, all'utente viene chiesto di scegliere se utilizzare il backup e ripristino di Android. Se l'utente attiva il backup e ripristino, i dati delle app Android vengono caricati sui server di backup di Android e ripristinati dai server per le app compatibili durante la fase di reinstallazione.

      Tieni presente che questo criterio controlla lo stato di backup e ripristino di Android solo durante la configurazione iniziale. L'utente può aprire le impostazioni di Android in un secondo momento e attivare o disattivare il backup e ripristino di Android.</translation>
<translation id="3831376478177535007">Se questa impostazione viene attivata, <ph name="PRODUCT_NAME" /> consente di ritenere attendibili i certificati emessi dal team addetto alle operazioni dell'infrastruttura PKI precedente di Symantec Corporation se sono correttamente convalidati e collegati a un certificato CA riconosciuto.

      Tieni presente che questa norma dipende dal riconoscimento da parte del sistema operativo dei certificati dell'infrastruttura precedente di Symantec. Se un aggiornamento del sistema operativo cambia la modalità di gestione di tali certificati da parte del sistema, questa norma non viene più applicata. Inoltre, questa norma è intesa come soluzione alternativa temporanea per dare alle aziende più tempo per ritirare i certificati Symantec precedenti. Questa norma verrà rimossa il 1° gennaio 2019 o in una data successiva.

      Se questa norma non viene impostata o viene impostata su false, <ph name="PRODUCT_NAME" /> segue il piano di ritiro pubblico.

      Visita la pagina https://g.co/chrome/symantecpkicerts per avere ulteriori informazioni sul ritiro.</translation>
<translation id="383466854578875212">Consente di specificare gli host di messaggi nativi da escludere dalla lista nera.

Il valore della lista nera * indica che tutti gli host di messaggi nativi non sono autorizzati e che verranno caricati soltanto gli host di messaggi nativi elencati nella whitelist.

Per impostazione predefinita sono autorizzati tutti gli host di messaggi nativi ma, se tutti gli host sono stati aggiunti alla lista nera secondo la norma, è possibile utilizzare la whitelist per ignorare la norma.</translation>
<translation id="3835692988507803626">Forza la disattivazione delle lingue per correttore ortografico</translation>
<translation id="3837424079837455272">Questa norma consente di stabilire se i nuovi utenti possono essere aggiunti a <ph name="PRODUCT_OS_NAME" />. Non impedisce agli utenti di accedere ad Account Google aggiuntivi su Android. Se vuoi impedirlo, configura la norma <ph name="ACCOUNT_TYPES_WITH_MANAGEMENT_DISABLED_CLOUDDPC_POLICY_NAME" /> specifica per Android nell'ambito della norma <ph name="ARC_POLICY_POLICY_NAME" />.</translation>
<translation id="384743459174066962">Consente di impostare un elenco di pattern URL che specificano i siti in cui non è consentita l'apertura dei popup. Se questa norma non viene impostata, per tutti i siti verrà utilizzato il valore predefinito globale della norma "DefaultPopupsSetting", se è impostata, oppure verrà utilizzata la configurazione personale dell'utente.</translation>
<translation id="3851039766298741586">Consente di segnalare informazioni sulla sessione kiosk attiva, ad esempio l'ID e la versione dell'applicazione.

      Se la norma viene impostata su false, le informazioni relative alla sessione kiosk non verranno segnalate. Se viene impostata su true o non viene impostata, tali informazioni verranno segnalate.</translation>
<translation id="3852924591079583104">
      Se è impostata su ArcSession, questa norma forza il riavvio del dispositivo all'uscita dell'utente se Android è stato avviato.
      Se è impostata su Sempre, forza il riavvio del dispositivo a ogni uscita dell'utente.
      Se non è impostata, non sortisce alcun effetto e non viene forzato alcun riavvio all'uscita dell'utente. Lo stesso accade se è impostata su Mai.
      </translation>
<translation id="3858658082795336534">Modalità di stampa fronte/retro predefinita</translation>
<translation id="3859780406608282662">Consente di aggiungere un parametro al recupero del numero di inizializzazione delle varianti in <ph name="PRODUCT_OS_NAME" />.

      Se la norma è specificata, verrà aggiunto un parametro query chiamato "restrict" all'URL utilizzato per recuperare il numero di inizializzazione delle varianti. Il valore del parametro sarà il valore specificato in questa norma.

      Se la norma non è specificata, l'URL di recupero del numero di inizializzazione delle varianti non verrà modificato.</translation>
<translation id="3863409707075047163">Versione SSL minima attivata</translation>
<translation id="3864020628639910082">Consente di specificare l'URL del motore di ricerca utilizzato per fornire suggerimenti di ricerca. L'URL deve contenere la stringa "<ph name="SEARCH_TERM_MARKER" />", che verrà sostituita in fase di query dal testo inserito fino a quel momento dall'utente.

          Questa norma è facoltativa. Se non viene impostata, non verranno utilizzati URL di suggerimento.

          L'URL per i suggerimenti di Google può essere specificato come segue: <ph name="GOOGLE_SUGGEST_SEARCH_URL" />.

          Questa norma viene rispettata soltanto se la norma "DefaultSearchProviderEnabled" è attiva.</translation>
<translation id="3864129983143201415">Configura le lingue consentite in una sessione utente</translation>
<translation id="3866249974567520381">Descrizione</translation>
<translation id="3868347814555911633">Questa norma è attiva soltanto in modalità retail.

      Consente di elencare le estensioni che vengono installate automaticamente per gli utenti Demo di dispositivi in modalità retail. Queste estensioni vengono salvate sul dispositivo e possono essere installate offline, dopo l'installazione.

      Ogni voce dell'elenco contiene un dizionario che deve includere l'ID dell'estensione nel campo "extension-id" e il relativo URL di aggiornamento nel campo "update-url".</translation>
<translation id="3874773863217952418">Attiva Tocca per cercare</translation>
<translation id="3877517141460819966">Modalità di autenticazione a due fattori integrata</translation>
<translation id="3879208481373875102">Configura l'elenco delle app web con installazione forzata</translation>
<translation id="388237772682176890">Questa norma è stata ritirata in M53 e rimossa in M54 perché è stato rimosso il supporto di SPDY/3.1.

      Consente di disattivare l'utilizzo del protocollo SPDY in <ph name="PRODUCT_NAME" />.

      Se questa norma viene attivata, il protocollo SPDY non sarà disponibile in <ph name="PRODUCT_NAME" />.

      Se la norma viene disattivata sarà possibile utilizzare il protocollo.

      Se la norma non viene impostata, il protocollo SPDY sarà disponibile.</translation>
<translation id="3891357445869647828">Abilita JavaScript</translation>
<translation id="3895557476567727016">Consente di configurare la directory predefinita da usare in <ph name="PRODUCT_NAME" /> per il download dei file.

      Se questa norma viene impostata, verrà cambiata la directory predefinita in cui vengono scaricati i file in <ph name="PRODUCT_NAME" />. Questa norma non è obbligatoria, pertanto l'utente potrà cambiare la directory.

      Se questa norma non viene impostata, verrà usata la normale directory predefinita (specifica della piattaforma) di <ph name="PRODUCT_NAME" />.

      Visita il sito https://www.chromium.org/administrators/policy-list-3/user-data-directory-variables per consultare un elenco di variabili utilizzabili.</translation>
<translation id="3904459740090265495">Questa norma consente di stabilire il comportamento di accesso del browser. Ti consente di specificare se l'utente può accedere a <ph name="PRODUCT_NAME" /> con il proprio account e usare i servizi correlati all'account come Sincronizzazione Chrome.

      Se la norma viene impostata su "Disattiva accesso al browser", l'utente non potrà accedere al browser e usare i servizi basati sull'account. In questo caso, le funzionalità a livello di browser come la Sincronizzazione Chrome non potranno essere usate e non saranno disponibili. Se la norma viene impostata su "Disattivata" dopo che l'utente ha eseguito l'accesso, l'utente verrà scollegato alla successiva esecuzione di Chrome, ma i dati locali del profilo, come preferiti, password ecc., verranno mantenuti. L'utente potrà comunque accedere e usare i servizi web di Google come Gmail.

      Se la norma viene impostata su "Attiva accesso al browser", l'utente potrà accedere al browser e verrà collegato automaticamente al browser se accederà a servizi web di Google come Gmail. Se viene eseguito l'accesso al browser, i dati dell'account dell'utente vengono memorizzati dal browser, ma la funzione Sincronizzazione Chrome non viene attivata per impostazione predefinita; per poter utilizzare questa funzione, l'utente deve attivarla separatamente. Se attivi questa norma, l'utente non potrà disattivare l'impostazione che consente l'accesso al browser. Per gestire la disponibilità della funzione Sincronizzazione Chrome, usa la norma "SyncDisabled".

      Se la norma viene impostata su "Forza accesso al browser", all'utente verrà mostrata una finestra di dialogo di selezione dell'account, da cui dovrà scegliere un account a cui accedere per usare il browser. Questa misura garantisce l'applicazione, nell'ambito degli account gestiti, delle norme associate all'account. La funzione Sincronizzazione Chrome viene attivata per impostazione predefinita per l'account, ad eccezione del caso in cui la sincronizzazione sia stata disattivata dall'amministratore di dominio o tramite la norma "SyncDisabled". Il valore predefinito della norma BrowserGuestModeEnabled sarà false. Tieni presente che i profili esistenti a cui non viene eseguito l'accesso saranno bloccati e inaccessibili dopo l'attivazione di questa norma. Per ulteriori informazioni, leggi il seguente articolo del Centro assistenza: https://support.google.com/chrome/a/answer/7572556.

      Se questa norma non è impostata, l'utente potrà decidere se attivare o meno l'opzione di accesso al browser e di usarla in base alle necessità.</translation>
<translation id="3911737181201537215">Questa norma non influisce sulla registrazione effettuata da Android.</translation>
<translation id="391531815696899618">Consente di disattivare la sincronizzazione di Google Drive nell'app File di <ph name="PRODUCT_OS_NAME" /> quando è impostata su True. In tal caso, non vengono caricati dati in Google Drive.

          Se questa norma non viene impostata o è impostata su False, gli utenti potranno trasferire file in Google Drive.</translation>
<translation id="3915395663995367577">URL di un file proxy .pac</translation>
<translation id="3920892052017026701">Consente di impostare il valore personalizzato espresso in percentuale raggiunto il quale la batteria avvia la ricarica.

          La batteria inizia a caricarsi quando raggiunge il valore il valore di avvio della ricarica personalizzato.

          DeviceBatteryChargeCustomStartCharging deve essere inferiore a DeviceBatteryChargeCustomStopCharging.

          Questo criterio viene utilizzato unicamente quando DeviceBatteryChargeMode è impostato su personalizzato.

          Se questo criterio non è configurato o non è impostato, verrà applicata la modalità di ricarica standard della batteria.</translation>
<translation id="3925377537407648234">Imposta fattore di scala e risoluzione del display</translation>
<translation id="3939893074578116847">Invia pacchetti di rete al server di gestione per monitorare lo stato online, per consentire
      al server di rilevare se il dispositivo è offline.

      Se la norma è impostata su true, i pacchetti di rete di monitoraggio (chiamati <ph name="HEARTBEATS_TERM" />) verranno inviati.
      Se la norma è impostata su false, i pacchetti non verranno inviati.</translation>
<translation id="3950239119790560549">Limitazioni relative alla data/ora di aggiornamento</translation>
<translation id="3956686688560604829">Utilizza la norma SiteList di Internet Explorer per il Supporto dei browser precedenti.</translation>
<translation id="3958586912393694012">Consenti l'utilizzo di Smart Lock</translation>
<translation id="3963602271515417124">Se la norma viene impostata su true, l'attestazione da remoto viene consentita per il dispositivo e viene generato automaticamente un certificato che viene caricato sul Server di gestione del dispositivo.

          Se la norma viene impostata su false o non viene impostata, non verrà generato alcun certificato e le chiamate all'API di estensione enterprise.platformKeys non andranno a buon fine.</translation>
<translation id="3965339130942650562">Timeout fino a esecuzione uscita utente non attivo</translation>
<translation id="3973371701361892765">Non nascondere mai automaticamente lo shelf</translation>
<translation id="3984028218719007910">Consente di stabilire se tenere o meno memorizzati in <ph name="PRODUCT_OS_NAME" /> i dati degli account locali dopo l'uscita. Se la norma viene impostata su true, in <ph name="PRODUCT_OS_NAME" /> non verranno conservati gli account persistenti e tutti i dati della sessione utente verranno eliminati dopo l'uscita. Se la norma viene impostata su false o non viene configurata, il dispositivo potrebbe conservare i dati utente locali (criptati).</translation>
<translation id="398475542699441679">Questa norma consente di stabilire se attivare il Supporto dei browser precedenti.

      Se questa norma non viene impostata o viene impostata su false, Chrome non proverà ad avviare gli URL stabiliti in un browser alternativo.

      Quando questa norma è impostata su true, Chrome prova ad avviare alcuni URL in un browser alternativo (ad esempio, Internet Explorer). Questa funzionalità viene configurata con le norme nel gruppo <ph name="LEGACY_BROWSER_SUPPORT_POLICY_GROUP" />.

      Questa funzionalità sostituisce l'estensione <ph name="LEGACY_BROWSER_SUPPORT_EXTENSION_NAME" />. La configurazione dell'estensione viene riportata in questa funzionalità, ma consigliamo vivamente di utilizzare invece le norme di Chrome. Infatti, ciò garantisce una maggiore compatibilità in futuro.</translation>
<translation id="3997519162482760140">URL a cui verrà concesso l'accesso ai dispositivi di acquisizione video su pagine di accesso SAML</translation>
<translation id="4001275826058808087">Gli amministratori IT di dispositivi aziendali possono utilizzare questo flag per stabilire se consentire agli utenti di utilizzare le offerte tramite la registrazione a Chrome OS.

      Se questa norma viene impostata su true o non viene impostata, gli utenti potranno utilizzare le offerte tramite la registrazione a Chrome OS.

      Se questa norma viene impostata su false, gli utenti non potranno utilizzare le offerte.</translation>
<translation id="4008507541867797979">Se questa norma viene impostata su True o non viene configurata, nella schermata di accesso di <ph name="PRODUCT_OS_NAME" /> verranno visualizzati gli utenti esistenti tra cui sarà possibile selezionare un utente.

      Se la norma è impostata su False, nella schermata di accesso di <ph name="PRODUCT_OS_NAME" /> non verranno visualizzati gli utenti esistenti. Verrà visualizzata la normale schermata di accesso (richiesta di email utente e password o telefono) o la schermata interstiziale SAML (se attivata tramite la norma <ph name="LOGIN_AUTHENTICATION_BEHAVIOR_POLICY_NAME" />), a meno che non sia stata configurata una sessione gestita. Quando viene configurata una sessione gestita, verranno visualizzati solo gli account della sessione gestita, consentendo di selezionarne uno.

      Tieni presente che questa norma non influisce sull'eliminazione o meno dei dati utenti locali sul dispositivo.</translation>
<translation id="4010738624545340900">Consenti richiamo di finestre di dialogo di selezione file</translation>
<translation id="4012737788880122133">Se questa norma viene impostata su True, gli aggiornamenti automatici vengono disattivati.

Se questa norma non viene configurata o viene impostata su False, i dispositivi <ph name="PRODUCT_OS_NAME" /> controllano automaticamente la disponibilità di aggiornamenti.

Avviso. È consigliabile mantenere attivati gli aggiornamenti automatici per consentire agli utenti di ricevere gli aggiornamenti software e le correzioni di sicurezza fondamentali. Disattivare gli aggiornamenti automatici potrebbe mettere a rischio gli utenti.</translation>
<translation id="4018000735882846261">Questa norma autorizza l'Assistente Google ad ascoltare la frase di attivazione vocale.

      Se la norma viene attivata, l'Assistente Google ascolta la frase di attivazione vocale.
      Se la norma viene disattivata, l'Assistente Google non ascolta la frase di attivazione vocale.
      Se la norma non è impostata, l'Assistente Google non ascolta la frase di attivazione vocale.
      </translation>
<translation id="4020682745012723568">Le app Android non possono accedere ai cookie trasferiti al profilo dell'utente.</translation>
<translation id="402759845255257575">Non consentire ad alcun sito di eseguire JavaScript</translation>
<translation id="4027608872760987929">Attiva il provider di ricerca predefinito</translation>
<translation id="4039085364173654945">Consente di stabilire se per i contenuti secondari di terze parti presenti in una pagina è consentita la visualizzazione di una finestra di dialogo Autorizzazione di base HTTP. Generalmente questa norma non è attiva per tutela dal phishing. Se questa norma non viene impostata, l'impostazione verrà disattivata e per i contenuti secondari di terze parti non potrà essere visualizzata una finestra di dialogo Autorizzazione di base HTTP.</translation>
<translation id="4056910949759281379">Disabilita protocollo SPDY</translation>
<translation id="408029843066770167">Consenti query a un servizio orario di Google</translation>
<translation id="408076456549153854">Attiva accesso al browser</translation>
<translation id="4088589230932595924">Modalità di navigazione in incognito forzata</translation>
<translation id="4088983553732356374">Consente di stabilire se consentire o meno ai siti web di impostare dati locali. L'impostazione dei dati locali può essere consentita o vietata per tutti i siti web.

          Se questa norma viene impostata su "Conserva cookie per tutta la durata della sessione", i cookie vengono cancellati alla chiusura della sessione. Quando <ph name="PRODUCT_NAME" /> è in esecuzione in "modalità background", è possibile che la sessione non si chiuda quando viene chiusa l'ultima finestra. Leggere la norma "BackgroundModeEnabled" per avere ulteriori informazioni sulla configurazione di questo comportamento.

          Se questa norma non viene impostata, verrà utilizzata la norma "AllowCookies", che potrà essere modificata dall'utente.</translation>
<translation id="4103289232974211388">Reindirizza a IdP SAML dopo la conferma dell'utente</translation>
<translation id="410478022164847452">Consente di specificare il periodo di tempo senza input dell'utente trascorso il quale viene compiuta l'azione stabilita per l'inattività quando viene utilizzata la corrente alternata.

Se questa norma viene impostata, consente di specificare il periodo di tempo per cui l'utente deve rimanere inattivo prima che <ph name="PRODUCT_OS_NAME" /> compia l'azione di inattività, che può essere configurata separatamente.

Se questa norma non viene impostata, viene utilizzato un periodo di tempo predefinito.

Il valore della norma deve essere specificato in millisecondi.</translation>
<translation id="4105884561459127998">Consente di configurare il tipo di autenticazione per gli accessi SAML.

      Se questa norma non viene impostata o è impostata sul valore predefinito (0), il comportamento degli accessi SAML è determinato dal browser sulla base di altri fattori. Nella situazione di base, l'autenticazione dell'utente e la protezione dei dati degli utenti memorizzati nella cache sono basate sulle password inserite manualmente dagli utenti.

      Se questa norma è impostata su ClientCertificate (valore 1), l'autenticazione del certificato client viene utilizzata per gli utenti aggiunti di recente che accedono tramite SAML. Per questi utenti non vengono utilizzate password e i loro dati locali memorizzati nella cache vengono protetti mediante le chiavi crittografiche corrispondenti. Ad esempio, questa impostazione consente di configurare un'autenticazione dell'utente basata su smart card (considera che le app middleware per smart card devono essere installate tramite la norma DeviceLoginScreenExtensions).

      Questa norma riguarda solo gli utenti che eseguono l'autenticazione utilizzando SAML.</translation>
<translation id="4105989332710272578">Disattiva l'imposizione di Certificate Transparency per un elenco di URL</translation>
<translation id="4121350739760194865">Impedisci la visualizzazione delle promozioni di applicazioni nella pagina Nuova scheda</translation>
<translation id="4125606414556046117">Questa norma consente di configurare l'immagine di sfondo che appare all'utente sul desktop e sullo sfondo della schermata di accesso. La norma viene impostata specificando l'URL da cui <ph name="PRODUCT_OS_NAME" /> può scaricare l'immagine di sfondo e un hash di crittografia utilizzato per verificare l'integrità del download. L'immagine deve essere in formato JPEG e avere dimensioni non superiori a 16 MB. L'URL deve essere accessibile senza nessuna autenticazione.

      L'immagine di sfondo viene scaricata e memorizzata nella cache. Verrà scaricata nuovamente ogni volta che l'URL o l'hash vengono modificati.

      La norma deve essere specificata sotto forma di stringa, in cui l'URL e l'hash vengono espressi in formato JSON, conformemente allo schema riportato di seguito:
      {
        "type": "object",
        "properties": {
          "url": {
            "description": "L'URL da cui può essere scaricata l'immagine di sfondo.",
            "type": "string"
          },
          "hash": {
            "description": "L'hash SHA-256 dell'immagine di sfondo.",
            "type": "string"
          }
        }
      }

      Se questa norma viene impostata, <ph name="PRODUCT_OS_NAME" /> scaricherà e utilizzerà l'immagine di sfondo.

      Se imposti questa norma, gli utenti non potranno modificarla o sostituirla.

      Se la norma non è impostata, l'utente può scegliere un'immagine da visualizzare sul desktop e sullo sfondo della schermata di accesso.</translation>
<translation id="412697421478384751">Consenti agli utenti di impostare PIN non sicuri per la schermata di blocco</translation>
<translation id="4138655880188755661">Limite di tempo</translation>
<translation id="4144164749344898721">Questa norma consente di stabilire diverse impostazioni relative alla strategia di gestione dell'alimentazione quando l'utente diventa inattivo.

          Esistono quattro tipi di azioni:
          * Lo schermo viene oscurato se l'utente rimane inattivo per il tempo specificato da |ScreenDim|.
          * Lo schermo viene spento se l'utente rimane inattivo per il tempo specificato da |ScreenOff|.
          * Se l'utente rimane inattivo per il tempo specificato da |IdleWarning|, viene visualizzata una finestra di dialogo di avviso per indicare all'utente che sta per essere compiuta l'azione per inattività. L'avviso viene mostrato solo se l'azione richiesta in caso di inattività è la disconnessione o lo spegnimento.
          * Se l'utente rimane inattivo per il tempo specificato da |Idle|, viene compiuta l'azione specificata da |IdleAction|.

          Per ognuna delle azioni precedenti, il ritardo deve essere specificato in millisecondi e per attivare l'azione corrispondente deve essere impostato un valore maggiore di zero. Se il ritardo viene impostato su zero, <ph name="PRODUCT_OS_NAME" /> non compie l'azione corrispondente.

          Per ciascun ritardo sopra indicato, quando il periodo di tempo non viene impostato, viene utilizzato il valore predefinito.

          Tieni presente che i valori |ScreenDim| saranno fissati in modo da essere minori o uguali al valore di |ScreenOff|, mentre |ScreenOff| e |IdleWarning| saranno fissati in modo da essere minori o uguali al valore di |Idle|.

          |IdleAction| può essere una delle quattro azioni seguenti:
          * |Suspend|
          * |Logout|
          * |Shutdown|
          * |DoNothing|

          Quando il valore |IdleAction| non è impostato, viene compiuta l'azione predefinita, ossia la sospensione.

          Esistono inoltre impostazioni separate per l'alimentazione CA e la batteria.
          </translation>
<translation id="4150201353443180367">Display</translation>
<translation id="4157003184375321727">Indica versione sistema operativo e firmware</translation>
<translation id="4157594634940419685">Consenti l'accesso a stampanti CUPS native</translation>
<translation id="4160962198980004898">Sorgente dell'indirizzo MAC del dispositivo quando inserito nel dock</translation>
<translation id="4163705126749612234">Consente di configurare i nomi di dominio client richiesti che verranno imposti ai client di accesso remoto e impedisce agli utenti di modificarli.

          Se questa impostazione viene attivata, solo i client di uno dei domini specificati potranno connettersi all'host.

          Se questa impostazione viene disattivata o non definita, sarà applicata la norma predefinita per il tipo di connessione. Per l'assistenza remota, l'impostazione consente ai client di qualsiasi dominio di connettersi all'host; per l'accesso remoto in qualsiasi momento, può connettersi solo il proprietario dell'host.

          Questa impostazione sostituirà RemoteAccessHostClientDomain, se presente.

          Vedi anche RemoteAccessHostDomainList.</translation>
<translation id="4183229833636799228">Impostazione predefinita per il plug-in <ph name="FLASH_PLUGIN_NAME" /></translation>
<translation id="4192388905594723944">URL per la convalida del token di autenticazione del client di accesso remoto</translation>
<translation id="4197038214024763371">Se questa norma non viene impostata o attivata, l'utente può usare il correttore ortografico.

      Se questa norma viene disattivata, l'utente non può usare il correttore ortografico. Quando la norma viene disattivata, vengono ignorate anche le norme SpellcheckLanguage e SpellcheckLanguageBlacklist.
      </translation>
<translation id="4203389617541558220">Consente di limitare il tempo di attività del dispositivo programmando riavvii automatici.

Se questa norma viene impostata consente di specificare il periodo di tempo di attività del dispositivo trascorso il quale è programmato un riavvio automatico.

Se la norma non viene impostata il tempo di attività del dispositivo non è limitato.

Se la norma viene impostata gli utenti non potranno modificarla o ignorarla.

Il riavvio automatico è programmato all'ora selezionata ma potrebbe essere ritardato sul dispositivo di massimo 24 ore se un utente sta utilizzando il dispositivo.

Nota. Attualmente i riavvii automatici vengono attivati soltanto durante la visualizzazione della schermata di accesso o durante una sessione di un'app kiosk. Questo comportamento cambierà in futuro e la norma sarà sempre valida, a prescindere dal fatto che sia in corso o meno una sessione di tipo specifico.

Il valore della norma dovrebbe essere specificato in secondi. Il valore minimo deve essere 3600 (un'ora).</translation>
<translation id="4203879074082863035">Agli utenti vengono mostrate soltanto le stampanti indicate nella whitelist</translation>
<translation id="420512303455129789">Un dizionario che mappa gli URL su un flag booleano che specifica se l'accesso all'host deve essere consentito (true) o bloccato (false).

          Questa norma è per uso interno di <ph name="PRODUCT_NAME" />.</translation>
<translation id="4224610387358583899">Ritardi del blocco schermo</translation>
<translation id="423797045246308574">Consente di impostare un elenco di pattern URL che specificano i siti in cui non è consentito l'utilizzo della generazione di chiavi. Se un pattern URL è indicato nella norma "KeygenAllowedForUrls", quest'ultima ha la precedenza su queste eccezioni.

          Se questa norma non viene impostata, per tutti i siti verrà utilizzato il valore predefinito globale della norma "DefaultKeygenSetting", se è impostata, oppure verrà utilizzata la configurazione personale dell'utente.</translation>
<translation id="4238997902172035160">Consente di configurare la directory che <ph name="PRODUCT_NAME" /> utilizzerà per memorizzare la copia di roaming dei profili.

      Se imposti questa norma, <ph name="PRODUCT_NAME" /> utilizzerà la directory indicata per memorizzare la copia di roaming dei profili se è stata attivata la norma <ph name="ROAMING_PROFILE_SUPPORT_ENABLED_POLICY_NAME" />. Se la norma <ph name="ROAMING_PROFILE_SUPPORT_ENABLED_POLICY_NAME" /> viene disattivata o non è impostata, il valore memorizzato in questa norma non viene utilizzato.

      Visita https://www.chromium.org/administrators/policy-list-3/user-data-directory-variables per consultare un elenco di variabili utilizzabili.

      Se questa norma non è impostata, verrà utilizzato il percorso di profilo di roaming predefinito.</translation>
<translation id="4239720644496144453">La cache non viene utilizzata per le app Android. Se più utenti installano la stessa app Android, questa viene scaricata per ogni utente.</translation>
<translation id="4243336580717651045">Consente di attivare la raccolta di dati anonimizzati con chiave URL in <ph name="PRODUCT_NAME" /> e di impedire agli utenti di modificare questa impostazione.

      La raccolta di dati anonimizzati con chiave URL invia a Google gli URL delle pagine visitate dall'utente al fine di migliorare la ricerca e la navigazione.

      Se questa norma viene attivata, la raccolta di dati anonimizzati con chiave URL è sempre attiva.

      Se questa norma viene disattivata, la raccolta di dati anonimizzati con chiave URL non è mai attiva.

      Se questa norma non viene impostata, la raccolta di dati anonimizzati con chiave URL verrà attivata, ma l'utente potrà modificare l'impostazione.</translation>
<translation id="4250680216510889253">No</translation>
<translation id="4261820385751181068">Lingua della schermata di accesso del dispositivo</translation>
<translation id="427220754384423013">Consente di specificare le stampanti utilizzabili dagli utenti.

      Questa norma viene usata soltanto se viene selezionata l'opzione <ph name="PRINTERS_WHITELIST" /> per la norma <ph name="BULK_PRINTERS_ACCESS_MODE" />.

      Se viene usata questa norma, solo le stampanti con ID corrispondenti ai valori della norma saranno disponibili per gli utenti. Gli ID devono corrispondere ai campi "id" o "guid" del file specificato nella norma <ph name="BULK_PRINTERS_POLICY" />.
      </translation>
<translation id="427632463972968153">Consente di specificare i parametri utilizzati durante la ricerca di immagini con POST. Si tratta di coppie di nome/valore separate da virgole. Se un valore è il parametro di un modello, come {imageThumbnail} nell'esempio precedente, verrà sostituito con i dati delle miniature di immagini reali.

Questa norma è facoltativa. Se non viene impostata, la richiesta di ricerca di immagini verrà inviata utilizzando il metodo GET.

Questa norma viene rispettata soltanto se la norma "DefaultSearchProviderEnabled" è attiva.</translation>
<translation id="4285674129118156176">Consenti agli utenti non affiliati di usare ARC</translation>
<translation id="4298509794364745131">Consente di specificare l'elenco di app che è possibile attivare come app per scrivere note nella schermata di blocco di <ph name="PRODUCT_OS_NAME" />.

      Se nella schermata di blocco viene attivata l'app per scrivere note preferita, nella schermata sarà presente l'elemento dell'interfaccia utente per avviare tale app.
      Quando viene avviata, l'app può creare una finestra sopra la schermata di blocco e creare dati (note) nel contesto della schermata di blocco. L'app può importare note create nella sessione utente principale, quando la sessione è sbloccata. Attualmente, nella schermata di blocco sono supportate soltanto le app per scrivere note di Chrome.

      Se la norma viene impostata, l'utente potrà attivare un'app nella schermata di blocco soltanto se l'ID estensione dell'app è presente come valore nell'elenco della norma.
      Di conseguenza, se l'elenco di questa norma viene lasciato vuoto, non sarà consentito scrivere note nella schermata di blocco.
      Tieni presente che l'esistenza dell'ID di un'app nella norma non implica necessariamente che l'utente potrà attivare l'app in questione come app per scrivere note nella schermata di blocco. Ad esempio, su Chrome 61, il gruppo di app disponibili è limitato ulteriormente dalla piattaforma.

      Se la norma non viene impostata, non ci saranno limitazioni relative al gruppo di app che l'utente potrà attivare nella schermata di blocco.</translation>
<translation id="4313767483634435271">Indirizzo MAC designato del dock</translation>
<translation id="4322842393287974810">Consenti all'app kiosk avviata automaticamente senza ritardo di controllare la versione di <ph name="PRODUCT_OS_NAME" /></translation>
<translation id="4325690621216251241">Aggiungi un pulsante di uscita all'area di notifica</translation>
<translation id="4332177773549877617">Registra eventi per le installazioni di app Android</translation>
<translation id="4335292026668105285">Consente di specificare il periodo di tempo senza immissioni da parte dell'utente dopo il quale viene mostrata una finestra di dialogo di avviso quando il computer è alimentato tramite CA.

          Quando è impostata, questa norma specifica per quanto tempo l'utente deve rimanere inattivo prima che <ph name="PRODUCT_OS_NAME" /> mostri una finestra di dialogo di avviso in cui comunica all'utente che sta per essere intrapresa l'azione richiesta in caso di inattività.

          Quando questa norma non è impostata, non viene visualizzata alcuna finestra di dialogo di avviso.

          Il valore della norma deve essere specificato in millisecondi. I valori sono fissati in modo da essere minori o uguali al ritardo di inattività.

          L'avviso viene mostrato solo se l'azione richiesta in caso di inattività è la disconnessione o lo spegnimento.</translation>
<translation id="4346674324214534449">Consente di stabilire se bloccare o meno gli annunci su siti con annunci invasivi.

      Se questa norma viene impostata su 2, gli annunci verranno bloccati sui siti con annunci invasivi.
      Questo comportamento non verrà però attivato se la norma SafeBrowsingEnabled viene impostata su False.
      Se questa norma viene impostata su 1, gli annunci non verranno bloccati sui siti con annunci invasivi.
      Se questa norma non viene impostata, verrà usato il valore 2.</translation>
<translation id="4347908978527632940">Se la norma viene impostata su true e l'utente è supervisionato, le altre app Android possono chiedere le restrizioni web dell'utente tramite un provider di contenuti.

          Se la norma è impostata su false o non è impostata, il provider di contenuti non restituisce informazioni.</translation>
<translation id="435461861920493948">Contiene un elenco di pattern utilizzati per stabilire la visibilità degli account in <ph name="PRODUCT_NAME" />.

      Ogni Account Google sul dispositivo viene confrontato con i pattern memorizzati in questa norma per stabilirne la visibilità in <ph name="PRODUCT_NAME" />. L'account sarà visibile se il nome coincide con qualsiasi pattern nell'elenco. In caso contrario l'account sarà nascosto.

      Il carattere jolly "*" rappresenta zero o più caratteri arbitrari. Il carattere di escape è "\", quindi per trovare una corrispondenza con il significato letterale dei caratteri "*" o "\", falli precedere da "\".

      Se questa norma non viene impostata, tutti gli Account Google sul dispositivo saranno visibili in <ph name="PRODUCT_NAME" />.</translation>
<translation id="4360826270668210664">Se questa norma viene impostata, l'host di accesso remoto richiederà che i client di autenticazione ottengano un token di autenticazione da questo URL per consentire la connessione. Deve essere utilizzata insieme a RemoteAccessHostTokenValidationUrl.

          Questa funzione è attualmente disattivata lato server.</translation>
<translation id="4363057787588706121">Unisci i criteri relativi all'elenco provenienti da diverse origini</translation>
<translation id="436581050240847513">Riporta interfacce di rete del dispositivo</translation>
<translation id="4372704773119750918">Non permettere all'utente aziendale di far parte del profilo multiplo (principale o secondario)</translation>
<translation id="4377599627073874279">Consenti la visualizzazione di tutte le immagini in tutti i siti</translation>
<translation id="437791893267799639">Norma non impostata. Non consentire migrazione dei dati e ARC</translation>
<translation id="4389073105055031853">Consenti agli utenti di gestire tutti i certificati</translation>
<translation id="4389091865841123886">Configura l'attestazione da remoto con meccanismo TPM.</translation>
<translation id="4408428864159735559">Elenco di condivisioni di file di rete preconfigurate.</translation>
<translation id="4410236409016356088">Attiva la limitazione della larghezza di banda della rete</translation>
<translation id="441217499641439905">Disattiva Google Drive su reti cellulari nell'app File di <ph name="PRODUCT_OS_NAME" /></translation>
<translation id="4415603335307944578">Se questa norma è impostata su true o non è configurata, il browser mostrerà di nuovo la pagina di benvenuto al primo avvio successivo a un upgrade del sistema operativo.

      Se la norma è impostata su false, il browser non mostrerà di nuovo la pagina di benvenuto in occasione del primo avvio successivo a un upgrade del sistema operativo.</translation>
<translation id="4418726081189202489">Se questa norma viene impostata su false, <ph name="PRODUCT_NAME" /> non può più inviare query occasionali a un server di Google per recuperare un timestamp preciso. Queste query vengono attivate se questa norma viene impostata su True o non viene configurata.</translation>
<translation id="4423597592074154136">Specifica manualmente le impostazioni proxy</translation>
<translation id="4429220551923452215">Attiva o disattiva la scorciatoia per le app nella barra dei Preferiti. Se questa norma non è impostata, l'utente può scegliere di mostrare o nascondere la scorciatoia per le app dal menu contestuale della barra dei Preferiti. Se la norma è configurata, l'utente non può modificarla e la scorciatoia per le app viene mostrata sempre oppure non viene mostrata mai.</translation>
<translation id="4432762137771104529">Attiva rapporti estesi su Navigazione sicura</translation>
<translation id="443454694385851356">Precedente (non sicuro)</translation>
<translation id="443665821428652897">Cancella i dati del sito alla chiusura del browser (obsoleta)</translation>
<translation id="4439132805807595336">Consente al dispositivo di eseguire PluginVm.

      Se la norma viene impostata su false o non viene impostata, <ph name="PLUGIN_VM_NAME" /> non viene attivato per il dispositivo. Se viene impostata su true, <ph name="PLUGIN_VM_NAME" /> viene attivato per il dispositivo, a condizione che anche le altre impostazioni lo permettano. La norma <ph name="PLUGIN_VM_ALLOWED_POLICY_NAME" /> deve essere impostata su true, mentre le norme <ph name="PLUGIN_VM_LICENSE_KEY_POLICY_NAME" /> e <ph name="PLUGIN_VM_IMAGE_POLICY_NAME" /> devono essere impostate per consentire l'esecuzione di <ph name="PLUGIN_VM_NAME" />.</translation>
<translation id="4439336120285389675">Consente di specificare un elenco di funzioni ritirate della piattaforma web da riattivare temporaneamente.

      Questa norma consente agli amministratori di riattivare funzioni ritirate della piattaforma web per un periodo di tempo limitato. Le funzioni sono identificate da un tag string e le funzioni corrispondenti ai tag inclusi nell'elenco specificato tramite questa norma verranno riattivate.

      Se questa norma non viene impostata, se l'elenco è vuoto o non corrisponde a uno dei tag string supportati, rimarranno disattivate tutte le funzioni ritirate della piattaforma web.

      La norma stessa è supportata sulle piattaforme precedenti, ma la funzione attivata dalla norma potrebbe essere disponibile su meno piattaforme. Non è possibile riattivare tutte le funzioni ritirate della piattaforma web, ma soltanto quelle elencate esplicitamente di seguito e soltanto per un periodo di tempo limitato, che è diverso per ogni funzione. Il formato generico del tag string sarà [NomeFunzioneRitirata]_EffectiveUntil[aaaammgg]. È possibile conoscere lo scopo delle modifiche alle funzioni della piattaforma web all'indirizzo https://bit.ly/blinkintents.
      </translation>
<translation id="4442582539341804154">Attiva il blocco quando lo stato del dispositivo diventa inattivo o sospeso</translation>
<translation id="4449469846627734399">Consente di impostare la configurazione giornaliera della variazione dei picchi energetici</translation>
<translation id="4449545651113180484">Ruota lo schermo in senso orario di 270°</translation>
<translation id="445270821089253489">Consente di stabilire i tipi di informazioni su dispositivi e utenti da segnalare.</translation>
<translation id="4454820008017317557">Mostra l'icona della barra degli strumenti di <ph name="PRODUCT_NAME" /></translation>
<translation id="4467952432486360968">Blocca cookie di terze parti</translation>
<translation id="4474167089968829729">Attiva il salvataggio delle password in Gestione password</translation>
<translation id="4476769083125004742">Se la norma viene impostata su <ph name="BLOCK_GEOLOCATION_SETTING" />, le app Android non possono accedere ai dati sulla posizione. Se la norma viene impostata su qualsiasi altro valore o non viene impostata, all'utente viene chiesta l'autorizzazione quando un'app Android vuole accedere ai dati sulla posizione.</translation>
<translation id="4480694116501920047">Forza SafeSearch</translation>
<translation id="4482640907922304445">Consente di visualizzare il pulsante Pagina iniziale sulla barra degli strumenti di <ph name="PRODUCT_NAME" />. Se attivi questa impostazione il pulsante Pagina iniziale verrà sempre visualizzato, in caso contrario non verrà mai visualizzato. Se questa impostazione viene attivata o disattivata, gli utenti non potranno modificarla o sostituirla in <ph name="PRODUCT_NAME" />. Se non imposti questa norma gli utenti potranno scegliere se visualizzare o meno il pulsante Pagina iniziale.</translation>
<translation id="4483649828988077221">Disattiva l'aggiornamento automatico</translation>
<translation id="4485425108474077672">Configura l'URL per la pagina Nuova scheda</translation>
<translation id="4492287494009043413">Disabilita l'acquisizione di screenshot</translation>
<translation id="4494132853995232608">DTC wilco</translation>
<translation id="449423975179525290">Imposta le norme relative a <ph name="PLUGIN_VM_NAME" />.</translation>
<translation id="450537894712826981">Consente di configurare le dimensioni della cache che verranno utilizzate da <ph name="PRODUCT_NAME" /> per archiviare sul disco i file multimediali memorizzati nella cache.

Se questa norma viene impostata, <ph name="PRODUCT_NAME" /> utilizzerà le dimensioni della cache indicate a prescindere dalla specifica o meno da parte dell'utente del flag "--media-cache-size". Il valore specificato in questa norma non è un limite rigido ma un suggerimento per il sistema di memorizzazione nella cache. I valori inferiori ad alcuni megabyte sono troppo piccoli e verranno arrotondati a un valore minimo ragionevole.

Se il valore di questa norma è 0, verranno utilizzate le dimensioni della cache predefinite, che l'utente non potrà modificare.

Se questa norma non viene impostata, verranno utilizzate le dimensioni predefinite, che l'utente potrà sostituire con il flag --media-cache-size.</translation>
<translation id="4508686775017063528">Se questa norma viene impostata su true o non viene impostata, <ph name="PRODUCT_NAME" /> sarà attivato e gli utenti potranno avviarlo dal menu dell'app, dai menu contestuali nelle pagine, dai controlli multimediali nei siti web compatibili con Google Cast e (se presente) dall'icona Cast della barra degli strumenti.

          Se questa norma viene impostata su false, <ph name="PRODUCT_NAME" /> sarà disattivato.</translation>
<translation id="4515404363392014383">Attiva Navigazione sicura per le origini attendibili</translation>
<translation id="4518251772179446575">Chiedi ogni volta che un sito desidera monitorare la posizione fisica degli utenti</translation>
<translation id="4519046672992331730">Consente di attivare i suggerimenti di ricerca nella omnibox di <ph name="PRODUCT_NAME" /> e di impedire agli utenti di modificare l'impostazione.

Se questa impostazione viene attivata, i suggerimenti di ricerca verranno utilizzati, in caso contrario non verranno mai utilizzati.

Se questa impostazione viene attivata o disattivata, gli utenti non potranno modificarla o sostituirla in <ph name="PRODUCT_NAME" />.

Se questa norma non viene impostata, l'impostazione verrà attivata ma gli utenti potranno modificarla.</translation>
<translation id="4531706050939927436">L'installazione di app Android può essere imposta dalla Console d'amministrazione Google tramite Google Play. Questa norma non viene utilizzata.</translation>
<translation id="4534500438517478692">Nome della limitazione di Android:</translation>
<translation id="4541530620466526913">Account del dispositivo</translation>
<translation id="4543502256674577024">Impostazioni di aggiornamento del dispositivo</translation>
<translation id="4554651132977135445">Modalità di elaborazione loopback dei criteri relativi agli utenti</translation>
<translation id="4554841826517980623">Questa norma controlla se per <ph name="PRODUCT_NAME" /> la funzione Condivisioni file di rete debba utilizzare o meno il protocollo <ph name="NETBIOS_PROTOCOL" /> per individuare le condivisioni sulla rete.
      Quando questa norma è impostata su True, il rilevamento delle condivisioni utilizza il protocollo <ph name="NETBIOS_PROTOCOL" /> per individuare le condivisioni sulla rete.
      Quando questa norma è impostata su False, il rilevamento delle condivisioni non utilizza il protocollo <ph name="NETBIOS_PROTOCOL" /> per individuare le condivisioni sulla rete.
      Se la norma viene lasciata senza impostazione, per impostazione predefinita la norma sarà disattivata per gli utenti gestiti dall'azienda, mentre sarà attiva per gli utenti non gestiti.</translation>
<translation id="4555850956567117258">Attivazione dell'attestazione da remoto per l'utente</translation>
<translation id="4557134566541205630">URL pagina Nuova scheda provider di ricerca predefinito</translation>
<translation id="4567137030726189378">Consenti l'utilizzo degli Strumenti per sviluppatori</translation>
<translation id="4578265298946081589">Non riavviare all'uscita dell'utente.</translation>
<translation id="4578912515887794133">Se questa impostazione viene attivata, l'host di accesso remoto confronta il nome dell'utente locale (a cui è associato l'host) con il nome dell'Account Google registrato come proprietario dell'host (ad es. "mariorossi" se l'host è di proprietà dell'Account Google "mariorossi@example.com").  L'host di accesso remoto non viene avviato se il nome del proprietario dell'host non coincide con quello dell'utente locale a cui è associato l'host.  La norma RemoteAccessHostMatchUsername deve essere utilizzata insieme a RemoteAccessHostDomain per far sì che l'Account Google del proprietario dell'host sia associato a un dominio specifico (ad es. "example.com").

          Se questa impostazione viene disattivata o non viene impostata, l'host di accesso remoto può essere associato a qualsiasi utente locale.</translation>
<translation id="4600786265870346112">Attivazione del puntatore grande</translation>
<translation id="4604931264910482931">Configura lista nera di messaggi nativi</translation>
<translation id="4613508646038788144">Se la norma viene impostata su false, i programmi software di terze parti potranno inserire codice eseguibile nei processi di Chrome. Se la norma non viene impostata o viene impostata su true, i programmi software di terze parti non potranno inserire codice eseguibile nei processi di Chrome.</translation>
<translation id="4617338332148204752">Salta il controllo dei metatag in <ph name="PRODUCT_FRAME_NAME" /></translation>
<translation id="4625915093043961294">Configura la whitelist per l'installazione delle estensioni</translation>
<translation id="4632343302005518762">Consenti a <ph name="PRODUCT_FRAME_NAME" /> di gestire i tipi di contenuti elencati</translation>
<translation id="4632566332417930481">Non consentire l'utilizzo degli Strumenti per sviluppatori per le estensioni installate in base a norme aziendali; consenti l'utilizzo degli Strumenti per sviluppatori in altri contesti</translation>
<translation id="4633786464238689684">Consente di modificare il comportamento predefinito dei tasti della fila superiore in tasti funzione.

          Se questa norma è impostata su "true", i tasti della fila superiore della tastiera riprodurranno i comandi dei tasti funzione per impostazione predefinita. Per ripristinare il comportamento dei tasti multimediali, è necessario premere il tasto per la ricerca.

          Se questa norma è impostata su "false" o non viene impostata, la tastiera riprodurrà i comandi dei tasti multimediali per impostazione predefinita e i comandi dei tasti funzione quando viene premuto il tasto per la ricerca.</translation>
<translation id="4639407427807680016">Nomi degli host di messaggi nativi da escludere dalla lista nera.</translation>
<translation id="4650759511838826572">Disabilita schemi di protocollo dell'URL</translation>
<translation id="465099050592230505">URL del web store dell'azienda (obsoleta)</translation>
<translation id="4665897631924472251">Impostazioni di gestione delle estensioni</translation>
<translation id="4668325077104657568">Impostazione immagini predefinite</translation>
<translation id="4670865688564083639">Minimo:</translation>
<translation id="4671708336564240458">Ti consente di determinare se evitare l'apertura di nuove finestre o schede da parte di siti con esperienze intrusive.

      Se questa norma è impostata su True, verrà evitata l'apertura di nuove finestre o schede da parte di siti con esperienze intrusive.
      Tuttavia, questo comportamento non viene attivato se la norma SafeBrowsingEnabled è impostata su False.
      Se questa norma è impostata su False, verrà consentita l'apertura di nuove finestre o schede da parte di siti con esperienze intrusive.
      Se questa norma non viene impostata, verrà usata l'impostazione True.</translation>
<translation id="467236746355332046">Funzionalità supportate:</translation>
<translation id="4674167212832291997">Consente di personalizzare l'elenco di pattern URL per i quali il rendering deve sempre essere eseguito da <ph name="PRODUCT_FRAME_NAME" />.

          Se la norma non viene impostata, verrà utilizzato per tutti i siti il renderer predefinito specificato dalla norma "ChromeFrameRendererSettings".

          Per avere pattern di esempio, visita il sito https://www.chromium.org/developers/how-tos/chrome-frame-getting-started.</translation>
<translation id="467449052039111439">Apri un elenco di URL</translation>
<translation id="4674871290487541952">Consente algoritmi non protetti nei controlli dell'integrità durante gli aggiornamenti e le installazioni delle estensioni</translation>
<translation id="4680936297850947973">Ritirata in M68. Usa DefaultPopupsSetting.

      Per una spiegazione completa, consulta la pagina https://www.chromestatus.com/features/5675755719622656.
      Se questa norma viene attivata, ai siti sarà concesso di navigare e aprire nuove finestre/schede contemporaneamente.
      Se questa norma viene disattivata o non viene impostata, ai siti non sarà concesso di navigare e aprire nuove finestre/schede contemporaneamente.</translation>
<translation id="4680961954980851756">Abilita Compilazione automatica</translation>
<translation id="4703402283970867140">Attiva il modello di oscuramento smart per ritardare l'oscuramento dello schermo</translation>
<translation id="4722122254122249791">Attiva isolamento sito per origini specificate</translation>
<translation id="4722399051042571387">Se questa norma viene impostata su false, gli utenti non potranno impostare PIN non sicuri e facili da intuire.

          Ecco alcuni esempi di PIN non sicuri: PIN formati da una sola cifra ripetuta (1111), PIN composti da cifre con incrementi di 1 (1234) o decrementi di 1 (4321) e PIN troppo comuni.

          Per impostazione predefinita, gli utenti riceveranno un avviso, e non un errore, se il PIN è considerato non sicuro.</translation>
<translation id="4723829699367336876">Abilita attraversamento firewall da client di accesso remoto</translation>
<translation id="4725528134735324213">Attiva Android Backup Service</translation>
<translation id="4725801978265372736">Richiedi la corrispondenza tra il nome dell'utente locale e il proprietario dell'host di accesso remoto</translation>
<translation id="4733471537137819387">Norme relative all'autenticazione HTTP integrata.</translation>
<translation id="4744190513568488164">Server a cui <ph name="PRODUCT_NAME" /> potrebbe delegare le credenziali utente.

          Separare più nomi di server con delle virgole. Sono ammessi i caratteri jolly (*).

          Se questa norma non è impostata, <ph name="PRODUCT_NAME" /> non delegherà le credenziali utente, anche se viene rilevato un server sulla Intranet.</translation>
<translation id="4752880493649142945">Certificato client per la connessione a RemoteAccessHostTokenValidationUrl</translation>
<translation id="4757671984625088193">Se questa norma viene impostata su true o non viene impostata, <ph name="PRODUCT_NAME" /> ti suggerirà pagine correlate alla pagina corrente.
      Questi suggerimenti vengono recuperati da remoto dai server di Google.

      Se la norma è impostata su false, non verranno recuperati o mostrati suggerimenti.</translation>
<translation id="4788252609789586009">Consente di attivare la funzione Compilazione automatica di <ph name="PRODUCT_NAME" /> e permette agli utenti di eseguire il completamento automatico dei dati della carta di credito nei moduli web utilizzando informazioni memorizzate in precedenza.

      Se questa impostazione è disattivata, la funzione Compilazione automatica non suggerirà o non inserirà mai i dati della carta di credito e non salverà i dati di altre carte di credito che l'utente potrebbe inviare durante la navigazione sul Web.

      Se questa impostazione è attivata o non è impostata su alcun valore, l'utente potrà gestire la funzione Compilazione automatica per le carte di credito nell'interfaccia utente.</translation>
<translation id="4791031774429044540">Consente di attivare la funzione di accessibilità del puntatore grande.

Se la norma viene impostata su true, il puntatore grande sarà sempre attivo.

Se la norma viene impostata su false, il puntatore grande sarà sempre disattivato.

Se la norma viene impostata, gli utenti non potranno modificarla o ignorarla.

Se la norma non viene impostata, il puntatore grande sarà inizialmente disattivato ma gli utenti potranno attivarlo in qualsiasi momento.</translation>
<translation id="4802905909524200151">Configura il comportamento di aggiornamento del firmware <ph name="TPM_FIRMWARE_UPDATE_TPM" /></translation>
<translation id="4804828344300125154">Riavvia sempre all'uscita dell'utente.</translation>
<translation id="4807950475297505572">Gli utenti utilizzati meno di recente vengono rimossi fino alla disponibilità di spazio libero sufficiente</translation>
<translation id="4816674326202173458">Consenti all'utente aziendale di essere l'utente principale e secondario (comportamento predefinito per gli utenti non gestiti)</translation>
<translation id="4826326557828204741">Azione da compiere quando il ritardo di inattività viene raggiunto durante l'utilizzo della batteria</translation>
<translation id="4832852360828533362">Rapporti su dispositivi e utenti</translation>
<translation id="4834526953114077364">Gli utenti utilizzati meno di recente che non hanno eseguito l'accesso negli ultimi tre mesi vengono rimossi fino alla disponibilità di spazio libero sufficiente</translation>
<translation id="4835622243021053389">Attiva autenticazione NTLMv2.</translation>
<translation id="4858735034935305895">Consenti modalità a schermo intero</translation>
<translation id="4861767323695239729">Configura i metodi di immissione consentiti in una sessione utente</translation>
<translation id="487460824085252184">Esegui automaticamente la migrazione senza chiedere il consenso dell'utente</translation>
<translation id="4874982543810021567">Blocca WebUSB su questi siti</translation>
<translation id="4876805738539874299">Versione SSL massima abilitata</translation>
<translation id="4897928009230106190">Consente di specificare i parametri utilizzati durante la ricerca di suggerimenti con POST. Si tratta di coppie di nome/valore separate da virgole. Se un valore è il parametro di un modello, come {searchTerms} nell'esempio precedente, verrà sostituito con i dati dei termini di ricerca reali.

Questa norma è facoltativa. Se non viene impostata, la richiesta di ricerca di suggerimenti verrà inviata utilizzando il metodo GET.

Questa norma viene rispettata soltanto se la norma "DefaultSearchProviderEnabled" è attiva.</translation>
<translation id="489803897780524242">Parametro di controllo sostituzione termini di ricerca per fornitore ricerca predefinito</translation>
<translation id="4899708173828500852">Consenti Navigazione sicura</translation>
<translation id="4899802251198446659">Ti consente di stabilire se permettere o meno la riproduzione automatica dei video (senza il consenso dell'utente) con contenuti audio in <ph name="PRODUCT_NAME" />.

      Se il criterio viene impostato su True, in <ph name="PRODUCT_NAME" /> è consentita la riproduzione automatica dei contenuti multimediali.
      Se il criterio viene impostato su False, in <ph name="PRODUCT_NAME" /> non è consentita la riproduzione automatica dei contenuti multimediali. È possibile usare il criterio AutoplayWhitelist in sostituzione di questo criterio per alcuni pattern URL.
      Per impostazione predefinita, la riproduzione automatica di contenuti multimediali in <ph name="PRODUCT_NAME" /> non è consentita. È possibile usare il criterio AutoplayWhitelist in sostituzione di questo criterio per alcuni pattern URL.

      Tieni presente che se questo criterio viene cambiato mentre <ph name="PRODUCT_NAME" /> è in esecuzione, il criterio viene applicato soltanto alle nuove schede aperte. Di conseguenza alcune schede potrebbero mantenere il comportamento precedente.
      </translation>
<translation id="4906194810004762807">Frequenza di aggiornamento per norma dispositivo</translation>
<translation id="4917385247580444890">Forte</translation>
<translation id="4923806312383904642">Consenti a WebDriver di eseguire l'override delle norme non compatibili</translation>
<translation id="494613465159630803">Cast Receiver</translation>
<translation id="494924690085329212">Riavvia all'uscita dell'utente se Android è stato avviato.</translation>
<translation id="4962262530309732070">Se questo criterio è impostato su true o non viene configurato, su <ph name="PRODUCT_NAME" /> sarà possibile aggiungere persone con la funzione Aggiungi persona di Gestione utenti.

      Se questo criterio è impostato su false, in <ph name="PRODUCT_NAME" /> non sarà possibile creare nuovi profili da Gestione utenti.</translation>
<translation id="4970855112942626932">Disattiva accesso al browser</translation>
<translation id="4978405676361550165">Se viene impostata la norma "OffHours", i criteri relativi ai dispositivi specificate vengono ignorate (vengono usate le impostazioni predefinite dei criteri) durante gli intervalli di tempo definiti. I criteri relativi ai dispositivi vengono riapplicati da Chrome ogni volta che inizia o finisce il periodo definito in "OffHours". L'utente verrà informato e obbligato a uscire dall'account quando vengono cambiate le impostazioni relative alla fine del periodo "OffHours" e ai criteri relativi ai dispositivi (ad esempio se l'utente ha eseguito l'accesso con un account non consentito).</translation>
<translation id="4980635395568992380">Tipo di dati:</translation>
<translation id="4983201894483989687">Consenti esecuzione dei plug-in obsoleti</translation>
<translation id="4986560318567565414">Percorso a Chrome per cambiare il browser alternativo.</translation>
<translation id="4988291787868618635">Azione da compiere a raggiungimento ritardo inattività</translation>
<translation id="5034604678285451405">Imposta un valore percentuale per il limite di consumo della batteria per la variazione dei picchi energetici.

          Questa norma viene utilizzata solo se l'opzione DevicePowerPeakShiftEnabled è impostata su true.

          Se questa norma non è configurata o non è impostata, la variazione dei picchi energetici risulterà sempre disattivata.</translation>
<translation id="5047604665028708335">Consenti l'accesso ai siti non presenti nei pacchetti di contenuti</translation>
<translation id="5052081091120171147">Se è attiva, questa norma impone l'importazione della cronologia di navigazione dal browser predefinito corrente. Se la norma è attiva incide anche sulla finestra di dialogo di importazione. Se non è attiva, la cronologia di navigazione non viene importata. Se non viene impostata, all'utente potrebbe essere chiesto se desidera effettuare l'importazione, oppure l'importazione potrebbe avvenire automaticamente.</translation>
<translation id="5055312535952606505">Consente di configurare le impostazioni proxy per <ph name="PRODUCT_NAME" />, che saranno disponibili anche per le app ARC.

          Se attivi questa impostazione, <ph name="PRODUCT_NAME" /> e le app ARC ignorano tutte le opzioni relative ai proxy specificate dalla riga di comando.

          Se questa norma non è impostata, gli utenti potranno scegliere le impostazioni proxy autonomamente.

          Se la norma <ph name="PROXY_SETTINGS_POLICY_NAME" /> è impostata, sostituirà qualsiasi norma singola <ph name="PROXY_MODE_POLICY_NAME" />, <ph name="PROXY_PAC_URL_POLICY_NAME" />, <ph name="PROXY_SERVER_POLICY_NAME" />, <ph name="PROXY_BYPASS_POLICY_NAME" /> e <ph name="PROXY_SERVER_MODE_POLICY_NAME" />.

          Il campo <ph name="PROXY_MODE_PROXY_SETTINGS_FIELD" /> consente di specificare il server proxy utilizzato da <ph name="PRODUCT_NAME" /> e impedisce agli utenti di modificare le impostazioni di proxy.

          Il campo <ph name="PROXY_PAC_URL_PROXY_SETTINGS_FIELD" /> è un URL di un file proxy .pac.

          Il campo <ph name="PROXY_SERVER_PROXY_SETTINGS_FIELD" /> è un URL del server proxy.

          Il campo <ph name="PROXY_BYPASS_LIST_PROXY_SETTINGS_FIELD" /> è un elenco di host proxy che <ph name="PRODUCT_NAME" /> aggirerà.

          Il campo <ph name="PROXY_SERVER_MODE_PROXY_SETTINGS_FIELD" /> è obsoleto a favore del campo "ProxyMode". Consente di specificare il server proxy utilizzato da <ph name="PRODUCT_NAME" /> e impedisce agli utenti di modificare le impostazioni proxy.

          Se si sceglie come "ProxyMode" il valore "direct", non verrà mai utilizzato un proxy e tutti gli altri campi saranno ignorati.

          Se si sceglie come "ProxyMode" il valore "system", verrà utilizzato il proxy del sistema e tutti gli altri campi saranno ignorati.

          Se si sceglie come "ProxyMode" il valore "auto_detect", tutti gli altri campi saranno ignorati.

          Se si sceglie come "ProxyMode" il valore "fixed_server", verranno utilizzati i campi "ProxyServer" e "ProxyBypassList".

          Se si sceglie come "ProxyMode" il valore "pac_script", verranno utilizzati i campi "ProxyPacUrl" e "ProxyBypassList".</translation>
<translation id="5056708224511062314">Ingrandimento dello schermo disattivato</translation>
<translation id="5058573563327660283">Seleziona la strategia da utilizzare per liberare spazio su disco durante la pulizia automatica (obsoleta)</translation>
<translation id="5067143124345820993">Whitelist di utenti con accesso</translation>
<translation id="5075834892754086022">Se la norma viene impostata, viene applicata la lunghezza di PIN minima
          configurata. (La lunghezza minima assoluta dei codici PIN è 1; i valori inferiori a 1
          vengono considerati pari a 1).

          Se la norma non viene impostata, viene applicata la lunghezza minima del PIN,
          pari a 6 cifre. Si tratta del minimo consigliato.</translation>
<translation id="5076274878326940940">Attiva l'utilizzo di un provider di ricerca predefinito.

          Se attivi questa impostazione, verrà eseguita una ricerca predefinita ogni volta che l'utente digita nella omnibox un testo che non è un URL.

          Puoi specificare il provider di ricerca predefinito da utilizzare impostando tutti le altre norme relative alla ricerca predefinita. Se le norme non sono specificate, l'utente potrà scegliere il provider predefinito.

          Se disattivi questa impostazione, quando l'utente inserisce un testo che non è un URL nella omnibox non verrà eseguita nessuna ricerca.

          Se attivi o disattivi questa impostazione, gli utenti non potranno modificare né sostituire questa impostazione in <ph name="PRODUCT_NAME" />.

          Se questa norma non viene impostata, viene attivato il provider di ricerca predefinito e l'utente potrà impostare l'elenco di provider di ricerca.

          Questa norma è disponibile esclusivamente per le istanze di Windows che fanno parte di un dominio <ph name="MS_AD_NAME" /> così come per le istanze di Windows 10 Pro o Enterprise registrate per la gestione dei dispositivi.</translation>
<translation id="5085647276663819155">Disattiva anteprima di stampa</translation>
<translation id="5090209345759901501">Applica l'impostazione dei contenuti Flash a tutti i contenuti</translation>
<translation id="5093540029655764852">Consente di specificare la frequenza (in giorni) alla quale un client modifica la password dell'account del computer. La password è generata in modo casuale dal client e non è visibile all'utente.

      Come per le password dell'utente, anche le password del computer andrebbero modificate regolarmente. Se disattivi questa norma o imposti un numero di giorni elevato, la sicurezza ne risentirà negativamente poiché in questo modo concederai più tempo ai potenziali utenti malintenzionati per trovare la password dell'account del computer e utilizzarla.

      Se la norma non viene impostata, la password dell'account del computer viene modificata ogni 30 giorni.

      Se la norma è impostata su 0, la modifica della password dell'account del computer è disattivata.

      Tieni presente che le password potrebbero durare più a lungo rispetto ai giorni specificati se il client è offline per un periodo più lungo di tempo.</translation>
<translation id="510196893779239086">Questa norma controlla la chiusura completa di Chrome quando l'ultima scheda passa a un altro browser.

      Se questa norma non viene impostata o viene impostata su true, Chrome manterrà almeno una scheda aperta dopo il passaggio a un browser alternativo.

      Se questa norma viene impostata su false, Chrome chiuderà la scheda dopo il passaggio a un browser alternativo, anche se si tratta dell'ultima scheda. Ciò comporterà la chiusura completa di Chrome.</translation>
<translation id="5105313908130842249">Ritardo blocco schermo in caso di utilizzo della batteria</translation>
<translation id="5108031557082757679">Stampanti aziendali associate ai dispositivi disattivate</translation>
<translation id="5113732180192599620">Questa norma consente di stabilire l'elenco di siti web che non causeranno mai un cambio di browser.

      Tieni presente che puoi aggiungere elementi all'elenco anche tramite le norme <ph name="USE_IE_SITELIST_POLICY_NAME" /> e <ph name="EXTERNAL_SITELIST_URL_POLICY_NAME" />.

      Se questa norma non viene impostata, nessun sito web viene aggiunto all'elenco.

      Se viene impostata, ogni elemento è considerato come una regola, in modo simile alla norma <ph name="URL_LIST_POLICY_NAME" />. Tuttavia, la logica funziona al contrario: le regole con una corrispondenza non aprono un browser alternativo.

      A differenza della norma <ph name="URL_LIST_POLICY_NAME" />, le regole vengono applicate in entrambe le direzioni. In altre parole, quando il componente aggiuntivo Internet Explorer è presente e attivato, la norma stabilisce se <ph name="IE_PRODUCT_NAME" /> deve aprire questi URL in <ph name="PRODUCT_NAME" />.</translation>
<translation id="5124368997194894978">Attiva avvio tramite CA (corrente alternata)</translation>
<translation id="5131211790949066746">Consente di unire le norme relative all'elenco di installazione delle estensioni <ph name="EXTENSION_INSTALL_BLACKLIST_POLICY_NAME" />, <ph name="EXTENSION_INSTALL_WHITELIST_POLICY_NAME" /> e <ph name="EXTENSION_INSTALL_FORCELIST_POLICY_NAME" />.

      Se attivi questa impostazione, i valori delle norme relative alla piattaforma del computer, al cloud del computer e alla piattaforma dell'utente vengono uniti in un unico elenco e usati in toto; in questo modo non vengono usati soltanto i valori di una singola fonte con la massima priorità.

      Se disattivi questa impostazione o non la imposti, vengono recuperate soltanto le voci dell'elenco della fonte con la massima priorità e tutte le altre fonti risultano in conflitto, ma vengono ignorate.</translation>
<translation id="5141670636904227950">Impostazione tipo di ingrandimento dello schermo predefinito attivato nella schermata di accesso</translation>
<translation id="5142301680741828703">Visualizza sempre i seguenti schemi di URL in <ph name="PRODUCT_FRAME_NAME" /></translation>
<translation id="5148753489738115745">Consente di specificare dei parametri aggiuntivi da utilizzare quando <ph name="PRODUCT_FRAME_NAME" /> avvia <ph name="PRODUCT_NAME" />.

Se questa norma non viene impostata viene utilizzata la riga di comando predefinita.</translation>
<translation id="5159469559091666409">Consente di stabilire la frequenza di invio, in millisecondi, dei pacchetti di rete di monitoraggio.

      Se la norma non viene impostata, l'intervallo predefinito è pari a tre minuti. L'intervallo minimo è pari a 30 secondi, il massimo a 24 ore. I valori che non rientrano in questo intervallo verranno fatti rientrare.</translation>
<translation id="5163002264923337812">Attiva il flusso di accesso basato sul Web precedente</translation>
<translation id="5168529971295111207">Questa norma è obsoleta, al suo posto usa ProxyMode.

          Consente di specificare il server proxy utilizzato da <ph name="PRODUCT_NAME" /> e impedisce agli utenti di modificare le impostazioni proxy.

          Questa norma viene applicata soltanto se la norma <ph name="PROXY_SETTINGS_POLICY_NAME" /> non è stata specificata.

          Se scegli di non utilizzare mai un server proxy e ti connetti sempre direttamente, tutte le altre opzioni verranno ignorate.

          Se scegli di utilizzare le impostazioni proxy di sistema o di rilevare automaticamente il server proxy, tutte le altre opzioni verranno ignorate.

          Se scegli le impostazioni proxy manuali, puoi specificare ulteriori opzioni in "Indirizzo o URL del server proxy", "URL di un file proxy .pac" e "Elenco separato da virgole delle regole di bypass proxy". Per le app ARC è disponibile solo il server proxy HTTP con la priorità più alta.

          Per esempi dettagliati, visita:
          <ph name="PROXY_HELP_URL" />.

          Se attivi questa impostazione, <ph name="PRODUCT_NAME" /> ignora tutte le opzioni relative al proxy specificate dalla riga di comando.

          Se questa norma non è impostata, gli utenti potranno scegliere le impostazioni proxy autonomamente.</translation>
<translation id="5182055907976889880">Configura Google Drive in <ph name="PRODUCT_OS_NAME" />.</translation>
<translation id="5183383917553127163">Consente di specificare le estensioni da non includere nella blacklist. Un valore di * riportato nella blacklist indica che tutte le estensioni sono state inserite nella blacklist e che gli utenti possono installare solo quelle elencate nella whitelist. Per impostazione predefinita, tutte le estensioni si trovano nella whitelist, ma se in base alla norma applicata tutte le estensioni sono state inserite nella blacklist, la whitelist può essere utilizzata per annullare tale norma.</translation>
<translation id="519247340330463721">Configura le norme relative alla Navigazione sicura.</translation>
<translation id="5192837635164433517">Consente di attivare l'utilizzo di pagine di errore alternative integrate in <ph name="PRODUCT_NAME" /> (come "pagina non trovata") e di impedire agli utenti di modificare questa impostazione. Se attivi questa impostazione, vengono utilizzate le pagine di errore alternative. Se la disattivi, le pagine di errore alternative non vengono mai utilizzate. Se l'impostazione viene attivata o disattivata, gli utenti non potranno modificarla o sostituirla in <ph name="PRODUCT_NAME" />. Se questa norma non viene impostata, l'impostazione verrà attivata ma gli utenti potranno modificarla.</translation>
<translation id="5196805177499964601">Blocca la modalità sviluppatore.

      Se questa norma viene impostata su True, <ph name="PRODUCT_OS_NAME" /> impedirà l'avvio del dispositivo in modalità sviluppatore. Il sistema non verrà avviato e verrà visualizzata una schermata di errore quando viene attivata la modalità sviluppatore.

      Se questa norma non è impostata o è impostata su False, la modalità sviluppatore continuerà a essere disponibile per il dispositivo.</translation>
<translation id="520403427390290017">La funzionalità cicli di vita delle schede recupera la CPU e la memoria associata alle schede in esecuzione che non sono state utilizzate per un lungo periodo di tempo, inizialmente limitandole, quindi bloccandole e infine eliminandole.

      Se la norma viene impostata su false, i cicli di vita delle schede verranno disattivati e tutte le schede verranno eseguite normalmente.

      Se la norma è impostata su true o non viene impostata in alcun modo, i cicli di vita delle schede verranno attivati.</translation>
<translation id="5207823059027350538">Consente di configurare l'URL predefinito della pagina Nuova scheda e impedisce agli utenti di modificarlo.

          La pagina Nuova scheda è la pagina che si apre quando vengono create nuove schede, inclusa quella aperta in una nuova finestra.

          Questa norma non stabilisce quali pagine si aprano all'avvio. Tali pagine dipendono infatti dalle norme <ph name="RESTORE_ON_STARTUP_POLICY_NAME" />. Questa norma influisce tuttavia sulla home page se impostata per l'apertura della pagina Nuova scheda, oltre che come pagina iniziale.

          Se la norma non è impostata o risulta vuota, viene utilizzata la pagina predefinita Nuova scheda.

          Questa norma è disponibile esclusivamente per le istanze di Windows che fanno parte di un dominio <ph name="MS_AD_NAME" /> così come per le istanze di Windows 10 Pro o Enterprise registrate per la gestione dei dispositivi.</translation>
<translation id="5208240613060747912">Consente di impostare un elenco di pattern URL che specificano i siti non autorizzati a visualizzare notifiche. Se questa norma non viene impostata, per tutti i siti verrà utilizzato il valore predefinito globale della norma "DefaultNotificationsSetting", se è impostata, oppure verrà utilizzata la configurazione personale dell'utente.</translation>
<translation id="5213038356678567351">Siti web che non devono mai attivare il cambio di browser.</translation>
<translation id="5219844027738217407">Nell'ambito delle app Android, la norma influisce solo sul microfono. Se la norma viene impostata su true, il microfono viene disattivato per tutte le app Android, senza alcuna eccezione.</translation>
<translation id="5228316810085661003">Il ritardo prima dell'accesso automatico all'account locale del dispositivo.

      Se non è impostata, la norma |DeviceLocalAccountAutoLoginId| non ha effetto. In caso contrario:

      Se è impostata, questa norma determina quanto tempo deve trascorrere senza attività dell'utente prima che venga eseguito l'accesso automatico all'account locale del dispositivo specificato dalla norma |DeviceLocalAccountAutoLoginId|.

      Se questa norma non è impostata, verrà utilizzato un timeout di 0 millisecondi.

      Questa norma è specificata in millisecondi.</translation>
<translation id="523505283826916779">Impostazioni di accessibilità</translation>
<translation id="5236882091572996759">Se questa norma è impostata su True o non viene impostata, l'utente non verrà considerato inattivo durante la riproduzione dell'audio. In questo modo non viene raggiunto il timeout di inattività e non viene compiuta l'azione per l'inattività. Tuttavia, lo schermo viene oscurato, disattivato e bloccato dopo i timeout configurati, a prescindere dall'attività audio.

          Se questa norma viene impostata su False, l'attività audio non impedisce di considerare inattivo l'utente.</translation>
<translation id="5246700266104954355">Questa norma è obsoleta. Usa <ph name="DEFAULT_PLUGINS_SETTING_POLICY_NAME" /> per controllare la disponibilità del plug-in Flash e <ph name="ALWAYS_OPEN_PDF_EXTERNALLY_POLICY_NAME" /> per controllare se si deve utilizzare il visualizzatore PDF integrato per aprire i file PDF.

      Specifica un elenco di plug-in attivati in <ph name="PRODUCT_NAME" /> e impedisce agli utenti di modificare questa impostazione.

      È possibile utilizzare i caratteri jolly "*" e "?" in corrispondenza delle sequenze di caratteri arbitrari. "*" corrisponde a un numero arbitrario di caratteri, mentre "?" specifica un singolo carattere facoltativo, ossia corrisponde a zero caratteri o a uno solo. Il carattere di escape è "\", quindi per rappresentare i caratteri "*", "?" o "\" effettivi puoi farli precedere da un "\".

      L'elenco specificato di plug-in è sempre utilizzato in <ph name="PRODUCT_NAME" /> se sono installati. I plug-in sono contrassegnati come attivati in "about:plugins" e gli utenti non possono disattivarli.

      Tieni presente che questa norma esegue l'override sia di DisabledPlugins sia di DisabledPluginsExceptions.

      Se la norma non viene impostata, l'utente può disattivare qualsiasi plug-in installato sul sistema.</translation>
<translation id="5247006254130721952">Blocca download pericolosi</translation>
<translation id="5248863213023520115">Permette di impostare i tipi di crittografia consentiti quando vengono richiesti ticket Kerberos a un server <ph name="MS_AD_NAME" />.

      Se la norma viene impostata su "Tutto", sono consentiti sia i tipi di crittografia AES "aes256-cts-hmac-sha1-96" e "aes128-cts-hmac-sha1-96" sia il tipo di crittografia RC4 "rc4-hmac". Se il server supporta entrambi i tipi, viene usata preferibilmente la crittografia AES. Tieni presente che la crittografia RC4 è considerata debole e, se possibile, il server dovrebbe essere riconfigurato per supportare la crittografia AES.

      Se la norma viene impostata su "Avanzata" o se non viene impostata, sono consentiti soltanto i tipi di crittografia AES.

      Se la norma viene impostata su "Precedente", è consentito soltanto il tipo di crittografia RC4. Questa opzione non è sicura e dovrebbe essere necessaria soltanto in casi molto specifici.

      Visita anche la pagina https://wiki.samba.org/index.php/Samba_4.6_Features_added/changed#Kerberos_client_encryption_types.</translation>
<translation id="5255162913209987122">Può essere consigliata</translation>
<translation id="527237119693897329">Consente di specificare gli host di messaggi nativi che non devono essere caricati.

Il valore della lista nera "*" indica che tutti gli host di messaggi nativi non sono autorizzati, a meno che vengano elencati espressamente nella whitelist.

Se la norma non viene impostata, <ph name="PRODUCT_NAME" /> caricherà tutti gli host di messaggi nativi installati.</translation>
<translation id="5272684451155669299">Se questa opzione viene impostata su true, l'utente può usare l'hardware su dispositivi Chrome per attestare da remoto la propria identità all'autorità di certificazione della privacy utilizzando la funzione <ph name="CHALLENGE_USER_KEY_FUNCTION" /> dell'<ph name="ENTERPRISE_PLATFORM_KEYS_API" />.

          Se viene impostata su false o non viene impostata, le chiamate all'API non vanno a buon fine e viene generato un codice di errore.</translation>
<translation id="5277806246014825877">Questa norma consente all'utente di eseguire Crostini.

      Se la norma viene impostata su False, Crostini non è abilitato per l'utente.
      Se la norma viene impostata su True o non viene impostata, Crostini è abilitato per l'utente, a patto che anche le altre impostazioni lo permettano.
      Le tre norme, VirtualMachinesAllowed, CrostiniAllowed e DeviceUnaffiliatedCrostiniAllowed devono essere impostate su True affinché Crostini possa essere eseguito.
      Quando l'impostazione di questa norma viene modificata in False, la norma viene applicata all'avvio di nuovi contenitori Crostini, ma non determina l'arresto dei contenitori già in esecuzione.</translation>
<translation id="5283457834853986457">Disattiva la ricerca dei plug-in (ritirata)</translation>
<translation id="5288772341821359899">Se la norma viene impostata, l'intervallo di porte UDP utilizzato da WebRTC viene limitato all'intervallo di porte specificato (endpoint inclusi).

      Se la norma non viene impostata oppure è impostata sulla stringa vuota o su un intervallo di porte non valido, WebRTC è autorizzato a utilizzare qualsiasi porta UDP locale disponibile.</translation>
<translation id="5290940294294002042">Specifica un elenco di plug-in che l'utente può attivare o disattivare</translation>
<translation id="5306186200045823863">Considera attendibile l'infrastruttura PKI precedente di Symantec Corporation</translation>
<translation id="5307432759655324440">Disponibilità della modalità di navigazione in incognito</translation>
<translation id="5318185076587284965">Attiva l'utilizzo dei server relay per l'host di accesso remoto</translation>
<translation id="5323128137188992869">Consente di trasmettere contenuti al dispositivo usando <ph name="PRODUCT_NAME" />.

          Se questa norma viene impostata su False, gli utenti non potranno trasmettere contenuti al proprio dispositivo. Se questa norma viene impostata su True, gli utenti potranno trasmettere contenuti. Se questa norma non viene impostata, gli utenti non potranno trasmettere contenuti a dispositivi Chrome OS registrati, ma potranno trasmetterli a dispositivi non registrati.</translation>
<translation id="5329007337159326804">Attenzione: la norma Versione TLS massima verrà interamente rimossa da <ph name="PRODUCT_NAME" /> con la versione 75 (orientativamente giugno 2019).

      Se questa norma non viene configurata, <ph name="PRODUCT_NAME" /> utilizza la versione massima predefinita.

      . In caso contrario, potrebbe essere impostato uno dei seguenti valori: "tls1.2" o "tls1.3". Se questa norma viene impostata, <ph name="PRODUCT_NAME" /> non utilizzerà versioni SSL/TLS successive a quella specificata. I valori non riconosciuti verranno ignorati.</translation>
<translation id="5330684698007383292">Consenti a <ph name="PRODUCT_FRAME_NAME" /> di gestire i seguenti tipi di contenuti</translation>
<translation id="5331746669335642668">La norma relativa alla cloud <ph name="PRODUCT_NAME" /> esegue l'override della norma relativa alla piattaforma.</translation>
<translation id="5365476955714838841">Parametri della riga di comando per il browser alternativo.</translation>
<translation id="5365946944967967336">Mostra il pulsante Pagina iniziale nella barra degli strumenti</translation>
<translation id="5366745336748853475">Ti consente di specificare un elenco di pattern URL relativi ai siti che richiedono certificati per cui viene selezionato automaticamente un certificato client nella schermata di accesso all'interno del frame che ospita il flusso SAML. Un esempio di utilizzo è la configurazione di un certificato a livello di dispositivo da presentare all'IdP SAML.

      Il valore deve essere un array di dizionari JSON in stringa. Ogni dizionario deve avere questa forma: { "pattern": "$URL_PATTERN", "filter" : $FILTER }, dove $URL_PATTERN è un pattern di impostazione dei contenuti. $FILTER restringe i certificati client selezionabili automaticamente dal browser. Indipendentemente dal filtro, saranno selezionati solo certificati che soddisfano la richiesta di certificato del server. Se $FILTER è nel formato { "ISSUER": { "CN": "$ISSUER_CN" } }, vengono inoltre selezionati solo i certificati client emessi da certificati con valore CommonName pari a $ISSUER_CN. Se $FILTER è il dizionario vuoto {}, la selezione dei certificati client non viene limitata ulteriormente.

      Se questa norma non viene impostata, la selezione automatica non avviene per nessun sito.</translation>
<translation id="5366977351895725771">Se questa norma è impostata su false, la creazione di utenti supervisionati da parte di questo utente sarà disabilitata. Gli eventuali utenti supervisionati esistenti saranno comunque disponibili.

          Se questa norma è impostata su true o non è configurata, questo utente può creare e gestire utenti supervisionati.</translation>
<translation id="5369937289900051171">Solo stampa a colori</translation>
<translation id="5370279767682621504">Attiva il supporto HTTP/0.9 sulle porte non predefinite</translation>
<translation id="5378985487213287085">Permette di stabilire se consentire o meno la visualizzazione di notifiche desktop nei siti web. La visualizzazione di notifiche desktop può essere consentita o negata per impostazione predefinita oppure l'utente può ricevere una richiesta ogni volta che un sito web desidera visualizzare le notifiche desktop. Se questa norma non viene impostata, verrà utilizzato il valore "AskNotifications", che potrà essere modificato dagli utenti.</translation>
<translation id="538108065117008131">Consenti a <ph name="PRODUCT_FRAME_NAME" /> di gestire i seguenti tipi di contenuto.</translation>
<translation id="5391388690191341203">Account locale del dispositivo per l'accesso automatico</translation>
<translation id="5392172595902933844">Le informazioni sullo stato di Android vengono rimandate al server.

      Se la norma viene impostata su false o non viene del tutto impostata, le informazioni sullo stato non vengono segnalate.
      Se viene impostata su true, le informazioni sullo stato vengono segnalate.

      Questa norma viene applicata soltanto se le app Android sono attive.</translation>
<translation id="5395271912574071439">Consente di attivare la separazione degli host di accesso remoto durante una connessione.

Se questa impostazione viene attivata, i dispositivi di input e output fisici degli host verranno disattivati durante una connessione remota.

Se questa impostazione viene disattivata o non viene impostata, sia gli utenti locali che remoti potranno interagire con l'host quando viene condiviso.</translation>
<translation id="5396049152026347991">Consente all'utente di gestire le connessioni VPN.

      Se questa norma viene impostata su false, le interfacce di <ph name="PRODUCT_NAME" /> che consentono all'utente di disconnettere o modificare le connessioni VPN vengono tutte disattivate.

      Se questa norma viene impostata su true o non viene impostata, l'utente può disconnettere o modificare le connessioni VPN come di consueto.

      Se la connessione VPN viene creata tramite un'app VPN, l'interfaccia all'interno dell'app non è interessata da questa norma. L'utente potrebbe quindi essere ancora in grado di utilizzare l'app per modificare la connessione VPN.

      Questa norma deve essere utilizzata assieme alla funzionalità "VPN sempre attiva", che permette all'amministratore di decidere se creare una connessione VPN all'avvio.</translation>
<translation id="5405289061476885481">Consente di configurare i layout da tastiera consentiti nella schermata di accesso di <ph name="PRODUCT_OS_NAME" />.

      Se per questa norma viene impostato un elenco di identificatori di metodi di immissione, i metodi specificati saranno disponibili nella schermata di accesso. Verrà preselezionato il primo metodo di immissione specificato. Anche se il pod dell'utente è basato sulla schermata di accesso, oltre ai metodi di immissione specificati in questa norma sarà disponibile anche l'ultimo metodo usato dall'utente. Se questa norma non viene impostata, i metodi di immissione per la schermata di accesso saranno recuperati in base alla lingua in cui è visualizzata la schermata di accesso. I valori che non corrispondono a identificatori di metodi di immissione validi verranno ignorati.</translation>
<translation id="5412057811596122582">Se la norma è attivata o non è configurata (impostazione predefinita), all'utente verrà richiesto
      l'accesso all'acquisizione audio ad eccezione degli URL configurati
      nell'elenco AudioCaptureAllowedUrls, per i quali verrà concesso l'accesso senza richiesta.

      Quando questa norma viene disattivata, all'utente non verrà mai richiesto nulla e l'accesso all'acquisizione
      audio sarà disponibile solo per gli URL configurati in AudioCaptureAllowedUrls.

      Questa norma si applica a tutti i tipi di ingressi audio e non solo al microfono integrato.</translation>
<translation id="5422643441807528365">Codice licenza <ph name="PLUGIN_VM_NAME" /></translation>
<translation id="5423001109873148185">Se è attiva, questa norma impone l'importazione dei motori di ricerca dal browser predefinito corrente. Se la norma è attiva incide anche sulla finestra di dialogo di importazione. Se non è attiva, il motore di ricerca predefinito non viene importato. Se non viene impostata, all'utente potrebbe essere chiesto se desidera effettuare l'importazione, oppure l'importazione potrebbe avvenire automaticamente.</translation>
<translation id="5423197884968724595">Nome della limitazione di Android WebView:</translation>
<translation id="5424147596523390018">Consenti tutte le modalità a colori</translation>
<translation id="5437733496511628148">L'attivazione di questa impostazione impedisce l'impostazione dei cookie da parte degli elementi delle pagine web non provenienti dal dominio riportato nella barra degli indirizzi del browser.

      La disattivazione di questa impostazione consente ai cookie di essere impostati da elementi delle pagine web non provenienti dal dominio riportato nella barra degli indirizzi del browser e impedisce agli utenti di modificare questa impostazione.

      Se questa norma non viene impostata, i cookie di terze parti verranno attivati, ma l'utente potrà modificarla.</translation>
<translation id="5442026853063570579">Questa norma consente di controllare anche l'accesso alle Opzioni sviluppatore di Android. Se la norma viene impostata su "DeveloperToolsDisallowed" (valore 2), gli utenti non potranno accedere alle Opzioni sviluppatore. Se la norma viene impostata su un altro valore o non viene impostata, gli utenti potranno accedere alle Opzioni sviluppatore toccando sette volte il numero di build nell'app Impostazioni di Android.</translation>
<translation id="544342220587994947">Consente di specificare un elenco di pattern URL che indicano i siti per cui <ph name="PRODUCT_NAME" /> deve selezionare automaticamente un certificato client, se i siti ne richiedono uno.

          Il valore deve essere un array di dizionari JSON sotto forma di stringa. Ogni dizionario deve avere questo formato: { "pattern": "$URL_PATTERN", "filter" : $FILTER }, dove $URL_PATTERN è un pattern di impostazione dei contenuti. $FILTER restringe i certificati client da cui il browser effettua automaticamente la selezione. Indipendentemente dal filtro, saranno selezionati solo certificati che soddisfano la richiesta di certificato del server. Ad esempio, se $FILTER è nel formato { "ISSUER": { "CN": "$ISSUER_CN" } }, vengono inoltre selezionati solo i certificati client emessi da certificati con valore CommonName uguale a $ISSUER_CN. Se $FILTER contiene una sezione "ISSUER" e una sezione "SUBJECT", per poter essere selezionato il certificato client deve soddisfare entrambe le condizioni. Se $FILTER specifica un'organizzazione ("O"), per poter essere selezionato un certificato deve avere almeno un'organizzazione corrispondente al valore specificato. Se $FILTER specifica un'unità organizzativa ("UO"), per poter essere selezionato un certificato deve avere almeno un'unità organizzativa corrispondente al valore specificato. Se $FILTER è il dizionario vuoto {}, la selezione dei certificati client non viene limitata ulteriormente.

          Se questa norma non viene impostata, la selezione automatica non avviene per nessun sito.</translation>
<translation id="5447306928176905178">Attiva le informazioni relative ai rapporti sulla memoria (dimensioni heap JS) per la pagina (obsoleto)</translation>
<translation id="5457065417344056871">Attiva modalità ospite nel browser</translation>
<translation id="5457924070961220141">Consente di configurare il renderer HTML predefinito se <ph name="PRODUCT_FRAME_NAME" /> è installato. Se questa norma non viene impostata, per impostazione predefinita il rendering viene eseguito dal browser host; tuttavia, in alternativa, puoi sostituire tale impostazione e consentire che l'esecuzione del rendering delle pagine HTML venga eseguita, per impostazione predefinita, da <ph name="PRODUCT_FRAME_NAME" />.</translation>
<translation id="5458584148602890023">Attiva la variazione dei picchi energetici</translation>
<translation id="5464816904705580310">Configurazione delle impostazioni per gli utenti gestiti.</translation>
<translation id="546726650689747237">Ritardo oscuramento schermo in caso di utilizzo di CA</translation>
<translation id="5469143988693423708">L'utente è abilitato a eseguire Crostini</translation>
<translation id="5469825884154817306">Blocca immagini su questi siti</translation>
<translation id="5472668698895343595">Questa norma consente di stabilire l'elenco di siti web da aprire in un browser alternativo.

      Tieni presente che puoi aggiungere elementi all'elenco anche tramite le norme <ph name="USE_IE_SITELIST_POLICY_NAME" /> e <ph name="EXTERNAL_SITELIST_URL_POLICY_NAME" />.

      Se questa norma non viene impostata, nessun sito web viene aggiunto all'elenco.

      Se viene impostata, ogni elemento è considerato come una regola per aprire qualcosa in un browser alternativo. <ph name="PRODUCT_NAME" /> utilizza queste regole quando deve scegliere se aprire un URL in un browser alternativo.

      Quando il componente aggiuntivo Internet Explorer è presente e attivato, Internet Explorer torna a <ph name="PRODUCT_NAME" /> se non c'è corrispondenza tra le regole.

      Se le regole si contraddicono a vicenda, <ph name="PRODUCT_NAME" /> usa quella più specifica.</translation>
<translation id="5475361623548884387">Attiva la stampa</translation>
<translation id="547601067149622666">Non consentire gli annunci su siti con annunci invasivi</translation>
<translation id="5483065054530244863">Consenti i certificati SHA-1 firmati emessi dai trust anchor locali</translation>
<translation id="5483777239978559943">Questa norma è obsoleta. Usa <ph name="DEFAULT_PLUGINS_SETTING_POLICY_NAME" /> per controllare la disponibilità del plug-in Flash e <ph name="ALWAYS_OPEN_PDF_EXTERNALLY_POLICY_NAME" /> per controllare se si deve utilizzare il visualizzatore PDF integrato per aprire i file PDF.

      Specifica un elenco di plug-in che l'utente può attivare o disattivare in <ph name="PRODUCT_NAME" />.

      È possibile utilizzare i caratteri jolly "*" e "?" in corrispondenza delle sequenze di caratteri arbitrari. "*" corrisponde a un numero arbitrario di caratteri, mentre "?" specifica un singolo carattere facoltativo, ossia corrisponde a zero caratteri o a uno solo. Il carattere di escape è "\", quindi per rappresentare i caratteri "*", "?" o "\" effettivi puoi farli precedere da un "\".

      Se attivi questa impostazione, è possibile utilizzare l'elenco specificato di plug-in in <ph name="PRODUCT_NAME" />. Gli utenti potranno attivare o disattivare i plug-in in "about:plugins" anche se il plug-in corrisponde a un pattern in DisabledPlugins. Gli utenti possono anche attivare e disattivare i plug-in che non corrispondono a nessun pattern in DisabledPlugins, DisabledPluginsExceptions ed EnabledPlugins.

      Questa norma è pensata per consentire un inserimento rigoroso dei plug-in nella lista nera, dove l'elenco "DisabledPlugins" contiene voci con caratteri jolly, ad esempio per disattivare tutti i plug-in "*" o per disattivare tutti i plug-in Java "*Java*", ma è pensata anche per consentire all'amministratore di attivare qualche versione particolare come "IcedTea Java 2.3". È possibile specificare queste versioni specifiche in questa norma.

      Tieni presente che devono essere esclusi sia il nome del plug-in che il nome del gruppo del plug-in. Ciascun gruppo di plug-in viene mostrato in una sezione separata di about:plugins; ciascuna sezione può contenere uno o più plug-in. Ad esempio, il plug-in "Shockwave Flash" appartiene al gruppo "Adobe Flash Player" ed entrambi i nomi devono avere una corrispondenza nell'elenco di eccezioni se il plug-in in questione deve essere escluso dalla lista nera.

      Se questa norma non viene impostata, qualsiasi plug-in corrispondente ai pattern in "DisabledPlugins" verrà disattivato e bloccato e l'utente non potrà attivarlo.</translation>
<translation id="5499375345075963939">Questa norma è attiva soltanto in modalità retail.

      Quando il valore di questa norma è impostato e non è 0, l'utente Demo correntemente connesso verrà disconnesso automaticamente dopo che sarà trascorso il tempo di inattività della durata specificata.

      Il valore della norma deve essere specificato in millisecondi.</translation>
<translation id="5511702823008968136">Attiva barra dei Preferiti</translation>
<translation id="5512418063782665071">URL pagina iniziale</translation>
<translation id="551639594034811656">Questa norma definisce un elenco di percentuali che definiranno la frazione dei dispositivi di <ph name="PRODUCT_OS_NAME" /> nell'UO da aggiornare ogni giorno a partire dal giorno in cui l'aggiornamento viene rilevato la prima volta. L'ora del rilevamento è successiva all'ora in cui l'aggiornamento viene pubblicato, perché potrebbe passare del tempo tra la pubblicazione dell'aggiornamento e il momento in cui il dispositivo controlla la disponibilità di aggiornamenti.

      Ogni coppia (giorno, percentuale) contiene la percentuale dei gruppi da aggiornare entro il numero di giorni stabilito a partire dal giorno in cui l'aggiornamento viene rilevato. Ad esempio, se abbiamo le coppie [(4, 40), (10, 70), (15, 100)], allora il 40% dei gruppi deve essere aggiornato entro 4 giorni dal rilevamento dell'aggiornamento; il 70% deve essere aggiornato dopo 10 giorni e così via.

      Se viene definito un valore per questa norma, gli aggiornamenti ignoreranno la norma <ph name="DEVICE_UPDATE_SCATTER_FACTOR_POLICY_NAME" /> e seguiranno invece questa norma.

      Se quest'elenco è vuoto, non verrà eseguita alcuna gestione temporanea e gli aggiornamenti verranno applicati in base alle altre norme del dispositivo.

      Questa norma non viene applicata agli switch del canale.</translation>
<translation id="5526701598901867718">Tutto (non sicuro)</translation>
<translation id="5529037166721644841">Consente di specificare in millisecondi il periodo di tempo per cui vengono richieste informazioni sui criteri relativi al dispositivo al servizio di gestione del dispositivo.

      Se questa norma viene impostata, il valore predefinito di tre ore viene ignorato. L'intervallo dei valori validi per questa norma è compreso tra 1800000 (30 minuti) e 86400000 (un giorno). I valori non compresi in questo intervallo verranno bloccati al relativo limite.

      Se questa norma non viene impostata, <ph name="PRODUCT_OS_NAME" /> utilizzerà il valore predefinito di tre ore.

      Se la piattaforma supporta le notifiche relative ai criteri, il ritardo dell'aggiornamento verrà impostato su 24 ore (vengono ignorati tutti i valori predefiniti e il valore di questa norma) perché è previsto che le notifiche relative ai criteri forzino l'aggiornamento automatico quando cambiano i criteri, rendendo superflui aggiornamenti più frequenti.</translation>
<translation id="5530347722229944744">Blocca download potenzialmente pericolosi</translation>
<translation id="5535973522252703021">Whitelist server di delega Kerberos</translation>
<translation id="555077880566103058">Consenti l'esecuzione automatica del plug-in <ph name="FLASH_PLUGIN_NAME" /> in tutti i siti</translation>
<translation id="5559079916187891399">Questa norma non influisce sulle app Android.</translation>
<translation id="5560039246134246593">Aggiungi un parametro al recupero del numero di inizializzazione delle varianti in <ph name="PRODUCT_NAME" />.

      Se specificata, questa norma aggiunge un parametro di query chiamato "restrict" all'URL utilizzato per recuperare il numero di inizializzazione delle varianti. Il valore del parametro sarà il valore specificato in questa norma.

      Se non è specificata, questa norma non modifica l'URL del numero di inizializzazione delle varianti.</translation>
<translation id="5561811616825571914">Seleziona automaticamente i certificati client per questi siti nella schermata di accesso</translation>
<translation id="5566210228171064229">Consenti la stampa con e senza PIN</translation>
<translation id="556865034069957245">Questa norma consente di stabilire la disponibilità della modalità a schermo intero in cui ogni UI di <ph name="PRODUCT_NAME" /> è nascosta e sono visibili solo i contenuti web.

      Se questa norma viene impostata su true o non è configurata, l'utente, le applicazioni e le estensioni con le autorizzazioni adeguate possono attivare la modalità a schermo intero.

      Se questa norma viene impostata su false, né l'utente né le app o le estensioni possono attivare la modalità a schermo intero.

      Su tutte le piattaforme ad eccezione di <ph name="PRODUCT_OS_NAME" />, la modalità kiosk non è disponibile quando la modalità a schermo intero è disattivata.</translation>
<translation id="556941986578702361">Controlla la visualizzazione automatica dello shelf in <ph name="PRODUCT_OS_NAME" />.

      Se il criterio è impostato su "AlwaysAutoHideShelf", lo scaffale non sarà mai visualizzato.

      Se il criterio è impostato su "NeverAutoHideShelf", lo scaffale sarà sempre visualizzato.

      Se imposti questo criterio, gli utenti non potranno modificarlo o ignorarlo.

      Se il criterio non viene impostato, gli utenti possono scegliere la visualizzazione dello shelf.</translation>
<translation id="557360560705413259">Quando questa impostazione è attiva, <ph name="PRODUCT_NAME" /> usa il nome comune di un certificato server per associare un nome host se il certificato è privo di un'estensione subjectAlternativeName, purché venga convalidato correttamente e collegato a un certificato CA installato in una posizione locale.

      Tieni presente che è sconsigliato farlo, perché potrebbe essere consentita l'elusione dell'estensione nameConstraints, che limita i nomi host per cui può essere autorizzato un determinato certificato.

      Se questa norma non viene impostata, o viene impostata su false, i certificati server privi di estensione subjectAlternativeName e contenenti un nome DNS o un indirizzo IP non verranno considerati attendibili.</translation>
<translation id="5581292529942108810">Consente di configurare le norme relative all'estensione Chrome Reporting Extension.

      Questa norma viene applicata soltanto se viene attivata l'estensione <ph name="CHROME_REPORTING_EXTENSION_NAME" /> e il computer viene registrato con la norma <ph name="MACHINE_LEVEL_USER_CLOUD_POLICY_ENROLLMENT_TOKEN_POLICY_NAME" />.</translation>
<translation id="5583806683960333345">Se questa impostazione viene attivata, gli utenti potranno utilizzare il tethering istantaneo, che consente al loro telefono Google di condividere i dati mobili con il dispositivo.

      Se questa impostazione viene disattivata, gli utenti non potranno utilizzare il tethering istantaneo.

      Se questa norma non è impostata, per impostazione predefinita la funzione non è consentita per gli utenti gestiti dall'azienda ed è consentita per gli utenti non gestiti.</translation>
<translation id="5584132346604748282">Controlla i servizi di geolocalizzazione di Google per Android</translation>
<translation id="5586942249556966598">Non fare niente</translation>
<translation id="5590494712401018042">Consente di specificare la percentuale di regolazione del ritardo di oscuramento dello schermo quando il dispositivo è in modalità di presentazione.

          Se questa norma viene impostata, consente di specificare la percentuale di regolazione del ritardo di oscuramento dello schermo quando il dispositivo è in modalità di presentazione. Quando il ritardo di oscuramento dello schermo viene regolato, i ritardi di spegnimento, blocco e inattività dello schermo vengono regolati per mantenere gli stessi distacchi dal ritardo di oscuramento dello schermo configurato in origine.

          Se questa norma non viene impostata, viene usato un fattore di regolazione predefinito.

          Questa norma viene applicata soltanto se la norma <ph name="POWER_SMART_DIM_ENABLED_POLICY_NAME" /> è disattivata. In caso contrario, questa norma viene ignorata perché il ritardo di oscuramento dello schermo viene stabilito da un modello di machine learning.

          Il fattore di regolazione minimo deve essere 100%. Non sono consentiti valori che renderebbero il ritardo di oscuramento dello schermo in modalità di presentazione inferiore al ritardo di oscuramento dello schermo normale.</translation>
<translation id="5592242031005200087">
      Se la norma è attivata, ciascuna delle origini denominate all'interno di un elenco separato da virgole verrà eseguita nel proprio processo. Ciò isolerà anche le origini indicate dai sottodomini, ad esempio specificando https://example.com/ si isolerà anche https://foo.example.com/, perché fa parte del sito https://example.com/.
      Se la norma è disattivata, non avverrà alcun isolamento esplicito dei siti e le prove sul campo di IsolateOriginsAndroid e SitePerProcessAndroid saranno disattivate. Gli utenti potranno ancora attivare IsolateOrigins manualmente, tramite flag da riga di comando.
      Se la norma non è configurata, l'utente potrà modificare questa impostazione.

      NOTA: su Android, l'isolamento dei siti è sperimentale. L'assistenza verrà migliorata, ma attualmente potrebbe causare problemi di prestazioni.

      NOTA: questa norma viene applicata solo a Chrome su dispositivi Android con più di 1 GB di RAM. Per applicare la norma su piattaforme non Android, utilizza IsolateOrigins.
      </translation>
<translation id="5599461642204007579">Impostazioni di gestione di <ph name="MS_AD_NAME" /></translation>
<translation id="5610104657949692379">Quando questa norma viene impostata, consente di specificare l'azione compiuta da <ph name="PRODUCT_OS_NAME" /> quando l'utente rimane inattivo per il periodo di tempo indicato dal ritardo di inattività, che può essere configurato separatamente.

          Quando la norma non è impostata, viene eseguita l'azione predefinita, ossia la sospensione.

          Se l'azione è la sospensione, è possibile configurare separatamente il blocco o meno dello schermo prima della sospensione di <ph name="PRODUCT_OS_NAME" />.</translation>
<translation id="5618398258385745432">L'impostazione associata veniva utilizzata prima dell'introduzione della riautenticazione per la visualizzazione delle password. Dopodiché l'impostazione e quindi la norma non hanno più inciso sul comportamento di Chrome. Ora Chrome funziona come se la norma fosse impostata in modo da disattivare la visualizzazione delle password in testo non criptato nella pagina delle impostazioni di Gestione password. Ciò significa che la pagina delle impostazioni contiene soltanto un segnaposto e che Chrome mostra la password soltanto se l'utente fa clic su "Mostra" (ed esegue la riautenticazione, se possibile). Di seguito è riportata la descrizione originale della norma.

          Consente di stabilire se l'utente può visualizzare le password in testo non criptato in Gestione password.

          Se disattivi questa impostazione, Gestione password impedisce la visualizzazione delle password memorizzate in testo non criptato nella finestra Gestione password.

          Se attivi questa norma o non la imposti, gli utenti potranno visualizzare le loro password in testo non criptato in Gestione password.</translation>
<translation id="5620392548325769024">Attiva la visualizzazione della pagina di benvenuto al primo avvio del browser successivo all'upgrade del sistema operativo</translation>
<translation id="5630352020869108293">Ripristina l'ultima sessione</translation>
<translation id="5643906875497889108">Controlla quali tipi di app/estensioni possono essere installati e limita l'accesso in fase di esecuzione.

          Questa impostazione autorizza i tipi consentiti di estensioni/app che possono essere installati in <ph name="PRODUCT_NAME" /> e gli host con cui possono interagire. Il valore è un elenco di stringhe, ognuna delle quali deve corrispondere a una delle seguenti: "extension", "theme", "user_script", "hosted_app", "legacy_packaged_app", "platform_app". Per ulteriori informazioni su questi tipi, consulta la documentazione sulle estensioni di <ph name="PRODUCT_NAME" />.

          Tieni presente che questo criterio riguarda anche le estensioni e le app con installazione forzata tramite ExtensionInstallForcelist.

          Se l'impostazione è configurata, le estensioni/app con un tipo che non è in elenco non verranno installate.

          Se l'impostazione non è configurata, non vengono imposte restrizioni sui tipi di estensioni/app accettabili.

          Nelle versioni precedenti alla 75, l'utilizzo di ID estensioni separati da virgola non è supportato e verrà ignorato. Il resto del criterio continuerà a essere applicato.</translation>
<translation id="5645779841392247734">Consenti i cookie in questi siti</translation>
<translation id="5689430183304951538">Dimensioni predefinite delle pagine di stampa</translation>
<translation id="5693469654327063861">Consenti migrazione dei dati</translation>
<translation id="5694594914843889579">Quando questa norma è impostata su true, la memoria esterna non sarà disponibile nei file che è possibile sfogliare.

      Questa norma riguarda tutti i tipi di supporti di memorizzazione. Ad esempio: unità flash USB, dischi rigidi esterni, schede di memoria SD e di altro tipo, memorie ottiche e così via. La memoria interna non è interessata, quindi i file salvati nella cartella Download rimangono accessibili. Anche Google Drive non è interessato da questa norma.

      Se questa impostazione è disattivata o non è configurata, gli utenti possono utilizzare tutti i tipi supportati di memorie esterne sul proprio dispositivo.</translation>
<translation id="5697306356229823047">Segnala utenti dispositivo</translation>
<translation id="5699487516670033016">Consente di specificare la durata in ore della cache. La cache viene utilizzata per velocizzare l'accesso. Contiene dati generali (nome del gruppo di lavoro e così via) riguardo alle aree di autenticazione delle affiliate, come le aree di autenticazione ritenute attendibili dall'area di autenticazione della macchina. Nessun dato specifico dell'utente o delle aree di autenticazione delle affiliate viene memorizzato nella cache. Se il dispositivo viene riavviato, la cache viene svuotata.

      Se la norma non viene impostata, i dati di autenticazione della cache possono essere riutilizzati per un periodo massimo di 73 ore.

      Se la norma viene impostata su 0, la memorizzazione nella cache dei dati di autenticazione viene disattivata. Ciò può rallentare significativamente l'accesso degli utenti affiliati, poiché i dati specifici dell'area di autenticazione devono essere recuperati a ogni accesso.

      Tieni presente che i dati relativi all'area di autenticazione vengono memorizzati nella cache anche per gli utenti temporanei. Per impedire che i dati di autenticazione degli utenti temporanei vengano tracciati è necessario disattivare la cache.</translation>
<translation id="570062449808736508">Se per questa norma viene impostata una stringa, WebView legge le limitazioni relative agli URL del fornitore di contenuti con il nome dell'autorità indicato.</translation>
<translation id="5701714006401683963">Se questa norma viene impostata su false, la sessione ospite gestita avrà il comportamento descritto all'indirizzo https://support.google.com/chrome/a/answer/3017014 ("Sessione pubblica" standard).

      Se questa norma viene impostata su true o non viene impostata, la sessione ospite gestita avrà il comportamento "Sessione gestita", a cui non vengono applicate molte delle limitazioni valide invece per le normali "Sessioni pubbliche".

      Se questa norma viene impostata, l'utente non potrà modificarla o eseguirne l'override.</translation>
<translation id="5708969689202733975">Configura le modalità di sblocco rapido consentite</translation>
<translation id="572155275267014074">Impostazioni di Android</translation>
<translation id="5722934961007828462">Se questa impostazione viene attivata, <ph name="PRODUCT_NAME" /> eseguirà sempre il controllo delle revoche per i certificati server che vengono convalidati e vengono firmati tramite certificati CA installati localmente.

      Se <ph name="PRODUCT_NAME" /> non riesce ad acquisire informazioni sullo stato delle revoche, tali certificati vengono considerati revocati ("hard-fail").

      Se questa norma non viene impostata o se viene impostata su false, <ph name="PRODUCT_NAME" /> utilizzerà le impostazioni di controllo delle revoche online esistenti.</translation>
<translation id="5728154254076636808">Consente la creazione di copie di roaming per i dati dei profili <ph name="PRODUCT_NAME" /></translation>
<translation id="5732972008943405952">Importa i dati della compilazione automatica dei moduli dal browser predefinito alla prima esecuzione</translation>
<translation id="5741810844420698449">Quando questa norma è impostata, specifica l'azione che <ph name="PRODUCT_OS_NAME" /> compie quando l'utente chiude il coperchio del dispositivo.

          Quando la norma non è impostata, viene eseguita l'azione predefinita, ossia la sospensione.

          Se l'azione è la sospensione, è possibile configurare separatamente il blocco o meno dello schermo prima della sospensione di <ph name="PRODUCT_OS_NAME" />.</translation>
<translation id="5765780083710877561">Descrizione:</translation>
<translation id="5770738360657678870">Canale Dev (potrebbe essere instabile)</translation>
<translation id="5774856474228476867">URL di ricerca del provider di ricerca predefinito</translation>
<translation id="5775235485119094648">Carica la batteria mentre si trova in un intervallo stabilito.</translation>
<translation id="5776485039795852974">Chiedi ogni volta che un sito desidera mostrare le notifiche desktop</translation>
<translation id="5781412041848781654">Consente di specificare la libreria GSSAPI da utilizzare per l'autenticazione HTTP. È possibile impostare semplicemente un nome di libreria oppure un percorso completo.

          Se non viene fornita alcuna impostazione, <ph name="PRODUCT_NAME" /> dovrà ricorrere a un nome di libreria predefinito.</translation>
<translation id="5781806558783210276">Consente di specificare il periodo di tempo senza input dell'utente trascorso il quale viene compiuta l'azione stabilita per l'inattività quando viene utilizzata la batteria.

Se questa norma viene impostata, consente di specificare il periodo di tempo per cui l'utente deve rimanere inattivo prima che <ph name="PRODUCT_OS_NAME" /> compia l'azione di inattività, che può essere configurata separatamente.

Se questa norma non viene impostata, viene utilizzato un periodo di tempo predefinito.

Il valore della norma deve essere specificato in millisecondi.</translation>
<translation id="5783009211970309878">Stampa intestazioni e piè di pagina</translation>
<translation id="5809210507920527553">Consente di gestire le impostazioni relative al container Linux (Crostini).</translation>
<translation id="5809728392451418079">Imposta il nome visualizzato per gli account del dispositivo</translation>
<translation id="5814301096961727113">Impostazione stato predefinito della lettura vocale nella schermata di accesso</translation>
<translation id="5815129011704381141">Riavvia automaticamente dopo l'aggiornamento</translation>
<translation id="5815353477778354428">Consente di configurare la directory che <ph name="PRODUCT_FRAME_NAME" /> utilizza per memorizzare i dati dell'utente.

      Se la norma viene impostata, <ph name="PRODUCT_FRAME_NAME" /> utilizza la directory fornita.

      Visita il sito https://www.chromium.org/administrators/policy-list-3/user-data-directory-variables per consultare un elenco di variabili utilizzabili.

      Se la norma non viene impostata, viene utilizzata la directory del profilo predefinita.</translation>
<translation id="5826047473100157858">Consente di specificare se l'utente può aprire o meno le pagine in modalità di navigazione in incognito in <ph name="PRODUCT_NAME" />. Se viene selezionata l'opzione "Attiva" o la norma non viene impostata, le pagine possono essere aperte in modalità di navigazione in incognito. Se viene selezionata l'opzione "Non attiva", le pagine non possono essere aperte in modalità di navigazione in incognito. Se viene selezionata l'opzione "Forzata", le pagine possono essere aperte SOLTANTO in modalità di navigazione in incognito.</translation>
<translation id="582857022372205358">Attiva la stampa fronte/retro su lato corto</translation>
<translation id="583091600226586337">
      Se la norma viene attivata, all'utente verrà chiesto dove salvare ogni file prima del download.
      Se la norma viene disattivata, i download inizieranno subito e all'utente non verrà chiesto dove salvare i file.
      Se la norma non viene configurata, l'utente potrà modificare questa impostazione.
      </translation>
<translation id="5832274826894536455">Norme obsolete</translation>
<translation id="5835124959204887277">Consente di specificare URL e domini per i quali non verranno mostrati messaggi quando verranno richiesti certificati di attestazione dei token di sicurezza. Verrà inoltre inviato un segnale al token di sicurezza per indicare che potrebbe essere usata la singola attestazione. Senza questo segnale, gli utenti di Chrome 65 e versioni successive riceveranno un messaggio quando i siti richiederanno l'attestazione dei token di sicurezza.

      Gli URL (ad esempio https://example.com/some/path) corrisponderanno soltanto ad appID U2F. I domini (come example.com) corrisponderanno soltanto a ID RP webauthn. Di conseguenza, per includere entrambe le API U2F e webauthn per un determinato sito, devono essere elencati sia il dominio sia l'URL appID.</translation>
<translation id="5836064773277134605">Limita l'intervallo di porte UDP utilizzate dall'host di accesso remoto</translation>
<translation id="5861856285460256766">Configurazione codice di accesso genitori</translation>
<translation id="5862253018042179045">Consente di impostare lo stato predefinito della funzione di accessibilità di lettura vocale nella schermata di accesso.

Se questa norma viene impostata su true, la lettura vocale viene attivata quando viene visualizzata la schermata di accesso.

Se la norma viene impostata su false, la lettura vocale viene disattivata quando viene visualizzata la schermata di accesso.

Se la norma viene impostata, gli utenti possono ignorarla temporaneamente attivando o disattivando la lettura vocale. La scelta dell'utente non è però permanente e viene ripristinato il valore predefinito quando viene visualizzata di nuovo la schermata di accesso o quando l'utente rimane inattivo nella schermata di accesso per un minuto.

Se la norma non viene impostata, la lettura vocale viene disattivata alla prima visualizzazione della schermata di accesso. Gli utenti possono attivare o disattivare la lettura vocale in qualsiasi momento e il relativo stato nella schermata di accesso persiste per tutti gli utenti.</translation>
<translation id="5868414965372171132">Configurazione di rete a livello di utente</translation>
<translation id="5879014913445067283">Consente di controllare la funzione Condivisioni file di rete tramite il protocollo <ph name="NETBIOS_NAME" /></translation>
<translation id="5882345429632338713">Ritardo prima di avviare il browser alternativo (in millisecondi)</translation>
<translation id="5883015257301027298">Impostazione cookie predefiniti</translation>
<translation id="5887414688706570295">Consente di configurare il prefisso TalkGadget che verrà utilizzato dagli host di accesso remoto e impedisce agli utenti di modificarlo.

          Se specificato, questo prefisso viene anteposto al nome TalkGadget di base per creare un nome di dominio completo per TalkGadget. Il nome TalkGadget di base del dominio è "Talkgadget.google.com".

          Se questa impostazione è abilitata, gli host utilizzeranno il nome di dominio personalizzato per l'accesso a TalkGadget invece del nome del dominio predefinito.

          Se questa impostazione è disabilitata o non è impostata, verrà utilizzato il nome di dominio predefinito di TalkGadget ("chromoting-host.talkgadget.google.com") per tutti gli host.

          I client di accesso remoto non sono interessati da questa impostazione e utilizzeranno sempre "chromoting-client.talkgadget.google.com" per accedere a TalkGadget.</translation>
<translation id="5893553533827140852">Se questa impostazione è attivata, le richieste di autenticazione Gnubby verranno trasferite al proxy attraverso una connessione host remota.

          Se questa impostazione è disattivata o non configurata, le richieste di autenticazione Gnubby non verranno trasferite al proxy.</translation>
<translation id="5897913798715600338">Carica la batteria con la tecnologia di ricarica veloce.</translation>
<translation id="5898486742390981550">Quando più utenti eseguono l'accesso, solo l'utente principale può utilizzare le app Android.</translation>
<translation id="5900196529149231477">Questo criterio si applica alla schermata di accesso. Vedi anche il criterio <ph name="ISOLATE_ORIGINS_POLICY_NAME" /> che viene applicato alla sessione utente. È consigliabile impostare lo stesso valore per entrambi i criteri. Se i valori non corrispondono, può verificarsi un ritardo quando si accede a una sessione utente mentre viene applicato il valore specificato dai criteri relativi agli utenti.
      Se il criterio è attivato, ciascuna delle origini denominate all'interno di un elenco separato da virgole verrà eseguita nel proprio processo. Ciò isolerà anche le origini indicate dai sottodomini, ad esempio specificando https://example.com/ si isolerà anche https://foo.example.com/, perché fa parte del sito https://example.com/.
      Se il criterio è disattivato, le funzionalità IsolateOrigins e SitePerProcess saranno entrambe disattivate. Gli utenti potranno ancora attivare IsolateOrigins manualmente, tramite flag da riga di comando.
      Se il criterio non è configurato, per la schermata di accesso verranno usate le impostazioni di isolamento dei siti predefinite della piattaforma.</translation>
<translation id="5901427587865226597">Solo stampa fronte/retro</translation>
<translation id="5905473632148429217">Attiva controlli OCSP/CRL online</translation>
<translation id="5906199912611534122">Consente di attivare o disattivare la limitazione della larghezza di banda.
      La scelta è valida per tutti gli utenti e per tutte le interfacce sul dispositivo. Una volta impostata, la limitazione rimane valida fino alla modifica della norma per disattivarla.

      Se la norma viene impostata su false, non viene applicata alcuna limitazione.
      Se viene impostata su true, il sistema viene limitato per raggiungere le velocità di caricamento e download indicate (in kbit/s).</translation>
<translation id="591088232153082363">Ricarica adattiva della batteria sulla base dei pattern di utilizzo batteria.</translation>
<translation id="5921713479449475707">Permetti download di aggiornamento automatico tramite HTTP</translation>
<translation id="5921888683953999946">Consente di impostare lo stato predefinito della funzione di accessibilità del puntatore grande nella schermata di accesso.

Se questa norma viene impostata su true, il puntatore grande viene attivato quando viene visualizzata la schermata di accesso.

Se la norma viene impostata su false, il puntatore grande viene disattivato quando viene visualizzata la schermata di accesso.

Se la norma viene impostata, gli utenti possono ignorarla temporaneamente attivando o disattivando il puntatore grande. La scelta dell'utente non è però permanente e viene ripristinato il valore predefinito quando viene visualizzata di nuovo la schermata di accesso o quando l'utente rimane inattivo nella schermata di accesso per un minuto.

Se la norma non viene impostata, il puntatore grande viene disattivato alla prima visualizzazione della schermata di accesso. Gli utenti possono attivare o disattivare il puntatore grande in qualsiasi momento e il relativo stato nella schermata di accesso persiste per tutti gli utenti.</translation>
<translation id="5929855945144989709">Consente ai dispositivi di eseguire macchine virtuali su Chrome OS</translation>
<translation id="5932767795525445337">Questa policy può essere utilizzata anche per bloccare app per Android.</translation>
<translation id="5936622343001856595">Forza l'esecuzione delle query in Ricerca Google con l'opzione SafeSearch attiva e impedisce agli utenti di modificare questa impostazione.

      Se attivi l'impostazione, SafeSearch in Ricerca Google è sempre attiva.

      Se disattivi l'impostazione o non imposti un valore, l'utilizzo di SafeSearch non viene forzato in Ricerca Google.</translation>
<translation id="5946082169633555022">Canale Beta</translation>
<translation id="5950205771952201658">Alla luce del fatto che i controlli della revoca online soft-fail non offrono un effettivo vantaggio per la sicurezza, sono disattivati per impostazione predefinita nella versione 19 e nelle versioni successive di <ph name="PRODUCT_NAME" />. Se questa norma viene impostata su true, viene ripristinato il comportamento precedente e vengono effettuati controlli OCSP/CRL online.

      Se la norma non viene impostata o viene impostata su false, <ph name="PRODUCT_NAME" /> non effettuerà controlli della revoca online in <ph name="PRODUCT_NAME" /> 19 e nelle versioni successive.</translation>
<translation id="5961137303188584693">Indirizzo MAC NIC integrato del dispositivo</translation>
<translation id="5966615072639944554">Estensioni autorizzate a utilizzare l'API di attestazione da remoto</translation>
<translation id="5983708779415553259">Comportamento predefinito per i siti non presenti in pacchetti di contenuti</translation>
<translation id="5997543603646547632">Utilizza orologio di 24 ore per impostazione predefinita</translation>
<translation id="5997846976342452720">Specifica se disattivare o meno la ricerca dei plug-in (ritirata)</translation>
<translation id="6017568866726630990">Mostra la finestra di dialogo di stampa del sistema invece dell'anteprima di stampa.

      Se l'impostazione è attivata, <ph name="PRODUCT_NAME" /> aprirà la finestra di dialogo di stampa del sistema invece dell'anteprima di stampa integrata quando un utente richiede la stampa di una pagina.

      Se il criterio non è impostato o è impostato su False, i comandi di stampa attivano la schermata dell'anteprima di stampa.</translation>
<translation id="6022948604095165524">Azione all'avvio</translation>
<translation id="6023030044732320798">Consente di specificare un insieme di norme che saranno trasferite al runtime ARC. Il valore deve essere un JSON valido.

      È possibile usare questa norma per configurare le app Android da installare automaticamente sul dispositivo:

      {
        "type": "object",
        "properties": {
          "applications": {
            "type": "array",
            "items": {
              "type": "object",
              "properties": {
                "packageName": {
                  "description": "Identificatore dell'app Android, ad esempio "com.google.android.gm" per Gmail",
                  "type": "string"
                },
                "installType": {
                  "description": "Consente di specificare la modalità di installazione di un'app. OPTIONAL: l'app non viene installata automaticamente, ma l'utente può installarla. Si tratta del valore predefinito se questa norma non viene specificata. PRELOAD: l'app viene installata automaticamente, ma l'utente può disinstallarla. FORCE_INSTALLED: l'app viene installata automaticamente e l'utente non può disinstallarla. BLOCKED: l'app è bloccata e non può essere installata. Se l'app è stata installata in base a una norma precedente, verrà disinstallata.",
                  "type": "string",
                  "enum": [
                    "OPTIONAL",
                    "PRELOAD",
                    "FORCE_INSTALLED",
                    "BLOCKED"
                  ]
                },
                "defaultPermissionPolicy": {
                  "description": "Norma per le richieste di concessione delle autorizzazioni delle app. PERMISSION_POLICY_UNSPECIFIED: norma non specificata. Se per un'autorizzazione non viene specificata alcuna norma a nessuno livello, viene usato per impostazione predefinita il comportamento "PROMPT". PROMPT: viene chiesto all'utente di concedere un'autorizzazione. GRANT: viene concessa automaticamente un'autorizzazione. DENY: viene negata automaticamente un'autorizzazione.",
                  "type": "string",
                  "enum": [
                    "PERMISSION_POLICY_UNSPECIFIED",
                    "PROMPT",
                    "GRANT",
                    "DENY"
                  ]
                },
                "managedConfiguration": {
                  "description": "Oggetto di configurazione JSON specifico dell'app con una serie di coppie chiave-valore, ad esempio '"managedConfiguration": { "key1": value1, "key2": value2 }'. Le chiavi sono definite nel file manifest dell'app.",
                  "type": "object"
                }
              }
            }
          }
        }
      }

      Per bloccare le app in Avvio applicazioni, vedi la norma PinnedLauncherApps.</translation>
<translation id="602728333950205286">URL di ricerca istantanea del provider di ricerca predefinito</translation>
<translation id="603410445099326293">Parametri per l'URL del suggerimento che utilizza POST</translation>
<translation id="6034341625190551415">Consente di controllare tipi di account kiosk e sessioni pubbliche.</translation>
<translation id="6034603289689965535">Consente a una pagina di mostrare i popup durante l'unload.</translation>
<translation id="6036523166753287175">Abilita attraversamento firewall da host di accesso remoto</translation>
<translation id="6070667616071269965">Layout da tastiera della schermata di accesso del dispositivo</translation>
<translation id="6074963268421707432">Non consentire la visualizzazione di notifiche desktop da parte dei siti</translation>
<translation id="6074964551275531965">Imposta il periodo di tempo per le notifiche relative agli aggiornamenti</translation>
<translation id="6076099373507468537">Definisce l'elenco di dispositivi USB che possono essere scollegati dal driver del kernel per essere utilizzati tramite l'API chrome.usb direttamente all'interno di un'applicazione web. Le voci sono coppie costituite dall'ID fornitore USB e dall'ID prodotto per identificare un hardware specifico.

      Se la norma non è configurata, l'elenco di dispositivi USB scollegabili è vuoto.</translation>
<translation id="6083631234867522991">Windows (client Windows):</translation>
<translation id="608788685013546076">Imposta un valore percentuale per il limite di consumo della batteria per la variazione dei picchi energetici</translation>
<translation id="6089679180657323464">Consente di stabilire le impostazioni del controller DTC (Diagnostics and Telemetry Controller) wilco.</translation>
<translation id="6091233616732024397">Obbliga gli utenti ad eseguire l'accesso per poter usare il browser</translation>
<translation id="6093156968240188330">Consente agli utenti remoti di interagire con finestre con privilegi più elevati nelle sessioni di assistenza remota</translation>
<translation id="6095999036251797924">Consente di specificare il periodo di tempo senza input dell'utente trascorso il quale lo schermo viene bloccato durante l'utilizzo di alimentazione CA o batteria.

Se il periodo di tempo viene impostato su un valore maggiore di zero, questo valore rappresenta il periodo di tempo per cui l'utente deve rimanere inattivo prima che <ph name="PRODUCT_OS_NAME" /> blocchi lo schermo.

Se il periodo di tempo viene impostato su zero, <ph name="PRODUCT_OS_NAME" /> non blocca lo schermo quando l'utente diventa inattivo.

Se il periodo di tempo non viene impostato, viene utilizzato un periodo di tempo predefinito.

La modalità di blocco dello schermo per inattività consigliata è l'attivazione del blocco schermo in caso di sospensione e la sospensione di <ph name="PRODUCT_OS_NAME" /> una volta trascorso il ritardo di inattività. Questa norma dovrebbe essere utilizzata soltanto quando il blocco dello schermo deve avvenire molto prima della sospensione o quando non si desidera attivare la sospensione in caso di inattività.

Il valore della norma deve essere specificato in millisecondi. I valori devono essere minori del ritardo di inattività.</translation>
<translation id="6097601282776163274">Attiva la raccolta di dati anonimizzati con chiave URL</translation>
<translation id="6099853574908182288">Modalità di stampa a colori predefinita</translation>
<translation id="6107642964266628393">Consente di stabilire come e quando applicare gli aggiornamenti di Chrome OS.</translation>
<translation id="6111936128861357925">Attiva il gioco del dinosauro</translation>
<translation id="6114416803310251055">obsoleto</translation>
<translation id="6133088669883929098">Consenti a tutti i siti di utilizzare la generazione di chiavi</translation>
<translation id="6136537398661737682">Questo criterio consente di controllare lo stato iniziale dei servizi di geolocalizzazione di Google.

      Se questo criterio non è configurato o non è impostato su <ph name="GLS_DISABLED" />, i servizi di geolocalizzazione di Google sono inizialmente disattivati.

      Se questo criterio è impostato su <ph name="GLS_ENABLED" />, i servizi di geolocalizzazione di Google sono inizialmente attivati.

      Se questo criterio è impostato su <ph name="GLS_UNDER_USER_CONTROL" />, all'utente viene chiesto di scegliere se utilizzare o meno i servizi di geolocalizzazione di Google. Questo consente alle app Android di usare i servizi per inviare query sulla posizione del dispositivo; inoltre, consentirà l'invio a Google di dati sulla posizione anonimi.

      Tieni presente che questo criterio controlla lo stato dei servizi di geolocalizzazione di Google solo durante la configurazione iniziale. L'utente può aprire le impostazioni di Android in un secondo momento e attivare o disattivare i servizi di geolocalizzazione di Google.

      Tieni presente che questo criterio viene ignorato e i servizi di geolocalizzazione di Google vengono sempre disattivati quando il criterio <ph name="DEFAULT_GEOLOCATION_SETTING_POLICY_NAME" /> è impostato su <ph name="BLOCK_GEOLOCATION_SETTING" />.</translation>
<translation id="6141402445226505817">Utilizza sempre il rilevamento approssimativo del fuso orario</translation>
<translation id="6145799962557135888">Consente di impostare un elenco di pattern URL che specificano i siti in cui è consentita l'esecuzione di JavaScript. Se questa norma non viene impostata, per tutti i siti verrà utilizzato il valore predefinito globale della norma "DefaultJavaScriptSetting", se è impostata, oppure verrà utilizzata la configurazione personale dell'utente.</translation>
<translation id="614662973812186053">Questa norma controlla anche la raccolta dei dati diagnostici e sull'utilizzo di Android.</translation>
<translation id="6153048425064249648">Questa norma consente di controllare il reporting su cloud di <ph name="PRODUCT_NAME" />, che carica informazioni sul funzionamento del browser sulla Console di amministrazione Google.

      Se questa norma non viene impostata o viene impostata su False, i dati non vengono raccolti o caricati.
      Se questa norma viene impostata su True, i dati vengono raccolti e caricati sulla Console di amministrazione Google.
      Per controllare quali dati vengono caricati, ricorri alle norme nel gruppo Estensione per la segnalazione di Chrome.

      Questa norma viene applicata soltanto se il computer viene registrato con la norma <ph name="MACHINE_LEVEL_USER_CLOUD_POLICY_ENROLLMENT_TOKEN_POLICY_NAME" />.

      Questa norma effettua l'installazione forzata di <ph name="CHROME_REPORTING_EXTENSION_NAME" /> per il reporting ed esegue l'override di tutte le norme di estensione relative a quell'estensione.</translation>
<translation id="6155247658847899816">Quando questa norma è impostata, la risoluzione e il fattore di scala per ogni
      display sono impostati sui valori specificati. Le impostazioni del display esterno vengono
      applicate a tutti i display esterni collegati.

      I valori "external_width" ed "external_height" devono essere specificati in
      pixel. I valori "external_scale_percentage" e
      "internal_scale_percentage" devono essere specificati in percentuale.

      Se il valore "external_use_native" è impostato su true, la norma ignora i valori
      "external_height" ed "external_width" e imposta la risoluzione nativa
      dei display esterni.

      Se il valore "external_use_native" è impostato su false o non è fornito e non viene fornito nemmeno
      il valore "external_height" o "external_width", la norma non
      influisce sulle impostazioni del display esterno. Se la risoluzione o il
      fattore di scala specificati non sono supportati da un display, la norma non viene applicata
      al display.

      Se il contrassegno "recommended" è impostato su true, gli utenti possono modificare la risoluzione e
      il fattore di scala di qualsiasi display tramite la pagina delle impostazioni dopo aver eseguito l'accesso, tuttavia
      al riavvio successivo le loro impostazioni verranno sostituite dal valore della norma.
      Se il contrassegno "recommended" è impostato su false o non è impostato, gli utenti non possono modificare le
      impostazioni del display.</translation>
<translation id="6155936611791017817">Impostazione stato predefinito del puntatore grande nella schermata di accesso</translation>
<translation id="6157537876488211233">Elenco separato da virgole delle regole di bypass proxy</translation>
<translation id="6158324314836466367">Nome del web store dell'azienda (obsoleta)</translation>
<translation id="6158817306788002298">Puoi specificare un URL di un file .pac del proxy qui.

          Questa norma viene applicata solo se hai selezionato manualmente le impostazioni proxy in "Scegli come specificare le impostazioni del server proxy" e se la norma <ph name="PROXY_SETTINGS_POLICY_NAME" /> non è stata specificata.

          Devi lasciare questa norma non impostata se hai selezionato una qualsiasi altra modalità per l'impostazione delle norme relative al proxy.

          Per esempi dettagliati, visita:
          <ph name="PROXY_HELP_URL" />.</translation>
<translation id="6178075938488052838">Questa norma consente di stabilire chi può avviare una sessione di <ph name="PRODUCT_OS_NAME" />. Non impedisce agli utenti di accedere ad altri Account Google su Android. Se invece vuoi impedirlo, configura la norma <ph name="ACCOUNT_TYPES_WITH_MANAGEMENT_DISABLED_CLOUDDPC_POLICY_NAME" /> specifica per Android nell'ambito della norma <ph name="ARC_POLICY_POLICY_NAME" />.</translation>
<translation id="6181608880636987460">Consente di impostare un elenco di pattern URL che specificano i siti che non possono eseguire il plug-in <ph name="FLASH_PLUGIN_NAME" />.

          Se questa norma non viene impostata, per tutti i siti verrà utilizzato il valore predefinito globale della norma "DefaultPluginsSetting", se impostata, oppure la configurazione personale dell'utente.</translation>
<translation id="6190022522129724693">Impostazione popup predefiniti</translation>
<translation id="6190367314942602985">Segnala informazioni di identificazione degli utenti</translation>
<translation id="6197453924249895891">Consente di concedere alle estensioni l'accesso alle chiavi aziendali.

      Le chiavi sono destinate all'utilizzo aziendale se generate tramite l'API chrome.enterprise.platformKeys su un account gestito. Le chiavi importate o generate in altro modo non sono destinate all'utilizzo aziendale.

      L'accesso a chiavi destinate all'utilizzo aziendale è controllato esclusivamente da questa norma. L'utente non può concedere o revocare l'accesso delle estensioni alle chiavi aziendali.

      Per impostazione predefinita, un'estensione non può utilizzare una chiave destinata all'utilizzo aziendale. Questo equivale a impostare la norma allowCorporateKeyUsage su false per l'estensione in questione.

      Soltanto se la norma allowCorporateKeyUsage relativa a un'estensione viene impostata su true l'estensione può utilizzare qualsiasi chiave della piattaforma contrassegnata per l'utilizzo aziendale per firmare dati arbitrari. Questa autorizzazione dovrebbe essere concessa soltanto se l'estensione è ritenuta attendibile ai fini della protezione della chiave da potenziali attacchi.</translation>
<translation id="6208896993204286313">Segnala informazioni sulle norme di <ph name="PRODUCT_NAME" /></translation>
<translation id="6210259502936598222">Segnala informazioni sulla versione del sistema operativo e di <ph name="PRODUCT_NAME" /></translation>
<translation id="6210610748361191729">Se la norma viene impostata su False, l'interfaccia utente di esportazione/importazione non sarà disponibile agli utenti; è comunque possibile usare i comandi "lxc" direttamente nella macchina virtuale per esportare e importare le immagini del contenitore.</translation>
<translation id="6211428344788340116">Consente di indicare i tempi di attività del dispositivo. Se questa impostazione viene impostata su True, i dispositivi registrati indicheranno i periodi di tempo di attività di un utente sul dispositivo. Se l'impostazione viene impostata su False, i tempi di attività del dispositivo non verranno registrati o indicati.</translation>
<translation id="6212868225782276239">Vengono mostrate tutte le stampanti, tranne quelle indicate nella lista nera.</translation>
<translation id="6219965209794245435">Se viene attivata, questa norma consente di imporre l'importazione dei dati della compilazione automatica dei moduli dal browser predefinito precedente. Se la norma è attiva incide anche sulla finestra di dialogo di importazione.

      Se viene disattivata, i dati della compilazione automatica dei moduli non vengono importati.

      Se non viene impostata, all'utente potrebbe essere chiesto se desidera importare i dati oppure l'importazione potrebbe avvenire automaticamente.</translation>
<translation id="6221175752766085998">Consenti i certificati emessi dai trust anchor locali senza estensione subjectAlternativeName</translation>
<translation id="6224304369267200483">URL/domini per cui è consentita automaticamente l'attestazione diretta dei token di sicurezza</translation>
<translation id="6233173491898450179">Imposta directory di download</translation>
<translation id="6244210204546589761">Pagine da aprire all'avvio</translation>
<translation id="6255387031094435995">Consente ai criteri selezionati di essere uniti quando provengono da origini diverse, con stesso ambito e livello.

        Se un criterio è nell'elenco, nel caso ci sia conflitto tra due origini, purché abbiano lo stesso ambito e lo stesso livello, i valori verranno uniti nel nuovo elenco dei criteri.

        Se un criterio è nell'elenco, nel caso ci sia conflitto tra due origini, ma anche tra ambito e/o livello, verrà applicato il criterio con la priorità massima.

        Se un criterio non si trova nell'elenco, nel caso in cui ci siano conflitti tra origine, ambito e/o livello, verrà applicato il criterio con la priorità massima.</translation>
<translation id="6258193603492867656">Consente di specificare se il Kerberos SPN generato deve includere una porta non standard. Se attivi questa impostazione e specifichi una porta non standard (cioè una porta diversa da 80 o 443), la porta verrà inclusa nel Kerberos SPN generato. Se disattivi l'impostazione o non la imposti, il Kerberos SPN generato non includerà in nessun caso una porta.</translation>
<translation id="6261643884958898336">Segnala informazioni di identificazione dei computer</translation>
<translation id="6281043242780654992">Consente di configurare le norme per i messaggi nativi. Gli host di messaggi nativi non autorizzati non saranno consentiti se non vengono aggiunti alla whitelist.</translation>
<translation id="6282799760374509080">Consenti o nega acquisizione audio</translation>
<translation id="6284362063448764300">TLS 1.1</translation>
<translation id="6306608379445125648">Forza la disattivazione delle lingue per correttore ortografico. Le lingue non riconosciute di quell'elenco verranno ignorate.

      Se attivi questa norma, il correttore ortografico verrà disattivato per le lingue specificate. L'utente può comunque attivare o disattivare il correttore ortografico per le lingue che non sono nell'elenco.

      Se non imposti la norma o la disattivi, le preferenze sul correttore ortografico dell'utente rimarranno invariate.

      Questa norma non verrà applicata se la norma SpellcheckEnabled è disattivata.

      Se una lingua è inclusa sia in questa norma sia nella norma SpellcheckLanguage, la norma SpellcheckLanguage ha la priorità e verrà attivata la lingua per il correttore ortografico.

      Le lingue attualmente supportate sono: af, bg, ca, cs, da, de, el, en-AU, en-CA, en-GB, en-US, es, es-419, es-AR, es-ES, es-MX, es-US, et, fa, fo, fr, he, hi, hr, hu, id, it, ko, lt, lv, nb, nl, pl, pt-BR, pt-PT, ro, ru, sh, sk, sl, sq, sr, sv, ta, tg, tr, uk, vi.</translation>
<translation id="6310223829319187614">Consente il completamento automatico del nome di dominio durante l'accesso dell'utente</translation>
<translation id="6315673513957120120">Chrome mostra una pagina di avviso quando gli utenti visitano siti che presentano errori SSL. Per impostazione predefinita, o se la norma viene impostata su true, gli utenti possono fare clic nelle pagine di avviso.
      Se questa norma viene impostata su false, gli utenti non possono fare clic nelle pagine di avviso.</translation>
<translation id="6352543686437322588">Un account locale del dispositivo a cui accedere automaticamente dopo un ritardo.

      Se questa norma è impostata, verrà eseguito l'accesso automatico alla sessione specificata dopo che è trascorso un periodo di tempo senza interazioni dell'utente nella schermata di accesso. L'account locale del dispositivo deve essere già configurato (vedi |DeviceLocalAccounts|).

      Se questa norma non è impostata, non avverrà l'accesso automatico.</translation>
<translation id="6353901068939575220">Consente di specificare i parametri utilizzati durante la ricerca di un URL con POST. Si tratta di coppie di nome/valore separate da virgole. Se un valore è il parametro di un modello, come {searchTerms} nell'esempio precedente, verrà sostituito con i dati dei termini di ricerca reali.

Questa norma è facoltativa. Se non viene impostata, la richiesta di ricerca verrà inviata utilizzando il metodo GET.

Questa norma viene rispettata soltanto se la norma "DefaultSearchProviderEnabled" è attiva.</translation>
<translation id="6368011194414932347">Configura l'URL della pagina iniziale</translation>
<translation id="6368403635025849609">Consenti JavaScript su questi siti</translation>
<translation id="6376659517206731212">Può essere obbligatoria</translation>
<translation id="6377355597423503887">Questa norma è stata ritirata; usa la norma BrowserSignin.

      Consente all'utente di accedere a <ph name="PRODUCT_NAME" />.

      Se questa norma viene impostata, puoi stabilire se un utente può accedere o meno a <ph name="PRODUCT_NAME" />. Se la norma viene impostata su "False", le app e le estensioni che utilizzano l'API chrome.identity non funzioneranno, pertanto è consigliabile utilizzare la norma SyncDisabled.</translation>
<translation id="6378076389057087301">Specifica se l'attività audio incide sulla gestione dell'alimentazione</translation>
<translation id="637934607141010488">Consente di indicare un elenco di utenti del dispositivo che hanno eseguito l'accesso di recente. Se la norma è impostata su False, gli utenti non vengono indicati.</translation>
<translation id="6394350458541421998">La norma non è più supportata a partire dalla versione 29 di <ph name="PRODUCT_OS_NAME" />. Utilizza la norma PresentationScreenDimDelayScale.</translation>
<translation id="6401669939808766804">Disconnetti l'utente</translation>
<translation id="6406448383934634215">Se come azione all'avvio è stato impostato "Apri un elenco di URL", puoi specificare l'elenco degli URL che vengono aperti. Se questa norma non viene impostata, all'avvio non verrà aperto alcun URL.

          Questa norma funziona soltanto se la norma "RestoreOnStartup" viene impostata su "RestoreOnStartupIsURLs".

          Questa norma è disponibile esclusivamente per le istanze di Windows che fanno parte di un dominio <ph name="MS_AD_NAME" /> così come per le istanze di Windows 10 Pro o Enterprise registrate per la gestione dei dispositivi.</translation>
<translation id="6417265370957905582">Assistente Google</translation>
<translation id="6426205278746959912">Non è possibile imporre l'utilizzo di un proxy alle app Android. Viene messo a disposizione un sottoinsieme di impostazioni proxy che le app Android possono decidere se rispettare o meno.

          Se si decide di non usare mai un server proxy, alle app Android viene comunicato che non è configurato alcun proxy.

          Se si decide di usare le impostazioni proxy di sistema o un proxy server fisso, alle app Android vengono forniti l'indirizzo HTTP e la porta di tale server.

          Se si decide di rilevare automaticamente il server proxy, alle app Android viene fornito l'URL script "http://wpad/wpad.dat". Non viene utilizzata nessun'altra parte del protocollo di rilevamento automatico del server proxy.

          Se si decide di utilizzare uno script proxy .pac, alle app Android viene fornito l'URL script.</translation>
<translation id="6430366557948788869">Estensione Chrome Reporting Extension</translation>
<translation id="6440051664870270040">Consenti ai siti di navigare e aprire popup contemporaneamente</translation>
<translation id="6447948611083700881">Backup e ripristino disabilitati</translation>
<translation id="6449476513004303784">Non consentire più agli utenti di gestire i certificati</translation>
<translation id="645425387487868471">Attiva l'accesso forzato per <ph name="PRODUCT_NAME" /></translation>
<translation id="6464074037294098618">Attiva la Compilazione automatica per gli indirizzi</translation>
<translation id="6467613372414922590">Consenti host di messaggistica nativi a livello di utente (installati senza privilegi di amministratore)</translation>
<translation id="6468980648680553776">Questa norma è obsoleta. Al suo posto utilizza RemoteAccessHostClientDomainList.</translation>
<translation id="6473623140202114570">Configura l'elenco di domini sui quali Navigazione sicura non attiverà avvisi.</translation>
<translation id="6488627892044759800">Consente di configurare il tipo di home page predefinita di <ph name="PRODUCT_NAME" /> e di impedire agli utenti di modificare le preferenze della home page. L'home page può essere impostata sull'URL specificato oppure sulla pagina Nuova scheda.

          Se attivi questa impostazione, la pagina Nuova scheda verrà sempre utilizzata come home page e l'URL della home page verrà ignorato.

          Se disattivi questa impostazione, la home page dell'utente non sarà mai la pagina Nuova scheda, a meno che l'URL sia impostato su "chrome://newtab".

          Se questa impostazione viene attivata o disattivata, gli utenti non possono modificare il tipo di home page in <ph name="PRODUCT_NAME" />.

         Se questa norma non viene impostata, l'utente può scegliere autonomamente se utilizzare la pagina Nuova scheda come home page.

          Questa norma è disponibile esclusivamente per le istanze di Windows che fanno parte di un dominio <ph name="MS_AD_NAME" /> così come per le istanze di Windows 10 Pro o Enterprise registrate per la gestione dei dispositivi.</translation>
<translation id="6491139795995924304">Consenti Bluetooth sul dispositivo</translation>
<translation id="6491872498385040936">Questa norma è obsoleta. È possibile utilizzare la norma <ph name="FORCE_YOUTUBE_RESTRICT_POLICY_NAME" />, che sostituisce questa norma e consente un perfezionamento più preciso.

      Consente di imporre il livello medio della Modalità con restrizioni di YouTube e di impedire agli utenti di modificare l'impostazione.

      Se questa impostazione viene attivata, verrà sempre applicato almeno il livello medio della Modalità con restrizioni su YouTube.

      Se questa impostazione viene disattivata o non viene impostato alcun valore, la Modalità con restrizioni su YouTube non verrà applicata da <ph name="PRODUCT_NAME" />. La Modalità con restrizioni potrebbe essere comunque applicata da norme esterne, ad esempio dalle norme di YouTube.</translation>
<translation id="6495328383950074966">Consente di configurare l'elenco dei domini che Navigazione sicura ritiene attendibili. Ciò significa che:
      Navigazione sicura non controllerà la presenza di risorse pericolose (ad es. phishing, malware o software indesiderato) se i rispettivi URL corrispondono a questi domini.
      Il servizio di protezione dei download di Navigazione sicura non controllerà i download ospitati su questi domini.
      Il servizio di protezione tramite password di Navigazione sicura non controllerà il riutilizzo della password se l'URL della pagina corrisponde a questi domini.

      Se questa impostazione è attivata, Navigazione sicura considererà questi domini attendibili.
      Se questa impostazione è disattivata o non impostata, a tutte le risorse verrà applicata la protezione predefinita di Navigazione sicura.
      Questa norma è disponibile esclusivamente per le istanze di Windows che fanno parte di un dominio <ph name="MS_AD_NAME" /> così come per le istanze di Windows 10 Pro o Enterprise registrate per la gestione dei dispositivi.</translation>
<translation id="6515357889978918016">Immagine <ph name="PLUGIN_VM_NAME" /></translation>
<translation id="6520802717075138474">Importa motori di ricerca dal browser predefinito alla prima esecuzione</translation>
<translation id="6525955212636890608">Se attivi questa impostazione, verranno eseguiti tutti i contenuti Flash incorporati nei siti web per cui è stato consentito Flash nelle impostazioni dei contenuti (dall'utente o in base a una norma aziendale), inclusi i contenuti di altre origini o contenuti ridotti.

      Per stabilire quali siti web possono eseguire i contenuti Flash, fai riferimento alle norme "DefaultPluginsSetting", "PluginsAllowedForUrls" e "PluginsBlockedForUrls".

      Se questa impostazione viene disattivata o non viene impostata, i contenuti Flash di altre origini o i contenuti ridotti potrebbero essere bloccati.</translation>
<translation id="6532769014584932288">Consenti i wakelock</translation>
<translation id="653608967792832033">Consente di specificare il periodo di tempo senza input dell'utente trascorso il quale lo schermo viene bloccato quando viene utilizzata la batteria.

Se questa norma viene impostata su un valore maggiore di zero, consente di specificare il periodo di tempo per cui l'utente deve rimanere inattivo prima che <ph name="PRODUCT_OS_NAME" /> blocchi lo schermo.

Se questa norma viene impostata su zero, <ph name="PRODUCT_OS_NAME" /> non blocca lo schermo quando l'utente diventa inattivo.

Se questa norma non viene impostata, viene utilizzato un periodo di tempo predefinito.

Il metodo consigliato per bloccare lo schermo in caso di inattività consiste nell'attivare il blocco dello schermo in caso di sospensione e fare in modo che <ph name="PRODUCT_OS_NAME" /> venga sospeso dopo il ritardo di inattività. Questa norma dovrebbe essere utilizzata soltanto quando il blocco dello schermo dovrebbe avvenire molto tempo prima della sospensione o quando non si desidera affatto la sospensione in caso di inattività.

Il valore della norma deve essere specificato in millisecondi. I valori devono essere inferiori al ritardo di inattività.</translation>
<translation id="6536600139108165863">Riavvia automaticamente allo spegnimento del dispositivo</translation>
<translation id="6539246272469751178">Questa norma non influisce sulle app Android, che utilizzano sempre la directory per i download predefinita e non possono accedere ai file scaricati da <ph name="PRODUCT_OS_NAME" /> in una directory per i download non predefinita.</translation>
<translation id="654303922206238013">Strategia di migrazione per ecryptfs</translation>
<translation id="6544897973797372144">Se questa norma è impostata su True e non è specificata la norma ChromeOsReleaseChannel, gli utenti del dominio di registrazione avranno la facoltà di modificare il canale della versione del dispositivo. Se questa norma è impostata su False, il dispositivo risulterà bloccato in qualunque canale in cui è stato impostato per ultimo.

      Il canale selezionato dall'utente verrà sostituito dalla norma ChromeOsReleaseChannel, ma se il canale della norma è più stabile di quello che è stato installato sul dispositivo, il canale cambierà solo quando la versione del canale più stabile raggiungerà un numero di versione superiore rispetto a quello installato sul dispositivo.</translation>
<translation id="6553143066970470539">Percentuale di luminosità dello schermo</translation>
<translation id="6559057113164934677">Non consentire ad alcun sito di accedere alla fotocamera e al microfono</translation>
<translation id="6561396069801924653">Mostra le opzioni di accessibilità nel menu della barra delle applicazioni di sistema</translation>
<translation id="6563458316362153786">Attiva 802.11r Fast Transition</translation>
<translation id="6565312346072273043">Imposta lo stato predefinito della funzione di accessibilità della tastiera sullo schermo nella schermata di accesso.

          Se questa norma viene impostata su true, la tastiera sullo schermo viene attivata quando viene visualizzata la schermata di accesso.

          Se questa norma viene impostata su false, la tastiera sullo schermo viene disattivata quando viene visualizzata la schermata di accesso.

          Se questa norma viene impostata, gli utenti possono ignorarla temporaneamente attivando o disattivando la tastiera sullo schermo. Tuttavia, la scelta dell'utente non è permanente e l'impostazione predefinita viene ripristinata ogni volta che viene visualizzata la schermata di accesso o se l'utente rimane inattivo sulla schermata di acceso per un minuto.

          Se questa norma non viene impostata, la tastiera sullo schermo è disattivata alla prima visualizzazione della schermata di accesso. Gli utenti possono attivare o disattivare la tastiera sullo schermo in qualsiasi momento e il relativo stato sulla schermata di accesso viene mantenuto tra utenti differenti.</translation>
<translation id="6570691255874112762">Questa norma controlla se l'utente è in grado di importare e rimuovere certificati tramite Gestione certificati.

      Se la norma è impostata su "Consenti agli utenti di gestire tutti i certificati" o se non è impostata, gli utenti potranno gestire i certificati.

      Se la norma è impostata su "Consenti agli utenti di gestire i certificati utente", gli utenti potranno gestire i certificati utente, ma non i certificati a livello di dispositivo.

      Se la norma è impostata su "Non consentire più agli utenti di gestire i certificati", gli utenti non potranno gestire i certificati, ma solo visualizzarli.</translation>
<translation id="6573305661369899995">Imposta una fonte esterna di limitazioni relative agli URL</translation>
<translation id="6598235178374410284">Immagine avatar utente</translation>
<translation id="6603004149426829878">Consente di inviare sempre al server i segnali relativi alla posizione disponibili durante le operazioni per stabilire il fuso orario</translation>
<translation id="6628120204569232711">Segnala lo stato di archiviazione</translation>
<translation id="6628646143828354685">Permette di stabilire se consentire o meno l'accesso ai dispositivi Bluetooth nelle vicinanze. L'accesso può essere bloccato completamente oppure l'utente può ricevere una richiesta ogni volta che un sito web desidera accedere ai dispositivi Bluetooth vicini.

          Se questa norma non viene impostata, verrà utilizzato il valore "3", che potrà essere modificato dall'utente.</translation>
<translation id="663685822663765995">Limita la modalità di stampa a colori</translation>
<translation id="6641981670621198190">Disattiva supporto per le API grafiche 3D</translation>
<translation id="6646056064606561298">Consente di attivare la norma di gestione dell'energia relativa all'avvio tramite CA.

          L'avvio tramite CA permette al sistema di avviarsi automaticamente dallo stato di Spento/Ibernazione quando viene inserita la corrente.

          Se questa norma è impostata su true, l'avvio tramite CA sarà sempre attivo, se supportato sul dispositivo.

          Se questa norma è impostata su false, l'avvio tramite CA sarà sempre disattivato.

          Se imposti questa norma, gli utenti non potranno modificarla o sostituirla.

          Se questa norma non è impostata, l'avvio tramite CA è disattivato e non può essere attivato dall'utente.</translation>
<translation id="6647965994887675196">Se questa norma è impostata su true, è possibile creare e utilizzare utenti supervisionati.

          Se questa norma è impostata su false o non è configurata, la creazione di utenti supervisionati e il relativo accesso saranno disattivati. Tutti gli utenti supervisionati esistenti saranno nascosti.

          NOTA. Il comportamento predefinito per dispositivi consumer ed enterprise è diverso: sui dispositivi consumer, gli utenti supervisionati sono abilitati per impostazione predefinita, mentre sui dispositivi enterprise sono disabilitati per impostazione predefinita.</translation>
<translation id="6649397154027560979">Questa norma non è più supportata; utilizza la norma URLBlacklist.

Consente di disattivare gli schemi dei protocolli elencati in <ph name="PRODUCT_NAME" />.

Gli URL che utilizzano uno schema di questo elenco non verranno caricati e non potranno essere visitati.

Se questa norma non viene impostata o se l'elenco è vuoto, sarà possibile accedere a tutti gli schemi in <ph name="PRODUCT_NAME" />.</translation>
<translation id="6652197835259177259">Impostazioni degli utenti gestiti localmente</translation>
<translation id="6658245400435704251">Consente di specificare il numero di secondi massimo per cui un dispositivo può ritardare in modo casuale il download di un suo aggiornamento dal momento della pubblicazione dell'aggiornamento sul server. Il dispositivo può attendere una parte di questo tempo in termini di tempo reale e la parte rimanente in termini di numero di controlli della disponibilità di aggiornamenti. In ogni caso, la dispersione ha un limite massimo pari a un periodo di tempo costante in modo che un dispositivo non si blocchi mai in attesa di scaricare un aggiornamento.</translation>
<translation id="6665670272107384733">Imposta la frequenza di inserimento della password per poter usare lo sblocco rapido</translation>
<translation id="6681229465468164801">Consente di impostare un elenco di pattern URL che specificano i siti che non possono richiedere all'utente l'accesso al dispositivo USB.

          Se questa norma non viene impostata, per tutti i siti verrà utilizzato il valore predefinito globale della norma "DefaultWebUsbGuardSetting", se impostata, oppure la configurazione personale dell'utente.

          I pattern URL di questa norma non devono essere in conflitto con quelli configurati tramite la norma WebUsbAskForUrls. Non viene specificato quale delle due norme debba avere precedenza se un URL presenta corrispondenze con entrambe.</translation>
<translation id="6689792153960219308">Segnala lo stato dell'hardware</translation>
<translation id="6698632841807204978">Attiva la stampa monocromatica</translation>
<translation id="6699880231565102694">Abilita autenticazione a due fattori per gli host di accesso remoto</translation>
<translation id="6731757988219967594">Filtra i siti di contenuti per adulti di primo livello (ma non gli iframe incorporati)</translation>
<translation id="6734521799274931721">Consente di controllare la disponibilità della funzione Condivisioni file di rete per Chrome OS</translation>
<translation id="6735701345096330595">Forza attivazione lingue per controllo ortografico</translation>
<translation id="673699536430961464">Questa impostazione consente agli utenti di passare da un Account Google a un altro all'interno dell'area dei contenuti della finestra del browser dopo avere eseguito l'accesso al dispositivo <ph name="PRODUCT_OS_NAME" />.

      Se questa norma viene impostata su false, l'accesso a un altro account dall'area dei contenuti del browser in modalità diversa da quella di navigazione in incognito non sarà consentito.

      Se questa norma non viene impostata o viene impostata su true, verrà usato il comportamento predefinito: sarà possibile accedere a un altro account dall'area dei contenuti del browser, ma non agli account di minori, per i quali tale accesso non sarà consentito dall'area dei contenuti in modalità diversa da quella di navigazione in incognito.

      Qualora l'accesso a un altro account non debba essere consentito tramite la modalità di navigazione in incognito, potresti bloccare tale modalità usando la norma IncognitoModeAvailability.

      Tieni presente che gli utenti potranno accedere ai servizi Google in uno stato non autenticato bloccando i loro cookie.</translation>
<translation id="6757438632136860443">Consente di impostare un elenco di pattern URL che specificano i siti che possono eseguire il plug-in <ph name="FLASH_PLUGIN_NAME" />.

          Se questa norma non viene impostata, per tutti i siti verrà utilizzato il valore predefinito globale della norma "DefaultPluginsSetting", se impostata, oppure la configurazione personale dell'utente..</translation>
<translation id="6757613329154374267">Backup e ripristino attivato</translation>
<translation id="6762235610019366960">Ti consente di gestire la presentazione dei contenuti promozionali e/o informativi a scheda intera in <ph name="PRODUCT_NAME" />.

      Se la norma non viene configurata o viene attivata (impostata su true), <ph name="PRODUCT_NAME" /> potrebbe mostrare agli utenti i contenuti a scheda intera per fornire informazioni sul prodotto.

      Se viene disattivata (impostata su false), <ph name="PRODUCT_NAME" /> non mostrerà agli utenti i contenuti a scheda intera per fornire informazioni sul prodotto.

      Questa impostazione consente di gestire la presentazione delle pagine di benvenuto che consentono agli utenti di accedere a <ph name="PRODUCT_NAME" /> o sceglierlo come browser predefinito oppure che danno agli utenti informazioni sulle funzionalità del prodotto.</translation>
<translation id="6766216162565713893">Consenti ai siti di chiedere all'utente di concedere l'accesso a un dispositivo Bluetooth nelle vicinanze.</translation>
<translation id="6770454900105963262">Segnala informazioni sulle sessioni kiosk attive</translation>
<translation id="6786747875388722282">Estensioni</translation>
<translation id="6786967369487349613">Imposta la directory profilo di roaming</translation>
<translation id="6795485990775913659">Consenti la stampa solo senza PIN</translation>
<translation id="6810445994095397827">Blocca Javascript in questi siti</translation>
<translation id="6813263547126514821">Alimentazione e spegnimento</translation>
<translation id="681446116407619279">Schemi di autenticazione supportati</translation>
<translation id="6816212867679667972">Determina il nome host del dispositivo usato nelle richieste DHCP.

      Se per questa norma viene impostata una stringa non vuota, tale stringa verrà usata come nome host del dispositivo durante la richiesta DHCP.

      La stringa può contenere variabili ${ASSET_ID}, ${SERIAL_NUM}, ${MAC_ADDR}, ${MACHINE_NAME} che verrebbero sostituite con valori sul dispositivo prima di usare la stringa come nome host. La sostituzione finale dovrebbe essere un nome host valido (come da RFC 1035, sezione 3.1).

      Se questa norma non viene impostata o se il valore ottenuto in seguito alla sostituzione non è un nome host valido, non verrà impostato alcun nome host nella richiesta DHCP. </translation>
<translation id="6833988859168635883">Avvio, pagina iniziale e pagina Nuova scheda</translation>
<translation id="6835883744948188639">Mostra un messaggio ricorrente all'utente in cui indica che è consigliato eseguire un riavvio</translation>
<translation id="6837480141980366278">Consente di specificare se il client DNS integrato viene utilizzato in <ph name="PRODUCT_NAME" />.

      Se la norma è impostata su true, verrà utilizzato il client DNS integrato, se disponibile.

      Se la norma è impostata su false, il client DNS integrato non verrà mai utilizzato.

      Se la norma non viene impostata, per impostazione predefinita il client DNS integrato verrà attivato su macOS, Android (nel caso in cui non siano attivi il DNS privato né la VPN) e ChromeOS. Gli utenti saranno in grado di scegliere se il client DNS integrato è utilizzato modificando chrome://flags o specificando un flag della riga di comando.</translation>
<translation id="6838056959556423778">Consente di sostituire le regole di selezione della stampante predefinita di <ph name="PRODUCT_NAME" />.

      Questa norma consente di stabilire le regole per la selezione della stampante predefinita in <ph name="PRODUCT_NAME" />, che viene effettuata al primo utilizzo della funzione di stampa con un profilo.

      Se questa norma viene impostata, <ph name="PRODUCT_NAME" /> cercherà di trovare una stampante corrispondente a tutti gli attributi specificati e la selezionerà come stampante predefinita. Verrà selezionata la prima stampante trovata corrispondente alla norma; in caso di corrispondenze non univoche, può essere selezionata qualsiasi stampante, a seconda dell'ordine di rilevamento delle stampanti.

      Se questa norma non viene impostata o se non viene trovata una stampante corrispondente prima del timeout, viene selezionata come predefinita la stampante PDF integrata; se non è disponibile la stampante PDF, non viene selezionata alcuna stampante.

      Il valore viene analizzato come oggetto JSON, in base al seguente schema:
      {
        "type": "object",
        "properties": {
          "kind": {
            "description": "Indica se limitare la ricerca della stampante corrispondente a un insieme di stampanti specifico.",
            "type": "string",
            "enum": [ "local", "cloud" ]
          },
          "idPattern": {
            "description": "Espressione regolare corrispondente all'ID stampante.",
            "type": "string"
          },
          "namePattern": {
            "description": "Espressione regolare corrispondente al nome visualizzato per la stampante.",
            "type": "string"
          }
        }
      }

      Le stampanti connesse a <ph name="CLOUD_PRINT_NAME" /> vengono considerate <ph name="PRINTER_TYPE_CLOUD" />, mentre le altre stampanti vengono classificate come <ph name="PRINTER_TYPE_LOCAL" />.
      L'omissione di un campo implica la corrispondenza di tutti i valori; ad esempio, se non viene specificata la connettività, nell'Anteprima di stampa viene avviato il rilevamento di tutti i tipi di stampanti, locali e cloud.
      I modelli di espressioni regolari devono seguire la sintassi JavaScript RegExp e per le corrispondenze viene fatta distinzione tra maiuscole e minuscole.</translation>
<translation id="6843296367238757293">Questa norma è obsoleta. Ne sconsigliamo l'utilizzo. Leggi ulteriori informazioni all'indirizzo https://support.google.com/chrome/a/answer/7643500</translation>
<translation id="684856667300805181">Questa norma è stata rimossa in <ph name="PRODUCT_NAME" /> 68 e sostituita da <ph name="ARC_GLS_POLICY_NAME" />.</translation>
<translation id="6856743875250214792">Questa norma è obsoleta ed è stata rimossa su M66, poiché era utilizzata solo per test interni e rappresenta un rischio per la sicurezza.

      Consente di specificare i flag da applicare all'avvio di <ph name="PRODUCT_NAME" />. I flag specificati vengono applicati soltanto alla schermata di accesso. I flag impostati tramite questa norma non vengono applicati anche alle sessioni utente.</translation>
<translation id="685769593149966548">Imponi Livello massimo della Modalità con restrizioni per YouTube</translation>
<translation id="6857824281777105940">Questa norma consente di stabilire se segnalare o meno dati di Navigazione sicura, incluso il numero dell'avviso di Navigazione sicura e il numero del relativo click-through.

      Se questa norma non viene impostata o viene impostata su True, i dati di Navigazione sicura vengono raccolti.
      Se questa norma viene impostata su False, i dati di Navigazione sicura non vengono raccolti.

      Questa norma viene applicata soltanto se viene attivata l'estensione <ph name="CHROME_REPORTING_EXTENSION_NAME" /> e il computer viene registrato con la norma <ph name="MACHINE_LEVEL_USER_CLOUD_POLICY_ENROLLMENT_TOKEN_POLICY_NAME" />.</translation>
<translation id="686079137349561371">Microsoft Windows 7 o versioni successive</translation>
<translation id="687046793986382807">Questa norma è stata ritirata a partire dalla versione 35 di <ph name="PRODUCT_NAME" />.

      Le informazioni sulla memoria sono comunque riportate sulla pagina, indipendentemente dal valore opzione, ma le dimensioni segnalate presentano
      restrizioni e la frequenza di aggiornamento è stata limitata per motivi di sicurezza. Per acquisire dati precisi in tempo reale,
      utilizza strumenti come Telemetry.</translation>
<translation id="6894178810167845842">URL della pagina Nuova scheda</translation>
<translation id="6899705656741990703">Rileva automaticamente impostazioni proxy</translation>
<translation id="6903814433019432303">Questa norma è attiva soltanto in modalità retail.

      Consente di stabilire l'insieme di URL da caricare all'avvio della sessione demo. Questa norma sostituirà qualsiasi altro meccanismo di impostazione dell'URL iniziale ed è quindi possibile applicarla soltanto a una sessione non associata a un determinato utente.</translation>
<translation id="6908640907898649429">Configura il provider di ricerca predefinito. Puoi specificare il provider di ricerca predefinito che l'utente utilizzerà oppure scegliere di disattivare la ricerca predefinita.</translation>
<translation id="6913068954484253496">Consenti a <ph name="PRODUCT_NAME" /> di connettersi ai dispositivi Cast su tutti gli indirizzi IP.</translation>
<translation id="6915442654606973733">Consente di attivare la funzione di accessibilità di lettura vocale.

Se questa norma viene impostata su true, la lettura vocale sarà sempre attiva.

Se la norma viene impostata su false, la lettura vocale sarà sempre disattivata.

Se la norma viene impostata, gli utenti non potranno modificarla o ignorarla.

Se la norma non viene configurata, la lettura vocale viene inizialmente disattivata ma potrà essere attivata dagli utenti in qualsiasi momento.</translation>
<translation id="6916507170737609563">
      Potresti considerare l'impostazione della norma IsolateOriginsAndroid per ottenere sia l'isolamento sia un impatto limitato per gli utenti, utilizzando IsolateOriginsAndroid con un elenco di siti che vuoi isolare. Questa impostazione, SitePerProcessAndroid, isola tutti i siti.
      Se la norma viene attivata, ogni sito verrà eseguito in un proprio processo.
      Se la norma viene disattivata, non avverrà alcun isolamento esplicito dei siti e le prove sul campo di IsolateOriginsAndroid e SitePerProcessAndroid saranno disattivate. Gli utenti potranno ancora attivare SitePerProcess manualmente.
      Se la norma non viene configurata, l'utente potrà modificare questa impostazione.

      NOTA: su Android, l'isolamento dei siti è sperimentale. L'assistenza verrà migliorata, ma attualmente potrebbe causare problemi di prestazioni.

      NOTA: questa norma viene applicata solo a Chrome su dispositivi Android con più di 1 GB di RAM. Per applicare la norma su piattaforme non Android, utilizza SitePerProcess.
      </translation>
<translation id="6922884955650325312">Blocca il plug-in <ph name="FLASH_PLUGIN_NAME" /></translation>
<translation id="6923366716660828830">Consente di specificare il nome del provider di ricerca predefinito. Se il nome non viene impostato verrà utilizzato il nome host specificato nell'URL di ricerca. Questa norma viene considerata soltanto se è attiva la norma "DefaultSearchProviderEnabled".</translation>
<translation id="6926703471186170050">Attiva la stampa fronte/retro su lato lungo</translation>
<translation id="6931242315485576290">Disattiva la sincronizzazione dei dati con Google</translation>
<translation id="6936894225179401731">Consente di specificare il numero massimo di connessioni simultanee al server proxy.

      Alcuni server proxy non sono in grado di gestire un numero elevato di connessioni simultanee per client e questo problema può essere risolto impostando un valore inferiore per questa norma.

      Il valore di questa norma dovrebbe essere inferiore a 100 e superiore a 6, mentre il valore predefinito è 32.

      Alcune applicazioni web utilizzano notoriamente molte connessioni con Hanging-GET, pertanto utilizzare un valore minore di 32 potrebbe comportare interruzioni di rete del browser se sono aperte troppe applicazioni web di questo tipo. Se imposti un valore inferiore al valore predefinito, lo fai a tuo rischio.

      Se questa norma non viene impostata viene utilizzato il valore predefinito 32.</translation>
<translation id="6943577887654905793">Nome di preferenza per Mac/Linux:</translation>
<translation id="6944167205014013774">Le informazioni sull'utilizzo delle app Linux vengono rimandate al
      server.

      Se la norma viene impostata su false o non viene impostata, non vengono segnalate
      informazioni sull'utilizzo. Se viene impostata su true, queste informazioni vengono invece segnalate.

      Questa norma viene applicata soltanto se le app Linux sono attive.</translation>
<translation id="69525503251220566">Parametro che fornisce la funzione di ricerca tramite immagine per il provider di ricerca predefinito</translation>
<translation id="6953102253399571439">Attiva la stampa PIN per impostazione predefinita</translation>
<translation id="6956272732789158625">Non consentire a nessun sito di utilizzare la generazione di chiavi</translation>
<translation id="6965859329738616662">Specifica se al modello di oscuramento smart è consentito estendere la quantità di tempo prima che lo schermo venga oscurato.

Quando lo schermo sta per essere oscurato, il modello di oscuramento smart valuta se posticipare l'azione. In tal caso, il tempo prima che lo schermo venga oscurato viene effettivamente prolungato e il ritardo di inattività, la disattivazione dello schermo e il blocco dello schermo vengono regolati in modo da rispettare gli intervalli di tempo rispetto al ritardo oscuramento schermo configurati in precedenza.
Se questa norma è impostata su True o non è impostata, il modello di oscuramento smart verrà attivato e la quantità di tempo prima che lo schermo venga oscurato verrà estesa. Se questa norma è impostata su False, il modello di oscuramento smart non inciderà sull'oscuramento dello schermo.</translation>
<translation id="6967394885063085697">Consente di attivare il criterio di gestione della modalità di ricarica avanzata della batteria.

          La modalità di ricarica avanzata della batteria consente all'utente di massimizzare le condizioni della batteria. In modalità di ricarica avanzata, il sistema utilizza un algoritmo di ricarica standard e altre tecniche durante gli orari non di lavoro per massimizzare le condizioni della batteria. Durante gli orari di lavoro viene utilizzata una ricarica express. La ricarica express permette di ricaricare la batteria in modo più rapido; perciò, la carica completa avviene in tempi minori. Per ogni giorno, il tempo in cui il sistema viene usato con maggiore frequenza è specificato da ora di inizio e durata.

          Se questo criterio è impostato su true, e DeviceAdvancedBatteryChargeModeDayConfig è impostato, la modalità di ricarica avanzata della batteria verrà attivata se supportata sul dispositivo.

          Se questo criterio è impostato su false, la modalità di ricarica avanzata della batteria è sempre disattivata.

          Se imposti questo criterio, gli utenti non potranno modificarla o sostituirla.

          Se questo criterio non è impostato, la modalità di ricarica avanzata della batteria è disattivata e non può essere attivata dall'utente.</translation>
<translation id="6972540544240464302">Seleziona configurazione programma di pianificazione attività</translation>
<translation id="6979158407327259162">Google Drive</translation>
<translation id="6994082778848658360">Consente di specificare in che modo è possibile usare l'hardware degli elementi di sicurezza su scheda per fornire l'autenticazione a due fattori, se compatibile con questa funzione. Il tasto di accensione del computer viene usato per rilevare la presenza fisica dell'utente.

       Se selezioni l'opzione "Disabilitata", non viene fornita l'autenticazione a due fattori.

      Se selezioni l'opzione "U2F", il funzionamento dell'autenticazione a due fattori integrata dipenderà dalla specifica FIDO U2F.

      Se selezioni l'opzione "U2F_EXTENDED", l'autenticazione a due fattori integrata fornirà le funzioni U2F più alcune estensioni per la singola attestazione.</translation>
<translation id="7003334574344702284">Se è attiva, questa norma impone l'importazione delle password salvate dal browser predefinito precedente. Se la norma è attiva incide anche sulla finestra di dialogo di importazione. Se non è attiva, le password salvate non vengono importate. Se non viene impostata, all'utente potrebbe essere chiesto se desidera effettuare l'importazione, oppure l'importazione potrebbe avvenire automaticamente.</translation>
<translation id="7003746348783715221">Preferenze di <ph name="PRODUCT_NAME" /></translation>
<translation id="7006788746334555276">Impostazioni contenuti</translation>
<translation id="7007671350884342624">Consente di configurare la directory che <ph name="PRODUCT_NAME" /> utilizza per memorizzare i dati utente.

      Se la norma viene impostata, <ph name="PRODUCT_NAME" /> utilizza la directory fornita, indipendentemente dal fatto che l'utente abbia specificato o meno il flag "--user-data-dir". Per evitare perdite di dati o altri errori imprevisti, la norma non deve essere impostata su una directory radice del volume o su una directory utilizzata per altri scopi, poiché <ph name="PRODUCT_NAME" /> gestisce i relativi contenuti.

      Vai alla pagina https://www.chromium.org/administrators/policy-list-3/user-data-directory-variables per consultare un elenco delle variabili che possono essere utilizzate.

      Se la norma non viene impostata, viene utilizzato il percorso profilo predefinito e l'utente può ignorarla con il flag della riga di comando "--user-data-dir".</translation>
<translation id="7027785306666625591">Configura la gestione dell'alimentazione in <ph name="PRODUCT_OS_NAME" />.

      Queste norme consentono di configurare il comportamento di <ph name="PRODUCT_OS_NAME" /> quando l'utente rimane inattivo per un determinato periodo di tempo.</translation>
<translation id="7040229947030068419">Valore di esempio:</translation>
<translation id="7044883996351280650">Controlla il servizio backup e ripristino di Android</translation>
<translation id="7049373494483449255">Permette di consentire a <ph name="PRODUCT_NAME" /> di inviare documenti da stampare a <ph name="CLOUD_PRINT_NAME" />. NOTA. Questo riguarda soltanto il supporto di <ph name="CLOUD_PRINT_NAME" /> in <ph name="PRODUCT_NAME" />. Non impedisce agli utenti di inviare processi di stampa su siti web. Se questa impostazione viene attivata o non viene configurata, gli utenti potranno stampare con <ph name="CLOUD_PRINT_NAME" /> utilizzando la finestra di dialogo di stampa di <ph name="PRODUCT_NAME" />. Se questa impostazione viene disattivata, gli utenti non potranno stampare con <ph name="CLOUD_PRINT_NAME" /> utilizzando la finestra di dialogo di stampa di <ph name="PRODUCT_NAME" />.</translation>
<translation id="7053678646221257043">Se è attiva, questa norma impone l'importazione dei Preferiti dal browser predefinito corrente. Se la norma è attiva incide anche sulla finestra di dialogo di importazione. Se non è attiva, i Preferiti non vengono importati. Se non viene impostata, all'utente potrebbe essere chiesto se desidera effettuare l'importazione, oppure l'importazione potrebbe avvenire automaticamente.</translation>
<translation id="7063895219334505671">Consenti popup su questi siti</translation>
<translation id="706568410943497889">
      Se la norma è impostata su True, <ph name="PRODUCT_NAME" /> può raccogliere log eventi WebRTC dai servizi Google (ad es., Google Meet) e caricare i log su Google.

      Se la norma è impostata su False o è priva di impostazione, <ph name="PRODUCT_NAME" /> potrebbe non raccogliere né caricare tali log.
      Questi log contengono informazioni di diagnostica utili per il debug dei problemi relativi a chiamate vocali o videochiamate in Chrome, ad esempio data/ora e dimensioni dei pacchetti RTP inviati e ricevuti, feedback sulla congestione della rete, nonché metadati su tempo e qualità dei frame audio e video. Questi log non contengono l'audio o i video delle chiamate.

      Questa raccolta di dati da parte di Chrome può essere attivata soltanto dai servizi web di Google, ad esempio Google Hangouts o Google Meet.

      Google potrebbe associare questi log tramite un ID sessione ad altri log raccolti dal servizio Google stesso al fine di facilitare il debug.
      </translation>
<translation id="706669471845501145">Consenti la visualizzazione di notifiche desktop da parte dei siti</translation>
<translation id="7070525176564511548">Richiedi l'inserimento della password ogni settimana (168 ore)</translation>
<translation id="7072208053150563108">Frequenza di modifica della password del computer</translation>
<translation id="7079519252486108041">Blocca popup su questi siti</translation>
<translation id="7085803328069945025">Consente di impostare un elenco di pattern URL che specificano i siti che possono richiedere all'utente l'accesso al dispositivo USB.

          Se questa norma non viene impostata, per tutti i siti verrà utilizzato il valore predefinito globale della norma "DefaultWebUsbGuardSetting", se impostata, oppure la configurazione personale dell'utente.

          I pattern URL di questa norma non devono essere in conflitto con quelli configurati tramite la norma WebUsbBlockedForUrls. Non viene specificato quale delle due norme debba avere precedenza se un URL presenta corrispondenze con entrambe.</translation>
<translation id="7086677522575756117">Consente di specificare la percentuale di regolazione del ritardo di oscuramento dello schermo quando viene osservata l'attività dell'utente mentre lo schermo è oscurato o subito dopo lo spegnimento dello schermo.

          Se questa norma viene impostata, consente di specificare la percentuale di regolazione del ritardo di oscuramento dello schermo quando viene osservata l'attività dell'utente mentre lo schermo è oscurato o subito dopo lo spegnimento dello schermo. Quando il ritardo di oscuramento viene regolato, i ritardi di spegnimento, blocco e inattività dello schermo vengono regolati per mantenere gli stessi distacchi dal ritardo di oscuramento dello schermo configurato in origine.

          Se questa norma non viene impostata, viene usato un fattore di regolazione predefinito.

          Questa norma viene applicata soltanto se la norma <ph name="POWER_SMART_DIM_ENABLED_POLICY_NAME" /> è disattivata. In caso contrario, questa norma viene ignorata perché il ritardo di oscuramento dello schermo viene stabilito da un modello di machine learning.

          Il fattore di regolazione minimo deve essere 100%.</translation>
<translation id="7106631983877564505">Consente di attivare il blocco quando lo stato dei dispositivi <ph name="PRODUCT_OS_NAME" /> diventa inattivo o sospeso.

      Se questa impostazione viene attivata, agli utenti verrà chiesto di inserire una password per sbloccare il dispositivo dalla sospensione.

      Se questa impostazione viene disattivata, agli utenti non verrà chiesto di inserire una password per sbloccare il dispositivo dalla sospensione.

      Se questa impostazione viene attivata o disattivata, gli utenti non potranno modificarla o eseguirne l'override.

      Se la norma non viene impostata, gli utenti potranno scegliere se impostare o meno la richiesta della password per lo sblocco del dispositivo.</translation>
<translation id="7107148737865880402">Consente di attivare il criterio di gestione dell'energia condivisione dell'alimentazione USB.

          Alcuni dispositivi presentano una specifica porta USB contrassegnata con l'icona di un fulmine o di una batteria e che può essere utilizzata per ricaricare i dispositivi, ad esempio un cellulare, tramite la batteria di sistema. Questo criterio influisce sul comportamento di ricarica della porta mentre il sistema si trova nelle modalità di sospensione o spento. Questo criterio non influisce su altre porte USB e il comportamento di ricarica mentre il sistema è attivo.

          Quando il sistema è attivo, la porta USB fornisce sempre energia.

          Quando il sistema è in modalità di sospensione, se il criterio è impostato su true, verrà fornita energia alla porta USB quando il dispositivo è collegato alla corrente o se il livello della batteria è &gt; 50%. In caso contrario, non viene fornita energia.

          Quando il sistema è spento, se il criterio è impostato su true, viene fornita energia alla porta USB quando il dispositivo è collegato alla corrente. In caso contrario, non viene fornita energia.

          Se questo criterio non viene impostato, il criterio è attivato e non può essere disattivato dall'utente.</translation>
<translation id="7115494316187648452">Consente di stabilire se un processo di <ph name="PRODUCT_NAME" /> è stato avviato all'accesso al sistema operativo e se resta in esecuzione dopo la chiusura dell'ultima finestra del browser, consentendo di tenere attive le applicazioni in background e la sessione di navigazione corrente, compresi eventuali cookie di sessione. Nella barra delle applicazioni viene visualizzata un'icona per il processo in background che consente di chiudere il processo in qualsiasi momento.

      Se questa norma viene impostata su true, la modalità in background viene attivata e non può essere controllata dall'utente tramite le impostazioni del browser.

      Se questa norma viene impostata su false, la modalità in background viene disattivata e non può essere controllata dall'utente tramite le impostazioni del browser.

      Se la norma non viene impostata, la modalità in background viene inizialmente disattivata e può essere controllata dall'utente tramite le impostazioni del browser.</translation>
<translation id="7123160381479171745">Determina l'elenco di utenti autorizzati ad accedere al dispositivo. Le voci sono nel formato <ph name="USER_WHITELIST_ENTRY_FORMAT" />, ad esempio <ph name="USER_WHITELIST_ENTRY_EXAMPLE" />. Per autorizzare utenti arbitrari su un dominio, le voci devono essere nel formato <ph name="USER_WHITELIST_ENTRY_WILDCARD" />.

      Se questa norma non è configurata, non esistono limitazioni su quali utenti sono autorizzati ad accedere. Tieni presente che la creazione di nuovi utenti richiede comunque la corretta configurazione della norma <ph name="DEVICE_ALLOW_NEW_USERS_POLICY_NAME" />.</translation>
<translation id="7123266440503901785"><ph name="PRODUCT_NAME" /> garantisce la sicurezza degli aggiornamenti e dell'installazione delle estensioni. Tuttavia, i contenuti di alcune estensioni ospitate al di fuori del Chrome Web Store potrebbero essere protetti solo dagli accessi non sicuri o da algoritmi di hashing, ad esempio SHA1. Quando questa norma è disattivata, la nuova installazione o gli aggiornamenti di tali estensioni non verranno consentiti da Chrome (finché gli sviluppatori delle estensioni non ricreano le estensioni con algoritmi più efficaci). Se questa norma viene attivata, l'installazione e gli aggiornamenti di queste estensioni saranno concessi.

          Se la norma non è impostata, viene applicato per impostazione predefinita il comportamento previsto dalla norma attiva.
          A partire dalla versione 75 di <ph name="PRODUCT_NAME" />, qualora la norma non fosse impostata, verrà invece applicato per impostazione predefinita il comportamento previsto in caso di norma non attiva.

          A partire dalla versione 77 di <ph name="PRODUCT_NAME" />, questa norma verrà ignorata e considerata come disattivata.</translation>
<translation id="7126716959063786004">Consenti di terminare i processi in Task Manager</translation>
<translation id="7127892035367404455">Rollback alla versione target</translation>
<translation id="7128918109610518786">Consente di elencare gli ID delle applicazioni da visualizzare in <ph name="PRODUCT_OS_NAME" /> sotto forma di applicazioni bloccate nella barra Avvio applicazioni.

Se questa norma viene configurata, il gruppo di applicazioni è fisso e non può essere modificato dagli utenti.

Se questa norma non viene impostata gli utenti possono modificare l'elenco di applicazioni bloccate in Avvio applicazioni.</translation>
<translation id="7132877481099023201">URL a cui verrà concesso l'accesso ai dispositivi di acquisizione video senza richieste</translation>
<translation id="7138678301420049075">Altro</translation>
<translation id="7140629953254369759">Indica a <ph name="PRODUCT_OS_NAME" /> di usare la configurazione del programma di pianificazione delle attività identificato dal nome specificato.

      La norma può essere impostata su "conservativa" e "rendimento", opzioni che selezionano le configurazioni del programma di pianificazione più adatte, rispettivamente, per la stabilità o il massimo rendimento.

      Se la norma non viene impostata, l'utente è libero di fare la propria scelta.</translation>
<translation id="7145335384492396213">Modalità di stampa PIN predefinita</translation>
<translation id="7158064522994309072">Questa norma consente di stabilire i comandi da usare per aprire gli URL in un browser alternativo.

      Se questa norma non viene impostata, viene usata un'impostazione predefinita specifica della piattaforma: Internet Explorer per Windows o Safari per Mac OS X. Su Linux, se questa norma non viene impostata l'avvio del browser alternativo non riesce.

      Se questa norma viene impostata su ${ie}, ${firefox}, ${safari} o ${opera}, verrà avviato il browser corrispondente, se installato. ${ie} è disponibile solo su Windows e ${safari} è disponibile solo su Windows e Mac OS X.

      Se questa norma viene impostata su un percorso file, tale file viene usato come eseguibile.</translation>
<translation id="7167436895080860385">Consenti agli utenti di mostrare le password in Gestione password (ritirata)</translation>
<translation id="7173856672248996428">Profilo temporaneo</translation>
<translation id="717630378807352957">Consenti tutte le stampanti del file di configurazione.</translation>
<translation id="7176721759719212761">Consente di specificare se consentire o meno i wakelock dello schermo. I wakelock dello schermo possono essere richiesti dalle estensioni tramite l'API dell'estensione di gestione dell'alimentazione e dalle app ARC.

          Se questa norma viene impostata su true o non viene impostata, i wakelock dello schermo verranno rispettati per la gestione dell'alimentazione, a meno che la norma AllowWakeLocks sia impostata su false.

          Se questa norma viene impostata su false, le richieste di wakelock dello schermo verranno retrocesse a richieste di wakelock di sistema.</translation>
<translation id="7177857088692019405">Sblocco rapido</translation>
<translation id="7185078796915954712">TLS 1.3</translation>
<translation id="718956142899066210">Tipi di connessioni consentiti per gli aggiornamenti</translation>
<translation id="7194407337890404814">Nome del provider di ricerca predefinito</translation>
<translation id="7199304109870655950">Configura le opzioni di accesso remoto nell'host Chrome Remote Desktop.

      L'host Chrome Remote Desktop è un servizio nativo che viene eseguito sul computer di destinazione a cui l'utente può collegarsi utilizzando l'applicazione Chrome Remote Desktop.  Il servizio nativo viene pacchettizzato ed eseguito separatamente dal browser <ph name="PRODUCT_NAME" />.

      Queste norme vengono ignorate a meno che
      non sia installato l'host Chrome Remote Desktop.</translation>
<translation id="7202925763179776247">Consenti limitazioni dei download</translation>
<translation id="7207095846245296855">Forza il filtro SafeSearch di Google</translation>
<translation id="7211368186050418507">Non rilevare mai automaticamente il fuso orario</translation>
<translation id="7216442368414164495">Consenti agli utenti di attivare i rapporti estesi di Navigazione sicura</translation>
<translation id="7221822638060296742">Ti consente di stabilire se permettere o meno ai siti web di eseguire automaticamente il plug-in <ph name="FLASH_PLUGIN_NAME" />. L'esecuzione automatica del plug-in <ph name="FLASH_PLUGIN_NAME" /> può essere consentita o vietata per tutti i siti web.

          L'opzione Click to play consente di eseguire il plug-in <ph name="FLASH_PLUGIN_NAME" />, ma l'utente deve fare clic sul segnaposto per avviare l'esecuzione.

          La riproduzione automatica è consentita soltanto per i domini elencati esplicitamente nella norma <ph name="PLUGINS_ALLOWED_FOR_URLS_POLICY_NAME" />. Se vuoi attivare la riproduzione automatica per tutti i siti, potresti aggiungere http://* e https://* a questo elenco.

          Se questa norma non viene impostata, l'utente potrà cambiare manualmente questa impostazione.</translation>
<translation id="7229975860249300121">Contiene un'espressione regolare che viene usata per stabilire quali Account Google possono essere impostati come account principali del browser in <ph name="PRODUCT_NAME" /> (ossia l'account che viene scelto durante la procedura di attivazione della sincronizzazione).

      Viene visualizzato un errore appropriato se un utente cerca di impostare un account principale del browser con un nome utente non corrispondente allo schema indicato.

      Se questa norma non viene impostata o viene lasciata vuota, l'utente potrà impostare qualsiasi Account Google come account principale del browser in <ph name="PRODUCT_NAME" />.</translation>
<translation id="723103540848640830">Imposta la lunghezza minima del PIN per la schermata di blocco</translation>
<translation id="7232816984286843471">Se la norma viene impostata su False, gli utenti non affiliati non potranno usare Crostini.

      Se la norma non viene impostata o viene impostata su True, tutti gli utenti potranno utilizzare Crostini, a patto che anche le altre impostazioni lo permettano.
      Le tre norme, VirtualMachinesAllowed, CrostiniAllowed e DeviceUnaffiliatedCrostiniAllowed devono essere impostate su True affinché Crostini possa essere eseguito.
      Quando l'impostazione di questa norma viene modificata in False, la norma viene applicata all'avvio di nuovi contenitori Crostini, ma non determina l'arresto dei contenitori già in esecuzione.</translation>
<translation id="7234280155140786597">Nomi degli host di messaggi nativi vietati (o * per indicarli tutti)</translation>
<translation id="7236775576470542603">Consente di impostare il tipo di ingrandimento dello schermo predefinito che viene attivato nella schermata di accesso.

Se questa norma viene impostata consente di controllare il tipo di ingrandimento dello schermo che viene attivato quando viene visualizzata la schermata di accesso. L'impostazione della norma su "None" consente di disattivare l'ingrandimento dello schermo.

Se la norma viene impostata, gli utenti possono ignorarla temporaneamente attivando o disattivando l'ingrandimento dello schermo. La scelta dell'utente non è però permanente e viene ripristinato il valore predefinito quando viene visualizzata di nuovo la schermata di accesso o quando l'utente rimane inattivo nella schermata di accesso per un minuto.

Se la norma non viene impostata, l'ingrandimento dello schermo viene disattivato alla prima visualizzazione della schermata di accesso. Gli utenti possono attivare o disattivare l'ingrandimento dello schermo in qualsiasi momento e il relativo stato nella schermata di accesso persiste per tutti gli utenti.</translation>
<translation id="7249828445670652637">Attiva i certificati CA <ph name="PRODUCT_OS_NAME" /> per le app ARC</translation>
<translation id="7252681704926980614">Invia nome utente e nome file al server delle stampanti native per ogni processo di stampa. L'impostazione predefinita non prevede l'invio.

      Se imposti questa norma su true disattivi le stampanti che usano protocolli diversi da IPPS, USB o IPP-over-USB poiché il nome utente e il nome file non devono essere inviati nella rete in modo esplicito.</translation>
<translation id="7258823566580374486">Attiva separazione degli host di accesso remoto</translation>
<translation id="7260204423892780600">Consente di gestire le impostazioni dell'Assistente Google.</translation>
<translation id="7260277299188117560">Aggiornamento automatico p2p attivato</translation>
<translation id="7261252191178797385">Immagine di sfondo del dispositivo</translation>
<translation id="7264704483008663819">Questa norma è stata ritirata in M68; usa la norma DeveloperToolsAvailability.

      Consente di disattivare gli Strumenti per sviluppatori e la console JavaScript.

      Se questa impostazione viene attivata, gli Strumenti per sviluppatori non saranno accessibili e non sarà più possibile esaminare gli elementi del sito web. Le eventuali scorciatoie da tastiera e le voci dei menu contestuali o di altri menu che consentono di aprire gli Strumenti per sviluppatori o la console JavaScript verranno disattivate.

      Se questa opzione viene disattivata o non viene impostata sarà possibile utilizzare gli Strumenti per sviluppatori e la console JavaScript.

      Se la norma DeveloperToolsAvailability viene impostata, il valore della norma DeveloperToolsDisabled viene ignorato.</translation>
<translation id="7266471712301230894">Questa norma è stata rimossa a partire dalla versione 64 di <ph name="PRODUCT_NAME" />.

      La ricerca e l'installazione automatiche dei plug-in mancanti non sono più supportate.</translation>
<translation id="7267809745244694722">Per impostazione predefinita, i tasti multimediali si comportano come tasti funzione.</translation>
<translation id="7271085005502526897">Importazione della home page dal browser predefinito alla prima esecuzione</translation>
<translation id="7273823081800296768">Se questa impostazione viene attivata o non viene configurata, gli utenti possono decidere di accoppiare client e host in fase di connessione, evitando di dover inserire un codice PIN ogni volta.

Se l'impostazione viene disattivata, questa funzione non sarà disponibile.</translation>
<translation id="7274077256421167535">Attiva la condivisione dell'alimentazione USB</translation>
<translation id="7275334191706090484">Preferiti gestiti</translation>
<translation id="7291084543582732020">Se attivi questa impostazione, gli utenti potranno utilizzare la funzione Smart Lock se ne vengono soddisfatti i requisiti.

      Se disattivi l'impostazione, gli utenti non potranno utilizzare Smart Lock.

      Se questa norma non è impostata, per impostazione predefinita la funzione non è consentita per gli utenti gestiti dall'azienda ed è consentita per gli utenti non gestiti.</translation>
<translation id="7295019613773647480">Attiva utenti supervisionati</translation>
<translation id="7301543427086558500">Specifica un elenco di URL alternativi che possono essere utilizzati per estrarre termini di ricerca dal motore di ricerca. Gli URL devono contenere la stringa <ph name="SEARCH_TERM_MARKER" />, che verrà utilizzata per estrarre i termini di ricerca.

          Questa norma è facoltativa. Se non è impostata, non verrà utilizzato alcun URL alternativo per estrarre i termini di ricerca.

          Questa norma viene rispettata solo se è attiva la norma "DefaultSearchProviderEnabled".</translation>
<translation id="7302043767260300182">Ritardo blocco schermo in caso di utilizzo di CA</translation>
<translation id="7311458740754205918">Se questa norma viene impostata su true o non viene impostata, nella pagina Nuova scheda potrebbero essere mostrati suggerimenti di contenuti basati sulla cronologia di navigazione, sugli interessi o sulla posizione dell'utente.

      Se viene impostata su false, i suggerimenti di contenuti generati automaticamente non vengono mostrati nella pagina Nuova scheda.</translation>
<translation id="7313793931637495417">Questa norma consente di stabilire se segnalare o meno informazioni sulla versione, ad esempio la versione del sistema operativo, la piattaforma e l'architettura del sistema operativo, la versione di <ph name="PRODUCT_NAME" /> e il canale di <ph name="PRODUCT_NAME" />.

      Se questa norma non viene impostata o viene impostata su True, le informazioni sulla versione vengono raccolte.
      Se questa norma viene impostata su False, le informazioni sulla versione non vengono raccolte.

      Questa norma viene applicata soltanto se viene attivata l'estensione <ph name="CHROME_REPORTING_EXTENSION_NAME" /> e il computer viene registrato con la norma <ph name="MACHINE_LEVEL_USER_CLOUD_POLICY_ENROLLMENT_TOKEN_POLICY_NAME" />.</translation>
<translation id="7323896582714668701">Parametri aggiuntivi della riga di comando per <ph name="PRODUCT_NAME" /></translation>
<translation id="7326394567531622570">Simile a Wipe (valore 2), ma prova a mantenere i token di accesso per evitare all'utente di dover accedere di nuovo.</translation>
<translation id="7329842439428490522">Consente di specificare il periodo di tempo senza input dell'utente trascorso il quale lo schermo viene disattivato quando viene utilizzata la batteria.

Se questa norma viene impostata su un valore maggiore di zero, consente di specificare il periodo di tempo per cui l'utente deve rimanere inattivo prima che <ph name="PRODUCT_OS_NAME" /> disattivi lo schermo.

Se questa norma viene impostata su zero, <ph name="PRODUCT_OS_NAME" /> non disattiva lo schermo quando l'utente diventa inattivo.

Se questa norma non viene impostata, viene utilizzato un periodo di tempo predefinito.

Il valore della norma deve essere specificato in millisecondi. I valori devono essere inferiori o uguali al ritardo di inattività.</translation>
<translation id="7329968046053403405">Consente di specificare il tipo di account degli account forniti dall'app di autenticazione di Android che supporta l'autenticazione <ph name="HTTP_NEGOTIATE" /> (ad esempio, l'autenticazione Kerberos). Queste informazioni dovrebbero essere messe a disposizione dal fornitore dell'app di autenticazione. Per ulteriori informazioni, visitare la pagina https://goo.gl/hajyfN.

          Se non vengono fornite impostazioni, l'autenticazione <ph name="HTTP_NEGOTIATE" /> è disattivata su Android.</translation>
<translation id="7331962793961469250">Quando la norma è impostata su True, le promozioni relative alle applicazioni del Chrome Web Store non vengono visualizzate nella pagina Nuova scheda. Se questa opzione viene impostata su False o non viene impostata, le promozioni relative alle applicazioni del Chrome Web Store vengono visualizzate nella pagina Nuova scheda.</translation>
<translation id="7332963785317884918">Questa norma è obsoleta. <ph name="PRODUCT_OS_NAME" /> utilizzerà sempre la strategia di pulizia "RemoveLRU".

      Consente di stabilire il comportamento di pulizia automatica sui dispositivi <ph name="PRODUCT_OS_NAME" />. La pulizia automatica viene attivata per recuperare spazio quando la quantità di spazio libero su disco raggiunge un livello critico.

      Se questa norma viene impostata su "RemoveLRU", la pulizia automatica continua a rimuovere utenti dal dispositivo in ordine di accesso meno recente fino a liberare spazio a sufficienza.

      Se questa norma viene impostata su "RemoveLRUIfDormant", la pulizia automatica continua a rimuovere gli utenti che non hanno eseguito l'accesso negli ultimi tre mesi in ordine di accesso meno recente fino a liberare spazio a sufficienza.

      Se questa norma non viene impostata, la pulizia automatica utilizza la strategia incorporata predefinita, che al momento è "RemoveLRUIfDormant".</translation>
<translation id="7336785017449297672">Consente di gestire le impostazioni relative all'orologio e al fuso orario.</translation>
<translation id="7336878834592315572">Conserva cookie per tutta la durata della sessione</translation>
<translation id="7339315111520512972">Forza l'esecuzione del codice di networking nel processo di browser</translation>
<translation id="7340034977315324840">Indicazione tempi di attività del dispositivo</translation>
<translation id="7343497214039883642">File di configurazione delle stampanti aziendali per i dispositivi</translation>
<translation id="735902178936442460">Questa norma consente di stabilire se segnalare o meno informazioni che possono essere usate per identificare i computer, ad esempio il nome del computer e gli indirizzi di rete.

      Se questa norma non viene impostata o viene impostata su True, vengono raccolte le informazioni che possono essere usate per identificare i computer.
      Se questa norma viene impostata su False, non vengono raccolte le informazioni che possono essere usate per identificare i computer.

      Questa norma viene applicata soltanto se viene attivata l'estensione <ph name="CHROME_REPORTING_EXTENSION_NAME" /> e il computer viene registrato con la norma <ph name="MACHINE_LEVEL_USER_CLOUD_POLICY_ENROLLMENT_TOKEN_POLICY_NAME" />.</translation>
<translation id="737655323154569539">Consente di limitare le dimensioni delle pagine di stampa. Se la norma non viene impostata o viene lasciata vuota non vengono applicate limitazioni.</translation>
<translation id="7389872682701720082">Se attivi questa impostazione, i plug-in non obsoleti verranno sempre eseguiti.

      Se questa impostazione è disattivata o non è configurata, agli utenti verrà chiesta l'autorizzazione di eseguire i plug-in per i quali è necessaria. Questi sono plug-in che possono compromettere la sicurezza.</translation>
<translation id="7417972229667085380">Percentuale di regolazione del ritardo di inattività in modalità di presentazione (obsoleta)</translation>
<translation id="7421483919690710988">Imposta le dimensioni della cache su disco multimediale in byte</translation>
<translation id="7424751532654212117">Elenco delle eccezioni all'elenco dei plug-in disattivati</translation>
<translation id="7426112309807051726">Consente di specificare se disattivare o meno l'ottimizzazione <ph name="TLS_FALSE_START" />. Il nome di questa norma è DisableSSLRecordSplitting per motivi storici.

      Se la norma non viene impostata, o viene impostata su false, l'ottimizzazione <ph name="TLS_FALSE_START" /> viene attivata. Se viene impostata su true, l'ottimizzazione <ph name="TLS_FALSE_START" /> viene disattivata.</translation>
<translation id="7433714841194914373">Abilita Instant</translation>
<translation id="7434202861148928348">Configura i nomi di dominio richiesti per i client di accesso remoto</translation>
<translation id="7443616896860707393">Richieste di autenticazione di base HTTP tra origini</translation>
<translation id="7458437477941640506">Non eseguire il rollback alla versione target se la versione del sistema operativo è più nuova del target. Anche gli aggiornamenti sono disattivati.</translation>
<translation id="7464991223784276288">Limita i cookie degli URL corrispondenti alla sessione corrente</translation>
<translation id="7469554574977894907">Attiva suggerimenti di ricerca</translation>
<translation id="7485481791539008776">Regole di selezione della stampante predefinita</translation>
<translation id="7485730741952775732">Se questa norma è impostata, l'host di accesso remoto utilizzerà questo URL per convalidare i token di autenticazione dai client di accesso remoto per accettare connessioni. Deve essere usata insieme a RemoteAccessHostTokenUrl.

          Questa funzione è attualmente disattivata lato server.</translation>
<translation id="749556411189861380">Consente di indicare la versione del sistema operativo e del firmware dei dispositivi registrati. Se questa impostazione non è impostata o viene impostata su True, i dispositivi registrati indicheranno periodicamente la versione del sitema operativo e del firmware. Se l'impostazione viene impostata su False, le informazioni sulla versione non verranno indicate.</translation>
<translation id="7498946151094347510">Consente di specificare le stampanti non utilizzabili dagli utenti.

      Questa norma viene usata soltanto se viene selezionata l'opzione <ph name="PRINTERS_BLACKLIST" /> per la norma <ph name="DEVICE_PRINTERS_ACCESS_MODE" />.

      Se viene usata questa norma, gli utenti avranno a disposizione tutte le stampanti tranne quelle i cui ID sono elencati in questa norma. Gli ID devono corrispondere ai campi "id" o "guid" del file specificato nella norma <ph name="DEVICE_PRINTERS_POLICY" />.
      </translation>
<translation id="7506269062143646163">Consente di attivare il supporto per Signed HTTP Exchange (SXG).

          Se questa norma non è impostata o viene attivata, Google Chrome accetterà i contenuti web pubblicati come Signed HTTP Exchanges.

          Se non viene attivata, i contenuti Signed HTTP Exchanges non potranno essere caricati.</translation>
<translation id="7511361072385293666">Se questa norma viene impostata su true o non viene impostata, l'utilizzo del protocollo QUIC in <ph name="PRODUCT_NAME" /> è consentito.
     Se questa norma viene impostata su false, l'utilizzo del protocollo QUIC non è consentito.</translation>
<translation id="7517845714620372896">Consente di specificare la percentuale di luminosità dello schermo.
          Se questa norma viene impostata, la luminosità dello schermo iniziale viene regolata in base al valore della norma, ma l'utente potrà cambiare tale valore in un secondo momento. Le funzionalità relative alla luminosità automatica vengono disattivate.
          Se questa norma non viene impostata, i controlli dello schermo dell'utente e le funzionalità di luminosità automatica rimangono invariati.
          I valori della norma devono essere specificati in percentuali comprese tra 0 e 100.</translation>
<translation id="7517846421386644905">Permette di consentire a un amministratore di stabilire se i dati telemetrici e diagnostici devono essere raccolti, trattati e segnalati dal controller DTC (Diagnostics and Telemetry Controller) wilco.

      Se la norma viene impostata su false o non viene impostata, il controller DTC viene spento e non raccoglie, tratta e segnala dati telemetrici e diagnostici dal dispositivo.
      Se sul dispositivo è disponibile il controller DTC wilco e la norma viene impostata su true, vengono attivati la raccolta, il trattamento e la segnalazione di dati telemetrici e diagnostici.</translation>
<translation id="7519251620064708155">Consenti la generazione di chiavi su questi siti</translation>
<translation id="7529100000224450960">Consente di impostare un elenco di pattern URL che specificano i siti in cui è consentita l'apertura dei popup. Se questa norma non viene impostata, per tutti i siti verrà utilizzato il valore predefinito globale della norma "DefaultPopupsSetting", se è impostata, oppure verrà utilizzata la configurazione personale dell'utente.</translation>
<translation id="7529144158022474049">Fattore di dispersione aggiornamento automatico</translation>
<translation id="7534199150025803530">Questa norma non influisce sull'app Google Drive per Android. Se vuoi impedire l'utilizzo di Google Drive tramite rete cellulare, non devi consentire l'installazione dell'app Google Drive per Android.</translation>
<translation id="7540622499178214923">Permette di consentire l'uso del controller DTC (Diagnostics and Telemetry Controller) wilco</translation>
<translation id="7547549430720182663">Unisci</translation>
<translation id="7553535237300701827">Se viene impostata questa norma, il flusso di autenticazione dell'accesso sarà uno dei seguenti, a seconda del valore dell'impostazione:

      Se la norma viene impostata su GAIA, l'accesso verrà eseguito tramite il normale flusso di autenticazione GAIA.

      Se viene impostata su SAML_INTERSTITIAL, durante l'accesso verrà mostrata una schermata interstitial che consentirà all'utente di procedere con l'autenticazione tramite l'IdP SAML del dominio di registrazione del dispositivo oppure di tornare al normale flusso di accesso GAIA.</translation>
<translation id="755951849901630953">Se questa norma non viene impostata o viene impostata su True, consente gli aggiornamenti di tutti i componenti di <ph name="PRODUCT_NAME" />.

      Se viene impostata su False, gli aggiornamenti dei componenti vengono disattivati. Tuttavia, alcuni componenti sono esclusi da questa norma: gli aggiornamenti dei componenti che non contengono codice eseguibile, che non alterano in modo significativo il comportamento del browser o che sono fondamentali per la sicurezza non vengono disattivati.
      Esempi di tali componenti sono gli elenchi di revoche di certificati e i dati di Navigazione sicura.
      Visita il sito https://developers.google.com/safe-browsing per avere ulteriori informazioni sulla funzione Navigazione sicura.</translation>
<translation id="7566878661979235378">Tipo di autenticazione per gli accessi SAML</translation>
<translation id="757395965347379751">Quando questa impostazione è attivata, <ph name="PRODUCT_NAME" /> consente l'utilizzo dei certificati SHA-1 firmati che sono convalidati e concatenati a certificati CA installati localmente.

      Considera che questa norma dipende dallo stack di verifica dei certificati del sistema operativo che autorizza le firme SHA-1. Se un aggiornamento del sistema operativo modifica la gestione dei certificati SHA-1 da parte del sistema operativo, la norma potrebbe non essere più valida. Inoltre, questa norma è da considerarsi come soluzione alternativa temporanea per concedere alle aziende più tempo per l'abbandono della crittografia SHA-1. Questa norma verrà rimossa il 1° gennaio 2019 o intorno a quella data.

      Se questa norma non viene impostata o se viene impostata su false, <ph name="PRODUCT_NAME" /> seguirà il programma di ritiro della crittografia SHA-1 pubblicamente annunciato.</translation>
<translation id="7578049687634719313">Questa norma consente di stabilire quanto attendere prima di avviare un browser alternativo, in millisecondi.

      Se la norma non è impostata o viene impostata su 0, navigare a un URL designato ne comporta subito l'apertura in un browser alternativo.

      Se la norma viene impostata su un numero, Chrome mostra un messaggio per quel numero di millisecondi, quindi apre il browser alternativo.</translation>
<translation id="7593523670408385997">Consente di configurare le dimensioni della cache che verranno utilizzate da <ph name="PRODUCT_NAME" /> per archiviare sul disco i file memorizzati nella cache.

Se questa norma viene impostata, <ph name="PRODUCT_NAME" /> utilizzerà le dimensioni della cache indicate a prescindere dalla specifica o meno da parte dell'utente del flag "--disk-cache-size". Il valore specificato in questa norma non è un limite rigido ma un suggerimento per il sistema di memorizzazione nella cache. I valori inferiori ad alcuni megabyte sono troppo piccoli e verranno arrotondati a un valore minimo ragionevole.

Se il valore di questa norma è 0, verranno utilizzate le dimensioni della cache predefinite, che l'utente non potrà modificare.

Se questa norma non viene impostata, verranno utilizzate le dimensioni predefinite, che l'utente potrà sostituire con il flag --disk-cache-size.</translation>
<translation id="759389052790680884">Consente di impostare il valore personalizzato espresso in percentuale raggiunto il quale la batteria interrompe la ricarica.

          La batteria smette di caricarsi quando raggiunge il valore di interruzione della ricarica personalizzato.

          DeviceBatteryChargeCustomStartCharging deve essere inferiore a DeviceBatteryChargeCustomStopCharging.

          Questo criterio viene utilizzato unicamente quando DeviceBatteryChargeMode è impostato su personalizzato.

          Se questo criterio non è configurato o non è impostato, verrà applicata la modalità di ricarica standard della batteria.</translation>
<translation id="759957074386651883">Impostazioni di Navigazione sicura</translation>
<translation id="7604169113182304895">Le app Android potrebbero decidere volontariamente se rispettare o meno questo elenco. Non è possibile imporre il rispetto dell'elenco.</translation>
<translation id="7612157962821894603">Contrassegni a livello di sistema da applicare all'avvio di <ph name="PRODUCT_NAME" /></translation>
<translation id="7614663184588396421">Elenco degli schemi di protocollo disabilitati</translation>
<translation id="7617319494457709698">Questa norma consente di specificare le estensioni autorizzate a usare la funzione <ph name="CHALLENGE_USER_KEY_FUNCTION" /> dell'<ph name="ENTERPRISE_PLATFORM_KEYS_API" /> per l'attestazione da remoto. Le estensioni devono essere aggiunte a questo elenco per utilizzare l'API.

          Se un'estensione non è presente nell'elenco o l'elenco non è impostato, la chiamata all'API non va a buon fine e viene generato un codice di errore.</translation>
<translation id="7618907117929117943">Esegui il rollback e rimani nella versione target se la versione del sistema operativo è più recente di quella target ed è possibile trasferire la configurazione a livello di dispositivo (incluse le credenziali di rete) tramite il rollback, saltando anche l'OOBE dopo il rollback. Non eseguire o interrompere il rollback se non è possibile (perché la versione target non supporta il ripristino dei dati o a causa di una modifica non compatibile con le versioni precedenti).
          Supportato su <ph name="PRODUCT_OS_NAME" /> 70 e versioni successive. Per i client precedenti, questo valore indica che il rollback è disattivato.</translation>
<translation id="7620869951155758729">Questa norma consente di specificare la configurazione utilizzata per generare e verificare il codice di accesso genitori.

      La configurazione |current_config| viene sempre utilizzata per generare un codice di accesso e deve essere utilizzata per convalidare il codice di accesso solo quando non può essere convalidato con |future_config|.
     La configurazione |future_config| è la configurazione principale utilizzata per la convalida del codice di accesso.
      La configurazione |old_configs| deve essere utilizzata per convalidare il codice di accesso quando non può essere convalidato né con |future_config| né con |current_config|.

      La modalità di utilizzo prevista per questa norma consiste nella rotazione graduale della configurazione del codice di accesso. La nuova configurazione è sempre all'interno di |future_config| e allo stesso
      tempo il valore esistente viene spostato in |current_config|. I valori precedenti della configurazione |current_config| vengono spostati all'interno di |old_configs| e rimossi al termine del ciclo di rotazione.

      Questa norma viene applicata solo agli utenti che sono bambini o ragazzi.
      Quando questa norma è impostata, il codice di accesso genitori può essere verificato sul dispositivo dell'utente bambino o ragazzo.
      Quando questa norma non è impostata, non è possibile verificare il codice di accesso genitori sul dispositivo dell'utente bambino o ragazzo.</translation>
<translation id="7625444193696794922">Consente di specificare il canale di rilascio su cui deve essere bloccato questo dispositivo.</translation>
<translation id="7632724434767231364">Nome della libreria GSSAPI</translation>
<translation id="7635471475589566552">Consente di configurare in <ph name="PRODUCT_NAME" /> le impostazioni della lingua e di impedirne la modifica agli utenti. Se attivi questa impostazione, <ph name="PRODUCT_NAME" /> utilizzerà le impostazioni della lingua specificate. Se la lingua configurata non è supportata, verrà utilizzata la lingua "en-US". Se questa impostazione viene disattivata o non viene impostata, <ph name="PRODUCT_NAME" /> utilizzerà la lingua preferita specificata dall'utente (se configurata), quella del sistema o la lingua di riserva "en-US".</translation>
<translation id="7641363659597330616">Consente di configurare i tipi di download che verranno completamente bloccati in <ph name="PRODUCT_NAME" />; gli utenti non potranno ignorare la decisione di sicurezza.

      Se questa norma viene impostata, <ph name="PRODUCT_NAME" /> impedirà tipi specifici di download e non permetterà agli utenti di aggirare gli avvisi di sicurezza.

      Se viene selezionata l'opzione "Blocca download pericolosi", sono consentiti tutti i download, tranne quelli per cui vengono visualizzati gli avvisi di Navigazione sicura.

      Se viene selezionata l'opzione "Blocca download potenzialmente pericolosi", sono consentiti tutti i download, tranne quelli per cui vengono visualizzati gli avvisi di Navigazione sicura che segnalano la potenziale pericolosità di tali download.

      Se viene selezionata l'opzione "Blocca tutti i download", vengono bloccati tutti i download.

      Se questa norma non viene impostata (o se viene selezionata l'opzione "Nessuna limitazione speciale"), i download saranno sottoposti alle normali limitazioni per la sicurezza in base ai risultati dell'analisi di Navigazione sicura.

      È importante tenere presente che tali limitazioni vengono applicate ai download attivati dai contenuti delle pagine web, nonché all'opzione del menu contestuale "scarica link...". Tali limitazioni non vengono applicate al salvataggio o al download della pagina visualizzata né all'opzione di stampa relativa al salvataggio in PDF.

      Visita il sito https://developers.google.com/safe-browsing per avere ulteriori informazioni sulla funzione Navigazione sicura.</translation>
<translation id="7643883929273267746">Limita gli account visibili in <ph name="PRODUCT_NAME" /></translation>
<translation id="7644825865811580663">Se questa norma è impostata su true, <ph name="PRODUCT_NAME" /> ingrandirà senza condizioni la prima finestra mostrata alla prima esecuzione.
      Se la norma viene impostata su false o non viene configurata, verrà deciso se ingrandire o meno la prima finestra mostrata in base alle dimensioni dello schermo.</translation>
<translation id="7651739109954974365">È possibile stabilire se attivare o meno il roaming dei dati per il dispositivo. Se la norma viene impostata su true, il roaming dei dati sarà consentito. Se non viene configurata o viene impostata su false, il roaming dei dati non sarà disponibile.</translation>
<translation id="7657261947024629645">Ottimizza per ottenere il massimo rendimento.</translation>
<translation id="7673194325208122247">Periodo di tempo (millisecondi)</translation>
<translation id="7676708657861783864">I cookie impostati da pagine che corrispondono a questi pattern URL saranno limitati alla sessione corrente, vale a dire che verranno eliminati alla chiusura del browser.

          Per gli URL non coperti dai pattern specificati qui, o per tutti gli URL, se questa norma non viene impostata, verrà utilizzato il valore predefinito globale della norma "DefaultCookiesSetting", se è impostata, oppure verrà utilizzata la configurazione personale dell'utente.

           Tieni presente che se <ph name="PRODUCT_NAME" /> è in esecuzione in "modalità background", è possibile che la sessione non si chiuda quando viene chiusa l'ultima finestra del browser, ma che rimanga attiva fino alla chiusura del browser. Consulta la norma "BackgroundModeEnabled" per ulteriori informazioni sulla configurazione di questo comportamento.

          Vedi anche le norme "CookiesAllowedForUrls" e "CookiesBlockedForUrls". Tieni presente che non ci deve essere conflitto di pattern URL tra queste tre norme. Non viene specificato quale norma debba avere la precedenza.

          Se la norma "RestoreOnStartup" viene impostata in modo da ripristinare gli URL delle sessioni precedenti, questa norma non verrà rispettata e i cookie verranno memorizzati in modo permanente per i siti.</translation>
<translation id="7683777542468165012">Aggiornamento dinamico delle norme</translation>
<translation id="7687943045976362719">Se questa norma viene impostata, i tipi di contenuto specificati vengono gestiti da <ph name="PRODUCT_FRAME_NAME" />.

          Se la norma non viene impostata, verrà utilizzato per tutti i siti il renderer predefinito. (È possibile utilizzare la norma <ph name="CHROME_FRAME_RENDERER_SETTINGS_POLICY_NAME" /> per configurare il renderer predefinito).</translation>
<translation id="7694807474048279351">Consente di pianificare un riavvio automatico in seguito all'applicazione di un aggiornamento di <ph name="PRODUCT_OS_NAME" />.

Se questa norma viene impostata su true, viene pianificato un riavvio automatico in seguito all'applicazione di un aggiornamento di <ph name="PRODUCT_OS_NAME" /> e quando è necessario un riavvio per completare la procedura di aggiornamento. Il riavvio viene programmato subito ma potrebbe essere ritardato sul dispositivo di massimo 24 ore se un utente sta utilizzando il dispositivo.


Se la norma viene impostata su false, non vengono programmati riavvii automatici in seguito all'applicazione di un aggiornamento di <ph name="PRODUCT_OS_NAME" />. La procedura di aggiornamento viene completata al successivo riavvio del dispositivo.

Se la norma viene impostata gli utenti non potranno modificarla o ignorarla.

Nota. Attualmente i riavvii automatici vengono attivati soltanto durante la visualizzazione della schermata di accesso o durante una sessione di un'app kiosk. Questo comportamento cambierà in futuro e la norma sarà sempre valida, a prescindere dal fatto che sia in corso o meno una sessione di tipo specifico.</translation>
<translation id="7701341006446125684">Imposta le dimensioni della cache di app ed estensioni (in byte)</translation>
<translation id="7709537117200051035">Un dizionario che mappa i nomi host su un flag booleano che specifica se l'accesso all'host deve essere consentito (true) oppure bloccato (false).

          Questa norma è per uso interno di <ph name="PRODUCT_NAME" />.</translation>
<translation id="7712109699186360774">Chiedi ogni volta che un sito vuole accedere alla fotocamera e/o al microfono</translation>
<translation id="7713608076604149344">Limitazioni dei download</translation>
<translation id="7715711044277116530">Percentuale di regolazione del ritardo di oscuramento dello schermo in modalità di presentazione</translation>
<translation id="7716781462866245042">Consente di impostare la modalità di configurazione giornaliera per la ricarica avanzata della batteria.

          Questo criterio viene utilizzato solo se l'opzione DevicePowerPeakShiftEnabled è impostata su true.

          Se questo criterio non è configurato o non è impostato, la modalità di ricarica avanzata della batteria sarà sempre disattivata.

          Nota: <ph name="CHARGE_START_TIME_FIELD_NAME" /> deve essere inferiore a <ph name="CHARGE_END_TIME_FIELD_NAME" />.

          Nota: i valori consentiti per il campo <ph name="MINUTE_FIELD_NAME" /> in <ph name="CHARGE_START_TIME_FIELD_NAME" /> e <ph name="CHARGE_END_TIME_FIELD_NAME" /> sono 0, 15, 30, 45.</translation>
<translation id="7717938661004793600">Configura le funzioni di accessibilità di <ph name="PRODUCT_OS_NAME" />.</translation>
<translation id="7724994675283793633">La norma consente di attivare HTTP/0.9 sulle porte diverse da 80 per HTTP e 443 per HTTPS.

      Per impostazione predefinita, la norma è disattivata e, se attivata, espone gli utenti al problema di sicurezza https://crbug.com/600352.

      La norma è pensata per dare alle aziende la possibilità di eseguire la migrazione dei server esistenti da HTTP/0.9 e in futuro sarà rimossa.

      Se la norma non viene impostata, HTTP/0.9 sarà disattivato sulle porte non predefinite.</translation>
<translation id="7747447585227954402">Consenti ai dispositivi di usare <ph name="PLUGIN_VM_NAME" /> su <ph name="PRODUCT_OS_NAME" /></translation>
<translation id="7749402620209366169">Consente di abilitare l'autenticazione a due fattori per gli host di accesso remoto invece di un PIN specificato dall'utente.

          Se questa impostazione è abilitata, gli utenti devono fornire un codice valido a due fattori quando accedono a un host.

          Se questa impostazione è disabilitata o non è impostata, l'autenticazione a due fattori non sarà attiva e verrà utilizzato il comportamento predefinito che prevede l'uso di un PIN definito dall'utente.</translation>
<translation id="7750991880413385988">Apri pagina Nuova scheda</translation>
<translation id="7754704193130578113">Chiedi dove salvare il file prima di scaricarlo</translation>
<translation id="7761446981238915769">Configura l'elenco di app installate nella schermata di accesso</translation>
<translation id="7763479091692861127"> I tipi di connessioni utilizzabili per aggiornamenti del sistema operativo. Gli aggiornamenti del sistema operativo possono mettere a dura prova la connessione a causa delle loro dimensioni e potrebbero generare costi aggiuntivi. Pertanto, per impostazione predefinita non sono abilitati per i tipi di connessione che sono considerati costosi, fra cui WiMax, Bluetooth e cellulare, al momento.

      Gli identificatori dei tipi di connessione riconosciuti sono "ethernet", "wifi", "wimax", "bluetooth" e "cellulare".</translation>
<translation id="7763614521440615342">Mostra suggerimenti di contenuti nella pagina Nuova scheda</translation>
<translation id="7765879851993224640">Consenti l'uso dell'accesso tramite Smart Lock.</translation>
<translation id="7772346342637974431">Consente di specificare il periodo di tempo senza immissioni da parte dell'utente dopo il quale viene mostrata una finestra di dialogo di avviso quando il computer è alimentato tramite batteria.

          Quando è impostata, questa norma specifica per quanto tempo l'utente deve rimanere inattivo prima che <ph name="PRODUCT_OS_NAME" /> mostri una finestra di dialogo di avviso in cui comunica all'utente che sta per essere intrapresa l'azione richiesta in caso di inattività.

          Quando questa norma non è impostata, non viene visualizzata alcuna finestra di dialogo di avviso.

          Il valore della norma deve essere specificato in millisecondi. I valori sono fissati in modo da essere minori o uguali al ritardo di inattività.

          L'avviso viene mostrato solo se l'azione richiesta in caso di inattività è la disconnessione o lo spegnimento.</translation>
<translation id="7774768074957326919">Utilizza le impostazioni proxy di sistema</translation>
<translation id="7777535871204167559">Considera i dispositivi di archiviazione esterni come di sola lettura</translation>
<translation id="7788511847830146438">Per profilo</translation>
<translation id="780603170519840350">Disattiva l'applicazione dei requisiti di Certificate Transparency per un elenco di hash subjectPublicKeyInfo.

      Questa norma consente di disattivare i requisiti di divulgazione di Certificate Transparency per le catene di certificati che contengono certificati con uno degli hash subjectPublicKeyInfo specificati. Fa sì che i certificati che altrimenti sarebbero considerati non attendibili, in quanto non adeguatamente resi pubblici, continuino a essere utilizzati per gli host aziendali.

      Per disattivare l'applicazione dei requisiti di Certificate Transparency quando viene impostata questa norma, deve essere soddisfatta una delle seguenti condizioni:
      1. L'hash fa parte del subjectPublicKeyInfo del certificato del server.
      2. L'hash fa parte di un subjectPublicKeyInfo che compare in un certificato CA nella catena di certificati; tale certificato CA è limitato dall'estensione X.509v3 nameConstraints, uno o più nameConstraints del directoryName sono presenti nel permittedSubtrees e il directoryName contiene un attributo organizationName.
      3. L'hash fa parte di un subjectPublicKeyInfo che compare in un certificato CA nella catena di certificati; tale certificato possiede uno o più attributi organizationName nel Subject del certificato e il certificato del server contiene lo stesso numero di attributi organizationName nello stesso ordine e con identici valori byte per byte.

      Un hash subjectPublicKeyInfo viene specificato concatenando il nome dell'algoritmo hash, il carattere "/" e la codifica Base64 dell'algoritmo hash applicato al subjectPublicKeyInfo con codifica DER del certificato specificato. La codifica Base64 è nello stesso formato di un'impronta SPKI, come stabilito nella Sezione 2.4 dell'RFC 7469. Gli algoritmi hash non riconosciuti vengono ignorati. Attualmente l'unico algoritmo hash supportato è "sha256".

      Se questa norma non viene impostata, i certificati che devono essere resi pubblici tramite Certificate Transparency verranno considerati non attendibili nel caso in cui non vengano resi pubblici secondo quanto previsto dalle norme di Certificate Transparency.</translation>
<translation id="7818131573217430250">Impostazione stato predefinito modalità ad alto contrasto nella schermata di accesso</translation>
<translation id="7822837118545582721">Se la norma è impostata su true, gli utenti non possono scrivere su dispositivi di archiviazione esterni.

Se la norma è impostata su false o non è configurata, gli utenti possono creare e modificare file su dispositivi di archiviazione esterni che consentono la scrittura.

La norma ExternalStorageDisabled ha la precedenza su questa norma. Se la norma ExternalStorageDisabled è impostata su true, ogni accesso ai dispositivi di archiviazione esterni viene disattivato e di conseguenza questa norma viene ignorata.

L'aggiornamento dinamico della norma è supportato in M56 e versioni successive.</translation>
<translation id="7831595031698917016">Consente di specificare il ritardo massimo in millisecondi tra il ricevimento dell'invalidamento di una norma e il recupero della nuova norma dal servizio di gestione del dispositivo.

Se questa norma viene impostata, il suo valore sostituisce il valore predefinito di 5000 millisecondi. I valori validi di questa norma sono compresi tra 1000 (1 secondo) e 300000 (5 minuti). I valori non compresi in questo intervallo verranno fissati al rispettivo limite.

Se questa norma non viene impostata, <ph name="PRODUCT_NAME" /> utilizzerà il valore predefinito di 5000 millisecondi.</translation>
<translation id="7841880500990419427">Versione TLS minima a cui retrocedere</translation>
<translation id="7858404742201086014">Se attivi questa impostazione, i plug-in obsoleti vengono utilizzati come normali plug-in.

      Se disattivi questa impostazione, i plug-in obsoleti non vengono utilizzati e agli utenti non è richiesta l'autorizzazione per eseguirli.

      Se questa impostazione non è configurata, agli utenti verrà chiesta l'autorizzazione di eseguire i plug-in obsoleti.</translation>
<translation id="787125417158068494">Se la norma viene impostata su SyncDisabled o non viene configurata, i certificati <ph name="PRODUCT_OS_NAME" /> non saranno disponibili per le app ARC.

      Se viene impostata su CopyCaCerts, per le app ARC saranno disponibili tutti i certificati CA installati su ONC con <ph name="WEB_TRUSTED_BIT" />.</translation>
<translation id="7882585827992171421">Questa norma è attiva soltanto in modalità retail.

      Consente di stabilire l'ID dell'estensione da utilizzare come screensaver nella schermata di accesso. L'estensione deve far parte dell'AppPack configurato per il dominio tramite la norma DeviceAppPack.</translation>
<translation id="7882857838942884046">Se Google Sync viene disattivato, le funzioni di backup e ripristino di Android non funzionano correttamente.</translation>
<translation id="7882890448959833986">Elimina l'avviso di sistema operativo non supportato</translation>
<translation id="7895553628261067384">Accesso remoto</translation>
<translation id="7902255855035461275">I pattern di questo elenco verranno confrontati con
      l'origine di sicurezza dell'URL richiedente. Se viene trovata una corrispondenza, l'accesso ai dispositivi
      di acquisizione video verrà concesso senza richieste.

      NOTA: fino alla versione 45, questa norma era supportata soltanto in modalità kiosk.</translation>
<translation id="7912255076272890813">Configura tipi di app/estensioni consentiti</translation>
<translation id="7922358664346625612">Mantieni l'ultima scheda aperta in Chrome.</translation>
<translation id="793134539373873765">Consente di specificare se p2p deve essere utilizzato per i payload di aggiornamento del sistema operativo. Se questa norma viene impostata su True, i dispositivi condivideranno e proveranno a consumare i payload di aggiornamento sulla LAN, riducendo potenzialmente l'utilizzo e la congestione della larghezza di banda Internet. Se il payload di aggiornamento non è disponibile sulla LAN, il dispositivo ripiegherà sul download da un server di aggiornamento. Se la norma viene impostata su False o non viene configurata, non verrà utilizzato p2p.</translation>
<translation id="7933141401888114454">Attivazione della creazione di utenti controllati</translation>
<translation id="793473937901685727">Imposta la disponibilità dei certificati per le app ARC</translation>
<translation id="7937491150792971922">Unisci norme di più fonti relative all'elenco di installazione delle estensioni</translation>
<translation id="7937766917976512374">Consenti o nega acquisizione video</translation>
<translation id="7941975817681987555">Non prevedere le azioni di rete su qualsiasi connessione di rete</translation>
<translation id="7952007677054834789">Consente di configurare le pagine da caricare all'avvio, la pagina iniziale predefinita e la pagina Nuova scheda predefinita in <ph name="PRODUCT_NAME" />; inoltre, evita che gli utenti modifichino queste impostazioni.

      Le impostazioni della pagina iniziale dell'utente sono completamente bloccate se hai selezionato la pagina iniziale come pagina Nuova scheda oppure se hai specificato un URL che funga da pagina iniziale. Se non specifichi l'URL della pagina iniziale, l'utente può ancora impostare la pagina iniziale come pagina Nuova scheda se specifica "chrome://newtab".

      Il criterio "URL da aprire all'avvio" viene ignorato a meno che non selezioni "Apri un elenco di URL" in "Azione all'avvio".</translation>
<translation id="7952958573604504839">La norma è obsoleta in M48 in favore di <ph name="NETWORK_PREDICTION_OPTIONS_POLICY_NAME" /> ed è rimossa in M54.

      Attiva la previsione di rete in <ph name="PRODUCT_NAME" /> e impedisce agli utenti di modificare questa impostazione.

      Questa norma consente di stabilire non solo il precaricamento DNS ma anche la preconnessione TCP e SSL e il prerendering delle pagine web. Il nome della norma si riferisce al precaricamento DNS per motivi storici.

      Se attivi questa impostazione o la disattivi, gli utenti non potranno modificare o sostituire questa impostazione in <ph name="PRODUCT_NAME" />.

      Se la norma non è impostata, sarà attivata ma l'utente potrà modificarla.</translation>
<translation id="7953256619080733119">Host delle eccezioni manuali per gli utenti gestiti</translation>
<translation id="7958537754689366707">Richiedi inserimento della password ogni dodici ore</translation>
<translation id="7961779417826583251">Disattiva l'applicazione di Certificate Transparency per un elenco di autorità di certificazione precedenti</translation>
<translation id="7974114691960514888">Questa norma non è più supportata. Consente di attivare l'utilizzo di server relay e STUN durante la connessione a un client remoto. Se questa impostazione viene attivata, questo computer potrà rilevare i computer host remoti e collegarsi a essi anche se sono separati da un firewall. Se questa impostazione viene disattivata e le connessioni UDP in uscita vengono filtrate dal firewall, questo computer potrà collegarsi ai computer host soltanto all'interno della rete locale.</translation>
<translation id="7976157349247117979">Nome della destinazione di <ph name="PRODUCT_NAME" /></translation>
<translation id="7980227303582973781">Nessuna limitazione speciale</translation>
<translation id="7985242821674907985"><ph name="PRODUCT_NAME" /></translation>
<translation id="798856998567564266">Se attivi questa impostazione, è possibile aggiungere, rimuovere o modificare i preferiti. Questa è l'impostazione predefinita quando la norma non è impostata.

      Se disattivi questa impostazione, non sarà possibile aggiungere, rimuovere o modificare i preferiti. I preferiti esistenti rimangono comunque disponibili.</translation>
<translation id="7992136759457836904">Questa norma consente di controllare se le macchine virtuali possono essere eseguite su Chrome OS.

      Se la norma viene impostata su True, al dispositivo è consentito eseguire le macchine virtuali.
      Se la norma viene impostata su False, al dispositivo non è consentito eseguire le macchine virtuali.
      Le tre norme, VirtualMachinesAllowed, CrostiniAllowed e DeviceUnaffiliatedCrostiniAllowed devono essere impostate su True affinché Crostini possa essere eseguito.
      Quando l'impostazione di questa norma viene modificata in False, la norma viene applicata all'avvio di nuove macchine virtuali, ma non determina l'arresto delle macchine virtuali già in esecuzione.
      Quando questa norma non è impostata su un dispositivo gestito, il dispositivo non può eseguire macchine virtuali.
       I dispositivi non gestiti sono autorizzati a eseguire macchine virtuali.</translation>
<translation id="8001701200415781021">Limita gli Account Google che è possibile impostare come account principali del browser in <ph name="PRODUCT_NAME" /></translation>
<translation id="8009554972280451023">Se attivi questa impostazione, le impostazioni memorizzate nei profili <ph name="PRODUCT_NAME" />, come i preferiti, i dati della compilazione automatica, le password e così via, saranno scritte anche in un file memorizzato nella cartella del profilo utente Roaming o in una posizione specificata dall'amministratore tramite la norma <ph name="ROAMING_PROFILE_LOCATION_POLICY_NAME" />. Se si attiva questa norma, viene disattivata la sincronizzazione nella cloud.

      Se questa norma viene disattivata o non viene impostata, saranno utilizzati solo i normali profili locali.

      La norma <ph name="SYNC_DISABLED_POLICY_NAME" /> consente di disattivare la sincronizzazione di tutti i dati e sostituisce la norma <ph name="ROAMING_PROFILE_SUPPORT_ENABLED_POLICY_NAME" />.</translation>
<translation id="802147957407376460">Ruota lo schermo di 0°</translation>
<translation id="8033913082323846868">Questa norma è stata ritirata in M70, utilizza le norme AutofillAddressEnabled e AutofillCreditCardEnabled.

Consente di attivare la funzione Compilazione automatica di <ph name="PRODUCT_NAME" /> e permette agli utenti di eseguire il completamento automatico dei moduli web utilizzando informazioni memorizzate in precedenza, come l'indirizzo o i dati della carta di credito.

Se disattivi questa impostazione, gli utenti non potranno utilizzare la funzione Compilazione automatica.

Se attivi questa impostazione o non imposti un valore, la funzione Compilazione automatica potrà essere gestita dagli utenti, che potranno quindi configurare i profili di Compilazione automatica e attivare o disattivare a propria scelta questa funzione.</translation>
<translation id="8044493735196713914">Indicazione modalità di avvio dispositivo</translation>
<translation id="8050080920415773384">Stampa nativa</translation>
<translation id="8053580360728293758">Consente di eseguire l'override della modalità di stampa a colori predefinita. Se la modalità non è disponibile, questa norma viene ignorata.</translation>
<translation id="8059164285174960932">URL su cui i client di accesso remoto dovrebbero ottenere il token di autenticazione</translation>
<translation id="806280865577636339">Se questa norma è impostata su true, le opzioni di accessibilità vengono visualizzate sempre nel menu della barra delle applicazioni.

          Se questa norma è impostata su false, le opzioni di accessibilità non vengono mai visualizzate nel menu della barra delle applicazioni.

          Se imposti questa norma, gli utenti non potranno modificarla o sostituirla.

          Se questa norma non viene impostata, le opzioni di accessibilità non verranno visualizzate nel menu della barra delle applicazioni, ma l'utente potrà attivarne la visualizzazione tramite la pagina Impostazioni.</translation>
<translation id="806523868782250975">Configura un elenco di preferiti gestiti.

      La norma è costituita da un elenco di preferiti, in cui ogni preferito è un dizionario che contiene le chiavi "<ph name="NAME" />" e "<ph name="URL_LABEL" />" indicanti il nome e la destinazione del preferito. È possibile configurare una sottocartella definendo un preferito senza una chiave "<ph name="URL_LABEL" />", ma con una chiave aggiuntiva "<ph name="CHILDREN" />" contenente un elenco di preferiti come definito sopra (alcuni dei quali possono essere a loro volta cartelle). <ph name="PRODUCT_NAME" /> corregge gli URL incompleti come se fossero stati inviati tramite la omnibox, ad esempio "<ph name="GOOGLE_COM" />" diventa "<ph name="HTTPS_GOOGLE_COM" />".

      Questi preferiti vengono inseriti in una cartella che l'utente non può modificare (ma che può scegliere di nascondere dalla barra dei Preferiti). Per impostazione predefinita, il nome della cartella è "Preferiti gestiti" ma può essere personalizzata aggiungendo all'elenco dei preferiti un dizionario contenente la chiave "<ph name="TOPLEVEL_NAME" />" con il nome desiderato per la cartella come valore.

      I preferiti gestiti non vengono sincronizzati con l'account utente e non è possibile modificarli tramite estensioni.</translation>
<translation id="8078366200175825572">Questa norma consente di impostare un elenco di pattern URL che specificano i siti non autorizzati a impostare cookie.

          Se questa norma non viene impostata, per tutti i siti verrà utilizzato il valore predefinito globale della norma "DefaultCookiesSetting", se è impostata, oppure verrà utilizzata la configurazione personale dell'utente.

          Vedi anche le norme "CookiesAllowedForUrls" e "CookiesSessionOnlyForUrls". Tieni presente che non ci deve essere conflitto di pattern URL tra queste tre norme. Non viene specificato quale norma debba avere la precedenza.</translation>
<translation id="8099880303030573137">Ritardo inattività in caso di utilizzo della batteria</translation>
<translation id="8102913158860568230">Impostazione stream multimediale predefinito</translation>
<translation id="8104186956182795918">Questa norma consente di specificare se consentire o meno la visualizzazione delle immagini sui siti web. La visualizzazione delle immagini può essere consentita o negata a tutti i siti web.

          Se questa norma non viene impostata, verrà utilizzata l'impostazione "AllowImages" e l'utente sarà in grado di modificarla.

          Tieni presente che in precedenza questa norma è stata erroneamente abilitata su Android, ma questa funzione non è mai stata completamente supportata su Android.</translation>
<translation id="8104962233214241919">Seleziona automaticamente i certificati client per questi siti</translation>
<translation id="8112122435099806139">Consente di specificare il formato dell'orologio da utilizzare per il dispositivo.

      Questa norma consente di configurare il formato dell'orologio da utilizzare nella schermata di accesso e come predefinito per le sessioni utente. Gli utenti possono comunque sostituire il formato dell'orologio per il loro account.

      Se la norma viene impostata su true, sul dispositivo viene utilizzato il formato di 24 ore, se viene impostata su false viene utilizzato il formato di 12 ore.

      Se questa norma non viene impostata, sul dispositivo viene utilizzato il formato predefinito di 24 ore.</translation>
<translation id="8114382167597081590">Non imporre la Modalità con restrizioni su YouTube</translation>
<translation id="8118665053362250806">Imposta le dimensioni della cache su disco di supporto</translation>
<translation id="8124468781472887384">Norma di accesso alla configurazione delle stampanti per i dispositivi.</translation>
<translation id="8135937294926049787">Consente di specificare il periodo di tempo senza input dell'utente trascorso il quale lo schermo viene disattivato quando viene utilizzata la corrente alternata.

Se questa norma viene impostata su un valore maggiore di zero, consente di specificare il periodo di tempo per cui l'utente deve rimanere inattivo prima che <ph name="PRODUCT_OS_NAME" /> disattivi lo schermo.

Se questa norma viene impostata su zero, <ph name="PRODUCT_OS_NAME" /> non disattiva lo schermo quando l'utente diventa inattivo.

Se questa norma non viene impostata, viene utilizzato un periodo di tempo predefinito.

Il valore della norma deve essere specificato in millisecondi. I valori devono essere inferiori o uguali al ritardo di inattività.</translation>
<translation id="8138009212169037227">Questa norma consente di stabilire se segnalare o meno i dati delle norme e data/ora del recupero delle norme.

      Se questa norma non viene impostata o viene impostata su True, i dati delle norme e data/ora del recupero delle norme vengono raccolti.
      Se questa norma viene impostata su False, i dati delle norme e data/ora del recupero delle norme non vengono raccolti.

      Questa norma viene applicata soltanto se viene attivata l'estensione <ph name="CHROME_REPORTING_EXTENSION_NAME" /> e il computer viene registrato con la norma <ph name="MACHINE_LEVEL_USER_CLOUD_POLICY_ENROLLMENT_TOKEN_POLICY_NAME" />.</translation>
<translation id="8140204717286305802">Consente di comunicare al server l'elenco di interfacce di rete con i relativi tipi e indirizzi hardware. Se la norma viene impostata su False, l'elenco di interfacce non viene comunicato.</translation>
<translation id="8141795997560411818">Questa norma non impedisce all'utente di utilizzare l'app Google Drive per Android. Se vuoi impedire l'accesso a Google Drive, non devi consentire l'installazione dell'app Google Drive per Android.</translation>
<translation id="8142894094385450823">Questa norma consente di impostare le impostazioni internazionali consigliate per una sessione gestita</translation>
<translation id="8146727383888924340">Consenti agli utenti di utilizzare le offerte tramite la registrazione a Chrome OS</translation>
<translation id="8148785525797916822">Elimina l'avviso che viene mostrato quando <ph name="PRODUCT_NAME" /> è in esecuzione su un computer o l'avviso di sistema operativo non più supportato.</translation>
<translation id="8148901634826284024">Consente di attivare la funzione di accessibilità della modalità ad alto contrasto.

Se la norma viene impostata su true, la modalità ad alto contrasto sarà sempre attiva.

Se la norma viene impostata su false, la modalità ad alto contrasto sarà sempre disattivata.

Se la norma viene impostata, gli utenti non potranno modificarla o ignorarla.

Se la norma non viene configurata, la modalità ad alto contrasto viene inizialmente disattivata ma potrà essere attivata dagli utenti in qualsiasi momento.</translation>
<translation id="815061180603915310">Se viene attivata, questa norma forza l'attivazione della modalità temporanea per il profilo. Se viene specificata come norma del sistema operativo (ad esempio GPO su Windows), la norma viene applicata a ogni profilo nel sistema; se la norma viene impostata come norma Cloud, viene applicata soltanto a un profilo a cui viene eseguito l'accesso con un account gestito.

      In questa modalità, i dati del profilo rimangono memorizzati su disco soltanto per la durata della sessione utente. Funzionalità quali cronologia del browser, estensioni e relativi dati, dati web quali cookie e database web non rimangono memorizzati alla chiusura del browser. L'utente può comunque scaricare i dati su disco manualmente, salvare pagine o stamparle.

      Se l'utente ha attivato la sincronizzazione, tutti i dati rimangono memorizzati nel suo profilo sincronizzato così come avviene per i profili normali. È disponibile anche la modalità di navigazione in incognito se non è disattivata esplicitamente dalla norma.

      Se la norma viene disattivata o non viene impostata, l'accesso rimanda a profili normali.</translation>
<translation id="8158758865057576716">Consente la creazione di copie di roaming per i dati dei profili <ph name="PRODUCT_NAME" />.</translation>
<translation id="8172676363520748127">Se la norma è attivata, non è possibile acquisire screenshot utilizzando scorciatoie da tastiera o API di estensioni.

      Se la norma è disattivata o non è specificata, è possibile acquisire screenshot.</translation>
<translation id="817455428376641507">Consente l'accesso agli URL elencati, sotto forma di eccezioni alla blacklist di URL.

      Consulta la descrizione della norma sulle blacklist di URL per il formato delle voci di questo elenco.

      Questa norma può essere utilizzata per aprire eccezioni alle blacklist restrittive. Ad esempio "*" può essere incluso nella blacklist per bloccare tutte le richieste e questa norma può essere utilizzata per consentire l'accesso a un elenco limitato di URL. Può essere utilizzata per aprire eccezioni rispetto a determinati schemi, sottodomini di altri domini, porte o percorsi specifici.

      Il filtro più specifico consente di determinare se un URL è bloccato o consentito. La whitelist ha la precedenza sulla blacklist.

       Per questa norma è possibile definire massimo 1000 voci; le voci in più vengono ignorate.

      Se questa norma non viene impostata, non ci saranno eccezioni alla blacklist dalla norma "URLBlacklist".</translation>
<translation id="8176035528522326671">Consenti all'utente aziendale di essere solo l'utente multiprofilo principale (comportamento predefinito per gli utenti gestiti dall'azienda)</translation>
<translation id="8214600119442850823">Consente di configurare Gestione password.</translation>
<translation id="8217516105848565518">Questa norma è obsoleta. Al suo posto utilizza RemoteAccessHostDomainList.</translation>
<translation id="8244171102276095471">Attiva i pacchetti di crittografia RC4 in TLS</translation>
<translation id="8244525275280476362">Ritardo di recupero massimo dopo l'invalidazione di una norma</translation>
<translation id="8256688113167012935">Controlla il nome account visualizzato da <ph name="PRODUCT_OS_NAME" /> nella schermata di accesso per il corrispondente account del dispositivo.

      Se il criterio è impostato, la schermata di accesso utilizzerà la stringa specificata nel selettore di accesso basato su immagine per il corrispondente account del dispositivo.

      Se il criterio non viene impostato, <ph name="PRODUCT_OS_NAME" /> utilizzerà l'ID account email dell'account dispositivo come nome visualizzato nella schermata di accesso.

      Questo criterio viene ignorato per gli account utente standard.</translation>
<translation id="8259375588339409826">Chromium e Google Chrome supportano lo stesso insieme di norme. Questo documento potrebbe includere norme riferite a versioni non ancora introdotte (la relativa voce "Supported on" si riferisce a una versione non rilasciata di <ph name="PRODUCT_NAME" />). Tali norme sono soggette a modifica o rimozione senza preavviso e non viene fornita alcuna garanzia in merito, neanche in relazione alle proprietà di privacy e sicurezza.

Queste norme devono essere utilizzate esclusivamente per la configurazione delle istanze di <ph name="PRODUCT_NAME" /> interne all'organizzazione. L'utilizzo di queste norme al di fuori dell'organizzazione (ad esempio in un programma distribuito pubblicamente) viene considerato malware e potrebbe essere contrassegnato come malware da Google e dai fornitori di programmi antivirus.

Non è necessario configurare manualmente queste impostazioni. È possibile scaricare modelli di facile utilizzo per Windows, Mac e Linux da <ph name="POLICY_TEMPLATE_DOWNLOAD_URL" />.

Su Windows è consigliabile configurare le norme tramite Criteri di gruppo, anche se la specifica di norme tramite il registro di sistema è ancora supportata per le istanze di Windows che fanno parte di un dominio <ph name="MS_AD_NAME" />.</translation>
<translation id="8259592978873597235">Se questa norma è impostata su True o non viene impostata, l'utente non verrà considerato inattivo durante la riproduzione del video. In questo modo si impedisce il ritardo di inattività, il ritardo nell'attenuazione dello schermo, il ritardo nello spegnimento dello schermo e il ritardo nel blocco dello schermo e l'esecuzione delle azioni corrispondenti.

          Se questa norma è impostata su False, l'attività del video non impedisce all'utente di essere considerato inattivo.</translation>
<translation id="8274603902181597201">Cancella la home directory ecryptfs dell'utente e inizia con una nuova home directory criptata tramite ext4</translation>
<translation id="8285435910062771358">Ingrandimento a schermo intero attivo</translation>
<translation id="8288199156259560552">Attiva il servizio di geolocalizzazione di Google per Android</translation>
<translation id="8292322992383748446">Consente di segnalare statistiche hardware relative ai componenti SoC.

      Se la norma viene impostata su false, le statistiche non vengono segnalate.
      Se viene impostata su true o non viene impostata, le statistiche vengono segnalate.</translation>
<translation id="8294750666104911727">In genere le pagine con X-UA-Compatible impostato su chrome=1 saranno visualizzate in <ph name="PRODUCT_FRAME_NAME" /> nonostante la norma "£ChromeFrameRendererSettings".

Se attivi questa impostazione, le pagine non saranno sottoposte a scansione per i metatag.

Se disattivi questa impostazione, le pagine saranno sottoposte a scansione per i metatag.

Se questa norma non viene impostata, le pagine saranno sottoposte a scansione per i metatag.</translation>
<translation id="8300455783946254851">Consente di disattivare la sincronizzazione di Google Drive nell'app File di <ph name="PRODUCT_OS_NAME" /> utilizzando una connessione alla rete dati quando questa norma viene impostata su True. In tal caso, i dati vengono sincronizzati con Google Drive solo in presenza di una connessione alla rete Wi-Fi o Ethernet.

          Se questa norma non viene impostata o viene impostata su False, gli utenti possono trasferire file in Google Drive mediante connessioni alla rete dati.</translation>
<translation id="8300992833374611099">Stabilisci dove è possibile utilizzare gli Strumenti per sviluppatori</translation>
<translation id="8306117673860983372">Impostazioni di accesso</translation>
<translation id="8312129124898414409">Consente di stabilire se consentire o meno l'utilizzo della generazione di chiavi sui siti web. L'utilizzo della generazione di chiavi può essere consentito o negato per tutti i siti web.

          Se questa norma non viene impostata, verrà utilizzato il valore della norma "BlockKeygen", che potrà essere modificato dagli utenti.</translation>
<translation id="8320149248919453401">Modalità di carica della batteria</translation>
<translation id="8329984337216493753">Questa norma è attiva soltanto in modalità retail.

      Se viene specificata la norma DeviceIdleLogoutTimeout, questa norma consente di definire la durata della casella di avviso con un timer per il conto alla rovescia che viene mostrato all'utente prima dell'esecuzione dell'uscita.

      Il valore della norma deve essere specificato in millisecondi.</translation>
<translation id="8339420913453596618">Autenticazione a due fattori disattivata</translation>
<translation id="8344454543174932833">Importa Preferiti dal browser predefinito alla prima esecuzione</translation>
<translation id="8357681633047935212">Limita la durata di una sessione utente</translation>
<translation id="8359734107661430198">Attiva l'API ExampleDeprecatedFeature valida fino al 02/09/2008</translation>
<translation id="8367209241899435947">Attiva Chrome Software Cleaner su Windows</translation>
<translation id="8369602308428138533">Ritardo disattivazione schermo in caso di utilizzo di CA</translation>
<translation id="8371178326720637170">Consente alle estensioni gestite di utilizzare l'API Enterprise Hardware Platform</translation>
<translation id="8374747520743832795">Consente di segnalare statistiche hardware e identificatori relativi all'alimentazione.

      Se la norma viene impostata su false, le statistiche non vengono segnalate.
      Se viene impostata su true o non viene impostata, le statistiche vengono segnalate.</translation>
<translation id="8380490658357556620">Attiva l'utilizzo dei relay server quando i client remoti tentano di stabilire una connessione con il computer.

          Se questa impostazione viene attivata, i client remoti possono utilizzare relay server per collegarsi al computer quando non è disponibile una connessione diretta (ad es. a causa di limitazioni del firewall).

          Tieni presente che questa norma viene ignorata, se <ph name="REMOTE_ACCESS_HOST_FIREWALL_TRAVERSAL_POLICY_NAME" /> viene disattivata.

          Se questa norma non è impostata, l'impostazione viene attivata.</translation>
<translation id="8382184662529825177">Attiva l'utilizzo dell'attestazione remota per la protezione dei contenuti per il dispositivo</translation>
<translation id="838870586332499308">Attiva roaming dati</translation>
<translation id="8390049129576938611">Consente di disattivare il visualizzatore di PDF interno di <ph name="PRODUCT_NAME" />. I file PDF vengono gestiti come download che l'utente può aprire con l'applicazione predefinita.

      Se questa norma non viene impostata o viene disattivata, per aprire i file PDF verrà utilizzato il plug-in di PDF, se l'utente non lo disattiva.</translation>
<translation id="8395749934754392549">Consente di gestire le impostazioni relative al container Android (ARC) e alle app Android.</translation>
<translation id="8396145449084377015">Questa norma consente di stabilire se caricare regole dalla norma SiteList di Internet Explorer.

      Se questa norma non viene impostata o viene impostata su False, <ph name="PRODUCT_NAME" /> non utilizza la norma <ph name="IEEM_SITELIST_POLICY" /> di Internet Explorer come fonte di regole per il cambio di browser.

      Se questa norma viene impostata su True, <ph name="PRODUCT_NAME" /> legge la norma <ph name="IEEM_SITELIST_POLICY" /> di Internet Explorer per ottenere l'URL dell'elenco di siti. <ph name="PRODUCT_NAME" /> scarica poi l'elenco da quell'URL e applica le regole come se fossero state configurate con la norma <ph name="SITELIST_POLICY_NAME" />.

      Per ulteriori informazioni sulla norma <ph name="IEEM_SITELIST_POLICY" /> di Internet Explorer, visita il sito https://docs.microsoft.com/internet-explorer/ie11-deploy-guide/what-is-enterprise-mode</translation>
<translation id="8402079500086185021">Apri sempre file PDF esternamente</translation>
<translation id="8417305981081876834">Imposta la lunghezza massima del PIN per la schermata di blocco</translation>
<translation id="841977920223099909">Attivazione dell'avviso di protezione tramite password</translation>
<translation id="8424255554404582727">Imposta la rotazione predefinita dello schermo, riapplicata a ogni riavvio</translation>
<translation id="8426231401662877819">Ruota lo schermo in senso orario di 90°</translation>
<translation id="8433186206711564395">Impostazioni di rete</translation>
<translation id="8433423491036718210">Configura l'elenco di URL di accesso aziendale in cui il servizio di protezione tramite password deve acquisire l'impronta della password.</translation>
<translation id="8451988835943702790">Usa la pagina Nuova scheda come Pagina iniziale</translation>
<translation id="8459216513698220096">Consente di specificare se e come devono essere elaborati i criteri relativi agli utenti del GPO del computer.

      Se vengono impostati su "Default" o non vengono impostati, i criteri relativi agli utenti vengono letti soltanto dai GPO degli utenti (i GPO del computer vengono ignorati).

      Se vengono impostati su "Merge", i criteri relativi agli utenti nei GPO degli utenti vengono uniti a quelli dei GPO del computer (a cui viene data la precedenza).

      Se vengono impostati su "Replace", i criteri relativi agli utenti nei GPO degli utenti vengono sostituiti da quelli dei GPO del computer (i GPO degli utenti vengono ignorati).</translation>
<translation id="8465065632133292531">Parametri per l'URL istantaneo che utilizza POST</translation>
<translation id="847472800012384958">Non consentire la visualizzazione di popup nei siti</translation>
<translation id="8477885780684655676">TLS 1.0</translation>
<translation id="8483004350080020634">Consente di rimuovere le parti sensibili per la privacy e la sicurezza dagli URL https:// prima di trasmetterli agli script PAC (Proxy Auto Config) utilizzati da <ph name="PRODUCT_NAME" /> durante la risoluzione proxy.

      Se la norma viene impostata su True, la funzione di sicurezza viene attivata e vengono rimosse le parti sensibili dagli URL https:// prima di inviarli allo script PAC. In questo modo lo script PAC non può visualizzare i dati solitamente protetti tramite un canale criptato (ad esempio il percorso e la query dell'URL).

      Se la norma viene impostata su False, la funzione di sicurezza viene disattivata e gli script PAC possono visualizzare tutti i componenti di un URL https://. Questa impostazione viene applicata per tutti gli script PAC, a prescindere dall'origine (sono inclusi quelli recuperati tramite un metodo di trasporto non protetto o scoperti in modo non sicuro tramite WPAD).

      Il valore predefinito della norma è True (funzione di sicurezza attivata).

      È consigliato impostare la norma su True. L'unico motivo per impostare la norma su False è in caso di problemi di compatibilità con gli script PAC esistenti.

      La norma verrà rimossa in M75.</translation>
<translation id="8484458986062090479">Consente di personalizzare l'elenco di pattern URL per i quali il rendering deve sempre essere eseguito dal browser host.

          Se la norma non viene impostata, viene utilizzato per tutti i siti il renderer predefinito specificato dalla norma "ChromeFrameRendererSettings".

          Per avere pattern di esempio, visita il sito https://www.chromium.org/developers/how-tos/chrome-frame-getting-started.</translation>
<translation id="8489964335640955763">PluginVm</translation>
<translation id="8493645415242333585">Disabilita salvataggio della cronologia del browser</translation>
<translation id="8499172469244085141">Impostazioni predefinite (gli utenti possono ignorarle)</translation>
<translation id="8507835864888987300">Consente di impostare una versione target per gli Aggiornamenti automatici.

      Consente di specificare il prefisso della versione target a cui <ph name="PRODUCT_OS_NAME" /> deve aggiornarsi. Se sul dispositivo viene eseguita una versione precedente a quella del prefisso specificato, il dispositivo si aggiornerà all'ultima versione con il prefisso dato. Se il dispositivo ha già l'ultima versione, gli effetti dipendono dal valore di <ph name="DEVICE_ROLLBACK_TO_TARGET_VERSION_POLICY_NAME" />. Il formato del prefisso funziona in relazione al componente, come mostrato nell'esempio seguente:

      "" (o non configurata): aggiornamento all'ultima versione disponibile.
      "1412.": aggiornamento a qualsiasi versione secondaria di 1412 (ad es. 1412.24.34 o 1412.60.2)
      "1412.2.": aggiornamento a qualsiasi versione secondaria di 1412.2 (ad es. 1412.2.34 o 1412.2.2)
      "1412.24.34": aggiornamento soltanto a questa versione specifica

      Avviso: non è consigliabile configurare restrizioni alle versioni, poiché potrebbero impedire agli utenti di ricevere aggiornamenti software e correzioni di sicurezza fondamentali. Limitare gli aggiornamenti a uno specifico prefisso per la versione potrebbe mettere a rischio gli utenti.</translation>
<translation id="8519264904050090490">URL delle eccezioni manuali per gli utenti gestiti</translation>
<translation id="8525526490824335042">Container Linux</translation>
<translation id="8538235451413605457">Consente di configurare il requisito della versione minima consentita di <ph name="PRODUCT_NAME" />. Le versioni inferiori vengono trattate come obsolete e il dispositivo non consente agli utenti di accedere, se prima non viene aggiornato il sistema operativo.
      Se la versione corrente diventa obsoleta durante una sessione utente, l'utente verrà forzatamente scollegato.

      Se questa norma non viene applicata, non vengono applicate restrizioni e l'utente può accedere a prescindere dalla sua versione di <ph name="PRODUCT_NAME" />.

      Qui per "versione" si intende sia una versione esatta come "61.0.3163.120", sia un prefisso per la versione, come "61.0".  </translation>
<translation id="8544375438507658205">Renderer HTML predefinito per <ph name="PRODUCT_FRAME_NAME" /></translation>
<translation id="8544465954173828789">Consente la sincronizzazione di messaggi SMS dal telefono al Chromebook</translation>
<translation id="8548832052135586762">Consente di impostare solo la stampa a colori, solo la stampa monocromatica oppure nessuna limitazione per la modalità a colori. Se la norma non viene impostata non vengono applicate limitazioni.</translation>
<translation id="8549772397068118889">Avvisa quando vengono visitati siti non presenti nei pacchetti di contenuti</translation>
<translation id="8566842294717252664">Nascondi il Web Store nella pagina Nuova scheda e in Avvio applicazioni</translation>
<translation id="8569734380847633643">
          Se la norma è impostata su false, <ph name="PRODUCT_OS_NAME" /> disattiverà la connessione Wi-Fi e gli utenti non potranno riattivarla.
          Se la norma è impostata su true o non è impostata, gli utenti potranno attivare o disattivare la connessione Wi-Fi a loro piacimento.</translation>
<translation id="857369585509260201">Questa norma è stata ritirata; usa la norma BrowserSignin.

      Se questa norma viene impostata su true, l'utente deve accedere a <ph name="PRODUCT_NAME" /> con il proprio profilo per poter usare il browser e il valore predefinito di BrowserGuestModeEnabled viene impostato su false. Tieni presente che i profili esistenti a cui non è stato eseguito l'accesso saranno bloccati e inaccessibili dopo l'attivazione di questa norma. Per ulteriori informazioni, leggi l'articolo del Centro assistenza.

      Se la norma viene impostata su false o non viene configurata, l'utente può utilizzare il browser senza accedere a <ph name="PRODUCT_NAME" />.</translation>
<translation id="8586528890725660268">Consente di specificare le stampanti non utilizzabili dagli utenti.

      Questa norma viene usata soltanto se viene selezionata l'opzione <ph name="PRINTERS_BLACKLIST" /> per la norma <ph name="BULK_PRINTERS_ACCESS_MODE" />.

      Se viene usata questa norma, gli utenti avranno a disposizione tutte le stampanti tranne quelle i cui ID sono elencati in questa norma. Gli ID devono corrispondere ai campi "id" o "guid" del file specificato nella norma <ph name="BULK_PRINTERS_POLICY" />.
      </translation>
<translation id="8587229956764455752">Consenti la creazione di nuovi account utente</translation>
<translation id="8598350264853261122">Se la norma viene impostata su false, gli utenti non affiliati non potranno usare ARC.

      Se la norma non viene impostata o viene impostata su true, tutti gli utenti potranno utilizzare ARC (a meno che la funzione ARC sia stata disattivata in altri modi).

      Le modifiche apportate alla norma verranno applicate soltanto quando ARC non è in esecuzione, ad esempio durante l'avvio di Chrome OS.</translation>
<translation id="8615400197788843468">Consente di attivare la funzione di accesso limitato di <ph name="PRODUCT_NAME" /> in G Suite e di impedire agli utenti di modificare questa impostazione.

      Se l'impostazione viene definita, l'utente potrà accedere alle app Google soltanto usando gli account dei domini specificati (tieni presente che per consentire gli account gmail.com/googlemail.com devi aggiungere "consumer_accounts", senza virgolette, all'elenco di domini).

      Questa impostazione impedirà all'utente di accedere e aggiungere un account secondario su un dispositivo gestito che richiede l'autenticazione di Google, se tale account non appartiene all'elenco sopracitato di domini consentiti. 

      Se l'impostazione viene lasciata vuota/non configurata, l'utente potrà accedere a G Suite con qualsiasi account.

      Questa norma comporta l'aggiunta dell'intestazione X-GoogApps-Allowed-Domains a tutte le richieste HTTP e HTTPS inviate a tutti i domini google.com, come descritto all'indirizzo https://support.google.com/a/answer/1668854.

      L'utente non può modificare o ignorare questa impostazione.</translation>
<translation id="8631434304112909927">fino alla versione <ph name="UNTIL_VERSION" /></translation>
<translation id="8649763579836720255">I dispositivi Chrome OS possono utilizzare un'attestazione remota (Accesso verificato) per ottenere un certificato emesso dalla CA di Chrome OS in cui si afferma che il dispositivo è idoneo a riprodurre contenuti protetti. Questo processo comporta l'invio alla CA di Chrome OS di informazioni di approvazione dell'hardware che identificano in modo univoco il dispositivo.

Se questa impostazione viene impostata su false, il dispositivo non utilizzerà l'attestazione remota per la protezione dei contenuti e il dispositivo potrebbe non essere in grado di riprodurre i contenuti protetti.

Se l'impostazione viene impostata su true, o se non viene impostata, l'attestazione remota potrebbe essere utilizzata per la protezione dei contenuti.</translation>
<translation id="8650974590712548439">Posizione del Registro di sistema di Windows per client Windows:</translation>
<translation id="8654286232573430130">Consente di specificare quali server devono essere autorizzati per l'autenticazione integrata. L'autenticazione integrata è attivata solo quando <ph name="PRODUCT_NAME" /> riceve una richiesta di autenticazione da un proxy o da un server che si trova in questo elenco di autorizzazione.

          Separa più nomi di server con delle virgole. Sono ammessi i caratteri jolly (*).

          Se questa norma non viene impostata <ph name="PRODUCT_NAME" /> tenterà di rilevare se sulla Intranet è presente un server e solo allora risponderà alle richieste IWA. Se viene rilevato un server su Internet, le sue richieste IWA verranno ignorate da <ph name="PRODUCT_NAME" />.</translation>
<translation id="8661297125441579970">Non consentire migrazione dei dati e ARC.</translation>
<translation id="8672321184841719703">Scegli versione target dell'aggiornamento automatico</translation>
<translation id="867410340948518937">U2F (Universal Second Factor)</translation>
<translation id="8682611302223077049">Consente di stabilire per quanto tempo, in millisecondi, gli utenti riceveranno notifiche relative alla necessità di riavviare <ph name="PRODUCT_NAME" /> o un dispositivo <ph name="PRODUCT_OS_NAME" /> per applicare un aggiornamento in sospeso

      Durante questo periodo di tempo l'utente verrà informato più volte della necessità di un aggiornamento. Per quanto riguarda i dispositivi <ph name="PRODUCT_OS_NAME" />, nella barra delle applicazioni viene mostrata una notifica relativa al riavvio quando viene rilevato un upgrade. Per quanto riguarda i browser <ph name="PRODUCT_NAME" />, il menu delle app cambia per indicare che è necessario il riavvio una volta trascorso un terzo del periodo di notifica. Questa notifica cambia colore una volta trascorsi due terzi del periodo di notifica e lo cambia di nuovo al termine dell'intero periodo di notifica. Le notifiche aggiuntive attivate in base alla norma <ph name="RELAUNCH_NOTIFICATION_POLICY_NAME" /> seguono questa stessa pianificazione.

      Se la norma non viene impostata, viene usato il periodo predefinito di 345600000 millisecondi (quattro giorni) per <ph name="PRODUCT_OS_NAME" /> e di 604800000 millisecondi (una settimana) per <ph name="PRODUCT_NAME" />.</translation>
<translation id="8685024486845674965">L'avviso di protezione tramite password viene attivato se vengono riutilizzate password</translation>
<translation id="8693243869659262736">Utilizza client DNS integrato</translation>
<translation id="8698286761337647563">Stabilisci con quanti giorni di anticipo avvisare gli utenti SAML quando la loro password sta per scadere</translation>
<translation id="8703488928438047864">Segnala lo stato della scheda</translation>
<translation id="8703872185032220081">Consente di impostare la configurazione giornaliera della variazione dei picchi energetici.

          Questa norma viene utilizzata solo se l'opzione DevicePowerPeakShiftEnabled è impostata su true.

          Se questa norma non è configurata o non è impostata, la variazione dei picchi energetici risulterà sempre disattivata.

          Nota: i valori consentiti per il campo <ph name="MINUTE_FIELD_NAME" /> in <ph name="START_TIME_FIELD_NAME" />, <ph name="END_TIME_FIELD_NAME" /> e <ph name="CHARGE_START_TIME_FIELD_NAME" /> sono 0, 15, 30, 45.</translation>
<translation id="8704831857353097849">Elenco dei plug-in disattivati</translation>
<translation id="8711086062295757690">Consente di specificare la parola chiave, che è la scorciatoia utilizzata nella omnibox per attivare la ricerca con il provider. Questa norma è facoltativa. Se non viene impostata, nessuna parola chiave attiverà il provider di ricerca. Questa norma viene considerata soltanto se è attiva la norma "DefaultSearchProviderEnabled".</translation>
<translation id="8731693562790917685">Le Impostazioni contenuti consentono di specificare la modalità di gestione di determinati tipi di contenuto (ad esempio Cookie, Immagini o JavaScript).</translation>
<translation id="8733448613597049197">Attiva i rapporti estesi su Navigazione sicura di <ph name="PRODUCT_NAME" /> e impedisce agli utenti di modificare questa impostazione.

      I rapporti estesi inviano ai server di Google alcune informazioni di sistema e i contenuti della pagina per contribuire a rilevare app e siti pericolosi.

      Se l'impostazione è configurata su True, i rapporti verranno creati e inviati a seconda delle necessità (ad esempio, quando viene mostrato un annuncio interstitial di sicurezza).

      Se l'impostazione è configurata su False, i rapporti non vengono inviati.

      Se la norma è impostata su True o False, l'utente non potrà modificare l'impostazione.

      Se la norma non viene impostata, l'utente potrà modificare l'impostazione e decidere se inviare rapporti o meno.

      Visita il sito https://developers.google.com/safe-browsing per avere ulteriori informazioni sulla funzione Navigazione sicura.</translation>
<translation id="8736538322216687231">Imponi livello minimo della Modalità con restrizioni di YouTube</translation>
<translation id="8749370016497832113">Consente di eliminare la cronologia del browser e la cronologia dei download in <ph name="PRODUCT_NAME" /> e impedisce agli utenti di modificare questa impostazione.

      Tieni presente che anche quando questa norma è disattivata, non è garantita la memorizzazione della cronologia di navigazione e della cronologia dei download: gli utenti potrebbero essere in grado di modificare o eliminare direttamente i file dei database delle cronologie e il browser stesso potrebbe far scadere o archiviare alcuni o tutti gli elementi della cronologia in qualsiasi momento.

      Se questa impostazione è attivata o non è impostata, la cronologia di navigazione e la cronologia dei download possono essere eliminate.

      Se questa impostazione è disattivata, la cronologia di navigazione e la cronologia dei download non possono essere eliminate.</translation>
<translation id="8757552286070680084">Configurazione di DTC wilco</translation>
<translation id="8758831693895931466">Attiva la registrazione alla gestione della cloud obbligatoria</translation>
<translation id="8759829385824155666">Tipi di crittografia Kerberos consentiti</translation>
<translation id="8764119899999036911">Consente di specificare se il Kerberos SPN generato si basa sul nome canonico DNS o sul nome originale inserito. Se attivi questa impostazione, la ricerca CNAME verrà saltata e verrà utilizzato il nome del server inserito. Se disattivi l'impostazione o non la imposti, il nome canonico del server sarà determinato tramite ricerca CNAME.</translation>
<translation id="8764477907716150749">Questa norma è per uso interno di <ph name="PRODUCT_NAME" />.</translation>
<translation id="8765776988041674792">Consente di configurare l'URL di modifica della password (solo schemi HTTP e HTTPS). Il servizio di protezione tramite password indirizzerà gli utenti a questo URL dopo la visualizzazione di un avviso nel browser per modificare la loro password.
      Per consentire a <ph name="PRODUCT_NAME" /> di acquisire correttamente l'impronta digitale della nuova password in questa pagina di modifica della password, assicurati che tale pagina rispetti le linee guida disponibili all'indirizzo https://www.chromium.org/developers/design-documents/create-amazing-password-forms.

      Se questa impostazione è attiva, il servizio di protezione tramite password indirizza gli utenti a questo URL per modificare la password, dopo la visualizzazione di un avviso nel browser.
      Se questa impostazione è disattivata o non configurata, il servizio di protezione tramite password indirizzerà gli utenti alla pagina https://myaccounts.google.com per modificare la loro password.
      Questa norma è disponibile esclusivamente per le istanze di Windows che fanno parte di un dominio <ph name="MS_AD_NAME" /> così come per le istanze di Windows 10 Pro o Enterprise registrate per la gestione dei dispositivi.</translation>
<translation id="8798099450830957504">Predefinito</translation>
<translation id="8800453707696044281">Imposta il valore personalizzato espresso in percentuale raggiunto il quale la batteria interrompe la ricarica</translation>
<translation id="8801680448782904838">Consente di inviare a un utente una notifica che comunica che è consigliato o necessario eseguire un riavvio del browser o del dispositivo</translation>
<translation id="8818173863808665831">Consente di segnalare la posizione geografica del dispositivo.

Se la norma non viene impostata o viene impostata su false, la posizione non viene segnalata.</translation>
<translation id="8818768076343557335">Prevedi sempre le azioni di rete su ogni rete non cellulare.
          (obsoleto nella versione 50, rimosso nella 52. Dopo la versione 52, se viene impostato il valore 1, viene gestito come 0; prevedi le azioni di rete su qualsiasi connessione di rete).</translation>
<translation id="8825782996899863372">L'avviso di protezione tramite password viene attivato se vengono riutilizzate password in pagine di phishing</translation>
<translation id="8833109046074170275">Autenticazione tramite il flusso GAIA predefinito</translation>
<translation id="8838303810937202360"><ph name="PRODUCT_OS_NAME" /> memorizza nella cache app ed estensioni per consentire a più utenti di uno stesso dispositivo di installarle senza doverle riscaricare.
      Se questa norma non viene configurata o se il valore è inferiore a 1 MB, <ph name="PRODUCT_OS_NAME" /> utilizzerà le dimensioni della cache predefinite.</translation>
<translation id="8851325571441692315">Consente di specificare il server proxy utilizzato da <ph name="PRODUCT_NAME" /> e impedisce agli utenti di modificare le impostazioni proxy.

          Questa norma viene applicata soltanto se la norma <ph name="PROXY_SETTINGS_POLICY_NAME" /> non è stata specificata.

          Se si sceglie di non utilizzare mai un server proxy e ci si connette sempre direttamente, tutte le altre opzioni verranno ignorate.

          Se si sceglie di utilizzare le impostazioni proxy di sistema, tutte le altre opzioni verranno ignorate.

          Se si sceglie il rilevamento automatico del server proxy, tutte le altre opzioni verranno ignorate.

          Se si sceglie la modalità server proxy fissa, è possibile specificare ulteriori opzioni in "Indirizzo o URL del server proxy" e in "Elenco separato da virgole delle regole di bypass proxy". Per le app ARC è disponibile solo il server proxy HTTP con la priorità più alta.

          Se si sceglie di utilizzare uno script proxy .pac, si deve specificare l'URL per lo script in "URL per file proxy .pac".

          Per esempi dettagliati, visita:
          <ph name="PROXY_HELP_URL" />.

          Se attivi questa impostazione, <ph name="PRODUCT_NAME" /> e le app ARC ignorano tutte le opzioni relative al proxy specificate dalla riga di comando.

          Se questa norma non è impostata, gli utenti potranno scegliere le impostazioni proxy autonomamente.</translation>
<translation id="8858642179038618439">Forza la Modalità di protezione di YouTube</translation>
<translation id="8860342862142842017">Disattiva l'applicazione di Certificate Transparency per un elenco di hash subjectPublicKeyInfo</translation>
<translation id="8864975621965365890">Consente di eliminare il messaggio di richiesta di turndown che compare quando un sito viene visualizzato da <ph name="PRODUCT_FRAME_NAME" />.</translation>
<translation id="8867464911288727016">Consente di attivare il servizio Google Traduttore integrato su <ph name="PRODUCT_NAME" />.

      Se questa impostazione viene attivata, in <ph name="PRODUCT_NAME" /> verrà offerta una funzionalità di traduzione mediante una barra degli strumenti di traduzione integrata (se opportuno) e un'opzione di traduzione mostrata nel menu contestuale visualizzato facendo clic con il pulsante destro del mouse.

      Se questa impostazione viene disattivata, tutte le funzioni di traduzione incorporate verranno disattivate.

      Se questa impostazione viene attivata o disattivata, gli utenti non potranno modificarla o sostituirla in <ph name="PRODUCT_NAME" />.

      Se questa impostazione non viene configurata, gli utenti potranno decidere se utilizzare o meno questa funzione.</translation>
<translation id="8876188741456358123">Consente di eseguire l'override della modalità di stampa fronte/retro predefinita. Se la modalità non è disponibile, questa norma viene ignorata.</translation>
<translation id="8882006618241293596">Blocca il plug-in <ph name="FLASH_PLUGIN_NAME" /> su questi siti</translation>
<translation id="8906768759089290519">Attiva modalità ospite</translation>
<translation id="8908294717014659003">Consente di stabilire se i siti web possono accedere ai dispositivi di acquisizione dei contenuti multimediali. L'accesso ai dispositivi di acquisizione dei contenuti multimediali può essere consentito per impostazione predefinita oppure l'utente può visualizzare una richiesta ogni volta che un sito web vuole accedere ai dispositivi di acquisizione dei contenuti multimediali.

          Se questa norma non viene impostata, verrà utilizzata la norma "PromptOnAccess" e l'utente sarà in grado di modificarla.</translation>
<translation id="8909280293285028130">Consente di specificare il periodo di tempo senza input dell'utente trascorso il quale lo schermo viene bloccato quando viene utilizzata la corrente alternata.

Se questa norma viene impostata su un valore maggiore di zero, consente di specificare il periodo di tempo per cui l'utente deve rimanere inattivo prima che <ph name="PRODUCT_OS_NAME" /> blocchi lo schermo.

Se questa norma viene impostata su zero, <ph name="PRODUCT_OS_NAME" /> non blocca lo schermo quando l'utente diventa inattivo.

Se questa norma non viene impostata, viene utilizzato un periodo di tempo predefinito.

Il metodo consigliato per bloccare lo schermo in caso di inattività consiste nell'attivare il blocco dello schermo in caso di sospensione e fare in modo che <ph name="PRODUCT_OS_NAME" /> sospenda dopo il ritardo di inattività. Questa norma dovrebbe essere utilizzata soltanto quando il blocco dello schermo dovrebbe avvenire molto tempo prima della sospensione o quando non si desidera affatto la sospensione in caso di inattività.

Il valore della norma deve essere specificato in millisecondi. I valori devono essere inferiori al ritardo di inattività.</translation>
<translation id="891435090623616439">codificato sotto forma di stringa JSON; per informazioni dettagliate, visita la pagina <ph name="COMPLEX_POLICIES_URL" /></translation>
<translation id="8934944553121392674">Consente di stabilire quali stampanti della norma <ph name="DEVICE_PRINTERS_POLICY" /> mettere a disposizione degli utenti.

      Determina quale norma di accesso usare per la configurazione collettiva delle stampanti. Se viene selezionata l'opzione <ph name="PRINTERS_ALLOW_ALL" />, vengono mostrate tutte le stampanti. Se viene selezionata l'opzione <ph name="PRINTERS_BLACKLIST" />, viene usata la norma <ph name="DEVICE_PRINTERS_BLACKLIST" /> per limitare l'accesso a stampanti specifiche. Se viene selezionata l'opzione <ph name="PRINTERS_WHITELIST" />, la norma <ph name="DEVICE_PRINTERS_WHITELIST" /> stabilisce soltanto le stampanti selezionabili.

      Se questa norma non viene impostata, viene usata l'opzione <ph name="PRINTERS_ALLOW_ALL" />.
      </translation>
<translation id="8938932171964587769">Ritirata in M69. Utilizza la norma OverrideSecurityRestrictionsOnInsecureOrigin.

Questa norma consente di specificare un elenco di origini (URL) o di schemi di nomi host (ad esempio "*.example.com") a cui non vengono applicate limitazioni di sicurezza previste per le origini non sicure.

Lo scopo è consentire alle organizzazioni di autorizzare le origini per le applicazioni precedenti che non possono eseguire il deployment di TLS o di configurare un server di gestione temporanea per gli sviluppi web interni, di modo che gli sviluppatori possano testare le funzioni che richiedono contesti sicuri senza dover eseguire il deployment di TLS sul server di gestione temporanea. Questa norma impedisce inoltre che l'origine venga contrassegnata come "Non sicura" nella omnibox.

L'impostazione di un elenco di URL in questa norma ha lo stesso effetto dell'impostazione del flag della riga di comando "--unsafely-treat-insecure-origin-as-secure" su un elenco separato da virgole degli stessi URL. Se viene impostata, questa norma sostituisce il flag della riga di comando.

Questa norma è stata ritirata in M69 in favore di OverrideSecurityRestrictionsOnInsecureOrigin. Se sono presenti entrambe le norme, verrà utilizzata OverrideSecurityRestrictionsOnInsecureOrigin.

Per ulteriori informazioni sui contesti sicuri, visita il sito
https://www.w3.org/TR/secure-contexts/
      </translation>
<translation id="8942616385591203339">Questa norma consente di controllare se il consenso alla sincronizzazione può essere mostrato all'utente durante il primo accesso. Dovrebbe essere impostata su false se tale consenso non è mai necessario per l'utente.
      Se impostata su false, il consenso alla sincronizzazione non verrà visualizzato.
      Se impostata su true o non viene impostata, il consenso alla sincronizzazione può essere visualizzato.</translation>
<translation id="8947415621777543415">Segnala posizione del dispositivo</translation>
<translation id="8951350807133946005">Impostazione directory della cache su disco</translation>
<translation id="8952317565138994125">Consente di disattivare la sincronizzazione dei dati in <ph name="PRODUCT_NAME" /> tramite servizi di sincronizzazione in hosting su Google e di impedire agli utenti di modificare questa impostazione.

      Se attivi questa impostazione, gli utenti non potranno modificarla o sostituirla in <ph name="PRODUCT_NAME" />.

      Se questa norma non viene impostata, gli utenti potranno scegliere se utilizzare o meno Google Sync.

      Per disattivare completamente Google Sync, si consiglia di disattivare il servizio Google Sync nella Console amministrazione Google.

      Questa norma non deve essere attivata quando la norma <ph name="ROAMING_PROFILE_SUPPORT_ENABLED_POLICY_NAME" /> è attiva, perché tale funzione ha la stessa funzionalità lato client. La sincronizzazione in hosting su Google viene completamente disattivata in questo caso.</translation>
<translation id="8955719471735800169">Torna all'inizio</translation>
<translation id="8959992920425111821">Configurazione predefinita</translation>
<translation id="8960850473856121830">I pattern di questo elenco verranno confrontati con l'origine di sicurezza dell'URL richiedente. Se viene trovata una corrispondenza, l'accesso ai dispositivi di acquisizione audio viene concesso senza richieste.

      NOTA. Fino alla versione 45, questa norma era supportata soltanto in modalità kiosk.</translation>
<translation id="8970205333161758602">Eliminazione del messaggio di richiesta di turndown di <ph name="PRODUCT_FRAME_NAME" /></translation>
<translation id="8976248126101463034">Consenti l'autenticazione Gnubby per gli host di accesso remoto</translation>
<translation id="8976531594979650914">Usa stampante di sistema come predefinita</translation>
<translation id="8992176907758534924">Non consentire la visualizzazione di immagini nei siti</translation>
<translation id="9013875414788074110">Durante l'accesso, <ph name="PRODUCT_OS_NAME" /> può eseguire l'autenticazione con un server (online) o utilizzando una password memorizzata nella cache (offline).

      Quando la norma è impostata sul valore -1, l'utente può eseguire per sempre l'autenticazione offline. Quando la norma è impostata su qualsiasi altro valore, questo specifica il periodo di tempo trascorso dall'ultima autenticazione online, dopo il quale l'utente dovrà eseguire nuovamente l'autenticazione.

      Se questa norma non viene impostata, <ph name="PRODUCT_OS_NAME" /> utilizzerà un limite di tempo predefinito pari a 14 giorni, trascorsi i quali l'utente deve eseguire nuovamente l'autenticazione.

      Questa norma viene applicata soltanto per gli utenti che si sono autenticati tramite SAML.

      Il valore della norma deve essere specificato in secondi.</translation>
<translation id="9018338365267278833">Consente di rimuovere le estensioni visualizzate in <ph name="EXTENSION_INSTALL_BLACKLIST_POLICY_NAME" /> o quelle visualizzate in <ph name="EXTENSION_SETTINGS_POLICY_NAME" /> la cui modalità di installazione è impostata sul blocco ed elimina tutti i relativi dati utente locali.  Consulta le norme sulla privacy per le estensioni o le norme sulla conservazione dei dati per sapere cosa può accadere se i dati utente non vengono archiviati in locale.

      Se il criterio è impostato su disattivato, le estensioni che rientrano negli elenchi sopra elencati (se già installati su una macchina) verranno rimossi completamente dalla macchina (inclusi i dati utente locali).

      Se il criterio è impostato su disattivato o non è impostato, le estensioni che rientrano negli elenchi sopra elencati (se già installati su una macchina e presenti nella lista nera <ph name="EXTENSION_INSTALL_BLACKLIST_POLICY_NAME" />) verranno disattivate sulla macchina e non installate.</translation>
<translation id="9027787254195333560">Questa norma consente di configurare l'immagine avatar che rappresenta l'utente sulla schermata di accesso. La norma viene impostata specificando l'URL da cui <ph name="PRODUCT_OS_NAME" /> può scaricare l'immagine e un hash crittografico per verificare l'integrità del download. L'immagine deve essere in formato JPEG e avere dimensioni non superiori a 512 kB. L'URL deve essere accessibile senza nessuna autenticazione.

      L'immagine avatar viene scaricata e memorizzata nella cache. Verrà scaricata nuovamente ogni volta che l'URL o l'hash vengono modificati.

      La norma deve essere specificata sotto forma di stringa, in cui l'URL e l'hash vengono espressi in formato JSON, conformemente allo schema riportato di seguito:
      {
        "type": "object",
        "properties": {
          "url": {
            "description": "URL da cui scaricare l'immagine avatar.",
            "type": "string"
          },
          "hash": {
            "description": "Hash SHA-256 dell'immagine avatar.",
            "type": "string"
          }
        }
      }

      Se questa norma viene impostata, <ph name="PRODUCT_OS_NAME" /> scaricherà e utilizzerà l'immagine avatar.

      Se imposti questa norma, gli utenti non potranno modificarla o sostituirla.

      Se la norma non viene impostata, l'utente può scegliere l'immagine avatar che lo rappresenta sulla schermata di accesso.</translation>
<translation id="9035964157729712237">ID delle estensioni da escludere dalla blacklist</translation>
<translation id="9038058011835642205">Consente di specificare un elenco di siti web che vengono installati automaticamente, senza l'interazione dell'utente, e che non possono essere disinstallati né disattivati dall'utente.

      Ogni voce dell'elenco della norma è un oggetto con un componente obbligatorio: "url" e due componenti facoltativi: "default_launch_container" e "create_desktop_shortcut". "url" deve essere l'URL dell'applicazione web da installare, "launch_container" deve essere "window" o "tab" a indicare che l'applicazione web verrà aperta una volta installata, e "create_desktop_shortcut" deve essere "true" se è necessario creare un collegamento sul desktop su Linux e Windows. Se "default_launch_container" viene omesso, l'applicazione si aprirà in una scheda per impostazione predefinita. A prescindere dal valore di "default_launch_container", gli utenti possono modificare il contenitore in cui si aprirà l'applicazione. Se "create_desktop_shortcuts" viene omesso, non verranno creati collegamenti sul desktop.</translation>
<translation id="9038839118379817310">Consente di attivare la rete Wi-Fi</translation>
<translation id="9039822628127365650">Quando questa norma viene impostata, consente di specificare il periodo di tempo trascorso il quale un utente viene automaticamente disconnesso, terminando così la sessione. Un timer conto alla rovescia nella barra delle applicazioni informa l'utente del tempo restante.

      Quando la norma non viene impostata, la durata della sessione non è limitata.

      Se imposti questa norma, gli utenti non potranno modificarla o sostituirla.

      Il valore della norma deve essere specificato in millisecondi. I valori sono limitati a un intervallo compreso tra 30 secondi e 24 ore.</translation>
<translation id="9042911395677044526">Consente di forzare l'applicazione della configurazione di rete per utente su un dispositivo <ph name="PRODUCT_OS_NAME" />. La configurazione di rete è una stringa in formato JSON definita secondo il formato Open Network Configuration descritto all'indirizzo <ph name="ONC_SPEC_URL" />.</translation>
<translation id="9050853837490399534">Questa norma consente di stabilire se il dispositivo debba essere aggiornato a una build di correzione rapida.

      Se il valore della norma viene impostato su un token associato a una build di correzione rapida, il dispositivo verrà aggiornato alla build di correzione rapida corrispondente se l'aggiornamento non è bloccato da un'altra norma.

      Se questa norma non è impostata o se il valore non è associato a una build di correzione rapida, il dispositivo non verrà aggiornato a una build di correzione rapida. Se il dispositivo esegue già una build di correzione rapida e la norma non è più impostata o il suo valore non è più associato a una build di correzione rapida, il dispositivo verrà aggiornato a una normale build se l'aggiornamento non è bloccato da un'altra norma.</translation>
<translation id="906631898352326790">Se il criterio viene attivato, ogni origine indicata in un elenco di valori separati da virgole verrà eseguita in un proprio processo. Verranno inoltre isolate le origini indicate dai sottodomini; ad esempio, se viene specificato il sito https://example.com/ viene isolato anche https://foo.example.com/, perché fa parte del sito https://example.com/.
      Se il criterio è disattivato, le funzionalità IsolateOrigins e SitePerProcess saranno entrambe disattivate. Gli utenti potranno ancora attivare IsolateOrigins manualmente, tramite flag da riga di comando.
      Se il criterio non è configurato, l'utente potrà modificare questa impostazione.
      In <ph name="PRODUCT_OS_NAME" />, si consiglia di impostare anche il criterio <ph name="DEVICE_LOGIN_SCREEN_ISOLATE_ORIGINS_POLICY_NAME" /> relativo ai dispositivi sullo stesso valore. Se i valori specificati dai due criteri non corrispondono, può verificarsi un ritardo durante l'accesso a una sessione utente mentre viene applicato il valore specificato dai criteri relativi agli utenti.

      NOTA: questo criterio non viene applicato su Android. Per attivare IsolateOrigins su Android, utilizza l'impostazione del criterio IsolateOriginsAndroid.</translation>
<translation id="9072600218500597787">Consente di configurare i nomi di dominio dell'host che verranno imposti sugli host di accesso remoto e impedisce agli utenti di modificarli.

          Se questa impostazione è attiva, allora è possibile condividere gli host solo utilizzando gli account registrati su uno dei nomi di dominio specificati.

          Se questa impostazione è disattivata o non configurata, allora è possibile condividere gli host utilizzando qualsiasi account.

          Questa impostazione eseguirà l'override del RemoteAccessHostDomain, se presente.

          Vedi anche RemoteAccessHostClientDomainList.</translation>
<translation id="9077227880520270584">Timer accesso automatico all'account locale del dispositivo</translation>
<translation id="9084985621503260744">Specifica se l'attività video incide sulla gestione dell'alimentazione</translation>
<translation id="9088433379343318874">Abilita il provider di contenuti dell'utente supervisionato</translation>
<translation id="9088444059179765143">Configura il metodo di rilevamento automatico del fuso orario</translation>
<translation id="9094064873808699479">Esegui il rollback e rimani nella versione target se la versione del sistema operativo è più recente di quella target. Prova a trasferire la configurazione a livello di dispositivo (incluse le credenziali di rete) tramite la procedura di rollback, se possible, ma esegui il rollback con il powerwash completo anche se il ripristino dei dati non è possibile (perché la versione target non supporta il ripristino dei dati o a causa di una modifica non compatibile con le versioni precedenti).
          Supportato su <ph name="PRODUCT_OS_NAME" /> 70 e versioni successive. Per i client precedenti, questo valore indica che il rollback è disattivato.</translation>
<translation id="9096086085182305205">Whitelist server di autenticazione</translation>
<translation id="9105265795073104888">Solo un sottoinsieme di opzioni di configurazione del proxy viene reso disponibile alle app Android, che decidono volontariamente se rispettarlo o meno. Non puoi forzarle a utilizzare un proxy.</translation>
<translation id="9106865192244721694">Consenti WebUSB su questi siti</translation>
<translation id="9112727953998243860">File di configurazione delle stampanti aziendali</translation>
<translation id="9112897538922695510">Ti consente di registrare un elenco di gestori di protocolli. Questa può essere soltanto una norma consigliata. Per la proprietà |protocol| dovrebbe essere impostato lo schema, ad esempio "mailto", e per la proprietà |url| dovrebbe essere impostato il pattern URL dell'applicazione che gestisce lo schema. Il pattern può includere "%s" che, se presente, verrà sostituito dall'URL gestito.

          I gestori di protocolli registrati tramite la norma vengono uniti a quelli registrati dall'utente e possono essere utilizzati entrambi i tipi. L'utente può sostituire i gestori di protocolli installati tramite la norma installando un nuovo gestore predefinito, ma non può rimuovere un gestore di protocollo registrato tramite la norma.</translation>
<translation id="9123211093995421438">Consente di specificare il numero minimo di obiettivi di <ph name="PRODUCT_OS_NAME" /> consentiti per il rollback a partire dalla versione stabile in qualsiasi momento.

      L'impostazione predefinita è 0 per il consumatore, 4 (circa sei mesi) per i dispositivi aziendali registrati.

      Se imposti questa norma impedisci che la protezione del rollback venga applicata, come minimo, a questo numero di obiettivi.

      Se imposti un valore più basso per questa norma, l'effetto è permanente: il dispositivo POTREBBE non essere in grado di eseguire il rollback alle versioni precedenti anche dopo aver reimpostato un valore maggiore della norma.

      Le possibilità effettive di eseguire il rollback potrebbero dipendere anche dal modello di dispositivo e dalle patch di vulnerabilità critiche.</translation>
<translation id="9126014181388780690">"Consenti all'Assistente Google di accedere al contesto dello schermo"</translation>
<translation id="913195841488580904">Blocca l'accesso a un elenco di URL</translation>
<translation id="9135033364005346124">Attiva proxy <ph name="CLOUD_PRINT_NAME" /></translation>
<translation id="9136399279941091445">Intervalli di orari di minore attività quando vengono rilasciate le norme del dispositivo specificate</translation>
<translation id="9147029539363974059">Consente di inviare log di sistema al server di gestione per consentire
      agli amministratori di monitorare i log di sistema.

      Se questa norma viene impostata su true, i log di sistema vengono inviati. Se viene impostata
      su false o non viene impostata, i log di sistema non vengono inviati.</translation>
<translation id="9150416707757015439">Questa norma è obsoleta. Utilizza IncognitoModeAvailability. Consente di attivare la modalità di navigazione in incognito in <ph name="PRODUCT_NAME" />. Se questa impostazione viene attivata o non viene configurata, gli utenti potranno aprire le pagine web in modalità di navigazione in incognito. Se l'impostazione viene disattivata, gli utenti non potranno aprire le pagine web in modalità di navigazione in incognito. Se questa norma non viene impostata, l'impostazione verrà attivata e gli utenti potranno utilizzare la modalità di navigazione in incognito.</translation>
<translation id="915194831143859291">Se questa norma viene impostata su false o non viene configurata, <ph name="PRODUCT_OS_NAME" /> consente all'utente di spegnere il dispositivo.
      Se questa norma viene impostata su true, <ph name="PRODUCT_OS_NAME" /> attiva il riavvio quando l'utente spegne il dispositivo. <ph name="PRODUCT_OS_NAME" /> sostituisce tutte le occorrenze dei pulsanti di spegnimento nell'interfaccia utente con pulsanti di riavvio. Se l'utente spegne il dispositivo utilizzando il tasto di accensione, il dispositivo non viene riavviato, anche se la norma è attivata.</translation>
<translation id="9152473318295429890">Attiva i suggerimenti contestuali delle pagine web correlate</translation>
<translation id="9158929520101169054">Consenti accesso simultaneo nel browser</translation>
<translation id="9159126470527871268">Consente di inviare agli utenti una notifica che comunica che <ph name="PRODUCT_NAME" /> o <ph name="PRODUCT_OS_NAME" /> deve essere riavviato per applicare un aggiornamento in sospeso

      Questa impostazione della norma attiva le notifiche che informano l'utente che è consigliabile oppure obbligatorio riavviare il browser o il dispositivo. Se non è impostata, <ph name="PRODUCT_NAME" /> indica all'utente che è necessario un riavvio tramite piccole modifiche al menu, mentre <ph name="PRODUCT_OS_NAME" /> indica ciò con una notifica nella barra delle applicazioni. Se l'impostazione è "Recommended", all'utente verrà mostrato un avviso ricorrente con un riavvio consigliato. L'utente può ignorare questo avviso e rimandare il riavvio. Se impostata su "Required", verrà visualizzato un avviso ricorrente all'utente che indica che il riavvio del browser sarà forzato una volta trascorso il periodo di notifica. Per impostazione predefinita, il periodo di notifica è di sette giorni per <ph name="PRODUCT_NAME" /> e di quattro giorni per <ph name="PRODUCT_OS_NAME" /> e può essere configurato tramite l'impostazione della norma <ph name="RELAUNCH_NOTIFICATION_PERIOD_POLICY_NAME" />.

      La sessione dell'utente viene ripristinata dopo il riavvio.</translation>
<translation id="9165792353046089850">Consente di stabilire se consentire o meno ai siti web di accedere ai dispositivi USB collegati. L'accesso può essere bloccato completamente oppure l'utente può ricevere una richiesta ogni volta che un sito web vuole accedere ai dispositivi USB collegati.

          Questa norma può essere sostituita per pattern URL specifici che utilizzano le norme "WebUsbAskForUrls" e "WebUsbBlockedForUrls".

          Se questa norma non viene impostata, verrà utilizzato il valore "3", che potrà essere modificato dall'utente.</translation>
<translation id="9167719789236691545">Disattiva Drive nell'app File di <ph name="PRODUCT_OS_NAME" /></translation>
<translation id="9185107612228451403">Configura le norme relative alle estensioni. L'utente non può installare estensioni presenti nella lista nera, a meno che non siano inserite nella lista bianca. È possibile anche forzare <ph name="PRODUCT_NAME" /> affinché installi automaticamente le estensioni specificandole in <ph name="EXTENSION_INSTALL_FORCELIST_POLICY_NAME" />. Le estensioni a installazione forzata sono installate indipendentemente dalla loro presenza nella lista nera.</translation>
<translation id="9187743794267626640">Disabilita il montaggio di una memoria esterna</translation>
<translation id="9197740283131855199">Percentuale di regolazione del ritardo di oscuramento dello schermo se l'utente diventa attivo dopo l'oscuramento</translation>
<translation id="9200828125069750521">Parametri per l'URL dell'immagine che utilizza POST</translation>
<translation id="920209539000507585">Consente di forzare l'attivazione o la disattivazione dell'opzione "Intestazioni e piè di pagina" nella finestra di dialogo Stampa.

      Se la norma non viene impostata, l'utente può decidere se stampare o meno le intestazioni e i piè di pagina.

      Se la norma viene impostata su false, l'opzione "Intestazioni e piè di pagina" non viene selezionata nella finestra di dialogo dell'anteprima di stampa e l'utente non può modificarla.

      Se la norma viene impostata su true, l'opzione "Intestazioni e piè di pagina" viene selezionata nella finestra di dialogo dell'anteprima di stampa e l'utente non può modificarla.</translation>
<translation id="9213347477683611358">Configura l'immagine di sfondo a livello del dispositivo che viene mostrata nella schermata di accesso nel caso in cui nessun utente abbia ancora effettuato l'accesso al dispositivo. Questa norma viene impostata specificando l'URL dal quale il dispositivo Chrome OS può scaricare l'immagine di sfondo e un hash crittografico la cui funzione è quella di verificare l'integrità del download. L'immagine deve essere in formato JPEG e non deve superare le dimensioni di 16 MB. L'URL specificato deve essere accessibile senza bisogno di autenticazione. L'immagine di sfondo viene scaricata e memorizzata nella cache. Verrà scaricata nuovamente ogni volta che l'URL e l'hash vengono modificati.

      La norma deve essere specificata sotto forma di stringa in cui l'URL e l'hash vengono espressi in formato JSON, ad esempio,
      {
        "url": "https://example.com/device_wallpaper.jpg",
        "hash": "examplewallpaperhash"
      }

      Nel caso in cui sia impostata la norma dello sfondo del dispositivo, il dispositivo Chrome OS scaricherà e utilizzerà l'immagine di sfondo nella schermata di accesso se nessun utente ha ancora effettuato l'accesso al dispositivo. Quando un utente accede, si attiva la norma dello sfondo dell'utente.

      Nel caso in cui non venga impostata la norma dello sfondo del dispositivo, è la norma dello sfondo dell'utente a decidere cosa mostrare se si imposta la norma dello sfondo del dispositivo.</translation>
<translation id="9217154963008402249">Frequenza dei pacchetti di rete di monitoraggio</translation>
<translation id="922540222991413931">Configura fonti di installazione di estensioni, applicazioni e script utente</translation>
<translation id="924557436754151212">Importa password salvate dal browser predefinito alla prima esecuzione</translation>
<translation id="926146562923985266">Questa norma consente di stabilire il comando da utilizzare per aprire gli URL in <ph name="PRODUCT_NAME" /> anziché in Internet Explorer.

      Se il componente aggiuntivo "Supporto dei browser precedenti" per Internet Explorer non è installato, questa norma non viene applicata.

      Quando questa norma non viene impostata, Internet Explorer rileverà automaticamente il percorso eseguibile di <ph name="PRODUCT_NAME" /> all'avvio di <ph name="PRODUCT_NAME" /> da Internet Explorer.

      Quando la norma è impostata, verrà usata per avviare <ph name="PRODUCT_NAME" /> quando si avvia <ph name="PRODUCT_NAME" /> da Internet Explorer.

      Per questa norma è possibile impostare un percorso di file eseguibile oppure ${chrome} per rilevare automaticamente il percorso di installazione di Chrome.</translation>
<translation id="930930237275114205">Imposta la directory dei dati utente di <ph name="PRODUCT_FRAME_NAME" /></translation>
<translation id="943865157632139008">Consente di configurare il renderer HTML predefinito quando è installato <ph name="PRODUCT_FRAME_NAME" />.
      Per impostazione predefinita, l'host browser esegue il rendering, ma in alternativa è possibile sostituire questa impostazione e far sì che <ph name="PRODUCT_FRAME_NAME" /> esegua il rendering delle pagine HTML per impostazione predefinita.</translation>
<translation id="944817693306670849">Imposta dimensioni cache su disco</translation>
<translation id="966854160628341653">Consente di stabilire se <ph name="PRODUCT_OS_NAME" /> permette la creazione di nuovi account utente. Se la norma è impostata su false, gli utenti che non hanno ancora un account non potranno accedere.

      Se la norma viene impostata su true o non è configurata, sarà possibile creare nuovi account utente purché <ph name="DEVICE_USER_WHITELIST_POLICY_NAME" /> non impedisca all'utente di accedere.</translation>
<translation id="981346395360763138">Servizi di geolocalizzazione di Google disabilitati</translation>
<translation id="982497069985795632">Attiva il controllo ortografico</translation>
<translation id="991560005425213776">Invia nome utente e nome file alle stampanti native</translation>
</translationbundle>