<?xml version="1.0" ?>
<!DOCTYPE translationbundle>
<translationbundle lang="nl">
<translation id="1503959756075098984">Extensie-id's en update-URL's worden op de achtergrond geïnstalleerd</translation>
<translation id="793134539373873765">Specificeert of p2p wordt gebruikt voor netto-updateladingen voor het besturingssysteem. Als dit is ingesteld op 'Waar', proberen apparaten netto-updateladingen (payloads) op te halen via het LAN, waardoor bandbreedtegebruik en vertraging kunnen worden verminderd. Als de netto-updatelading niet beschikbaar is via het LAN, gaat het apparaat over tot downloaden via een updateserver. Als deze instelling is ingesteld op 'Niet waar' of niet is geconfigureerd, wordt 2p2 niet gebruikt.</translation>
<translation id="2463365186486772703">Landinstelling voor applicatie</translation>
<translation id="1397855852561539316">Voorgestelde URL voor standaardzoekprovider</translation>
<translation id="3347897589415241400">Het standaardgedrag voor sites die zich niet in een inhoudspakket bevinden.

          Dit beleid is bedoeld voor intern gebruik door Chrome zelf.</translation>
<translation id="7040229947030068419">Voorbeeldwaarde:</translation>
<translation id="1213523811751486361">Hiermee wordt de URL gespecificeerd voor de zoekmachine die wordt gebruikt om zoeksuggesties te leveren. De URL moet de tekenreeks '<ph name="SEARCH_TERM_MARKER"/>' bevatten, die op het moment van de zoekopdracht wordt vervangen door de tekst die de gebruiker tot op dat moment heeft getypt. Dit beleid is optioneel. Als het beleid niet is ingesteld, wordt er geen suggestie-URL gebruikt. Dit beleid wordt alleen gerespecteerd als het beleid 'DefaultSearchProviderEnabled' is ingeschakeld.</translation>
<translation id="6106630674659980926">Wachtwoordbeheer inschakelen</translation>
<translation id="7109916642577279530">Het vastleggen van audio toestaan of weigeren.

      Als deze instelling is ingeschakeld of niet is geconfigureerd (standaard), wordt de gebruiker gevraagd naar
      toegang tot het vastleggen van audio, met uitzondering van URL's die zijn geconfigureerd in de lijst
      AudioCaptureAllowedUrls (die zonder prompt toegang krijgen).

      Wanneer dit beleid is uitgeschakeld, ziet de gebruiker nooit een prompt en is het vastleggen van
      audio alleen beschikbaar voor URL's die in AudioCaptureAllowedUrls zijn geconfigureerd.

      Dit beleid heeft invloed op alle typen van audio-invoer en niet alleen de ingebouwde microfoon.</translation>
<translation id="9150416707757015439">Dit beleid is verouderd. Gebruik in plaats hiervan 'IncognitoModeAvailability'.
      Schakelt de incognitomodus in <ph name="PRODUCT_NAME"/> in.

      Als deze instelling is ingeschakeld of niet is geconfigureerd, kunnen gebruikers webpagina's openen in de incognitomodus.

      Als deze instelling is uitgeschakeld, kunnen gebruikers geen webpagina's openen in de incognitomodus.

      Als dit beleid niet is ingesteld, wordt dit ingeschakeld en kan de gebruiker de incognitomodus gebruiken.</translation>
<translation id="4203389617541558220">De bedrijfstijd van het apparaat beperken door automatisch opnieuw opstarten te plannen.

      Wanneer dit beleid is ingesteld, bepaalt het de duur van de bedrijfstijd van het apparaat waarna het automatisch opnieuw opstarten is gepland.

      Wanneer dit beleid niet is ingesteld, is de bedrijfstijd van het apparaat niet beperkt.

      Als je dit beleid inschakelt, kunnen gebruikers dit niet wijzigen of negeren.

      Het automatisch opnieuw opstarten is gepland op het geselecteerde tijdstip maar kan tot 24 uur worden uitgesteld op het apparaat als een gebruiker het apparaat op dat moment gebruikt.

      Opmerking: momenteel is automatisch opnieuw opstarten alleen ingeschakeld als het inlogscherm wordt weergegeven of een kiosk-appsessie wordt verwerkt. Binnenkort wordt dit veranderd en is het beleid altijd van toepassing, ongeacht of er een sessie van een bepaald type wordt verwerkt.

      De beleidswaarde moet in seconden worden ingevoerd. Waarden worden vastgezet zodat deze ten minste 3600 (één uur) zijn.</translation>
<translation id="5304269353650269372">Hiermee wordt de tijdsduur zonder gebruikersinvoer gespecificeerd waarna een waarschuwingsdialoogvenster wordt weergegeven wanneer op de accu wordt gewerkt.

          Als dit beleid is ingesteld, specificeert het de tijdsduur dat de gebruiker inactief moet zijn voordat <ph name="PRODUCT_OS_NAME"/> een waarschuwingsdialoogvenster aan de gebruiker laat zien om aan te geven dat de actie voor inactiviteit bijna wordt ondernomen.

          Als dit beleid niet is ingesteld, wordt er geen waarschuwingsdialoogvenster weergegeven.

          De beleidswaarde moet worden opgegeven in milliseconden. De waarde die wordt opgegeven, moet kleiner zijn dan of gelijk aan de inactieve vertraging.</translation>
<translation id="7818131573217430250">De standaardstatus van de modus voor hoog contrast op het inlogscherm instellen</translation>
<translation id="7614663184588396421">Lijst met uitgeschakelde protocolschema's</translation>
<translation id="2309390639296060546">Standaardinstelling voor geolocatie</translation>
<translation id="1313457536529613143">Bepaalt het percentage waarmee de dimvertraging van het scherm wordt geschaald wanneer er activiteit van de gebruiker wordt waargenomen terwijl het scherm is gedimd of kort nadat het scherm is uitgeschakeld.

          Als dit beleid is ingeschakeld, bepaalt het het percentage waarmee de dimvertraging van het scherm wordt geschaald wanneer er activiteit van de gebruiker wordt waargenomen terwijl het scherm is gedimd of kort nadat het scherm is uitgeschakeld. Wanneer de dimvertraging is geschaald, worden de vertragingen 'Scherm uit', 'Schermvergrendeling' en 'Inactief' aangepast om dezelfde afstand van de dimvertraging van het scherm te behouden zoals oorspronkelijk was geconfigureerd.

          Als dit beleid niet is ingesteld, wordt een standaardschaalfactor gebruikt.

          De schaalfactor moet 100% of meer zijn.</translation>
<translation id="7443616896860707393">Prompts voor algemene HTTP-authenticatie met verschillende herkomst</translation>
<translation id="2337466621458842053">Hiermee kun je een lijst URL-patronen instellen waarmee sites worden gespecificeerd waarop afbeeldingen kunnen worden weergegeven.

          Als dit beleid niet is ingesteld, wordt de algemene standaardwaarde gebruikt voor alle sites op basis van het beleid 'DefaultImagesSetting' (als dit is ingesteld) of anders op basis van de configuratie van de gebruiker.</translation>
<translation id="4680961954980851756">Automatisch aanvullen inschakelen</translation>
<translation id="5183383917553127163">Hiermee kun je opgeven welke extensies niet op de zwarte lijst staan.

          Een waarde van '*' op de zwarte lijst betekent dat alle extensies op de zwarte lijst staan. Gebruikers kunnen alleen extensies installeren die op de witte lijst staan.

          Standaard staan alle extensies op de witte lijst, maar als alle extensies door een beleidsmaatregel op de zwarte lijst zijn geplaatst, kan de witte lijst worden gebruikt om dat beleid voor specifieke extensies op te heffen.</translation>
<translation id="5921888683953999946">De standaardstatus van de toegankelijkheidsfunctie 'Grote muisaanwijzer' op het inlogscherm instellen.

          Als dit beleid op 'waar' is ingesteld, wordt de grote muisaanwijzer ingeschakeld als het inlogscherm wordt weergegeven.

          Als dit beleid op 'onwaar' is ingesteld, wordt de grote muisaanwijzer uitgeschakeld als het inlogscherm wordt weergegeven.

          Als je dit beleid instelt, kunnen gebruikers dit tijdelijk negeren door de grote muisaanwijzer in of uit te schakelen. De keuze van de gebruiker is echter niet permanent en de standaardinstelling wordt hersteld wanneer het inlogscherm opnieuw wordt weergegeven of als de gebruiker gedurende een minuut niet actief is op het inlogscherm.

          Als dit beleid niet is ingesteld, wordt de grote muisaanwijzer uitgeschakeld wanneer het inlogscherm voor de eerste keer wordt weergegeven. Gebruikers kunnen de grote muisaanwijzer op elk moment in- of uitschakelen en de status op het inlogscherm is van toepassing op alle gebruikers.</translation>
<translation id="3185009703220253572">sinds versie <ph name="SINCE_VERSION"/></translation>
<translation id="2204753382813641270">Automatisch verbergen van archief beheren</translation>
<translation id="3816312845600780067">Sneltoets voor automatisch inloggen inschakelen</translation>
<translation id="3214164532079860003">Indien ingeschakeld, wordt met dit beleid afgedwongen dat de startpagina wordt geïmporteerd uit de huidige standaardbrowser.

      Als dit beleid is uitgeschakeld, wordt de startpagina niet geïmporteerd.

      Als dit beleid niet is ingesteld, kan de gebruiker worden gevraagd of deze wil importeren, of wordt er automatisch geïmporteerd.</translation>
<translation id="5330684698007383292"><ph name="PRODUCT_FRAME_NAME"/> toestaan de volgende soorten inhoud te verwerken.</translation>
<translation id="6647965994887675196">Als dit wordt ingesteld op 'true' (waar), kunnen bewaakte gebruikers worden gemaakt en gebruikt.

          Als dit wordt ingesteld op 'false' (niet waar) of niet wordt geconfigureerd, wordt het maken van en inloggen voor bewaakte gebruikers uitgeschakeld. Alle bestaande bewaakte gebruikers worden verborgen.

          OPMERKING: het standaardgedrag voor zakelijke en consumentenapparaten verschilt: op consumentenapparaten zijn bewaakte gebruikers standaard ingeschakeld, maar op zakelijke apparaten zijn ze standaard uitgeschakeld.</translation>
<translation id="69525503251220566">Parameter die een functie voor zoeken op afbeelding levert voor de standaardzoekprovider</translation>
<translation id="5469825884154817306">Afbeeldingen blokkeren op deze sites</translation>
<translation id="5827231192798670332">De strategie selecteren die wordt gebruikt om schijfruimte vrij te maken tijdens het automatisch opschonen</translation>
<translation id="8412312801707973447">Uitvoer van online OCSP/CRL-controles</translation>
<translation id="6649397154027560979">Dit  beleid is verouderd, gebruik URLBlacklist.

      Hiermee schakel je de vermelde protocolschema's in <ph name="PRODUCT_NAME"/> uit.

      URL's die een schema van deze lijst gebruiken worden niet geladen en kunnen niet worden geopend.

      Als je dit beleid niet instelt of als de lijst leeg is, zijn alle schema's toegankelijk in <ph name="PRODUCT_NAME"/>.</translation>
<translation id="3213821784736959823">Hiermee wordt bepaald of de ingebouwde DNS-client wordt gebruikt in <ph name="PRODUCT_NAME"/>.

      Als dit beleid is ingesteld op 'waar', wordt de ingebouwde DNS-client gebruikt (indien beschikbaar).

      Als dit beleid is ingesteld op 'onwaar', wordt de ingebouwde DNS-client nooit gebruikt.

      Als dit beleid niet wordt ingesteld, kunnen de gebruikers wijzigen of de ingebouwde DNS-client wordt gebruikt door chrome://flags te bewerken of een opdrachtregelmarkering op te geven.</translation>
<translation id="2908277604670530363">Maximaal aantal gelijktijdige verbindingen met de proxyserver</translation>
<translation id="556941986578702361">Het automatisch verbergen van het <ph name="PRODUCT_OS_NAME"/>-archief beheren.

      Als dit beleid is ingesteld op 'AlwaysAutoHideShelf', wordt het archief altijd automatisch verborgen.

      Als dit beleid is ingesteld op 'NeverAutoHideShelf', wordt het archief nooit automatisch verborgen.

      Als je dit beleid instelt, kunnen gebruikers het niet wijzigen of overschrijven.

      Als het beleid niet wordt ingesteld, kunnen gebruikers kiezen of het archief automatisch wordt verborgen.</translation>
<translation id="4838572175671839397">Bevat een reguliere expressie die wordt gebruikt om te bepalen welke gebruikers kunnen inloggen bij <ph name="PRODUCT_NAME"/>. Er wordt een fout weergegeven als een gebruiker probeert in te loggen met een gebruikersnaam die niet overeenkomt met dit patroon. Als dit beleid niet wordt ingesteld of leeg blijft, kan elke gebruiker inloggen op <ph name="PRODUCT_NAME"/>.</translation>
<translation id="2892225385726009373">Als deze instelling is ingeschakeld, voert <ph name="PRODUCT_NAME"/> altijd een intrekkingscontrole uit voor servercertificaten die kunnen worden gevalideerd en zijn ondertekend door lokaal geïnstalleerde CA-certificaten.

      Als <ph name="PRODUCT_NAME"/> geen informatie over de intrekkingsstatus kan verkrijgen, worden dergelijke certificaten beschouwd als ingetrokken ('hard-fail').

      Als dit beleid niet is ingesteld of is ingesteld op 'onwaar', gebruikt Chrome de bestaande instellingen voor online intrekkingscontrole.</translation>
<translation id="1438955478865681012">Hiermee wordt extensiegerelateerd beleid geconfigureerd. De gebruiker mag geen extensies installeren die op de zwarte lijst staan, tenzij ze ook op de witte lijst staan. Je kunt ook instellen dat <ph name="PRODUCT_NAME"/> extensies automatisch installeert, door deze te specificeren in <ph name="EXTENSIONINSTALLFORCELIST_POLICY_NAME"/>. Voor de lijst met automatisch geïnstalleerde extensies heeft de zwarte lijst voorrang op de witte lijst.</translation>
<translation id="3516856976222674451">Hiermee wordt de maximale lengte van een gebruikerssessie beperkt.

      Als dit beleid is ingesteld, geeft het de periode op waarna een gebruiker automatisch wordt uitgelogd en de sessie wordt beëindigd. De gebruiker wordt geïnformeerd over de resterende tijd door een aftel-timer die in de systeembalk wordt weergegeven.

      Als dit beleid niet is ingesteld, wordt de sessieduur niet beperkt.

      Als je dit beleid instelt, kunnen gebruikers het niet wijzigen of overschrijven.

      De beleidswaarde moet worden opgegeven in milliseconden. Waarden worden afgerond tot een bereik van 30 seconden tot 24 uur.</translation>
<translation id="9200828125069750521">Parameters voor afbeeldings-URL die POST gebruikt</translation>
<translation id="2769952903507981510">De vereiste domeinnaam configureren voor hosts voor externe toegang</translation>
<translation id="8294750666104911727">Normaal worden pagina's waarvoor X-UA-Compatible is ingesteld op chrome=1, weergegeven in <ph name="PRODUCT_FRAME_NAME"/> ongeacht het beleid 'ChromeFrameRendererSettings'.

          Als je deze instelling inschakelt, worden pagina's niet gescand op metatags.

          Als je deze instelling uitschakelt, worden pagina's gescand op metatags.

          Als dit beleid niet is geconfigureerd, worden pagina's gescand op metatags.</translation>
<translation id="3478024346823118645">Gebruikersgegevens wissen bij uitloggen</translation>
<translation id="8668394701842594241">Hiermee wordt een lijst met plug-ins gespecificeerd die zijn ingeschakeld in <ph name="PRODUCT_NAME"/> en wordt voorkomen dat gebruikers deze instelling kunnen wijzigen.

      De jokertekens '*' en '?' kunnen worden gebruikt om overeenkomsten met willekeurige tekens te zoeken. '*' komt overeen met een willekeurig aantal tekens terwijl '?' één optioneel teken specificeert en dus kan overeenkomen met één of nul tekens. Het teken '\' kan worden gebruikt om deze tekens te escapen, dus als je overeenkomsten voor de letterlijke tekens '*', '?' of '\' wilt zoeken, moet je er een '\' vóór plaatsen.

      De gespecificeerde lijst met plug-ins wordt altijd gebruikt in <ph name="PRODUCT_NAME"/> als deze plug-ins zijn geïnstalleerd. De plug-ins zijn gemarkeerd als ingeschakeld in 'about:plugins' en gebruikers kunnen ze niet uitschakelen.

      Houd er rekening mee dat dit beleid voorrang heeft op zowel DisabledPlugins als DisabledPluginsExceptions.

      Als dit beleid niet wordt ingesteld, kan de gebruiker alle plug-ins verwijderen die op het systeem zijn geïnstalleerd.</translation>
<translation id="653608967792832033">Hiermee wordt de tijdsduur zonder input van gebruikers gespecificeerd waarna het scherm wordt vergrendeld wanneer op de accu wordt gewerkt.

          Als dit beleid is ingesteld op een grotere waarde dan nul, specificeert het de tijd die de gebruiker inactief moet blijven voordat het scherm wordt vergrendeld door <ph name="PRODUCT_OS_NAME"/>.

          Als dit beleid is ingesteld op nul, wordt het scherm niet vergrendeld door <ph name="PRODUCT_OS_NAME"/> wanneer de gebruiker inactief wordt.

          Als dit beleid niet is ingesteld, wordt een standaardtijdsduur gebruikt.

          De aanbevolen manier om het scherm bij inactiviteit te vergrendelen is door schermvergrendeling bij onderbreking in te schakelen en <ph name="PRODUCT_OS_NAME"/> te onderbreken na de inactieve vertraging. Dit beleid mag alleen worden gebruikt wanneer schermvergrendeling veel eerder voorkomt dan onderbreking of wanneer onderbreking bij inactiviteit helemaal niet gewenst is.

          De beleidswaarde moet worden opgegeven in milliseconden. Waarden moeten lager zijn dan de inactieve vertraging.</translation>
<translation id="4157003184375321727">Besturingssysteem- en firmwareversie rapporteren</translation>
<translation id="4752214355598028025">De service Safe Browsing geeft een waarschuwingspagina weer wanneer gebruikers naar sites gaan die zijn gemarkeerd als potentieel schadelijk. Als je deze instelling inschakelt, voorkom je dat gebruikers vanaf de waarschuwingspagina toch doorgaan naar de schadelijke site.

      Als deze instelling is uitgeschakeld of niet is geconfigureerd, kunnen gebruikers ervoor kiezen door te gaan naar de gemarkeerde site nadat de waarschuwing is weergegeven.</translation>
<translation id="5255162913209987122">Kan worden aanbevolen</translation>
<translation id="1861037019115362154">Hiermee geef je een lijst met plug-ins op die zijn uitgeschakeld <ph name="PRODUCT_NAME"/> en voorkom je dat gebruikers deze instelling kunnen wijzigen.

      De jokertekens '*' en '?' kunnen worden gebruikt om overeenkomsten met willekeurige tekens te zoeken. '*' komt overeen met een willekeurig aantal tekens terwijl '?' één optioneel teken aangeeft (dat wil zeggen, overeenkomsten met nul of één teken). Het escape-teken '\' kan worden gebruikt om deze tekens te escapen, dus als je overeenkomsten voor de letterlijke tekens '*', '?' of '\' wilt zoeken, kun je een '\' vóór deze tekens plaatsen.

      Als je deze instelling inschakelt, wordt de lijst met opgegeven plug-ins nooit gebruikt in <ph name="PRODUCT_NAME"/>. De plug-ins zijn gemarkeerd als 'uitgeschakeld' in 'about:plugins' en gebruikers kunnen deze niet inschakelen.

      Houd er rekening mee dat dit beleid kan worden overschreven door EnabledPlugins en DisabledPluginsExceptions.

      Als dit beleid niet is ingesteld, kan de gebruiker alle plug-ins gebruiken die op het systeem zijn geïnstalleerd, met uitzondering van plug-ins die hardcoded incompatibel, verouderd of gevaarlijk zijn.</translation>
<translation id="9197740283131855199">Percentage waarmee de dimvertraging van het scherm wordt geschaald als de gebruiker actief wordt na het dimmen</translation>
<translation id="1492145937778428165">Hiermee wordt de periode in milliseconden gespecificeerd waarna de apparaatbeheerservice wordt gevraagd informatie te verstrekken over het gebruikersbeleid.

      Als je dit beleid instelt, wordt de standaardwaarde van 3 uur overschreven. Geldige waarden voor dit beleid liggen tussen 1800000 (30 minuten) en 86400000 (1 dag). Alle waarden die niet binnen dit bereik vallen, worden afgerond tot de boven- of ondergrens.

      Als je dit beleid niet instelt, gebruikt <ph name="PRODUCT_OS_NAME"/> de standaardwaarde van 3 uur.</translation>
<translation id="3765260570442823273">Duur van de waarschuwing bij uitloggen inactieve gebruiker</translation>
<translation id="7302043767260300182">Vertraging van schermvergrendeling wanneer op netstroom wordt gewerkt</translation>
<translation id="7331962793961469250">Wanneer dit is ingesteld op 'True', worden promoties voor apps van de Chrome Web Store niet weergegeven op de pagina 'Nieuw tabblad'.

      Als je deze optie instelt op 'False' of deze niet instelt, worden promoties voor apps van de Chrome Web Store wel op de pagina 'Nieuw tabblad' weergegeven.</translation>
<translation id="7271085005502526897">Startpagina importeren uit standaardbrowser bij eerste uitvoering</translation>
<translation id="6036523166753287175">Firewallpassage vanaf host voor externe toegang inschakelen</translation>
<translation id="1096105751829466145">Standaardzoekprovider</translation>
<translation id="7567380065339179813">Plug-ins toestaan op deze sites</translation>
<translation id="4555850956567117258">Externe bevestiging van gebruiker inschakelen</translation>
<translation id="5966615072639944554">Extensies die toestemming hebben de API voor externe bevestiging te gebruiken</translation>
<translation id="1617235075406854669">Verwijderen van browser- en downloadgeschiedenis inschakelen</translation>
<translation id="5290940294294002042">Een lijst met plug-ins opgeven die de gebruiker kan in- of uitschakelen</translation>
<translation id="3153348162326497318">Hiermee kun je specificeren welke extensies gebruikers NIET kunnen installeren. Als geïnstalleerde extensies op de zwarte lijst voorkomen, worden ze verwijderd.

          De waarde '*' van een zwarte lijst houdt in dat alle extensies op de zwarte lijst worden geplaatst, tenzij ze expliciet op de witte lijst worden vermeld.

          Als dit beleid niet wordt ingesteld, kan de gebruiker alle extensies installeren in <ph name="PRODUCT_NAME"/>.</translation>
<translation id="3067188277482006117">Indien ingesteld als 'true', kan de gebruiker met de hardware van Chrome-apparaten de identiteit ervan extern bewijzen aan de privacy-CA via de Enterprise Platform Keys-API chrome.enterprise.platformKeysPrivate.challengeUserKey().

          Indien aanroepen zijn ingesteld als 'false' of als ze niet zijn ingesteld, zullen aanroepen van de API mislukken en wordt een foutcode weergegeven.</translation>
<translation id="5809728392451418079">De weergavenaam voor lokale accounts van het apparaat instellen</translation>
<translation id="1427655258943162134">Adres of URL van proxyserver</translation>
<translation id="1827523283178827583">Vaste proxyservers gebruiken</translation>
<translation id="3021409116652377124">Plug-inzoeker uitschakelen</translation>
<translation id="7236775576470542603">Het standaardtype van vergrootglas instellen dat op het inlogscherm is ingeschakeld.

          Als dit beleid is ingesteld, bepaalt het het type vergrootglas dat is ingeschakeld wanneer het inlogscherm wordt weergegeven. Als je het beleid op 'Geen' instelt, wordt het vergrootglas uitgeschakeld.

          Als je dit beleid instelt, kunnen gebruikers dit tijdelijk negeren door het vergrootglas in of uit te schakelen. De keuze van de gebruiker is echter niet permanent en de standaardinstelling wordt hersteld wanneer het inlogscherm opnieuw wordt weergegeven of de gebruiker gedurende een minuut niet actief is op het inlogscherm.

          Als je dit beleid niet instelt, is het vergrootglas uitgeschakeld wanneer het inlogscherm voor de eerste keer wordt weergegeven. Gebruikers kunnen het vergrootglas op elk moment in- of uitschakelen en de status op het inlogscherm is van toepassing op alle gebruikers.</translation>
<translation id="5423001109873148185">Indien ingeschakeld, wordt met dit beleid afgedwongen dat zoekmachines worden geïmporteerd uit de huidige standaardbrowser. Als het beleid is ingeschakeld, is dit ook van invloed op het dialoogvenster voor importeren.

      Als het beleid is uitgeschakeld, wordt de standaardzoekmachine niet geïmporteerd.

      Als dit beleid niet is ingesteld, kan de gebruiker worden gevraagd of deze wil importeren, of wordt er automatisch geïmporteerd.</translation>
<translation id="3288595667065905535">Releasekanaal</translation>
<translation id="2785954641789149745">Hiermee schakel je de functie Veilig surfen van <ph name="PRODUCT_NAME"/> in en voorkom je dat gebruikers deze instelling wijzigen.

      Als je deze instelling inschakelt, is Veilig surfen altijd actief.

      Als je deze instelling uitschakelt, is Veilig surfen nooit actief.

      Als je deze instelling in- of uitschakelt, kunnen gebruikers de instelling 'Bescherming tegen phishing en malware inschakelen' in <ph name="PRODUCT_NAME"/> niet wijzigen of negeren.

      Als je deze instelling niet instelt, wordt deze uitgeschakeld maar kan de gebruiker deze wijzigen.</translation>
<translation id="268577405881275241">De proxyfunctie voor het comprimeren van gegevens inschakelen</translation>
<translation id="8369602308428138533">Vertraging van scherm uitschakelen wanneer op netstroom wordt gewerkt</translation>
<translation id="6513756852541213407">Hiermee kun je de proxyserver specificeren die door <ph name="PRODUCT_NAME"/> wordt gebruikt en wordt voorkomen dat gebruikers proxyinstellingen kunnen aanpassen.

          Als je ervoor kiest nooit een proxyserver te gebruiken en altijd rechtstreeks verbinding te maken, worden alle andere opties genegeerd.

          Als je ervoor kiest de proxyinstellingen van het systeem te gebruiken of de proxyserver automatisch te detecteren, worden alle andere opties genegeerd.

          Als je de modus voor een vaste proxyserver kiest, kun je verdere opties specificeren in 'Adres of URL van proxyserver' en 'Door komma's gescheiden lijst van regels voor proxyomzeiling'.

          Als je een proxyscript in een PAC-bestand gebruikt, moet je de URL met het script specificeren in 'URL naar een PAC-bestand voor de proxy'.

          Ga voor gedetailleerde voorbeelden naar:
          <ph name="PROXY_HELP_URL"/>

          Als je deze instelling inschakelt, negeert <ph name="PRODUCT_NAME"/> alle aan proxy's gerelateerde opties die via de opdrachtregel worden opgegeven.

          Als je dit beleid niet instelt, kunnen gebruikers zelf proxyinstellingen selecteren.</translation>
<translation id="7763311235717725977">Hiermee kun je instellen of het websites is toegestaan afbeeldingen weer te geven. Het weergeven van afbeeldingen kan worden toegestaan voor alle websites of worden geweigerd voor alle websites.

          Als dit beleid niet wordt ingesteld, wordt 'AllowImages' gebruikt en kan dit door de gebruiker worden gewijzigd.</translation>
<translation id="5630352020869108293">De laatste sessie herstellen</translation>
<translation id="2067011586099792101">Toegang blokkeren naar sites die zich niet in inhoudspakketten bevinden</translation>
<translation id="4980635395568992380">Gegevenstype:</translation>
<translation id="3096595567015595053">Lijst met ingeschakelde plug-ins</translation>
<translation id="3048744057455266684">Als dit beleid is ingesteld en een zoek-URL die is voorgesteld vanuit de omnibox, deze parameter in de zoekreeks of in de fragment-ID bevat, geeft de suggestie de zoektermen en zoekprovider weer en niet de onbewerkte zoek-URL.

          Dit beleid is optioneel. Als het niet wordt ingesteld, wordt er geen vervanging van zoektermen uitgevoerd.

          Dit beleid wordt alleen gerespecteerd als het beleid 'DefaultSearchProviderEnabled' is ingeschakeld.</translation>
<translation id="5912364507361265851">Gebruikers toestaan wachtwoorden weer te geven in Wachtwoordbeheer</translation>
<translation id="510186355068252378">Hiermee wordt gegevenssynchronisatie ingeschakeld in <ph name="PRODUCT_NAME"/> via door Google gehoste synchronisatieservices. Gebruikers kunnen deze instelling niet aanpassen.

      Als je deze instelling inschakelt, kunnen gebruikers de instelling niet aanpassen of negeren in <ph name="PRODUCT_NAME"/>.

      Als dit beleid niet wordt ingesteld, kan de gebruiker zelf besluiten Google Sync wel of niet te gebruiken.</translation>
<translation id="7953256619080733119">Hosts van handmatige uitzonderingen voor beheerde gebruikers</translation>
<translation id="7412982067535265896">Hiermee kun je een lijst met URL's opgeven voor sites die sessiecookies mogen instellen.

          Als dit beleid niet wordt ingesteld, wordt de algemene standaardwaarde gebruikt voor alle sites, die je vindt in het beleid 'Standaardinstellingen voor cookies', als dit is ingesteld, of in de persoonlijke configuratie van de gebruiker.

          Als het beleid voor 'Herstellen bij opstarten' zo is ingesteld dat URL's van eerdere sessies worden hersteld, blijft dit beleid gelden en worden cookies voor deze sites permanent opgeslagen.</translation>
<translation id="4807950475297505572">De gebruikers die het langst geleden gebruikt zijn, worden verwijderd totdat er voldoende vrije ruimte is</translation>
<translation id="8828766846428537606">Hiermee wordt de standaard startpagina in <ph name="PRODUCT_NAME"/> geconfigureerd en wordt voorkomen dat gebruikers deze instelling kunnen wijzigen.

      De instellingen voor de startpagina worden alleen volledig voor de gebruiker vergrendeld als je de pagina 'Nieuw tabblad' als de startpagina selecteert of als je zelf een URL voor de startpagina specificeert. Als je geen URL voor de startpagina opgeeft, kan de gebruiker nog steeds de pagina 'Nieuw tabblad' als startpagina instellen door 'chrome://newtab' op te geven.</translation>
<translation id="2231817271680715693">Browsergeschiedenis importeren uit standaardbrowser bij eerste uitvoering</translation>
<translation id="1353966721814789986">Startpagina's</translation>
<translation id="7173856672248996428">Kort geldig profiel</translation>
<translation id="1841130111523795147">Hiermee wordt toegestaan dat de gebruiker inlogt bij <ph name="PRODUCT_NAME"/> en wordt voorkomen dat gebruikers deze instelling wijzigen.

      Als je dit beleid instelt, kun je configureren of een gebruiker wel of niet mag inloggen bij <ph name="PRODUCT_NAME"/>.</translation>
<translation id="5564962323737505851">Hiermee wordt Wachtwoordbeheer geconfigureerd. Als Wachtwoordbeheer is ingeschakeld, kun je specificeren of de gebruiker opgeslagen wachtwoorden als leesbare tekst mag weergeven.</translation>
<translation id="4668325077104657568">Standaardinstelling voor afbeeldingen</translation>
<translation id="4492287494009043413">Het maken van screenshots uitschakelen</translation>
<translation id="6368403635025849609">JavaScript toestaan op deze sites</translation>
<translation id="6074963268421707432">Niet toestaan dat sites bureaubladmeldingen weergeven</translation>
<translation id="8614804915612153606">Schakelt 'Automatisch bijwerken' uit</translation>
<translation id="4834526953114077364">De gebruikers die het langst geleden gebruikt zijn en gedurende de laatste drie maanden niet zijn ingelogd, worden verwijderd totdat er voldoende vrije ruimte is</translation>
<translation id="382476126209906314">Het voorvoegsel voor het TalkGadget configureren voor hosts voor externe toegang</translation>
<translation id="6561396069801924653">Toegankelijkheidsopties weergeven in het systeemvakmenu</translation>
<translation id="8104962233214241919">Clientcertificaten automatisch selecteren voor deze sites</translation>
<translation id="2906874737073861391">Lijst met app-pakketextensies</translation>
<translation id="3758249152301468420">Hulpprogramma's voor ontwikkelaars uitschakelen</translation>
<translation id="8665076741187546529">De lijst met automatisch geïnstalleerde extensies configureren</translation>
<translation id="410478022164847452">Hiermee wordt de tijdsduur zonder input van gebruikers gespecificeerd waarna de vertragingsactie wordt ondernomen wanneer op netstroom wordt gewerkt.

          Als dit beleid is ingesteld, specificeert het de tijd die de gebruiker inactief moet blijven voordat de vertragingsactie wordt ondernomen door <ph name="PRODUCT_OS_NAME"/>. De vertragingsactie kan afzonderlijk worden geconfigureerd.

          Als dit beleid niet is ingesteld, wordt een standaardtijdsduur gebruikt.

          De beleidswaarde moet in milliseconden worden opgegeven.</translation>
<translation id="6598235178374410284">Avatarafbeelding van gebruiker</translation>
<translation id="1675391920437889033">Hiermee wordt bepaald welke typen apps/extensies mogen worden geïnstalleerd.

          Met deze instelling worden de toegestane typen extensies/apps die in <ph name="PRODUCT_NAME"/> kunnen worden geïnstalleerd op de witte lijst gezet. De waarde is een lijst met tekenreeksen waarbij elke tekenreeks een van de volgende zou moeten zijn: 'extension', 'theme', 'user_script', 'hosted_app', 'legacy_packaged_app', 'platform_app'. Raadpleeg de documentatie over Chrome-extensies voor meer informatie over deze typen.

          Houd er rekening mee dat dit beleid ook invloed heeft op extensies en apps die geforceerd worden geïnstalleerd via ExtensionInstallForcelist.

          Als deze instelling is geconfigureerd, worden extensies/apps met een type dat niet op de lijst staat, niet geïnstalleerd.

          Als deze instelling niet wordt geconfigureerd, worden er geen beperkingen afgedwongen voor de geaccepteerde typen extensies/apps.</translation>
<translation id="6378076389057087301">Specificeer of audioactiviteit invloed heeft op stroombeheer</translation>
<translation id="8818173863808665831">De geografische locatie van het apparaat rapporteren.

      Als het beleid niet is ingesteld of is ingesteld op 'False', wordt de locatie niet gerapporteerd.</translation>
<translation id="4899708173828500852">Safe Browsing inschakelen</translation>
<translation id="4442582539341804154">Vergrendeling inschakelen wanneer het apparaat inactief wordt of overschakelt op de slaapstand</translation>
<translation id="7719251660743813569">Controleert of gebruiksstatistieken worden gerapporteerd aan Google. Als dit is ingesteld op 'true', rapporteert <ph name="PRODUCT_OS_NAME"/> gebruiksstatistieken. Als het niet is geconfigureerd of is ingesteld op 'false', wordt de rapportage van statistieken uitgeschakeld.</translation>
<translation id="2372547058085956601">De vertraging voor automatisch inloggen bij de openbare sessie.

      Als het beleid |DeviceLocalAccountAutoLoginId| niet is ingesteld, heeft dit beleid geen effect. Anders:

      Als dit beleid is ingesteld, bepaalt het de tijdsduur zonder gebruikersactiviteit die moet verstrijken voordat er automatisch wordt ingelogd bij de openbare sessie gespecificeerd door het beleid |DeviceLocalAccountAutoLoginId|.

      Als dit beleid niet is ingesteld, wordt 0 milliseconden gebruikt als time-out.

      Dit beleid wordt opgegeven in milliseconden.</translation>
<translation id="7275334191706090484">Beheerde bladwijzers</translation>
<translation id="3570008976476035109">Plug-ins blokkeren op deze sites</translation>
<translation id="8749370016497832113">Hiermee wordt het verwijderen van de browsergeschiedenis en downloadgeschiedenis in <ph name="PRODUCT_NAME"/> ingeschakeld en wordt voorkomen dat gebruikers deze instelling wijzigen.

      Zelfs als dit beleid is uitgeschakeld, kan niet worden gegarandeerd dat de browser- en downloadgeschiedenis behouden blijven. Gebruikers kunnen de geschiedenisbestanden rechtstreeks bewerken of verwijderen en de browser kan sommige of alle geschiedenisitems op elk gewenst moment laten verlopen of archiveren.

      Als deze instelling is ingeschakeld of niet is ingesteld, kunnen de browsergeschiedenis en downloadgeschiedenis worden verwijderd.

      Als deze instelling is uitgeschakeld, kunnen de browsergeschiedenis en downloadgeschiedenis niet worden verwijderd.</translation>
<translation id="2884728160143956392">Sessiecookies toestaan op deze sites</translation>
<translation id="3021272743506189340">Hiermee wordt synchronisatie van Google Drive in de app Bestanden van Chrome OS uitgeschakeld wanneer een mobiele verbinding wordt gebruikt en de optie is ingesteld op 'true'. In dat geval worden gegevens alleen gesynchroniseerd met Google Drive als er een wifi- of Ethernet-verbinding is.

          Als de optie niet is ingesteld of is ingesteld op 'false', kunnen gebruikers via mobiele verbindingen bestanden naar Google Drive overzetten.</translation>
<translation id="4655130238810647237">Hiermee wordt het bewerken van bladwijzers in <ph name="PRODUCT_NAME"/> in- of uitgeschakeld.

      Als je deze instelling inschakelt, kunnen bladwijzers worden toegevoegd, verwijderd of aangepast. Dit is ook de standaardinstelling wanneer dit beleid niet is ingesteld.

      Als je deze instelling uitschakelt, kunnen er geen bladwijzers worden toegevoegd, verwijderd of aangepast. Bestaande bladwijzers zijn wel beschikbaar.</translation>
<translation id="3496296378755072552">Wachtwoordbeheer</translation>
<translation id="4372704773119750918">Zakelijke gebruikers niet toestaan deel uit te maken van multiprofielen (primair of secundair)</translation>
<translation id="2565967352111237512">Hiermee wordt anonieme rapportage van gebruiks- en crashgegevens voor <ph name="PRODUCT_NAME"/> aan Google ingeschakeld en wordt voorkomen dat gebruikers deze instelling kunnen wijzigen.

      Als je deze instelling inschakelt, worden anonieme gebruiks- en crashgegevens naar Google verzonden.

      Als je deze instelling uitschakelt, worden er nooit anonieme gebruiks- en crashgegevens naar Google verzonden.

      Als je deze instelling in- of uitschakelt, kunnen gebruikers de instelling niet aanpassen of negeren in <ph name="PRODUCT_NAME"/>.

      Als dit beleid niet wordt ingesteld, komt de instelling overeen met de keuze van de gebruiker bij installatie/eerste uitvoering.</translation>
<translation id="4784220343847172494">Beheert het gedrag voor automatisch opschonen op apparaten met <ph name="PRODUCT_OS_NAME"/>.Automatisch opschonen wordt gestart wanneer de hoeveelheid vrije schijfruimte een bepaald kritiek niveau bereikt, om schijfruimte terug te krijgen.

      Als dit beleid op 'RemoveLRU' wordt ingesteld, gaat het automatisch opschonen door met het van het apparaat verwijderen van gebruikers totdat er voldoende vrije ruimte is. Hierbij worden gebruikers die het langst geleden zijn ingelogd, als eerste verwijderd.


      Als dit beleid op 'RemoveLRUIfDormant' wordt ingesteld, gaat het automatisch opschonen door met het verwijderen van gebruikers die gedurende ten minste drie maanden niet zijn ingelogd, totdat er voldoende vrije ruimte is. Hierbij worden gebruikers die het langst geleden zijn ingelogd, als eerste verwijderd.

      Als dit beleid niet wordt ingesteld, gebruikt automatisch opschonen de ingebouwde standaardstrategie. Momenteel is dit de strategie 'RemoveLRUIfDormant'.</translation>
<translation id="6256787297633808491">Markeringen voor het hele systeem die worden toegepast bij het starten van Chrome</translation>
<translation id="2516600974234263142">Hiermee wordt afdrukken in <ph name="PRODUCT_NAME"/> ingeschakeld en wordt voorkomen dat gebruikers deze instelling kunnen wijzigen.

      Als deze instelling is ingeschakeld of niet is geconfigureerd, kunnen gebruikers afdrukken.

      Als deze instelling is uitgeschakeld, kunnen gebruikers niet afdrukken via <ph name="PRODUCT_NAME"/>. Afdrukken is uitgeschakeld in het menu 'Gereedschap', extensies, JavaScript-applicaties, enzovoort. Het is nog steeds mogelijk af te drukken via plug-ins die <ph name="PRODUCT_NAME"/> omzeilen tijdens het afdrukken. Bij Flash-applicaties bevindt de afdrukoptie zich in het contextmenu, wat niet onder dit beleid valt.</translation>
<translation id="9135033364005346124">Proxy voor <ph name="CLOUD_PRINT_NAME"/> inschakelen</translation>
<translation id="4519046672992331730">Hiermee worden zoeksuggesties in de omnibox van <ph name="PRODUCT_NAME"/> ingeschakeld en wordt voorkomen dat gebruikers deze instelling kunnen wijzigen.

      Als je deze instelling inschakelt, worden er zoeksuggesties gebruikt.

      Als je deze instelling uitschakelt, worden er nooit zoeksuggesties gebruikt.

      Als je deze instelling in- of uitschakelt, kunnen gebruikers de instelling niet aanpassen of negeren in <ph name="PRODUCT_NAME"/>.

      Als dit beleid niet wordt ingesteld, wordt dit ingeschakeld maar kan de gebruiker dit wijzigen.</translation>
<translation id="6943577887654905793">Voorkeursnaam voor Mac/Linux:</translation>
<translation id="6925212669267783763">Hiermee wordt de directory geconfigureerd die <ph name="PRODUCT_FRAME_NAME"/> gebruikt voor het opslaan van gebruikersgegevens.

      Als je dit beleid instelt, gebruikt <ph name="PRODUCT_FRAME_NAME"/> deze directory.

      Ga naar http://www.chromium.org/administrators/policy-list-3/user-data-directory-variables voor een lijst met variabelen die kunnen worden gebruikt.

      Als deze instelling niet wordt ingesteld, wordt de standaarddirectory voor het profiel gebruikt.</translation>
<translation id="8906768759089290519">Gastmodus inschakelen</translation>
<translation id="2168397434410358693">Inactieve vertraging wanneer op netstroom wordt gewerkt</translation>
<translation id="838870586332499308">Gegevensroaming inschakelen</translation>
<translation id="3234167886857176179">Dit is de lijst met beleidsregels die <ph name="PRODUCT_NAME"/> respecteert.

      Je hoeft deze instellingen niet handmatig te wijzigen. Je kunt gebruiksvriendelijke sjablonen downloaden van
      <ph name="POLICY_TEMPLATE_DOWNLOAD_URL"/>.

      De lijst met ondersteunde beleidsregels is gelijk voor Chromium en Google Chrome.

      Deze beleidsregels zijn uitsluitend bedoeld voor het configureren van instanties van Chrome binnen je organisatie. Gebruik van deze beleidsregels buiten je organisatie (bijvoorbeeld in een openbaar gedistribueerd programma) wordt beschouwd als malware en wordt waarschijnlijk gelabeld als malware door Google en antivirusproviders.

      Opmerking: vanaf Chrome 28 worden beleidsregels rechtstreeks geladen via de API voor groepsbeleid in Windows. Beleidsregels die handmatig naar het register worden geschreven, worden genegeerd. Bekijk http://crbug.com/259236 voor meer informatie.</translation>
<translation id="2292084646366244343"><ph name="PRODUCT_NAME"/> kan een webservice van Google gebruiken om spelfouten te corrigeren. Als deze instelling is ingeschakeld, wordt deze service altijd gebruikt. Als deze instelling is uitgeschakeld, wordt deze service nooit gebruikt.

      Spellingcontrole kan nog steeds worden uitgevoerd met een gedownload woordenboek. Dit beleid beheert alleen het gebruik van de online service.

      Als deze instelling niet is geconfigureerd, kunnen gebruikers kiezen of de service voor spellingcontrole moet worden gebruikt.</translation>
<translation id="8782750230688364867">Hiermee wordt het percentage gespecificeerd waarmee de inactieve vertraging wordt geschaald als het apparaat zich in presentatiemodus bevindt.

          Als dit beleid is ingesteld, specificeert het het percentage waarmee de inactieve vertraging wordt geschaald als het apparaat zich in presentatiemodus bevindt. Als de inactieve vertraging wordt geschaald, worden het dimmen van het scherm, scherm uitschakelen en vertragingen van schermvergrendeling aangepast om dezelfde afstanden tot de inactieve vertraging te behouden als oorspronkelijk is geconfigureerd.

          Als dit beleid niet is ingesteld, wordt een standaardschaalfactor gebruikt.

          De schaalfactor moet 100% of meer zijn. Waarden waarmee de inactieve vertraging in presentatiemodus korter wordt dan de normale inactieve vertraging, zijn niet toegestaan.</translation>
<translation id="254524874071906077">Chrome instellen als standaardbrowser</translation>
<translation id="8764119899999036911">Hiermee wordt gespecificeerd of de gegenereerde Kerberos-SPN wordt gebaseerd op de canonieke DNS-naam of de oorspronkelijk opgegeven naam.

          Als je deze instelling inschakelt, wordt de CNAME-lookup overgeslagen en wordt de servernaam gebruikt zoals deze is opgegeven.

          Als je deze instelling uitschakelt of niet instelt, wordt de canonieke naam van de server bepaald aan de hand van de CNAME-lookup.</translation>
<translation id="5056708224511062314">Vergrootglas uitgeschakeld</translation>
<translation id="4377599627073874279">Alle sites toestaan afbeeldingen weer te geven</translation>
<translation id="7195064223823777550">Specificeer de actie die moet worden ondernomen wanneer de gebruiker de klep sluit.

          Als dit beleid is ingesteld, specificeert het de actie die <ph name="PRODUCT_OS_NAME"/> onderneemt wanneer de gebruiker de klep van het apparaat sluit.

          Als dit beleid niet is ingesteld, wordt de standaardactie ondernomen. De standaardactie is onderbreken.

          Als de actie 'onderbreken' is, kan <ph name="PRODUCT_OS_NAME"/> afzonderlijk worden geconfigureerd om het scherm wel of niet te vergrendelen vóór de onderbreking.</translation>
<translation id="3915395663995367577">URL naar een PAC-bestand voor de proxy</translation>
<translation id="2144674628322086778">Zakelijke gebruikers toestaan zowel primair als secundair te zijn (standaardgedrag)</translation>
<translation id="1022361784792428773">Id's van extensies die de gebruiker niet mag installeren (of '*' voor alle extensies)</translation>
<translation id="5499375345075963939">Dit beleid is alleen actief in de commerciële modus.

      Wanneer de waarde van dit beleid is ingesteld en niet 0 is, wordt de momenteel ingelogde demogebruiker automatisch uitgelogd nadat een inactiviteitsperiode met de opgegeven duur is verstreken.

      De beleidswaarde moet worden opgegeven in milliseconden.</translation>
<translation id="7683777542468165012">Beleid dynamisch vernieuwen</translation>
<translation id="1160939557934457296">Doorgaan vanaf de waarschuwingspagina van Safe Browsing uitschakelen</translation>
<translation id="8987262643142408725">Splitsen van SSL-records uitschakelen</translation>
<translation id="4529945827292143461">Hiermee kun je de lijst aanpassen van URL-patronen die altijd door de hostbrowser moeten worden verwerkt.

         Als dit beleid niet is ingesteld, wordt de standaardrenderer gebruikt voor alle sites die door het beleid 'ChromeFrameRendererSettings' zijn gespecificeerd.

          Ga voor voorbeeldpatronen naar http://www.chromium.org/developers/how-tos/chrome-frame-getting-started.</translation>
<translation id="8044493735196713914">Opstartmodus van apparaat melden</translation>
<translation id="2746016768603629042">Dit beleid is verouderd. Gebruik in plaats hiervan DefaultJavaScriptSetting.

      Dit beleid kan worden gebruikt om JavaScript in <ph name="PRODUCT_NAME"/> uit te schakelen.

      Als deze instelling is uitgeschakeld, kunnen webpagina's JavaScript niet gebruiken en kan de gebruiker die instelling niet wijzigen.

      Als deze instelling is ingeschakeld of niet wordt ingesteld, kunnen webpagina's JavaScript gebruiken, maar kan de gebruiker die instelling wijzigen.</translation>
<translation id="1942957375738056236">Je kunt de URL van de proxyserver hier opgeven.

          Dit beleid wordt alleen van kracht als je handmatige proxyinstellingen heeft geselecteerd bij 'Kies hoe je proxyserverinstellingen wilt opgeven'.

          Stel dit beleid niet in als je een andere modus hebt geselecteerd voor het instellen van het proxybeleid.

          Ga voor meer opties en gedetailleerde voorbeelden naar:
          <ph name="PROXY_HELP_URL"/></translation>
<translation id="6076008833763548615">Hiermee schakel je het koppelen van externe opslag uit.

      Wanneer dit beleid is ingesteld op 'Waar', is externe opslag niet beschikbaar in de bestandsbrowser.

      Dit beleid is van toepassing op alle typen opslagmedia. Bijvoorbeeld: USB-flashstations, externe vaste schijven, SD-kaarten en andere geheugenkaarten, optische opslag, enzovoort. Dit is niet van toepassing op interne opslag, dus bestanden die zijn opgeslagen in de downloadmap, zijn nog steeds toegankelijk. Dit beleid is ook niet van toepassing op Google Drive.

      Als deze instelling is uitgeschakeld of niet is geconfigureerd, kunnen gebruikers alle ondersteunde typen externe opslag gebruiken op hun apparaat.</translation>
<translation id="6936894225179401731">Hiermee kun je het maximum aantal gelijktijdige verbindingen met de proxyserver opgeven.

      Bepaalde proxyservers kunnen niet een groot aantal gelijktijdige verbindingen per client verwerken. Dit kan worden opgelost door dit beleid op een lagere waarde in te stellen.

      De waarde van dit beleid moet tussen 6 en 100 liggen en de standaardwaarde is 32.

      Het is bekend dat bepaalde webapps veel verbindingen gebruiken voor openstaande GET-verzoeken. Als je deze waarde lager instelt dan 32, lopen netwerkprocessen van de browser daarom mogelijk vast als je te veel van dergelijke webapps heeft geopend. Het tot onder de standaardwaarde verlagen van deze waarde is daarom op eigen risico.

      Als dit beleid niet is ingesteld, wordt de standaardwaarde 32 gebruikt.</translation>
<translation id="5395271912574071439">Schakelt afscherming van hosts voor externe toegang in terwijl een verbinding tot stand wordt gebracht.

          Als deze instelling is ingeschakeld, worden de fysieke invoer- en uitvoerapparaten van hosts uitgeschakeld terwijl een externe verbinding tot stand wordt gebracht.

          Als deze instelling is uitgeschakeld of niet is ingesteld, kunnen zowel lokale als externe gebruikers met de host communiceren terwijl deze wordt gedeeld.</translation>
<translation id="4894257424747841850">Lijst melden met apparaatgebruikers die onlangs zijn ingelogd.

      Als het beleid niet is ingesteld of is ingesteld op 'False', worden de gebruikers niet gemeld.</translation>
<translation id="2488010520405124654">Prompt voor netwerkconfiguratie inschakelen als je offline bent.

      Als dit beleid niet is ingesteld of is ingesteld op 'waar' en een lokaal account op het apparaat is geconfigureerd om automatisch en zonder vertraging in te loggen en het apparaat geen toegang heeft tot internet, geeft <ph name="PRODUCT_OS_NAME"/> een prompt weer voor netwerkconfiguratie.

      Als dit beleid op 'onwaar' is ingesteld, verschijnt een foutmelding in plaats van de prompt voor de netwerkconfiguratie.</translation>
<translation id="1426410128494586442">Ja</translation>
<translation id="4897928009230106190">Specificeert de parameters die worden gebruikt voor het uitvoeren van een voorgestelde zoekopdracht met POST. Het bestaat uit door komma's gescheiden naam/waarde-paren. Als een waarde een sjabloonparameter, zoals {searchTerms} in het bovenstaande voorbeeld, is, wordt de waarde vervangen door echte zoektermgegevens.

          Dit beleid is optioneel. Als het beleid niet is ingesteld, wordt de voorgestelde zoekopdracht verzonden met de GET-methode.

          Dit beleid wordt alleen gerespecteerd als het beleid 'DefaultSearchProviderEnabled' is ingeschakeld.</translation>
<translation id="4962195944157514011">Hiermee wordt de URL gespecificeerd voor de zoekmachine die wordt gebruikt voor standaard zoekopdrachten. De URL moet de tekenreeks '<ph name="SEARCH_TERM_MARKER"/>' bevatten, die op het moment van de zoekopdracht wordt vervangen door de termen waarnaar de gebruiker zoekt.

          Deze optie moet worden ingesteld wanneer het beleid 'DefaultSearchProviderEnabled' is ingeschakeld en wordt alleen gerespecteerd als dit het geval is.</translation>
<translation id="6009903244351574348"><ph name="PRODUCT_FRAME_NAME"/> toestaan de genoemde soorten inhoud te verwerken.

          Als dit beleid niet is ingesteld, wordt de standaardrenderer gebruikt voor alle sites, zoals opgegeven door het beleid 'ChromeFrameRendererSettings'.</translation>
<translation id="3381968327636295719"> gebruiken</translation>
<translation id="3627678165642179114">Webservice voor spellingcontrole in- of uitschakelen</translation>
<translation id="6520802717075138474">Zoekmachines importeren uit standaardbrowser bij eerste uitvoering</translation>
<translation id="4039085364173654945">Hiermee wordt bepaald of subinhoud van derden op een pagina een dialoogvenster voor algemene HTTP-authenticatie als pop-up mag weergeven.

          Deze optie is meestal uitgeschakeld als beveiliging tegen phishing. Als dit beleid niet wordt ingesteld, wordt de optie uitgeschakeld en mag subinhoud van derden geen dialoogvenster voor algemene HTTP-authenticatie als pop-up weergeven.</translation>
<translation id="4946368175977216944">Hiermee worden de markeringen gespecificeerd die bij het starten moeten worden toegepast op Chrome. De opgegeven markeringen worden toegepast voordat Chrome wordt gestart, zelfs voor het inlogscherm.</translation>
<translation id="7447786363267535722">Hiermee wordt het opslaan van wachtwoorden en het gebruik van opgeslagen wachtwoorden in <ph name="PRODUCT_NAME"/> ingeschakeld.

          Als je deze instelling inschakelt, kunnen gebruikers <ph name="PRODUCT_NAME"/> wachtwoorden laten onthouden en deze automatisch laten invullen wanneer ze zich later opnieuw bij een site inloggen.

          Als je deze instelling uitschakelt, kunnen gebruikers geen wachtwoorden opslaan of eerder opgeslagen wachtwoorden gebruiken.

          Als je deze instelling in- of uitschakelt, kunnen gebruikers deze instelling niet aanpassen of negeren in <ph name="PRODUCT_NAME"/>.

          Als dit beleid niet wordt ingesteld, wordt dit ingeschakeld maar kan de gebruiker dit wijzigen.</translation>
<translation id="1138294736309071213">Dit beleid is alleen ingeschakeld in de winkelmodus.

      Bepaalt de periode waarna de schermbeveiliging wordt weergegeven in het inlogvenster voor apparaten in de winkelmodus.

      De beleidswaarde moet worden opgegeven in milliseconden.</translation>
<translation id="6368011194414932347">De startpagina-URL configureren</translation>
<translation id="2877225735001246144">CNAME-lookup uitschakelen bij het verwerken van Kerberos-authenticatie</translation>
<translation id="9120299024216374976">Hiermee wordt de tijdzone gespecificeerd die voor het apparaat moet worden gebruikt. Gebruikers kunnen de gespecificeerde tijdzone overschrijven voor de huidige sessie. Bij het uitloggen wordt de tijd echter teruggezet naar de gespecificeerde tijdzone. Als een ongeldige waarde wordt opgegeven, wordt het beleid nog steeds geactiveerd, maar wordt 'GMT' gebruikt. Als een lege tekenreeks wordt opgegeven, wordt het beleid genegeerd.

      Als dit beleid niet wordt gebruikt, blijft de huidige actieve tijdzone in gebruik. Gebruikers kunnen de tijdzone echter wijzigen en de wijziging is blijvend. Een wijziging door één gebruiker is dus van invloed op het inlogscherm en op alle andere gebruikers.

      Bij nieuwe apparaten is de tijdzone standaard ingesteld op 'US/Pacific'.

      De notatie van de waarde volgt de naamgeving van tijdzones in de 'IANA Time Zone Database' (zie 'http://en.wikipedia.org/wiki/List_of_tz_database_time'). Je kunt naar veel tijdzones verwijzen via 'continent/grote_stad' of 'oceaan/grote_stad'.</translation>
<translation id="3646859102161347133">Het type vergrootglas instellen</translation>
<translation id="3528000905991875314">Alternatieve foutpagina's inschakelen</translation>
<translation id="1283072268083088623">Hiermee wordt gespecificeerd welke HTTP-authenticatieschema's door <ph name="PRODUCT_NAME"/> worden ondersteund.

          Mogelijke waarden zijn 'basic', 'digest', 'ntlm' en 'negotiate'. Scheid meerdere waarden van elkaar met komma's.

          Als dit beleid niet wordt ingesteld, worden alle vier schema's gebruikt.</translation>
<translation id="4914647484900375533">Hiermee schakel je de Instant-functie van <ph name="PRODUCT_NAME"/> in en voorkom je dat gebruikers deze instelling wijzigen.

      Als je deze instelling inschakelt, is <ph name="PRODUCT_NAME"/> Instant ingeschakeld.

      Als je deze instelling uitschakelt, is <ph name="PRODUCT_NAME"/> Instant uitgeschakeld.

      Als je deze instelling in- of uitschakelt, kunnen gebruikers deze niet wijzigen of negeren.

      Als je deze instelling niet instelt, kan de gebruiker bepalen of de functie wordt gebruikt.

      Deze instelling is verwijderd uit Chrome 29 en hogere versies.</translation>
<translation id="6114416803310251055">verouderd</translation>
<translation id="8493645415242333585">Opslaan van browsegeschiedenis uitschakelen</translation>
<translation id="5319306267766543020">Stroombeheer configureren in <ph name="PRODUCT_OS_NAME"/>.

      Met dit beleid kun je configureren hoe <ph name="PRODUCT_OS_NAME"/> reageert wanneer de gebruiker een bepaalde tijd inactief is.</translation>
<translation id="2747783890942882652">Hiermee configureer je de vereiste domeinnaam die wordt opgelegd aan hosts voor externe toegang en voorkom je dat gebruikers deze wijzigen.

          Als deze instelling is ingeschakeld, kunnen hosts alleen worden gedeeld met accounts die zijn geregistreerd op de opgegeven domeinnaam.

          Als deze instelling is uitgeschakeld of niet is ingesteld, kunnen hosts worden gedeeld met elk account.</translation>
<translation id="6417861582779909667">Hiermee kun je een lijst met URL-patronen instellen waarmee sites worden gespecificeerd die geen cookies mogen instellen.

          Als dit beleid niet wordt ingesteld, wordt de algemene standaardwaarde gebruikt voor alle sites op basis van het beleid 'DefaultCookiesSetting' (als dit is ingesteld) of anders op basis van de configuratie van de gebruiker.</translation>
<translation id="5457296720557564923">Toestaan dat pagina's toegang krijgen tot statistieken met betrekking tot JavaScript-geheugengebruik. Met deze instellingen worden de geheugenstatistieken van het deelvenster 'Profielen voor hulpprogramma's voor ontwikkelaars' beschikbaar voor de webpagina zelf.</translation>
<translation id="5776485039795852974">Altijd vragen wanneer een site bureaubladmeldingen wil weergeven</translation>
<translation id="5047604665028708335">Toegang toestaan tot sites die zich niet in de inhoudspakketten bevinden</translation>
<translation id="5052081091120171147">Indien ingeschakeld, wordt met dit beleid afgedwongen dat de browsergeschiedenis wordt geïmporteerd uit de huidige standaardbrowser. Als het beleid is ingeschakeld, is dit ook van invloed op het dialoogvenster voor importeren.

      Als het beleid is uitgeschakeld, wordt er geen browsergeschiedenis geïmporteerd.

      Als dit beleid niet is ingesteld, kan de gebruiker worden gevraagd of deze wil importeren, of wordt er automatisch geïmporteerd.</translation>
<translation id="6786747875388722282">Extensies</translation>
<translation id="7132877481099023201">URL's die zonder prompt toegang krijgen tot apparaten voor het vastleggen van video</translation>
<translation id="8947415621777543415">Apparaatlocatie rapporteren</translation>
<translation id="1655229863189977773">Grootte van schijfcache in bytes instellen</translation>
<translation id="6376842084200599664">Hiermee kun je een lijst specificeren met extensies die zonder gebruikersinteractie op de achtergrond worden geïnstalleerd.

          Elk item op de lijst is een tekenreeks die een extensie-ID en een update-URL bevat die van elkaar zijn gescheiden met een puntkomma (<ph name="SEMICOLON"/>). De extensie-ID is de 32-letterige tekenreeks die je bijvoorbeeld op <ph name="CHROME_EXTENSIONS_LINK"/> kunt vinden wanneer de ontwikkelaarsmodus is ingeschakeld. De update-URL moet verwijzen naar een XML-document met een updatemanifest, zoals beschreven in <ph name="LINK_TO_EXTENSION_DOC1"/>. Houd er rekening mee dat de update-URL die voor dit beleid is ingesteld, alleen wordt gebruikt voor de eerste installatie. Daaropvolgende updates van de extensie gebruiken de update-URL die in het manifest van de extensie is aangegeven.

          Voor elk item haalt <ph name="PRODUCT_NAME"/> de door de extensie-ID gespecificeerde extensie op uit de updateservice via de gespecificeerde update-URL. Vervolgens wordt de extensie op de achtergrond geïnstalleerd.

          Een voorbeeld: <ph name="EXTENSION_POLICY_EXAMPLE"/> installeert de extensie <ph name="EXTENSION_POLICY_EXAMPLE_EXTENSION_NAME"/> via de standaardupdate-URL uit de Chrome Web Store. Voor meer informatie over het hosten van extensies ga je naar: <ph name="LINK_TO_EXTENSION_DOC2"/>.

          Gebruikers kunnen extensies die in dit beleid zijn gespecificeerd, niet verwijderen. Als je een extensie uit deze lijst verwijdert, wordt deze automatisch verwijderd door <ph name="PRODUCT_NAME"/>. Extensies die in deze lijst zijn gespecificeerd, worden ook automatisch op de witte lijst voor installatie gezet. ExtensionsInstallBlacklist is hierop niet van invloed.

          Als dit beleid niet wordt ingesteld, kan de gebruiker elke extensie in <ph name="PRODUCT_NAME"/> verwijderen.</translation>
<translation id="6899705656741990703">Proxyinstellingen automatisch detecteren</translation>
<translation id="8382184662529825177">Het gebruik van externe verificatie inschakelen voor het beveiligen van inhoud voor het apparaat</translation>
<translation id="7003334574344702284">Indien ingeschakeld, wordt met dit beleid afgedwongen dat de opgeslagen wachtwoorden worden geïmporteerd uit de vorige standaardbrowser. Als het beleid is ingeschakeld, is dit ook van invloed op het dialoogvenster voor importeren.

      Als het beleid is uitgeschakeld, worden opgeslagen wachtwoorden niet geïmporteerd.

      Als dit beleid niet is ingesteld, kan de gebruiker worden gevraagd of deze wil importeren, of wordt er automatisch geïmporteerd.</translation>
<translation id="6258193603492867656">Hiermee wordt aangegeven of de gegenereerde Kerberos-SPN een niet-standaardpoort moet bevatten.

          Als je deze instelling inschakelt en er een niet-standaardpoort (een andere poort dan 80 of 443) wordt opgegeven, wordt deze opgenomen in de gegenereerde Kerberos-SPN.

          Als je deze instelling uitschakelt of niet instelt, bevat de gegenereerde Kerberos-SPN in geen geval een poortnummer.</translation>
<translation id="3236046242843493070">URL-patronen om de installatie van extensies, apps en gebruikersscripts toe te staan vanaf</translation>
<translation id="2498238926436517902">Archief altijd automatisch verbergen</translation>
<translation id="253135976343875019">Inactieve waarschuwingsvertraging wanneer op netstroom wordt gewerkt</translation>
<translation id="480987484799365700">Als dit beleid is ingeschakeld, schakelt het profiel gedwongen over naar de kort geldige modus. Als dit beleid als OS-beleid wordt ingesteld (bijv. GPO in Windows), is het van toepassing op elk profiel in het systeem. Als het beleid als cloudbeleid is ingesteld, is het alleen van toepassing op een profiel waarop met een beheerd account is ingelogd.

      In deze modus worden de profielgegevens alleen voor de duur van de gebruikerssessie opgeslagen op de schijf. Functies als browsergeschiedenis, extensies en de bijbehorende gegevens, webgegevens (zoals cookies) en webdatabases blijven niet behouden nadat de browser is gesloten. Hierdoor wordt echter niet voorkomen dat de gebruiker handmatig gegevens naar de schijf kan downloaden of pagina's kan opslaan of afdrukken.

      Als de gebruiker synchronisatie heeft ingeschakeld, worden al deze gegevens bewaard in het synchronisatieprofiel van de gebruiker, net als bij gewone profielen. De incognitomodus is ook beschikbaar als deze niet expliciet door een beleid is uitgeschakeld.

      Als het beleid is uitgeschakeld of niet is ingesteld, leidt inloggen tot het gebruik van gewone profielen.</translation>
<translation id="6997592395211691850">Of online OCSP/CRL-controles zijn vereist voor lokale vertrouwensankers</translation>
<translation id="152657506688053119">Lijst met alternatieve URL's voor de standaardzoekprovider</translation>
<translation id="8992176907758534924">Niet toestaan dat sites afbeeldingen weergeven</translation>
<translation id="262740370354162807">Verzenden van documenten naar <ph name="CLOUD_PRINT_NAME"/> inschakelen</translation>
<translation id="7717938661004793600">Toegankelijkheidsfuncties van <ph name="PRODUCT_OS_NAME"/> configureren.</translation>
<translation id="5182055907976889880">Google Drive in <ph name="PRODUCT_OS_NAME"/> configureren.</translation>
<translation id="8704831857353097849">Lijst met uitgeschakelde plug-ins</translation>
<translation id="8391419598427733574">De OS- en firmwareversie van aangemelde apparaten melden.
Als deze instelling op 'True' wordt ingesteld, melden de aangemelde apparaten regelmatig de OS- en firmwareversie. Als deze instelling niet wordt ingesteld of op 'False' wordt ingesteld, wordt geen versie-informatie gemeld.</translation>
<translation id="467449052039111439">Een lijst met URL's openen</translation>
<translation id="5883015257301027298">Standaardinstelling voor cookies</translation>
<translation id="5017500084427291117">Blokkeert de toegang tot de vermelde URL's.

      Met dit beleid wordt voorkomen dat de gebruiker webpagina's laadt van URL's die op de zwarte lijst staan.

      Een URL heeft de notatie 'scheme://host:port/path'.
      Het optionele schema kan 'http', 'https' of 'ftp' zijn. Alleen dit schema wordt geblokkeerd. Als er geen schema is opgegeven, worden alle schema's geblokkeerd.
      De host kan een hostnaam of een IP-adres zijn. Subdomeinen van een hostnaam worden ook geblokkeerd. Om te voorkomen dat subdomeinen worden geblokkeerd, voeg je een '.' toe vóór de hostnaam. De speciale hostnaam '*' blokkeert alle domeinen.
      De optionele poort is een geldig poortnummer tussen 1 en 65535. Als geen poortnummer is opgegeven, worden alle poorten geblokkeerd.
      Als het optionele pad is opgegeven, worden alleen paden met dat voorvoegsel geblokkeerd.

      Uitzonderingen kunnen worden gedefinieerd in het beleid voor de witte lijst voor URL's. Dit beleid is beperkt tot 1000 items. Daaropvolgende items worden genegeerd.

      Als dit beleid niet is ingesteld, wordt geen enkele URL op de zwarte lijst van de browser geplaatst.</translation>
<translation id="2762164719979766599">Hiermee wordt de lijst met lokale accounts op het apparaat weergegeven op het aanmeldscherm.

      Elke lijstvermelding specificeert een ID die intern wordt gebruikt om de verschillende lokale accounts van het apparaat te onderscheiden.</translation>
<translation id="8955719471735800169">Bovenkant pagina</translation>
<translation id="2534584045044686957">Hiermee configureer je de cachegrootte die <ph name="PRODUCT_NAME"/> gebruikt voor het opslaan van gecachte mediabestanden op de schijf.

      Als je dit beleid instelt, gebruikt <ph name="PRODUCT_NAME"/> de opgegeven cachegrootte, ongeacht of de gebruiker de markering '--media-cache-size' heeft opgegeven.

      Als de waarde van dit beleid 0 is, wordt de standaardcachegrootte gebruikt, maar kan de gebruiker deze niet wijzigen.

      Als dit beleid niet is ingesteld, wordt de standaardgrootte gebruikt en kan de gebruiker deze overschrijven met behulp van de markering --media-cache-size.</translation>
<translation id="3723474915949495925">Hiermee geef je een lijst met plug-ins op die gebruikers kunnen in- of uitschakelen in <ph name="PRODUCT_NAME"/>.

      De jokertekens '*' en '?' kunnen worden gebruikt om overeenkomsten met willekeurige tekens te zoeken. '*' komt overeen met een willekeurig aantal tekens terwijl '?' één optioneel teken aangeeft (dat wil zeggen, overeenkomsten met nul of één teken). Het escape-teken '\' kan worden gebruikt om deze tekens te escapen, dus als je overeenkomsten voor de letterlijke tekens '*', '?' of '\' wilt zoeken, kun je een '\' vóór deze tekens plaatsen.

      Als je deze instelling inschakelt, kan de opgegeven lijst met plug-ins worden gebruikt in <ph name="PRODUCT_NAME"/>. Gebruikers kunnen deze in- of uitschakelen in 'about:plugins', zelfs als de plug-in ook overeenkomt met een patroon DisabledPlugins. Gebruikers kunnen ook plug-ins in- en uitschakelen die niet overeenkomen met patronen in DisabledPlugins, DisabledPluginsExceptions en EnabledPlugins.

      Dit beleid is bedoeld voor gevallen met strenge zwarte lijsten voor plug-ins, waarin de lijst 'DisabledPlugins' vermeldingen met jokertekens bevat, zoals 'alle plug-ins '*' uitschakelen' of 'alle Java-plug-ins '*Java*' uitschakelen', maar de beheerder een specifieke versie zoals 'IcedTea Java 2.3' wil inschakelen. Deze specifieke versies kunnen worden opgegeven in dit beleid.

      Als dit beleid niet is ingesteld, wordt elke plug-in die overeenkomt met de patronen in 'DisabledPlugins', vergrendeld op 'uitgeschakeld' en kan de gebruiker deze niet inschakelen.</translation>
<translation id="4557134566541205630">URL van standaard zoekprovider voor nieuwe tabbladpagina</translation>
<translation id="546726650689747237">Vertraging van dimmen van scherm wanneer op netstroom wordt gewerkt</translation>
<translation id="4988291787868618635">Actie die wordt ondernomen wanneer de inactieve vertraging wordt bereikt</translation>
<translation id="7260277299188117560">Automatisch bijwerken van p2p ingeschakeld</translation>
<translation id="5316405756476735914">Hiermee kun je instellen of websites lokaal gegevens mogen instellen. Het instellen van lokale gegevens kan worden toegestaan voor alle websites of worden geweigerd voor alle websites.

          Als dit beleid niet wordt ingesteld, wordt 'AllowCookies' gebruikt en kan de gebruiker dit wijzigen.</translation>
<translation id="4250680216510889253">Nee</translation>
<translation id="1522425503138261032">Sites toestaan de fysieke locatie van gebruikers bij te houden</translation>
<translation id="6467433935902485842">Hiermee kun je een lijst met URL-patronen instellen waarmee sites worden gespecificeerd waarop plug-ins niet mogen worden uitgevoerd.

          Als dit beleid niet wordt ingesteld, wordt de algemene standaardwaarde gebruikt voor alle sites, op basis van het beleid 'DefaultPluginsSetting' (als dit is ingesteld) of anders op basis van de configuratie van de gebruiker.</translation>
<translation id="4423597592074154136">Proxyinstellingen handmatig specificeren</translation>
<translation id="209586405398070749">Stabiel kanaal</translation>
<translation id="8170878842291747619">Hiermee wordt de geïntegreerde service Google Translate ingeschakeld in <ph name="PRODUCT_NAME"/>.

      Als je deze instelling inschakelt, wordt in <ph name="PRODUCT_NAME"/> een geïntegreerde werkbalk weergegeven waarin de gebruiker wordt gevraagd of deze de pagina wil laten vertalen (indien van toepassing).

      Als je deze instelling uitschakelt, krijgen gebruikers de vertaalbalk nooit te zien.

      Als je deze instelling in- of uitschakelt, kunnen gebruikers de instelling niet aanpassen of negeren in <ph name="PRODUCT_NAME"/>.

      Als je deze instelling niet instelt, kan de gebruiker ervoor kiezen deze functie wel of niet te gebruiken.</translation>
<translation id="9035964157729712237">Extensie-id's die zijn vrijgesteld van de zwarte lijst</translation>
<translation id="8244525275280476362">Maximum vertraging voor ophalen na ongeldigverklaring voor beleid</translation>
<translation id="8587229956764455752">Het maken van nieuwe gebruikersaccounts toestaan</translation>
<translation id="7417972229667085380">Het percentage waarmee je de inactieve vertraging in presentatiemodus kunt schalen (verouderd)</translation>
<translation id="3964909636571393861">Toegang verlenen aan een lijst met URL's</translation>
<translation id="3450318623141983471">De status van de schakelaar voor de ontwikkelaarsmodus van het apparaat bij starten melden. Als het beleid niet is ingesteld, of is ingesteld op 'False', wordt de status van de schakelaar voor de ontwikkelaarsmodus niet gemeld.</translation>
<translation id="1811270320106005269">Vergrendelen als <ph name="PRODUCT_OS_NAME"/>-apparaten inactief zijn over overschakelen op de slaapstand.

      Als je deze instelling inschakelt, wordt gebruikers gevraagd een wachtwoord in te voeren om het apparaat uit de slaapstand te ontgrendelen.

      Als je deze instelling uitschakelt, wordt gebruikers niet gevraagd om een wachtwoord in te voeren om het apparaat uit de slaapstand te ontgrendelen.

      Als je deze instelling in- of uitschakelt, kunnen gebruikers deze niet wijzigen of negeren.

      Als je het beleid niet instelt, kan de gebruiker kiezen of hij/zij wel of niet wil worden gevraagd een wachtwoord in te voeren om het apparaat te ontgrendelen.</translation>
<translation id="6022948604095165524">Actie bij starten</translation>
<translation id="9042911395677044526">Hiermee kun je een gebruikerspecifieke netwerkconfiguratie toepassen op een <ph name="PRODUCT_OS_NAME"/>-apparaat. De netwerkconfiguratie is een tekenreeks met JSON-indeling, zoals gedefinieerd door de indeling voor open netwerkconfiguratie, beschreven op <ph name="ONC_SPEC_URL"/></translation>
<translation id="7128918109610518786">Hiermee worden de app-ID's vermeld die <ph name="PRODUCT_OS_NAME"/> weergeeft als vastgezette apps in de balk van het opstartprogramma.

      Als dit beleid is geconfigureerd, staat de reeks apps vast en kan deze niet worden gewijzigd door de gebruiker.

      Als het beleid niet is ingesteld, kan de gebruiker de lijst met vastgezette apps in het opstartprogramma wijzigen.</translation>
<translation id="1679420586049708690">Openbare sessie voor automatisch inloggen</translation>
<translation id="7625444193696794922">Hiermee wordt het releasekanaal gespecificeerd waarmee dit apparaat moet worden vergrendeld.</translation>
<translation id="2552966063069741410">Tijdzone</translation>
<translation id="2240879329269430151">Hiermee kun je instellen of websites pop-ups mogen weergeven. Het weergeven van pop-ups kan worden toegestaan voor alle websites of worden geweigerd voor alle websites.

          Als dit beleid niet is ingesteld, wordt 'BlockPopups' gebruikt en kan de gebruiker dit wijzigen.</translation>
<translation id="2529700525201305165">Beperken welke gebruikers mogen inloggen bij <ph name="PRODUCT_NAME"/></translation>
<translation id="8971221018777092728">Timer voor automatisch inloggen bij de openbare sessie</translation>
<translation id="8285435910062771358">Vergrootglas van volledig scherm ingeschakeld</translation>
<translation id="5141670636904227950">Het standaardtype van vergrootglas instellen dat op het inlogscherm is ingeschakeld</translation>
<translation id="3864818549971490907">Standaardinstelling voor plug-ins</translation>
<translation id="7151201297958662315">Bepaalt of een <ph name="PRODUCT_NAME"/>-proces is gestart als een gebruiker zich bij het besturingssysteem aanmeldt, en actief blijft als het laatste browservenster is gesloten, waardoor achtergrondapps actief kunnen blijven. Het achtergrondproces wordt weergegeven met een pictogram in de systeembalk en kan op elk moment vanuit de systeembalk worden gesloten.

      Als dit beleid is ingesteld op 'True', is de achtergrondmodus ingeschakeld en kan de gebruiker deze niet beheren in de browserinstellingen.

      Als dit beleid is ingesteld op 'False', is de achtergrondmodus uitgeschakeld en kan de gebruiker deze niet beheren in de browserinstellingen.

      Als dit beleid niet is ingesteld, is de achtergrondmodus aanvankelijk uitgeschakeld en kan de gebruiker de achtergrondmodus beheren in de browserinstellingen.</translation>
<translation id="4320376026953250541">Microsoft Windows XP SP2 of hoger</translation>
<translation id="5148753489738115745">Hiermee kun je extra parameters opgeven die worden gebruikt wanneer <ph name="PRODUCT_FRAME_NAME"/> <ph name="PRODUCT_NAME"/> start.

          Als dit beleid niet is ingesteld, wordt de standaardopdrachtregel gebruikt.</translation>
<translation id="2646290749315461919">Hiermee kun je instellen of websites de fysieke locatie van gebruikers mogen bijhouden. Het bijhouden van de fysieke locatie van gebruikers kan standaard worden toegestaan, standaard worden geweigerd of het kan de gebruiker telkens worden gevraagd wanneer een website zijn fysieke locatie opvraagt.

          Als dit beleid niet wordt ingesteld, wordt 'AskGeolocation' gebruikt en kan de gebruiker dit wijzigen.</translation>
<translation id="6394350458541421998">Dit beleid wordt niet meer gebruikt sinds <ph name="PRODUCT_OS_NAME"/> versie 29. Gebruik het beleid PresentationScreenDimDelayScale.</translation>
<translation id="5770738360657678870">Ontwikkelaarskanaal (mogelijk instabiel)</translation>
<translation id="2959898425599642200">Regels voor proxyomzeiling</translation>
<translation id="228659285074633994">Hiermee wordt de tijdsduur zonder gebruikersinvoer gespecificeerd waarna een waarschuwingsdialoogvenster wordt weergegeven wanneer op netstroom wordt gewerkt.

          Als dit beleid is ingesteld, specificeert het de tijdsduur dat de gebruiker inactief moet zijn voordat <ph name="PRODUCT_OS_NAME"/> een waarschuwingsdialoogvenster aan de gebruiker laat zien om aan te geven dat de actie voor inactiviteit bijna wordt ondernomen.

          Als dit beleid niet is ingesteld, wordt er geen waarschuwingsdialoogvenster weergegeven.

          De beleidswaarde moet worden opgegeven in milliseconden. De waarde die wordt opgegeven, moet kleiner zijn dan of gelijk aan de inactieve vertraging.</translation>
<translation id="1098794473340446990">Perioden van apparaatgebruik melden.
Als dit beleid op 'True' is ingesteld, melden aangemelde apparaten perioden waarin een gebruiker het apparaat gebruikt. Als deze instelling niet is ingesteld of op 'False' is ingesteld, worden perioden van apparaatgebruik niet geregistreerd of gemeld.</translation>
<translation id="1327466551276625742">Prompt voor netwerkconfiguratie inschakelen als je offline bent</translation>
<translation id="7937766917976512374">Het opnemen van video's toestaan of weigeren</translation>
<translation id="427632463972968153">Specificeert de parameters die worden gebruikt voor het uitvoeren van een zoekopdracht naar afbeeldingen met POST. Het bestaat uit door komma's gescheiden naam/waarde-paren. Als een waarde een sjabloonparameter, zoals {imageThumbnail} in het bovenstaande voorbeeld, is, wordt de waarde vervangen door echte afbeeldingsminiatuurgegevens.

          Dit beleid is optioneel. Als het beleid niet is ingesteld, wordt de voorgestelde zoekopdracht verzonden met de GET-methode.

          Dit beleid wordt alleen gerespecteerd als het beleid 'DefaultSearchProviderEnabled' is ingeschakeld.</translation>
<translation id="8818646462962777576">Patronen in deze lijst worden vergeleken met de beveiligingsoorsprong
      van de aanvragende URL. Als een overeenkomst wordt gevonden, wordt toegang tot apparaten
      voor het vastleggen van audio zonder prompt toegestaan.

      OPMERKING: dit beleid wordt momenteel alleen ondersteund in de kioskmodus.</translation>
<translation id="489803897780524242">Parameter die plaatsing van zoektermen beheert voor de standaardzoekprovider</translation>
<translation id="316778957754360075">Deze instelling wordt niet meer gebruikt sinds <ph name="PRODUCT_NAME"/> versie 29. De aanbevolen manier om verzamelingen van uitbreidingen/apps die door de organisatie worden gehost in te stellen, is het opnemen van de site die de CRX-pakketten in ExtensionInstallSources host en het plaatsen van rechtstreekse downloadlinks naar de pakketten op een webpagina. Je kunt voor die webpagina een startprogramma maken met het beleid ExtensionInstallForcelist.</translation>
<translation id="6401669939808766804">De gebruiker uitloggen</translation>
<translation id="4826326557828204741">Actie die moet worden ondernomen wanneer de vertraging voor inactief wordt bereikt bij gebruik op accuvermogen</translation>
<translation id="7912255076272890813">Toegestane typen apps/extensies configureren</translation>
<translation id="817455428376641507">Verleent toegang tot de vermelde URL's, ter uitzondering op de zwarte lijst voor URL's.

      Bekijk de beschrijving van het beleid voor de zwarte lijst voor URL's voor de notatie van items in deze lijst.

      Dit beleid kan worden gebruikt om uitzonderingen op te geven voor beperkende zwarte lijsten. '*' kan bijvoorbeeld op de zwarte lijst worden gezet om alle verzoeken te blokkeren en dit beleid kan worden gebruikt om toegang tot een beperkte lijst met URL's te verlenen. Het beleid kan worden gebruikt om uitzonderingen op te geven voor bepaalde schema's, subdomeinen van andere domeinen, poorten of specifieke paden.

      Het meest specifieke filter bepaalt of een URL wordt geblokkeerd of toegestaan. De witte lijst krijgt voorrang op de zwarte lijst.

      Dit beleid is beperkt tot 1000 items; daaropvolgende items worden genegeerd.

      Als dit beleid niet is ingesteld, worden er geen uitzonderingen opgegeven voor de zwarte lijst van het beleid 'URLBlacklist'.</translation>
<translation id="4163644371169597382">IT-beheerders voor zakelijke apparaten kunnen deze markering gebruiken om te bepalen of gebruikers aanbiedingen kunnen inwisselen via registratie van Chrome OS.

      Als dit beleid is ingesteld op 'waar' of niet wordt ingesteld, kunnen gebruikers aanbiedingen inwisselen via registratie van Chrome OS.

      Als dit beleid is ingesteld op 'onwaar', kunnen gebruikers geen aanbiedingen inwisselen.</translation>
<translation id="8148901634826284024">De toegankelijkheidsfunctie Modus voor hoog contrast inschakelen.

          Als dit beleid op 'waar' is ingesteld, is de modus voor hoog contrast altijd ingeschakeld.

          Als dit beleid op 'onwaar' is ingesteld, is de modus voor hoog contrast altijd uitgeschakeld.

          Als je dit beleid instelt, kunnen gebruikers dit niet wijzigen of negeren.

          Als je dit beleid niet instelt, is de modus voor hoog contrast initieel uitgeschakeld maar kan de gebruiker deze op elk moment inschakelen.</translation>
<translation id="6177482277304066047">Hiermee stel je een doelversie voor Automatische updates in.

      Hiermee geef je het voorvoegsel van een doelversie op waarnaar <ph name="PRODUCT_OS_NAME"/> moet worden bijgewerkt. Als op het apparaat een versie wordt uitgevoerd die lager is dan het opgegeven voorvoegsel, wordt het apparaat bijgewerkt naar de nieuwste versie met het opgegeven voorvoegsel. Als op het apparaat al een hogere versie is geïnstalleerd, gebeurt er niets (dat wil zeggen, er worden geen downgrades uitgevoerd) en blijft het apparaat de huidige versie gebruiken. De notatie van het voorvoegsel werkt op basis van componenten, zoals het volgende voorbeeld laat zien:

      &quot;&quot; (of niet geconfigureerd): bijwerken naar de nieuwste versie.
      &quot;1412.&quot;: bijwerken naar een secundaire versie van 1412 (bijvoorbeeld 1412.24.34 of 1412.60.2)
      &quot;1412.2.&quot;: bijwerken naar een secundaire versie van 1412.2 (bijvoorbeeld 1412.2.34 of 1412.2.2)
      &quot;1412.24.34&quot;: alleen bijwerken naar deze specifieke versie</translation>
<translation id="8102913158860568230">Standaardinstelling voor mediastreams</translation>
<translation id="6641981670621198190">Ondersteuning voor API's voor 3D-beelden uitschakelen</translation>
<translation id="7929480864713075819">Het rapporteren van geheugengegevens (JS-heapgrootte) aan de pagina inschakelen</translation>
<translation id="5703863730741917647">Specificeer de actie die moet worden ondernomen wanneer de vertraging voor inactief wordt bereikt.

          Houd er rekening mee dat dit beleid verouderd is en in de toekomst wordt verwijderd.

          Dit beleid levert een reservewaarde voor de specifiekere beleidsregels <ph name="IDLEACTIONAC_POLICY_NAME"/> en <ph name="IDLEACTIONBATTERY_POLICY_NAME"/>. Als dit beleid is ingesteld, wordt de bijbehorende waarde gebruikt als het respectieve specifiekere beleid niet is ingesteld.

          Als het instellen van dit beleid ongedaan wordt gemaakt, heeft dit geen invloed op het gedrag van de specifiekere beleidsregels.</translation>
<translation id="5997543603646547632">Klok met 24-uursnotatie standaard gebruiken</translation>
<translation id="7003746348783715221">Voorkeuren voor <ph name="PRODUCT_NAME"/></translation>
<translation id="4723829699367336876">Firewallpassage vanaf client voor externe toegang inschakelen</translation>
<translation id="6367755442345892511">Of de gebruiker het releasekanaal moet configureren</translation>
<translation id="3868347814555911633">Dit beleid is alleen actief in de commerciële modus.

      Hiermee vermeld je extensies die automatisch worden geïnstalleerd voor de demogebruiker, voor apparaten in de commerciële modus. Deze extensies worden opgeslagen op het apparaat en kunnen worden geïnstalleerd in de offline modus, na de installatie.

      Elke lijstvermelding bevat een woordenboek dat de extensie-ID moet bevatten in het veld 'Extensie-ID' en de update-URL in het veld 'Update-URL'.</translation>
<translation id="9096086085182305205">Witte lijst voor verificatieserver</translation>
<translation id="4980301635509504364">Het vastleggen van video toestaan of weigeren.

      Als dit beleid is ingeschakeld of niet is geconfigureerd (standaard), wordt de gebruiker gevraagd naar
      toegang voor het vastleggen van video, met uitzondering van URL's die in de
      lijst VideoCaptureAllowedUrls zijn geconfigureerd. Deze krijgen toegang zonder prompt.

      Als dit beleid is uitgeschakeld, krijgt de gebruiker nooit een prompt en is het vastleggen van video
      alleen beschikbaar voor URL's die in VideoCaptureAllowedUrls zijn geconfigureerd.

      Dit beleid heeft invloed op alle typen van video-invoer en niet alleen op de ingebouwde camera.</translation>
<translation id="7063895219334505671">Pop-ups toestaan ​​op deze sites</translation>
<translation id="4052765007567912447">Hiermee wordt bepaald of de gebruiker wachtwoorden als leesbare tekst mag weergeven in Wachtwoordbeheer.

          Als je deze instelling uitschakelt, staat Wachtwoordbeheer de gebruiker niet toe opgeslagen wachtwoorden als leesbare tekst weer te geven in het venster van Wachtwoordbeheer.

          Als je deze instelling inschakelt of niet configureert, kunnen gebruikers hun wachtwoorden als leesbare tekst bekijken in Wachtwoordbeheer.</translation>
<translation id="5936622343001856595">Hiermee wordt afgedwongen dat zoekopdrachten in Google Zoeken worden uitgevoerd met SafeSearch ingesteld op 'actief' en wordt voorkomen dat gebruikers deze instelling kunnen wijzigen.

      Als je deze instelling inschakelt, is SafeSearch altijd actief in Google Zoeken.

      Als je deze instelling uitschakelt of geen waarde instelt, wordt SafeSearch Zoeken niet afgedwongen voor Google Zoeken.</translation>
<translation id="6017568866726630990">Het systeemdialoogvenster voor afdrukken weergeven in plaats van een afdrukvoorbeeld.

      Wanneer deze instelling is ingeschakeld, opent <ph name="PRODUCT_NAME"/> het systeemdialoogvenster voor afdrukken in plaats van het ingebouwde afdrukvoorbeeld wanneer een gebruiker een pagina wil laten afdrukken.

      Als dit beleid niet is ingesteld of is ingesteld op 'onwaar', activeren afdrukopdrachten het afdrukvoorbeeldscherm.</translation>
<translation id="7933141401888114454">Maken van bewaakte gebruikers inschakelen</translation>
<translation id="2824715612115726353">Incognitomodus inschakelen</translation>
<translation id="1057535219415338480">Hiermee wordt netwerkvoorspelling in <ph name="PRODUCT_NAME"/> ingeschakeld en wordt voorkomen dat gebruikers deze instelling kunnen wijzigen.

      Hiermee wordt niet alleen DNS-prefetching beheerd, maar ook het vooraf verbinden met TCP en SSL en het vooraf renderen van webpagina's. De beleidsnaam verwijst naar DNS-prefetching vanwege historische redenen.

      Als je deze instelling in- of uitschakelt, kunnen gebruikers deze instelling niet wijzigen of overschrijven in <ph name="PRODUCT_NAME"/>.

      Als dit beleid niet wordt ingesteld, wordt het automatisch ingeschakeld, maar de gebruiker kan het wijzigen.</translation>
<translation id="4541530620466526913">Lokale accounts op apparaat</translation>
<translation id="5815129011704381141">Automatisch opnieuw opstarten na update</translation>
<translation id="1757688868319862958">Hiermee kan <ph name="PRODUCT_NAME"/> plug-ins uitvoeren waarvoor toestemming is vereist.

      Als je deze instelling inschakelt, worden plug-ins altijd uitgevoerd als ze niet verouderd zijn.

      Als deze instelling is uitgeschakeld of niet is ingesteld, wordt gebruikers om toestemming gevraagd voordat plug-ins worden uitgevoerd waarvoor toestemming is vereist. Dit zijn de plug-ins die een beveiligingsrisico kunnen vormen.</translation>
<translation id="6392973646875039351">Hiermee wordt de functie Automatisch aanvullen van <ph name="PRODUCT_NAME"/> ingeschakeld en wordt gebruikers toegestaan webformulieren automatisch in te vullen met eerder opgeslagen informatie zoals adres- of creditcardgegevens.

      Als je deze instelling uitschakelt, kunnen gebruikers de functie Automatisch aanvullen niet gebruiken.

      Als je de instelling inschakelt of geen waarde instelt, kunnen gebruikers de opties voor Automatisch aanvullen zelf beheren. Zo kunnen ze profielen voor Automatisch aanvullen configureren en de functie naar wens in- of uitschakelen.</translation>
<translation id="6157537876488211233">Door komma's gescheiden lijst van regels voor proxyomzeiling</translation>
<translation id="7788511847830146438">Per profiel</translation>
<translation id="2516525961735516234">Hiermee wordt gespecificeerd of videoactiviteit invloed heeft op stroombeheer.

          Als dit beleid is ingesteld op 'waar' of niet is ingesteld, wordt de gebruiker niet beschouwd als inactief terwijl de video wordt afgespeeld. Hiermee wordt voorkomen dat de inactieve vertraging, vertraging van dimmen van het scherm, scherm uitschakelen en vertraging van schermvergrendeling worden bereikt en dat de bijbehorende acties worden ondernomen.

          Als dit beleid is ingesteld op 'onwaar', voorkomt videoactiviteit niet dat de gebruiker als inactief wordt beschouwd.</translation>
<translation id="3965339130942650562">Time-out tot de inactieve gebruiker is uitgelogd</translation>
<translation id="5814301096961727113">De standaardstatus van gesproken feedback op het inlogscherm instellen</translation>
<translation id="9084985621503260744">Specificeer of videoactiviteit invloed heeft op stroombeheer</translation>
<translation id="7091198954851103976">Plug-ins waarvoor toestemming is vereist, altijd uitvoeren</translation>
<translation id="1708496595873025510">De beperking voor het ophalen van de seed voor varianten instellen</translation>
<translation id="8870318296973696995">Startpagina</translation>
<translation id="1240643596769627465">Hiermee kun je de URL opgeven van de zoekmachine die wordt gebruikt om instant resultaten te leveren. De URL moet de tekenreeks '<ph name="SEARCH_TERM_MARKER"/>' bevatten, die op het moment van de zoekopdracht wordt vervangen door de tekst die de gebruiker tot op dat moment heeft getypt.

          Dit beleid is optioneel. Als het beleid niet is ingesteld, worden er geen instant resultaten geleverd.

          Dit beleid wordt alleen gerespecteerd als het beleid 'DefaultSearchProviderEnabled' is ingeschakeld.</translation>
<translation id="6693751878507293182">Als je deze instelling inschakelt, wordt het automatisch zoeken naar en de installatie van ontbrekende plug-ins uitgeschakeld in <ph name="PRODUCT_NAME"/>.

      Als je deze optie uitschakelt of niet instelt, wordt de zoekfunctie voor plug-ins geactiveerd.</translation>
<translation id="2650049181907741121">Actie die wordt ondernomen wanneer de gebruiker de klep sluit</translation>
<translation id="7880891067740158163">Hiermee kun je een lijst met URL-patronen opgeven waarvoor <ph name="PRODUCT_NAME"/> automatisch een clientcertificaat moet selecteren als de site vraagt om een certificaat.

          Als dit beleid niet wordt ingesteld, wordt er geen automatische selectie uitgevoerd voor sites.</translation>
<translation id="3866249974567520381">Beschrijving</translation>
<translation id="5192837635164433517">Hiermee wordt het gebruik ingeschakeld van alternatieve foutpagina's die zijn geïntegreerd in <ph name="PRODUCT_NAME"/> (zoals 'pagina niet gevonden') en wordt voorkomen dat gebruikers deze instelling kunnen wijzigen.

      Als je deze instelling inschakelt, worden er alternatieve foutpagina's gebruikt.

      Als je deze instelling uitschakelt, worden er nooit alternatieve foutpagina's gebruikt.

      Als je deze instelling in- of uitschakelt, kunnen gebruikers de instelling niet aanpassen of negeren in <ph name="PRODUCT_NAME"/>.

      Als dit beleid niet wordt ingesteld, wordt dit ingeschakeld maar kan de gebruiker dit wijzigen.</translation>
<translation id="2236488539271255289">Niet toestaan dat sites lokaal gegevens instellen</translation>
<translation id="4467952432486360968">Indirecte cookies blokkeren</translation>
<translation id="1305864769064309495">Een woordenboek dat URL's toewijst aan een booleaanse markering die aangeeft of toegang tot de host moet worden toegestaan ('true') of geblokkeerd ('false').

          Dit beleid is bedoeld voor intern gebruik door Chrome zelf.</translation>
<translation id="5586942249556966598">Niets doen</translation>
<translation id="131353325527891113">Gebruikersnamen weergeven in het aanmeldscherm</translation>
<translation id="5317965872570843334">Maakt het gebruik van STUN en relayservers mogelijk wanneer externe clients verbinding proberen te maken met dit apparaat.

          Als deze instelling is ingeschakeld, kunnen externe clients deze apparaten zien en hier verbinding mee maken, zelfs als ze worden gescheiden door een firewall.

          Als deze instelling is uitgeschakeld en uitgaande UDP-verbindingen worden gefilterd door de firewall, staat dit apparaat alleen verbindingen toe met clientapparaten binnen het lokale netwerk.

          Als dit beleid niet wordt ingesteld, wordt de instelling ingeschakeld.</translation>
<translation id="4057110413331612451">Zakelijke gebruikers alleen toestaan een primaire multiprofielgebruiker te zijn</translation>
<translation id="5365946944967967336">Knop 'Startpagina' in de werkbalk weergeven</translation>
<translation id="3709266154059827597">Zwarte lijst voor het installeren van extensies configureren</translation>
<translation id="8451988835943702790">De pagina 'Nieuw tabblad' als startpagina gebruiken</translation>
<translation id="4617338332148204752">De metatagcontrole in <ph name="PRODUCT_FRAME_NAME"/> overslaan</translation>
<translation id="8469342921412620373">Hiermee wordt het gebruik van een standaardzoekprovider ingeschakeld.

          Als je deze instelling inschakelt, wordt er een zoekopdracht uitgevoerd via een standaardzoekprovider wanneer een gebruiker tekst in de omnibox opgeeft die geen URL is.

          Je kunt de standaardzoekprovider opgeven door de rest van het standaardzoekbeleid in te stellen. Als dit niet wordt ingesteld, kan de gebruiker zelf de standaardprovider kiezen.

          Als je deze instelling uitschakelt, wordt er geen zoekopdracht uitgevoerd wanneer de gebruiker tekst in de omnibox opgeeft die geen URL is.

          Als je deze instelling in- of uitschakelt, kunnen gebruikers de instelling niet aanpassen of negeren in <ph name="PRODUCT_NAME"/>.

          Als dit beleid niet wordt ingesteld, wordt de standaardzoekprovider ingeschakeld en kan de gebruiker de lijst voor de zoekprovider instellen.</translation>
<translation id="4791031774429044540">De toegankelijkheidsfunctie 'Grote muisaanwijzer' inschakelen.

          Als dit beleid op 'waar' is ingesteld, is de grote muisaanwijzer altijd ingeschakeld.

          Als dit beleid op 'onwaar' is ingesteld, is de grote muisaanwijzer altijd uitgeschakeld.

          Als je dit beleid instelt, kunnen gebruikers dit niet wijzigen of negeren.

          Als je dit beleid niet instelt, is de grote muisaanwijzer eerst uitgeschakeld, maar kan de gebruiker deze op elk moment inschakelen.</translation>
<translation id="2633084400146331575">Gesproken feedback inschakelen</translation>
<translation id="8731693562790917685">Met instellingen voor inhoud kun je opgeven hoe inhoud van een bepaald type (zoals cookies, afbeeldingen of JavaScript) wordt verwerkt.</translation>
<translation id="2411919772666155530">Meldingen op deze sites blokkeren</translation>
<translation id="6923366716660828830">Hiermee wordt de naam van de standaardzoekprovider gespecificeerd. Als dit leeg is of niet wordt ingesteld, wordt de hostnaam gebruikt die door de zoek-URL wordt gespecificeerd.

          Dit beleid wordt alleen gebruikt als het beleid 'DefaultSearchProviderEnabled' is ingeschakeld.</translation>
<translation id="4869787217450099946">Geeft aan of schermactiveringsvergrendeling is toegestaan. Deze kan worden aangevraagd door extensies via de API voor de stroombeheerextensie.

          Als dit beleid is ingesteld als 'true' of als het niet is ingesteld, wordt schermactiveringsvergrendeling ingesteld voor stroombeheer.

          Als dit beleid is ingesteld als 'false', worden verzoeken voor schermactiveringsvergrendeling genegeerd.</translation>
<translation id="467236746355332046">Ondersteunde functies:</translation>
<translation id="7632724434767231364">Naam van GSSAPI-bibliotheek</translation>
<translation id="3038323923255997294">Doorgaan met uitvoeren van achtergrondapps als <ph name="PRODUCT_NAME"/> is gesloten</translation>
<translation id="8909280293285028130">Hiermee wordt de tijdsduur zonder input van gebruikers gespecificeerd waarna het scherm wordt vergrendeld als er op netstroom wordt gewerkt.

          Als dit beleid is ingesteld op een grotere waarde dan nul, specificeert het de tijd die de gebruiker inactief moet blijven voordat het scherm wordt vergrendeld door <ph name="PRODUCT_OS_NAME"/>.

          Als dit beleid is ingesteld op nul, wordt het scherm niet vergrendeld door <ph name="PRODUCT_OS_NAME"/> wanneer de gebruiker inactief wordt.

          Als dit beleid niet is ingesteld, wordt een standaardtijdsduur gebruikt.

          De aanbevolen manier om het scherm bij inactiviteit te vergrendelen is door schermvergrendeling bij onderbreking in te schakelen en <ph name="PRODUCT_OS_NAME"/> te onderbreken na de inactieve vertraging. Dit beleid mag alleen worden gebruikt wanneer schermvergrendeling veel eerder voorkomt dan onderbreking of wanneer onderbreking bij inactiviteit helemaal niet gewenst is.

          De beleidswaarde moet worden opgegeven in milliseconden. Waarden moeten lager zijn dan de inactieve vertraging.</translation>
<translation id="7651739109954974365">Bepaalt of gegevensroaming moet worden ingeschakeld voor het apparaat. Als dit is ingesteld op 'true', wordt gegevensroaming toegestaan. Als de instelling niet wordt geconfigureerd of op 'false' is ingesteld, is gegevensroaming niet beschikbaar.</translation>
<translation id="6244210204546589761">URL's die worden geopend bij starten</translation>
<translation id="7468416082528382842">Locatie van Windows-register:</translation>
<translation id="1808715480127969042">Cookies blokkeren op deze sites</translation>
<translation id="1908884158811109790">Schakelt Google Drive uit via mobiele verbindingen in de app Bestanden van Chrome OS</translation>
<translation id="7340034977315324840">Tijdsduur van apparaatgebruik melden</translation>
<translation id="4928632305180102854">Controleert of <ph name="PRODUCT_OS_NAME"/> het maken van nieuwe gebruikersaccounts toestaat. Als dit beleid is ingesteld op 'false', kunnen gebruikers die nog geen account hebben inloggen.

      Als dit beleid is ingesteld op 'true' of niet is geconfigureerd, kunnen er nieuwe gebruikersaccounts worden gemaakt, mits <ph name="DEVICEUSERWHITELISTPROTO_POLICY_NAME"/> de gebruiker toestaat in te loggen.</translation>
<translation id="4389091865841123886">De externe bevestiging configureren met een TPM-mechanisme.</translation>
<translation id="8256688113167012935">Hiermee wordt de weergave van de accountnaam in <ph name="PRODUCT_OS_NAME"/> op het aanmeldscherm beheerd voor het bijbehorende lokale account van het apparaat.

      Als dit beleid is ingesteld, gebruikt het aanmeldscherm de opgegeven tekenreeks in de afbeeldinggebaseerde aanmeldkiezer voor het bijbehorende lokale account van het apparaat.

      Als het beleid niet wordt ingesteld, gebruikt <ph name="PRODUCT_OS_NAME"/> de e-mailaccount-ID van het lokale account van het apparaat als de weergavenaam op het aanmeldscherm.

      Dit beleid wordt genegeerd voor gewone gebruikersaccounts.</translation>
<translation id="267596348720209223">Hiermee worden de tekencoderingen gespecificeerd die door de zoekprovider worden ondersteund. Deze coderingen zijn codepaginanamen zoals UTF-8, GB2312 en ISO-8859-1. Ze worden getest in de volgorde waarin ze worden opgegeven.

          Dit beleid is optioneel. Als het beleid niet wordt ingesteld, wordt de standaardcodering (UTF-8) gebruikt.

          Dit beleid wordt alleen gerespecteerd als het beleid 'DefaultSearchProviderEnabled' is ingeschakeld.</translation>
<translation id="1349276916170108723">Hiermee wordt synchronisatie van Google Drive in de app Bestanden van Chrome OS uitgeschakeld wanneer de optie is ingesteld als 'true'. In dat geval worden geen gegevens naar Google Drive geüpload.

          Indien de optie niet is ingesteld of is ingesteld als 'false', kunnen gebruikers bestanden naar Google Drive overzetten.</translation>
<translation id="1964634611280150550">Incognitomodus uitgeschakeld</translation>
<translation id="5971128524642832825">Schakelt Google Drive uit in de app Bestanden van Chrome OS</translation>
<translation id="1847960418907100918">Specificeert de parameters die worden gebruikt voor het uitvoeren van een instantzoekopdracht met POST. Het bestaat uit door komma's gescheiden naam/waarde-paren. Als een waarde een sjabloonparameter, zoals {searchTerms} in het bovenstaande voorbeeld, is, wordt de waarde vervangen door echte zoektermgegevens.

          Dit beleid is optioneel. Als het beleid niet is ingesteld, wordt de instantzoekopdracht verzonden met de GET-methode.

          Dit beleid wordt alleen gerespecteerd als het beleid 'DefaultSearchProviderEnabled' is ingeschakeld.</translation>
<translation id="1454846751303307294">Hiermee kun je een lijst URL-patronen instellen waarmee sites worden gespecificeerd die JavaScript niet mogen uitvoeren.

          Als dit beleid niet wordt ingesteld, wordt de algemene standaardwaarde gebruikt voor alle sites op basis van het beleid 'DefaultJavaScriptSetting' (als dit is ingesteld) of anders op basis van de configuratie van de gebruiker.</translation>
<translation id="538108065117008131"><ph name="PRODUCT_FRAME_NAME"/> toestaan de volgende soorten inhoud te verwerken.</translation>
<translation id="2312134445771258233">Hiermee kun he de pagina's configureren die bij het starten worden geladen.

      De inhoud van de lijst 'URL's die worden geopend bij starten' wordt genegeerd, tenzij je 'Een lijst met URL's openen' selecteert bij 'Actie bij starten'.</translation>
<translation id="243972079416668391">Specificeer de actie die moet worden ondernomen wanneer de vertraging voor inactief wordt bereikt bij gebruik op netspanning.

          Als dit beleid is ingesteld, specificeert het de actie die <ph name="PRODUCT_OS_NAME"/> onderneemt wanneer de gebruiker inactief blijft gedurende de periode die wordt aangegeven door de vertraging voor inactief. Deze periode kan afzonderlijk worden geconfigureerd.

          Als het instellen van dit beleid ongedaan wordt gemaakt, wordt de standaardactie ondernomen, namelijk opschorten.

          Als de actie opschorten is, kan <ph name="PRODUCT_OS_NAME"/> afzonderlijk worden geconfigureerd om het scherm wel of niet te vergrendelen vóór het opschorten.</translation>
<translation id="7750991880413385988">Pagina 'Nieuw tabblad' openen</translation>
<translation id="741903087521737762">Hiermee kun je het gedrag tijdens het starten opgeven.

          Als je 'Pagina 'Nieuw tabblad' openen' kiest, wordt de pagina 'Nieuw tabblad' altijd geopend wanneer je <ph name="PRODUCT_NAME"/> start.

          Als je 'De laatste sessie herstellen' kiest, worden de URL's die waren geopend toen <ph name="PRODUCT_NAME"/> de laatste keer werd gesloten, opnieuw geopend en wordt de browsersessie hersteld zoals deze is achtergelaten.

          Als je deze optie kiest, worden bepaalde instellingen uitgeschakeld die gebruikmaken van sessies of die acties uitvoeren tijdens het afsluiten (zoals het wissen van browsergegevens tijdens het afsluiten of het wissen van sessiecookies).

          Als je 'Een lijst met URL's openen' kiest, wordt de lijst 'URL's die worden geopend bij starten' geopend wanneer een gebruiker <ph name="PRODUCT_NAME"/> start.

          Als je deze instelling inschakelt, kunnen gebruikers deze niet wijzigen of negeren in <ph name="PRODUCT_NAME"/>.

          Het uitschakelen van deze instelling staat gelijk aan het niet configureren van de instelling. De gebruiker kan de instelling nog steeds wijzigen in <ph name="PRODUCT_NAME"/>.</translation>
<translation id="8161570238552664224">Het afspelen van audio toestaan.

      Als dit beleid is ingesteld op 'onwaar', is audio-uitvoer niet beschikbaar op het apparaat wanneer de gebruiker is ingelogd.

      Dit beleid is van invloed op alle typen audio-invoer en niet alleen op de ingebouwde luidsprekers. Dit beleid is ook van invloed op toegankelijkheidsfuncties voor audio. Schakel dit beleid niet in als de gebruiker een schermlezer nodig heeft.

      Als deze instelling is ingesteld op 'waar' of 'niet geconfigureerd', kunnen gebruikers alle ondersteunde audio-uitvoer op hun apparaat gebruiken.</translation>
<translation id="5761030451068906335">Hiermee configureer je de proxyinstellingen voor <ph name="PRODUCT_NAME"/>. Dit beleid is nog niet klaar voor gebruik, gebruik het dus niet.</translation>
<translation id="3006443857675504368">Toegankelijkheidsopties voor <ph name="PRODUCT_OS_NAME"/> weergeven in het systeemmenu.

          Als dit beleid is ingesteld op 'waar', worden toegankelijkheidsopties altijd weergegeven in het systeemvakmenu.

          Als dit beleid is ingesteld op 'onwaar', worden toegankelijkheidsopties nooit weergegeven in het systeemvakmenu.

          Als je dit beleid instelt, kunnen gebruikers het niet wijzigen of overschrijven.

          Als je dit beleid niet instelt, worden toegankelijkheidsopties niet weergegeven in het systeemvakmenu, maar kan de gebruiker de toegankelijkheidsopties laten weergeven via de pagina 'Instellingen'.</translation>
<translation id="8344454543174932833">Bladwijzers importeren uit standaardbrowser bij eerste uitvoering</translation>
<translation id="1019101089073227242">Gegevensdirectory voor gebruiker instellen</translation>
<translation id="5826047473100157858">Geeft aan of de gebruiker pagina's in de incognitomodus mag openen in <ph name="PRODUCT_NAME"/>.

      Als 'Ingeschakeld' is geselecteerd, mogen pagina's worden geopend in de incognitomodus.

      Als 'Uitgeschakeld' is geselecteerd, mogen pagina's niet worden geopend in de incognitomodus.

      Als 'Afgedwongen' is geselecteerd, mogen pagina's ALLEEN worden geopend in de incognitomodus.</translation>
<translation id="2988031052053447965">De app en voettekstlink voor de Chrome Web Store verbergen op de pagina 'Nieuw tabblad' en in het app-opstartprogramma van Chrome OS.

      Als dit beleid is ingesteld op 'waar', zijn de pictogrammen verborgen.

      Als dit beleid is ingesteld op 'onwaar' of niet is ingesteld, zijn de pictogrammen zichtbaar.</translation>
<translation id="5085647276663819155">Afdrukvoorbeeld uitschakelen</translation>
<translation id="8672321184841719703">Doelversie voor automatische updates</translation>
<translation id="1689963000958717134">Hiermee kun je een netwerkconfiguratie toepassen voor alle gebruikers van een <ph name="PRODUCT_OS_NAME"/>-apparaat. De netwerkconfiguratie is een tekenreeks met JSON-indeling, zoals gedefinieerd door de indeling voor open netwerkconfiguratie, beschreven op <ph name="ONC_SPEC_URL"/></translation>
<translation id="6699880231565102694">Authenticatie in twee stappen inschakelen voor hosts voor externe toegang</translation>
<translation id="2030905906517501646">Zoekwoord voor standaardzoekprovider</translation>
<translation id="3072045631333522102">Schermbeveiliging voor gebruik in het inlogvenster in de winkelmodus</translation>
<translation id="4550478922814283243">Verificatie zonder pincode in- of uitschakelen</translation>
<translation id="7712109699186360774">Elke keer vragen wanneer een site toegang wil hebben tot de camera en/of microfoon</translation>
<translation id="350797926066071931">Vertalen inschakelen</translation>
<translation id="3711895659073496551">Onderbreken</translation>
<translation id="4010738624545340900">Activering van dialoogvensters voor het selecteren van bestanden toestaan</translation>
<translation id="4518251772179446575">Vragen wanneer een site de fysieke locatie van gebruikers wil bijhouden</translation>
<translation id="402759845255257575">Niet toestaan dat sites JavaScript uitvoeren</translation>
<translation id="5457924070961220141">Hiermee kun je de standaard HTML-renderer configureren wanneer <ph name="PRODUCT_FRAME_NAME"/> is geïnstalleerd.
          De standaardinstelling die wordt gebruikt wanneer dit beleid niet wordt ingesteld, wordt gebruikt om de hostbrowser de rendering te laten regelen, maar je kunt dit naar wens aanpassen en <ph name="PRODUCT_FRAME_NAME"/> HTML-pagina's standaard laten renderen.</translation>
<translation id="706669471845501145">Sites toestaan bureaubladmeldingen weer te geven</translation>
<translation id="7529144158022474049">Spreidingsfactor voor automatische update</translation>
<translation id="2188979373208322108">Hiermee wordt de bladwijzerbalk ingeschakeld in <ph name="PRODUCT_NAME"/>.

      Als je deze instelling inschakelt, geeft <ph name="PRODUCT_NAME"/> een bladwijzerbalk weer.

      Als je deze instelling uitschakelt, krijgen gebruikers de bladwijzerbalk nooit te zien.

      Als je deze instelling in- of uitschakelt, kunnen gebruikers de instelling niet aanpassen of negeren in <ph name="PRODUCT_NAME"/>.

      Als deze instelling niet wordt ingesteld, kan de gebruiker zelf bepalen deze functie wel of niet te gebruiken.</translation>
<translation id="5475361623548884387">Afdrukken inschakelen</translation>
<translation id="7287359148642300270">Hiermee wordt gespecificeerd welke servers op de witte lijst voor geïntegreerde verificatie moeten worden geplaatst. Geïntegreerde verificatie wordt alleen ingeschakeld wanneer <ph name="PRODUCT_NAME"/> een verificatieverzoek ontvangt van een proxy of van een server die op deze toegestane lijst staat.

          Scheid meerdere servernamen van elkaar met komma's. Jokertekens (*) zijn toegestaan.

          Als je dit beleid niet instelt, probeert Chrome te detecteren op een server zich in het intranet bevindt en wordt daarna pas gereageerd op IWA-verzoeken. Als een server wordt gedetecteerd als intranet, worden IWA-verzoeken van de server genegeerd door Chrome.</translation>
<translation id="3653237928288822292">Pictogram voor standaardzoekprovider</translation>
<translation id="2872961005593481000">Afsluiten</translation>
<translation id="4445684791305970001">Hiermee worden de hulpprogramma's voor ontwikkelaars en de JavaScript-console uitgeschakeld.

      Als je deze instelling inschakelt, kunnen de hulpprogramma's voor ontwikkelaars niet meer worden geopend en kunnen website-elementen niet meer worden geïnspecteerd. Alle sneltoetsen en menu- en contextmenu-opties voor het openen van de hulpprogramma's voor ontwikkelaars of de JavaScript-console worden uitgeschakeld.

      Als je deze optie uitschakelt of niet instelt, kunnen hulpprogramma's voor ontwikkelaars en de JavaScript-console worden gebruikt.</translation>
<translation id="9203071022800375458">Hiermee schakel je het maken van screenshots uit.

      Als deze instelling is ingeschakeld, kunnen screenshots niet worden gemaakt met sneltoetsen op het toetsenbord of extensie-API's.

      Als deze instelling is uitgeschakeld of niet is opgegeven, mogen er screenshots worden gemaakt.</translation>
<translation id="5697306356229823047">Apparaatgebruikers melden</translation>
<translation id="8649763579836720255">Chrome OS-apparaten kunnen externe verificatie (geverifieerde toegang) gebruiken om een certificaat te ontvangen dat is uitgegeven door de certificaatautoriteit voor Chrome OS en waarin het apparaat uniek wordt geïdentificeerd.

          Als deze instelling is ingesteld op 'niet waar', gebruikt het apparaat geen externe verificatie om inhoud te beveiligen en kan het apparaat beveiligde inhoud mogelijk niet afspelen.

          Als deze instelling is ingesteld op 'waar' of als deze niet is geconfigureerd, kan externe verificatie worden gebruikt voor het beveiligen van inhoud.</translation>
<translation id="4632343302005518762"><ph name="PRODUCT_FRAME_NAME"/> toestaan de vermelde soorten inhoud te verwerken.</translation>
<translation id="13356285923490863">Naam van beleid</translation>
<translation id="557658534286111200">Het bewerken van bladwijzers in- of uitschakelen</translation>
<translation id="5378985487213287085">Hiermee kun je instellen of websites bureaubladmeldingen mogen weergeven. Het weergeven van bureaubladmeldingen kan standaard worden toegestaan of geweigerd, of de gebruiker kan een melding te zien krijgen wanneer een website bureaubladmeldingen wil weergeven.

          Als dit beleid niet wordt ingesteld, wordt 'AskNotifications' gebruikt en kan de gebruiker dit aanpassen.</translation>
<translation id="2386362615870139244">Schermactiveringsvergrendeling toestaan</translation>
<translation id="6908640907898649429">Hiermee wordt de standaardzoekprovider geconfigureerd. Je kunt de standaardzoekprovider specificeren die de gebruiker gaat gebruiken, of je kunt ervoor kiezen de standaardzoekfunctie uit te schakelen.</translation>
<translation id="6544897973797372144">Als dit beleid is ingesteld op 'Waar' en het beleid ChromeOsReleaseChannel niet is ingesteld, mogen gebruikers van het registrerende domein het releasekanaal van het apparaat wijzigen. Als dit beleid is ingesteld op 'Onwaar', wordt het apparaat vergrendeld op het laatst ingestelde kanaal.

      Het door de gebruiker geselecteerde kanaal wordt overschreven door het beleid ChromeOsReleaseChannel. Als het beleidskanaal echter stabieler is dan het kanaal dat is geïnstalleerd op het apparaat, wordt het kanaal pas gewijzigd nadat de versie van het stabielere kanaal een hoger versienummer bereikt dan de versie die op het apparaat is geïnstalleerd.</translation>
<translation id="389421284571827139">Hiermee kun je de proxyserver specificeren die door <ph name="PRODUCT_NAME"/> wordt gebruikt en wordt voorkomen dat gebruikers proxyinstellingen kunnen aanpassen.

      Als je ervoor kiest nooit een proxyserver te gebruiken en altijd rechtstreeks verbinding te maken, worden alle andere opties genegeerd.

      Als je ervoor kiest de proxyserver automatisch te detecteren, worden alle andere opties genegeerd.

      Ga voor gedetailleerde voorbeelden naar:
      <ph name="PROXY_HELP_URL"/>

      Als je deze instelling inschakelt, negeert <ph name="PRODUCT_NAME"/> alle aan proxy's gerelateerde opties die via de opdrachtregel worden opgegeven.

      Als je dit beleid niet instelt, kunnen gebruikers zelf de gewenste proxyinstellingen selecteren.</translation>
<translation id="681446116407619279">Ondersteunde authenticatieschema's</translation>
<translation id="4027608872760987929">De standaardzoekprovider inschakelen</translation>
<translation id="2223598546285729819">Standaardinstelling voor meldingen</translation>
<translation id="6158324314836466367">Naam van zakelijke webwinkel (verouderd)</translation>
<translation id="3984028218719007910">Bepaalt of <ph name="PRODUCT_OS_NAME"/> na het afmelden lokale accountgegevens bewaart. Als dit is ingesteld op 'true', bewaart <ph name="PRODUCT_OS_NAME"/> geen bestaande accounts en worden alle gegevens over de gebruikerssessie na het afmelden gewist. Als dit beleid is ingesteld op 'false' of niet is geconfigureerd, bewaart het apparaat mogelijk (gecodeerde) lokale gebruikersgegevens.</translation>
<translation id="3793095274466276777">Hiermee worden de controles van standaardbrowser in <ph name="PRODUCT_NAME"/> geconfigureerd en wordt voorkomen dat gebruikers deze instelling kunnen wijzigen.

      Als je deze instelling inschakelt, controleert <ph name="PRODUCT_NAME"/> bij het starten altijd of dit programma de standaardbrowser is en registreert zichzelf indien mogelijk automatisch.

      Als deze instelling is uitgeschakeld, controleert <ph name="PRODUCT_NAME"/> nooit of dit programma de standaardbrowser is en worden gebruikersopties voor het instellen van de standaardbrowser uitgeschakeld.

      Als deze instelling niet is ingeschakeld, kan de gebruiker in <ph name="PRODUCT_NAME"/> bepalen of dit programma de standaardbrowser is, en of er een melding aan de gebruiker moet worden weergegeven wanneer dit niet het geval is.</translation>
<translation id="3504791027627803580">Specificeert de URL van de zoekmachine die wordt gebruikt om de functie voor zoeken naar afbeeldingen te leveren. Zoekopdrachten worden verzonden met de GET-methode. Als het beleid DefaultSearchProviderImageURLPostParams is ingesteld, gebruiken zoekopdrachten voor afbeeldingen in plaats daarvan de POST-methode.

          Dit beleid is optioneel. Als het beleid niet is ingesteld, wordt er geen functie voor afbeeldingen zoeken gebruikt.

          Dit beleid wordt alleen gerespecteerd als het beleid 'DefaultSearchProviderEnabled' is ingeschakeld.</translation>
<translation id="7529100000224450960">Hiermee kun je een lijst met URL-patronen instellen waarmee sites worden gespecificeerd waarop pop-ups mogen worden geopend.

          Als dit beleid niet wordt ingesteld, wordt de algemene standaardwaarde gebruikt voor alle sites op basis van het beleid 'DefaultPopupsSetting' (als dit is ingesteld) of anders op basis van de configuratie van de gebruiker.</translation>
<translation id="6155936611791017817">De standaardstatus van de grote muisaanwijzer op het inlogscherm instellen</translation>
<translation id="1530812829012954197">De volgende URL-patronen altijd verwerken in de hostbrowser</translation>
<translation id="9026000212339701596">Een woordenboek dat hostnamen toewijst aan een booleaanse markering die aangeeft of toegang tot de host moet worden toegestaan ('true') of geblokkeerd ('false').

          Dit beleid is bedoeld voor intern gebruik door Chrome zelf.</translation>
<translation id="913195841488580904">Toegang blokkeren voor een lijst met URL's</translation>
<translation id="3292147213643666827">Met deze instelling kan <ph name="PRODUCT_NAME"/> als proxy worden ingesteld tussen <ph name="CLOUD_PRINT_NAME"/> en printers die zijn aangesloten op het apparaat.

      Als deze instelling is ingeschakeld of niet is geconfigureerd, kunnen gebruikers de proxy voor Cloudprinter inschakelen met authenticatie via hun Google-account.

      Als deze instelling is uitgeschakeld, kunnen gebruikers de proxy niet inschakelen en kan de computer zijn printers niet delen met <ph name="CLOUD_PRINT_NAME"/>.</translation>
<translation id="6373222873250380826">Schakelt automatische updates uit als dit is ingesteld op 'True'.

      <ph name="PRODUCT_OS_NAME"/>-apparaten zoeken automatisch naar updates als deze instelling niet is geconfigureerd of is ingesteld op 'False'.</translation>
<translation id="6190022522129724693">Standaardinstelling voor pop-ups</translation>
<translation id="847472800012384958">Niet toestaan dat sites pop-ups weergeven</translation>
<translation id="4733471537137819387">Beleid met betrekking tot geïntegreerde HTTP-authenticatie.</translation>
<translation id="8951350807133946005">Directory voor schijfcache instellen</translation>
<translation id="603410445099326293">Parameters voor suggestie-URL die POST gebruikt</translation>
<translation id="2592091433672667839">Duur van inactiviteit voordat de schermbeveiliging wordt weergegeven in het inlogvenster in de winkelmodus</translation>
<translation id="166427968280387991">Proxyserver</translation>
<translation id="2805707493867224476">Alle sites toestaan pop-ups weer te geven</translation>
<translation id="1727394138581151779">Alle plug-ins blokkeren</translation>
<translation id="8118665053362250806">Grootte voor mediaschijfcache instellen</translation>
<translation id="7079519252486108041">Pop-ups blokkeren op deze sites</translation>
<translation id="1859633270756049523">De sessielengte beperken</translation>
<translation id="7433714841194914373">Instant inschakelen</translation>
<translation id="4983201894483989687">Verouderde plug-ins toestaan die actief zijn</translation>
<translation id="443665821428652897">Sitegegevens wissen als de browser wordt gesloten (verouderd)</translation>
<translation id="3823029528410252878">Hiermee wordt het opslaan van de browsergeschiedenis in <ph name="PRODUCT_NAME"/> uitgeschakeld en wordt voorkomen dat gebruikers deze instelling kunnen wijzigen.

      Als deze instelling is ingeschakeld, wordt de browsergeschiedenis niet opgeslagen.

      Als deze instelling is uitgeschakeld of niet is ingesteld, wordt de browsergeschiedenis opgeslagen.</translation>
<translation id="7295019613773647480">Bewaakte gebruikers inschakelen</translation>
<translation id="2759224876420453487">Het gebruikersgedrag beheren in een multiprofielsessie</translation>
<translation id="3844092002200215574">Hiermee wordt de directory geconfigureerd die <ph name="PRODUCT_NAME"/> gebruikt om gecachte bestanden op schijf op te slaan.

      Als je dit beleid instelt, gebruikt <ph name="PRODUCT_NAME"/> deze directory, ongeacht of de gebruiker de markering voor '--disk-cache-dir' heeft ingesteld.

      Ga naar http://www.chromium.org/administrators/policy-list-3/user-data-directory-variables voor een lijst met variabelen die kunnen worden gebruikt.

      Als dit beleid niet wordt ingesteld, wordt de standaardcachedirectory gebruikt en kan de gebruiker dit overschrijven met de opdrachtregelmarkering '--disk-cache-dir'.</translation>
<translation id="3034580675120919256">Hiermee kun je instellen of JavaScript op websites mag worden uitgevoerd. Het uitvoeren van JavaScript kan voor alle websites worden toegestaan of voor alle websites worden geweigerd.

          Als dit beleid niet wordt ingesteld, wordt 'AllowJavaScript' gebruikt en kan de gebruiker dit aanpassen.</translation>
<translation id="193900697589383153">Hiermee wordt een afmeldknop aan de systeembalk toegevoegd.

      Als dit beleid is ingeschakeld, wordt een grote rode afmeldknop weergegeven in de systeembalk terwijl een sessie actief is en het scherm niet is vergrendeld.

      Als dit beleid is uitgeschakeld of niet is gespecificeerd, wordt er geen grote rode afmeldknop weergegeven in de systeembalk.</translation>
<translation id="5111573778467334951">Specificeer de actie die moet worden ondernomen wanneer de vertraging voor inactief wordt bereikt bij gebruik op accuvermogen.

          Als dit beleid is ingesteld, specificeert het de actie die <ph name="PRODUCT_OS_NAME"/> onderneemt wanneer de gebruiker inactief blijft gedurende de periode die wordt aangegeven door de vertraging voor inactief. Deze periode kan afzonderlijk worden geconfigureerd.

          Als het instellen van dit beleid ongedaan wordt gemaakt, wordt de standaardactie ondernomen, namelijk opschorten.

          Als de actie opschorten is, kan <ph name="PRODUCT_OS_NAME"/> afzonderlijk worden geconfigureerd om het scherm wel of niet te vergrendelen vóór het opschorten.</translation>
<translation id="3195451902035818945">Geeft aan of het splitsen van SSL-records moet worden uitgeschakeld. Het splitsen van records is een tijdelijke oplossing voor een fout in SSL 3.0 en TLS 1.0, maar kan compatibiliteitsproblemen met bepaalde HTTPS-servers en -proxy's veroorzaken.
Als het beleid niet wordt ingesteld, of op 'False' wordt ingesteld, wordt het splitsen van records gebruikt bij SSL-/TLS-verbindingen die gebruikmaken van CBC-coderingssuites.</translation>
<translation id="6903814433019432303">Dit beleid is alleen ingeschakeld in de winkelmodus.

      Bepaalt welke serie URL's moet worden geladen als de demosessie wordt gestart. Dit beleid overschrijft alle andere procedures voor het instellen van de eerste URL en kan daarom alleen worden toegepast in een sessie die niet is toegewezen aan een specifieke gebruiker.</translation>
<translation id="5868414965372171132">Netwerkconfiguratie op gebruikersniveau</translation>
<translation id="8519264904050090490">URL's van handmatige uitzonderingen voor beheerde gebruikers</translation>
<translation id="4480694116501920047">SafeSearch afdwingen</translation>
<translation id="465099050592230505">URL van zakelijke webwinkel (verouderd)</translation>
<translation id="1221359380862872747">Gespecificeerde URL's laden in demo-aanmeldvenster</translation>
<translation id="2431811512983100641">Specificeert of de extensie voor domeingebonden TLS-certificaten moet worden ingeschakeld.

      Deze instelling wordt gebruikt voor het inschakelen van de extensie voor domeingebonden TLS-certificaten, om de extensie te testen. Deze experimentele instelling wordt in de toekomst verwijderd.</translation>
<translation id="8711086062295757690">Hiermee wordt het zoekwoord gespecificeerd dat in de omnibox wordt gebruikt om de zoekfunctie voor deze provider te activeren.

          Dit beleid is optioneel. Als je dit niet instelt, wordt de zoekfunctie voor de provider door geen enkel zoekwoord geactiveerd.

          Dit beleid wordt alleen gebruikt als het beleid 'DefaultSearchProviderEnabled' is ingeschakeld.</translation>
<translation id="5774856474228476867">Zoek-URL voor standaardzoekprovider</translation>
<translation id="4650759511838826572">URL-protocolschema's uitschakelen</translation>
<translation id="7831595031698917016">Specificeert de maximum vertraging in milliseconden tussen het ontvangen van een ongeldigverklaring van een beleid en het ophalen van het nieuwe beleid uit de apparaatbeheerservice.

      Als je dit beleid instelt, wordt de standaardwaarde van 5000 milliseconden genegeerd. Geldige waarden voor dit beleid vallen binnen het bereik van 1000 (1 seconde) tot 300.000 (5 minuten). Waarden buiten dit bereik worden vast ingesteld op de respectieve grenswaarde.

      Als je dit beleid niet instelt, gebruikt <ph name="PRODUCT_NAME"/> de standaardwaarde van 5000 milliseconden.</translation>
<translation id="8099880303030573137">Inactieve vertraging wanneer op de accu wordt gewerkt</translation>
<translation id="2761483219396643566">Inactieve waarschuwingsvertraging wanneer op de accu wordt gewerkt</translation>
<translation id="5058056679422616660">Nettoladingen (payloads) voor automatische updates voor <ph name="PRODUCT_OS_NAME"/> kunnen worden gedownload via HTTP in plaats van HTTPS. Hierdoor kunnen HTTP-downloads transparant in het HTTP-cachegeheugen worden opgeslagen.

      Als dit beleid is ingesteld op 'waar', probeert <ph name="PRODUCT_OS_NAME"/> nettoladingen voor automatische updates te downloaden via HTTP. Als het beleid is ingesteld op 'niet waar' of niet is geconfigureerd, wordt HTTPS gebruikt voor het downloaden van nettoladingen voor automatische updates.</translation>
<translation id="1468307069016535757">De standaardstatus van de toegankelijkheidsfunctie 'Modus voor hoog contrast' instellen op het inlogscherm

          Als dit beleid op 'waar' is ingesteld, wordt de modus voor hoog contrast ingeschakeld wanneer het inlogscherm wordt weergegeven.

          Als dit beleid op 'onwaar' is ingesteld, wordt de modus voor hoog contrast uitgeschakeld wanneer het inlogscherm wordt weergegeven.

          Als je dit beleid instelt, kunnen gebruikers dit tijdelijk negeren door de modus voor hoog contrast in of uit te schakelen. De keuze van de gebruiker is echter niet permanent en de standaardinstelling wordt hersteld wanneer het inlogscherm opnieuw wordt weergegeven of de gebruiker gedurende een minuut niet actief is op het inlogscherm.

          Als je het beleid niet instelt, wordt de modus voor hoog contrast uitgeschakeld wanneer het inlogscherm voor de eerste keer wordt weergegeven. Gebruikers kunnen de modus voor hoog contrast op elk moment in- of uitschakelen en de status op het inlogscherm is permanent tussen gebruikers.</translation>
<translation id="602728333950205286">Instant-URL voor standaardzoekprovider</translation>
<translation id="3030000825273123558">Rapportage van statistieken inschakelen</translation>
<translation id="8465065632133292531">Parameters voor instant-URL die POST gebruikt</translation>
<translation id="6659688282368245087">Specificeert de klokinstelling die moet worden gebruikt voor het apparaat.

      Dit beleid configureert de klokinstelling die wordt gebruikt op het inlogscherm en als standaard voor gebruikerssessies. Gebruikers kunnen de klokinstelling overschrijven voor hun accounts.

      Als het beleid is ingesteld op 'waar', gebruikt het apparaat een 24-uursnotatie. Als het beleid is ingesteld op 'niet waar', gebruikt het apparaat een 12-uursnotatie.

      Als dit beleid niet is geconfigureerd, maakt het apparaat standaard gebruik van een 24-uursnotatie.</translation>
<translation id="6559057113164934677">Niet toestaan dat sites toegang krijgen tot de camera en microfoon</translation>
<translation id="7273823081800296768">Als deze instelling is ingeschakeld of niet is geconfigureerd, kunnen gebruikers clients en hosts aanmelden op het moment dat verbinding wordt gemaakt, zodat er niet elke keer een pincode hoeft te worden opgegeven.

          Als deze instelling is uitgeschakeld, is deze functie niet beschikbaar.</translation>
<translation id="1675002386741412210">Ondersteund op:</translation>
<translation id="1608755754295374538">URL's die zonder prompt toegang krijgen tot apparaten voor het vastleggen van audio</translation>
<translation id="3547954654003013442">Proxyinstellingen</translation>
<translation id="5921713479449475707">Downloads voor automatische updates via HTTP toestaan</translation>
<translation id="4482640907922304445">Hiermee wordt de knop 'Startpagina' weergegeven in de werkbalk van <ph name="PRODUCT_NAME"/>.

      Als je deze instelling inschakelt, wordt de knop 'Startpagina' altijd weergegeven.

      Als je deze instelling uitschakelt, wordt de knop 'Startpagina' nooit weergegeven.

      Als je deze instelling in- of uitschakelt, kunnen gebruikers de instelling niet aanpassen of negeren in <ph name="PRODUCT_NAME"/>.

      Als dit beleid niet wordt ingesteld, kan de gebruiker kiezen of de knop 'Startpagina' wel of niet wordt weergegeven.</translation>
<translation id="2518231489509538392">Het afspelen van audio toestaan</translation>
<translation id="8146727383888924340">Gebruikers toestaan aanbiedingen in te wisselen via registratie van Chrome OS</translation>
<translation id="7301543427086558500">Hiermee wordt een lijst met alternatieve URL's gespecificeerd die kunnen worden gebruikt om zoektermen uit de zoekmachine te extraheren. De URL's moeten de tekenreeks <ph name="SEARCH_TERM_MARKER"/> bevatten die wordt gebruikt om de zoektermen te extraheren.

          Dit beleid is optioneel. Als het beleid niet wordt ingesteld, worden geen alternatieve URL's gebruikt om zoektermen te verkrijgen.

          Dit beleid wordt alleen gerespecteerd als het beleid 'DefaultSearchProviderEnabled' is ingeschakeld.</translation>
<translation id="436581050240847513">Apparaatnetwerkinterface rapporteren</translation>
<translation id="6282799760374509080">Het opnemen van audio toestaan of weigeren</translation>
<translation id="8864975621965365890">Hiermee onderdruk je de prompt die wordt weergegeven wanneer een site wordt weergegeven door <ph name="PRODUCT_FRAME_NAME"/>.</translation>
<translation id="3264793472749429012">Coderingen voor standaardzoekprovider</translation>
<translation id="285480231336205327">Modus voor hoog contrast inschakelen</translation>
<translation id="5366977351895725771">Als dit is ingesteld op 'false' (niet waar) wordt het maken van bewaakte gebruikers uitgeschakeld voor deze gebruiker. Bestaande bewaakte gebruikers blijven beschikbaar.

          Als dit is ingesteld op 'true' (waar) of niet is geconfigureerd, kunnen bewaakte gebruikers worden gemaakt en beheerd door deze gebruiker.</translation>
<translation id="8101760444435022591">Omdat soft-fail, online certificaatintrekkingscontroles de veiligheid niet aantoonbaar verhogen, worden deze standaard uitgeschakeld in versie 19 en hoger van <ph name="PRODUCT_NAME"/>. Door dit beleid op 'true' in te stellen, wordt het eerdere gedrag hersteld en worden online OCSP/CRL-controles uitgevoerd.

      Als het beleid niet is ingesteld, of is ingesteld op 'false', voert Chrome geen online intrekkingscontroles uit in Chrome 19 en hoger.</translation>
<translation id="5469484020713359236">Hiermee kun je een lijst met URL-patronen instellen waarmee sites worden gespecificeerd die cookies mogen instellen.

          Als dit beleid niet wordt ingesteld, wordt de algemene standaardwaarde gebruikt voor alle sites op basis van het beleid 'DefaultCookiesSetting' (als dit is ingesteld) of anders op basis van de configuratie van de gebruiker.</translation>
<translation id="1504431521196476721">Externe bevestiging</translation>
<translation id="1881299719020653447">De Web Store verbergen op de pagina 'Nieuw tabblad' en in het app-opstartprogramma</translation>
<translation id="930930237275114205">Directory met gebruikersgegevens voor <ph name="PRODUCT_FRAME_NAME"/> instellen</translation>
<translation id="244317009688098048">Sneltoets voor automatisch inloggen inschakelen.

      Als dit beleid niet is ingesteld of is ingesteld als 'true', en een lokaal account op een apparaat is geconfigureerd voor automatisch inloggen zonder uitstel, gebruikt <ph name="PRODUCT_OS_NAME"/> de sneltoets Ctrl+Alt+S voor het overslaan van het automatisch inloggen en weergeven van het inlogvenster.

      Als dit beleid is ingesteld als 'false', kan het automatisch inloggen zonder uitstel (indien geconfigureerd) niet worden overgeslagen.</translation>
<translation id="5208240613060747912">Hiermee kun je een lijst met URL-patronen opgeven van sites waarop geen meldingen mogen worden weergegeven.

          Als dit beleid niet wordt ingesteld, wordt de algemene standaardwaarde gebruikt voor alle sites op basis van het beleid 'DefaultNotificationsSetting' (als dit is ingesteld) of anders op basis van de configuratie van de gebruiker.</translation>
<translation id="346731943813722404">Hiermee wordt aangegeven of vertragingen in energiebeheer en de limiet voor sessielengte pas moeten worden gestart nadat de eerste gebruikersactiviteit in een sessie is gedetecteerd.

          Als dit beleid is ingesteld op 'True', worden vertragingen in energiebeheer en de limiet voor sessielengte pas gestart nadat de eerste gebruikersactiviteit in een sessie is gedetecteerd.

          Als dit beleid is ingesteld op 'False', worden vertragingen in energiebeheer en de limiet voor sessielengte gestart bij het starten van de sessie.</translation>
<translation id="4600786265870346112">Grote muisaanwijzer inschakelen</translation>
<translation id="8592105098257899882">Hiermee wordt de cachegrootte geconfigureerd die <ph name="PRODUCT_NAME"/> gebruikt om gecachte bestanden op schijf op te slaan.

      Als je dit beleid instelt, gebruikt <ph name="PRODUCT_NAME"/> de opgegeven cachegrootte, ongeacht of de gebruiker de optie '--disk-cache-size' heeft ingesteld of niet.

      Als de waarde van het beleid '0' is, wordt de standaard cachegrootte gebruikt, maar kan de gebruiker dit niet wijzigen.

      Als dit beleid niet wordt ingesteld, wordt de standaardgrootte gebruikt en kan de gebruiker dit negeren via de optie '--disk-cache-size'.</translation>
<translation id="5887414688706570295">Hiermee configureer je het voorvoegsel voor het TalkGadget dat wordt gebruikt door hosts voor externe toegang en voorkom je dat gebruikers dit wijzigen.

          Als dit voorvoegsel is opgegeven, wordt het toegevoegd aan het begin van de basisnaam voor het TalkGadget om een volledige domeinnaam voor het TalkGadget te maken. De basisdomeinnaam voor het TalkGadget is '.talkgadget.google.com'.

          Als deze instelling is ingeschakeld, gebruiken hosts de aangepaste domeinnaam in plaats van de standaarddomeinnaam om toegang te krijgen tot het TalkGadget.

          Als deze instelling is uitgeschakeld of niet is ingesteld, wordt de standaarddomeinnaam voor het TalkGadget ('chromoting-host.talkgadget.google.com') gebruikt voor alle hosts.

          Deze beleidsinstelling is niet van toepassing op clients voor externe toegang. Deze clients gebruiken altijd 'chromoting-client.talkgadget.google.com' om toegang tot het TalkGadget te krijgen.</translation>
<translation id="5765780083710877561">Beschrijving:</translation>
<translation id="6915442654606973733">De toegankelijkheidsfunctie voor gesproken feedback inschakelen.

          Als je dit beleid op 'waar' instelt, is gesproken feedback altijd ingeschakeld.

          Als je dit beleid op 'onwaar' instelt, is gesproken feedback altijd uitgeschakeld.

          Als je dit beleid instelt, kunnen gebruikers dit niet wijzigen of negeren.

          Als je dit beleid niet instelt, is gesproken feedback eerst uitgeschakeld maar kan de gebruiker deze op elk moment inschakelen.</translation>
<translation id="7796141075993499320">Hiermee kun je een lijst met URL-patronen instellen waarmee sites worden gespecificeerd waarop plug-ins mogen worden uitgevoerd.

          Als dit beleid niet wordt ingesteld, wordt de algemene standaardwaarde gebruikt voor alle sites, op basis van het beleid 'DefaultPluginsSetting' (als dit is ingesteld) of anders op basis van de configuratie van de gebruiker.</translation>
<translation id="3809527282695568696">Als 'Een lijst met URL's openen' is geselecteerd als de actie na het starten, kun je hier de lijst specificeren met URL's die worden geopend. Als je dit niet selecteert, worden er geen URL's geopend na het starten.

          Dit beleid functioneert alleen als het beleid 'RestoreOnStartup' policy is ingesteld op 'RestoreOnStartupIsURLs'.</translation>
<translation id="649418342108050703">Hiermee kun je ondersteuning voor de API's voor 3D-beelden uitschakelen.

      Als je deze instelling inschakelt, krijgen webpagina's geen toegang tot de GPU (graphics processing unit). Webpagina's krijgen met name geen toegang tot de WebGL-API en plug-ins kunnen de Pepper 3D-API niet gebruiken.

      Als je deze instelling uitschakelt of niet instelt, kunnen webpagina's mogelijk de WebGL-API en plug-ins de Pepper 3D-API gebruiken. In de standaardinstellingen van de browser kan zijn ingesteld dat er opdrachtregelargumenten nodig zijn om deze API's te gebruiken.</translation>
<translation id="2077273864382355561">Vertraging van scherm uitschakelen wanneer op de accu wordt gewerkt</translation>
<translation id="909184783177222836">Stroombeheer</translation>
<translation id="3417418267404583991">Als dit beleid is ingesteld op 'true' of niet is geconfigureerd, staat <ph name="PRODUCT_OS_NAME"/> gasten toe zich aan te melden. Gastensessies zijn anonieme sessies waar geen wachtwoord voor hoeft te worden ingevoerd.

      Als dit beleid is ingesteld op 'false', staat <ph name="PRODUCT_OS_NAME"/> niet toe dat er gastensessies worden gestart.</translation>
<translation id="8329984337216493753">Dit beleid is alleen ingeschakeld in de winkelmodus.

      Als DeviceIdleLogoutTimeout is gespecificeerd, bepaalt dit beleid hoe lang het waarschuwingsvenster met afteltimer wordt weergegeven dat de gebruiker te zien krijgt voordat deze wordt afgemeld.

      De beleidswaarde moet worden opgegeven in milliseconden.</translation>
<translation id="54795286564479339">Avatarafbeelding van gebruiker configureren.

      Met dit beleid kun je de avatarafbeelding configureren waarmee de gebruiker op het inlogscherm wordt aangeduid. Het beleid wordt ingesteld door de URL te specificeren waar <ph name="PRODUCT_OS_NAME"/> de avatarafbeelding kan downloaden en er wordt een cryptografische hash gebruikt om de integriteit van de download te verifiëren. De bestandsindeling van de afbeelding moet JPEG zijn en het bestand mag niet groter zijn dan 512 KB. De URL moet zonder authenticatie toegankelijk zijn.

      De avatarafbeelding wordt gedownload en opgeslagen in het cachegeheugen. De afbeelding wordt opnieuw gedownload wanneer de URL of hash wordt gewijzigd.

      Het beleid moet worden opgegeven als een tekenreeks waarin de URL en hash worden uitgedrukt in JSON-notatie, in overeenstemming met het volgende schema:
      {
        &quot;type&quot;: &quot;object&quot;,
        &quot;properties&quot;: {
          &quot;url&quot;: {
            &quot;description&quot;: &quot;De URL waar de avatarafbeelding kan worden gedownload.&quot;,
            &quot;type&quot;: &quot;string&quot;
          },
          &quot;hash&quot;: {
            &quot;description&quot;: &quot;De SHA-1-hash van de avatarafbeelding.&quot;,
            &quot;type&quot;: &quot;string&quot;
          }
        }
      }

      Als dit beleid is ingesteld, wordt de avatarafbeelding gedownload en gebruikt door <ph name="PRODUCT_OS_NAME"/>.

      Als je dit beleid instelt, kunnen gebruikers het niet wijzigen of negeren.

      Als het beleid niet wordt ingesteld, kan de gebruiker zelf een avatarafbeelding kiezen waarmee hij/zij wordt aangeduid op het inlogscherm.</translation>
<translation id="237494535617297575">Hiermee kun je een lijst met URL-patronen opgeven van sites waarop meldingen mogen worden weergegeven.

          Als dit beleid niet wordt ingesteld, wordt de algemene standaardwaarde gebruikt voor alle sites op basis van het beleid 'DefaultNotificationsSetting' (als dit is ingesteld) of anders op basis van de configuratie van de gebruiker.</translation>
<translation id="7258823566580374486">Afschermen van hosts voor externe toegang inschakelen</translation>
<translation id="5560039246134246593">Een parameter toevoegen aan het ophalen van de seed voor varianten in <ph name="PRODUCT_NAME"/>.

      Als dit is gespecificeerd, wordt een queryparameter met de naam 'restrict' toegevoegd aan de URL die wordt gebruikt om de seed voor varianten op te halen. De waarde van de parameter is de waarde die wordt opgegeven in dit beleid.

      Als dit niet is gespecificeerd, wordt de URL voor de seed voor varianten niet aangepast.</translation>
<translation id="944817693306670849">Grootte voor schijfcache instellen</translation>
<translation id="8544375438507658205">Standaard HTML-renderer voor <ph name="PRODUCT_FRAME_NAME"/></translation>
<translation id="2371309782685318247">Hiermee wordt de periode in milliseconden gespecificeerd waarna de apparaatbeheerservice wordt gevraagd informatie te verstrekken over het gebruikersbeleid.

      Als je dit beleid instelt, wordt de standaardwaarde van 3 uur overschreven. Geldige waarden voor dit beleid liggen tussen 1800000 (30 minuten) en 86400000 (1 dag). Alle waarden die niet binnen dit bereik vallen, worden afgerond tot de boven- of ondergrens.

      Als je dit beleid niet instelt, gebruikt <ph name="PRODUCT_NAME"/> de standaardwaarde van 3 uur.</translation>
<translation id="2571066091915960923">Schakelt de proxy voor het comprimeren van gegevens in of uit en voorkomt dat gebruikers deze instelling kunnen wijzigen.

      Als je deze instelling in- of uitschakelt, kunnen gebruikers deze instelling niet wijzigen of overschrijven.

      Als dit beleid niet wordt ingesteld, is de proxyfunctie voor het comprimeren van gegevens beschikbaar en kunnen gebruikers kiezen of ze deze willen gebruiken.</translation>
<translation id="7424751532654212117">Lijst van uitzonderingen op de lijst met uitgeschakelde plug-ins</translation>
<translation id="6233173491898450179">Downloaddirectory instellen</translation>
<translation id="78524144210416006">Energiebeheer op het inlogscherm in <ph name="PRODUCT_OS_NAME"/> configureren.

      Met dit beleid kun je configureren hoe <ph name="PRODUCT_OS_NAME"/> zich gedraagt wanneer er enige tijd geen gebruikersactiviteit is terwijl het inlogscherm wordt weergegeven. Het beleid beheerst meerdere instellingen. Voor de afzonderlijke semantiek en waardebereiken bekijk je de bijbehorende beleidsregels die energiebeheer in een sessie beheersen. De enige afwijkingen van deze beleidsregels zijn:
      * De acties die worden ondernomen voor inactief of het sluiten van de klep, kunnen de sessie niet beëindigen.
      * De standaardactie die wordt ondernomen voor inactief bij gebruik op netspanning, is uitschakelen.

      Het beleid moet worden gespecificeerd als tekenreeks die de afzonderlijke instellingen uitdrukt in JSON-indeling, in overeenstemming met het volgende schema:
      {
        &quot;type&quot;: &quot;object&quot;,
        &quot;properties&quot;: {
          &quot;AC&quot;: {
            &quot;description&quot;: &quot;Instellingen voor energiebeheer die alleen van toepassing zijn bij gebruik op netspanning&quot;,
            &quot;type&quot;: &quot;object&quot;,
            &quot;properties&quot;: {
              &quot;Delays&quot;: {
                &quot;type&quot;: &quot;object&quot;,
                &quot;properties&quot;: {
                  &quot;ScreenDim&quot;: {
                    &quot;description&quot;: &quot;De periode zonder gebruikersinvoer waarna het scherm wordt gedimd, in milliseconden&quot;,
                    &quot;type&quot;: &quot;integer&quot;,
                    &quot;minimum&quot;: 0
                  },
                  &quot;ScreenOff&quot;: {
                    &quot;description&quot;: &quot;De periode zonder gebruikersinvoer waarna het scherm wordt uitgeschakeld, in milliseconden&quot;,
                    &quot;type&quot;: &quot;integer&quot;,
                    &quot;minimum&quot;: 0
                  },
                  &quot;Idle&quot;: {
                    &quot;description&quot;: &quot;De periode zonder gebruikersinvoer waarna de actie voor inactief wordt ondernomen, in milliseconden&quot;,
                    &quot;type&quot;: &quot;integer&quot;,
                    &quot;minimum&quot;: 0
                  }
                }
              },
              &quot;IdleAction&quot;: {
                &quot;description&quot;: &quot;Actie die moet worden ondernomen wanneer de vertraging voor inactief wordt bereikt&quot;,
                &quot;enum&quot;: [ &quot;Suspend&quot;, &quot;Shutdown&quot;, &quot;DoNothing&quot; ]
              }
            }
          },
          &quot;Battery&quot;: {
            &quot;description&quot;: &quot;Instellingen voor energiebeheer die alleen van toepassing zijn bij gebruik op accuvermogen&quot;,
            &quot;type&quot;: &quot;object&quot;,
            &quot;properties&quot;: {
              &quot;Delays&quot;: {
                &quot;type&quot;: &quot;object&quot;,
                &quot;properties&quot;: {
                  &quot;ScreenDim&quot;: {
                    &quot;description&quot;: &quot;De periode zonder gebruikersinvoer waarna het scherm wordt gedimd, in milliseconden&quot;,
                    &quot;type&quot;: &quot;integer&quot;,
                    &quot;minimum&quot;: 0
                  },
                  &quot;ScreenOff&quot;: {
                    &quot;description&quot;: &quot;De periode zonder gebruikersinvoer waarna het scherm wordt uitgeschakeld, in milliseconden&quot;,
                    &quot;type&quot;: &quot;integer&quot;,
                    &quot;minimum&quot;: 0
                  },
                  &quot;Idle&quot;: {
                    &quot;description&quot;: &quot;De periode zonder gebruikersinvoer waarna de actie voor inactief wordt ondernomen, in milliseconden&quot;,
                    &quot;type&quot;: &quot;integer&quot;,
                    &quot;minimum&quot;: 0
                  }
                }
              },
              &quot;IdleAction&quot;: {
                &quot;description&quot;: &quot;Actie die moet worden ondernomen wanneer de vertraging voor inactief wordt bereikt&quot;,
                &quot;enum&quot;: [ &quot;Suspend&quot;, &quot;Shutdown&quot;, &quot;DoNothing&quot; ]
              }
            }
          },
          &quot;LidCloseAction&quot;: {
            &quot;description&quot;: &quot;Actie die moet worden ondernomen wanneer de klep wordt gesloten&quot;,
            &quot;enum&quot;: [ &quot;Suspend&quot;, &quot;Shutdown&quot;, &quot;DoNothing&quot; ]
          },
          &quot;UserActivityScreenDimDelayScale&quot;: {
            &quot;description&quot;: &quot;Percentage waarmee de vertraging voor het dimmen van het scherm wordt geschaald wanneer gebruikersactiviteit wordt waargenomen terwijl het scherm is gedimd of kort nadat het scherm is uitgeschakeld&quot;,
            &quot;type&quot;: &quot;integer&quot;,
            &quot;minimum&quot;: 100
          }
        }
      }

      Als een instelling niet wordt gespecificeerd, wordt een standaardwaarde gebruikt.

      Als het instellen van dit beleid ongedaan wordt gemaakt, worden de standaardwaarden gebruikt voor alle instellingen.</translation>
<translation id="8908294717014659003">Hiermee kun je instellen of websites toegang mogen krijgen tot media-opnameapparaten. Toegang tot media-opnameapparaten kan standaard worden toegestaan of de gebruiker kan elke keer om toestemming worden gevraagd wanneer een website toegang wil hebben tot media-opnameapparaten.

          Als dit beleid niet is ingesteld, wordt 'PromptOnAccess' gebruikt en kan de gebruiker dit wijzigen.</translation>
<translation id="2299220924812062390">Een lijst met ingeschakelde plug-ins specificeren</translation>
<translation id="328908658998820373">Modus voor volledig scherm toestaan.

      Dit beleid bepaalt de beschikbaarheid van de modus voor volledig scherm waarin de volledige gebruikersinterface van <ph name="PRODUCT_NAME"/> is verborgen en alleen webinhoud zichtbaar is.

      Als dit beleid is ingesteld op 'waar' of niet is geconfigureerd, hebben de gebruiker en apps en extensies met de juiste rechten toegang tot de modus voor volledig scherm.

      Als dit beleid is ingesteld op 'niet waar', hebben zowel gebruikers als apps en extensies geen toegang tot de modus voor volledig scherm.

      Op alle platforms behalve <ph name="PRODUCT_OS_NAME"/> is de kioskmodus niet beschikbaar wanneer de modus voor volledig scherm is uitgeschakeld.</translation>
<translation id="4325690621216251241">Een afmeldknop toevoegen aan de systeembalk</translation>
<translation id="924557436754151212">Opgeslagen wachtwoorden importeren uit standaardbrowser bij eerste uitvoering</translation>
<translation id="1465619815762735808">Klikken om te spelen</translation>
<translation id="7227967227357489766">Hiermee definieer je de lijst met gebruikers die toestemming hebben om in te loggen bij het apparaat. Vermeldingen hebben de vorm <ph name="USER_WHITELIST_ENTRY_FORMAT"/>, zoals <ph name="USER_WHITELIST_ENTRY_EXAMPLE"/>. Als je willekeurige gebruikers toegang wilt verlenen tot een domein, gebruik je vermeldingen in de vorm <ph name="USER_WHITELIST_ENTRY_WILDCARD"/>.

      Als dit beleid niet is geconfigureerd, gelden er geen beperkingen voor welke gebruikers mogen inloggen. Houd er rekening mee dat voor het maken van nieuwe gebruikers het beleid <ph name="DEVICEALLOWNEWUSERS_POLICY_NAME"/> nog steeds correct moet worden geconfigureerd.</translation>
<translation id="8135937294926049787">Hiermee wordt de tijdsduur zonder input van gebruikers gespecificeerd waarna het scherm wordt uitgeschakeld als er op netstroom wordt gewerkt.

          Als dit beleid is ingesteld op een grotere waarde dan nul, specificeert het de tijd die de gebruiker inactief moet blijven voordat het scherm wordt uitgeschakeld door <ph name="PRODUCT_OS_NAME"/>.

          Als dit beleid is ingesteld op nul, wordt het scherm niet uitgeschakeld door <ph name="PRODUCT_OS_NAME"/> wanneer de gebruiker inactief wordt.

          Als dit beleid niet is ingesteld, wordt een standaardtijdsduur gebruikt.

          De beleidswaarde moet worden opgegeven in milliseconden. Waarden moet lager zijn dan of gelijk zijn aan de inactieve vertraging.</translation>
<translation id="1897365952389968758">Alle sites toestaan JavaScript uit te voeren</translation>
<translation id="5244714491205147861">Energiebeheer op het inlogscherm</translation>
<translation id="922540222991413931">Installatiebronnen voor het configureren van extensies, apps en gebruikersscripts</translation>
<translation id="7323896582714668701">Extra opdrachtregelparameters voor <ph name="PRODUCT_NAME"/></translation>
<translation id="6931242315485576290">Synchronisatie van gegevens met Google uitschakelen</translation>
<translation id="7006788746334555276">Instellingen voor inhoud</translation>
<translation id="63659515616919367">Beheer het gedrag van gebruikers in een multiprofielsessie op <ph name="PRODUCT_OS_NAME"/>-apparaten.

      Als dit beleid is ingesteld op 'MultiProfileUserBehaviorUnrestricted', kan de gebruiker een primaire of secundaire gebruiker zijn in een multiprofielsessie.

      Als dit beleid is ingesteld op 'MultiProfileUserBehaviorMustBePrimary', kan de gebruiker alleen een primaire gebruiker zijn in een multiprofielsessie.

      Als dit beleid is ingesteld op 'MultiProfileUserBehaviorNotAllowed', kan de gebruiker niet deelnemen aan een multiprofielsessie.

      Als je deze instelling configureert, kunnen gebruikers deze niet wijzigen of overschrijven.

      Als de instelling wordt gewijzigd terwijl de gebruiker is ingelogd bij een multiprofielsessie, worden voor alle gebruikers in de sessie de instellingen gecontroleerd. De sessie wordt gesloten als een van de gebruikers geen toestemming meer heeft om deel te nemen aan de sessie.

      Als het beleid niet wordt geconfigureerd, wordt de standaardwaarde 'MultiProfileUserBehaviorUnrestricted' gebruikt.</translation>
<translation id="5142301680741828703">De volgende URL-patronen altijd verwerken in <ph name="PRODUCT_FRAME_NAME"/></translation>
<translation id="4625915093043961294">Witte lijst voor het installeren van extensies configureren</translation>
<translation id="187819629719252111">Hiermee wordt toegang tot lokale bestanden op de computer toegestaan doordat <ph name="PRODUCT_NAME"/> dialoogvensters voor het selecteren van bestanden kan weergeven.

      Als je deze instelling inschakelt, kunnen gebruikers zoals gewoonlijk dialoogvensters voor het selecteren van bestanden openen.

      Als je deze instelling uitschakelt, wordt er een bericht weergegeven wanneer de gebruiker een actie uitvoert waarvoor normaal gesproken een dialoogvenster voor het selecteren van bestanden wordt weergegeven (zoals bij het importeren van bladwijzers, het opslaan van links, enzovoort) Alle processen gaan verder alsof de gebruiker in een dialoogvenster voor het selecteren van bestanden op 'Annuleren' heeft geklikt.

      Als deze instelling niet wordt ingesteld, kunnen gebruikers zoals gewoonlijk dialoogvensters voor het selecteren van bestanden openen.</translation>
<translation id="4507081891926866240">Hiermee kun je de lijst aanpassen van URL-patronen die altijd door <ph name="PRODUCT_FRAME_NAME"/> moeten worden verwerkt.

          Als dit beleid niet wordt ingesteld, wordt de standaardrenderer gebruikt voor alle sites die door het beleid 'ChromeFrameRendererSettings' zijn opgegeven.

          Ga voor voorbeeldpatronen naar http://www.chromium.org/developers/how-tos/chrome-frame-getting-started.</translation>
<translation id="3101501961102569744">Kies hoe je proxyserverinstellingen wilt specificeren</translation>
<translation id="1803646570632580723">Lijst met vastgezette apps om weer te geven in het opstartprogramma</translation>
<translation id="1062011392452772310">Externe bevestiging van apparaat inschakelen</translation>
<translation id="7774768074957326919">Proxyinstellingen van het systeem gebruiken</translation>
<translation id="3891357445869647828">JavaScript inschakelen</translation>
<translation id="868187325500643455">Alle sites toestaan automatisch plug-ins uit te voeren</translation>
<translation id="7421483919690710988">Grootte van mediaschijfcache in bytes instellen</translation>
<translation id="5226033722357981948">Aangeven of de plug-inzoeker moet worden uitgeschakeld</translation>
<translation id="4890209226533226410">Het type vergrootglas instellen dat is ingeschakeld.

          Als dit beleid is ingesteld, bepaalt dit het type vergrootglas dat is ingeschakeld. Als je het beleid op 'Geen' instelt, wordt het vergrootglas uitgeschakeld.

          Als je dit beleid instelt, kunnen gebruikers dit niet wijzigen of negeren.

          Als je dit beleid niet instelt, wordt het vergrootglas initieel uitgeschakeld maar kan de gebruiker het op elk moment inschakelen.</translation>
<translation id="3428247105888806363">Netwerkvoorspelling inschakelen</translation>
<translation id="3460784402832014830">Specificeert de URL die een zoekmachine gebruikt om een nieuwe tabbladpagina weer te geven.

          Dit beleid is optioneel. Als het niet wordt ingesteld, wordt er geen nieuwe tabbladpagina weergegeven.

          Dit beleid wordt alleen gerespecteerd als het beleid 'DefaultSearchProviderEnabled' is ingeschakeld.</translation>
<translation id="6145799962557135888">Hiermee kun je een lijst URL-patronen instellen waarmee sites worden gespecificeerd die JavaScript mogen uitvoeren.

          Als dit beleid niet wordt ingesteld, wordt de algemene standaardwaarde gebruikt voor alle sites op basis van het beleid 'DefaultJavaScriptSetting' (als dit is ingesteld) of anders op basis van de configuratie van de gebruiker.</translation>
<translation id="2757054304033424106">Typen extensies/apps die mogen worden geïnstalleerd</translation>
<translation id="7053678646221257043">Indien ingeschakeld, wordt met dit beleid afgedwongen dat bladwijzers worden geïmporteerd uit de huidige standaardbrowser. Als het beleid is ingeschakeld, is dit ook van invloed op het dialoogvenster voor importeren.

      Als het beleid is uitgeschakeld, worden er geen bladwijzers geïmporteerd.

      Als dit beleid niet wordt ingesteld, kan de gebruiker worden gevraagd of deze wil importeren, of wordt er automatisch geïmporteerd.</translation>
<translation id="5757829681942414015">Hiermee wordt de directory geconfigureerd die <ph name="PRODUCT_NAME"/> gebruikt voor het opslaan van gebruikersgegevens.

      Als je dit beleid instelt, gebruikt <ph name="PRODUCT_NAME"/> deze directory, ongeacht of de gebruiker de markering voor '--user-data-dir' heeft ingesteld.

      Ga naar http://www.chromium.org/administrators/policy-list-3/user-data-directory-variables voor een lijst met variabelen die kunnen worden gebruikt.

      Als dit beleid niet wordt ingesteld, wordt het standaardprofielpad gebruikt en kan de gebruiker dit overschrijven met de opdrachtregelmarkering '--user-data-dir'.</translation>
<translation id="5067143124345820993">Aanmelden bij witte lijst van gebruikers</translation>
<translation id="2514328368635166290">Hiermee specificeer je de URL van het voorkeurspictogram voor de standaardzoekprovider.

          Dit beleid is optioneel. Als je het niet instelt, wordt er geen pictogram weergegeven voor de zoekprovider.

          Dit beleid wordt alleen gerespecteerd als het beleid 'DefaultSearchProviderEnabled' is ingeschakeld.</translation>
<translation id="7194407337890404814">Naam van standaardzoekprovider</translation>
<translation id="1843117931376765605">Vernieuwingsfrequentie voor gebruikersbeleid</translation>
<translation id="5535973522252703021">Witte lijst voor Kerberos-delegatieserver</translation>
<translation id="9187743794267626640">Koppelen van externe opslag uitschakelen</translation>
<translation id="6353901068939575220">Specificeert de parameters die worden gebruikt wanneer een URL wordt gezocht met POST. Het bestaat uit door komma's gescheiden naam/waarde-paren. Als een waarde een sjabloonparameter, zoals {searchTerms} in het bovenstaande voorbeeld, is, wordt de waarde vervangen door echte zoektermgegevens.

          Dit beleid is optioneel. Als het beleid niet is ingesteld, wordt de zoekopdracht verzonden met de GET-methode.

          Dit beleid wordt alleen gerespecteerd als het beleid 'DefaultSearchProviderEnabled' is ingeschakeld.</translation>
<translation id="5307432759655324440">Beschikbaarheid van incognitomodus</translation>
<translation id="4056910949759281379">SPDY-protocol uitschakelen</translation>
<translation id="3808945828600697669">Een lijst met uitgeschakelde plug-ins specificeren</translation>
<translation id="4525521128313814366">Hiermee kun je een lijst URL-patronen instellen waarmee sites worden gespecificeerd waarop geen afbeeldingen kunnen worden weergegeven.

          Als dit beleid niet is ingesteld, wordt de algemene standaardwaarde gebruikt voor alle sites op basis van het beleid 'DefaultImagesSetting' (als dit is ingesteld) of anders op basis van de configuratie van de gebruiker.</translation>
<translation id="8499172469244085141">Standaardinstellingen (gebruikers kunnen overschrijven)</translation>
<translation id="8693243869659262736">Ingebouwde DNS-client gebruiken</translation>
<translation id="3072847235228302527">De Servicevoorwaarden instellen voor een apparaat-lokaal account</translation>
<translation id="5523812257194833591">Een openbare sessie om automatisch in te loggen na een vertraging.

      Als dit beleid is ingesteld, wordt de opgegeven sessie automatisch ingelogd na een tijdsperiode zonder gebruikersinteractie op het inlogscherm is verstreken. De openbare sessie moet al zijn geconfigureerd (zie |DeviceLocalAccounts|).

      Als dit beleid niet is ingesteld, wordt er niet automatisch ingelogd.</translation>
<translation id="5983708779415553259">Standaardgedrag voor sites die zich niet in een inhoudspakket bevinden</translation>
<translation id="3866530186104388232">Als dit beleid is ingesteld op 'true' of niet is geconfigureerd, worden in het aanmeldscherm van <ph name="PRODUCT_OS_NAME"/> bestaande gebruikers weergegeven die kunnen worden geselecteerd. Als dit beleid is ingesteld op 'false', krijgt de gebruiker bij aanmelding op <ph name="PRODUCT_OS_NAME"/> de vraag de combinatie van gebruikersnaam/wachtwoord in te voeren.</translation>
<translation id="2098658257603918882">Rapportage van gebruiks- en crashgegevens inschakelen</translation>
<translation id="2324547593752594014">Inloggen bij Chrome toestaan</translation>
<translation id="172374442286684480">Alle sites toestaan lokale gegevens in te stellen</translation>
<translation id="1151353063931113432">Afbeeldingen toestaan op deze sites</translation>
<translation id="1297182715641689552">Een PAC-script voor de proxy gebruiken</translation>
<translation id="2976002782221275500">Hiermee wordt de tijdsduur zonder input van gebruikers gespecificeerd waarna het scherm wordt gedimd wanneer er op de accu wordt gewerkt.

          Als dit beleid is ingesteld op een grotere waarde dan nul, specificeert het de tijd die de gebruiker inactief moet blijven voordat het scherm wordt gedimd door <ph name="PRODUCT_OS_NAME"/>.

          Als dit beleid is ingesteld op nul, wordt het scherm niet gedimd door <ph name="PRODUCT_OS_NAME"/> wanneer de gebruiker inactief wordt.

          Als dit beleid niet is ingesteld, wordt een standaardtijdsduur gebruikt.

          De beleidswaarde moet worden opgegeven in milliseconden. Waarden moeten lager zijn dan of gelijk zijn aan de vertraging van scherm uitschakelen (indien ingesteld) en de inactieve vertraging.</translation>
<translation id="8631434304112909927">tot versie <ph name="UNTIL_VERSION"/></translation>
<translation id="7469554574977894907">Zoeksuggesties inschakelen</translation>
<translation id="4906194810004762807">Vernieuwingsfrequentie voor apparaatbeleid</translation>
<translation id="8922668182412426494">Servers waarnaar <ph name="PRODUCT_NAME"/> mag delegeren.

          Scheid meerdere servernamen van elkaar met komma's. Jokertekens (*) zijn toegestaan.

          Als je dit beleid niet instelt, delegeert Chrome geen gebruikersreferenties, zelfs niet als een server wordt gedetecteerd als intranet.</translation>
<translation id="1398889361882383850">Hiermee kun je instellen of websites automatisch plug-ins mogen uitvoeren. Het automatisch uitvoeren van plug-ins kan ofwel worden toegestaan voor alle websites, ofwel worden geweigerd voor alle websites.

          Met click-to-play kunnen plug-ins worden uitgevoerd, maar de gebruiker moet erop klikken om ze uit te voeren.

          Als dit beleid niet wordt ingesteld, wordt 'AllowPlugins' gebruikt en kan de gebruiker dit wijzigen.</translation>
<translation id="7974114691960514888">Dit beleid wordt niet meer ondersteund.
          Maakt het gebruik van STUN en relayservers mogelijk bij het verbinding maken met een externe client.

          Als deze instelling is ingeschakeld, kan dit apparaat externe hosts zien en hier verbinding mee maken, zelfs als ze worden gescheiden door een firewall.

          Als deze instelling is uitgeschakeld en uitgaande UDP-verbindingen worden gefilterd door de firewall, kan dit apparaat alleen verbinding maken met hosts binnen het lokale netwerk.</translation>
<translation id="7694807474048279351">Plannen dat het apparaat automatisch opnieuw opstart nadat een update van <ph name="PRODUCT_OS_NAME"/> is uitgevoerd.

      Wanneer dit beleid is ingesteld op 'waar', start het apparaat automatisch opnieuw op wanneer een update van <ph name="PRODUCT_OS_NAME"/> is uitgevoerd en opnieuw opstarten vereist is om het updateproces te voltooien. Het opnieuw opstarten is onmiddellijk gepland maar kan op het apparaat tot 24 uur worden uitgesteld als een gebruiker het apparaat op dat moment gebruikt.

      Wanneer dit beleid is ingesteld op 'onwaar', start het apparaat niet automatisch opnieuw op nadat een update van <ph name="PRODUCT_OS_NAME"/> is uitgevoerd. Het updateproces wordt voltooid wanneer de gebruiker het apparaat opnieuw opstart.

      Als je dit beleid instelt, kunnen gebruikers dit niet wijzigen of negeren.

      Opmerking: momenteel is automatisch opnieuw opstarten alleen ingeschakeld als het inlogscherm wordt weergegeven of een kiosk-appsessie wordt verwerkt. Dit zal in de toekomst veranderen en het beleid zal altijd worden toegepast, ongeacht of er een sessie van een bepaald type in verwerking is.</translation>
<translation id="5511702823008968136">Bladwijzerbalk inschakelen</translation>
<translation id="5105313908130842249">Vertraging van schermvergrendeling wanneer op de accu wordt gewerkt</translation>
<translation id="7882585827992171421">Dit beleid is alleen actief in de commerciële modus.

      Hiermee bepaal je de ID van de extensie die moet worden gebruikt als schermbeveiliging voor het inlogvenster. De extensie moet onderdeel zijn van het AppPack dat is geconfigureerd voor dit domein via het beleid DeviceAppPack.</translation>
<translation id="7736666549200541892">Extensie voor domeingebonden TLS-certificaten inschakelen</translation>
<translation id="1796466452925192872">Hiermee kun je opgeven welke URL's extensies, apps en thema's mogen installeren.

          Vanaf Chrome 21 is het moeilijker om extensies, apps en gebruikersscripts te installeren van buiten de Chrome Web Store. Gebruikers konden eerder op een link naar een *.crx-bestand klikken. Na enkele waarschuwingen bood Chrome vervolgens aan het bestand te installeren. Vanaf Chrome 21 moeten dergelijke bestanden worden gedownload en naar de pagina met Chrome-instellingen worden gesleept. Deze instelling maakt het mogelijk de oude, gemakkelijkere installatieprocedure te gebruiken voor specifieke URL's.

          Elk item in deze lijst is overeenkomstpatroon op basis van extensies (zie http://code.google.com/chrome/extensions/match_patterns.html). Gebruikers kunnen items gemakkelijk installeren vanaf elke URL die overeenkomt met een item in deze lijst. De locatie van het *.crx-bestand en de pagina waar de download wordt gestart (dat wil zeggen, de verwijzing), moeten beide zijn toegestaan op basis van deze patronen.

          ExtensionInstallBlacklist krijgt voorrang op dit beleid. Dat wil zeggen, een extensie op de zwarte lijst wordt niet geïnstalleerd, zelfs niet als de installatie wordt gestart vanaf een site in deze lijst.</translation>
<translation id="2113068765175018713">Uptime van apparaat beperken door automatisch opnieuw op te starten</translation>
<translation id="7848840259379156480">Hiermee kun je de standaard HTML-renderer configureren wanneer <ph name="PRODUCT_FRAME_NAME"/> is geïnstalleerd.
          De standaardinstelling is om de hostbrowser de rendering te laten regelen, maar
          je kunt dit aanpassen en <ph name="PRODUCT_FRAME_NAME"/> HTML-pagina's standaard laten renderen.</translation>
<translation id="186719019195685253">Actie die moet worden ondernomen wanneer de vertraging voor inactief wordt bereikt bij gebruik op netspanning</translation>
<translation id="7890264460280019664">De lijst met netwerkinterfaces met hun typen en hardwareadressen rapporteren aan de server.

      Als het beleid niet is ingesteld of is ingesteld op 'onwaar', wordt de interfacelijst niet gerapporteerd.</translation>
<translation id="4121350739760194865">Voorkomen dat app-promoties worden weergegeven op de pagina 'Nieuw tabblad'</translation>
<translation id="2127599828444728326">Meldingen op deze sites toestaan</translation>
<translation id="3973371701361892765">Archief nooit automatisch verbergen</translation>
<translation id="7635471475589566552">Hiermee wordt de landinstelling voor de applicatie geconfigureerd in <ph name="PRODUCT_NAME"/> en wordt voorkomen dat gebruikers de landinstelling kunnen wijzigen.

      Als je deze instelling inschakelt, gebruikt <ph name="PRODUCT_NAME"/> de gespecificeerde landinstelling. Als de geconfigureerde landinstelling niet wordt ondersteund, wordt 'en-US' gebruikt.

      Als deze instelling is uitgeschakeld of niet is ingesteld, gebruikt <ph name="PRODUCT_NAME"/> de door de gebruiker gespecificeerde landinstelling (indien geconfigureerd), de landinstelling voor het systeem of 'en-US'.</translation>
<translation id="2948087343485265211">Hiermee wordt gespecificeerd of audioactiviteit invloed heeft op stroombeheer.

          Als dit beleid is ingesteld op 'waar' of niet is ingesteld, wordt de gebruiker niet beschouwd als inactief terwijl audio wordt afgespeeld. Hierdoor wordt voorkomen dat de inactieve time-out wordt bereikt en dat de inactieve actie wordt ondernomen. Dimmen van het scherm, scherm uitschakelen en schermvergrendeling worden echter uitgevoerd na de geconfigureerde time-outs, ongeacht de audioactiviteit.

          Als dit beleid is ingesteld op 'onwaar', wordt met audioactiviteit niet voorkomen dat de gebruiker als inactief wordt beschouwd.</translation>
<translation id="7842869978353666042">Opties voor Google Drive configureren</translation>
<translation id="718956142899066210">Verbindingstypen die zijn toegestaan voor updates</translation>
<translation id="1734716591049455502">Opties voor externe toegang configureren</translation>
<translation id="7336878834592315572">Cookies bewaren voor de duur van de sessie</translation>
<translation id="7715711044277116530">Percentage waarmee de dimvertraging van het scherm in de presentatiemodus wordt geschaald</translation>
<translation id="8777120694819070607">Hiermee kun je aangeven dat <ph name="PRODUCT_NAME"/> verouderde plug-ins mag uitvoeren.

      Als je deze instelling inschakelt, worden verouderde plug-ins op dezelfde manier gebruikt als normale plug-ins.

      Als je deze instelling uitschakelt, worden verouderde plug-ins niet gebruikt en wordt gebruikers niet gevraagd of ze deze willen uitvoeren.

      Als deze instelling niet is ingesteld, wordt gebruikers gevraagd of ze verouderde plug-ins willen uitvoeren.</translation>
<translation id="2629448496147630947">Opties voor externe toegang configureren in <ph name="PRODUCT_NAME"/>.

      Deze functies worden genegeerd, tenzij de webapp Remote Access is geïnstalleerd.</translation>
<translation id="1310699457130669094">Je kunt hier een URL naar een PAC-bestand voor de proxy opgeven.

          Dit beleid wordt alleen van kracht als je handmatige proxyinstellingen hebt geselecteerd bij 'Kies hoe je proxyserverinstellingen wilt opgeven'.

          Stel dit beleid niet in als een je andere modus hebt geselecteerd voor het instellen van je proxybeleid.

          Ga voor gedetailleerde voorbeelden naar:
          <ph name="PROXY_HELP_URL"/></translation>
<translation id="1509692106376861764">Dit beleid wordt niet meer gebruikt sinds <ph name="PRODUCT_NAME"/> versie 29.</translation>
<translation id="5464816904705580310">Hiermee configureer je instellingen voor beheerde gebruikers.</translation>
<translation id="3219421230122020860">Incognitomodus beschikbaar</translation>
<translation id="7690740696284155549">Hiermee wordt de directory geconfigureerd die <ph name="PRODUCT_NAME"/> gebruikt voor het downloaden van bestanden.

      Als je dit beleid instelt, gebruikt <ph name="PRODUCT_NAME"/> deze directory, ongeacht of de gebruiker een directory heeft gespecificeerd of heeft aangegeven telkens te willen worden gevraagd wat de downloadlocatie moet zijn.

      Ga naar http://www.chromium.org/administrators/policy-list-3/user-data-directory-variables voor een lijst met variabelen die kunnen worden gebruikt.

      Als dit beleid niet wordt ingesteld, wordt de standaarddirectory voor het downloaden van bestanden gebruikt en kan de gebruiker deze wijzigen.</translation>
<translation id="7381326101471547614">Hiermee wordt het gebruik van het SPDY-protocol in <ph name="PRODUCT_NAME"/> uitgeschakeld. Als dit beleid is ingeschakeld, is het SPDY-protocol niet beschikbaar in <ph name="PRODUCT_NAME"/>. Als je dit beleid instelt op uitgeschakeld, kan het SPDY-protocol worden gebruikt. Als dit beleid niet wordt ingesteld, is het SPDY-protocol beschikbaar.</translation>
<translation id="2208976000652006649">Parameters voor zoek-URL die POST gebruikt</translation>
<translation id="1583248206450240930"><ph name="PRODUCT_FRAME_NAME"/> standaard gebruiken</translation>
<translation id="1047128214168693844">Niet toestaan dat sites de fysieke locatie van gebruikers bijhouden</translation>
<translation id="4101778963403261403">Hiermee wordt het type standaard startpagina in <ph name="PRODUCT_NAME"/> geconfigureerd en wordt voorkomen dat gebruikers deze instelling kunnen wijzigen. De startpagina kan worden ingesteld op een URL die je specificeert, of op de pagina 'Nieuw tabblad'.

          Als je deze instelling inschakelt, wordt altijd de pagina 'Nieuw tabblad' voor de startpagina gebruikt, en wordt de URL voor de startpagina genegeerd.

          Als je deze instelling uitschakelt, wordt de pagina 'Nieuw tabblad' nooit weergegeven als de startpagina, tenzij de URL is ingesteld op 'chrome://newtab'.

          Als je deze instelling in- of uitschakelt, kunnen gebruikers het type startpagina niet aanpassen in <ph name="PRODUCT_NAME"/>.

          Als dit beleid niet wordt ingesteld, kan de gebruiker ervoor kiezen de pagina 'Nieuw tabblad' als startpagina te gebruiken of een eigen pagina als startpagina te gebruiken.</translation>
<translation id="8970205333161758602">De prompt <ph name="PRODUCT_FRAME_NAME"/> negeren</translation>
<translation id="3273221114520206906">Standaardinstelling voor JavaScript</translation>
<translation id="4025586928523884733">Hiermee worden indirecte cookies geblokkeerd.

      Als je deze instelling inschakelt, kunnen er geen cookies worden ingesteld door webpagina-elementen die niet afkomstig zijn van het domein dat in de adresbalk van de browser staat.

      Als je deze instelling uitschakelt, kunnen cookies worden ingesteld door webpagina-elementen die niet afkomstig zijn van het domein dat in de adresbalk van de browser staat, en wordt voorkomen dat gebruikers deze instelling kunnen wijzigen.

      Als dit beleid niet wordt ingesteld, worden indirecte cookies ingeschakeld maar kan dit door de gebruiker worden gewijzigd.</translation>
<translation id="6810445994095397827">JavaScript blokkeren op deze sites</translation>
<translation id="6672934768721876104">Dit beleid is verouderd. Gebruik in plaats hiervan ProxyMode.

          Hiermee kun je de proxyserver specificeren die wordt gebruikt door <ph name="PRODUCT_NAME"/> en wordt voorkomen dat gebruikers proxyinstellingen kunnen wijzigen.

          Als je ervoor kiest nooit een proxyserver te gebruiken en altijd rechtstreeks verbinding te maken, worden alle andere opties genegeerd.

          Als je ervoor kiest de proxyinstellingen van het systeem te gebruiken of de proxyserver automatisch te detecteren, worden alle andere opties genegeerd.

          Als je handmatige proxyinstellingen kiest, kun je verdere opties specificeren via 'Adres of URL van proxyserver', 'URL naar een PAC-bestand voor de proxy' en 'Door komma's gescheiden lijst van regels voor proxyomzeiling'.

          Ga voor gedetailleerde voorbeelden naar:
          <ph name="PROXY_HELP_URL"/>

          Als je deze instelling inschakelt, negeert <ph name="PRODUCT_NAME"/> alle aan proxy's gerelateerde opties die worden gespecificeerd in de opdrachtregel.

          Als je dit beleid niet instelt, kunnen gebruikers zelf proxyinstellingen selecteren.</translation>
<translation id="3780152581321609624">Niet-standaardpoort in Kerberos-SPN opnemen</translation>
<translation id="1749815929501097806">De Servicevoorwaarden instellen die de gebruiker moet accepteren voordat een apparaat-lokale accountsessie kan worden gestart.

      Als dit beleid is ingesteld, worden de Servicevoorwaarden gedownload door <ph name="PRODUCT_OS_NAME"/> en worden deze aan de gebruiker getoond wanneer een apparaat-lokale accountsessie wordt gestart. De gebruiker mag alleen deelnemen aan de sessie nadat hij/zij de Servicevoorwaarden accepteert.

      Als dit beleid niet is ingesteld, worden er geen Servicevoorwaarden weergegeven.

      Het beleid moet op een URL worden ingesteld vanaf waar de Servicevoorwaarden door <ph name="PRODUCT_OS_NAME"/> kunnen worden gedownload. De Servicevoorwaarden moeten platte tekst zijn die als tekst met MIME-type/plat wordt weergegeven. Er is geen opmaak toegestaan.</translation>
<translation id="2623014935069176671">Wachten op initiële gebruikersactiviteit</translation>
<translation id="2660846099862559570">Nooit een proxy gebruiken</translation>
<translation id="1435659902881071157">Netwerkconfiguratie op apparaatniveau</translation>
<translation id="2131902621292742709">Vertraging van dimmen van scherm wanneer op de accu wordt gewerkt</translation>
<translation id="5781806558783210276">Hiermee wordt de tijdsduur zonder input van gebruikers gespecificeerd waarna de inactieve actie wordt ondernomen wanneer op de accu wordt gewerkt.

          Als dit beleid is ingesteld, specificeert het de tijd die de gebruiker inactief moet blijven voordat de inactieve actie wordt ondernomen door <ph name="PRODUCT_OS_NAME"/>, die afzonderlijk kan worden geconfigureerd.

          Als dit beleid niet is ingesteld, wordt een standaardtijdsduur gebruikt.

          De beleidswaarde moet worden opgegeven in milliseconden.</translation>
<translation id="5512418063782665071">URL van startpagina</translation>
<translation id="2948381198510798695"><ph name="PRODUCT_NAME"/> omzeilt elke proxy voor de lijst met hosts die hier wordt gespecificeerd.

          Dit beleid wordt alleen van kracht als je handmatig proxyinstellingen hebt geselecteerd bij 'Kies hoe je proxyserverinstellingen wilt specificeren'.

          Stel dit beleid niet in als je een andere modus voor het instellen van je proxybeleid hebt geselecteerd.

          Ga voor meer gedetailleerde voorbeelden naar:
          <ph name="PROXY_HELP_URL"/></translation>
<translation id="6658245400435704251">Bepaalt het maximaal aantal seconden dat een apparaat willekeurig de download van een update mag uitstellen vanaf het moment dat de update voor het eerst naar de server werd gepusht. Het apparaat kan een deel van deze tijd wachten in termen van kloktijd en het resterende deel in termen van het aantal updatecontroles. De maximale spreiding is in elk geval begrensd door een constante periode zodat een apparaat nooit vastloopt tijdens het wachten tot een update kan worden gedownload.</translation>
<translation id="523505283826916779">Toegankelijkheidsinstellingen</translation>
<translation id="1948757837129151165">Beleid voor HTTP-authenticatie</translation>
<translation id="5946082169633555022">Bètakanaal</translation>
<translation id="7187256234726597551">Als je 'waar' heeft ingesteld, wordt toestemming op afstand toegestaan voor het apparaat en wordt er automatisch een certificaat gegenereerd en naar de Device Management Server geüpload.

          Als je 'onwaar' of niets heeft ingesteld, wordt er geen certificaat gegenereerd en zullen oproepen aan de uitbreidings-API enterprise.platformKeysPrivate mislukken.</translation>
<translation id="5242696907817524533">Configureert een lijst met beheerde bladwijzers.

      Het beleid is een lijst met bladwijzers en elke bladwijzer is een woordenboek met de bladwijzer 'name' en het doel 'url.

      Deze bladwijzers worden in een map 'Beheerde bladwijzers' in de mobiele bladwijzers geplaatst. Deze bladwijzers kunnen niet worden aangepast door de gebruiker.

      Als dit beleid is ingesteld, is de map 'Beheerde bladwijzers' de standaardmap die wordt geopend wanneer de bladwijzerweergave wordt geopend in Chrome.

      Beheerde bladwijzers worden niet gesynchroniseerd met het gebruikersaccount.</translation>
<translation id="8303314579975657113">Hiermee wordt gespecificeerd welke GSSAPI-bibliotheek moet worden gebruikt voor HTTP-authenticatie. Je kunt een bibliotheeknaam instellen of een volledig pad.

          Als er geen instelling wordt opgegeven, gebruikt <ph name="PRODUCT_NAME"/> een standaard bibliotheeknaam.</translation>
<translation id="8549772397068118889">Waarschuwen als sites worden bezocht die zich niet in de inhoudspakketten bevinden</translation>
<translation id="7749402620209366169">Hiermee schakel je authenticatie in twee stappen in plaats van een door de gebruiker gedefinieerde pincode in voor hosts voor externe toegang.

          Als deze instelling is ingeschakeld, moeten gebruikers een geldige code in twee stappen opgeven wanneer ze toegang willen krijgen tot een host.

          Als deze instelling is uitgeschakeld of niet is ingesteld, wordt authenticatie in twee stappen niet ingeschakeld en wordt het standaardgedrag van een door de gebruiker gedefinieerde pincode gebruikt.</translation>
<translation id="7329842439428490522">Hiermee wordt de tijdsduur zonder input van gebruikers gespecificeerd waarna het scherm wordt uitgeschakeld als er op de accu wordt gewerkt.

          Als dit beleid is ingesteld op een grotere waarde dan nul, specificeert het de tijd die de gebruiker inactief moet blijven voordat het scherm wordt uitgeschakeld door <ph name="PRODUCT_OS_NAME"/>.

          Als dit beleid is ingesteld op nul, wordt het scherm niet uitgeschakeld door <ph name="PRODUCT_OS_NAME"/> wanneer de gebruiker inactief wordt.

          Als dit beleid niet is ingesteld, wordt een standaardtijdsduur gebruikt.

          De beleidswaarde moet worden opgegeven in milliseconden. Waarden moeten lager zijn dan of gelijk zijn aan de inactieve vertraging.</translation>
<translation id="384743459174066962">Hiermee kun je een lijst met URL-patronen instellen waarmee sites worden gespecificeerd waarop geen pop-ups mogen worden geopend.

          Als dit beleid niet wordt ingesteld, wordt de algemene standaardwaarde gebruikt voor alle sites op basis van het beleid 'DefaultPopupsSetting' (als dit is ingesteld) of anders op basis van de configuratie van de gebruiker.</translation>
<translation id="5645779841392247734">Cookies toestaan op deze sites</translation>
<translation id="4043912146394966243"> De verbindingstypen die mogen worden gebruikt voor updates voor het besturingssysteem. Updates voor het besturingssysteem kunnen de verbinding zwaar belasten door hun grootte en kunnen extra kosten tot gevolg hebben. Updates voor het besturingssysteem zijn daarom standaard uitgeschakeld voor dure verbindingstypen. Dit omvat momenteel de verbindingstypen WiMax, Bluetooth en Mobiel.

      De herkende verbindingstypen zijn 'ethernet', 'wifi', 'wimax', 'bluetooth' en 'mobiel'.</translation>
<translation id="6652197835259177259">Instellingen voor lokaal beheerde gebruikers</translation>
<translation id="3243309373265599239">Hiermee wordt de tijdsduur zonder input van gebruikers gespecificeerd waarna het scherm wordt gedimd wanneer er op netstroom wordt gewerkt.

           Als dit beleid is ingesteld op een grotere waarde dan nul, specificeert het de tijd die de gebruiker inactief moet blijven voordat het scherm wordt gedimd door <ph name="PRODUCT_OS_NAME"/>.

          Als dit beleid is ingesteld op nul, wordt het scherm niet gedimd door <ph name="PRODUCT_OS_NAME"/> wanneer de gebruiker inactief wordt.

          Als dit beleid niet is ingesteld, wordt een standaardtijdsduur gebruikt.

          De beleidswaarde moet worden opgegeven in milliseconden. Waarden moeten lager zijn dan of gelijk zijn aan de vertraging van scherm uitschakelen (indien ingesteld) en de inactieve vertraging.</translation>
<translation id="3859780406608282662">Voeg een parameter toe aan het ophalen van de varianten-seed in <ph name="PRODUCT_OS_NAME"/>.

      Indien dit wordt aangegeven, wordt aan de URL waarmee de varianten-seed wordt opgehaald een zoekopdrachtparameter toegevoegd met de naam 'restrict'. De waarde van de parameter is dezelfde waarde die in dit beleid wordt opgegeven.

      Indien deze niet is opgegeven, wordt de URL van de varianten-seed niet gewijzigd.</translation>
<translation id="7049373494483449255">Hiermee kan <ph name="PRODUCT_NAME"/> documenten verzenden naar <ph name="CLOUD_PRINT_NAME"/> voor afdrukken. OPMERKING: dit is alleen van invloed op ondersteuning voor <ph name="CLOUD_PRINT_NAME"/> in <ph name="PRODUCT_NAME"/>. Hiermee wordt niet voorkomen dat gebruikers afdruktaken verzenden via websites.

      Als deze instelling is ingeschakeld of niet is geconfigureerd, kunnen gebruikers afdrukken naar <ph name="CLOUD_PRINT_NAME"/> via het dialoogvenster voor afdrukken van <ph name="PRODUCT_NAME"/>.

      Als deze instelling is uitgeschakeld, kunnen gebruikers niet afdrukken naar <ph name="CLOUD_PRINT_NAME"/> via het dialoogvenster voor afdrukken van <ph name="PRODUCT_NAME"/></translation>
<translation id="4088589230932595924">Incognitomodus afgedwongen</translation>
<translation id="5862253018042179045">De standaardstatus van de toegankelijkheidsfunctie voor gesproken feedback instellen op het inlogscherm.

          Als dit beleid is ingesteld op 'waar', wordt gesproken feedback ingeschakeld wanneer het inlogscherm wordt weergegeven.

          Als dit beleid is ingesteld op 'onwaar', wordt gesproken feedback uitgeschakeld wanneer het inlogscherm wordt weergegeven.

          Als je dit beleid instelt, kunnen gebruikers dit tijdelijk negeren door gesproken feedback in of uit te schakelen. De keuze van de gebruiker is echter niet permanent en de standaardinstelling wordt hersteld als het inlogscherm opnieuw wordt weergegeven of de gebruiker gedurende een minuut niet actief is op het inlogscherm.

          Als je het beleid niet instelt, wordt gesproken feedback uitgeschakeld wanneer het inlogscherm voor het eerst wordt weergegeven. Gebruikers kunnen gesproken feedback op elk moment in- of uitschakelen en de status op het inlogscherm is permanent tussen gebruikers.</translation>
<translation id="8197918588508433925">Dit beleid geeft aan welke extensies de Enterprise Platform Keys-API chrome.enterprise.platformKeysPrivate.challengeUserKey() mogen gebruiken voor externe bevestiging. Je moet extensies aan deze lijst toevoegen om de API te kunnen gebruiken.

          Als een extensie niet in de lijst voorkomt, of als de lijst niet is ingesteld, mislukt het aanroepen van de API en wordt een foutcode weergegeven.</translation>
<translation id="7649638372654023172">Hiermee configureer je de standaard-URL voor de startpagina in <ph name="PRODUCT_NAME"/> en voorkom je dat gebruikers deze wijzigen.

          De startpagina is de pagina die wordt geopend met de knop 'Startpagina'. De pagina's die worden geopend bij het starten van Chrome, worden beheerd door het beleid RestoreOnStartup.

           Het type startpagina kan worden ingesteld op een URL die je hier opgeeft of op de pagina 'Nieuw tabblad'. Als je de pagina 'Nieuw tabblad' selecteert, wordt dit beleid niet van kracht.

          Als je deze instelling inschakelt, kunnen gebruikers de URL voor hun startpagina in <ph name="PRODUCT_NAME"/>, niet wijzigen, maar kunnen ze er nog steeds voor kiezen de pagina 'Nieuw tabblad' te gebruiken als startpagina.

          Als je dit beleid niet instelt, kan de gebruiker de gewenste startpagina zelf kiezen als HomepageIsNewTabPage ook niet is ingesteld.</translation>
<translation id="4858735034935305895">Modus voor volledig scherm toestaan</translation>
</translationbundle>