<?xml version="1.0" ?>
<!DOCTYPE translationbundle>
<translationbundle lang="da">
<translation id="101438888985615157">Roter skærmen 180 grader</translation>
<translation id="1016912092715201525">Konfigurerer tjek af standardbrowser i <ph name="PRODUCT_NAME" /> og forhindrer brugerne i at ændre dem.

      Hvis du aktiverer denne indstilling, tjekker <ph name="PRODUCT_NAME" /> altid ved opstart, om den er standardbrowser, og registrerer automatisk sig selv, hvis det er muligt.

      Hvis denne indstilling er deaktiveret, tjekker <ph name="PRODUCT_NAME" /> aldrig, om den er standardbrowser, og deaktiverer brugerstyring for konfiguration af denne indstilling.

      Hvis denne indstilling ikke er angivet, giver <ph name="PRODUCT_NAME" /> brugeren mulighed for at vælge, om den skal være standardbrowser, og om der skal vises notifikationer til brugeren, når den ikke er.

      Bemærkning til administratorer af <ph name="MS_WIN_NAME" />: Aktivering af denne indstilling fungerer kun for computere med Windows 7. Ved Windows-versioner fra og med Windows 8 skal du implementere en fil med "standardprogramtilknytninger", der gør <ph name="PRODUCT_NAME" /> til handler af protokollerne <ph name="HHTPS_PROTOCOL" /> og <ph name="HTTP_PROTOCOL" /> (samt eventuelt <ph name="FTP_PROTOCOL" />-protokollen og filformater som <ph name="HTML_EXTENSION" />, <ph name="HTM_EXTENSION" />, <ph name="PDF_EXTENSION" />, <ph name="SVG_EXTENSION" />, <ph name="WEBP_EXTENSION" /> osv.). Gå til <ph name="SUPPORT_URL" /> for at få flere oplysninger.</translation>
<translation id="1017967144265860778">Strømstyring på loginskærmen</translation>
<translation id="1019101089073227242">Angiv brugerdatamappe</translation>
<translation id="1022361784792428773">Udvidelses-id'er, som brugeren skal forhindres i at installere (eller * for alle)</translation>
<translation id="102492767056134033">Angiv standardtilstanden for skærmtastaturet på loginskærmen</translation>
<translation id="1027000705181149370">Angiver, om godkendelsescookies, der angives af en SAML-IdP ved login, skal overføres til brugerens profil.

      Når en bruger godkendes via en SAML-IdP ved login, skrives cookies, der er angivet af IdP'en, først i en midlertidig profil. Disse cookies kan overføres til brugerens profil for at overføre godkendelsestilstanden.

      Når denne politik er angivet som sand, overføres cookies, der er angivet af IdP'en, til brugerens profil, hver gang vedkommende godkender ved hjælp af SAML-IdP'en ved login.

      Når denne politik er angivet som falsk eller ikke er indstillet, overføres cookies, der er angivet af IdP'en, kun til brugerens profil, første gang vedkommende logger ind på en enhed.

      Denne politik berører kun brugere, hvis domæne svarer til enhedens registreringsdomæne. For alle andre brugere overføres cookies, der er angivet af IdP'en, kun til brugerens profil, første gang vedkommende logger ind på enheden.</translation>
<translation id="1029052664284722254">Tving enheden til at genstarte, når brugeren logger ud</translation>
<translation id="1030120600562044329">Aktiverer anonym rapportering af forbrug og nedbrudsrelaterede data angående <ph name="PRODUCT_NAME" /> til Google og forhindrer brugerne i at ændre denne indstilling.

      Hvis denne indstilling er aktiveret, sendes der anonyme rapporter om forbrug og nedbrudsrelaterede data til Google.  Hvis indstillingen er deaktiveret, sendes der ikke oplysninger
      til Google.  Brugerne kan i ingen af tilfældene ændre eller tilsidesætte indstillingen.
      Hvis denne politik ikke er angivet, bliver indstillingen den, som brugeren valgte
      i forbindelse med installationen eller første kørsel.

      Denne politik er kun tilgængelig for Windows-forekomster, der er knyttet til et <ph name="MS_AD_NAME" />-domæne, eller Windows 10 Pro- eller Enterprise-forekomster, der er tilmeldt administration af enheder.
      (se DeviceMetricsReportingEnabled, hvis du bruger Chrome OS).</translation>
<translation id="1035385378988781231">Denne politik styrer, om fildelingsfunktionen via netværk for <ph name="PRODUCT_NAME" /> anvender NTLM til godkendelse.

      Når denne politik er angivet som Sand, anvendes NTLM til godkendelse af SMB-deling, hvis det er nødvendigt.
      Når denne politik er angivet som Falsk, deaktiveres NTLM-godkendelse af SMB-deling.

      Hvis politikken ikke er angivet, er fildelingsfunktionen via netværk som standard deaktiveret for brugere, der administreres af en virksomhed, og aktiveret for brugere, der ikke administreres.</translation>
<translation id="1040446814317236570">Aktivér PAC til fjernelse af webadresser (for https://)</translation>
<translation id="1044878202534415707">Rapportér hardwarestatistik, f.eks. CPU/RAM-forbrug.

      Hvis politikken angives som Falsk, rapporteres statistikken ikke.
      Hvis den angives som Sand eller slet ikke indstilles, rapporteres statistikken.</translation>
<translation id="1046484220783400299">Aktivér forældede funktioner på webplatformen i en begrænset periode</translation>
<translation id="1047128214168693844">Tillad ikke, at websites sporer brugerens fysiske placering</translation>
<translation id="1049138910114524876">Konfigurerer den landestandard, der gennemtvinges på loginskærmen for <ph name="PRODUCT_OS_NAME" />.

Hvis denne politik er angivet, vises loginskærmen i den landestandard, der er angivet af den første værdi i denne politik (politikken er defineret som en liste til fremadrettet kompatibilitet). Hvis politikken ikke er angivet eller er angivet som en tom liste, vises loginskærmen i den landestandard, der blev anvendt i den forrige brugersession. Hvis denne politik er angivet med en værdi, der ikke er en gyldig landestandard, vises loginskærmen i en reservelandestandard (som i øjeblikket er en-US).</translation>
<translation id="1062011392452772310">Aktivér fjernattestering for enheden</translation>
<translation id="1062407476771304334">Erstat</translation>
<translation id="1079801999187584280">Tillad ikke brug af Udviklerværktøjer</translation>
<translation id="1093082332347834239">Hvis denne indstilling er aktiveret, køres den eksterne hjælpehost i en proces med <ph name="UIACCESS_PERMISSION_NAME" />-tilladelser. Dette giver eksterne brugere mulighed for at interagere med vinduer med administratorrettigheder på den lokale brugers skrivebord.

          Hvis denne indstilling er deaktiveret eller ikke er konfigureret, køres den eksterne hjælpehost i brugerens kontekst, og eksterne brugere kan ikke interagere med vinduer med administratorrettigheder på skrivebordet.</translation>
<translation id="1096105751829466145">Standardsøgemaskine</translation>
<translation id="1099282607296956954">Aktivér isolering af websites for alle websites</translation>
<translation id="1100570158310952027">
      Denne politik angiver en liste over kilder (webadresser) eller mønstre (f.eks. "*example.com") for hostnames, hvor sikkerhedsbegrænsninger på usikre kilder ikke anvendes.

Hensigten er at give organisationer mulighed for at angive hvidlistekilder for forældede apps, der ikke kan implementere TLS, eller konfigurere en testserver til intern webudvikling, så deres udviklere kan teste funktioner, der kræver sikre kontekster, uden at skulle anvende TLS på testserveren. Denne politik forhindrer desuden, at kilden mærkes som "Ikke sikker" i omnifeltet.

Angivelse af en liste over webadresser i denne politik har den samme effekt som indstilling af kommandolinjemarkeringen "--unsafely-treat-insecure-origin-as-secure" på en kommasepareret liste over de samme webadresser. Hvis politikken er angivet, tilsidesætter den kommandolinjemarkeringen.

Denne politik tilsidesætter UnsafelyTreatInsecureOriginAsSecure, hvis den er til stede.

Du kan få flere oplysninger om sikre kontekster på https://www.w3.org/TR/secure-contexts/.
      </translation>
<translation id="1107764601871839136">Angiver levetiden (i timer) for GPO-cachen (Group Policy Object). I stedet for at downloade GPO'er på ny, hver gang der hentes en politik, kan systemet genbruge cachelagrede GPO'er, så længe versionen ikke er ændret. Denne politik angiver det maksimale tidsrum, hvor cachelagrede GPO'er må genbruges, før de skal downloades på ny. Cachen ryddes, hvis du genstarter enheden eller logger ud.

      Hvis politikken ikke er angivet, kan cachelagrede GPO'er genbruges i op til 25 timer.

      Hvis politikken er angivet til 0, er GPO-cachelagring slået fra. Bemærk, at dette øger serverbelastningen, da GPO'er downloades på ny, hver gang der hentes en politik – også hvis politikken ikke er ændret.</translation>
<translation id="1117535567637097036">De protokolhandlere, der er angivet via denne politik, bruges ikke til håndtering af Android-formål.</translation>
<translation id="1118093128235245168">Tillad, at websites anmoder en bruger om adgang til en tilsluttet USB-enhed i nærheden.</translation>
<translation id="1128903365609589950">Konfigurerer det indeks, som <ph name="PRODUCT_NAME" /> anvender til at gemme cachelagrede filer på disken.

      Hvis du angiver denne politik, anvender <ph name="PRODUCT_NAME" /> det medfølgende indeks, uanset om brugeren har angivet markeringen "--disk-cache-dir" eller ej. For ikke at miste data eller få uventede fejl bør denne politik ikke angives som en mængdes rodindeks eller som et indeks, der bruges til andre formål, da <ph name="PRODUCT_NAME" /> administrerer indholdet.

      Gå til https://www.chromium.org/administrators/policy-list-3/user-data-directory-variables for at se en liste over variabler, der kan bruges.

      Hvis denne politik ikke angives, anvendes standardcacheindekset, og brugeren vil kunne tilsidesætte det med kommandolinjemarkeringen "--disk-cache-dir".</translation>
<translation id="113521240853905588">Konfigurerer de sprog, der kan bruges som foretrukne sprog af <ph name="PRODUCT_OS_NAME" />.

      Hvis denne politik er angivet, kan brugeren kun føje et af sprogene i denne politik til listen over foretrukne sprog. Hvis denne politik ikke er angivet eller er angivet som en tom liste, kan brugeren angive et hvilket som helst sprog som foretrukket. Hvis denne politik er angivet som en liste med ugyldige værdier, ignoreres alle ugyldige værdier. Hvis en bruger tidligere har føjet sprog, der ikke tillades af denne politik, til listen over foretrukne sprog, fjernes disse sprog. Hvis brugeren tidligere har konfigureret <ph name="PRODUCT_OS_NAME" /> til visning på et af de sprog, der ikke tillades af denne politik, ændres visningssproget til et tilladt brugerfladesprog, næste gang brugeren logger ind. Ellers skifter <ph name="PRODUCT_OS_NAME" /> til den første gyldige værdi, der er angivet af denne politik, eller til en alternativ landestandard (i øjeblikket en-US), hvis denne politik kun indeholder ugyldige poster.</translation>
<translation id="1135264353752122851">Konfigurerer, hvilke tastaturlayouts der tillades for brugersessioner i <ph name="PRODUCT_OS_NAME" />.

      Hvis denne politik er angivet, kan brugeren kun vælge én af indtastningsmetoderne, der er angivet af denne politik. Hvis politikken ikke er angivet eller er angivet som en tom liste, kan brugeren vælge alle understøttede indtastningsmetoder. Hvis den aktuelle indtastningsmetode ikke tillades af denne politik, skiftes indtastningsmetoden til hardwaretastaturlayoutet (hvis det er tilladt) eller den første gyldige post på denne liste. Alle ugyldige eller ikke-understøttede indtastningsmetoder på denne liste ignoreres.</translation>
<translation id="1138294736309071213">Denne politik er kun aktiv i detailtilstand.

      Bestemmer, hvor lang tid der går, inden pauseskærmen vises på loginskærmen for enheder i detailtilstand.

      Politikværdien skal angives i millisekunder.</translation>
<translation id="1141767714195601945">Denne politik styrer kommandolinjeparametre fra Internet Explorer til Chrome.

      Hvis Internet Explorer-tilføjelsen "Emulator til ældre websites" ikke er installeret, har denne politik ingen effekt.

      Hvis politikken ikke er konfigureret, overfører Internet Explorer kun webadressen til Chrome som en kommandolinjeparameter.

      Hvis politikken er konfigureret med en liste over strenge, knyttes strengene sammen med mellemrum, hvorefter de overføres til Chrome som kommandolinjeparametre.

      Hvis et element indeholder ${url}, erstattes det med webadressen til den side, der skal åbnes.

      Hvis ingen elementer indeholder ${url}, tilføjes webadressen i slutningen af kommandolinjen.

      Variabler for miljøet udvides. I Windows erstattes %ABC% med variabelværdien for ABC-miljøet.</translation>
<translation id="1151353063931113432">Tillad billeder på disse websites</translation>
<translation id="1152117524387175066">Rapportér tilstanden for enhedens udviklerkontakt ved opstart.

      Hvis politikken er angivet til Falsk, rapporteres tilstanden for udviklerkontakten ikke.</translation>
<translation id="1160479894929412407">Tillad QUIC-protokol</translation>
<translation id="1160939557934457296">Deaktiver fortsættelse fra advarselssiden for Beskyttet browsing</translation>
<translation id="1189817621108632689">Giver dig mulighed for at oprette en liste med webadressemønstre, der angiver websites, hvor det ikke er tilladt at vise billeder.

          Hvis denne politik ikke angives, anvendes den globale standardværdi på alle websites, enten fra politikken "DefaultImagesSetting", hvis den er angivet, eller brugerens personlige konfiguration.

          Bemærk, at denne politik tidligere ved en fejl blev aktiveret for Android, men denne funktionalitet har aldrig været understøttet fuldt ud af Android.</translation>
<translation id="1198465924256827162">Hvor ofte der sendes enhedsstatusuploads (i millisekunder).

      Hvis denne politik ikke angives, er standardfrekvensen tre timer. Den laveste
      tilladte frekvens er 60 sekunder.</translation>
<translation id="1204263402976895730">Aktiverede virksomhedsprintere</translation>
<translation id="1219695476179627719">Angiver, om enheden skal gå tilbage til den version, der er konfigureret af <ph name="DEVICE_TARGET_VERSION_PREFIX_POLICY_NAME" />, hvis den allerede kører en nyere version.

      RollbackDisabled anvendes som standard.</translation>
<translation id="1221359380862872747">Indlæs de angivne webadresser ved demologin</translation>
<translation id="1223789468190631420">Aktivér Beskyttet browsing i forbindelse med godkendte kilder</translation>
<translation id="122899932962115297">En hvidliste, der styrer, hvilke tilstande for hurtig oplåsning brugeren kan konfigurere og bruge til at låse låseskærmen op.

          Denne værdi er en liste med strenge. Gyldige poster på listen er: "all", "PIN", "FINGERPRINT". Hvis du føjer "all" til listen, betyder det, at alle tilstande for hurtig oplåsning er tilgængelige for brugeren – også dem, der implementeres i fremtiden. Ellers er det kun de tilstande for hurtig oplåsning, der er på listen, som er tilgængelige.

          Brug f.eks. ["all"] for at tillade alle tilstande for hurtig oplåsning. Brug ["PIN"] for kun at tillade oplåsning med pinkode. Brug ["PIN", "FINGERPRINT"] for at tillade oplåsning med pinkode og fingeraftryk. Brug [] for at deaktivere alle tilstande for hurtig oplåsning.

          Som standard er ingen tilstande for hurtig oplåsning tilgængelige på administrerede enheder.</translation>
<translation id="123081309365616809">Aktivér casting af indhold til enheden</translation>
<translation id="1231349879329465225">Gør det muligt at aktivere eller deaktivere Fast Transition.
      Denne indstilling gælder for alle brugere og på alle grænseflader på enheden.
      Både denne indstilling og ONC-ejendommen pr. netværk skal aktiveres, før Fast Transition kan bruges.
      Når indstillingen er angivet, anvendes Fast Transition, indtil den deaktiveres ved en ændring af politikken.

      Hvis denne politik ikke er angivet eller er angivet som falsk, anvendes Fast Transition ikke.
      Hvis den er angivet som sand, anvendes Fast Transition, hvis det trådløse adgangspunkt understøtter funktionen.</translation>
<translation id="1243570869342663665">Administrer filtrering af voksenindhold for SafeSites.</translation>
<translation id="1257550411839719984">Angiv standardmappe til downloads</translation>
<translation id="1265053460044691532">Begræns den tid, hvor en bruger, der er godkendt via SAML, kan logge på offline</translation>
<translation id="1290634681382861275">Styrer diverse indstillinger, bl.a. USB, Bluetooth, opdatering af politikker, udviklertilstand og mange andre.</translation>
<translation id="1291880496936992484">Advarsel! RC4 bliver fjernet helt fra <ph name="PRODUCT_NAME" /> efter version 52 (omkring september 2016), og på det tidspunkt vil denne politik holde op med at virke.

      Hvis politikken ikke er angivet eller er angivet til Falsk, aktiveres RC4-krypteringsprogrammer i TLS ikke. Alternativt kan den angives til Sandt for at bevare kompatibiliteten med en forældet server. Dette er en midlertidig løsning, og serveren bør rekonfigureres.</translation>
<translation id="1297182715641689552">Brug et .pac-proxyscript</translation>
<translation id="1304973015437969093">Udvidelses-/app-id'er og opdateringswebadresser skal installeres ubemærket</translation>
<translation id="1307454923744766368">Kilder eller mønstre for hostname, hvor begrænsninger på usikre kilder ikke bør anvendes</translation>
<translation id="1312799700549720683">Styrer skærmindstillinger.</translation>
<translation id="131353325527891113">Vis brugernavne på loginskærmen</translation>
<translation id="1327466551276625742">Aktivér meddelelse om netværkskonfiguration, når du er offline</translation>
<translation id="1330145147221172764">Aktivér skærmtastatur</translation>
<translation id="13356285923490863">Navn på politik</translation>
<translation id="1352174694615491349">Denne politik tillader sammenkædning af HTTP/2-forbindelser, når klientcertifikater er i brug. Både den potentielle nye forbindelses hostname og en eksisterende forbindelses hostname skal matche et eller flere mønstre, der beskrives i denne politik, for at kunne sammenkædes. Politikken er en liste over hosts, der bruger filterformatet URLBlacklist: "example.com" matcher "example.com" og alle underdomæner (f.eks. "under.example.com"), mens ".example.net" nøjagtigt matcher "example.net".

Anmodninger om sammenkædning til forskellige hosts via forbindelser, der bruger klientcertifikater, kan medføre problemer med sikkerhed og fortrolighed, da ambient authority overføres til alle anmodninger, selv om brugeren ikke specifikt har godkendt dette. Denne politik er midlertidig og fjernes i en fremtidig udgivelse. Se https://crbug.com/855690.

Hvis denne politik ikke er angivet, benyttes standardreglen, hvor ingen HTTP/2-forbindelser får tilladelse til sammenkædning med forbindelser ved hjælp af klientcertifikater.</translation>
<translation id="1353966721814789986">Startsider</translation>
<translation id="1354424209129232709">Maksimum:</translation>
<translation id="1359553908012294236">Hvis denne politik er angivet til sand eller ikke er konfigureret, aktiverer <ph name="PRODUCT_NAME" /> gæstelogins. Gæstelogins er <ph name="PRODUCT_NAME" />-profiler, hvor alle vinduer er i inkognitotilstand.

      Hvis denne politik er angivet til falsk, tillader <ph name="PRODUCT_NAME" /> ikke, at der startes gæsteprofiler.</translation>
<translation id="1363275621236827384">Aktivér forespørgsler til Quirks Server om hardwareprofiler</translation>
<translation id="1363612796557848469">Denne politik giver Google Assistent tilladelse til at se skærmindhold og sende oplysningerne til serveren.
      Hvis politikken er aktiveret, kan Google Assistent få adgang til skærmindhold.
      Hvis politikken er deaktiveret, kan Google Assistent ikke få adgang til skærmindhold.
      Hvis politikken ikke er konfigureret. kan brugerne selv bestemme, om Google Assistent skal have adgang til skærmindhold.</translation>
<translation id="1383493480903114193">Denne politik tvinger netværkskoden til at køre i browserprocessen.

      Denne politik er som standard deaktiveret. Hvis den aktiveres, kan brugerne blive udsat for sikkerhedsproblemer, når der anvendes en sandboxløsning til netværksprocessen.

      Denne politik har til formål at give virksomhederne mulighed for at migrere til tredjepartssoftware, der ikke er afhængig af at bruge hooking til netværks-API'er. Det anbefales at bruge proxyservere i stedet for LSP'er og Win32 API-programrettelser.

      Hvis denne politik ikke er konfigureret, kan netværkskoden køre ud af browserprocessen afhængigt af brugstest i NetworkService-eksperimentet.</translation>
<translation id="1384459581748403878">Reference: <ph name="REFERENCE_URL" /></translation>
<translation id="1384653327213929024">Tillad, at brugerne administrerer installerede certifikater.</translation>
<translation id="1387596372902085462">Angiver, om der skal aktiveres tillid til Symantec Corporations forældede PKI-infrastruktur</translation>
<translation id="1393485621820363363">Aktiverede virksomhedsprintere for enheder</translation>
<translation id="1397855852561539316">Foreslået webadresse fra standardsøgemaskinen</translation>
<translation id="1404043648050567997">Tjenesten Beskyttet browsing viser en advarselsside, når brugerne navigerer til websites, der er markeret som potentielt skadelige. Hvis denne indstilling aktiveres, forhindrer det brugerne i at fortsætte fra advarselssiden til det skadelige website.

      Denne politik forhindrer kun brugerne i at fortsætte i tilfælde af Beskyttet browsing-advarsler (f.eks. malware og phishing) og ikke ved problemer relateret til SSL-certifikater såsom ugyldige eller udløbne certifikater.

      Hvis denne indstilling er deaktiveret eller ikke er konfigureret, kan brugerne vælge at gå til det rapporterede website, efter advarslen er vist.

      Du kan få flere oplysninger om Beskyttet browsing på https://developers.google.com/safe-browsing.</translation>
<translation id="1413936351612032792">Rapportér oplysninger om brug af Linux-apps</translation>
<translation id="142346659686073702">Tillad, at brugere uden tilknytning benytter Crostini</translation>
<translation id="1426410128494586442">Ja</translation>
<translation id="1427655258943162134">Adresse eller webadresse på proxyserveren</translation>
<translation id="1431272318313028342">Aktiverer Beskyttet browsing i <ph name="PRODUCT_NAME" /> og forhindrer brugere i at ændre denne indstilling.

      Hvis du aktiverer denne indstilling, er Beskyttet browsing altid aktiv.

      Hvis du deaktiverer denne indstilling, er Beskyttet browsing aldrig aktiv.

      Hvis du aktiverer eller deaktiverer denne indstilling, kan brugerne ikke ændre eller tilsidesætte indstillingen "Aktivér beskyttelse mod phishing og malware" i <ph name="PRODUCT_NAME" />.

      Hvis denne politik ikke er angivet, aktiveres indstillingen, men brugeren kan ikke ændre den.

      Du kan få flere oplysninger om Beskyttet browsing på https://developers.google.com/safe-browsing.

      Denne politik er kun tilgængelig for Windows-forekomster, der er knyttet til et <ph name="MS_AD_NAME" />-domæne, eller Windows 10 Pro- eller Enterprise-forekomster, der er tilmeldt administration af enheder.</translation>
<translation id="1435659902881071157">Netværkskonfiguration på enhedsniveau</translation>
<translation id="1438739959477268107">Standardindstilling for nøglegenerering</translation>
<translation id="1454846751303307294">Gør det muligt at oprette en liste over webadressemønstre for at angive websites, som ikke må køre JavaScript. Hvis denne politik ikke angives, anvendes den globale standardværdi på alle websites, enten fra politikken "DefaultJavaScriptSetting", hvis den er angivet, eller brugerens personlige konfiguration.</translation>
<translation id="1456822151187621582">Windows (<ph name="PRODUCT_OS_NAME" />-klienter):</translation>
<translation id="1464848559468748897">Kontrollér brugeradfærden i en session med flere profiler på <ph name="PRODUCT_OS_NAME" />-enheder.

      Hvis politikken er angivet til "MultiProfileUserBehaviorUnrestricted", kan brugeren enten være primær eller sekundær bruger i en session med flere profiler.

      Hvis denne politik er angivet til "MultiProfileUserBehaviorMustBePrimary", kan brugeren kun være den primære bruger i en session med flere profiler.

      Hvis denne politik er angivet til "MultiProfileUserBehaviorNotAllowed'", kan brugeren ikke være en del af en session med flere profiler.

      Hvis du aktiverer denne indstilling, kan brugerne ikke ændre eller tilsidesætte den.

      Hvis indstillingen ændres, mens brugeren er logget ind på en session med flere profiler, undersøges de respektive indstillinger for alle brugere i sessionen. Sessionen afsluttes, når en af brugerne ikke længere har tilladelse til at være i sessionen.

      Hvis politikken ikke er indstillet, anvendes standardværdien "MultiProfileUserBehaviorMustBePrimary" for virksomhedsadministrerede brugere, og "MultiProfileUserBehaviorUnrestricted" anvendes for ikke-administrerede brugere.</translation>
<translation id="1465619815762735808">Klik for at afspille</translation>
<translation id="1468307069016535757">Indstil standardtilstanden for hjælpefunktionen Høj kontrast på loginskærmen.

          Hvis denne politik angives som sand, aktiveres høj kontrast, når loginskærmen vises.

          Hvis denne politik angives som falsk, deaktiveres høj kontrast, når loginskærmen vises.

          Hvis du angiver denne politik, kan brugerne midlertidigt tilsidesætte den ved at aktivere eller deaktivere Høj kontrast. Brugerens valg er dog ikke endegyldigt, og standarden gendannes, når loginskærmen vises igen, eller hvis brugeren forbliver inaktiv på loginskærmen i et minut.

          Hvis denne politik ikke angives, deaktiveres høj kontrast, når loginskærmen vises første gang. Brugerne kan når som helst aktivere eller deaktivere Høj kontrast, og dens status på loginskærmen fastholdes hos brugerne.</translation>
<translation id="1468707346106619889">Hvis denne politik er angivet som sand, er Kombineret skrivebord tilladt og
      aktiveret som standard, hvilket giver apps mulighed for at fylde flere skærme.
      Brugeren kan deaktivere Kombineret skrivebord for de enkelte skærme ved at fjerne markeringen af afkrydsningsfeltet ud for dem
      i skærmindstillingerne.

      Hvis denne politik er angivet som falsk eller ikke er angivet, vil Kombineret skrivebord være
      deaktiveret. Hvis det er tilfældet, kan brugeren ikke aktivere denne funktion.</translation>
<translation id="1474273443907024088">Deaktiver TLS False Start</translation>
<translation id="1477934438414550161">TLS 1.2</translation>
<translation id="1484146587843605071"><ph name="PRODUCT_NAME" /> vil omgå alle proxyer for den hostliste, der vises her.

          Denne politik træder kun i kraft, hvis du har valgt indstillinger for manuel proxy under "Vælg, hvordan du vil angive indstillinger for proxyserver".

          Denne politik bør ikke angives, hvis du har valgt en anden form for angivelse af proxypolitikker.

          Få flere detaljerede eksempler på:
          <ph name="PROXY_HELP_URL" />.</translation>
<translation id="1502843533062797703">Bloker for tilføjelse af software fra tredjeparter</translation>
<translation id="1504431521196476721">Fjernattestering</translation>
<translation id="1507957856411744193">Hvis politikken er angivet som Sand, opretter <ph name="PRODUCT_NAME" /> forbindelse til Cast-enheder på alle IP-adresser og ikke kun på private adresser af typen RFC1918/RFC4193.

          Hvis politikken er angivet som Falsk, opretter <ph name="PRODUCT_NAME" /> kun forbindelse til Cast-enheder på private adresser af typen RFC1918/RFC4193.

          Hvis politikken ikke er konfigureret, opretter <ph name="PRODUCT_NAME" /> kun forbindelse til Cast-enheder på private adresser af typen RFC1918/RFC4193, medmindre funktionen CastAllowAllIPs er aktiveret.

          Hvis politikken "EnableMediaRouter" er angivet som Falsk, har værdien for denne politik ingen virkning.</translation>
<translation id="1509692106376861764">Denne politik er trukket tilbage fra og med <ph name="PRODUCT_NAME" /> version 29.</translation>
<translation id="1514888685242892912">Aktivér <ph name="PRODUCT_NAME" /></translation>
<translation id="1522425503138261032">Tillad, at websites registrerer brugernes fysiske placering</translation>
<translation id="1523774894176285446">Alternative browsere, der skal åbnes for konfigurerede websites.</translation>
<translation id="152657506688053119">Liste over alternative webadresser for standardsøgemaskinen</translation>
<translation id="1530812829012954197">Gengiv altid følgende webadressemønstre i værtsbrowseren</translation>
<translation id="1541170838458414064">Begræns størrelsen på udskriftsiden</translation>
<translation id="1553684822621013552">Når denne politik er angivet til sand, aktiveres ARC for brugeren
      (undelagt de øvrige indstillinger for politik. ARC er stadig
      utilgængelig, hvis engangsbruger eller samlet login fra flere konti
      aktiveres i den aktuelle brugersession).

      Hvis denne indstilling er deaktiveret eller ikke er konfigureret, kan
      virksomhedsbrugere ikke bruge ARC.</translation>
<translation id="1559980755219453326">Politikken styrer, om der skal rapporteres oplysninger om udvidelser og plugins.

      Hvis politikken er angivet som Sand eller ikke er konfigureret, indsamles der data om udvidelser og plugins.
      Hvis politikken er angivet som Falsk, indsamles der ikke data om udvidelser og plugins.

      Politikken gælder kun, når <ph name="CHROME_REPORTING_EXTENSION_NAME" /> er aktiveret, og maskinen er tilmeldt <ph name="MACHINE_LEVEL_USER_CLOUD_POLICY_ENROLLMENT_TOKEN_POLICY_NAME" />.</translation>
<translation id="1561424797596341174">Tilsidesættelser af politik for fejlretningsbuilds på hosten til fjernadgang</translation>
<translation id="1561967320164410511">U2F samt udvidelser til individuel attestering</translation>
<translation id="1574554504290354326">Denne indstilling er forældet. Brug SafeBrowsingExtendedReportingEnabled i stedet. Aktivering eller deaktivering af SafeBrowsingExtendedReportingEnabled svarer til at angive SafeBrowsingExtendedReportingOptInAllowed som Falsk.

      Hvis politikken er angivet som Falsk, forhindres brugerne i at sende visse former for systemoplysninger og sideindhold til Googles servere. Hvis indstillingen er angivet som Sand eller ikke er angivet, kan brugerne sende visse former for systemoplysninger og sideindhold til Beskyttet browsing som en hjælp til at registrere skadelige apps og websites.

      Få flere oplysninger om Beskyttet browsing på https://developers.google.com/safe-browsing.</translation>
<translation id="1583248206450240930">Brug <ph name="PRODUCT_FRAME_NAME" /> som standard</translation>
<translation id="1599424828227887013">Aktivér isolering af websites for bestemte websites på Android-enheder</translation>
<translation id="1608259529294767544">Denne politik giver Google Assistent tilladelse til at lytte efter den stemmestyrede aktiveringssætning.

      Hvis politikken er aktiveret, lytter Google Assistent efter den stemmestyrede aktiveringssætning.
      Hvis politikken er deaktiveret, lytter Google Assistent ikke efter den stemmestyrede aktiveringssætning.
      Hvis politikken ikke er konfigureret, kan brugerne selv bestemme, om Google Assistent skal lytte efter den stemmestyrede aktiveringssætning.
      </translation>
<translation id="1608755754295374538">Webadresser, der får adgang til lydoptagelsesenheder, uden at du skal give tilladelse hertil</translation>
<translation id="1615221548356595305">Tillad sammenkædning af HTTP/2-forbindelser for disse hosts, selv når der anvendes klientcertifikater</translation>
<translation id="1617235075406854669">Aktivér sletning af browser- og downloadhistorik</translation>
<translation id="163200210584085447">Mønstre på denne liste sammenlignes med sikkerhedskilden
      for den anmodede webadresse.  Hvis der findes et match, gives der
      adgang til videooptagelsesenheder på SAML-loginsider.  Hvis der ikke findes
      noget match, nægtes der automatisk adgang.  Mønstre med jokertegn
      tillades ikke.</translation>
<translation id="1634989431648355062">Tillad <ph name="FLASH_PLUGIN_NAME" />-pluginnet på disse websites</translation>
<translation id="1655229863189977773">Angiv diskcache i bytes</translation>
<translation id="166427968280387991">Proxyserver</translation>
<translation id="1668836044817793277">Om den automatisk startede terminalapp uden forsinkelse skal kunne kontrollere <ph name="PRODUCT_OS_NAME" />-versionen.

      Denne politik bestemmer, om den automatisk startede terminalapp uden forsinkelse skal kunne styre <ph name="PRODUCT_OS_NAME" />-versionen ved at angive en required_platform_version i sit manifest og bruge den som præfiks for en automatisk opdateret målversion.

      Hvis politikken er angivet til sand, bruges værdien i manifestnøglen required_platform_version fra den automatisk startede terminalapp uden forsinkelse til automatisk at opdatere præfikset for målversionen.

      Hvis politikken ikke konfigureres, eller den indstilles til falsk, ignoreres manifestnøglen required_platform_version, og den automatiske opdatering fortsætter som normalt.

      Advarsel! Det frarådes at delegere kontrol over <ph name="PRODUCT_OS_NAME" />-versionen til en terminalapp, da det kan forhindre enheden i at modtage softwareopdateringer og kritiske sikkerhedsrettelser. Delegering af kontrol over <ph name="PRODUCT_OS_NAME" />-versionen kan udgøre en sikkerhedsrisiko for brugerne.</translation>
<translation id="1675002386741412210">Understøttes på:</translation>
<translation id="1689963000958717134">Tillader, at netværkskonfigurationen gøres gældende for alle brugere af en <ph name="PRODUCT_OS_NAME" />-enhed. Netværkskonfigurationen er en JSON-formateret streng, som er defineret af formatet Open Network Configuration som beskrevet på <ph name="ONC_SPEC_URL" /></translation>
<translation id="1708496595873025510">Angiv begrænsningen for hentning af variationbasistallet</translation>
<translation id="1717817358640580294">Hvis politikken ikke er angivet, kan Chrome-oprydning, hvis der findes uønsket software, rapportere metadata om scanningen til Google i overensstemmelse med politikken, der angives af SafeBrowsingExtendedReportingEnabled. Chrome-oprydning spørger derefter brugeren, om den uønskede software skal ryddes. Brugeren kan vælge at dele resultater fra oprydningen med Google for at assistere med registrering af uønsket software i fremtiden. Disse resultater indeholder filmetadata, automatisk installerede udvidelser og registreringsnøgler som beskrevet i Google Chromes hvidbog om beskyttelse af personlige oplysninger.

      Hvis politikken er deaktiveret, rapporterer Chrome-oprydning ikke metadata om scanningen til Google, hvis der findes uønsket software. Eventuelle politikker, der er angivet af SafeBrowsingExtendedReportingEnabled, tilsidesættes. Chrome-oprydning spørger brugeren, om den uønskede software skal ryddes.  Resultater af oprydningen rapporteres ikke til Google, og brugeren har ikke mulighed for selv at rapportere resultater.

      Hvis politikken er angivet, kan Chrome-oprydning, hvis der findes uønsket software, rapportere metadata om scanningen til Google i overensstemmelse med politikken, der angives af SafeBrowsingExtendedReportingEnabled. Chrome-oprydning spørger brugeren, om den uønskede software skal ryddes.  Resultater af oprydningen rapporteres til Google, og brugeren har ikke mulighed for at forhindre det.

      Denne politik er kun tilgængelig for Windows-forekomster, der er knyttet til et <ph name="MS_AD_NAME" />-domæne, eller Windows 10 Pro- eller Enterprise-forekomster, der er tilmeldt administration af enheder.</translation>
<translation id="172374442286684480">Tillad, at alle websites angiver lokale data</translation>
<translation id="1734716591049455502">Konfigurer indstillinger for fjernadgang</translation>
<translation id="1736269219679256369">Tillad fortsættelse fra SSL-advarselssiden</translation>
<translation id="1745780278307622857">Identificer, om <ph name="PRODUCT_NAME" /> kan tillade download uden tjek fra Beskyttet browsing, når det sker fra en pålidelig kilde.

      Når politikken er angivet som falsk, sendes downloadede filer ikke til analyse hos Beskyttet browsing, når de kommer fra en pålidelig kilde.

      Når politikken ikke er angivet (eller er angivet som sand), sendes downloadede filer til analyse hos Beskyttet browsing – også når de kommer fra en pålidelig kilde.

      Bemærk, at disse begrænsninger gælder for downloads, der udløses af indhold på websider og fra valgmuligheden "download link..." i genvejsmenuen. Disse begrænsninger gælder ikke for lagring/download af den side, der aktuelt vises, eller for lagring som PDF-fil under valgmulighederne for udskrift.

      Denne politik er kun tilgængelig for Windows-forekomster, der er knyttet til et <ph name="MS_AD_NAME" />-domæne, eller Windows 10 Pro- eller Enterprise-forekomster, der er tilmeldt administration af enheder.</translation>
<translation id="1749815929501097806">Angiver de Servicevilkår, som brugeren skal acceptere, inden en enhedslokal kontosession kan påbegyndes.

      Hvis denne politik indstilles, downloader <ph name="PRODUCT_OS_NAME" /> servicevilkårene og præsenterer dem for brugeren, når en enhedslokal kontosession påbegyndes. Brugeren får først tilladelse til sessionen, når servicevilkårene accepteres.

      Hvis denne politik ikke indstilles, vises der ikke nogen Servicevilkår.

      Politikken skal indstilles til en webadresse, hvorfra <ph name="PRODUCT_OS_NAME" /> kan downloade servicevilkårene. Servicevilkårene skal være almindelig tekst vist som MIME-tekst. Markering er ikke tilladt.</translation>
<translation id="1750315445671978749">Bloker alle downloads</translation>
<translation id="1781356041596378058">Denne politik styrer også adgangen til Indstillinger for udviklere i Android. Hvis du angiver denne politik til Sand, kan brugerne ikke få adgang til Indstillinger for udviklere. Hvis du angiver denne politik til Falsk eller ikke angiver den, kan brugerne få adgang til Indstillinger for udviklere ved at trykke syv gange på build-nummeret i Android-appen Indstillinger.</translation>
<translation id="1793346220873697538">Deaktiver udskrivning med pinkode som standard</translation>
<translation id="1797233582739332495">Vis brugeren en fast meddelelse, som indikerer, at en genstart er påkrævet</translation>
<translation id="1798559516913615713">Levetid for GPO-cache</translation>
<translation id="1803646570632580723">Liste over fastgjorte apps, der skal vises på applisten</translation>
<translation id="1808715480127969042">Bloker cookies på disse websites</translation>
<translation id="1810261428246410396">Tillad brug af øjeblikkelig netdeling.</translation>
<translation id="1817685358399181673">Denne politik angiver <ph name="PLUGIN_VM_NAME" />-billedet for en bruger. Politikken angives ved at angive den webadresse, som enheden kan downloade billedet fra, samt et SHA-256-hash, der bruges til at bekræfte downloadens integritet.

      Politikken skal angives som en streng, der viser webadressen og hashet i JSON-format.</translation>
<translation id="1827523283178827583">Brug faste proxyservere</translation>
<translation id="1831495419375964631">Denne politik er en webadresse, der henviser til en XML-fil i det samme format som Internet Explorers <ph name="IEEM_SITELIST_POLICY" />-politik. Dette indlæser regler fra en XML-fil uden at dele disse regler med Internet Explorer.

      Når denne politik ikke er angivet eller ikke er angivet til en gyldig webadresse, bruger <ph name="PRODUCT_NAME" /> den ikke som en kilde til regler om browserskift.

      Når denne politik er angivet til en gyldig webadresse, downloader <ph name="PRODUCT_NAME" /> websitelisten fra den pågældende webadresse og anvender reglerne, som hvis de var konfigureret med <ph name="SITELIST_POLICY_NAME" />-politikken.

      Du kan få flere oplysninger om Internet Explorers <ph name="IEEM_SITELIST_POLICY" />-politik på: https://docs.microsoft.com/internet-explorer/ie11-deploy-guide/what-is-enterprise-mode</translation>
<translation id="1839060937202387559">Rapportér hardwarestatistik og id'er for lagerenheder.

      Hvis politikken angives som Falsk, rapporteres statistikken ikke.
      Hvis politikken angives som Sand eller ikke angives, rapporteres statistikken.</translation>
<translation id="1843117931376765605">Opdateringsfrekvens for brugerpolitik</translation>
<translation id="1844620919405873871">Konfigurerer politikker for hurtig oplåsning.</translation>
<translation id="1845405905602899692">Terminalindstillinger</translation>
<translation id="1845429996559814839">Begræns udskrivningstilstanden med pinkode</translation>
<translation id="1847960418907100918">Angiver de parametre, der anvendes ved direkte søgning med POST. Det består af kommaseparerede navne/værdipar. Hvis en værdi er en skabelonparameter såsom {searchTerms} i ovenstående eksempel, erstattes den med rigtige søgetermdata.

          Denne politik er valgfri. Hvis den ikke er angivet, sendes anmodninger om direkte søgning ved hjælp af GET-metoden.

          Denne politik respekteres kun, hvis politikken "DefaultSearchProviderEnabled" er aktiveret.</translation>
<translation id="1852294065645015766">Tillad automatisk afspilning af medier</translation>
<translation id="1857152770025485173">Politikken forhindrer brugeren i at indlæse websider fra sortlistede webadresser. Sortlisten viser en liste over webadressemønstre, som angiver, hvilke webadresser der føjes til sortlisten.

      Et webadressemønster skal formateres i overensstemmelse med https://www.chromium.org/administrators/url-blacklist-filter-format.

      Undtagelser kan defineres i politikken for hvidlistede webadresser. Der er en maksimumsgrænse på 1000 poster for disse politikker. Alle efterfølgende poster ignoreres.

      Bemærk, at det frarådes at blokere interne webadresser af typen "chrome://*", da dette kan føre til uventede fejl.

      Du kan blokere webadresser af typen "javascript://*" via M73. Det påvirker dog kun JavaScript, der er angivet i adresselinjen (eller f.eks. bookmarklets). Bemærk, at JavaScript-webadresser på siden ikke er underlagt denne politik, så længe de er dynamisk indlæste data. Hvis du f.eks. blokerer "eksempel.dk/abc", kan "eksempel.dk" stadig indlæse "eksempel.dk/abc" via XMLHTTPRequest.

      Hvis politikken ikke konfigureres, bliver ingen webadresser sortlistet i browseren.</translation>
<translation id="1859859319036806634">Advarsel! Denne TLS-fallbackversion fjernes fra <ph name="PRODUCT_NAME" /> efter version 52 (omkring september 2016), og denne politik er da ikke længere aktuel.

Når TLS-dataudveksling mislykkes, ville <ph name="PRODUCT_NAME" /> tidligere prøve at oprette forbindelse igen med en ældre TLS-version for at løse problemet med fejl i HTTPS-servere. Denne indstilling konfigurerer den version, hvor fallback-processen stopper. Hvis en server udfører versionsforhandling korrekt (dvs. uden at afbryde forbindelsen), anvendes denne indstilling ikke. Uanset hvad skal den resulterende forbindelse stadig være i overensstemmelse med SSLVersionMin.

Hvis denne politik ikke konfigureres, eller hvis den indstilles til "tls1.2", udfører <ph name="PRODUCT_NAME" /> ikke længere dette fallback. Bemærk, at dette ikke deaktiverer understøttelse af ældre TLS-versioner, kun hvorvidt <ph name="PRODUCT_NAME" /> vil løse problemet med fejlbehæftede servere, som ikke kan forhandle versioner korrekt.

Hvis kompatabilitet med en fejlbehæftet server skal opretholdes, kan denne politik indstilles til "tls1.1". Dette er en midlertidig løsning, og problemet med serveren bør snarest udbedres.</translation>
<translation id="1864269674877167562">Hvis denne politik er angivet med en tom streng, eller hvis den ikke er konfigureret, viser <ph name="PRODUCT_OS_NAME" /> ikke et forslag til autofuldførelse under loginflowet.
      Hvis denne politik er angivet med en streng, der repræsenterer et domænenavn, viser <ph name="PRODUCT_OS_NAME" /> et forslag til autofuldførelse under loginflowet. Dette giver brugeren mulighed for kun at skulle angive sit brugernavn uden hele domænenavnet. Brugeren kan overskrive dette domænenavn.</translation>
<translation id="1864382791685519617">Aktiverer netværksforudsigelse i <ph name="PRODUCT_NAME" /> og forhindrer brugerne i at ændre denne indstilling.

      Dette styrer både forudhentning af DNS og forhåndstilslutning af TCP og SSL samt forhåndsgengivelse af websider.

      Hvis du indstiller denne politik, kan brugerne ikke ændre eller tilsidesætte denne indstilling i <ph name="PRODUCT_NAME" />.

      Hvis denne politik ikke indstilles, aktiveres netværksforudsigelse, men brugeren vil kunne ændre det.</translation>
<translation id="1865417998205858223">Vigtige tilladelser</translation>
<translation id="186719019195685253">Den handling, der igangsættes ved inaktiv forsinkelse på fast strømforsyning</translation>
<translation id="187819629719252111">Giver adgang til lokale filer på maskinen ved at lade <ph name="PRODUCT_NAME" /> vise dialogbokse om filvalg. Hvis du aktiverer denne indstilling, kan brugerne åbne dialogbokse om filvalg som normalt. Hvis du deaktiverer denne indstilling, vises der en meddelelse i stedet for en dialogboks om filvalg, hver gang brugeren foretager en handling, der ville have frembragt en dialogboks om filvalg (såsom at importere bogmærker, uploade filer, gemme links osv.), og det antages, at brugeren har trykket på Annuller i dialogboksen om filvalg. Hvis denne indstilling ikke angives, kan brugerne åbne dialogbokse om filvalg som normalt.</translation>
<translation id="1885782360784839335">Aktivér visning af kampagneindhold på hele fanen</translation>
<translation id="1888871729456797026">Tilmeldingstoken for Cloud-politikken på computere</translation>
<translation id="1897365952389968758">Tillad, at alle websites kører JavaScript</translation>
<translation id="1906888171268104594">Bestemmer, om metrics om brug og diagnosticeringsdata, bl.a. nedbrudsrapporter, rapporteres tilbage til Google.

      Hvis den er angivet som sand, rapporterer <ph name="PRODUCT_OS_NAME" /> metrics om brug og diagnosticeringsdata.

      Hvis den er angivet som falsk, deaktiveres rapportering af metrics og diagnosticeringsdata.

      Hvis den ikke konfigureres, deaktiveres rapportering af metrics og diagnosticeringsdata på ikke-administrerede enheder, mens det aktiveres på administrerede enheder.</translation>
<translation id="1907431809333268751">Konfigurer listen over webadresser til virksomhedslogin (kun HTTP- og HTTPS-skemaer). Adgangskodens fingeraftryk registreres på disse webadresser og bruges til registrering af genbrug af adgangskoder.
      For at <ph name="PRODUCT_NAME" /> kan registrere fingeraftryk for adgangskoder korrekt skal du sørge for, at dine loginsider følger retningslinjerne på https://www.chromium.org/developers/design-documents/create-amazing-password-forms.

      Hvis denne indstilling er aktiveret, registrerer tjenesten til adgangskodebeskyttelse fingeraftryk for adgangskoder på disse webadresser med henblik på at registrere genbrug af adgangskoder.
      Hvis denne indstilling er deaktiveret eller ikke er angivet, registrerer tjenesten til adgangskodebeskyttelse kun fingeraftryk for adgangskoder på https://accounts.google.com.
      Denne politik er kun tilgængelig for Windows-forekomster, der er knyttet til et <ph name="MS_AD_NAME" />-domæne, eller Windows 10 Pro- eller Enterprise-forekomster, der er tilmeldt administration af enheder.</translation>
<translation id="1920046221095339924">Tillad administreret session på enheden</translation>
<translation id="1929709556673267855">Angiver konfigurationer af virksomhedsprintere, der er knyttet til enheder.

      Denne politik giver dig mulighed for at angive printerkonfigurationer for <ph name="PRODUCT_OS_NAME" />-enheder.  Formatet er det samme som for NativePrinters-ordbogen, men for hver printer er der et yderligere påkrævet felt for "id" eller "guid" til hvidlister og sortlister.

      Filen må ikke være større end 5 MB, og den skal indkodes i JSON.  En fil med ca. 21.000 printere forventes at indkode som en fil på 5 MB.  Den kryptografiske nøgletransformation bruges til at bekræfte downloadens integritet.

      Filen downloades og gemmes i cachen. Den downloades igen, hver gang webadressen eller nøgletransformationen ændres.

      Hvis denne politik er angivet, vil <ph name="PRODUCT_OS_NAME" /> downloade filen til printerkonfigurationer og gøre printere tilgængelige i overensstemmelse med <ph name="DEVICE_PRINTERS_ACCESS_MODE" />, <ph name="DEVICE_PRINTERS_WHITELIST" /> og <ph name="DEVICE_PRINTERS_BLACKLIST" />.

      Denne politik påvirker ikke, om brugerne kan konfigurere printere på individuelle enheder.  Den er beregnet til at fungere som supplement til den enkelte brugers konfiguration af printere.

      Denne politik er en tilføjelse til <ph name="BULK_PRINTERS_POLICY" />.

      Hvis denne politik ikke er angivet, er der ingen printere for enhederne, og andre politikker af typen <ph name="DEVICE_PRINTERS_POLICY_PATTERN" /> ignoreres.
      </translation>
<translation id="193259052151668190">Hvidliste over USB-enheder, der kan frigøres</translation>
<translation id="1933378685401357864">Baggrundsbillede</translation>
<translation id="1956493342242507974">Konfigurer strømstyring på loginskærmen i <ph name="PRODUCT_OS_NAME" />.

      Med denne politik kan du konfigurere, hvordan <ph name="PRODUCT_OS_NAME" /> reagerer, når der ikke har været brugeraktivitet i et stykke tid, mens loginskærmen vises. Politikken styrer flere indstillinger. Se de tilsvarende politikker, som styrer strømstyring i en session, for individuelle semantik- og værdiområder. De eneste afvigelser fra disse politikker er:
      * Handlingerne ved inaktivitet eller ved lukning må ikke være at afslutte sessionen.
      * Standardhandlingen ved inaktivitet under kørsel på vekselstrøm er at lukke ned.

      Hvis en indstilling ikke er specificeret, anvendes en standardværdi.

      Hvis denne politik ikke er indstillet, anvendes standarder for alle indstillinger.</translation>
<translation id="1958138414749279167">Aktiverer funktionen AutoFyld for <ph name="PRODUCT_NAME" /> og giver brugerne mulighed for automatisk at udfylde webformularer med adresseoplysninger, der er gemt tidligere.

      Hvis denne indstilling er deaktiveret, foreslår eller udfylder AutoFyld aldrig adresseoplysninger, og der gemmes heller ikke yderligere adresseoplysninger, som brugeren muligvis indsender, når vedkommende er på nettet.

      Hvis denne indstilling er aktiveret eller ikke har nogen værdi, kan brugeren administrere den overordnede AutoFyld-funktion for adresser i brugerfladen.</translation>
<translation id="1960840544413786116">Hvorvidt der skal gives tilladelse til certifikater, som er udstedt af lokale tillidsankre og mangler udvidelsen subjectAlternativeName</translation>
<translation id="1962273523772270623">Tillad indsamling af WebRTC-hændelseslogfiler fra Google-tjenester</translation>
<translation id="1964634611280150550">Inkognitotilstand er deaktiveret</translation>
<translation id="1964802606569741174">Denne politik påvirker ikke YouTube-appen til Android. Hvis Beskyttet tilstand på YouTube skal håndhæves, skal installation af YouTube-appen til Android ikke tillades.</translation>
<translation id="1969212217917526199">Tilsidesætter politikker i fejlfindingsbuilds for hosten for fjernadgang.

          Værdien parses som en JSON-ordbog for politikkens navn til politikkens værditilknytninger.</translation>
<translation id="1969808853498848952">Kør altid plugins, der kræver godkendelse (udfaset)</translation>
<translation id="1988371335297483117">Automatisk opdaterede nyttedata i <ph name="PRODUCT_OS_NAME" /> kan downloades via HTTP i stedet for HTTPS. Dette giver mulighed for åben HTTP-caching af HTTP-downloads.

      Hvis denne politik er angivet til Sand, vil <ph name="PRODUCT_OS_NAME" /> forsøge at downloade automatisk opdaterede nyttedata via HTTP. Hvis politikken er angivet til Falsk eller ikke er angivet, anvendes HTTPS til at downloade automatisk opdaterede nyttedata.</translation>
<translation id="199764499252435679">Aktivér komponentopdateringer i <ph name="PRODUCT_NAME" /></translation>
<translation id="2006530844219044261">Strømstyring</translation>
<translation id="2014757022750736514">Styrer adfærden for den loginskærm, hvor brugerne logger ind på deres konti. Indstillingerne omfatter, hvem der kan logge ind, hvilke typer konti der tillades, hvilke godkendelsesmetoder der må anvendes, samt generelle hjælpefunktioner, indtastningsmetode og lokale indstillinger.</translation>
<translation id="201557587962247231">Hyppighed for upload af rapporter om enhedsstatus</translation>
<translation id="2017301949684549118">Webadresser til webapps skal installeres uovervåget.</translation>
<translation id="2018836497795982119">Angiver den periode i millisekunder, hvor enhedsadministrationstjenesten anmodes om brugerpolitikoplysninger.

      Angivelse af denne politik tilsidesætter standardværdien på tre timer. Gyldige værdier for denne politik ligger i intervallet fra 1800000 (30 minutter) til 86400000 (ét døgn). Alle værdier, der ikke ligger inden for dette interval, fastgøres til den respektive grænse. Hvis platformen understøtter notifikationer vedrørende politik, angives forsinkelsen af opdateringen til 24 timer, da det forventes, at notifikationer vedrørende politik automatisk gennemtvinger en opdatering, når politikken ændres.

      Hvis denne politik ikke angives, bruger <ph name="PRODUCT_NAME" /> standardværdien på tre timer.

      Bemærk! Hvis platformen understøtter notifikationer vedrørende politik, angives forsinkelsen af opdateringen til 24 timer (der ses bort fra alle standardindstillingerne og værdierne for denne politik), da det forventes, at notifikationer vedrørende politik automatisk gennemtvinger en opdatering, når politikken ændres. Dermed er hyppige opdateringer ikke nødvendige.</translation>
<translation id="2024149678078029009">Denne politik styrer den kommando, der skal bruges til at åbne webadresser i <ph name="PRODUCT_NAME" />, når der skiftes fra Internet Explorer.

      Hvis Internet Explorer-tilføjelsen "Emulator til ældre websites" ikke er installeret, har denne politik ingen effekt.

      Hvis politikken ikke er konfigureret, registrerer Internet Explorer automatisk den eksekverbare stil, der tilhører <ph name="PRODUCT_NAME" />, når <ph name="PRODUCT_NAME" /> åbnes via Internet Explorer.

      Når politikken er konfigureret, anvendes den til at åbne <ph name="PRODUCT_NAME" />, når åbningen af <ph name="PRODUCT_NAME" /> via Internet Explorer skiftes til en anden browser.

      Politikken kan angives som en eksekverbar filsti eller ${chrome} for automatisk at registrere, hvor Chrome er installeret.</translation>
<translation id="2024476116966025075">Konfigurer det påkrævede domænenavn for klienter med fjernadgang</translation>
<translation id="2030905906517501646">Søgeord til standardsøgemaskine</translation>
<translation id="203096360153626918">Denne politik påvirker ikke Android-apps. De kan åbnes i fuldskærmstilstand, selv hvis denne politik angives som <ph name="FALSE" />.</translation>
<translation id="2043770014371753404">Deaktiverede virksomhedsprintere</translation>
<translation id="2057317273526988987">Giv adgang til en liste over webadresser</translation>
<translation id="206623763829450685">Angiver, hvilke skemaer for HTTP-godkendelse der understøttes af <ph name="PRODUCT_NAME" />.

          Mulige værdier er "grundlæggende", "sammenfatning", "NTLM" og "forhandling". Flere værdier adskilles med kommaer.

          Hvis denne politik ikke er angivet, anvendes alle fire skemaer.</translation>
<translation id="2067011586099792101">Bloker adgangen til websites uden for indholdspakker</translation>
<translation id="2073552873076775140">Tillad login på <ph name="PRODUCT_NAME" /></translation>
<translation id="2077129598763517140">Brug hardwareacceleration, når det er muligt</translation>
<translation id="2077273864382355561">Skærmslukforsinkelse, når batteriet bruges</translation>
<translation id="2082205219176343977">Konfigurer den Chrome-version, der som minimum påkræves for enheden.</translation>
<translation id="209586405398070749">Stabil kanal</translation>
<translation id="2098658257603918882">Aktiver rapportering af brugs- og nedbrudsrelaterede data</translation>
<translation id="2104418465060359056">Rapportér oplysninger om udvidelser og plugins</translation>
<translation id="2106627642643925514">Tilsidesætter standardtilstanden for udskrivning med pinkode Hvis tilstanden ikke er tilgængelig, ignoreres politikken.</translation>
<translation id="2107601598727098402">
        Denne politik er udfaset i M72. Brug CloudManagementEnrollmentToken i stedet.
        </translation>
<translation id="2111016292707172233">Aktiverer tilgængeligheden af funktionen "Tryk for at søge" i indholdsvisningen i <ph name="PRODUCT_NAME" />.

      Hvis du aktiverer denne indstilling, er "Tryk for at søge" tilgængelig for brugerne, og de kan vælge at slå funktionen til eller fra.

      Hvis du deaktiverer denne indstilling, deaktiveres "Tryk for at søge" fuldstændigt.

      Hvis politikken ikke angives, svarer det til, at den er aktiveret som i beskrivelsen ovenfor.</translation>
<translation id="2113068765175018713">Begræns oppetid for enheden vha. automatisk genstart</translation>
<translation id="2116790137063002724">Denne politik styrer, om der skal rapporteres oplysninger, der kan bruges til at identificere brugere, f.eks. login i OS, login på <ph name="PRODUCT_NAME" />-profil, <ph name="PRODUCT_NAME" />-profilnavn, <ph name="PRODUCT_NAME" />-profilsti og eksekverbar sti i <ph name="PRODUCT_NAME" />.

      Når denne politik ikke er angivet eller er angivet som Sand, indhentes der oplysninger, der kan bruges til at identificere brugere.
      Når denne politik er angivet som Falsk, indhentes der ikke oplysninger, der kan bruges til at identificere brugere.

      Denne politik gælder kun, når <ph name="CHROME_REPORTING_EXTENSION_NAME" /> er aktiveret, og maskinen er tilmeldt <ph name="MACHINE_LEVEL_USER_CLOUD_POLICY_ENROLLMENT_TOKEN_POLICY_NAME" />.</translation>
<translation id="2126178089984117495">Begrænser tilstanden for udskrivning med pinkode En politik uden konfiguration behandles som ingen begrænsning. Hvis tilstanden ikke er tilgængelig, ignoreres politikken.</translation>
<translation id="2127599828444728326">Tillad notifikationer på disse websites</translation>
<translation id="2131902621292742709">Skærmnedtoningsforsinkelse, når batteriet bruges</translation>
<translation id="2134437727173969994">Tillad låsning af skærmen</translation>
<translation id="2137064848866899664">Hvis denne politik er angivet, roteres hver visning i den
      angivne retning ved hver genstart og første gang, der oprettes forbindelse,
      efter politikkens værdi ændres. Brugere kan ændre visningens
      rotation via siden med indstillinger, når de er logget ind, men deres
      indstilling tilsidesættes af politikkens værdi ved næste genstart.

      Denne politik gælder for både den primære visning og den sekundære visning.

      Hvis politikken ikke er angivet, er standardværdien 0 grader, og brugere
      kan frit ændre den. I dette tilfælde genanvendes værdien ikke
      ved genstart.</translation>
<translation id="214901426630414675">Begræns udskrivning i duplex-tilstand</translation>
<translation id="2149330464730004005">Aktivér farveudskrivning</translation>
<translation id="2156132677421487971">Konfigurer politikker for <ph name="PRODUCT_NAME" />, som er en funktion, der giver brugerne mulighed for at sende indholdet af faner, websites eller skrivebordet fra browseren til eksterne skærme og lydsystemer.</translation>
<translation id="2166472654199325139">Filtrér ikke voksenindhold fra på websites</translation>
<translation id="2168397434410358693">Inaktivitetsforsinkelse, når strømforsyningen er tilsluttet</translation>
<translation id="217013996107840632">Kommandolinjeparametre til at skifte fra den alternative browser.</translation>
<translation id="2170233653554726857">Aktivér WPAD-optimering</translation>
<translation id="2176565653304920879">Når denne politik er indstillet, fungerer flowet for registrering af tidszoner på en af de følgende måder, alt efter hvilken værdi der bruges i indstillingen:

      Hvis der er indstillet til TimezoneAutomaticDetectionUsersDecide, kan brugerne kontrollere den automatiske registrering af tidszoner med de almindelige kontrolelementer i chrome://settings.

      Hvis der er indstillet til TimezoneAutomaticDetectionDisabled, bliver de automatiske kontrolelementer for tidszoner i chrome://settings deaktiveret. Automatisk registrering af tidszoner vil altid være deaktiveret.

      Hvis der er indstillet til TimezoneAutomaticDetectionIPOnly, bliver kontrolelementerne for tidszone i chrome://settings deaktiveret. Automatisk registrering af tidszoner vil altid være aktiveret. Registreringen af tidszoner bruger udelukkende IP-metoden til at fastlægge placeringen.

      Hvis der indstilles til TimezoneAutomaticDetectionSendWiFiAccessPoints, bliver kontrolelementerne for tidszoner i chrome://settings deaktiveret. Automatisk registrering af tidszoner vil altid være aktiveret. Listen over synlige Wi-Fi-adgangspunkter sendes altid til Geolocation API-serveren, så der kan foretages detaljeret registrering af tidszoner.

      Hvis der indstilles til TimezoneAutomaticDetectionSendAllLocationInfo, bliver kontrolelementerne for tidszoner i chrome://settings deaktiveret. Automatisk registrering af tidszoner vil altid være aktiveret. Placeringsinfo (som f.eks. Wi-Fi-adgangspunkter, tilgængelige mobiltårne, GPS) bliver sendt til en server, så der kan foretages detaljeret registrering af tidszoner.

      Hvis politikken ikke indstilles, svarer det til, at TimezoneAutomaticDetectionUsersDecide er indstillet.

      Hvis politikken SystemTimezone indstilles, tilsidesættes denne politik. I dette tilfælde deaktiveres registrering af tidszoner helt.</translation>
<translation id="2178899310296064282">Gennemtving som minimum Moderat begrænset tilstand på YouTube</translation>
<translation id="2182291258410176649">Brugeren beslutter, om sikkerhedskopiering og gendannelse skal aktiveres</translation>
<translation id="2183294522275408937">Denne indstilling styrer, hvor ofte låseskærmen kræver, at adgangskoden angives for at fortsætte med at bruge hurtig oplåsning. Når du går ind på låseskærmen, vil hurtig oplåsning ikke være tilgængelig, hvis den seneste adgang med adgangskode overskrider denne indstilling. Hvis brugeren bliver på låseskærmen ud over det angivne tidsrum, anmodes der om en adgangskode, næste gang brugeren indtaster den forkerte kode eller går ind på låseskærmen, alt efter hvad der kommer først.

      Hvis denne indstilling er konfigureret, bliver brugere, der anvender hurtig oplåsning, anmodet om at indtaste deres adgangskode på låseskærmen afhængigt af denne indstilling.

      Hvis denne indstilling ikke er konfigureret, bliver brugere, der anvender hurtig oplåsning, anmodet om at indtaste deres adgangskode på låseskærmen hver dag.</translation>
<translation id="2194470398825717446">Denne politik er udfaset i M61. Brug EcryptfsMigrationStrategy i stedet.

      Angiver, hvordan en enhed skal opføre sig, hvis den blev leveret med ecryptfs-kryptering og skal skifte til ext4-kryptering.

      Hvis du indstiller denne politik til "DisallowArc", deaktiveres Android-apps for alle brugere på enheden (inklusive dem, der allerede har ext4-kryptering), og der tilbydes ikke migrering fra ecryptfs- til ext4-kryptering til nogen brugere.

      Hvis du indstiller denne politik til "AllowMigration", bliver brugere med ecryptfs-hovedmapper tilbudt at migrere disse til ext4-kryptering, hvor det er nødvendigt (i øjeblikket når Android N bliver tilgængeligt på enheden).

      Denne politik gælder ikke for terminalapps – disse migreres automatisk. Hvis denne politik endnu ikke er angivet, opfører enheden sig, som om "DisallowArc" er valgt.</translation>
<translation id="2195032660890227692">Denne politik er blevet fjernet i <ph name="PRODUCT_NAME" /> 68 og erstattet af <ph name="ARC_BR_POLICY_NAME" />.</translation>
<translation id="2201555246697292490">Konfigurer hvidlisten for indbyggede beskedhosts</translation>
<translation id="2204753382813641270">Administrer, hvornår hylden skjules automatisk</translation>
<translation id="2208976000652006649">Parametre for søgewebadresse, som anvender POST</translation>
<translation id="2214880135980649323">Når denne politik er aktiveret, har udvidelser, der er installeret via en virksomhedspolitik, tilladelse til at bruge Enterprise Hardware Platform API.
      Når denne politik er deaktiveret eller ikke angivet, har ingen udvidelser tilladelse til at bruge Enterprise Hardware Platform API.
      Denne politik gælder også for komponentudvidelser som f.eks. udvidelsen Hangout Services.</translation>
<translation id="2223598546285729819">Standardindstilling for notifikationer</translation>
<translation id="2231817271680715693">Import af browseroversigt fra standardbrowser ved første visning</translation>
<translation id="2236488539271255289">Tillad ikke, at websites angiver lokale data</translation>
<translation id="2240879329269430151">Giver dig mulighed for at bestemme, om websites må vise pop op-vinduer. Visning af pop op-vinduer kan enten være tilladt for alle websites eller nægtet for alle websites. Hvis denne politik ikke angives, anvendes "BlockPopups", og brugeren vil kunne ændre den.</translation>
<translation id="2269319728625047531">Aktivér visning af samtykke til synkronisering under login</translation>
<translation id="2274864612594831715">Denne politik konfigurerer aktiveringen af det virtuelle tastatur som inputenhed i ChromeOS. Brugere kan ikke tilsidesætte denne politik.

      Hvis politikken er angivet som Sand, vil det virtuelle tastatur på skærmen altid være aktiveret.

      Hvis den er angivet som Falsk, vil det virtuelle tastatur på skærmen altid være deaktiveret.

      Hvis du har indstillet denne politik, kan brugere ikke ændre eller tilsidesætte den. Brugere kan dog stadig aktivere/deaktivere et skærmtastatur som hjælpefunktion, som har forrang over det virtuelle tastatur, der kontrolleres af denne politik. Se mere om kontrol af skærmtastaturet som hjælpefunktion i politikken |VirtualKeyboardEnabled|.

      Hvis denne politik ikke indstilles, er tastaturet på skærmen slået fra til at starte med, men kan til enhver tid aktiveres af brugeren. Der kan også benyttes heuristiske regler til at bestemme, hvornår tastaturet skal vises.</translation>
<translation id="228659285074633994">Angiver den tidsperiode uden brugerindtastning, hvorefter en dialogboks med en advarsel vises, når enheden bruger strømforsyningen

          Når denne politik er indstillet, angives den tidsperiode, i hvilken brugeren ikke er aktiv, hvorefter <ph name="PRODUCT_OS_NAME" /> viser en dialogboks med en advarsel, der informerer brugeren om, at der vil blive reageret på denne inaktivitet..

          Når denne politik ikke er indstillet, vises der ingen dialogboks med en advarsel.

          Værdien for politikken aktiveres inden for millisekunder. Værdierne er låste til mindre end eller det samme som inaktivitetsforsinkelsen.</translation>
<translation id="2292084646366244343"><ph name="PRODUCT_NAME" /> kan anvende Googles webtjeneste til at rette stavefejl. Hvis denne indstilling er aktiveret, bruges denne tjeneste altid. Hvis indstillingen er deaktiveret, bruges tjenesten aldrig.

      Stavekontrol kan stadig udføres ved hjælp af den downloadede ordbog. Denne politik kontrollerer kun brugen af onlinetjenesten.

      Hvis denne indstilling ikke er konfigureret, kan brugerne vælge, om stavekontrol skal aktiveres eller ej.</translation>
<translation id="2294283832646774959">Konfigurerer en liste over printere.

      Denne politik giver administratorer mulighed for at angive printerkonfigurationer
      for deres brugere.

      <ph name="PRINTER_DISPLAY_NAME" /> og <ph name="PRINTER_DESCRIPTION" /> er strenge i frit format, der kan tilpasses, så valg af printer bliver nemmere. <ph name="PRINTER_MANUFACTURER" /> og <ph name="PRINTER_MODEL" /> gør det nemmere for slutbrugerne at identificere printere. De repræsenterer printerproducenten og -modellen. <ph name="PRINTER_URI" /> skal være en adresse, der er tilgængelig fra en klientcomputer, bl.a. <ph name="URI_SCHEME" />, <ph name="URI_PORT" /> og <ph name="URI_QUEUE" />. <ph name="PRINTER_UUID" /> er valgfri. Hvis den angives, bruges den som en hjælp til at deduplikere <ph name="ZEROCONF_DISCOVERY" />-printere.

      <ph name="PRINTER_EFFECTIVE_MODEL" /> skal stemme overens med en af de strenge, der repræsenterer en <ph name="PRODUCT_NAME" />-understøttet printer. Strengen bruges til at identificere og installere den relevante PPD-fil til printeren. Du kan finde flere oplysninger på https://support.google.com/chrome?p=noncloudprint.

      Printerkonfigurationen fuldføres, første gang printeren tages i brug.  PPD-filer downloades ikke, før printeren benyttes.  Derefter gemmes ofte anvendte PPD-filer i cachen.

      Denne politik påvirker ikke, om brugerne kan konfigurere printere på individuelle enheder.  Den er beregnet til at fungere som supplement til den enkelte brugers konfiguration af printere.

      For enheder, der administreres med Active Directory, understøtter denne politik udvidelse af <ph name="MACHINE_NAME_VARIABLE" /> til Active Directory-enhedsnavnet eller en af dets understrenge. Hvis enhedsnavnet f.eks. er <ph name="MACHINE_NAME_EXAMPLE" />, erstattes <ph name="MACHINE_NAME_VARIABLE_EXAMPLE" /> af de fire tegn, der kommer efter den sjette position, dvs. <ph name="MACHINE_NAME_PART_EXAMPLE" />. Bemærk! Positionen er nulbaseret.
      </translation>
<translation id="2294382669900758280">Videoafspilning i Android-apps tages ikke med i betragtning, selv hvis denne politik angives som <ph name="TRUE" />.</translation>
<translation id="2298647742290373702">Konfigurer standardsiden Ny fane i <ph name="PRODUCT_NAME" />.</translation>
<translation id="2299220924812062390">Angiv en liste over aktiverede plugins</translation>
<translation id="2303795211377219696">Aktivér AutoFyld for betalingskort</translation>
<translation id="2309390639296060546">Standardindstilling for geoplacering</translation>
<translation id="2312134445771258233">Giver dig mulighed for at konfigurere de sider, der indlæses ved opstart. Indholdet af listen "Webadresser, der skal åbnes ved opstart" ignoreres, medmindre du vælger "Åbn en liste over webadresser" i "Handling ved opstart".</translation>
<translation id="2327252517317514801">Definer domæner, der har adgang til G Suite</translation>
<translation id="237494535617297575">Giver dig mulighed for at oprette en liste over webadressemønstre, der angiver websites, der må vise notifikationer. Hvis denne politik ikke angives, anvendes den globale standardværdi på alle websites, enten fra politikken "DefaultNotificationsSetting", hvis den er indstillet, eller brugerens personlige konfiguration.</translation>
<translation id="2386362615870139244">Tillad aktiveringslås af skærm</translation>
<translation id="2411817661175306360">Advarsler via adgangskodebeskyttelse er slået fra</translation>
<translation id="2411919772666155530">Bloker notifikationer på disse websites</translation>
<translation id="2418507228189425036">Deaktiverer lagring af browserhistorik i <ph name="PRODUCT_NAME" /> og forhindrer brugerne i at ændre denne indstilling.

     Hvis denne indstilling er aktiveret, gemmes browserhistorikken ikke. Denne indstilling deaktiverer også synkronisering af faner.

      Hvis denne indstilling er deaktiveret eller ikke konfigureret, gemmes browserhistorikken.</translation>
<translation id="2426782419955104525">Aktiverer Direkte-funktionen i <ph name="PRODUCT_NAME" /> og forhindrer brugerne i at ændre denne indstilling.

      Hvis du aktiverer denne indstilling, aktiveres <ph name="PRODUCT_NAME" /> Direkte.

      Hvis du deaktiverer denne indstilling, deaktiveres <ph name="PRODUCT_NAME" /> Direkte.

      Hvis du aktiverer eller deaktiverer denne indstilling, kan brugerne hverken ændre eller tilsidesætte denne indstilling.

      Hvis denne indstilling ikke konfigureres, kan brugeren bestemme, om denne funktion skal anvendes eller ej.

      Denne indstilling er fjernet fra <ph name="PRODUCT_NAME" />-version 29 og nyere.</translation>
<translation id="2433412232489478893">Denne politik styrer, om fildelingsfunktionen via netværk for <ph name="PRODUCT_NAME" /> er tilladt for en bruger.

      Når denne politik ikke er konfigureret eller er angivet som sand, kan brugerne anvende fildeling via netværk.

      Når denne politik er angivet som falsk, kan brugerne ikke anvende fildeling via netværk.</translation>
<translation id="2438609638493026652">Aktivér rapportering af vigtige hændelser under Android-appinstallation til Google. Hændelser registreres kun i forbindelse med apps, hvis installation blev aktiveret via en politik.

      Hvis politikken er angivet som sand, logføres hændelser.
      Hvis politikken er angivet som falsk eller ikke er angivet, logføres hændelser ikke.</translation>
<translation id="244317009688098048">Aktivér nødtastaturgenvej til automatisk login.

      Hvis denne politik ikke er angivet eller er angivet til Sand, og en lokal konto på enheden er konfigureret til ingen forsinkelse ved automatisk login, indfrier <ph name="PRODUCT_OS_NAME" /> tastaturgenvejen Ctrl+Alt+S til at omgå automatisk login og visning af loginskærmen.

      Hvis denne politik er angivet til Falsk, kan ingen forsinkelse ved automatisk login (hvis det er konfigureret) ikke omgås.</translation>
<translation id="2454228136871844693">Optimer for at forbedre stabiliteten.</translation>
<translation id="2463365186486772703">Landestandard for applikationen</translation>
<translation id="2466131534462628618">Captive portal-godkendelse ignorerer proxy</translation>
<translation id="2482676533225429905">Indbyggede beskedhosts</translation>
<translation id="2483146640187052324">Forudse netværkshandlinger på enhver netværksforbindelse</translation>
<translation id="2484208301968418871">Denne politik styrer anvendelsen af webadressefilteret for SafeSites.
      Dette filter anvender Google Safe Search API til at klassificere, om webadresser indeholder pornografisk indhold eller ej.

      Når denne politik ikke er konfigureret eller er angivet som "Filtrér ikke voksenindhold fra på websites", filtreres de pågældende websites ikke fra.

      Når denne politik er angivet til "Filtrér voksenindhold fra på websites på øverste niveau", klassificeres disse websites som pornografiske og filtreres fra.</translation>
<translation id="2486371469462493753">Deaktiverer håndhævelse af krav vedrørende Certifikatsgennemsigtighed for de angivne webadresser.

      Denne politik tillader, at certifikater til hostnames i de angivne webadresser ikke fremvises via Certifikatsgennemsigtighed. Dette tillader, at certifikater, der ellers ville være usikre, fordi de ikke blev fremvist korrekt offentligt, fortsat kan bruges. Det gør det dog sværere at registrere certifikater, der er udstedt ved en fejl, for disse hosts.

      Et webadressemønster formateres i overensstemmelse med https://www.chromium.org/administrators/url-blacklist-filter-format. Da certifikater er gyldige for et givent hostname uafhængigt af ordningen, porten eller stien, er det dog kun hostnamedelen af webadressen, der tages i betragtning. Hosts for jokertegn understøttes ikke.

      Hvis denne politik ikke angives, behandles certifikater, der skal fremvises via Certifikatsgennemsigtighed, som usikre, hvis de ikke fremvises i overensstemmelse med politikken for Certifikatsgennemsigtighed.</translation>
<translation id="2488010520405124654">Aktivér meddelelse om netværkskonfiguration, når du er offline. 

      Hvis denne politik er deaktiveret eller indstillet til True, en enhedslokal konto er konfigureret til automatisk login med nul-forsinkelse og enheden ikke har adgang til internettet, viser <ph name="PRODUCT_OS_NAME" /> en meddelelse om netværkskonfiguration.

      Hvis denne politik er indstillet til False, vises en fejlmeddelelse i stedet for meddelelsen om netværkskonfiguration.</translation>
<translation id="2498238926436517902">Skjul altid hylden automatisk</translation>
<translation id="2514328368635166290">Angiver den foretrukne ikonwebadressen for standardsøgemaskinen. Denne politik er valgfri. Hvis den ikke er angivet, vises der ikke noget ikon for søgeudbyderen. Denne politik respekteres kun, hvis politikken "DefaultSearchProviderEnabled" er aktiveret.</translation>
<translation id="2516600974234263142">Aktiverer udskrivning i <ph name="PRODUCT_NAME" /> og forhindrer, at brugerne kan ændre denne indstilling.

      Hvis denne indstilling er aktiveret eller ikke er konfigureret, kan brugerne udskrive.

      Hvis denne indstilling er deaktiveret, kan brugerne ikke udskrive fra <ph name="PRODUCT_NAME" />. Udskrivning deaktiveres i skruenøglemenuen, udvidelser, JavaScript-apps osv. Det er stadig muligt at udskrive fra plugins, der omgår <ph name="PRODUCT_NAME" /> under udskrivning. For eksempel har visse Flash-apps mulighed for udskrivning i deres genvejsmenu, og denne deaktiveres ikke.</translation>
<translation id="2518231489509538392">Tillad afspilning af lyd</translation>
<translation id="2521581787935130926">Vis genvej til apps i bogmærkelinjen</translation>
<translation id="2529659024053332711">Giver dig mulighed for at angive adfærd ved opstart.

          Hvis du vælger "Åbn siden Ny fane", åbnes siden Ny fane altid, når du starter <ph name="PRODUCT_NAME" />.

          Hvis du vælger "Gendan sidste session", genåbnes de webadresser, der var åbne sidste gang, hvor <ph name="PRODUCT_NAME" /> blev lukket, og browsersessionen gendannes, sådan som den blev efterladt.
          Hvis du vælger denne mulighed, deaktiveres nogle af de indstillinger, der benytter sig af sessioner, eller som udfører handlinger ved nedlukning (f.eks. Ryd browserdata ved nedlukning og sessioncookies).

          Hvis du vælger "Åbn en liste med webadresser", åbnes listen med "webadresser, der skal åbnes ved opstart", når brugeren starter <ph name="PRODUCT_NAME" />.

          Hvis du aktiverer denne indstilling, kan brugerne ikke ændre eller tilsidesætte den i <ph name="PRODUCT_NAME" />.

          Deaktivering af denne indstilling er det samme som ikke at konfigurere den. Brugeren kan stadig ændre den i <ph name="PRODUCT_NAME" />.

          Denne politik er kun tilgængelig for Windows-forekomster, der er knyttet til et <ph name="MS_AD_NAME" />-domæne eller Windows 10 Pro- eller Enterprise-forekomster, der er tilmeldt administration af enheder.</translation>
<translation id="2529880111512635313">Konfigurer listen over udvidelser og apps med tvungen installation</translation>
<translation id="253135976343875019">Advarsel om inaktivitetsforsinkelse, når strømforsyningen er tilsluttet</translation>
<translation id="2536525645274582300">Brugeren beslutter, om Googles placeringstjenester skal aktiveres</translation>
<translation id="254653220329944566">Aktiverer <ph name="PRODUCT_NAME" />-rapportering i skyen</translation>
<translation id="2548572254685798999">Rapportér oplysninger om Beskyttet browsing</translation>
<translation id="2550593661567988768">Kun simplex-udskrivning</translation>
<translation id="2552966063069741410">Tidszone</translation>
<translation id="2562339630163277285">Angiver webadressen for den søgemaskine, der bruges til at give direkte resultater. Webadressen skal indeholde strengen <ph name="SEARCH_TERM_MARKER" />, som på forespørgselstidspunktet erstattes af den tekst, som brugeren har indtastet hidtil.

          Denne politik er valgfri. Hvis den ikke angives, gives der ikke direkte søgeresultater.

          Webadressen for Googles direkte søgeresultater kan angives som: <ph name="GOOGLE_INSTANT_SEARCH_URL" />.

          Denne politik respekteres kun, hvis politikken "DefaultSearchProviderEnabled" er aktiveret.</translation>
<translation id="2569647487017692047">Hvis denne politik angives som falsk, deaktiverer <ph name="PRODUCT_OS_NAME" /> Bluetooth, og brugeren kan ikke aktivere det igen.

      Hvis denne politik er angivet som sand eller ikke er indstillet, kan brugeren aktivere og deaktivere Bluetooth efter forgodtbefindende.

      Hvis denne politik er angivet, kan brugeren ikke ændre eller tilsidesætte den.

      Når Bluetooth er aktiveret, skal brugeren logge ud og ind igen, før ændringerne kan træde i kraft (dette er ikke nødvendigt, når Bluetooth deaktiveres).</translation>
<translation id="2571066091915960923">Aktivér eller deaktiver proxyen til datakomprimering for at forhindre brugerne i at ændre denne indstilling.

      Hvis du aktiverer eller deaktiverer denne indstilling, kan brugerne ikke ændre eller tilsidesætte indstillingen.

      Hvis denne politik ikke er angivet, vil proxyfunktionen til datakomprimering være tilgængelig for brugeren.</translation>
<translation id="2587719089023392205">Angiv <ph name="PRODUCT_NAME" /> som standardbrowser</translation>
<translation id="2592091433672667839">Varighed af inaktivitet, før pauseskærmen vises på loginskærmen i detailtilstand</translation>
<translation id="2596260130957832043">Styrer, om NTLMv2 aktiveres.

          Alle nye versioner af Samba- og Windows-servere understøtter NTLMv2. Politikken bør kun deaktiveres for bagudrettet kompatibilitet, og den reducerer sikkerheden ved godkendelse.

          Hvis politikken ikke er angivet, indstilles den som standard til Sand, og NTLMv2 aktiveres.</translation>
<translation id="2604182581880595781">Konfigurer politikker for fildeling via netværk.</translation>
<translation id="2623014935069176671">Vent på første aktivitet fra brugeren</translation>
<translation id="262740370354162807">Aktiver indsendelse af dokumenter til <ph name="CLOUD_PRINT_NAME" /></translation>
<translation id="2627554163382448569">Angiver konfigurationer af virksomhedsprintere.

      Denne politik giver dig mulighed for at angive printerkonfigurationer for <ph name="PRODUCT_OS_NAME" />-enheder.  Formatet er det samme som for NativePrinters-ordbogen, men for hver printer er der et yderligere påkrævet felt for "id" eller "guid" til hvidlister og sortlister.

      Filen må ikke være større end 5 MB, og den skal indkodes i JSON.  En fil med ca. 21.000 printere forventes at indkode som en fil på 5 MB.  Den kryptografiske nøgletransformation bruges til at bekræfte downloadens integritet.

      Filen downloades og gemmes i cachen. Den downloades igen, hver gang webadressen eller nøgletransformationen ændres.

      Hvis denne politik er angivet, vil <ph name="PRODUCT_OS_NAME" /> downloade filen til printerkonfigurationer og gøre printere tilgængelige i overensstemmelse med <ph name="BULK_PRINTERS_ACCESS_MODE" />, <ph name="BULK_PRINTERS_WHITELIST" /> og <ph name="BULK_PRINTERS_BLACKLIST" />.

      Hvis du angiver denne politik, kan brugerne ikke ændre eller tilsidesætte den.

      Denne politik påvirker ikke, om brugerne kan konfigurere printere på individuelle enheder.  Den er beregnet til at fungere som supplement til den enkelte brugers konfiguration af printere.
      </translation>
<translation id="2633084400146331575">Aktivér talefeedback</translation>
<translation id="2646290749315461919">Giver dig mulighed for at angive, om websites skal have tilladelse til at spore brugernes fysiske placering. Sporing af brugernes fysiske placering kan tillades som standard, nægtes som standard, eller brugeren kan blive spurgt, hver gang et website anmoder om den fysiske placering. Hvis denne politik ikke angives, anvendes "AskGeolocation", og brugeren vil kunne ændre den.</translation>
<translation id="2647069081229792812">Aktivér eller deaktiver redigering af bogmærker</translation>
<translation id="2650049181907741121">Handling, der skal udføres, når brugeren slår skærmen ned</translation>
<translation id="2655233147335439767">Angiver webadressen for den søgemaskine, der bruges ved standardsøgninger. Webadressen skal indeholde strengen "<ph name="SEARCH_TERM_MARKER" />", som på forespørgselstidspunktet erstattes af søgeord, når brugeren foretager en søgning.

          Googles søgewebadresse kan angives som: <ph name="GOOGLE_SEARCH_URL" />.

          Denne indstilling skal aktiveres, når politikken "DefaultSearchProviderEnabled" er aktiveret, og den vil kun blive respekteret, hvis dette er tilfældet.</translation>
<translation id="2659019163577049044">Hvis denne indstilling aktiveres, kan brugerne konfigurere deres enheder til at synkronisere sms-beskeder mellem deres telefoner og Chromebooks. Bemærk! Hvis denne politik tillades, skal brugerne udtrykkeligt tilmelde sig denne funktion ved at gennemføre en konfiguration. Når konfigurationen er gennemført, kan brugerne sende og modtage sms-beskeder på deres Chromebooks.

      Hvis denne indstilling deaktiveres, kan brugerne ikke konfigurere synkronisering af sms-beskeder.

      Hvis politikken ikke konfigureres, tillades den som standard ikke for administrerede brugere, mens den som standard tillades for ikke-administrerede brugere.</translation>
<translation id="2660846099862559570">Brug aldrig en proxy</translation>
<translation id="2663739737868438950">
      Politikken gælder for loginskærmen. Se også politikken <ph name="SITE_PER_PROCESS_POLICY_NAME" />, som gælder for brugersessionen. Det anbefales, at der angives den samme værdi for begge politikker. Hvis politikkerne har forskellige værdier, kan der ske forsinkelser ved opstart af en brugersession, mens den værdi, der er angivet af brugerpolitikken, anvendes.
      Det er en god idé at kigge på politikindstillingen IsolateOrigins for at få det bedste fra begge verdener (isolering og begrænset indvirkning på brugerne) ved at bruge IsolateOrigins sammen med en liste over de websites, du vil isolere. Denne indstilling, SitePerProcess, isolerer alle websites.
      Hvis politikken er aktiveret, kører hvert website sin egen proces.
      Hvis politikken er deaktiveret, deaktiveres begge funktionerne IsolateOrigins og SitePerProcess. Brugere kan stadig aktivere SitePerProcess manuelt via kommandolinjerapportering.
      Hvis politikken ikke konfigureres, kan brugerne ændre denne indstilling.
      </translation>
<translation id="2672012807430078509">Styrer aktivering af NTLM som en godkendelsesprotokol for anvendelse af SMB</translation>
<translation id="267596348720209223">Angiver tegnkodninger, der understøttes af søgemaskinen. Kodninger er tegntabelnavne såsom UTF-8, GB2312, og ISO-8859-1. De afprøves i den angivne rækkefølge. Denne politik er valgfri. Hvis den ikke er angivet, anvendes standarden, UTF-8. Denne politik respekteres kun, hvis politikken "DefaultSearchProviderEnabled" er aktiveret.</translation>
<translation id="268577405881275241">Aktivér proxyfunktionen for datakomprimering</translation>
<translation id="2693108589792503178">Konfigurer webadressen til ændring af adgangskoder.</translation>
<translation id="2706708761587205154">Tillad kun udskrivning med pinkode</translation>
<translation id="2731627323327011390">Deaktiver brug af certifikater i <ph name="PRODUCT_OS_NAME" /> til ARC-apps</translation>
<translation id="2742843273354638707">Skjul appen Chrome Webshop og linket i sidefoden på siden Ny fane og applisten for <ph name="PRODUCT_OS_NAME" />.

      Hvis denne politik er angivet til Sand, skjules ikonerne.

      Hvis denne politik er angivet til Falsk eller ikke er indstillet, er ikonerne synlige.</translation>
<translation id="2744751866269053547">Registrer protokolhandlere</translation>
<translation id="2746016768603629042">Denne politik er forældet. Brug DefaultJavaScriptSetting i stedet

      Kan bruges til at deaktivere JavaScript i <ph name="PRODUCT_NAME" />.

      Hvis denne indstilling er deaktiveret, kan websider ikke anvende JavaScript, og brugeren kan ikke ændre denne indstilling.

      Hvis denne indstilling er deaktiveret eller ikke angivet, kan websider anvende JavaScript, men brugeren kan ændre denne indstilling.</translation>
<translation id="2753637905605932878">Begræns antallet af lokale UDP-porte, der bruges af WebRTC</translation>
<translation id="2755385841634849932">Denne politik styrer tilgængeligheden af Android-tjenesten til sikkerhedskopiering og gendannelse.

      Hvis politikken ikke er konfigureret eller angivet som <ph name="BR_DISABLED" />, er Android-tjenesten til sikkerhedskopiering og gendannelse deaktiveret, og den kan ikke aktiveres af brugeren.

      Hvis politikken er angivet som <ph name="BR_UNDER_USER_CONTROL" />, bliver brugeren bedt om at vælge, hvorvidt Android-tjenesten til sikkerhedskopiering og gendannelse skal bruges. Hvis brugeren aktiverer sikkerhedskopiering og gendannelse, uploades der Android-appdata til alternative servere for Android, hvorfra de gendannes, efter kompatible apps er installeret igen.</translation>
<translation id="2757054304033424106">Typer af udvidelser/apps, der må installeres</translation>
<translation id="2758084448533744848">Angiver den tidszone, der skal gælde for enheden. Når politikken er konfigureret, kan brugerne på enheden ikke tilsidesætte den angivne tidszone. Hvis der angives en ugyldig værdi, aktiveres politikken med "GMT" i stedet. Hvis der angives en tom streng, ignoreres politikken.

      Hvis politikken ikke anvendes, benyttes den aktive tidszone. Brugerne kan dog skifte tidszone.

      Nye enheder er som udgangspunkt indstillet til tidszonen "Pacific Standard Time".

      Formatet for værdierne følger navnene på tidszonerne i "IANA Time Zone Database" (se "https://en.wikipedia.org/wiki/Tz_database"). De fleste tidszoner betegnes som "continent/large_city" eller "ocean/large_city".

      Hvis du konfigurerer denne politik, deaktiveres automatisk opdatering af tidszone på baggrund af enhedens placering fuldstændigt. Samtidig tilsidesættes politikken SystemTimezoneAutomaticDetection.</translation>
<translation id="2759224876420453487">Kontrollér brugeradfærden i en multiprofilsession</translation>
<translation id="2761483219396643566">Advarsel om inaktivitetsforsinkelse, når batteriet anvendes</translation>
<translation id="2762164719979766599">Angiver listen over enhedslokale konti, der skal vises på loginskærmen.

      Hver post på listen angiver et id, som bruges internt til at skelne mellem de forskellige enhedslokale konti.</translation>
<translation id="2769952903507981510">Konfigurer det påkrævede domænenavn for værter med fjernadgang</translation>
<translation id="2787173078141616821">Rapportér oplysninger om status for Android</translation>
<translation id="2799297758492717491">Tillad automatisk afspilning af medier på en hvidliste over webadressemønstre</translation>
<translation id="2801230735743888564">Giv brugerne mulighed for at spille det ekstra dinosaurspil, når enheden er offline.

      Hvis denne politik er angivet til Falsk, kan brugerne ikke spille det ekstra dinosaurspil, når enheden er offline. Hvis indstillingen er angivet til Sand, kan brugerne spille dinosaurspillet. Hvis politikken ikke er angivet, kan brugerne ikke spille det ekstra dinosaurspil på tilmeldte Chrome OS-systemer, men de kan spille det under andre omstændigheder.</translation>
<translation id="2802085784857530815">Giver dig mulighed for at angive, om brugerne kan få adgang til printere, der ikke tilhører virksomheden

      Hvis politikken er angivet som Sand eller slet ikke er angivet, kan brugerne tilføje, konfigurere og udskrive via deres egne printere.

      Hvis politikken er angivet som Falsk, kan brugerne ikke tilføje og konfigurere deres egne printere. De kan heller ikke udskrive via egne printere, der tidligere er blevet konfigureret.
      </translation>
<translation id="2805707493867224476">Tillad, at alle websites viser pop op-vinduer</translation>
<translation id="2808013382476173118">Muliggør brug af STUN-servere, hvis fjernklienter forsøger at oprette forbindelse til denne computer.

          Hvis denne indstilling er aktiveret, kan fjernklienter finde og oprette forbindelse til denne computer, selvom de er adskilt af en firewall.

          Hvis denne indstilling er deaktiveret, og udgående UDP-forbindelser filtreres af firewallen, vil denne computer kun tillade forbindelser fra klientcomputere på det lokale netværk.
 
          Hvis denne politik ikke er angivet, aktiveres denne indstilling.</translation>
<translation id="2813281962735757923">Denne politik styrer de tidsrum, hvor <ph name="PRODUCT_OS_NAME" />-enheden ikke har tilladelse til automatisk at søge efter opdateringer.
      Hvis politikken er konfigureret med en liste over tidsintervaller, som ikke er tom:
      Enheder kan ikke automatisk søge efter opdateringer i de angivne tidsintervaller. Enheder, der kræver en tilbagetrækning eller er ældre end minimumsversionen for <ph name="PRODUCT_OS_NAME" />, berøres ikke af denne politik på grund af potentielle sikkerhedsproblemer. Derudover blokerer politikken ikke for søgning efter opdateringer, hvis brugere eller administratorer anmoder om dette.
      Hvis politikken ikke er konfigureret eller ikke indeholder tidsintervaller:
      Automatiske søgninger efter opdateringer blokeres ikke af denne politik, men blokeres muligvis af andre politikker. Denne funktion er kun aktiveret på Chrome-enheder, der er konfigureret som terminaler med automatisk opstart. Andre enheder begrænses ikke af denne politik.</translation>
<translation id="2823870601012066791"><ph name="PRODUCT_OS_NAME" />-klienters placering i Windows-registreringsdatabasen:</translation>
<translation id="2824715612115726353">Aktiver inkognitotilstand</translation>
<translation id="2838830882081735096">Tillad ikke datamigrering og ARC</translation>
<translation id="2839294585867804686">Indstillinger for fildeling via netværk</translation>
<translation id="2840269525054388612">Angiver, hvilke printere en bruger kan anvende.

      Denne politik anvendes kun, hvis <ph name="PRINTERS_WHITELIST" /> er valgt for <ph name="DEVICE_PRINTERS_ACCESS_MODE" />

      Hvis denne politik anvendes, er det kun printere med id'er, der matcher værdierne i denne politik, som kan anvendes af brugeren. Id'erne skal stemme overens med feltet "id" eller "guid" i den fil, der er angivet i <ph name="DEVICE_PRINTERS_POLICY" />.
      </translation>
<translation id="2842152347010310843">Styrer hvidlisten over webadressemønstre, som autoplay altid er aktiveret for.

      Hvis autoplay er aktiveret, kan videoer automatisk afspilles (uden brugersamtykke) med lydindhold i <ph name="PRODUCT_NAME" />.

      Gyldige specifikationer for webadressemønstre er:

      - [*.]domain.tld (matcher domain.tld og alle underdomæner)

      - host (matcher et nøjagtigt hostname)

      - scheme://host:port (understøttede formater: http,https)

      - scheme://[*.]domain.tld:port (understøttede formater: http,https)

      - file://path (Hele stien skal angives og starte med "/")

      - a.b.c.d (matcher en nøjagtig IP-adresse af typen IPv4)

      - [a:b:c:d:e:f:g:h] (matcher en nøjagtig IP-adresse af typen IPv6)

      Hvis politikken AutoplayAllowed er angivet som Sand, har denne politik ingen effekt.

      Hvis politikken AutoplayAllowed er angivet som Falsk, kan alle angivne webadressemønstre i denne politik stadig afspilles.

      Bemærk! Hvis <ph name="PRODUCT_NAME" /> kører, og denne politik ændres, anvendes den kun for nye åbne faner. Nogle faner kan derfor stadig observere den forrige adfærd.</translation>
<translation id="285480231336205327">Aktivér høj kontrast</translation>
<translation id="2854919890879212089">Får <ph name="PRODUCT_NAME" /> til at bruge systemets standardprinter som standardvalg i Vis udskrift i stedet for den senest brugte printer.

      Hvis du deaktiverer denne indstilling eller ikke angiver en værdi, benytter Vis udskrift den senest brugte printer som standarddestination.

      Hvis du aktiverer denne indstilling, benytter Vis udskrift operativsystemets standardprinter som standarddestination.</translation>
<translation id="2856674246949497058">Træk udgivelsen tilbage, og behold målversionen, hvis OS-versionen er nyere end målversionen. Foretag en Powerwash under processen.</translation>
<translation id="2872961005593481000">Sluk</translation>
<translation id="2873651257716068683">Tilsidesætter størrelsen på udskriftsiden. Hvis sidestørrelsen ikke er tilgængelig, ignoreres denne politik.</translation>
<translation id="2874209944580848064">Bemærkning om <ph name="PRODUCT_OS_NAME" />-enheder, der understøtter Android-apps:</translation>
<translation id="2877225735001246144">Deaktiver CNAME-opslag, når godkendelsen af Kerberos forhandles</translation>
<translation id="2890645751406497668">Giv automatisk disse websites tilladelse til at oprette forbindelse til USB-enheder med det givne leverandør- og produkt-id.</translation>
<translation id="2892414556511568464">Begrænser duplex-tilstanden for udskrivning. En ikke-angivet politik og en tom indstilling behandles som ingen begrænsning.</translation>
<translation id="2893546967669465276">Send systemlogfiler til administrationsserveren</translation>
<translation id="2899002520262095963">Android-apps kan anvende de netværkskonfigurationer og CA-certifikater, der er angivet via denne politik, men de har ikke adgang til bestemte konfigurationsmuligheder.</translation>
<translation id="290002216614278247">Giver dig mulighed for at låse brugerens session baseret på klienttiden eller dagens brugskvote.

          |time_window_limit| angiver et dagligt tidsrum, hvor brugerens session skal låses. Vi understøtter kun én regel pr. ugedag. Rækken |entries| kan derfor variere i størrelse fra 0-7. |starts_at| og |ends_at| er starten og slutningen på tidsrummet. Når |ends_at| er mindre end |starts_at|, betyder det, at |time_limit_window| slutter den følgende dag. |last_updated_millis| er UTC-tidsstemplet for den sidste gang, dette element blev opdateret. Det sendes som en streng, fordi tidsstemplet ikke kan passe i et heltal.

          |time_usage_limit| angiver en daglig skærmkvote, så når kvoten opbruges, bliver brugerens session låst. Der er en egenskab for hver dag i ugen, og den skal kun angives, hvis der er en aktiv kvote for den pågældende dag. |usage_quota_mins| er den mængde tid, en administreret enhed kan bruges på en dag, og |reset_at| er tidspunktet, hvor brugskvoten fornys. Standardværdien for |reset_at| er midnat ({'hour': 0, 'minute': 0}). |last_updated_millis| er UTC-tidsstemplet for den sidste gang, dette element blev opdateret. Det sendes som en streng, fordi tidsstemplet ikke kan passe i et heltal.

          |overrides| angives for midlertidigt at ugyldiggøre én eller flere af de tidligere regler.
          * Hvis hverken time_window_limit eller time_usage_limit er aktiv, kan |LOCK| bruges til at låse enheden.
          * |LOCK| låser midlertidigt en brugersession, indtil den næste time_window_limit eller time_usage_limit starter.
          * |UNLOCK| låser en brugersession op, der er låst af time_window_limit eller time_usage_limit.
          |created_time_millis| er UTC-tidsstemplet for oprettelsen af tilsidesættelsen. Det sendes som en streng, fordi tidsstemplet ikke kan passe i et heltal. Det bruges til at afgøre, om en tilsidesættelse stadig skal anvendes. Hvis den nuværende funktion til begrænsning af aktiv tid (grænse for tidsforbrug eller tidsrum med begrænsning) startede, før tilsidesættelsen blev oprettet, bør den ikke udføre en handling. Hvis tilsidesættelsen blev oprettet før den sidste ændring af den aktive time_window_limit eller time_usage_window, bør den heller ikke anvendes.

          Der kan sendes flere tilsidesættelser. Det er den nyeste gyldige post, der anvendes.</translation>
<translation id="2905984450136807296">Levetid for cachen til godkendelsesdata</translation>
<translation id="2906874737073861391">Liste over AppPack-udvidelser</translation>
<translation id="2907992746861405243">Bestemmer, hvilke printere fra <ph name="BULK_PRINTERS_POLICY" /> der kan anvendes af brugerne.

      Angiver, hvilken adgangspolitik der anvendes til konfiguration af flere printere. Hvis <ph name="PRINTERS_ALLOW_ALL" /> er valgt, vises alle printere. Hvis <ph name="PRINTERS_BLACKLIST" /> er valgt, anvendes <ph name="BULK_PRINTERS_BLACKLIST" /> til at begrænse adgangen til de angivne printere. Hvis <ph name="PRINTERS_WHITELIST" /> er valgt, angiver <ph name="BULK_PRINTERS_WHITELIST" /> kun de printere, der kan vælges.

      Hvis politikken ikke angives, anvendes <ph name="PRINTERS_ALLOW_ALL" /> som standard.
      </translation>
<translation id="2908277604670530363">Maksimalt antal samtidige forbindelser til proxyserveren</translation>
<translation id="2952347049958405264">Begrænsninger:</translation>
<translation id="2956777931324644324">Denne politik udgik fra og med <ph name="PRODUCT_NAME" /> version 36.

      Angiver, om udvidelsen for certifikater, der er bundet af TLS-domænet, skal aktiveres.

      Denne indstilling bruges til at aktivere udvidelsen for certifikater, der er bundet af TLS-domænet, til testformål. Denne eksperimentelle indstilling vil blive fjernet senere hen.</translation>
<translation id="2957506574938329824">Tillad ikke, at websites får adgang til Bluetooth-enheder via Web Bluetooth API</translation>
<translation id="2957513448235202597">Kontotype for <ph name="HTTP_NEGOTIATE" />-godkendelse</translation>
<translation id="2959898425599642200">Regler for omgåelse af proxy</translation>
<translation id="2960128438010718932">Tidsplan for trinvis anvendelse af en ny opdatering</translation>
<translation id="2960691910306063964">Aktivér eller deaktiver godkendelse uden pinkode for hosts til fjernadgang</translation>
<translation id="2976002782221275500">Angiver den tid uden brugerinput, der aktiverer skærmnedtoning, når batteriet bruges.

          Hvis denne politik indstilles til en højere værdi end nul, angives den tid, som brugeren skal forblive inaktiv i, før <ph name="PRODUCT_OS_NAME" /> nedtoner skærmen.

          Hvis denne politik indstilles til nul, nedtoner <ph name="PRODUCT_OS_NAME" /> ikke skærmen, når brugeren er inaktiv.

          Hvis denne politik ikke indstilles, anvendes standardindstillingen.

          Politikkens værdi skal angives i millisekunder. Værdierne reduceres, så de er mindre end eller lig med skærmslukforsinkelsen (hvis angivet) og inaktivitetsforsinkelsen.</translation>
<translation id="2987155890997901449">Aktivér ARC</translation>
<translation id="2987227569419001736">Kontrollér brugen af Web Bluetooth API</translation>
<translation id="3016255526521614822">Hvidlistedeapps til notatskrivning er tilladt på <ph name="PRODUCT_OS_NAME" />-låseskærmen</translation>
<translation id="3021562480854470924">Hvor mange gange tidligere versioner kan gendannes</translation>
<translation id="3023572080620427845">Webadresse for en XML-fil, der indeholder webadresser, som skal indlæses i en alternativ browser.</translation>
<translation id="3030000825273123558">Aktivér metrics-rapportering</translation>
<translation id="3034580675120919256">Giver dig mulighed for at angive, om websites må køre JavaScript. Kørsel af JavaScript kan enten være tilladt for alle websites eller nægtet for alle websites. Hvis denne politik ikke angives, anvendes "AllowJavaScript", og brugeren vil kunne ændre det.</translation>
<translation id="3038323923255997294">Fortsætter med at køre baggrundsapps, når <ph name="PRODUCT_NAME" /> er lukket</translation>
<translation id="3046192273793919231">Send netværkspakker til administratorserveren for at overvåge onlinestatus</translation>
<translation id="3047732214002457234">Styr, hvordan Chrome-oprydning rapporterer data til Google</translation>
<translation id="304775240152542058">Politikken styrer kommandolinjeparametre, der skal åbnes i den alternative browser.

      Hvis politikken ikke konfigureres, er det kun webadressen, der videregives som en kommandolinjeparameter.

      Hvis politikken er konfigureret med en liste over strenge, videregives hver streng til den alternative browser som en separat kommandolinjeparameter. I Windows tilknyttes parametre med mellemrum. I Mac OS X og Linux kan en parameter indeholde mellemrum og stadig blive behandlet som en enkelt parameter.

      Hvis et element indeholder ${url}, erstattes det med webadressen til den side, der skal åbnes.

      Hvis ingen elementer indeholder ${url}, tilføjes webadressen i slutningen af kommandolinjen.

      Variabler for miljøet udvides. I Windows erstattes %ABC% med variabelværdien for ABC-miljøet. I Mac OS X og Linux erstattes ${ABC} med variabelværdien for ABC-miljøet.</translation>
<translation id="3048744057455266684">Hvis denne politik er indstillet, og en søgewebadresse foreslået af omnifeltet indeholder denne parameter i forespørgselsstrengen eller i fragment-id'et, vil forslaget vise søgetermerkene og søgemaskinen i stedet for kun søgewebadressen.

          Denne politik er valgfri. Hvis den ikke indstilles, udføres der ingen erstatning af søgetermer.

          Denne politik respekteres kun, hvis politikken 'DefaultSearchProviderEnabled' aktiveres.</translation>
<translation id="306887062252197004">Med denne politik kan brugere af funktionen WebDriver tilsidesætte
      politikker, der kan forstyrre processen.

      Politikken deaktiverer i øjeblikket politikkerne SitePerProcess og IsolateOrigins.

      Hvis politikken er aktiveret, kan WebDriver tilsidesætte inkompatible
      politikker.
      Hvis politikken er deaktiveret eller ikke er konfigureret, kan WebDriver ikke
      tilsidesætte inkompatible politikker.</translation>
<translation id="3069958900488014740">Tillader deaktivering af WPAD-optimering (Web Proxy Auto-Discovery) i <ph name="PRODUCT_NAME" />.

      Hvis denne politik angives som Falsk, deaktiveres WPAD-optimering, så <ph name="PRODUCT_NAME" /> skal vente længere på DNS-baserede WPAD-servere. Hvis politikken ikke er indstillet, eller hvis den er aktiveret, er WPAD-optimering aktiveret.

      Uafhængigt af om politikken er indstillet og hvordan, kan indstillingen for WPAD-optimering ikke ændres af brugerne.</translation>
<translation id="3072045631333522102">Pauseskærm, som skal bruges på loginskærmen i detailtilstand</translation>
<translation id="3072847235228302527">Konfigurer servicevilkårene for en enhedslokal konto</translation>
<translation id="3077183141551274418">Aktiverer eller deaktiverer livscyklus for faner</translation>
<translation id="3086995894968271156">Konfigurer Cast Receiver i <ph name="PRODUCT_NAME" />.</translation>
<translation id="3088796212846734853">Giver dig mulighed for at oprette en liste over webadressemønstre, der angiver websites, som må vise billeder.

          Hvis denne politik ikke angives, anvendes den globale standardværdi på alle websites, enten fra politikken "DefaultImagesSetting", hvis den er angivet, eller brugerens personlige konfiguration.

          Bemærk, at denne politik tidligere ved en fejl blev aktiveret for Android, men denne funktionalitet har aldrig været understøttet fuldt ud af Android.</translation>
<translation id="3096595567015595053">Liste over aktiverede plugins</translation>
<translation id="3101501961102569744">Vælg, hvordan du vil angive indstillinger for proxyserveren</translation>
<translation id="3101709781009526431">Dato og klokkeslæt</translation>
<translation id="3117676313396757089">Advarsel! DHE fjernes helt fra <ph name="PRODUCT_NAME" /> efter version 57 (omkring marts 2017), og på det tidspunkt holder denne politik op med at virke.

      Hvis politikken ikke er angivet eller er angivet til Falsk, aktiveres DHE-krypteringsprogrammer i TLS ikke. Alternativt kan den angives til Sandt for at aktivere DHE-krypteringsprogrammer og for at bevare kompatibiliteten med en forældet server. Dette er en midlertidig løsning, og serveren bør konfigureres igen.

      Servere bør migreres til ECDHE-krypteringsprogrammer. Hvis disse ikke er tilgængelige, skal du sørge for, at et krypteringsprogram, der bruger RSA-hovedudveksling, er aktiveret.</translation>
<translation id="3117706142826400449">Hvis politikken er deaktiveret, forhindres Chrome-oprydning i at scanne systemet for uønsket software og foretage oprydning. Manuel aktivering af Chrome-oprydning fra chrome://settings/cleanup er deaktiveret.

      Hvis politikken er aktiveret eller ikke angivet, scanner Chrome-oprydning jævnligt systemet for uønsket software, og hvis der findes noget, bliver brugeren spurgt, om softwaren skal fjernes. Manuel aktivering af Chrome-oprydning fra chrome://settings/cleanup er aktiveret.

      Denne politik er kun tilgængelig for Windows-forekomster, der er knyttet til et <ph name="MS_AD_NAME" />-domæne, eller Windows 10 Pro- eller Enterprise-forekomster, der er tilmeldt administration af enheder.</translation>
<translation id="3159375329008977062">Brugeren kan eksportere/importere Crostini-containere via brugerfladen</translation>
<translation id="3165808775394012744">Disse politikker er inkluderet her for at gøre dem nemme at fjerne.</translation>
<translation id="316778957754360075">Denne indstilling er blevet trukket tilbage fra og med <ph name="PRODUCT_NAME" /> version 29. Den anbefalede metode til konfiguration af organisationshostede udvidelse-/app-samlinger er at medtage det website, der hoster CRX-pakkerne, i ExtensionInstallSources og placere direkte downloadlinks til pakkerne på en webside. Du kan oprette en applikationsliste for denne webside vha. politikken ExtensionInstallForcelist.</translation>
<translation id="3171369832001535378">Skabelon for enhedens hostname på netværket</translation>
<translation id="3185009703220253572">siden version <ph name="SINCE_VERSION" /></translation>
<translation id="3187220842205194486">Android-apps kan ikke få adgang til virksomhedsnøgler. De påvirkes ikke af denne politik.</translation>
<translation id="3201273385265130876">Giver dig mulighed for at angive den proxyserver, som anvendes af <ph name="PRODUCT_NAME" />, og forhindrer brugerne i at ændre proxyindstillingerne.

          Hvis du vælger aldrig at bruge en proxyserver og altid oprette forbindelse direkte, ignoreres alle andre valgmuligheder.

          Hvis du vælger at bruge systemets proxyindstillinger, ignoreres alle andre valgmuligheder.

          Hvis du vælger at bruge automatisk registrering af proxyserveren, ignoreres alle andre valgmuligheder.

          Hvis du vælger tilstanden for en fast proxyserver, kan du angive yderligere valgmuligheder i "Adresse eller webadresse til proxyserveren" og "Kommasepareret liste over regler for omgåelse af proxy". ARC-apps anvender kun den HTTP-proxyserver, der har højest prioritet.

          Hvis du vælger at bruge et proxyscript af typen .pac, skal du angive webadressen til scriptet i "Webadresse til en proxyfil af typen .pac".

          Få flere detaljerede eksempler på:
          <ph name="PROXY_HELP_URL" />.

          Hvis du aktiverer denne indstilling, ignorerer <ph name="PRODUCT_NAME" /> og ARC-apps alle proxyrelaterede valgmuligheder, der angives på kommandolinjen.

          Hvis disse politikker ikke angives, kan brugerne selv vælge proxyindstillingerne.</translation>
<translation id="3205825995289802549">Maksimer det første browservindue ved første kørsel</translation>
<translation id="3211426942294667684">Indstillinger for browserlogin</translation>
<translation id="3214164532079860003">Denne politik tvinger import af startsiden fra den aktuelle standardbrowser, hvis den er aktiveret. Hvis den er deaktiveret, importeres startsiden ikke. Hvis den ikke er angivet, kan brugeren blive spurgt, om den skal importeres, eller også sker det automatisk.</translation>
<translation id="3219421230122020860">Inkognitotilstand er tilgængelig</translation>
<translation id="3220624000494482595">Hvis terminalappen er en Android-app, har den ingen kontrol over <ph name="PRODUCT_OS_NAME" />-versionen, selv hvis denne politik angives som <ph name="TRUE" />.</translation>
<translation id="3236046242843493070">Webadressemønstre, der tillader installation af udvidelser, apps og brugerscripts fra</translation>
<translation id="3240609035816615922">Adgangspolitik for konfiguration af printere.</translation>
<translation id="3243309373265599239">Angiver den tid uden brugerinput, der aktiverer skærmnedtoning, når strømforsyningen er tilsluttet.

          Hvis denne politik indstilles til end højere værdi end nul, angives den tid, som brugeren skal forblive inaktiv i, før <ph name="PRODUCT_OS_NAME" /> nedtoner skærmen.

          Hvis denne politik indstilles til nul, nedtoner <ph name="PRODUCT_OS_NAME" /> ikke skærmen, når brugeren er inaktiv.

          Hvis denne politik ikke indstilles, anvendes standardindstillingen.

          Politikkens værdi skal angives i millisekunder. Værdierne reduceres, så de er mindre end eller lig med skærmslukforsinkelsen (hvis angivet) og inaktivitetsforsinkelsen.</translation>
<translation id="3251500716404598358">Konfigurer politikker for at skifte mellem browsere.

      Konfigurerede websites åbnes automatisk i en anden browser end <ph name="PRODUCT_NAME" />.</translation>
<translation id="3264793472749429012">Kodninger for standardsøgemaskinen</translation>
<translation id="3273221114520206906">Standardindstilling for JavaScript</translation>
<translation id="3284094172359247914">Styr brugen af WebUSB API</translation>
<translation id="3288595667065905535">Udgivelseskanal</translation>
<translation id="3292147213643666827">Aktiverer <ph name="PRODUCT_NAME" /> til at fungere som proxy mellem <ph name="CLOUD_PRINT_NAME" /> og forældede printere, der er sluttet til maskinen.

      Hvis indstillingen er aktiveret eller ikke konfigureret, kan brugerne aktivere proxyen til Cloudprinter ved at godkende med deres Google-konto.

      Hvis denne indstilling er deaktiveret, kan brugerne ikke aktivere proxyen, og det vil ikke være tilladt for maskinen at dele sine printere med <ph name="CLOUD_PRINT_NAME" />.</translation>
<translation id="3307746730474515290">Kontrollerer, hvilke typer apps/udvidelser der må installeres, og begrænser adgangen til kørselstid.

          Denne indstilling hvidlister de tilladte typer af udvidelser/apps, der kan installeres i <ph name="PRODUCT_NAME" />, og hvilke hosts de kan interagere med. Værdien er en liste over strenge, som skal være en af de følgende: "extension", "theme", "user_script", "hosted_app", "legacy_packaged_app", "platform_app". Se udvidelsesdokumentationen for <ph name="PRODUCT_NAME" /> for at få flere oplysninger om disse typer.

          Bemærk, at denne politik også påvirker udvidelser og apps, som skal installeres under tvang via ExtensionInstallForcelist.

          Hvis denne indstilling er konfigureret, bliver udvidelser/apps af en type, som ikke er angivet på listen, ikke installeret.

          Hvis denne indstilling ikke er konfigureret, håndhæves ingen begrænsninger af acceptable typer af udvidelser/apps.</translation>
<translation id="3322771899429619102">Giver dig mulighed for at oprette en liste med webadressemønstre, der angiver websites, som har tilladelse til at benytte nøglegenerering. Hvis et webadressemønster findes i "KeygenBlockedForUrls", tilsidesættes disse undtagelser.

          Hvis denne politik ikke angives, anvendes den globale standardværdi på alle websites, enten fra politikken "DefaultKeygenSetting", hvis den er angivet, eller brugerens personlige konfiguration.</translation>
<translation id="332771718998993005">Beslut dig for et navn, der angives som en destination for <ph name="PRODUCT_NAME" />.

          Hvis denne politik er angivet som en udfyldt streng, anvendes strengen som navnet på destinationen for <ph name="PRODUCT_NAME" />. Hvis ikke, er navnet på destinationen det samme som navnet på enheden. Hvis denne politik ikke er angivet, er navnet på destinationen det samme som navnet på enheden, og enhedsejeren (eller en bruger fra domænet, som administrerer enheden) kan ændre det. Navnet må højst indeholde 24 tegn.</translation>
<translation id="3335468714959531450">Giver dig mulighed for at angive en liste over webadressemønstre, der udpeger websites, som må gemme cookies.

          Hvis politikken ikke angives, anvendes den globale standardværdi på alle websites, enten fra politikken "DefaultCookiesSetting", hvis den er angivet, eller brugerens personlige konfiguration.

          Se også politikkerne "CookiesBlockedForUrls" og "CookiesSessionOnlyForUrls. Bemærk, at der ikke må være nogen modstridende webadressemønstre mellem disse tre politikker – det er ikke angivet, hvilken af politikkerne der har forrang.</translation>
<translation id="3373364525435227558">Angiver én eller flere landestandarder for en administreret session, så brugerne nemt kan vælge en af disse landestandarder.

      Brugeren kan vælge en landestandard og et tastaturlayout, før en administreret session påbegyndes. Som standard angives alle landestandarder, der understøttes af <ph name="PRODUCT_OS_NAME" />, i alfabetisk rækkefølge. Du kan bruge denne politik til at flytte udvalgte landestandarder til toppen af listen.

      Hvis denne politik ikke er angivet, bliver den landestandard, der aktuelt bruges til brugerfladen, valgt som standard.

      Hvis denne politik er indstillet, flyttes de anbefalede landestandarder til toppen af listen og bliver visuelt adskilt fra alle andre landestandarder. De anbefalede landestandarder bliver angivet i den rækkefølge, som de er angivet i politikken. Den første anbefalede landestandard bliver valgt som standard.

      Hvis der er mere end én anbefalet landestandard, antages det, at brugerne vil vælge mellem disse landestandarder. Valg af landestandard og tastaturlayout bliver tydeligt tilbudt, når der startes en administreret session. Ellers antages det, at de fleste brugere vil vælge den forudvalgte landestandard. Valg af landestandard og tastaturlayout bliver mindre tydeligt tilbudt, når der startes en administreret session.

      Når denne politik er angivet, og automatisk login er aktiveret (se politikkerne |DeviceLocalAccountAutoLoginId| og |DeviceLocalAccountAutoLoginDelay|), bruger den automatisk påbegyndte administrerede session den første anbefalede landestandard og det mest populære tastaturlayout, der matcher denne landestandard.

      Det forudvalgte tastaturlayout er altid det mest populære layout, der matcher den forudvalgte landestandard.

      Denne politik kan kun angives som anbefalet. Du kan bruge denne politik til at flytte udvalgte landestandarder til toppen af listen, men brugerne har altid tilladelse til vælge en hvilken som helst landestandard, der understøttes af <ph name="PRODUCT_OS_NAME" />, til deres session.
      </translation>
<translation id="3381968327636295719">Brug værtsbrowseren som standard</translation>
<translation id="3388153794103186066">Gør det muligt at angive en liste over webadresser, der angiver, hvilke sider der automatisk får adgangstilladelse til en USB-enhed med de givne leverandør- og produkt-id'er. Hvert element på listen skal indeholde både enheder og webadresser, før politikken er gyldig. Hvert element på enheder kan indeholde felter til leverandør-id og produkt-id. Alle id'er, der udelades, behandles som et jokertegn – et produkt-id kan dog ikke angives, uden at der også angives et leverandør-id. Hvis ikke disse regler overholdes, regnes politikken som ugyldig og ignoreres.

        USB-tilladelsesmodellen anvender webadressen til det anmodende website ("anmodende webadresse") og webadressen til indramningswebsitet på øverste niveau ("integrerende webadresse") til at give den anmodende webadresse adgang til USB-enheden. Den anmodende webadresse kan adskille sig fra den integrerende webadresse, når det anmodende website indlæses i en iframe. Feltet "webadresser" kan derfor indeholde op til to webadressestrenge, adskilt af et komma, for at angive henholdsvis den anmodende og den integrerende webadresse. Hvis der kun angives én webadresse, gives der adgang til de tilsvarende USB-enheder, når webadressen til det anmodende website stemmer overens med denne webadresse, uanset hvilken integreringsstatus den har. Webadresserne i feltet "webadresser" skal være gyldige webadresser, ellers ignoreres politikken.

        Hvis politikken ikke konfigureres, anvendes den globale standardværdi fra politikken "DefaultWebUsbGuardSetting" til alle websites, og hvis denne ikke er konfigureret, anvendes brugerens personlige konfiguration.

        Webadressemønstre i denne politik må ikke være i strid med dem, der er konfigureret via WebUsbBlockedForUrls. Hvis de er i strid med hinanden, har denne politik forrang frem for WebUsbBlockedForUrls og WebUsbAskForUrls.</translation>
<translation id="3414260318408232239">Hvis denne politik ikke konfigureres, anvender <ph name="PRODUCT_NAME" /> en standardminimumversion, som er TLS 1.0.

      Den kan også angives til en af følgende værdier: "tls1", "tls1.1" eller "tls1.2". Når der er angivet en værdi, anvender <ph name="PRODUCT_NAME" /> ikke SSL/TLS-versioner, der er mindre end den angivne version. Ukendte værdier ignoreres.</translation>
<translation id="34160070798637152">Styrer netværkskonfigurationen for hele enheden.</translation>
<translation id="3417418267404583991">Hvis denne politik er angivet til sand eller ikke er konfigureret, aktiverer <ph name="PRODUCT_OS_NAME" /> gæstelogins. Gæstelogins er anonyme brugersessioner, der ikke kræver en adgangskode,

      Hvis denne politik er angivet til falsk, vil <ph name="PRODUCT_OS_NAME" /> ikke tillade, at der startes gæstesessioner.</translation>
<translation id="3418871497193485241">Gennemtvinger som minimum Begrænset tilstand på YouTube og forhindrer brugere i
      at vælge en mindre begrænset tilstand.

      Hvis denne indstilling er angivet som Streng, er Strengt begrænset tilstand på YouTube altid aktiveret.

      Hvis denne indstilling er angivet som Moderat, kan brugerne kun vælge
      Moderat begrænset tilstand og Strengt begrænset tilstand på YouTube, men Begrænset tilstand kan ikke deaktiveres.

      Hvis denne indstilling er angivet som Fra, eller der ikke er angivet nogen værdi, gennemtvinges Begrænset tilstand på YouTube ikke af <ph name="PRODUCT_NAME" />. Eksterne politikker, som f.eks. YouTubes politikker, kan dog stadig gennemtvinge Begrænset tilstand.</translation>
<translation id="3428247105888806363">Aktivér forudsigelse af netværk</translation>
<translation id="3432863169147125747">Styrer indstillinger for udskrivning</translation>
<translation id="3437924696598384725">Tillad, at brugeren administrerer VPN-forbindelser</translation>
<translation id="3449886121729668969">Konfigurerer proxyindstillinger for <ph name="PRODUCT_NAME" />. Disse proxyindstillinger vil også være tilgængelige for ARC-apps.

      Denne politik er endnu ikke klar til brug, så undlad at bruge den.</translation>
<translation id="3459509316159669723">Udskrivning</translation>
<translation id="3460784402832014830">Angiver den webadresse, som en søgemaskine anvender til at angive siden Ny fane.

          Denne politik er valgfri. Hvis den ikke er angivet, leveres siden Ny fane ikke.

          Denne politik respekteres kun, hvis politikken 'DefaultSearchProviderEnabled' er aktiveret.</translation>
<translation id="3461279434465463233">Rapportér strømstatus</translation>
<translation id="346731943813722404">Angiver, om strømstyringsforsinkelser og begrænsning af sessionslængden kun skal begynde at køre, efter den første brugeraktivitet er blevet registreret i en session.

          Hvis denne politik er indstillet til Sand, begynder strømstyringsforsinkelser og begrænsing af sessionslængden først at køre, efter den første brugeraktivitet er blevet registreret i en session.

          Hvis denne politik er indstillet til Falsk eller ikke er indstillet, begynder strømstyringsforsinkelser og begræsning af sessionslængden straks at køre ved sessionstart.</translation>
<translation id="3478024346823118645">Slet alle brugerdata, når der logges ud</translation>
<translation id="348495353354674884">Aktivér virtuelt tastatur</translation>
<translation id="3487623755010328395">
        Hvis denne politik er angivet, vil <ph name="PRODUCT_NAME" /> forsøge at registrere sig selv og anvende den tilknyttede Cloud-politik for alle profiler.

        Værdien for denne politik er et tilmeldingstoken, der kan hentes fra Google Administrationskonsol.</translation>
<translation id="3496296378755072552">Adgangskodemanager</translation>
<translation id="3500732098526756068">Giver dig mulighed for at styre aktiveringen af advarsler via adgangskodebeskyttelse. Adgangskodebeskyttelse underretter brugerne, når de genbruger deres beskyttede adgangskode på potentielt mistænkelige websites.

      Du kan bruge politikkerne "PasswordProtectionLoginURLs" og "PasswordProtectionChangePasswordURL" til at konfigurere, hvilken adgangskode der skal beskyttes.

      Hvis der angives "PasswordProtectionWarningOff" for politikken, vises der ikke nogen advarsel via adgangskodebeskyttelse.
      Hvis der angives "PasswordProtectionWarningOnPasswordReuse" for politikken, vises der en advarsel via adgangskodebeskyttelse, når brugeren genbruger sin beskyttede adgangskode på et website, der ikke er hvidlistet.
      Hvis der angives "PasswordProtectionWarningOnPhishingReuse" for politikken, vises advarslen via adgangskodebeskyttelse, når brugeren genbruger sin beskyttede adgangskode på et phishingwebsite.
      Hvis politikken ikke konfigureres, beskytter tjenesten til adgangskodebeskyttelse kun adgangskoder til Google, men brugeren kan ændre denne indstilling.</translation>
<translation id="3502555714327823858">Tillad alle duplex-tilstande</translation>
<translation id="350443680860256679">Konfigurer ARC</translation>
<translation id="3504791027627803580">Angiver webadressen på den søgemaskine, der bruges til billedsøgning. Søgeanmodninger sendes ved hjælp af GET-metoden. Hvis politikken DefaultSearchProviderImageURLPostParams er angivet, vil anmodninger om billedsøgning anvende POST-metoden i stedet.

          Denne politik er valgfri. Hvis den ikke er angivet, anvendes der ikke nogen billedsøgning.

          Denne politik respekteres, hvis politikken "DefaultSearchProviderEnabled" er aktiveret.</translation>
<translation id="350797926066071931">Aktiver Oversæt</translation>
<translation id="3512226956150568738">Hvis klientens enhedsmodel allerede understøttede ARC, inden det blev nødvendigt at migrere til ext4 for at køre ARC, og hvis politikken ArcEnabled er angivet som sand, opfører denne valgmulighed sig som AskUser (værdi 3). I alle andre tilfælde (hvis enhedsmodellen ikke tidligere understøttede ARC, eller hvis politikken ArcEnabled er angivet som falsk), svarer denne værdi til DisallowArc (værdi 0).</translation>
<translation id="3524204464536655762">Tillad ikke, at websites anmoder om adgang til USB-enheder via WebUSB API</translation>
<translation id="3526752951628474302">Kun udskrivning i sort/hvid</translation>
<translation id="3528000905991875314">Aktiver alternative fejlsider</translation>
<translation id="3545457887306538845">Giver dig mulighed for at styre, hvor Udviklerværktøjer kan bruges.

      Hvis denne politik er indstillet til "DeveloperToolsDisallowedForForceInstalledExtensions" (værdi 0, som er standardværdien), kan der generelt opnås adgang til Udviklerværktøjer og JavaScript-konsollen, men der kan ikke opnås adgang til dem i forbindelse med udvidelser, der er installeret af en virksomhedspolitik.
      Hvis denne politik er indstillet til "DeveloperToolsAllowed" (værdi 1), kan Udviklerværktøjer og JavaScript-konsollen åbnes og bruges i alle sammenhænge – også i forbindelse med udvidelser, der er installeret af en virksomhedspolitik.
      Hvis denne politik er indstillet til "DeveloperToolsDisallowed" (værdi 2), kan der ikke opnås adgang til Udviklerværktøjer, og elementer på websites kan ikke længere inspiceres. Alle tastaturgenveje samt menuer eller genvejsmenuer, der åbner Udviklerværktøjer eller JavaScript-konsollen, deaktiveres.</translation>
<translation id="3547954654003013442">Proxyindstillinger</translation>
<translation id="355118380775352753">Websites, der skal åbnes i en alternativ browser</translation>
<translation id="3577251398714997599">Annonceindstilling for websites med påtrængende annoncer</translation>
<translation id="357917253161699596">Tillad, at brugerne administrerer brugercertifikater</translation>
<translation id="3583230441447348508">Angiver en liste over forudkonfigureret fildeling via netværk.

      Hvert listepunkt i politikken er et objekt med to medlemmer: "share_url" og "mode". "share_url" skal være webadressen for delingen, og "mode" skal være enten "drop_down" eller "pre_mount". Tilstanden "drop_down" indikerer, at "share_url" føjes til rullelisten for fildeling. Tilstanden "pre_mount" indikerer, at "share_url" anvendes.</translation>
<translation id="3591527072193107424">Aktivér funktionen Emulator til ældre websites.</translation>
<translation id="3591584750136265240">Konfigurer adfærden for logingodkendelse</translation>
<translation id="3624171042292187668">
      Det er en god idé at kigge på politikindstillingen IsolateOrigins for at få det bedste fra begge verdener (isolering og begrænset indvirkning på brugerne) ved at bruge IsolateOrigins sammen med en liste over de websites, du vil isolere. Denne indstilling, SitePerProcess, isolerer alle websites.
      Hvis politikken er aktiveret, kører hvert website sin egen proces.
      Hvis politikken er deaktiveret, deaktiveres begge funktionerne IsolateOrigins og SitePerProcess. Brugere kan stadig aktivere SitePerProcess manuelt via kommandolinjerapportering.
      Hvis politikken ikke konfigureres, kan brugerne ændre denne indstilling.
      I <ph name="PRODUCT_OS_NAME" /> anbefales det, at der også angives den samme værdi for enhedspolitikken <ph name="DEVICE_LOGIN_SCREEN_SITE_PER_PROCESS_POLICY_NAME" />. 
Hvis de to politikker har forskellige værdier, kan der ske forsinkelser ved opstart af en brugersession, mens den værdi, der er angivet af brugerpolitikken, anvendes.

      BEMÆRK! Politikken anvendes ikke på Android-enheder. Hvis du vil aktivere SitePerProcess på en Android-enhed, skal du bruge politikindstillingen SitePerProcessAndroid.
      </translation>
<translation id="3627678165642179114">Aktivér eller deaktiver webtjenesten stavekontrol</translation>
<translation id="3628480121685794414">Aktivér simplex-udskrivning</translation>
<translation id="3646859102161347133">Indstil type af lup</translation>
<translation id="3653237928288822292">Ikon for standardsøgemaskine</translation>
<translation id="3660510274595679517">
        Hvis politikken angives som Sand, er tilmelding til Cloud Management obligatorisk og manglende tilmelding forhindrer åbningen af Chrome.

        Hvis politikken ikke angives eller angives som Falsk, er tilmelding til Cloud Management valgfri, og manglende tilmelding forhindrer ikke åbningen af Chrome.

        Denne politik bruges til maskinel massetilmelding til Cloud-politikken på computere og kan angives af registreringsdatabasen eller GPO i Windows, plist på Mac og JSON-politikfilen i Linux.</translation>
<translation id="3660562134618097814">Overfør SAML-IdP-cookies ved login</translation>
<translation id="3701121231485832347">Styrer indstillinger, der gælder specifikt for <ph name="PRODUCT_OS_NAME" />-enheder, der administreres af <ph name="MS_AD_NAME" />.</translation>
<translation id="3702647575225525306"><ph name="POLICY_NAME" /> (feltet med en enkelt linje er udfaset og fjernes inden for den nærmeste fremtid. Begynd at bruge tekstfeltet med flere linjer nedenfor).</translation>
<translation id="3709266154059827597">Konfigurer sortliste for installation af udvidelser</translation>
<translation id="3711895659073496551">Suspender</translation>
<translation id="3715569262675717862">Godkendelse på baggrund af klientcertifikater</translation>
<translation id="3736879847913515635">Aktivér tilføjelse af personer i brugeradministration</translation>
<translation id="3738723882663496016">Denne politik angiver <ph name="PLUGIN_VM_NAME" />-licensnøglen til denne enhed.</translation>
<translation id="3748900290998155147">Angiver, om aktiveringslåse er tilladt. Udvidelser kan anmode om aktiveringslåse via Power Management Extension API og ARC-apps.

          Hvis denne politik er angivet som sand eller ikke er angivet, indfries aktiveringslåse i forbindelse med strømstyring.

          Hvis denne politik er angivet som falsk, ignoreres anmodninger om aktiveringslås.</translation>
<translation id="3750220015372671395">Bloker nøglegenerering på disse websites</translation>
<translation id="3756011779061588474">Bloker udviklertilstand</translation>
<translation id="3758089716224084329">Giver dig mulighed for at angive den proxyserver, der anvendes af <ph name="PRODUCT_NAME" />, og forhindrer brugerne i at ændre proxyindstillingerne.

      Hvis du vælger aldrig at bruge en proxyserver og altid opretter forbindelse direkte, ignoreres alle andre valgmuligheder.

      Hvis du vælger at registrere proxyserveren automatisk, ignoreres alle andre valgmuligheder.

      Få detaljerede eksempler på:
      <ph name="PROXY_HELP_URL" />.

      Hvis du aktiverer denne indstilling, ignorerer <ph name="PRODUCT_NAME" /> og ARC-apps alle proxyrelaterede valgmuligheder, der specificeres fra kommandolinjen.

      Hvis disse politikker ikke angives, kan brugerne selv vælge proxyindstillingerne.</translation>
<translation id="3758249152301468420">Deaktiver udviklerværktøjer</translation>
<translation id="3764248359515129699">Deaktiverer håndhævelse af krav vedrørende Certifikatgennemsigtighed for forældede certifikatautoriteter.

      Politikken tillader, at kravene om offentliggørelse via Certifikatgennemsigtighed ikke håndhæves for certifikatkæder, der indeholder certifikater med en af de angivne hash-koder fra subjectPublicKeyInfo. Dermed kan certifikater, der ellers ikke ville være godkendt, fordi de ikke er blevet offentliggjort korrekt, fortsat anvendes til virksomhedshosts.

      For at håndhævelse af Certifikatgennemsigtighed kan deaktiveres, når politikken er angivet, skal hash-koden være fra subjectPublicKeyInfo og angivet i et CA-certifikat, der genkendes som en forældet certifikatautoritet. En forældet certifikatautoritet er en autoritet, der som standard er offentligt godkendt af ét eller flere operativsystemer, som understøttes af <ph name="PRODUCT_NAME" />, men som ikke er godkendt af Android Open Source Project eller <ph name="PRODUCT_OS_NAME" />.

      En hash-kode fra subjectPublicKeyInfo angives ved at sammenføje navnet på hash-algoritmen, tegnet "/" og Base64-kodningen for den pågældende hash-algoritme, der anvendes i subjectPublicKeyInfo med DER-kodning i det angivne certifikat. Denne Base64-kodning har samme format som et SPKI-fingeraftryk, som beskrevet i afsnit 2.4 i RFC 7469. Hash-algoritmer, der ikke genkendes, ignoreres. Det er i øjeblikket kun hash-algoritmen "sha256", som understøttes.

      Hvis politikken ikke angives, behandles alle certifikater, der skal offentliggøres via Certifikatgennemsigtighed, som ikke-godkendte, hvis de ikke offentliggøres i overensstemmelse med politikken for Certifikatgennemsigtighed.</translation>
<translation id="3765260570442823273">Varighed af advarselsmeddelelsen om logout for inaktivitet</translation>
<translation id="377044054160169374">Håndhævelse af indgriben mod vildledende adfærd</translation>
<translation id="3780152581321609624">Inkluder en port, der ikke er standard, i Kerberos-SPN</translation>
<translation id="3780319008680229708">Hvis denne politik angives som Sand, vises Cast-ikonet altid på værktøjslinjen eller i prikmenuen, og brugerne kan ikke fjerne det.

          Hvis denne politik angives som Falsk eller ikke angives, kan brugerne fastgøre eller fjerne ikonet via genvejsmenuen.

          Hvis politikken "EnableMediaRouter" angives som Falsk, træder denne politik ikke i kraft, og ikonet vises ikke på værktøjslinjen.</translation>
<translation id="3788662722837364290">Indstillinger for strømstyring, når brugeren bliver inaktiv</translation>
<translation id="3790085888761753785">Hvis denne indstilling aktiveres, kan brugerne logge ind på deres konto med Smart Lock. Dette udgør en mindre streng regel end almindelig Smart Lock-adfærd, som kun tillader, at brugerne låser deres skærme op.

      Hvis denne indstilling deaktiveres, har brugerne ikke tilladelse til at logge ind med Smart Lock.

      Hvis politikken ikke angives, er det som standard ikke tilladt for brugere, der administreres af en virksomhed, og tilladt for brugere, der ikke administreres.</translation>
<translation id="379602782757302612">Giver dig mulighed for at angive, hvilke udvidelser brugerne IKKE kan installere. Udvidelser, der allerede er installeret, deaktiveres, hvis de er sortlistet, og brugeren kan ikke aktivere dem. Når en udvidelse fjernes fra sortlisten efter at have været deaktiveret på grund af den, aktiveres udvidelsen automatisk igen.

          Værdien * på en sortliste betyder, at alle udvidelser er sortlistet, medmindre de udtrykkeligt er angivet på hvidlisten.

          Hvis denne politik ikke er angivet, kan brugeren installere alle udvidelser i <ph name="PRODUCT_NAME" />.</translation>
<translation id="3800626789999016379">Konfigurerer den mappe, som <ph name="PRODUCT_NAME" /> bruger til at downloade filer.

      Hvis du angiver denne politik, vil <ph name="PRODUCT_NAME" /> bruge den angivne mappe, uanset om brugeren har angivet en eller aktiveret flaget for at blive bedt om en downloadplacering hver gang.

      Du kan se en liste over variabler, der kan anvendes, på http://www.chromium.org/administrators/policy-list-3/user-data-directory-variables.

      Hvis denne politik ikke angives, anvendes standardmappen til downloads, og brugeren vil kunne ændre den.</translation>
<translation id="3805659594028420438">Aktivér udvidelse af certifikater, der er bundet til TLS-domænet (udfaset)</translation>
<translation id="3808945828600697669">Angiv en liste over deaktiverede plugins</translation>
<translation id="3811562426301733860">Tillad annoncer på alle websites</translation>
<translation id="3816312845600780067">Aktivér nødtastaturgenvej til automatisk login</translation>
<translation id="3820526221169548563">Aktivér hjælpefunktionen Skærmtastatur.

          Hvis denne politik er angivet som Sand, vil hjælpefunktionen Skærmtastatur altid være slået til.

          Hvis denne politik er angivet som Falsk, vil hjælpefunktionen Skærmtastatur altid være slået fra.

          Hvis du indstiller denne politik, kan brugerne ikke ændre eller tilsidesætte den.

          Hvis denne politik ikke er angivet, vil skærmtastaturet være slået fra som udgangspunkt, men brugeren kan til enhver tid aktivere det.</translation>
<translation id="382476126209906314">Konfigurer TalkGadget-præfikset for værter med fjernadgang</translation>
<translation id="3824972131618513497">Styrer indstillinger relateret til strømstyring og genstart.</translation>
<translation id="3831376478177535007">Når denne indstilling er aktiveret, tillader <ph name="PRODUCT_NAME" /> certifikater, der er udstedt af Symantec Corporations forældede PKI-processer, så længe de bekræfter og sammenkædes med et anerkendt CA-certifikat.

      Bemærk, at denne politik afhænger af, at operativsystemet stadig anerkender certifikater fra Symantecs forældede struktur. Hvis en opdatering af operativsystemet ændrer operativsystemets håndtering af sådanne certifikater, er denne politik ikke længere aktiv. Denne politik er desuden beregnet som en midlertidig løsning, der giver virksomheder mere tid til at bevæge sig væk fra forældede Symantec-certifikater. Denne politik fjernes omkring den 1. januar 2019.

      Hvis politikken ikke angives, eller hvis den er indstillet til Falsk, følger <ph name="PRODUCT_NAME" /> den officielle plan for udfasning.

      Se https://g.co/chrome/symantecpkicerts for at få flere oplysninger om udfasningen.</translation>
<translation id="383466854578875212">Giver dig mulighed for at angive, hvilke indbyggede beskedhosts der ikke skal være omfattet af sortlisten.

          En sortlisteværdi på * betyder, at alle indbyggede beskedhosts er på sortlisten, og at kun indbyggede beskedhosts på hvidlisten vil blive indlæst.

          Som standard sættes alle indbyggede beskedhosts på hvidlisten, men hvis alle indbyggede beskedhosts er blevet sat på sortlisten via en politik, kan hvidlisten bruges til at tilsidesætte denne politik.</translation>
<translation id="384743459174066962">Giver dig mulighed for at oprette en liste over webadressemønstre, der angiver websites, som ikke må åbne pop op-vinduer. Hvis denne politik ikke angives, anvendes den globale standardværdi på alle websites, enten fra politikken "DefaultPopupsSetting", hvis den er angivet, eller brugerens personlige konfiguration.</translation>
<translation id="3851039766298741586">Rapportér oplysninger om aktive terminalsessioner, f.eks.
      app-id og -version.

      Hvis politikken er angivet som falsk, rapporteres terminaloplysningerne
      ikke. Hvis den angives som sand eller ikke angives, rapporteres
      terminaloplysningerne.</translation>
<translation id="3852924591079583104">
      Hvis politikken er angivet som ArcSession, tvinges enheden til at genstarte, når brugeren logger ud, hvis Android er startet.
      Hvis politikken er angivet som Altid, tvinges enheden til at genstarte, hver gang brugeren logger ud.
      Hvis politikken ikke er konfigureret, har den ikke nogen effekt, og enheden tvinges ikke til at genstarte, når brugeren logger ud. Det samme gælder, hvis politikken er angivet som Aldrig.
      </translation>
<translation id="3858658082795336534">Standardudskrivning i duplex-tilstand</translation>
<translation id="3859780406608282662">Føj en parameter til hentning af variationsbasistallet i <ph name="PRODUCT_OS_NAME" />.

      Hvis denne politik er angivet, føjes en forespørgsel kaldet "restrict" til den webadresse, der bruges til at hente variationsbasistallet. Værdien for parameteren er den værdi, der er angivet i denne politik.

     Hvis denne politik ikke er angivet, ændres webadressen for variationsbasistallet ikke.</translation>
<translation id="3863409707075047163">Minimumsversionen af SSL/TLS er aktiveret.</translation>
<translation id="3864020628639910082">Angiver webadressen for den søgemaskine, der anvendes til at give søgeforslag. Webadressen bør indeholde strengen "<ph name="SEARCH_TERM_MARKER" />", som på forespørgselstidspunktet erstattes af den tekst, som brugeren har indtastet hidtil.

          Denne politik er valgfri. Hvis den ikke er angivet, anvendes der ikke webadresseforslag.

          Googles foreslåede webadresser kan angives som: <ph name="GOOGLE_SUGGEST_SEARCH_URL" />.

          Denne politik respekteres kun, hvis politikken "DefaultSearchProviderEnabled" er aktiveret.</translation>
<translation id="3864129983143201415">Konfigurer de tilladte sprog i en brugersession</translation>
<translation id="3866249974567520381">Beskrivelse</translation>
<translation id="3868347814555911633">Denne politik er aktiv i detailtilstand.

      Listeudvidelser, der automatisk er installeret for demobrugeren til enheder i detailtilstand. Disse udvidelser gemmes i enheden og kan installeres i offlinetilstand efter installationen.

      Alle poster på listen indeholder en ordbog, der skal indeholde udvidelses-id'et i feltet "udvidelses-id" samt webadressen til opdatering i feltet "opdateringswebadresse".</translation>
<translation id="3874773863217952418">Aktivér "Tryk for at søge"</translation>
<translation id="3877517141460819966">Integreret godkendelsestilstand med sekundær faktor</translation>
<translation id="3879208481373875102">Konfigurer en liste over fjerninstallerede webapps</translation>
<translation id="388237772682176890">Denne politik er udfaset i M53 og fjernet i M54, da understøttelse af SPDY/3.1 er fjernet.

      Deaktiverer brug af SPDY-protokollen i <ph name="PRODUCT_NAME" />.

      Hvis denne politik aktiveres, vil SPDY-protokollen ikke være tilgængelig i <ph name="PRODUCT_NAME" />.

      Hvis denne politik deaktiveres, tillades brug af SPDY.

      Hvis denne politik ikke angives, vil SPDY være tilgængelig.</translation>
<translation id="3890999316834333174">Politikker for hurtig oplåsning</translation>
<translation id="3891357445869647828">Aktiver JavaScript</translation>
<translation id="3895557476567727016">Konfigurerer standardmappen, som <ph name="PRODUCT_NAME" /> bruger til download af filer.

      Hvis du angiver denne politik, ændrer det standardmappen, som <ph name="PRODUCT_NAME" /> downloader filer til. Denne politik er ikke obligatorisk, så brugeren kan ændre mappen.

      Hvis du ikke angiver denne politik, bruger <ph name="PRODUCT_NAME" /> den sædvanlige standardmappe (platformspecifikt).

      Se https://www.chromium.org/administrators/policy-list-3/user-data-directory-variables for en liste over variabler, der kan bruges.</translation>
<translation id="3904459740090265495">Denne politik styrer loginadfærd i browseren. Den giver dig mulighed for at angive, om brugeren kan logge ind i <ph name="PRODUCT_NAME" /> med sin konto og benytte kontorelaterede tjenester såsom Chrome-synkronisering.

      Hvis "Deaktiver browserlogin" er angivet for politikken, kan brugeren ikke logge ind i browseren og benytte kontobaserede tjenester. Det betyder, at browserfunktioner såsom Chrome-synkronisering ikke kan anvendes. Hvis brugeren allerede er logget ind, og "Deaktiveret" er angivet for politikken, logges brugeren ud, næste gang vedkommende starter Chrome. Brugerens lokale profildata som f.eks. bogmærker og adgangskoder bevares dog. Brugeren kan stadig logge ind på og benytte Google-webtjenester såsom Gmail.

      Hvis "Aktivér browserlogin" er angivet for politikken, har brugeren tilladelse til at logge ind i browseren, og brugeren logges automatisk ind i browseren, når vedkommende er logget ind i Google-webtjenester såsom Gmail. Når brugeren er logget ind i browseren, gemmes vedkommendes kontooplysninger i browseren. Det betyder dog ikke, at Chrome-synkronisering som standard aktiveres. Brugeren skal selv tilvælge denne funktion. Aktivering af denne politik forhindrer brugeren i at deaktivere den indstilling, der tillader browserlogin. Brug politikken "SyncDisabled" til at styre tilgængeligheden af Chrome-synkronisering.

      Hvis "Kræv browserlogin" er angivet for politikken, får brugeren vist en dialogboks til kontovalg, hvor vedkommende skal vælge og logge ind på en konto for at benytte browseren. Dette sikrer, at politikker, der er knyttet til administrerede konti, anvendes og håndhæves. Denne indstilling aktiverer som standard Chrome-synkronisering for kontoen, undtagen i tilfælde, hvor synkronisering er deaktiveret af domæneadministratoren eller via politikken "SyncDisabled". Standardværdien for BrowserGuestModeEnabled angives som Falsk. Bemærk! Eksisterende profiler, hvor der ikke er logget ind, låses og kan ikke længere anvendes efter aktivering af denne politik. Du kan få flere oplysninger i artiklen i Hjælp: https://support.google.com/chrome/a/answer/7572556.

      Hvis politikken ikke konfigureres, kan brugeren selv bestemme, om muligheden for browserlogin skal aktiveres, og anvende den efter eget behov.</translation>
<translation id="3911737181201537215">Denne politik påvirker ikke logføring udført af Android.</translation>
<translation id="391531815696899618">Deaktiverer Google Drev-synkronisering i appen Filer i <ph name="PRODUCT_OS_NAME" />, når den er angivet til Sand. I dette tilfælde uploades der ingen data til Google Drev.

          Hvis denne indstilling ikke er konfigureret eller er angivet til Falsk, kan brugerne overføre filer til Google Drev.</translation>
<translation id="3915395663995367577">Webadresse til en proxyfil af typen .pac</translation>
<translation id="3925377537407648234">Angiv skærmopløsning og skaleringsfaktor</translation>
<translation id="3939893074578116847">Send netværkspakker til administrationsserveren for at overvåge onlinestatus, så
      serveren kan registrere, om enheden er offline.

      Hvis denne politik er angivet til sand, sendes der netværkspakker til overvågning (også kaldet <ph name="HEARTBEATS_TERM" />).
      Hvis den angives til falsk eller ikke angives, sendes der ingen pakker.</translation>
<translation id="3950239119790560549">Opdater tidsbegrænsninger</translation>
<translation id="3956686688560604829">Brug politikken SiteList for Internet Explorer til Emulator til ældre websites.</translation>
<translation id="3958586912393694012">Tillad brug af Smart Lock</translation>
<translation id="3963602271515417124">Hvis denne er angivet som sand, tillades fjernbekræftelse for enheden, og der genereres og uploades automatisk et certifikat til Device Management Server.

          Hvis den er angivet som falsk eller slet ikke er angivet, genereres der ikke noget certifikat, og kald til enterprise.platformKeysPrivate extension API mislykkes.</translation>
<translation id="3965339130942650562">Timeout, indtil brugeren logges ud på grund af inaktivitet</translation>
<translation id="3973371701361892765">Skjul aldrig hylden automatisk</translation>
<translation id="3984028218719007910">Bestemmer, om <ph name="PRODUCT_OS_NAME" /> bevarer lokale kontodata efter logout. Hvis den er angivet til sand, er der ingen vedvarende konti, der bevares af <ph name="PRODUCT_OS_NAME" />, og alle data fra brugersessionen kasseres efter logout. Hvis denne politik er angivet til falsk eller ikke er konfigureret, kan enheden beholde (krypterede) lokale brugerdata.</translation>
<translation id="398475542699441679">Denne politik styrer, om Emulator til ældre websites skal aktiveres.

      Hvis politikken angives som falsk eller ikke konfigureres, forsøger Chrome ikke at starte angivne webadresser i en alternativ browser.

      Hvis politikken angives som sand, forsøger Chrome at starte nogle webadresser i en alternativ browser (f.eks. Internet Explorer). Denne funktion konfigureres via politikkerne i gruppen <ph name="LEGACY_BROWSER_SUPPORT_POLICY_GROUP" />.

      Denne funktion erstatter udvidelsen <ph name="LEGACY_BROWSER_SUPPORT_EXTENSION_NAME" />. Konfigurationen fra udvidelsen overføres til denne funktion, men vi anbefaler på det kraftigste, at du bruger Chrome-politikker i stedet. Dette sikrer en bedre kompatibilitet fremover.</translation>
<translation id="3997519162482760140">Webadresser, der får adgang til videooptagelsesenheder på SAML-loginsider</translation>
<translation id="4001275826058808087">It-administratorer for virksomhedsenheder kan bruge denne markering til at kontrollere, om brugerne skal have tilladelse til at indløse tilbud via Chrome OS-registrering.

      Hvis denne politik er angivet til Sand eller ikke er angivet, kan brugerne indløse kampagnetilbud via Chrome OS-registrering.

      Hvis denne politik er angivet til Falsk, kan brugerne ikke indløse kampagnetilbud.</translation>
<translation id="4008507541867797979">Hvis denne politik er angivet som Sand eller ikke konfigureret, viser <ph name="PRODUCT_OS_NAME" /> eksisterende brugere på loginskærmen og giver mulighed for at vælge en.

      Hvis politikken er angivet som Falsk, viser <ph name="PRODUCT_OS_NAME" /> ikke eksisterende brugere på loginskærmen. Den almindelige loginskærm (der beder om brugerens mailadresse og adgangskode eller telefonnummer) eller den mellemliggende SAML-skærm (hvis denne er aktiveret via politikken <ph name="LOGIN_AUTHENTICATION_BEHAVIOR_POLICY_NAME" />) vises, medmindre der er konfigureret en administreret session. Når der er konfigureret en administreret session, vises kun konti i den administrerede session, og der kan vælges én af dem.

      Bemærk, at denne politik ikke påvirker, om enheden beholder eller kasserer de lokale brugerdata.</translation>
<translation id="4010738624545340900">Tillad aktivering af dialogbokse for filvalg</translation>
<translation id="4012737788880122133">Deaktiverer automatiske opdateringer, når indstillingen angives til sand.

      <ph name="PRODUCT_OS_NAME" />-enheder søger automatisk efter opdateringer, når denne indstilling ikke er konfigureret eller er angivet til falsk.

      Advarsel! Det anbefales at holde automatiske opdateringer aktiveret, så brugerne modtager softwareopdateringer og kritiske sikkerhedsrettelser. Deaktivering af automatiske opdateringer kan udgøre en risiko for brugerne.</translation>
<translation id="4020682745012723568">Cookies, der overføres til brugerens profil, er ikke tilgængelige i Android-apps.</translation>
<translation id="402759845255257575">Tillad ikke, at websites kører JavaScript</translation>
<translation id="4027608872760987929">Aktiver standardsøgemaskine</translation>
<translation id="4039085364173654945">Kontrollerer, om underlæggende tredjepartsindhold på en side har tilladelse til at vise et pop op-vindue med dialogboksen HTTP Basic Auth. Den er typisk deaktiveret som et phishingforsvar. Hvis denne politik ikke er angivet, deaktiveres den og underlæggende tredjepartsindhold har ikke tilladelse til at vise et pop op-vindue med dialogboksen HTTP Basic Auth.</translation>
<translation id="4056910949759281379">Deaktiver SPDY-protokol</translation>
<translation id="4059515172917655545">Denne politik styrer tilgængeligheden af Googles placeringstjenester.

      Hvis politikken ikke er konfigureret eller angivet som <ph name="GLS_DISABLED" />, er Googles placeringstjenester deaktiveret, og de kan ikke aktiveres af brugeren.

      Hvis denne politik er angivet som <ph name="GLS_UNDER_USER_CONTROL" />, bliver brugeren bedt om at vælge, hvorvidt Googles placeringstjenester skal bruges. Dette giver Android-apps mulighed for at bruge tjenestens data til at anmode om enhedens placering, og det muliggør også indsendelse af anonyme placeringsdata til Google.

      Bemærk, at denne politik ignoreres, og Googles placeringstjenester altid er aktiveret, når politikken <ph name="DEFAULT_GEOLOCATION_SETTING_POLICY_NAME" /> er angivet som <ph name="BLOCK_GEOLOCATION_SETTING" />.</translation>
<translation id="408029843066770167">Tillad forespørgsler til en Google-tidstjeneste</translation>
<translation id="408076456549153854">Aktivér browserlogin</translation>
<translation id="4088589230932595924">Inkognitotilstand er gennemtvunget</translation>
<translation id="4088983553732356374">Giver dig mulighed for at angive, om websites må angive lokale data. Angivelse af lokale data kan enten være tilladt for alle websites eller forbudt for alle websites.

          Hvis denne politik er angivet til "Behold cookies under sessionen", så ryddes cookies, når sessionen afsluttes. Bemærk, at sessionen muligvis ikke afsluttes, når det sidste vindue lukkes, hvis <ph name="PRODUCT_NAME" /> kører i "baggrundstilstand". Se politikken "BackgroundModeEnabled" for at få flere oplysninger om konfiguration af denne adfærd.

          Hvis denne politik ikke angives, anvendes "AllowCookies", og brugeren kan ændre dette.</translation>
<translation id="4103289232974211388">Omdiriger til SAML IdP efter brugerbekræftelse</translation>
<translation id="410478022164847452">Angiver den tid uden brugerinput, der aktiverer inaktivitetshandlingen, når strømforsyningen er tilsluttet.

          Hvis denne politik indstilles, angives den tid, som brugeren skal være inaktiv, før <ph name="PRODUCT_OS_NAME" /> aktiverer inaktivitetshandlingen, hvilket kan konfigureres separat.

          Hvis denne politik ikke indstilles, anvendes standardindstillingen.

          Værdien for politikken bør angives i millisekunder.</translation>
<translation id="4105989332710272578">Deaktiver håndhævelse af Certifikatsgennemsigtighed for en række webadresser</translation>
<translation id="4121350739760194865">Undgå, at appkampagner vises på ny fane-siden</translation>
<translation id="412697421478384751">Giv brugerne mulighed for at konfigurere svage pinkoder som pinkoder til låseskærmen</translation>
<translation id="4138655880188755661">Tidsgrænse</translation>
<translation id="4150201353443180367">Skærm</translation>
<translation id="4157003184375321727">Rapportér OS- og firmwareversion</translation>
<translation id="4157594634940419685">Giv brugerne mulighed for at bruge deres egne CUPS-printere</translation>
<translation id="4183229833636799228">Standardindstilling for <ph name="FLASH_PLUGIN_NAME" /></translation>
<translation id="4192388905594723944">Webadresse til validering af tokenet til klientgodkendelse for fjernadgang</translation>
<translation id="4203389617541558220">Begræns enhedens oppetid vha. planlagte automatiske genstarter.

      Hvis denne politik indstilles, angiver den længden for enhedens oppetid efter en planlagt genstart.

      Hvis denne politik ikke indstilles, vil enhedens oppetid ikke være begrænset.

      Hvis du indstiller denne politik, kan brugerne ændre eller tilsidesætte den.

      Der er planlagt en genstart på det valgte tidspunkt, men den kan være forsinket med op til 24 timer på enheden, hvis en bruger er i færd med at bruge enheden.

      Bemærk! Automatisk genstart er kun aktiveret mens loginskærmen vises eller en terminalapp kører. Dette vil ændre sig med tiden, og politikken vil altid være gældende, uanset om en bestemt type kører eller ej.

      Denne politikværdi skal angives i sekunder. Værdierne skal være minimum 3600 (en time).</translation>
<translation id="4203879074082863035">Det er kun printerne på hvidlisten, der vises til brugere</translation>
<translation id="420512303455129789">En ordbog, der knytter webadresser til en boolesk markering, angiver, om adgang til hosten tillades (sand) eller blokeres (falsk).

          <ph name="PRODUCT_NAME" /> bruger selv politikken internt.</translation>
<translation id="4224610387358583899">Forsinkelser for skærmlås</translation>
<translation id="423797045246308574">Giver dig mulighed for at oprette en liste med webadressemønstre, der angiver websites, som ikke har tilladelse til at anvende nøglegenerering. Hvis et webadressemønster findes i "KeygenBlockedForUrls", tilsidesættes disse undtagelser.

          Hvis denne politik ikke angives, anvendes den globale standardværdi på alle websites, enten fra politikken "DefaultKeygenSetting", hvis den er angivet, eller fra brugerens personlige konfiguration.</translation>
<translation id="4239720644496144453">Cachen bruges ikke til Android-apps. Hvis flere brugere installerer den samme Android-app, downloades den på ny for hver bruger.</translation>
<translation id="4243336580717651045">Aktiverer anonym dataindsamling fra indtastede webadresser i <ph name="PRODUCT_NAME" /> og forhindrer brugerne i at ændre denne indstilling.

      Den anonyme dataindsamling fra indtastede webadresser sender webadresser for de sider, brugeren besøger, til Google med henblik på at forbedre søgninger og browsing.

      Hvis politikken aktiveres, er den anonyme dataindsamling fra indtastede webadresser altid aktiv.

      Hvis politikken deaktiveres, er den anonyme dataindsamling fra indtastede webadresser aldrig aktiv.

      Hvis politikken ikke konfigureres, aktiveres den anonyme dataindsamling fra indtastede webadresser, men brugeren kan ændre den.</translation>
<translation id="4250680216510889253">Nej</translation>
<translation id="4261820385751181068">Landestandard for loginskærme på enheder</translation>
<translation id="427220754384423013">Angiver, hvilke printere en bruger kan anvende.

      Denne politik anvendes kun, hvis <ph name="PRINTERS_WHITELIST" /> er valgt for <ph name="BULK_PRINTERS_ACCESS_MODE" />.

      Hvis denne politik anvendes, er det kun printere med id'er, der matcher værdierne i denne politik, som kan anvendes af brugeren. Id'erne skal stemme overens med feltet "id" eller "guid" i den fil, der er angivet i <ph name="BULK_PRINTERS_POLICY" />.
      </translation>
<translation id="427632463972968153">Angiver de parametre, der anvendes ved billedsøgning med POST. De består af kommaseparerede navne/værdipar. Hvis en værdi er en skabelonparameter såsom {imageThumbnail} i ovenstående eksempel, bliver den erstattet af data om rigtige miniaturebilleder.

          Denne politik er valgfri. Hvis den ikke er angivet, sendes anmodninger om billedsøgninger ved hjælp af GET-metoden.

          Denne politik respekteres kun, hvis politikken "DefaultSearchProviderEnabled" er aktiveret.</translation>
<translation id="427706009709857238">"Giv Google Assistent tilladelse til at lytte efter den stemmestyrede aktiveringssætning"</translation>
<translation id="4285674129118156176">Tillad, at brugere uden tilknytning benytter ARC</translation>
<translation id="4298509794364745131">Specificerer en liste over apps, der kan aktiveres som apps til notatskrivning på <ph name="PRODUCT_OS_NAME" />-låseskærmen.

      Hvis den foretrukne app til notatskrivning er aktiveret på låseskærmen, vil låseskærmen indeholde et brugerfladeelement til at åbne den foretrukne app til notatskrivning.
      Når appen er åbnet, kan den oprette et appvindue oven på låseskærmen og oprette dataelementer (noter) i låseskærmskonteksten. Appen vil kunne importere oprettede noter til den primære brugersession, når sessionen ikke er låst. På nuværende tidspunkt er det kun Chrome-apps til notatskrivning, der understøttes på låseskærmen.

      Hvis politikken er angivet, gives brugeren tilladelse til at aktivere en app på låseskærmen, såfremt at appens udvidelses-id omfattes af værdien på listen over politikker.
      Som følge heraf deaktiveres notatskrivning helt på låseskærmen, hvis politikken angives som en tom liste.
      Bemærk, at politikken, der indeholder et app-id, ikke nødvendigvis betyder, at brugeren kan aktivere appen som en app til notatskrivning på låseskærmen – f.eks. er rækken af tilgængelige apps i Chrome 61 begrænset yderligere af platformen.

      Hvis politikken ikke angives, pålægges der ingen restriktioner på rækken af apps, som brugeren kan aktivere på låseskærmen, af politikken.</translation>
<translation id="4309640770189628899">Afgør, om DHE-krypteringsprogrammerne i TLS aktiveres</translation>
<translation id="4322842393287974810">Tillad, at den automatisk startede terminalapp uden forsinkelse kontrollerer <ph name="PRODUCT_OS_NAME" />-versionen</translation>
<translation id="4325690621216251241">Tilføj en log ud-knap til systembakken</translation>
<translation id="4332177773549877617">Logfør hændelser under Android-appinstallationer</translation>
<translation id="4346674324214534449">Giver dig mulighed for at angive, om annoncer skal blokeres på websites med påtrængende annoncer.

      Hvis mulighed 2 er angivet for denne politik, blokeres annoncer på websites med påtrængende annoncer.
      Denne handling udløses dog ikke, hvis politikken SafeBrowsingEnabled er angivet som Falsk.
      Hvis mulighed 1 er angivet for denne politik, blokeres annoncer ikke på websites med påtrængende annoncer.
      Hvis der ikke angives nogen valgmuligheder for denne politik, anvendes mulighed 2.</translation>
<translation id="4347908978527632940">Hvis den er sand, og brugeren er en administreret bruger, kan andre Android-apps sende forespørgsler vedrørende brugerens webbegrænsninger via en indholdsudbyder.

          Hvis den er falsk, eller den ikke er angivet, returnerer indholdsudbyderen ikke nogen oplysninger.</translation>
<translation id="435461861920493948">Indeholder en liste over mønstre, som bruges til at regulere synligheden af konti i <ph name="PRODUCT_NAME" />.

      Hver Google-konto på enheden sammenlignes med mønstre, der er gemt i denne politik, for at fastslå kontoens synlighed i <ph name="PRODUCT_NAME" />. Kontoen er synlig, hvis dens navn matcher et mønster på listen. Hvis ikke navnet matcher, skjules kontoen.

      Brug jokertegnet * til at matche ingen eller flere vilkårlige tegn. "Escape"-tegnet er \, så hvis tegnene skal matche det reelle tegn * eller \, kan du skrive \ foran dem.

      Hvis politikken ikke angives, vil alle Google-konti på enheden være synlige i <ph name="PRODUCT_NAME" />.</translation>
<translation id="436581050240847513">Rapportér enhedens netværksgrænseflader</translation>
<translation id="4372704773119750918">Tillad ikke, at virksomhedsbrugere er en del af en multiprofil (primær eller sekundær)</translation>
<translation id="4377599627073874279">Tillad alle websites at vise alle billeder</translation>
<translation id="437791893267799639">Hvis der ikke angives noget for politikken, tillades datamigrering og ARC ikke</translation>
<translation id="4389073105055031853">Tillad, at brugerne administrerer alle certifikater</translation>
<translation id="4389091865841123886">Konfigurer fjernattestering med TPM-mekanismen</translation>
<translation id="4408428864159735559">Liste over forudkonfigureret fildeling via netværk.</translation>
<translation id="4410236409016356088">Gør det muligt at begrænse netværkets båndbredde</translation>
<translation id="441217499641439905">Deaktiver Google Drev over mobilforbindelser i appen Filer i <ph name="PRODUCT_OS_NAME" /></translation>
<translation id="4418726081189202489">Hvis du angiver denne politik til Falsk, stopper <ph name="PRODUCT_NAME" /> med af og til at sende forespørgsler til en Google-server for at hente et nøjagtigt tidsstempel. Forespørgslerne aktiveres, hvis denne politik angives til Sand eller ikke angives.</translation>
<translation id="4423597592074154136">Angiv proxyindstillingerne manuelt</translation>
<translation id="4429220551923452215">Aktiverer eller deaktiverer genvejen til apps i bogmærkelinjen.

      Hvis denne politik ikke er angivet, kan brugeren vælge at vise eller skjule genvejen til apps i bogmærkelinjens genvejsmenu.

      Hvis denne politik er konfigureret, kan brugeren ikke ændre den, og genvejen for apps er enten altid vist eller altid skjult..</translation>
<translation id="4432762137771104529">Aktivér udvidet rapportering af Beskyttet browsing</translation>
<translation id="443454694385851356">Forældet (ikke sikkert)</translation>
<translation id="443665821428652897">Ryd websitedata ved browserlukning (frarådes)</translation>
<translation id="4439132805807595336">Aktivér PluginVm for denne enhed.

      Hvis politikken angives som Falsk eller ikke angives, aktiveres <ph name="PLUGIN_VM_NAME" /> ikke for denne enhed. Hvis den angives som Sand, aktiveres <ph name="PLUGIN_VM_NAME" /> for enheden, så længe dette også tillades af andre indstillinger. <ph name="PLUGIN_VM_ALLOWED_POLICY_NAME" /> skal angives som Sand, og <ph name="PLUGIN_VM_LICENSE_KEY_POLICY_NAME" /> og <ph name="PLUGIN_VM_IMAGE_POLICY_NAME" /> skal konfigureres, før <ph name="PLUGIN_VM_NAME" /> kan køre.</translation>
<translation id="4439336120285389675">Angiv en liste over forældede funktioner på webplatformen for at genaktivere dem midlertidigt.

Denne politik giver administratorer mulighed for at genaktivere udfasede webplatformsfunktioner i en begrænset periode. Funktioner identificeres ved hjælp af et strengtag, og de funktioner, der svarer til de tags, der er angivet på listen i denne politik, genaktiveres.

Hvis denne politik ikke er indstillet, eller hvis listen er tom eller ikke stemmer overens med et af de understøttede strengtags, vil alle forældede funktioner på webplatformen fortsat være deaktiveret.

Mens selve politikken understøttes på ovenstående platforme, kan den funktion, som politikken aktiverer, være tilgængelig på færre platforme. Det er ikke alle funktioner på webplatforme, der kan genaktiveres. Det er kun de funktioner, der er angivet på listen nedenfor, som kan genaktiveres i en begrænset periode, hvis længde afhænger af funktionen. Det overordnede format for strengtagget er [DeprecatedFeatureName]_EffectiveUntil[yyyymmdd]. Du kan se hensigten med ændringerne af funktionen Webplatform på https://bit.ly/blinkintents.
      </translation>
<translation id="4442582539341804154">Aktivér låsen, hvis enheden bliver inaktiv eller suspenderes</translation>
<translation id="4449545651113180484">Roter skærmen 270 grader med uret</translation>
<translation id="445270821089253489">Styrer, hvilke typer brugere og enhedsoplysninger der rapporteres.</translation>
<translation id="4454820008017317557">Vis ikonet for <ph name="PRODUCT_NAME" /> på værktøjslinjen</translation>
<translation id="4467952432486360968">Bloker cookies fra tredjeparter</translation>
<translation id="4474167089968829729">Aktivér lagring af adgangskoder i adgangskodeadministratoren</translation>
<translation id="4476769083125004742">Hvis denne politik angives som <ph name="BLOCK_GEOLOCATION_SETTING" />, kan Android-apps ikke få adgang til placeringsoplysninger. Hvis du angiver denne politik til en anden værdi eller ikke angiver den, bliver brugeren bedt om at give sit samtykke, når en Android-app vil have adgang til placeringsoplysninger.</translation>
<translation id="4480694116501920047">Gennemtving Beskyttet Søgning</translation>
<translation id="4482640907922304445">Viser knappen Startside på værktøjslinjen i <ph name="PRODUCT_NAME" />. Hvis du aktiverer denne indstilling, vises knappen Startside altid. Hvis du deaktiverer denne indstilling, vises knappen Startside aldrig. Hvis du aktiverer eller deaktiverer denne indstilling, kan brugerne ikke ændre eller tilsidesætte denne indstilling i <ph name="PRODUCT_NAME" />. Hvis denne politik ikke angives, kan brugeren vælge, om knappen Startside skal vises.</translation>
<translation id="4483649828988077221">Deaktiver automatisk opdatering</translation>
<translation id="4485425108474077672">Konfigurer webadressen for siden Ny fane</translation>
<translation id="4492287494009043413">Deaktiver screenshots</translation>
<translation id="4494132853995232608">Wilco DTC</translation>
<translation id="449423975179525290">Konfigurer <ph name="PLUGIN_VM_NAME" />-relaterede politikker.</translation>
<translation id="450537894712826981">Konfigurerer cachestørrelsen, som <ph name="PRODUCT_NAME" /> vil bruge til at lagre cachelagrede filer på disken.

      Hvis du indstiller denne politik, vil <ph name="PRODUCT_NAME" /> bruge den angivne cachestørrelse, uanset om brugeren har markeret flaget "--media-cache-size" eller ej. Værdien, der er angivet i denne politik, er ikke en hård grænse, men snarere en forslag til et cachelagringssystem, Enhver værdi under et par megabyte er for lille og vil blive rundet op til et fornuftigt minimum.

      Hvis værdien af denne politik er 0, anvendes standardcachestørrelsen, men brugeren vil ikke kunne ændre den.

      Hvis denne politik ikke er indstillet, bruges standardstørrelsen, og brugeren vil kunne tilsidesætte den med flaget "--media-cache-size".</translation>
<translation id="4508686775017063528">Hvis denne politik er angivet til Sand eller ikke er angivet, er <ph name="PRODUCT_NAME" /> aktiveret, og brugerne kan åbne det via appmenuen, genvejsmenuen til sider, knapper til mediestyring på Cast-kompatible websites og Cast-ikonet på værktøjslinjen (hvis det vises).

          Hvis denne politik er angivet som Falsk, er <ph name="PRODUCT_NAME" /> deaktiveret.</translation>
<translation id="4515404363392014383">Aktivér Beskyttet browsing i forbindelse med godkendte kilder</translation>
<translation id="4518251772179446575">Spørg, hver gang et website ønsker at spore brugerens fysiske placering</translation>
<translation id="4519046672992331730">Aktiverer søgeforslag i omnifeltet i <ph name="PRODUCT_NAME" /> og forhindrer, at brugerne ændrer denne indstilling.

      Hvis du aktiverer denne indstilling, anvendes søgeforslagene.

      Hvis du deaktiverer denne indstilling, anvendes søgeforslagene aldrig.

      Hvis du aktiverer eller deaktiverer denne indstilling, kan brugerne ikke ændre eller tilsidesætte denne indstilling i <ph name="PRODUCT_NAME" />.

      Hvis denne politik ikke indstilles, bliver dette aktiveret, men brugeren vil kunne ændre det.</translation>
<translation id="4531706050939927436">Android-apps kan tvinges til installation via Google Administrationskonsol ved hjælp af Google Play. De anvender ikke denne politik.</translation>
<translation id="4534500438517478692">Navn på Android-begrænsning:</translation>
<translation id="4541530620466526913">Enhedslokale konti</translation>
<translation id="4543502256674577024">Indstillinger for enhedsopdatering</translation>
<translation id="4544079461524242527">Konfigurerer indstillinger for administration af udvidelser for <ph name="PRODUCT_NAME" />.

          Denne politik styrer flere indstillinger, herunder indstillinger, der styres af eksisterende politikker vedrørende udvidelser. Denne politik tilsidesætter eventuelle ældre politikker, hvis begge er angivet.

          Denne politik knytter et udvidelses-id eller en opdateringswebadresse til dens konfiguration. Med et udvidelses-id bliver konfigurationen udelukkende anvendt på den angivne udvidelse. Der kan angives en standardkonfiguration for det særlige id <ph name="DEFAULT_SCOPE" />, som gælder for alle udvidelser, hvor der ikke er angivet en standardkonfiguration i denne politik. Med en opdateringswebadresse anvendes konfigurationen på alle udvidelser, hvor den nøjagtige opdateringswebadresse er angivet i denne udvidelses manifestfil som beskrevet i <ph name="LINK_TO_EXTENSION_DOC1" />.

          Du kan få en komplet beskrivelse af mulige indstillinger og mulig struktur for denne politik på https://www.chromium.org/administrators/policy-list-3/extension-settings-full
          </translation>
<translation id="4554651132977135445">Brugerpolitik for tilstand til behandling via loopback</translation>
<translation id="4554841826517980623">Denne politik bestemmer, om funktionen Fildeling via netværk for <ph name="PRODUCT_NAME" /> anvender <ph name="NETBIOS_PROTOCOL" /> til at registrere deling på netværket.
      Når politikken er angivet som Sand, anvendes protokollen <ph name="NETBIOS_PROTOCOL" /> til at registrere deling på netværket.
      Når politikken er angivet som Falsk, anvendes protokollen <ph name="NETBIOS_PROTOCOL" /> ikke til at registrere deling.
      Hvis politikken ikke konfigureres, er den som standard deaktiveret for virksomhedsadministrerede brugere, mens den som standard er aktiveret for ikke-administrerede brugere.</translation>
<translation id="4555850956567117258">Aktivér fjernattestering for brugeren</translation>
<translation id="4557134566541205630">Webadresse for siden Ny fane i standardsøgemaskinen</translation>
<translation id="4567137030726189378">Tillad brug af Udviklerværktøjer</translation>
<translation id="4578265298946081589">Genstart ikke, når brugeren logger ud.</translation>
<translation id="4600786265870346112">Aktivér Stor markør</translation>
<translation id="4604931264910482931">Konfigurer sortlisten for indbyggede beskedhosts</translation>
<translation id="4613508646038788144">Hvis politikken er indstillet til falsk, tillades det, at tredjepartssoftware kan føje eksekverbar kode til Chromes processer. Hvis politikken ikke er indstillet eller er indstillet til sand, kan tredjepartssoftwaren ikke føje eksekverbar kode til Chromes processer.</translation>
<translation id="4617338332148204752">Spring kontrol af metatag over i <ph name="PRODUCT_FRAME_NAME" /></translation>
<translation id="4625915093043961294">Konfigurer hvidliste for installation af udvidelser</translation>
<translation id="4632343302005518762">Tillad, at <ph name="PRODUCT_FRAME_NAME" /> håndterer de angivne indholdstyper</translation>
<translation id="4632566332417930481">Tillad ikke brug af Udviklerværktøjer i udvidelser, der er installeret af en virksomhedspolitik, tillad brug af Udviklerværktøjer i andre sammenhænge</translation>
<translation id="4633786464238689684">Ændrer standardadfærden for tasterne i øverste række til funktionstaster.

          Hvis denne politik er angivet til Sand, vil den øverste række med taster på tastaturet som standard være funktionstaster. For igen at gøre tasterne til medietaster skal man trykke på søgetasten.

          Hvis denne politik er angivet til Falsk, eller hvis den ikke er indstillet, vil tastaturet skulle bruges som medietaster som standard og funktionstaster, når søgefeltet anvendes.</translation>
<translation id="4639407427807680016">Navne på de indbyggede beskedhosts, som fritages fra sortlisten</translation>
<translation id="4650759511838826572">Deaktiver protokolskemaer for webadresser</translation>
<translation id="465099050592230505">Webadresse for virksomhedens webshop (udfaset)</translation>
<translation id="4665897631924472251">Indstillinger for administration af udvidelser</translation>
<translation id="4668325077104657568">Standardindstilling for billeder</translation>
<translation id="4670865688564083639">Minimum:</translation>
<translation id="4671708336564240458">Giver dig mulighed for at angive, om det er tilladt for websites med vildledende adfærd at åbne nye vinduer eller faner.

      Hvis denne politik er angivet som Sand, forhindres websites med vildledende adfærd i at åbne nye vinduer eller faner.
      Denne handling udløses dog ikke, hvis politikken SafeBrowsingEnabled er angivet som Falsk.
      Hvis denne politik er angivet som Falsk, kan websites med vildledende adfærd åbne nye vinduer eller faner.
      Hvis denne politik ikke er indstillet, angives den som Sand.</translation>
<translation id="467236746355332046">Understøttede funktioner:</translation>
<translation id="4674167212832291997">Tilpas listen over webadressemønstre, der altid skal gengives af <ph name="PRODUCT_FRAME_NAME" />.

          Hvis denne politik ikke er angivet, anvendes standardgengivelsen på alle websites, sådan som det er angivet i politikken "ChromeFrameRendererSettings".

          Du kan se eksempler på mønstre på https://www.chromium.org/developers/how-tos/chrome-frame-getting-started.</translation>
<translation id="467449052039111439">Åbn en liste over webadresser</translation>
<translation id="4674871290487541952">Tillad usikre algoritmer i integritetstjek ved opdateringer og installationer af udvidelser</translation>
<translation id="4680936297850947973">Udfaset i M68. Brug DefaultPopupsSetting i stedet.

      Få en fuld forklaring på https://www.chromestatus.com/features/5675755719622656.
      Hvis politikken er aktiveret, kan websites navigere og åbne nye vinduer/faner samtidigt.
      Hvis politikken er deaktiveret eller ikke er angivet, kan websites ikke navigere eller åbne nye vinduer/faner samtidigt.</translation>
<translation id="4680961954980851756">Aktiver AutoFyld</translation>
<translation id="4703402283970867140">Aktivér smart nedtoningsmodel for at forlænge den tid, der går, inden skærmen nedtones</translation>
<translation id="4722122254122249791">Aktivér isolering af websites for bestemte websites</translation>
<translation id="4722399051042571387">Hvis den er angivet til falsk, kan brugerne ikke angive pinkoder, der er svage og nemme at gætte.

          Eksempler på svage pinkoder: Pinkoder, der kun indeholder ét tal (1111), pinkoder, der stiger med ét tal ad gangen (1234), pinkoder, der falder med ét tal ad gangen (4321), og pinkoder, der er meget almindelige.

          Som standard får brugerne en advarsel, ikke en fejl, hvis pinkoden anses for at være svag.</translation>
<translation id="4723829699367336876">Aktiver gennemgang af firewall fra fjernklient</translation>
<translation id="4725528134735324213">Aktivér Android-tjenesten til sikkerhedskopiering</translation>
<translation id="4725801978265372736">Kræv, at navnet på den lokale bruger og ejeren af hosten for fjernadgang stemmer overens</translation>
<translation id="4733471537137819387">Politikker i forbindelse med integreret HTTP-godkendelse.</translation>
<translation id="4744190513568488164">Servere, som <ph name="PRODUCT_NAME" /> kan overdrage til.

          Adskil servernavne med kommaer. Jokertegn (*) er tilladt.

          Hvis du ikke indstiller denne politik, vil <ph name="PRODUCT_NAME" /> ikke overdrage brugeroplysninger, heller ikke selvom en server registreres som intranet.</translation>
<translation id="4752880493649142945">Klientcertifikat for etablering af forbindelse til RemoteAccessHostTokenValidationUrl</translation>
<translation id="4757671984625088193">Hvis indstillingen er angivet som Sand eller ikke er angivet, anbefaler <ph name="PRODUCT_NAME" /> sider, der er relateret til den aktuelle side.
      Disse forslag hentes fra Googles servere.

      Hvis denne indstilling er angivet som Falsk, hentes eller vises forslag ikke.</translation>
<translation id="4788252609789586009">Aktiverer funktionen AutoFyld for <ph name="PRODUCT_NAME" /> og giver brugerne mulighed for automatisk at udfylde webformularer med betalingskortoplysninger, der er gemt tidligere.

      Hvis denne indstilling er deaktiveret, foreslår eller udfylder AutoFyld aldrig betalingskortoplysninger, og der gemmes heller ikke yderligere betalingskortoplysninger, som brugeren muligvis indsender, når vedkommende er på nettet.

      Hvis denne indstilling er aktiveret eller ingen værdi har kan brugeren administrere den overordnede AutoFyld-funktion for betalingskort i brugerfladen.</translation>
<translation id="4791031774429044540">Aktivér hjælpefunktionen Stor markør.

          Hvis denne politik angives som sand, vil den store markør altid være aktiveret.

          Hvis denne politik angives som falsk, vil den store markør altid være deaktiveret.

          Hvis du angiver denne politik, kan brugerne ikke ændre eller tilsidesætte den.

          Hvis denne politik ikke angives, deaktiveres den store markør, men brugeren kan når som helst slå funktionen til.</translation>
<translation id="4802905909524200151">Konfigurering af adfærd i forbindelse med opdatering af <ph name="TPM_FIRMWARE_UPDATE_TPM" /></translation>
<translation id="4804828344300125154">Genstart altid, når brugeren logger ud.</translation>
<translation id="4807950475297505572">De brugere, der har været inaktive i længst tid, fjernes, indtil der er frigjort tilstrækkeligt med plads.</translation>
<translation id="4815725774537609998">Denne politik er forældet, brug i stedet ProxyMode.

          Giver dig mulighed for at angive den proxyserver, som anvendes af <ph name="PRODUCT_NAME" />, og forhindrer brugerne i at ændre proxyindstillingerne.

          Hvis du vælger aldrig at bruge en proxyserver og altid oprette forbindelse direkte, ignoreres alle andre valgmuligheder.

          Hvis du vælger at bruge systemets proxyindstillinger, ignoreres alle andre valgmuligheder.

          Hvis du vælger manuelle proxyindstillinger, kan du angive yderligere valgmuligheder i "Adresse eller webadresse til proxyserveren", "Webadresse til en proxyfil af typen .pac" og "Kommasepareret liste over regler for omgåelse af proxy". ARC-apps bruger kun den HTTP-proxyserver, der har højest prioritet.

          Få flere detaljerede eksempler på:

          <ph name="PROXY_HELP_URL" />.

          Hvis du aktiverer denne indstilling, ignorerer <ph name="PRODUCT_NAME" /> og ARC-apps alle proxyrelaterede valgmuligheder, der angives på kommandolinjen.

          Hvis disse politikker ikke angives, kan brugerne selv vælge proxyindstillingerne.</translation>
<translation id="4816674326202173458">Tillad, at virksomhedsbrugeren både er primær og sekundær (standardadfærd for ikke-administrerede brugere)</translation>
<translation id="4826326557828204741">Handling, der igangsættes ved inaktive forsinkelser på batteristrøm</translation>
<translation id="4832852360828533362">Bruger- og enhedsrapportering</translation>
<translation id="4834526953114077364">Brugere, der ikke har logget ind i løbet af de seneste tre måneder, fjernes, indtil der er frigjort tilstrækkeligt med plads.</translation>
<translation id="4858735034935305895">Tillad fuldskærmstilstand</translation>
<translation id="4861767323695239729">Konfigurer tilladte indtastningsmetoder i en brugersession</translation>
<translation id="487460824085252184">Migrer automatisk uden at bede om brugerens samtykke.</translation>
<translation id="4874982543810021567">Bloker WebUSB på disse websites</translation>
<translation id="4876805738539874299">Maksimalversion af SSL er aktiveret</translation>
<translation id="4897928009230106190">Angiver de parametre, der anvendes ved forslagssøgning med POST. De består af kommaseparerede navne/værdipar. Hvis en værdi er en skabelonparameter såsom {searchTerms} i ovenstående eksempel, erstattes den med rigtige søgetermdata.

          Denne politik er valgfri. Hvis dette ikke angives, sendes der søgeforslag ved hjælp af GET-metoden.

          Denne politik respekteres kun, hvis politikken "DefaultSearchProviderEnabled" er aktiveret.</translation>
<translation id="489803897780524242">Parameter, der styrer placeringen af søgeterm i standardsøgemaskinen</translation>
<translation id="4899708173828500852">Aktiver Beskyttet browsing</translation>
<translation id="4899802251198446659">Giver dig mulighed for at bestemme, om videoer skal afspilles automatisk (uden brugernes samtykke) med lydindhold i <ph name="PRODUCT_NAME" />.

      Hvis politikken er angivet som Sand, har <ph name="PRODUCT_NAME" /> tilladelse til automatisk at afspille medier.
      Hvis politikken er angivet som Falsk, har <ph name="PRODUCT_NAME" /> ikke tilladelse til automatisk at afspille medier. Politikken AutoplayWhitelist kan bruges til at tilsidesætte dette for bestemte webadressemønstre.
      <ph name="PRODUCT_NAME" /> har som standard ikke tilladelse til automatisk at afspille medier. Politikken AutoplayWhitelist kan bruges til at tilsidesætte dette for bestemte webadressemønstre.

      Bemærk! Hvis <ph name="PRODUCT_NAME" /> kører, og denne politik ændres, anvendes ændringerne kun i nye, åbne faner. Nogle faner kan derfor stadig have den tidligere adfærd.
      </translation>
<translation id="4906194810004762807">Opdateringsfrekvens for enhedspolitik</translation>
<translation id="4917385247580444890">Stærk</translation>
<translation id="4923806312383904642">Tillad, at WebDriver tilsidesætter inkompatible politikker</translation>
<translation id="494613465159630803">Cast Receiver</translation>
<translation id="494924690085329212">Genstart, når brugeren logger ud, hvis Android er startet.</translation>
<translation id="4962262530309732070">Hvis denne politik er indstillet til sand eller ikke konfigureret, tillader <ph name="PRODUCT_NAME" /> tilføjelse af personer fra brugeradministration.

      Hvis denne politik er indstillet til falsk, tillader <ph name="PRODUCT_NAME" /> ikke oprettelse af nye profiler fra brugeradministration.</translation>
<translation id="4970855112942626932">Deaktiver browserlogin</translation>
<translation id="4978405676361550165">Hvis politikken "OffHours" er angivet, ignoreres de angivne enhedspolitikker (bruges standardindstillingerne for disse politikker) i de angivne tidsrum. Enhedspolitikker anvendes igen af Chrome, hver gang tidsrummet for "OffHours" starter eller slutter. Brugeren underrettes og tvinges til at logge ud, når tidspunktet for "OffHours" slutter, og indstillinger for enhedspolitikker ændres (f.eks. når brugeren ikke er logget ind med en tilladt konto).</translation>
<translation id="4980635395568992380">Datatype:</translation>
<translation id="4983201894483989687">Tillad, at der køres forældede plugins</translation>
<translation id="4986560318567565414">Sti til Chrome ved skift fra den alternative browser.</translation>
<translation id="4988291787868618635">Påkrævet handling for inaktivitetsforsinkelse</translation>
<translation id="4995548127349206948">Om NTLMv2-godkendelse er aktiveret.</translation>
<translation id="5047604665028708335">Tillad adgang til websites uden for indholdspakker.</translation>
<translation id="5052081091120171147">Denne politik tvinger import af browserhistorikken fra den aktuelle standardbrowser, hvis den er aktiveret. Hvis denne politik er aktiveret, påvirker den også dialogboksen for import. Hvis den er deaktiveret, importeres der ikke nogen browserdata. Hvis den ikke er angivet, kan brugeren blive spurgt, om der skal importeres, ellers sker importen automatisk.</translation>
<translation id="5056708224511062314">Luppen er deaktiveret</translation>
<translation id="5058573563327660283">Vælg den strategi, der bruges til at frigøre diskplads ved automatisk oprydning (udfaset)</translation>
<translation id="5067143124345820993">Login til brugerens hvidliste</translation>
<translation id="5068140065960598044">Cloudpolitikken for <ph name="PRODUCT_NAME" /> tilsidesætter maskinpolitikken.</translation>
<translation id="5076274878326940940">Aktiverer brug af en standardsøgemaskine.

          Hvis du aktiverer denne indstilling, foretages en standardsøgning, hvis brugeren skriver tekst, der ikke er en webadresse, i omnifeltet.

          Du kan angive standardsøgemaskinen, der skal bruges, ved at angive resten af politikkerne for søgestandarder. Hvis disse efterlades tomme, kan brugeren vælge en standardsøgemaskine.

          Hvis du deaktiverer denne indstilling, foretages der ikke en søgning, hvis brugeren skriver tekst, der ikke er en webadresse, i omnifeltet.

          Hvis du aktiverer eller deaktiverer denne indstilling, kan brugerne ikke ændre eller tilsidesætte denne indstilling i <ph name="PRODUCT_NAME" />.

          Hvis denne politik ikke angives, aktiveres standardsøgemaskinen, og brugeren kan angive listen over søgemaskiner.

          Denne politik er kun tilgængelig for Windows-forekomster, der er knyttet til et <ph name="MS_AD_NAME" />-domæne, eller Windows 10 Pro- eller Enterprise-forekomster, der er tilmeldt administration af enheder.</translation>
<translation id="5085647276663819155">Deaktiver udskriftsvisning</translation>
<translation id="5090209345759901501">Brug indstillingen for Flash-indhold til alt indhold</translation>
<translation id="5093540029655764852">Angiver, hvor ofte (i dage) en klient ændrer adgangskoden til sin computerkonto. Adgangskoden genereres tilfældigt af klienten og vises ikke for brugeren.

      Ligesom brugeradgangskoder bør adgangskoder til computere ændres regelmæssigt. Hvis du deaktiverer denne politik eller angiver et stort antal dage, kan det forringe sikkerheden, da det giver potentielle hackere længere tid til at finde og bruge adgangskoden til computerkontoen.

      Hvis politikken ikke er angivet, ændres adgangskoden til computerkontoen hver 30. dag.

      Hvis politikken er indstillet til 0, deaktiveres ændring af adgangskoden til computerkontoen.

      Bemærk, at adgangskoder kan gælde i længere tid end det angivne antal dage, hvis klienten har været offline i længere tid.</translation>
<translation id="510196893779239086">Denne politik styrer, om Chrome skal lukkes helt, når den sidste fane skifter til en anden browser.

      Når denne politik ikke er konfigureret eller er angivet som sand, lader Chrome mindst én fane være åben, efter der er skiftet til en anden browser.

      Når denne politik er angivet som falsk, lukker Chrome fanen, efter der er skiftet til en anden browser, også selvom det er den sidste fane. Det betyder, at Chrome lukkes helt.</translation>
<translation id="5105313908130842249">Skærmlåsforsinkelse, når batteriet bruges</translation>
<translation id="5108031557082757679">Deaktiverede virksomhedsprintere for enheder</translation>
<translation id="5113732180192599620">Denne politik styrer listen over websites, der aldrig forårsager et browserskift.

      Bemærk, at elementer også kan føjes til denne liste via politikkerne <ph name="USE_IE_SITELIST_POLICY_NAME" /> og <ph name="EXTERNAL_SITELIST_URL_POLICY_NAME" />.

      Hvis denne politik ikke er angivet, føjes der ikke websites til listen.

      Hvis denne politik er angivet, behandles hvert element som en regel, i stil med politikken <ph name="URL_LIST_POLICY_NAME" />. Logikken er dog vendt om. Regler, der matcher, åbner ikke en alternativ browser.

      I modsætning til <ph name="URL_LIST_POLICY_NAME" /> gælder reglerne i begge retninger. Det vil sige, at når Internet Explorer-tilføjelsen er til stede og aktiveret, styrer den også, om <ph name="IE_PRODUCT_NAME" /> skal åbne disse webadresser i <ph name="PRODUCT_NAME" />.</translation>
<translation id="5130288486815037971">Afgør, om RC4-krypteringsprogrammer i TLS aktiveres</translation>
<translation id="5141670636904227950">Indstil standardtype for lup til aktiveret på loginskærmen</translation>
<translation id="5142301680741828703">Gengiv altid følgende webadressemønstre i <ph name="PRODUCT_FRAME_NAME" /></translation>
<translation id="5148753489738115745">Giver dig mulighed for at angive yderligere parametre, som bruges, når <ph name="PRODUCT_FRAME_NAME" /> starter <ph name="PRODUCT_NAME" />.

          Hvis denne politik ikke er angivet, bruges standardkommandolinjen.</translation>
<translation id="5159469559091666409">Hvor ofte der sendes netværkspakker til overvågning (angivet i millisekunder).

      Hvis denne politik ikke er indstillet, er standardfrekvensen 3 minutter. Minimumsfrekvensen er 30 sekunder, og maksimumsfrekvensen er 24 timer. Alle værdier uden for dette interval justeres automatisk, så de ligger inden for dette interval.</translation>
<translation id="5163002264923337812">Aktivér det gamle webbaserede login</translation>
<translation id="5182055907976889880">Konfigurer Google Drev i <ph name="PRODUCT_OS_NAME" />.</translation>
<translation id="5183383917553127163">Giver dig mulighed for at angive, hvilke udvidelser der ikke er omfattet af sortlisten. Værdien ​​* på en sortliste betyder, at alle udvidelser er sortlistet, medmindre de er angivet på hvidlisten. Som standard er alle udvidelser hvidlistet, men hvis alle udvidelser er blevet sortlistet på grund af en politik, kan hvidlisten bruges til at tilsidesætte denne politik.</translation>
<translation id="519247340330463721">Konfigurer politikker, der er relateret til Beskyttet browsing.</translation>
<translation id="5192837635164433517">Muliggør brugen af alternative fejlsider, der er indbygget i <ph name="PRODUCT_NAME" /> (såsom "siden blev ikke fundet") og forhindrer brugerne i at ændre denne indstilling. Hvis du aktiverer denne indstilling, anvendes alternative fejlsider. Hvis du deaktiverer denne indstilling, anvendes alternative fejlsider aldrig. Hvis du aktiverer eller deaktiverer denne indstilling, kan brugerne ikke ændre eller tilsidesætte denne indstilling i <ph name="PRODUCT_NAME" />. Hvis denne politik ikke angives, vil dette blive aktiveret, men brugeren vil kunne ændre det.</translation>
<translation id="5196805177499964601">Bloker udviklertilstand. 

Hvis denne politik er sat til True (sandt), forhindrer <ph name="PRODUCT_OS_NAME" /> enheden i at starte i udviklertilstand. Systemet vil nægte at starte og vise en fejlskærm, når udviklerkontakten slås til. 

Hvis denne politik slås fra eller indstilles til False (falsk), er udviklertilstand fortsat tilgængelig for enheden.</translation>
<translation id="520403427390290017">Funktionen til fanelivscyklus frigør CPU og i sidste ende hukommelse, der er knyttet til kørsel af faner, der ikke er brugt i lang tid. Hastigheden på sådanne faner bliver først reguleret, hvorefter fanerne fryses og til sidst kasseres.

      Hvis politikken er indstillet til falsk, deaktiveres fanelivscyklusser, og alle faner kører videre som normalt.

      Hvis politikken er indstillet til sand, eller hvis der ikke angives en værdi, aktiveres fanelivscyklusser.</translation>
<translation id="5207823059027350538">Konfigurerer webadressen for standardsiden Ny fane og forhindrer brugere i at ændre den.

          Siden Ny fane er den side, der åbnes, når der oprettes nye faner (herunder sider, der åbnes i nye vinduer).

          Denne politik bestemmer ikke, hvilke sider der åbnes ved opstart. Disse styres af <ph name="RESTORE_ON_STARTUP_POLICY_NAME" />-politikkerne. Denne politik påvirker dog startsiden, hvis den er indstillet til at åbne siden Ny fane, og opstartssiden, hvis den er indstillet til at åbne siden Ny fane.

          Hvis denne politik ikke er angivet eller efterlades tom, anvendes standardsiden Ny fane.

          Denne politik er kun tilgængelig for Windows-forekomster, der er knyttet til et <ph name="MS_AD_NAME" />-domæne, eller Windows 10 Pro- eller Enterprise-forekomster, der er tilmeldt administration af enheder.</translation>
<translation id="5208240613060747912">Giver dig mulighed for at oprette en liste med webadressemønstre, der angiver websites, hvor det ikke er tilladt at vise notifikationer. Hvis denne politik ikke angives, anvendes den globale standardværdi på alle websites, enten fra politikken "DefaultNotificationsSetting", hvis den er indstillet, eller brugerens personlige konfiguration.</translation>
<translation id="5213038356678567351">Websites, der aldrig skal aktivere et browserskift.</translation>
<translation id="5219844027738217407">I Android-apps påvirker denne politik kun mikrofonen. Når denne politik angives som Sand, slås lyden på mikrofonen fra i alle Android-apps uden undtagelser.</translation>
<translation id="5228316810085661003">Forsinkelse af automatisk login på den lokale konto på enheden.

      Hvis politikken |DeviceLocalAccountAutoLoginId| ikke er angivet, har politikken ingen effekt. Ellers:

      Hvis politikken er angivet, fastlægger den mængden af tid uden brugeraktivitet, der skal gå, før der automatisk logges ind på den lokale konto på enheden, der er angivet i politikken |DeviceLocalAccountAutoLoginId|.

      Hvis politikken ikke er angivet, anvendes 0 millisekunder som timeout.

      Denne politik angives i millisekunder.</translation>
<translation id="523505283826916779">Indstillinger for hjælpefunktioner</translation>
<translation id="5247006254130721952">Bloker farlige downloads</translation>
<translation id="5248863213023520115">Angiver krypteringstyper, som tillades, når der anmodes om Kerberos-billetter fra en <ph name="MS_AD_NAME" />-server.

      Hvis politikken er indstillet til "Alle", tillades både AES-krypteringstyperne "aes256-cts-hmac-sha1-96" og "aes128-cts-hmac-sha1-96" samt RC4-krypteringstypen "rc4-hmac". AES-kryptering har forrang, hvis serveren understøtter begge typer. Bemærk, at RC4 ikke er sikker, og serveren bør om muligt konfigureres igen for at understøtte AES-kryptering.

      Hvis politikken er indstillet til "Stærk" eller ikke er angivet, er det kun AES-krypteringstypen, som tillades.

      Hvis politikken er indstillet til "Forældet", er det kun RC4-krypteringstypen, som tillades. Denne valgmulighed er usikker og bør kun være nødvendig under meget specifikke omstændigheder.

      Se også https://wiki.samba.org/index.php/Samba_4.6_Features_added/changed#Kerberos_client_encryption_types.</translation>
<translation id="5255162913209987122">Kan anbefales</translation>
<translation id="527237119693897329">Giver dig mulighed for at angive, hvilke indbyggede beskedhosts der ikke skal indlæses.

          En sortlisteværdi på "*" betyder, at alle indbyggede beskedhosts er på sortlisten, medmindre de udtrykkeligt opføres på hvidlisten.

          Hvis ikke denne politik angives, vil <ph name="PRODUCT_NAME" /> indlæse alle installerede indbyggede beskedhosts.</translation>
<translation id="5272684451155669299">Hvis denne er angivet som sand, kan brugeren benytte hardwaren på Chrome-enheder til at fjernbekræfte sin identitet over for privatlivs-CA'en via <ph name="ENTERPRISE_PLATFORM_KEYS_API" /> med <ph name="CHALLENGE_USER_KEY_FUNCTION" />.

          Hvis denne er angivet som falsk eller ikke er angivet, vil kald til API'en mislykkes og returnere en fejlkode.</translation>
<translation id="5277806246014825877">Aktivér kørsel af Crostini for denne bruger.

      Hvis politikken er angivet som Falsk, er Crostini ikke aktiveret for brugeren.
      Hvis politikken er angivet som Sand eller ikke angivet, er Crostini aktiveret for brugeren, så længe andre indstillinger også tillader det.
      Alle tre politikker, VirtualMachinesAllowed, CrostiniAllowed og DeviceUnaffiliatedCrostiniAllowed, skal være angivet som Sand, når de anvendes, for at tillade, at Crostini køres.
      Når politikken ændres til Falsk, gælder den for opstart af nye Crostini-containere, men lukker ikke containere, som allerede kører.</translation>
<translation id="5283457834853986457">Deaktiver pluginsøgning (udfaset)</translation>
<translation id="5288772341821359899">Hvis politikken er angivet, er UDP-portintervallet, som anvendes af WebRTC, begrænset til det specifikke portinterval (inklusive slutpunkter).

      Hvis politikken ikke er angivet, eller hvis den ikke er angivet til en tom streng eller et ugyldigt portinterval, har WebRTC tilladelse til at anvende enhver tilgængelig lokal UDP-port.</translation>
<translation id="5290940294294002042">Angiv en liste over plugins, som brugeren kan aktivere eller deaktivere</translation>
<translation id="5304269353650269372">Angiver den tidsperiode uden brugerindtastning, hvorefter en dialogboks med en advarsel vises, når enheden bruger batteriet.

          Når denne politik er aktiveret, angives den tidsperiode, i hvilken brugeren ikke er aktiv, hvorefter <ph name="PRODUCT_OS_NAME" /> viser en dialogboks med en advarsel, der informerer brugeren om, at der vil blive reageret på denne inaktivitet.

          Når denne politik er deaktiveret, vises der ingen dialogboks med en advarsel.

          Værdien for politikken aktiveres inden for millisekunder. Værdierne er låste til mindre end eller det samme som inaktivitetsforsinkelsen.</translation>
<translation id="5307432759655324440">Inkognitotilstandens tilgængelighed</translation>
<translation id="5318185076587284965">Aktivér brugen af relæservere for hosten for fjernadgang</translation>
<translation id="5323128137188992869">Tillad, at indhold castes til enheden via <ph name="PRODUCT_NAME" />.

          Hvis denne politik er angivet som Falsk, kan brugerne ikke caste indhold til deres enheder. Hvis denne politik er angivet som Sand, kan brugerne caste indhold. Hvis politikken ikke er angivet, kan brugerne ikke caste indhold til tilmeldte Chrome OS-enheder, men de kan caste indhold til enheder, der ikke er tilmeldt.</translation>
<translation id="5329007337159326804">Advarsel! Politikken for den maksimale TLS-version fjernes fuldstændigt fra <ph name="PRODUCT_NAME" /> omkring version 75 (omtrent juni 2019).

      Hvis denne politik ikke konfigureres, anvender <ph name="PRODUCT_NAME" /> en standardmaksimumversion.

      Den kan også angives som en af følgende værdier: "tls1.2" eller "tls1.3". Når der er angivet en værdi, anvender <ph name="PRODUCT_NAME" /> ikke SSL/TLS-versioner, der er nyere end den angivne version. Ukendte værdier ignoreres.</translation>
<translation id="5330684698007383292">Tillad, at <ph name="PRODUCT_FRAME_NAME" /> håndterer følgende indholdstyper</translation>
<translation id="5365476955714838841">Kommandolinjeparametre for den alternative browser.</translation>
<translation id="5365946944967967336">Vis knap til startsiden på værktøjslinjen</translation>
<translation id="5366745336748853475">Giver dig mulighed for at angive en liste over webadressemønstre, som angiver websites, hvor der automatisk vælges et klientcertifikat på loginskærmen i rammen for SAML-flowet, hvis websitet anmoder om et certifikat. Et eksempel på brug er at konfigurere et certifikat for hele enheden, der præsenteres for SAML IdP.

      Værdien skal være en matrix af JSON-ordbøger i strengformat. Alle ordbøgerne skal have formatet { "pattern": "$URL_PATTERN", "filter" : $FILTER }, hvor $URL_PATTERN er et mønster for indholdsangivelse. $FILTER begrænser, hvilke klientcertifikater browseren automatisk vælger fra. Uafhængigt af filteret vælges der kun certifikater, der stemmer overens med serverens certifikatanmodning. Hvis $FILTER har formatet { "ISSUER": { "CN": "$ISSUER_CN" } }, vælges der desuden kun klientcertifikater, der er udstedt af et certifikat med CommonName $ISSUER_CN. Hvis $FILTER er den tomme ordbog {}, begrænses valget af klientcertifikater ikke yderligere.

      Hvis denne politik ikke indstilles, foretages der ingen automatiske valg for nogen websites.</translation>
<translation id="5366977351895725771">Hvis dette er angivet som falsk, vil oprettelse af administrerede brugere være deaktiveret for denne bruger. Alle eksisterende administrerede brugere vil stadig være tilgængelige.

          Hvis dette er angivet som sandt eller ikke er konfigureret, kan administrerede brugere oprettes og administreres af denne bruger.</translation>
<translation id="5369937289900051171">Kun farveudskrivning</translation>
<translation id="5370279767682621504">Aktivér understøttelse af HTTP/0.9 på ikke-standard-porte</translation>
<translation id="5378985487213287085">Giver dig mulighed for at angive, om websites må vise notifikationer på skrivebordet. Visning af notifikationer på skrivebordet kan tillades som standard, nægtes som standard, eller brugeren kan blive spurgt, hver gang et website ønsker at vise notifikationer på skrivebordet. Hvis denne politik ikke angives, anvendes "AskNotifications", og brugeren vil kunne ændre det.</translation>
<translation id="538108065117008131">Tillad, at <ph name="PRODUCT_FRAME_NAME" /> håndterer følgende indholdstyper.</translation>
<translation id="5391388690191341203">Automatisk login lokalt på enhed</translation>
<translation id="5392172595902933844">Der sendes oplysninger om status for Android tilbage til
      serveren.

      Hvis politikken indstilles til falsk eller ikke indstilles, rapporteres der ingen statusoplysninger.
      Hvis der indstilles til sand, rapporteres der statusoplysninger.

      Denne politik gælder kun, hvis Android-apps er aktiveret.</translation>
<translation id="5395271912574071439">Aktiverer skærmning af eksterne hosts, mens en forbindelse er etableret.

          Hvis denne indstilling aktiveres, deaktiveres de fysiske input- og outputenheder for hosts, mens en fjernforbindelse er etableret.

          Hvis denne indstilling deaktiveres eller ikke angives, kan både lokale brugere og fjernbrugere interagere med en host, når den deles.</translation>
<translation id="5396049152026347991">Tillad, at brugeren administrerer VPN-forbindelser.

      Hvis denne politik er angivet som falsk, deaktiveres alle <ph name="PRODUCT_NAME" />-brugerflader, der kan give brugeren mulighed for at afbryde eller ændre VPN-forbindelser.

      Hvis denne politik ikke er angivet eller angivet som sand, kan brugerne afbryde eller ændre VPN-forbindelser som normalt.

      Hvis VPN-forbindelsen oprettes via en VPN-app, berøres brugerfladen i appen ikke af denne politik. En bruger kan derfor stadig have mulighed for at bruge appen til at ændre VPN-forbindelsen.

      Denne politik er beregnet til brug sammen med funktionen "Konstant VPN", der giver administratoren mulighed for at beslutte at etablere en VPN-forbindelse ved opstart.</translation>
<translation id="5405289061476885481">Konfigurerer, hvilke tastaturlayouts der tillades på loginskærmen for <ph name="PRODUCT_OS_NAME" />.

      Hvis denne politik er angivet med en liste over indtastningsmetode-id'er, vil de angivne indtastningsmetoder være tilgængelige på loginskærmen. Den første angivne indtastningsmetode udvælges på forhånd. Mens en bruger-pod fokuserer på loginskærmen, vil den indtastningsmetode, som brugeren har brugt mindst for nylig, være tilgængelig udover de indtastningsmetoder, der er angivet i denne politik. Hvis denne politik ikke er angivet, hentes indtastningsmetoderne på loginskærmen fra den landestandard, der gælder for loginskærmen. Værdier, der ikke er gyldige indtastningsmetode-id'er, ignoreres.</translation>
<translation id="5422643441807528365"><ph name="PLUGIN_VM_NAME" />-licensnøgle</translation>
<translation id="5423001109873148185">Denne politik tvinger import af søgemaskiner fra den aktuelle standardbrowser, hvis den er aktiveret. Hvis denne politik er aktiveret, påvirker den også dialogboksen for import. Hvis standardsøgemaskinen er deaktiveret, bliver den ikke importeret. Hvis den ikke er angivet, kan brugeren blive spurgt, om der skal importeres, ellers sker importen automatisk.</translation>
<translation id="5423197884968724595">Navn på Android WebView-begrænsning:</translation>
<translation id="5424147596523390018">Tillad alle farvetilstande</translation>
<translation id="5442026853063570579">Denne politik styrer også adgangen til Indstillinger for udviklere i Android. Hvis du indstiller denne politik til "DeveloperToolsDisallowed" (værdi 2), kan brugerne ikke få adgang til Indstillinger for udviklere. Hvis du indstiller denne politik til en anden værdi eller ikke angiver den, kan brugerne få adgang til Indstillinger for udviklere ved at trykke syv gange på build-nummeret i Android-appen Indstillinger.</translation>
<translation id="544342220587994947">Giver dig mulighed for at angive en liste over webadressemønstre, som angiver websites, hvor <ph name="PRODUCT_NAME" /> automatisk skal vælge et klientcertifikat, hvis websitet anmoder om et certifikat.

          Værdien skal være en matrix af JSON-ordbøger i strengformat. Alle ordbøgerne skal have formatet { "pattern": "$URL_PATTERN", "filter" : $FILTER }, hvor $URL_PATTERN er et mønster for indholdsangivelse. $FILTER begrænser, hvilke klientcertifikater browseren automatisk kan vælge fra. Uafhængigt af filteret vælges der kun certifikater, der stemmer overens med serverens certifikatanmodning. Hvis $FILTER f.eks. har formatet { "ISSUER": { "CN": "$ISSUER_CN" } }, vælges der desuden kun klientcertifikater, der er udstedt af et certifikat med CommonName $ISSUER_CN. Hvis $FILTER indeholder sektionerne "ISSUER" og "SUBJECT", skal et klientcertifikat opfylde begge betingelser, før det kan vælges. Hvis $FILTER angiver en organisation ("O"), skal et certifikat have mindst én organisation, som stemmer overens med den angivne værdi, der skal vælges. Hvis $FILTER angiver en organisationsenhed ("OU"), skal et certifikat have mindst én organisation, som stemmer overens med den angivne værdi, der skal vælges. Hvis $FILTER er den tomme ordbog {}, begrænses valget af klientcertifikater ikke yderligere.

          Hvis politikken ikke konfigureres, foretages der ingen automatiske valg for nogen websites.</translation>
<translation id="5447306928176905178">Aktiver rapportering af hukommelsesoplysninger (størrelse på JavaScript-heap) til siden. (Udfaset)</translation>
<translation id="5457065417344056871">Aktivér delefunktion i browseren</translation>
<translation id="5457924070961220141">Giver dig mulighed for at konfigurere standard-HTML-gengivelse, når <ph name="PRODUCT_FRAME_NAME" /> er installeret. Den standardindstilling, der anvendes, når denne politik ikke er angivet, er at lade værtsbrowseren foretage gengivelsen, men du kan vælge at tilsidesætte dette og få <ph name="PRODUCT_FRAME_NAME" /> til at gengive HTML-sider som standard.</translation>
<translation id="5464816904705580310">Konfigurer indstillingerne for administrerede brugere.</translation>
<translation id="546726650689747237">Forsinkelse på skærmnedtoning, når strømforsyning er tilsluttet</translation>
<translation id="5469143988693423708">Kørsel af Crostini er aktiveret for denne bruger</translation>
<translation id="5469825884154817306">Bloker billeder på disse websites</translation>
<translation id="5472668698895343595">Denne politik styrer listen over websites, der skal åbnes i en alternativ browser.

      Bemærk, at elementer også kan føjes til denne liste via politikkerne <ph name="USE_IE_SITELIST_POLICY_NAME" /> og <ph name="EXTERNAL_SITELIST_URL_POLICY_NAME" />.

      Hvis denne politik ikke er angivet, føjes der ikke websites til listen.

      Når denne politik er angivet, behandles hvert element som en regel for noget, der skal åbnes i en alternativ browser. <ph name="PRODUCT_NAME" /> bruger disse regler, når det skal afgøres, om en webadresse skal åbnes i en alternativ browser.

      Når Internet Explorer-tilføjelsen er til stede og aktiveret, skifter Internet Explorer tilbage til <ph name="PRODUCT_NAME" />, når reglerne ikke stemmer overens.

      Hvis reglerne ikke stemmer overens, bruger <ph name="PRODUCT_NAME" /> den mest specifikke regel.</translation>
<translation id="5475361623548884387">Aktiver udskrivning</translation>
<translation id="547601067149622666">Tillad ikke annoncer på websites med påtrængende annoncer</translation>
<translation id="5499375345075963939">Denne politik er kun aktiv i detailtilstand.

      Når værdien af ​​denne politik er indstillet og ikke er 0, logges den demobruger, der i øjeblikket er logget på, automatisk ud, når vedkommende har været inaktiv i en angivet tidsperiode.

      Politikkens værdi bør angives i millisekunder.</translation>
<translation id="5511702823008968136">Aktiver bogmærkelinje</translation>
<translation id="5512418063782665071">Startsidens webadresse</translation>
<translation id="551639594034811656">Denne politik angiver en liste over procentdele, som definerer den andel af <ph name="PRODUCT_OS_NAME" />-enheder i organisationsenheden, der skal opdateres pr. dag, fra og med den dag hvor opdateringen først opdages. Tidspunktet, hvor opdateringen opdages, ligger efter det tidspunkt, hvor opdateringen udgives, da der kan gå et stykke tid, efter opdateringen udgives, til enheden søger efter opdateringer.

      Hvert (dag, procentdel)-par indeholder den procentdel af flåden, der skal opdateres inden det givne antal dage, siden opdateringen blev opdaget. Hvis vi f.eks. har parrene [(4, 40), (10, 70), (15, 100)], så skal 40 % være opdateret fire dage efter opdagelsen af opdateringen, 70 % skal være opdateret efter 10 dage osv.

      Hvis der er angivet en værdi for denne politik, ignorerer opdateringer politikken <ph name="DEVICE_UPDATE_SCATTER_FACTOR_POLICY_NAME" /> og følger denne politik i stedet.

      Hvis denne liste er tom, anvendes ingen trindeling eller opdateringer i andre enhedspolitikker.

      Denne politik gælder ikke for kanalskift.</translation>
<translation id="5526701598901867718">Alle (ikke sikkert)</translation>
<translation id="5529037166721644841">Angiver den periode i millisekunder, hvor enhedsadministrationstjenesten anmodes om brugerpolitikoplysninger.

      Angivelse af denne politik tilsidesætter standardværdien på tre timer. Gyldige værdier for denne politik ligger i intervallet fra 1800000 (30 minutter) til 86400000 (ét døgn). Alle værdier, der ikke ligger inden for dette interval, fastgøres til den respektive grænse.

      Hvis denne politik ikke angives, bruger <ph name="PRODUCT_OS_NAME" /> standardværdien på tre timer.

      Bemærk! Hvis platformen understøtter notifikationer vedrørende politik, angives forsinkelsen af opdateringen til 24 timer (der ses bort fra alle standardindstillingerne og værdierne for denne politik), da det forventes, at notifikationer vedrørende politik automatisk gennemtvinger en opdatering, når politikken ændres. Dermed er hyppige opdateringer ikke nødvendige.</translation>
<translation id="5530347722229944744">Bloker potentielt farlige downloads</translation>
<translation id="5535973522252703021">Hvidliste for Kerberos-delegeringsserver</translation>
<translation id="555077880566103058">Giv alle websites tilladelse til at køre <ph name="FLASH_PLUGIN_NAME" />-pluginnet automatisk</translation>
<translation id="5559079916187891399">Denne politik påvirker ikke Android-apps.</translation>
<translation id="5560039246134246593">Tilføj en parameter til hentning af variationbasistal i <ph name="PRODUCT_NAME" />.

      Hvis dette er angivet, føjes der en forespørgselsparameter med navnet "restrict" til den webadresse, der bruges til at hente variationbasistallet. Værdien for parameteren er den værdi, der er angivet i denne politik.

      Hvis dette ikke er angivet, ændres variationbasistallet ikke.</translation>
<translation id="5561811616825571914">Vælg automatisk klientcertifikater til disse websites på loginskærmen</translation>
<translation id="5566210228171064229">Tillad, at der udskrives med og uden pinkode</translation>
<translation id="556941986578702361">Administrer, hvornår <ph name="PRODUCT_OS_NAME" />-hylden skjules automatisk.

      Hvis denne politik er angivet som "AlwaysAutoHideShelf'", skjules hylden altid automatisk.

      Hvis denne politik er angivet som "NeverAutoHideShelf', skjules hylden aldrig automatisk.

      Hvis du indstiller denne politik, kan brugere ikke ændre eller tilsidesætte den.

      Hvis politikken ikke indstilles, kan brugere vælge, om hylden skal skjules automatisk.</translation>
<translation id="557360560705413259">Når denne indstilling er aktiveret, bruger <ph name="PRODUCT_NAME" /> commonName for et servercertificat til at matche et hostnavn, hvis certifikatet mangler en subjectAlternativeName-udvidelse, såfremt det kan godkendes og kobles til lokalt installerede CA-certifikater.

      Bemærk, at dette ikke anbefales, da det kan tillade tilsidesættelse af udvidelsen nameConstraints, som begrænser de hostnavne, et givet certifikat kan godkendes til.

      Hvis denne politik ikke er indstillet eller er indstillet til falsk, anses servercertifikater, som ikke indeholder en subjectAlternativeName-udvidelse med enten et DNS-navn eller en IP-adresse, ikke for pålidelige.</translation>
<translation id="5581292529942108810">Konfigurer politikker, der er relateret til Chrome Reporting Extension.

      Disse politikker gælder kun, hvis <ph name="CHROME_REPORTING_EXTENSION_NAME" /> er aktiveret, og maskinen er tilmeldt <ph name="MACHINE_LEVEL_USER_CLOUD_POLICY_ENROLLMENT_TOKEN_POLICY_NAME" />.</translation>
<translation id="5584132346604748282">Styring af Googles placeringstjenester på Android-enheder</translation>
<translation id="5586942249556966598">Gør ingenting</translation>
<translation id="5590494712401018042">Angiver den procentdel, som nedtoningsforsinkelsen på skærmen skaleres med, når enheden er i præsentationstilstand.

          Hvis denne politik er konfigureret, angives den procentdel, som nedtoningsforsinkelsen på skærmen skaleres med, når enheden er i præsentationstilstand. Når nedtoningsforsinkelsen på skærmen er skaleret, tilpasses skærmsluk, skærmlås og inaktive forsinkelser for at bevare de samme afstande fra nedtoningsforsinkelsen på skærmen som i den oprindelige konfiguration.

          Hvis politikken ikke er konfigureret, anvendes en standardfaktor til skalering.

          Politikken anvendes kun, hvis <ph name="POWER_SMART_DIM_ENABLED_POLICY_NAME" /> er deaktiveret. Hvis ikke det er tilfældet, ignoreres politikken, da nedtoningsforsinkelsen på skærmen afhænger af en model til maskinlæring.

          Skaleringsfaktoren skal være mindst 100 %. Værdier, der forkorter nedtoningsforsinkelsen på skærmen i præsentationstilstand i forhold til den normale nedtoningsforsinkelse, er ikke tilladt.</translation>
<translation id="5592242031005200087">
      Hvis politikken er aktiveret, kører hvert af de angivne websites
      på en kommasepareret liste sin egen proces. Dette isolerer også websites,
      der er angivet af underdomæner. Hvis f.eks. https://eksempel.dk/ angives,
      isoleres https://foo.eksempel.dk/ også som en del af
      websitet https://eksempel.dk/.
      Hvis politikken er deaktiveret, sker der ingen udtrykkelig isolering af websites, og brugstest af IsolateOriginsAndroid og SitePerProcessAndroid deaktiveres. Brugere kan stadig aktivere IsolateOrigins manuelt via kommandolinjerapportering.
      Hvis politikken ikke konfigureres, kan brugerne ændre denne indstilling.

      BEMÆRK! Isolering af websites er eksperimentel på Android-enheder. Understøttelsen bliver bedre med tiden, men den kan i øjeblikket forårsage problemer med ydeevnen.

      BEMÆRK! Politikken gælder kun for Chrome på Android-enheder med mere end 1 GB RAM. Hvis du vil anvende politikken på andre platforme, skal du bruge IsolateOrigins.
      </translation>
<translation id="5599461642204007579">Indstillinger for administration via <ph name="MS_AD_NAME" /></translation>
<translation id="5630352020869108293">Gendan den seneste session</translation>
<translation id="5645779841392247734">Tillad cookies på disse websites</translation>
<translation id="5689430183304951538">Standardstørrelse for udskrivningsside</translation>
<translation id="5693469654327063861">Tillad datamigrering</translation>
<translation id="5694594914843889579">Hvis denne politik er indstillet til Sand, vil eksternt lager ikke være tilgængelig i filbrowseren.

      Denne politik omfatter alle typer lagermedier, f.eks. USB-nøgler, eksterne harddiske, SD- og andre hukommelseskort, optisk lagring m.v. Det interne lager påvirkes ikke, derfor er der stadig adgang til filer, der er gemt i mappen Download. Google Drev er heller ikke omfattet af denne politik.

      Hvis denne indstilling er deaktiveret eller ikke er konfigureret, kan brugerne benytte alle understøttede eksterne lagertyper på deres enhed.</translation>
<translation id="5697306356229823047">Rapportér enhedsbrugere</translation>
<translation id="5699487516670033016">Angiver levetiden (i timer) for cachen med godkendelsesdata. Cachen bruges til at gøre det hurtigere at logge ind. Den indeholder generelle data (f.eks. navn på arbejdsgruppe) om tilknyttede domæner, f.eks. domæner, som maskinens domæne anser for pålidelige. Der cachelagres ingen brugerspecifikke data og ingen data for ikke-tilknyttede domæner. Når enheden genstartes, ryddes cachen.

      Hvis politikken ikke er angivet, kan cachelagrede godkendelsesdata genbruges i op til 73 timer.

      Hvis politikken er angivet til 0, er cachelagring af godkendelsesdata slået fra. Dette kan gøre login af tilknyttede brugere betragteligt langsommere, fordi der skal hentes domænespecifikke data ved hvert login.

      Bemærk, at domænedata også cachelagres for engangsbrugere. Cachen skal slås fra, hvis cachelagring af domænet for engangsbrugere skal forhindres.</translation>
<translation id="570062449808736508">Når denne politik er angivet til en udfyldt streng, læser WebView webadressebegrænsninger fra indholdsudbyderen med det angivne myndighedsnavn.</translation>
<translation id="5701714006401683963">Hvis denne politik er angivet som falsk, reagerer administrerede gæstesessioner som beskrevet på https://support.google.com/chrome/a/answer/3017014 – standarden for "Offentlig session".

      Hvis politikken er angivet som sand eller ikke er angivet, har administrerede gæstesessioner samme adfærd som "Administreret session", hvilket fjerner mange af de begrænsninger, der gælder for "Offentlige sessioner".

      Hvis politikken er konfigureret, kan den ikke ændres eller tilsidesættes af brugeren.</translation>
<translation id="572155275267014074">Indstillinger for Android</translation>
<translation id="5722934961007828462">Når denne indstilling er aktiveret, vil <ph name="PRODUCT_NAME" /> altid forsøge at søge efter tilbagekaldelse af servercertifikater, som validerer og er signeret af lokalt installerede CA-certifikater.

      Hvis <ph name="PRODUCT_NAME" /> ikke kan hente oplysninger om tilbagekaldelsesstatus, bliver sådanne certifikater behandlet som tilbagekaldt ("alvorlig fejl").

      Hvis denne politik ikke er angivet eller angivet som falsk, vil <ph name="PRODUCT_NAME" /> anvende de eksisterende indstillinger for onlinesøgning efter tilbagekaldelser.</translation>
<translation id="5728154254076636808">Aktivér oprettelse af roamingkopier til profildata i <ph name="PRODUCT_NAME" />.</translation>
<translation id="5732972008943405952">Importér formulardata for AutoFyld fra standardbrowseren ved første visning</translation>
<translation id="5765780083710877561">Beskrivelse:</translation>
<translation id="5770738360657678870">Udviklerkanal (kan være ustabil)</translation>
<translation id="5774856474228476867">Søgewebadresse for standardsøgemaskinen</translation>
<translation id="5776485039795852974">Spørg hver gang et website vil vise skrivebordsunderretninger</translation>
<translation id="5781412041848781654">Angiver, hvilket GSSAPI-bibliotek der skal anvendes til HTTP-godkendelse. Du kan enten angive et biblioteksnavn eller en hel sti.

          Hvis der ikke angives en indstilling, går <ph name="PRODUCT_NAME" /> tilbage til at bruge et standardbiblioteksnavn.</translation>
<translation id="5781806558783210276">Angiver den tid uden brugerinput, der aktiverer inaktivitetshandlingen, når batteriet bruges.

          Hvis denne politik indstilles, angives den tid, som brugeren skal være inaktiv, før <ph name="PRODUCT_OS_NAME" /> effektuerer inaktivitetshandlingen, som kan konfigureres separat.

          Hvis denne politik ikke indstilles, anvendes standardindstillingen.

          Politikkens værdi skal angives i millisekunder.</translation>
<translation id="5783009211970309878">Udskriv sidehoveder og sidefødder</translation>
<translation id="5809210507920527553">Styrer indstillinger for Linux-containeren (Crostini).</translation>
<translation id="5809728392451418079">Indstil det viste navn for enhedslokale konti</translation>
<translation id="5814301096961727113">Indstil standardtilstanden for talefeedback på loginskærmen</translation>
<translation id="5815129011704381141">Automatisk genstart efter opdatering</translation>
<translation id="5815353477778354428">Konfigurerer den mappe, som <ph name="PRODUCT_FRAME_NAME" /> bruger til at lagre brugerdata.

      Hvis du angiver denne politik, vil <ph name="PRODUCT_FRAME_NAME" /> bruge den angivne mappe.

      Du kan se en liste over variabler, der kan anvendes, på http://www.chromium.org/administrators/policy-list-3/user-data-directory-variables.

      Hvis denne indstilling ikke angives, anvendes standardprofilmappen.</translation>
<translation id="5826047473100157858">Angiver, om brugeren kan åbne sider i inkognitotilstand i <ph name="PRODUCT_NAME" />. Hvis "Aktiveret" er valgt, eller hvis politikken ikke angives, kan siderne åbnes i inkognitotilstand. Hvis "Deaktiveret" er valgt, kan sider ikke åbnes i inkognitotilstand. Hvis "Tvunget" er valgt, kan siderne kun åbnes i inkognitotilstand.</translation>
<translation id="582857022372205358">Aktivér duplex-udskrivning med kort kant</translation>
<translation id="583091600226586337">
      Hvis politikken er aktiveret, bliver brugeren spurgt inden download, hvor de enkelte filer skal gemmes.
      Hvis politikken er deaktiveret, starter downloads med det samme, og brugeren bliver ikke spurgt, hvor filen skal gemmes.
      Hvis politikken ikke er konfigureret, kan brugeren ændre denne indstilling.
      </translation>
<translation id="5832274826894536455">Udfasede politikker</translation>
<translation id="5835124959204887277">Angiver webadresser og domæner, for hvilke der ikke vises en meddelelse, når der anmodes om attesteringscertifikater fra sikkerhedsnøgler. Desuden sendes et signal til sikkerhedsnøglen, som indikerer, at der kan anvendes individuel attestering. Uden dette får brugerne en meddelelse i version 65 og nyere af Chrome, når websites anmoder om attestering af sikkerhedsnøgler.

      Webadresser (såsom https://eksempel.dk/en/sti) matcher kun som U2F-app-id'er. Domæner (såsom eksempel.dk) matcher kun som webauthn RP-id'er. Derfor skal både app-id, webadresse og domæne angives for at dække både U2F- og webauthn-API'er for et givet website.</translation>
<translation id="5836064773277134605">Begræns rækkevidden for den UDP-port, der bruges af hosten for fjernadgang</translation>
<translation id="5861856285460256766">Konfiguration af forældreadgangskode</translation>
<translation id="5862253018042179045">Angiv standardtilstanden for hjælpefunktionen Talefeedback på loginskærmen.

          Hvis denne politik angives som sand, aktiveres talefeedback, når loginskærmen vises.

          Hvis denne politik angives som falsk, deaktiveres talefeedback, når loginskærmen vises.

          Hvis du angiver denne politik, kan brugerne midlertidigt tilsidesætte den ved at aktivere eller deaktivere talefeedback. Brugerens valg er dog ikke endegyldigt, og standarden gendannes, når loginskærmen vises igen, eller hvis brugeren forbliver inaktiv på loginskærmen i et minut.

          Hvis denne politik ikke angives, deaktiveres talefeedback, når loginskærmen vises første gang. Brugerne kan når som helst aktivere eller deaktivere talefeedback, og dens status på loginskærmen fastholdes hos brugerne.</translation>
<translation id="5868414965372171132">Netværkskonfiguration på brugerniveau</translation>
<translation id="5879014913445067283">Kontrollerer registrering for Fildeling via netværk via <ph name="NETBIOS_NAME" /></translation>
<translation id="5882345429632338713">Forsinkelse inden opstart af en alternativ browser (millisekunder)</translation>
<translation id="5883015257301027298">Standardindstilling for cookies</translation>
<translation id="5887414688706570295">Konfigurerer det TalkGadget-præfiks, der anvendes af værter med fjernadgang, og forhindrer brugere i at ændre det.

          Hvis præfikset er angivet, indsættes det foran basisnavnet på TalkGadget for at oprette et fuldt domænenavn til TalkGadget. Basisdomænenavnet for TalkGadget er ".talkgadget.google.com".

          Hvis denne indstilling er aktiveret, anvender værterne det brugerdefinerede domænenavn, når de forsøger at få adgang til TalkGadget i stedet for standarddomænenavnet.

          Hvis indstillingen er aktiveret eller ikke angivet, anvendes standarddomænenavnet for TalkGadget ("chromoting-host.talkgadget.google.com") for alle værter.

          Klienter med fjernadgang påvirkes ikke af denne politikindstilling. De anvender altid "chromoting-client.talkgadget.google.com" til at få adgang til TalkGadget.</translation>
<translation id="5893553533827140852">Hvis denne indstilling er aktiveret, oprettes der en proxyforbindelse for anmodninger om gnubby-godkendelse på tværs af en fjernhostforbindelse.

          Hvis denne indstilling er deaktiveret eller ikke er konfigureret, oprettes der ingen proxyforbindelse for anmodninger om gnubby-godkendelse.</translation>
<translation id="5898486742390981550">Når flere brugere er logget ind, er det kun den primære bruger, der kan bruge Android-apps.</translation>
<translation id="5900196529149231477">
      Politikken gælder for loginskærmen. Se også politikken <ph name="ISOLATE_ORIGINS_POLICY_NAME" />, som gælder for brugersessionen. Det anbefales, at der angives den samme værdi for begge politikker. Hvis politikkerne har forskellige værdier, kan der ske forsinkelser ved opstart af en brugersession, mens den værdi, der er angivet af brugerpolitikken, anvendes.
      Hvis politikken er aktiveret, kører hvert af de angivne websites på en kommasepareret liste sin egen proces. Dette isolerer også websites, der er angivet af underdomæner. Hvis f.eks. https://eksempel.dk/ angives, isoleres https://foo.eksempel.dk/ også som en del af websitet https://eksempel.dk/.
      Hvis politikken er deaktiveret, deaktiveres begge funktionerne IsolateOrigins og SitePerProcess. Brugere kan stadig aktivere IsolateOrigins manuelt via kommandolinjerapportering.
      Hvis politikken ikke konfigureres, anvendes platformens standardindstillinger for isolering af websites på loginskærmen.
      </translation>
<translation id="5901427587865226597">Kun duplex-udskrivning</translation>
<translation id="5906199912611534122">Gør det muligt at aktivere eller deaktivere netværksbegrænsning.
      Dette gælder for alle brugere og for alle grænseflader på enheden. Når denne indstilling er valgt,
      beholdes begrænsningen, indtil politikken ændres for at deaktivere den.

      Hvis den er angivet som falsk, er der ingen begrænsning.
      Hvis den er angivet som sand, er systemet begrænset for at opnå de angivne upload- og downloadhastigheder (i kbits/s).</translation>
<translation id="5921713479449475707">Tillad download af automatiske opdateringer via HTTP</translation>
<translation id="5921888683953999946">Indstil standardtilstanden for hjælpefunktionen med den store markør på loginskærmen.

          Hvis denne politik angives som sand, vil den store markør være aktiveret, når loginskærmen vises.

          Hvis denne politik angives som falsk, vil den store markør være deaktiveret, når loginskærmen vises.

          Hvis du angiver denne politik, kan brugerne midlertidigt tilsidesætte den ved at slå den store markør til eller fra. Men brugerens valg er ikke endegyldigt, og standarden gendannes, når loginskærmen vises igen, eller hvis brugeren forbliver inaktiv på loginskærmen i et minut.

          Hvis denne politik ikke angives, deaktiveres den store markør, når loginskærmen vises første gang. Brugerne kan når som helst aktivere eller deaktivere den store markør, og dens status på loginskærmen fastholdes hos brugerne.</translation>
<translation id="5929855945144989709">Tillader, at enheder kan køre virtuelle maskiner i Chrome OS</translation>
<translation id="5932767795525445337">Denne politik kan også bruges til at fastgøre Android-apps.</translation>
<translation id="5936622343001856595">Gennemtvinger, at forespørgsler i Google Websøgning bliver udført, mens Beskyttet søgning er indstillet til aktiv, og forhindrer brugere i at ændre denne indstilling.

      Hvis du aktiverer denne indstilling, vil Beskyttet søgning i Google Søgning altid være aktiv.

      Hvis du deaktiverer denne indstilling eller ikke konfigurerer en værdi, håndhæves Beskyttet søgning i Google Søgning ikke.</translation>
<translation id="5946082169633555022">Betakanal</translation>
<translation id="5950205771952201658">Set i lyset af, at ikke-omfattende tilbagekaldskontroller på nettet ikke giver nogen effektiv form for sikkerhed, er disse deaktiveret som standard i <ph name="PRODUCT_NAME" /> version 19 og nyere. Ved at angive denne politik til Sand gendannes de tidligere indstillinger, så der udføres OCSP/CRL-kontroller på nettet.

      Hvis politikken ikke er angivet eller er angivet til Falsk, udfører <ph name="PRODUCT_NAME" /> ikke tilbagekaldskontroller på nettet i <ph name="PRODUCT_NAME" /> 19 og nyere.</translation>
<translation id="5966615072639944554">Udvidelser har tilladelse til at bruge Remote Attestation API.</translation>
<translation id="5983708779415553259">Standardadfærd for websites, der ikke findes i en indholdspakke</translation>
<translation id="5997543603646547632">Brug 24-timers ur som standard</translation>
<translation id="5997846976342452720">Angiv, om pluginsøgning skal deaktiveres (udfaset)</translation>
<translation id="6017568866726630990">Vis systemets udskriftsdialog i stedet for udskriftseksempel.

      Når denne indstilling er aktiveret, åbnes <ph name="PRODUCT_NAME" /> systemets udskriftsdialog i stedet for det indbyggede udskriftseksempel, når en bruger anmoder om en side, der skal udskrives.

      Hvis denne politik ikke er indstillet eller er indstillet til falsk, aktiverer udskriftskommandoer skærmen Vis udskrift.</translation>
<translation id="6022948604095165524">Handling ved opstart</translation>
<translation id="6023030044732320798">Angiver en række politikker, der overgives til ARC-kørselstiden. Værdien skal være en gyldig JSON.

      Denne politik kan bruges til at konfigurere, hvilke Android-apps der automatisk installeres på enheden:

      {
        "type": "object",
        "properties": {
          "applications": {
            "type": "array",
            "items": {
              "type": "object",
              "properties": {
                "packageName": {
                  "description": "Id for Android-app, f.eks. "com.google.android.gm" for Gmail",
                  "type": "string"
                },
                "installType": {
                  "description": "Specificerer, hvordan en app installeres. OPTIONAL: Appen installeres ikke automatisk, men brugeren kan installere den. Dette er standarden, hvis denne politik ikke er angivet. PRELOAD: Appen installeres automatisk, men brugeren kan afinstallere den. FORCE_INSTALLED: Appen installeres automatisk, og brugeren kan ikke afinstallere den. BLOCKED: Appen er blokeret og kan ikke installeres. Hvis appen er blevet installeret i overensstemmelse med en tidligere politik, afinstalleres den.",
                  "type": "string",
                  "enum": [
                    "OPTIONAL",
                    "PRELOAD",
                    "FORCE_INSTALLED",
                    "BLOCKED"
                  ]
                },
                "defaultPermissionPolicy": {
                  "description": "Politik for godkendelse af appanmodninger om tilladelse. PERMISSION_POLICY_UNSPECIFIED: Politikken er ikke angivet. Hvis der ikke er angivet en politik for en tilladelse på noget niveau, bruges funktionsmåden 'PROMPT' som standard. PROMPT: Brugeren anmodes om at give tilladelse. GRANT: Giv automatisk tilladelse. DENY: Afvis automatisk at give tilladelse.",
                  "type": "string",
                  "enum": [
                    "PERMISSION_POLICY_UNSPECIFIED",
                    "PROMPT",
                    "GRANT",
                    "DENY"
                  ]
                },
                "managedConfiguration": {
                  "description": "App-specifik JSON-konfigurationsobjekt med en række nøgleværdipar, f.eks. '"managedConfiguration": { "nøgle1": værdi1, "nøgle2": værdi2 }'. Nøglerne er defineret i appens manifest",
                  "type": "object"
                }
              }
            }
          }
        }
      }

      Se PinnedLauncherApps, hvis du vil fastgøre apps til Appliste.</translation>
<translation id="602728333950205286">Direkte webadresse til standardsøgemaskinen</translation>
<translation id="603410445099326293">Parametre for forslagswebadresser, som anvender POST</translation>
<translation id="6034341625190551415">Styrer offentlige kontotyper og terminalkontotyper.</translation>
<translation id="6036523166753287175">Aktiver gennemgang af firewall fra vært for fjernadgang</translation>
<translation id="6070667616071269965">Tastaturlayouts for loginskærme på enheder</translation>
<translation id="6074963268421707432">Tillad ikke, at websites viser skrivebordsunderretninger</translation>
<translation id="6074964551275531965">Angiv tidsrummet for notifikationer om opdateringer</translation>
<translation id="6076099373507468537">Definerer listen over USB-enheder, der gerne må frigøres fra deres kernedriver, så de kan bruges via chrome.usb API direkte i en webapp. Poster er par bestående af et USB-leverandør-id og et produkt-id til identifikation af en bestemt hardware.

      Hvis denne politik ikke konfigureres, er listen over USB-enheder, der kan frigøres, tom.</translation>
<translation id="6083631234867522991">Windows (Windows-klienter):</translation>
<translation id="6089679180657323464">Styrer indstillingerne for Wilco DTC (Diagnostics and Telemetry Controller).</translation>
<translation id="6091233616732024397">Kræv, at brugerne logger ind for at bruge browseren</translation>
<translation id="6093156968240188330">Giv eksterne brugere tilladelse til at interagere med vinduer med administratorrettigheder i eksterne hjælpesessioner</translation>
<translation id="6095999036251797924">Angiver det tidsrum uden input fra brugeren, der går, før skærmen låses, når enheden kører på strømforsyning eller batteri.

          Når der er angivet et tidsrum over nul, angiver værdien, hvor lang tid brugeren skal være inaktiv, før <ph name="PRODUCT_OS_NAME" /> låser skærmen.

          Når det angivne tidsrum er nul, låser <ph name="PRODUCT_OS_NAME" /> ikke skærmen, når brugeren bliver inaktiv.

          Når der ikke er angivet et tidsrum, bruges et standardtidsrum.

          Den anbefalede metode til skærmlåsning, når brugeren er inaktiv, er at aktivere skærmlåsning ved midlertidigt stop og få <ph name="PRODUCT_OS_NAME" /> til at stoppe midlertidigt efter den angivne forsinkelse for inaktivitet. Denne politik bør kun anvendes, når skærmen skal låses en betydelig mængde tid før det midlertidige stop, eller når det midlertidige stop i forbindelse inaktivitet slet ikke ønskes.

          Værdien for politikken bør angives i millisekunder. Værdierne skal være mindre end forsinkelsen for inaktivitet.</translation>
<translation id="6097601282776163274">Aktivér anonym dataindsamling fra indtastede webadresser</translation>
<translation id="6099853574908182288">Farvetilstand for standardudskrivning</translation>
<translation id="6107642964266628393">Styrer, hvordan og hvornår Chrome OS-opdateringer anvendes.</translation>
<translation id="6111936128861357925">Tillad det ekstra dinosaurspil</translation>
<translation id="6114416803310251055">frarådet</translation>
<translation id="6133088669883929098">Tillad alle websites at anvende nøglegenerering</translation>
<translation id="6145799962557135888">Giver dig mulighed for at oprette en liste med webadressemønstre, der angiver websites, der får lov til at køre JavaScript. Hvis denne politik ikke angives, anvendes den globale standardværdi på alle websites, enten fra politikken "DefaultJavaScriptSetting", hvis den er indstillet, eller brugerens personlige konfiguration.</translation>
<translation id="614662973812186053">Denne politik styrer også indsamling af brugs- og diagnosticeringsdata i Android.</translation>
<translation id="6153048425064249648">Denne politik styrer <ph name="PRODUCT_NAME" />-rapportering i skyen, som uploader oplysninger om browseranvendelse til Google Administrationskonsol.

      Når politikken er angivet som Falsk eller ikke er konfigureret, indsamles og uploades der ikke nogen data.
      Når politikken er angivet som Sand, indsamles og uploades der data til Google Administrationskonsol.
      Du kan bestemme, hvilke data der uploades, ved at bruge politikkerne i gruppen Chrome Reporting Extension.

      Politikken anvendes kun, når maskinen er tilmeldt <ph name="MACHINE_LEVEL_USER_CLOUD_POLICY_ENROLLMENT_TOKEN_POLICY_NAME" />.

      Politikken gennemtvinger installation af <ph name="CHROME_REPORTING_EXTENSION_NAME" /> til rapportering og tilsidesætter alle udvidelsespolitikker, der er relateret til den pågældende udvidelse.</translation>
<translation id="6155247658847899816">Når politikken er konfigureret, indstilles opløsningen og skaleringsfaktoren for hver
      skærm til de angivne værdier. Indstillingerne for eksterne skærme anvendes
      for alle tilsluttede eksterne skærme.

      Værdierne for "external_width" og "external_height" skal angives i
      pixel. Værdierne for "external_scale_percentage" og
      "internal_scale_percentage" skal angives i procenter.

      Hvis "external_use_native" angives som sand, ignorerer politikken værdierne for
      "external_height" og "external_width", og opløsningen for eksterne skærme
      indstilles til deres indbyggede opløsning.

      Hvis "external_use_native" angives som falsk eller ikke konfigureres, og enten
      "external_height" eller "external_width" ikke er konfigureret, påvirker politikken
      ikke indstillingerne for eksterne skærme. Hvis den angivne opløsning eller
      skaleringsfaktor ikke understøttes af en skærm, anvendes politikken ikke
      for den pågældende skærm.

      Hvis demofunktionen "anbefalet" angives som sand, kan brugere ændre opløsning
      og skaleringsfaktor for alle skærme via siden med indstillinger, efter de er logget ind, men
      deres indstillinger tilsidesættes af politikværdien ved næste genstart.
      Hvis demofunktionen "anbefalet" angives som falsk eller ikke konfigureres, kan brugere ikke
      ændre skærmindstillingerne.</translation>
<translation id="6155936611791017817">Indstil standardtilstand for den store markør på loginskærmen</translation>
<translation id="6157537876488211233">Kommasepareret liste over regler for omgåelse af proxy</translation>
<translation id="6158324314836466367">Navn på virksomhedens webshop (udfaset)</translation>
<translation id="6181608880636987460">Giver dig mulighed for at angive en liste med webadressemønstre, der angiver websites, som ikke har tilladelse til at køre <ph name="FLASH_PLUGIN_NAME" />-pluginnet.

          Hvis denne politik ikke angives, anvendes den globale standardværdi for alle websites enten fra politikken "DefaultPluginsSetting", hvis denne er angivet, og ellers fra brugerens personlige konfiguration.</translation>
<translation id="6190022522129724693">Standardindstillinger for pop op-vinduer</translation>
<translation id="6190367314942602985">Rapportér oplysninger om brugeridentifikation</translation>
<translation id="6197453924249895891">Giver virksomhedsnøgler adgang til udvidelser.

Nøgler er beregnet til virksomhedsbrug, hvis de er genereret ved hjælp af chrome.enterprise.platformKeys API på en administreret konto. Nøgler, der er importeret eller genereret på en anden måde, er ikke beregnet til virksomhedsbrug.

Adgang til nøgler, der er beregnet til virksomhedsbrug, kontrolleres alene af denne politik. Brugeren kan hverken give udvidelser adgang til virksomhedsnøgler eller fjerne deres adgang.

En udvidelse kan som standard ikke benytte en nøgle, der er beregnet til virksomhedsbrug, hvilket svarer til at angive allowCorporateKeyUsage som "falsk" for udvidelsen.

Kun hvis allowCorporateKeyUsage er angivet som "sand" for en udvidelse, kan den benytte en hvilken som helst platformnøgle, der er markeret til virksomhedsbrug, til at signere vilkårlige data. Denne tilladelse bør kun gives, hvis du har tillid til, at udvidelsen beskytter nøglen, så hackere ikke kan få adgang til den.</translation>
<translation id="6208896993204286313">Rapportér oplysninger om politik for <ph name="PRODUCT_NAME" /></translation>
<translation id="6210259502936598222">Rapportér oplysninger om operativsystem og version for <ph name="PRODUCT_NAME" /></translation>
<translation id="6210610748361191729">Hvis politikken er angivet som Falsk, har brugerne ikke adgang til brugerfladen for eksport/import. De kan dog stadig bruge kommandoer af typen "lxc" direkte i den virtuelle maskine til at eksportere og importere containerbilleder.</translation>
<translation id="6211428344788340116">Rapportér tidspunkter for aktivitet på enheden.

      Hvis denne indstilling ikke er angivet eller er angivet til Sand, rapporterer tilmeldte enheder de tidsperioder, hvor en bruger er aktiv på enheden. Hvis den er er angivet til Falsk, registreres og rapporteres tidspunkter for aktivitet ikke på enheden.</translation>
<translation id="6212868225782276239">Alle printere vises, bortset fra dem på sortlisten.</translation>
<translation id="6219965209794245435">Denne politik tvinger formulardataene for AutoFyld til at blive importeret fra den foregående standardbrowser, hvis politikken er aktiveret. Hvis denne politik er aktiveret, påvirker den også importdialogboksen.

      Hvis den er deaktiveret, importeres formulardata for AutoFyld ikke.

      Hvis den ikke er indstillet, kan brugeren blive spurgt, om der skal importeres, eller også kan import ske automatisk.</translation>
<translation id="6224304369267200483">Webadresser/domæner tillader automatisk direkte attestering af sikkerhedsnøgler</translation>
<translation id="6233173491898450179">Angiv mappen til download</translation>
<translation id="6244210204546589761">Webadresser, der skal åbnes ved opstart</translation>
<translation id="6258193603492867656">Angiver, om den genererede Kerberos-SPN skal omfatte en port, der ikke er standard. Hvis du aktiverer denne indstilling, og en port, der ikke er standard (dvs. en anden port end 80 eller 443), angives, vil den indgå i den genererede Kerberos-SPN. Hvis du deaktiverer denne indstilling, vil den genererede Kerberos-SPN aldrig omfatte en port.</translation>
<translation id="6261643884958898336">Rapportér oplysninger om maskinidentifikation</translation>
<translation id="6281043242780654992">Konfigurerer politikker for indbyggede beskedhosts. Indbyggede beskedhosts på spærrelisten vil ikke blive tilladt, medmindre de er på hvidlisten.</translation>
<translation id="6282799760374509080">Tillad eller afvis lydoptagelse</translation>
<translation id="6284362063448764300">TLS 1.1</translation>
<translation id="6310223829319187614">Aktivér autofuldførelse af domænenavn under brugers login</translation>
<translation id="6315673513957120120">Chrome viser en advarselsside, når brugerne går til websites med SSL-fejl. Som standard, eller når denne politik er angivet til sand, kan brugerne klikke sig videre fra disse advarselssider.
      Hvis denne politik angives til falsk, kan brugerne ikke klikke sig videre fra nogen advarselssider.</translation>
<translation id="6352543686437322588">Automatisk login på en lokal konto på enheden efter en forsinkelse.

      Hvis politikken er angivet, logges der automatisk ind på den angivne session, når der er gået en mængde tid på loginskærmen uden brugerinteraktion. Den lokale konto på enheden skal allerede være konfigureret (se |DeviceLocalAccounts|).

      Hvis denne politik ikke er angivet, bliver der ikke automatisk logget ind.</translation>
<translation id="6353901068939575220">Specificerer de anvendte parametre ved søgning efter en webadresse med POST. De består af kommaseparerede navne/værdipar. Hvis en værdi er en skabelonparameter såsom {searchTerms} i ovenstående eksempel, erstattes de med rigtige søgetermdata.

          Denne politik er valgfri. Hvis den ikke angives, sendes der søgeanmodninger ved hjælp af GET-metoden.

          Denne politik respekteres kun, hvis politikken "DefaultSearchProviderEnabled" er aktiveret.</translation>
<translation id="6367755442345892511">Om udgivelseskanalen skal konfigureres af brugeren</translation>
<translation id="6368011194414932347">Konfigurer webadressen for startsiden</translation>
<translation id="6368403635025849609">Tillad JavaScript på disse websites</translation>
<translation id="6376659517206731212">Kan være obligatorisk</translation>
<translation id="6377355597423503887">Denne politik er udfaset. Overvej at bruge BrowserSignin i stedet.

      Tillader, at brugeren logger ind i <ph name="PRODUCT_NAME" />.

      Hvis du konfigurerer denne politik, kan du angive, om en bruger skal have tilladelse til at logge ind i <ph name="PRODUCT_NAME" />. Hvis du angiver denne politik som "Falsk", forhindres apps og udvidelser, der benytter chrome.identity API, i at fungere, så det kan være en god idé at bruge SyncDisabled i stedet.</translation>
<translation id="6378076389057087301">Angiv, om lydaktivitet påvirker strømstyringen</translation>
<translation id="637934607141010488">Rapportér liste over enhedsbrugere, der har logget ind for nylig.

      Hvis politikken er indstillet til Falsk, vil brugerne ikke blive rapporteret.</translation>
<translation id="6394350458541421998">Denne politik er trukket tilbage fra og med <ph name="PRODUCT_OS_NAME" /> version 29. Du kan i stedet bruge politikken PresentationScreenDimDelayScale.</translation>
<translation id="6401669939808766804">Log brugeren ud</translation>
<translation id="6406448383934634215">Hvis "Åbn en liste over webadresser" er valgt som starthandling, giver dette dig mulighed for at angive listen over webadresser, der åbnes. Hvis politikken ikke er angivet, åbnes der ikke en webadresse ved opstart.

          Denne politik fungerer kun, hvis politikken "RestoreOnStartup" er angivet til "RestoreOnStartupIsURLs".

          Denne politik er kun tilgængelig for Windows-forekomster, der er knyttet til et <ph name="MS_AD_NAME" />-domæne, eller Windows 10 Pro- eller Enterprise-forekomster, der er tilmeldt administration af enheder.</translation>
<translation id="6417265370957905582">Google Assistent</translation>
<translation id="6426205278746959912">Du kan ikke tvinge Android-apps til at bruge en proxy. En undergruppe af proxyindstillinger er tilgængelige for Android-apps, hvilket de frivilligt kan vælge at overholde:

          Hvis du vælger aldrig at bruge en proxyserver, oplyses Android-apps om, at der ikke er konfigureret en proxy.

          Hvis du vælger at bruge systemets proxyindstillinger eller en fast proxyserver, oplyses Android-apps om http-proxyserverens adresse og port.

          Hvis du vælger at registrere proxyserveren automatisk, oplyses scriptwebadressen "http://wpad/wpad.dat" til Android-apps. Ingen andre dele af protokollen for automatisk registrering af proxy anvendes.

          Hvis du vælger at bruge et .pac-proxyscript, oplyses scriptwebadressen til Android-apps.</translation>
<translation id="6430366557948788869">Chrome Reporting Extension</translation>
<translation id="6440051664870270040">Tillad, at websites navigerer samtidigt og åbner pop op-vinduer</translation>
<translation id="6447948611083700881">Sikkerhedskopiering og gendannelse er deaktiveret</translation>
<translation id="6449476513004303784">Tillad ikke, at brugerne administrerer certifikater</translation>
<translation id="645425387487868471">Aktivér påtvungen login for <ph name="PRODUCT_NAME" /></translation>
<translation id="6464074037294098618">Aktivér AutoFyld for adresser</translation>
<translation id="6473623140202114570">Konfigurer listen over domæner, hvor Beskyttet browsing ikke udløser advarsler.</translation>
<translation id="6488627892044759800">Konfigurerer standardstartsidens type i <ph name="PRODUCT_NAME" /> og forhindrer brugere i at ændre præferencer for startsider. Startsiden kan enten være en webadresse, du angiver, eller indstillet til siden Ny fane.

          Hvis du aktiverer denne indstilling, anvendes siden Ny fane altid som startside, og webadressen for startsiden ignoreres.

          Hvis du deaktiverer denne indstilling, er brugerens startside aldrig siden Ny fane, medmindre webadressen er indstillet til "chrome://newtab".

          Hvis du aktiverer eller deaktiverer denne indstilling, kan brugerne ikke ændre startsidetypen i <ph name="PRODUCT_NAME" />.

          Hvis du ikke angiver denne politik, kan brugeren selv vælge, om siden Ny fane skal være startsiden.

          Denne politik er kun tilgængelig for Windows-forekomster, der er knyttet til et <ph name="MS_AD_NAME" />-domæne, eller Windows 10 Pro- eller Enterprise-forekomster, der er tilmeldt administration af enheder.</translation>
<translation id="6491139795995924304">Tillad Bluetooth på enheden</translation>
<translation id="6495328383950074966">Konfigurer listen over domæner, som Beskyttet browsing skal have tillid til. Det betyder:
      Beskyttet browsing tjekker ikke, om der er farlige ressourcer (f.eks. phishing, malware eller uønsket software), hvis webadresserne matcher disse domæner.
      Downloadbeskyttelsen i Beskyttet browsing tjekker ikke downloads, der hostes på disse domæner.
      Adgangskodebeskyttelsen i Beskyttet browsing tjekker ikke, om adgangskoder genbruges, hvis sidens webadresse matcher disse domæner.

      Hvis denne indstilling er aktiveret, anser Beskyttet browsing disse domæner for pålidelige.
      Hvis denne indstilling er deaktiveret eller ikke angivet, anvendes Beskyttet browsing på alle ressourcer.
      Denne politik er kun tilgængelig for Windows-forekomster, der er knyttet til et <ph name="MS_AD_NAME" />-domæne, eller Windows 10 Pro- eller Enterprise-forekomster, der er tilmeldt administration af enheder.</translation>
<translation id="6515357889978918016"><ph name="PLUGIN_VM_NAME" />-billede</translation>
<translation id="6520802717075138474">Import af søgemaskiner fra standardbrowseren ved første visning</translation>
<translation id="6525955212636890608">Hvis du aktiverer denne indstilling, køres alt det Flash-indhold, der er integreret på websites med tilladelse til at bruge Flash i indstillingerne for indhold (som enten er angivet af brugeren eller virksomhedspolitikken). Dette omfatter indhold af anden oprindelse eller mindre indhold.

      Du kan se, hvilke websites der har tilladelse til at køre Flash, i politikkerne "DefaultPluginsSetting", "PluginsAllowedForUrls" og "PluginsBlockedForUrls".

      Hvis denne indstilling er deaktiveret eller ikke er angivet, kan Flash-indhold af anden oprindelse eller mindre indhold blive blokeret.</translation>
<translation id="6532769014584932288">Tillad aktiveringslåse</translation>
<translation id="653608967792832033">Angiver den tid uden brugerinput, der aktiverer skærmlåsen, når enheden kører på batteri.

          Hvis denne politik indstilles til en højere værdi end nul, angives den tid, som brugeren skal være inaktiv, før <ph name="PRODUCT_OS_NAME" /> låser skærmen.

          Hvis denne politik indstilles til nul, låser <ph name="PRODUCT_OS_NAME" /> ikke skærmen, når brugeren er inaktiv.

          Hvis denne politik ikke indstilles, anvendes standardindstillingen.

          Den anbefalede måde at låse skærmen på ved inaktivitet er ved at aktivere suspendering af skærmlåsning og suspendere <ph name="PRODUCT_OS_NAME" /> efter inaktivitetsforsinkelsen. Denne politik bør kun bruges, hvis skærmlåsning finder sted markant hurtigere end suspendering, eller hvis suspendering ved inaktivitet ikke ønskes.

          Politikkens værdi skal angives i millisekunder. Værdierne reduceres, så de er mindre end inaktivitetsforsinkelsen.</translation>
<translation id="6536600139108165863">Automatisk genstart, når enheden lukker ned</translation>
<translation id="6539246272469751178">Denne politik påvirker ikke Android-apps. Android-apps anvender altid standardmappen for download og har ikke adgang til filer, som <ph name="PRODUCT_OS_NAME" /> har downloadet til en ikke-standardmappe for download.</translation>
<translation id="654303922206238013">Migreringsstrategi for eCryptfs</translation>
<translation id="6544897973797372144">Hvis denne politik er indstillet til Sand, og politikken ChromeOsReleaseChannel ikke er specificeret, kan brugerne af tilmeldelsesdomænet ændre udgivelseskanalen for enheden. Hvis denne politik indstillet til Falsk, vil enheden blive låst på den kanal, den sidst blev indstillet til.

      Den valgte kanal tilsidesættes af politikken ChromeOsReleaseChannel, men hvis politikkanalen er mere stabil end den, der blev installeret på enheden, vil kanalen kun skifte, når versionen af den mere stabile kanalen når et højere versionsnummer end den, der er installeret på enheden.</translation>
<translation id="6553143066970470539">Skærmens lysstyrke i procent</translation>
<translation id="6559057113164934677">Tillad ikke, at websites får adgang til kameraet og mikrofonen</translation>
<translation id="6561396069801924653">Vis indstillinger for hjælpefunktioner i systembakkemenuen</translation>
<translation id="6563458316362153786">Aktivér 802.11r Fast Transition</translation>
<translation id="6565312346072273043">Angiv standardtilstanden for hjælpefunktionen Skærmtastatur på loginskærmen.

          Hvis denne politik er angivet som Sand, aktiveres skærmtastaturet, når loginskærmen vises.

          Hvis denne politik er angivet som Falsk, deaktiveres skærmtastaturet, når loginskærmen vises.

          Hvis du har indstillet denne politik, kan brugerne midlertidigt tilsidesætte den ved at aktivere eller deaktivere skærmtastaturet. Brugerens valg er dog ikke permanent, og standardindstillingen gendannes, når loginskærmen vises på ny, eller når brugeren har været inaktiv på loginskærmen i et minut.

          Hvis denne politik ikke indstilles, deaktiveres skærmtastaturet, når loginskærmen vises første gang. Brugerne kan til enhver tid aktivere eller deaktivere skærmtastaturet, og status for skærmtastaturet på loginskærmen bibeholdes for de enkelte brugere.</translation>
<translation id="6570691255874112762">Denne politik styrer, om brugeren kan importere og fjerne certifikater via Certifikatadministrator.

      Hvis denne politik er angivet som "'Tillad, at brugerne administrerer alle certifikater'' eller ikke er konfigureret, kan brugerne administrere certifikaterne.

      Hvis denne politik er angivet som "Tillad, at brugerne administrerer brugercertifikater'', kan brugerne administrere brugercertifikater, men ikke certifikater på hele enheden.

      Hvis denne politik er angivet som "Tillad ikke, at brugerne administrerer certifikater", kan brugerne ikke administrere certifikater. De kan kun se certifikaterne.</translation>
<translation id="6573305661369899995">Angiv en ekstern kilde til webadressebegrænsninger</translation>
<translation id="6598235178374410284">Brugerens avatarbillede</translation>
<translation id="6603004149426829878">Send altid eventuelle tilgængelige placeringssignaler til serveren under opdatering af tidszone.</translation>
<translation id="6628120204569232711">Rapportér lagerstatus</translation>
<translation id="6628646143828354685">Giver dig mulighed for at angive, om websites må få adgang til Bluetooth-enheder i nærheden. Adgangen kan være fuldstændig blokeret, eller brugeren kan få en anmodning, hver gang et website vil have adgang til en Bluetooth-enhed i nærheden.

          Hvis denne politik ikke indstilles, bruges "3", og brugeren kan ændre denne indstilling.</translation>
<translation id="663685822663765995">Begræns farvetilstand for udskrivning</translation>
<translation id="6641981670621198190">Deaktiver understøttelse af API'er til 3D-grafik</translation>
<translation id="6647965994887675196">Hvis dette er angivet som sandt, kan administrerede brugere oprettes og anvendes.

          Hvis dette er angivet som falsk eller ikke er konfigureret, vil oprettelse af administrerede brugere og login for sådanne brugere være deaktiveret. Alle eksisterende administrerede brugere vil blive skjult.

          BEMÆRK! Forbruger- og virksomhedsenheder opfører sig som standard forskelligt. På forbrugerenheder er administrerede brugere som standard aktiveret, men på virksomhedsenheder er de som standard deaktiveret.</translation>
<translation id="6649397154027560979">Denne politik er ved at blive udfaset. Brug i stedet URLBlacklist.

      Deaktiverer de angivne protokolskemaer i <ph name="PRODUCT_NAME" />.

      Webadresser, der anvender et skema fra denne liste, indlæses ikke, og det er ikke muligt at navigere til dem.

      Hvis denne politik ikke indstilles, eller hvis listen er tom, vil alle skemaer være tilgængelige i <ph name="PRODUCT_NAME" />.</translation>
<translation id="6652197835259177259">Indstillinger for lokalt administrerede brugere</translation>
<translation id="6658245400435704251">Angiver det antal sekunder, som en enhed på en tilfældig måde maksimalt kan forsinke en download af en opdatering fra det tidspunkt, hvor opdateringen først blev sendt ud til serveren. Enheden kan afsætte en del af denne tid i form af faktisk ventetid og den igangværende tid i form af det antal af opdateringer, der skal kontrolleres. Uanset hvad, er spredningen bundet af en øvre grænse til en konstant mængde af tid, således at en enhed aldrig kommer til at sidde fast og til evig tid vente på, at en opdatering downloades.</translation>
<translation id="6665670272107384733">Konfigurer, hvor ofte brugeren skal indtaste adgangskoden for at bruge hurtig oplåsning.</translation>
<translation id="6681229465468164801">Giver dig mulighed for at angive en liste med webadressemønstre, der angiver websites, som ikke må anmode brugeren om adgang til en USB-enhed.

          Hvis denne politik ikke angives, anvendes den globale på alle websites, enten fra politikken "DefaultWebUsbGuardSetting", hvis den er angivet, eller alternativt brugerens personlige konfiguration.

          Webadressemønstre i denne politik må ikke være i strid med dem, der er konfigureret via WebUsbAskForUrls. Det er ikke angivet, hvilken af de to politikker der har forrang, hvis en webadresse matcher begge.</translation>
<translation id="6689792153960219308">Rapportér hardwarestatus</translation>
<translation id="6698632841807204978">Aktivér udskrivning i sort/hvid</translation>
<translation id="6699880231565102694">Aktivér godkendelse med to faktorer for værter med fjernadgang</translation>
<translation id="6731757988219967594">Filtrér voksenindhold fra på websites på øverste niveau (men ikke integrerede iframes)</translation>
<translation id="6734521799274931721">Styrer tilgængelighed af fildeling via netværk for Chrome OS</translation>
<translation id="6735701345096330595">Gennemtving aktivering af stavekontrol af sprog</translation>
<translation id="673699536430961464">Med denne indstilling har brugerne tilladelse til at skifte mellem Google-konti i browservinduets indholdsområde, når de er logget ind på deres <ph name="PRODUCT_OS_NAME" />-enhed.

      Hvis politikken er indstillet til Falsk, er det ikke tilladt at logge ind på en anden konto fra indholdsområdet i en browser, der ikke er i inkognitotilstand

      Hvis politikken er indstillet til Sand eller ikke er angivet, anvendes standardadfærden: Det er tilladt at logge ind på en anden konto fra indholdsområdet i browseren, medmindre der er tale om en underordnet konto, hvor det vil være blokeret i et indholdsområde, der ikke er i inkognitotilstand.

      Hvis det ikke skal være tilladt at logge ind på en anden konto via inkognitotilstanden, kan du overveje at blokere denne tilstand ved hjælp af politikken IncognitoModeAvailability.

      Bemærk, at brugere kan få adgang til Google-tjenester i ikke-godkendt tilstand ved at blokere deres cookies.</translation>
<translation id="6738326937072482736">Konfigurerer tilgængelighed og adfærd for funktionen til opdatering af <ph name="TPM_FIRMWARE_UPDATE_TPM" />-firmware.

      Individuelle indstillinger kan angives i JSON-egenskaber:

      <ph name="TPM_FIRMWARE_UPDATE_SETTINGS_ALLOW_USER_INITIATED_POWERWASH" />: Hvis den er angivet som <ph name="TPM_FIRMWARE_UPDATE_SETTINGS_ALLOW_USER_INITIATED_POWERWASH_TRUE" />, kan brugerne aktivere Powerwash-processen for at installere en <ph name="TPM_FIRMWARE_UPDATE_TPM" />-firmwareopdatering.

      <ph name="TPM_FIRMWARE_UPDATE_SETTINGS_ALLOW_USER_INITIATED_PRESERVE_DEVICE_STATE" />: Hvis den er angivet som <ph name="TPM_FIRMWARE_UPDATE_SETTINGS_ALLOW_USER_INITIATED_PRESERVE_DEVICE_STATE_TRUE" />, kan brugerne starte processen til <ph name="TPM_FIRMWARE_UPDATE_TPM" />-firmwareopdatering, der bevarer tilstanden på hele enheden (bl.a. tilmelding af virksomhed), men medfører tab af brugerdata. Denne opdateringsproces er tilgængelig i version 68 og nyere.

      Hvis politikken ikke er angivet, er funktionen til opdatering af <ph name="TPM_FIRMWARE_UPDATE_TPM" />-firmware ikke tilgængelig.</translation>
<translation id="6757438632136860443">Giver dig mulighed for at angive en liste med webadressemønstre, der angiver websites, som har tilladelse til at køre <ph name="FLASH_PLUGIN_NAME" />-pluginnet.

         Hvis denne politik ikke angives, anvendes den globale standardværdi for alle websites enten fra politikken "DefaultPluginsSetting", hvis denne er angivet, og ellers fra brugerens personlige konfiguration.</translation>
<translation id="6762235610019366960">Giver dig mulighed for at styre præsentationen af kampagne- og/eller undervisningsindhold på hele fanen i <ph name="PRODUCT_NAME" />.

      Hvis politikken ikke er konfigureret eller aktiveret (angivet som Sand), viser <ph name="PRODUCT_NAME" /> muligvis indhold på hele fanen til brugerne for at levere produktoplysninger.

      Hvis den er deaktiveret (angivet som Falsk), viser <ph name="PRODUCT_NAME" /> ikke indhold på hele fanen til brugerne for at levere produktoplysninger.

      Denne indstilling styrer præsentationen på de velkomstsider, der hjælper brugerne med at logge ind i <ph name="PRODUCT_NAME" />, vælge deres standardbrowser, eller som på anden måde oplyser dem om produktfunktioner.</translation>
<translation id="6766216162565713893">Tillad, at websites anmoder en bruger om adgang til en Bluetooth-enhed i nærheden.</translation>
<translation id="6770454900105963262">Rapportér oplysninger om aktive terminalsessioner</translation>
<translation id="6786747875388722282">Udvidelser</translation>
<translation id="6786967369487349613">Angiv placeringen af roamingprofilen</translation>
<translation id="6795485990775913659">Tillad kun udskrivning uden pinkode</translation>
<translation id="6810445994095397827">Bloker JavaScript på disse websites</translation>
<translation id="6813263547126514821">Strøm og nedlukning</translation>
<translation id="681446116407619279">Understøttede godkendelsesskemaer</translation>
<translation id="6816212867679667972">Fastlæg det hostname, enheden anvender i DHCP-anmodninger.

      Hvis denne politik er angivet til en udfyldt streng, bruges strengen som enhedens hostname i forbindelse med en DHCP-anmodning.

      Strengen kan indeholde variablerne ${ASSET_ID}, ${SERIAL_NUM}, ${MAC_ADDR}, ${MACHINE_NAME}, som erstattes af værdier på enheden, inden den bruges som hostname. Resultatet af udskiftningen skal være et gyldigt hostname (i overensstemmelse med afsnit 3.1 i RFC 1035).

      Hvis denne politik ikke er angivet, eller værdien efter udskiftningen ikke er et gyldigt hostname, angives der ikke noget hostname i DHCP-anmodninger. </translation>
<translation id="6835883744948188639">Vis brugeren en fast meddelelse, som indikerer, at en genstart anbefales</translation>
<translation id="6837480141980366278">Styrer, om den indbyggede DNS-klient bruges i <ph name="PRODUCT_NAME" />.

      Hvis denne politik er angivet som sand, bruges den indbyggede DNS-klient, hvis den er tilgængelig.

      Hvis denne politik er angivet som falsk, bruges den indbyggede DNS-klient aldrig.

      Hvis denne politik ikke er angivet, aktiveres den indbyggede DNS-klient som standard i MacOS, Android (når hverken Privat DNS eller VPN er aktiveret) og ChromeOS, og brugerne kan ændre, om den indbyggede DNS-klient bruges, ved at redigere chrome://flags eller angive et kommandolinjeflag.</translation>
<translation id="6838056959556423778">Tilsidesætter regler for valg af standardprinter i <ph name="PRODUCT_NAME" />.

      Denne politik fastlægger reglerne for valg af standardprinter i <ph name="PRODUCT_NAME" />, som vælges, første gang udskrivningsfunktionen anvendes fra en profil.

      Når denne politik er indstillet, forsøger <ph name="PRODUCT_NAME" /> at finde en printer, der har alle de angivne attributter, og vælge den som standardprinter. Den først fundne printer, der stemmer overens med politikken, vælges. Hvis der er flere match, kan enhver printer vælges ud fra den rækkefølge, som printerne blev fundet i.

      Hvis denne politik ikke indstilles, eller hvis der ikke findes nogen printer, som stemmer overens med politikken, inden timeouten udløber, vælges en indbygget PDF-printer som standard. Hvis der ikke er nogen tilgængelig PDF-printer, vælges der ikke nogen printer.

      Værdien parses som et JSON-objekt i overensstemmelse med følgende skema:
      {
        "type": "object",
        "properties": {
          "kind": {
            "description": "Om søgningen efter en printer, der opfylder attributten, skal begrænses til en specifik gruppe printere.",
            "type": "string",
            "enum": [ "local", "cloud" ]
          },
          "idPattern": {
            "description": "Regulært udtryk, som matcher printer-id.",
            "type": "string"
          },
          "namePattern": {
            "description": "Regulært udtryk, som matcher printerens viste navn.",
            "type": "string"
          }
        }
      }

      Printere, der er forbundet til <ph name="CLOUD_PRINT_NAME" />, klassificeres som <ph name="PRINTER_TYPE_CLOUD" />, mens de øvrige printere klassificeres som <ph name="PRINTER_TYPE_LOCAL" />.
      Hvis et felt udelades, matcher alle værdier. Hvis du f.eks. ikke specificerer forbindelsen, vil et tryk på Vis udskrift starte en søgning efter alle typer printere – både lokalt og i skyen.
      Almindelige søgemønstre skal overholde JavaScript RegExp-syntaksen, og der skelnes mellem store og små bogstaver.</translation>
<translation id="6843296367238757293">Denne politik er forældet. Det anbefales ikke at bruge den. Læs mere på https://support.google.com/chrome/a/answer/7643500</translation>
<translation id="684856667300805181">Denne politik er blevet fjernet i <ph name="PRODUCT_NAME" /> 68 og erstattet af <ph name="ARC_GLS_POLICY_NAME" />.</translation>
<translation id="6856743875250214792">Denne politik er forældet og fjernet i M66, da den kun blev brugt til interne test, og den er til fare for sikkerheden.

      Angiver de markeringer, der skal anvendes for <ph name="PRODUCT_NAME" /> ved opstart. De angivne markeringer anvendes kun på loginskærmen. Markeringer, der angives via denne politik, overføres ikke til brugersessioner.</translation>
<translation id="685769593149966548">Gennemtving Strengt begrænset tilstand på YouTube</translation>
<translation id="6857824281777105940">Politikken styrer, om der skal rapporteres oplysninger om Beskyttet browsing, bl.a. antallet af advarsler via Beskyttet browsing og antallet af gennemklik på advarsler via Beskyttet browsing.

      Hvis politikken er angivet som Sand eller ikke er konfigureret, indsamles der data om Beskyttet browsing.
      Hvis politikken er angivet som Falsk, indsamles der ikke data om Beskyttet browsing.

      Politikken gælder kun, når <ph name="CHROME_REPORTING_EXTENSION_NAME" /> er aktiveret, og maskinen er tilmeldt <ph name="MACHINE_LEVEL_USER_CLOUD_POLICY_ENROLLMENT_TOKEN_POLICY_NAME" />.</translation>
<translation id="686079137349561371">Microsoft Windows 7 eller nyere</translation>
<translation id="687046793986382807">Denne politik er trukket tilbage fra og med <ph name="PRODUCT_NAME" /> version 35.

      Hukommelsesoplysninger rapporteres dog stadigvæk til siden uanset indstillingsværdien, men de rapporterede
      størrelser er kvantiseret, og opdateringsfrekvensen er begrænset af sikkerhedsmæssige hensyn. Du kan få
      nøjagtige data i realtid ved at bruge værktøjer som f.eks. Telemetri.</translation>
<translation id="6894178810167845842">Webadresse for siden Ny fane</translation>
<translation id="6899705656741990703">Registrer proxyindstillinger automatisk</translation>
<translation id="6903814433019432303">Denne politik er kun aktiv i detailtilstand.

      Bestemmer de sæt af webadresser, der skal indlæses, når demosessionen starter. Denne politik tilsidesætter alle andre mekanismer for angivelse af den indledende webadresse, og derfor kan den kun gælde for en session, der ikke er knyttet til en bestemt bruger.</translation>
<translation id="6908640907898649429">Konfigurerer standardsøgemaskinen. Du kan angive den standardsøgemaskine, som brugeren vil anvende, eller vælge at deaktivere standardsøgning.</translation>
<translation id="6913068954484253496">Tillad, at <ph name="PRODUCT_NAME" /> opretter forbindelse til Cast-enheder på alle IP-adresser.</translation>
<translation id="6915442654606973733">Aktivér hjælpefunktionen Talefeedback.

          Hvis denne politik angives som sand, vil talefeedback altid være aktiveret.

          Hvis denne politik angives som falsk, vil talefeedback altid være deaktiveret.

          Hvis du angiver denne politik, kan brugerne ikke ændre eller tilsidesætte den.

          Hvis denne politik ikke angives, vil talefeedback være deaktiveret, men brugeren kan når som helst slå funktionen til.</translation>
<translation id="6916507170737609563">
      Det er en god idé at kigge på politikindstillingen IsolateOriginsAndroid for at få det bedste fra begge verdener (isolering og begrænset indvirkning på brugerne) ved at bruge IsolateOriginsAndroid sammen med en liste over de websites, du vil isolere. Denne indstilling, SitePerProcessAndroid, isolerer alle websites.
      Hvis politikken er aktiveret, kører hvert website sin egen proces.
      Hvis politikken er deaktiveret, sker der ingen udtrykkelig isolering af websites, og brugstest af IsolateOriginsAndroid og SitePerProcessAndroid deaktiveres. Brugere kan stadig aktivere SitePerProcess manuelt.
      Hvis politikken ikke konfigureres, kan brugerne ændre denne indstilling.

      BEMÆRK! I Android er isolering af website eksperimentel. Understøttelsen bliver bedre med tiden, men den kan i øjeblikket forårsage problemer med ydeevnen.

      BEMÆRK! Politikken gælder kun for Chrome på Android-enheder med mere end 1 GB RAM. Hvis du vil anvende denne politik på andre platforme, skal du bruge SitePerProcess.
      </translation>
<translation id="6922884955650325312">Bloker <ph name="FLASH_PLUGIN_NAME" />-pluginnet</translation>
<translation id="6923366716660828830">Angiver navnet på standardsøgemaskinen. Hvis det ikke udfyldes eller angives, vil det hostname, der er angivet af søgewebadressen, blive anvendt. Denne politik overvejes kun, hvis politikken "DefaultSearchProviderEnabled" er aktiveret.</translation>
<translation id="6926703471186170050">Aktivér duplex-udskrivning med lang kant</translation>
<translation id="6931242315485576290">Deaktiver synkronisering af data med Google</translation>
<translation id="6936894225179401731">Angiver det maksimale antal sideløbende forbindelser til proxyserveren.

      Nogle proxyservere kan ikke håndtere et stort antal sideløbende forbindelser pr. klient, og dette kan løses ved at indstille denne politik til en lavere værdi.

      Værdien af denne politik bør være lavere end 100 og større end 6, og standardværdien er 32.

      Nogle webapps er kendt for at optage mange forbindelser med hængende GET'er, så hvis værdien sænkes til under 32, vil browserens netværk hænge, hvis der er for mange åbne webapps. Værdier under standardværdien er på eget ansvar.

      Hvis denne politik ikke angives, anvendes standardværdien på 32.</translation>
<translation id="6943577887654905793">Præferencenavn for Mac/Linux:</translation>
<translation id="6944167205014013774">Oplysninger om brug af Linux-apps sendes tilbage til
      serveren.

      Hvis politikken indstilles til falsk eller ikke indstilles, rapporteres oplysninger om
      brug ikke. Hvis den indstilles til sand, rapporteres brugsoplysninger.

      Denne politik gælder kun, hvis understøttelse af Linux-apps er aktiveret.</translation>
<translation id="69525503251220566">Parameter, der leverer funktion til billedsøgning i standardsøgemaskinen</translation>
<translation id="6953102253399571439">Aktivér udskrivning med pinkode som standard</translation>
<translation id="6956272732789158625">Tillad ikke, at websites anvender nøglegenerering</translation>
<translation id="6965859329738616662">Angiver, om det er tilladt at bruge en smart nedtoningsmodel for at forlænge den tid, der går, inden skærmen nedtones.

Når skærmen er ved at blive nedtonet, vurderer den smarte nedtoningsmodel, om nedtoningen af skærmen skal udskydes. Hvis den smarte nedtoningsmodel udskyder nedtoningen af skærmen, forlænges den tid, der går, inden skærmen nedtones. I dette tilfælde justeres skærmlåsen og inaktivitetsforsinkelsen, så de bevarer den samme afstand til skærmnedtoningsforsinkelsen som oprindeligt konfigureret.
Hvis denne politik er angivet som sand eller ikke angives, aktiveres den smarte nedtoningsmodel, som får tilladelse til at forlænge den tid, der går, inden skærmen nedtones. Hvis denne politik er angivet som falsk, har den smarte nedtoningsmodel ikke indflydelse på skærmnedtoning.</translation>
<translation id="6972540544240464302">Vælg konfiguration af opgaveplanlægning</translation>
<translation id="6994082778848658360">Angiver, hvordan det sikre element, der er indbygget i hardwaren, kan bruges til at levere godkendelse med sekundær faktor, hvis det er kompatibelt med denne funktion. Maskinens afbryderknap bruges til at fastslå brugerens fysiske tilstedeværelse.

      Hvis "Deaktiveret" er valgt, leveres der ingen sekundær faktor.

      Hvis "U2F" er valgt, vil den integrerede sekundære faktor fungere i henhold til FIDO U2F-specifikationen.

      Hvis "U2F_EXTENDED" er valgt, vil den integrerede sekundære faktor levere U2F-funktionerne samt nogle udvidelser til individuel attestering.</translation>
<translation id="6997592395211691850">Om der kræves online OCSP/CRL-kontroller for lokale tillidsankere</translation>
<translation id="7003334574344702284">Denne politik tvinger import af gemte adgangskoder fra den tidligere standardbrowser, hvis den er aktiveret. Hvis denne politik er aktiveret, påvirker den også dialogboksen for import. Hvis den er deaktiveret, importeres de gemte adgangskoder ikke. Hvis den ikke er angivet, kan brugeren blive spurgt, om der skal importeres, ellers sker importen automatisk.</translation>
<translation id="7003746348783715221">Præferencer for <ph name="PRODUCT_NAME" /></translation>
<translation id="7006788746334555276">Indstillinger for indhold</translation>
<translation id="7007671350884342624">Konfigurerer det indeks, som <ph name="PRODUCT_NAME" /> anvender til at gemme brugerdata.

      Hvis du angiver denne politik, anvender <ph name="PRODUCT_NAME" /> det medfølgende indeks, uanset om brugeren har angivet markeringen "--user-data-dir" eller ej. For ikke at miste data eller få uventede fejl bør denne politik ikke angives som en mængdes rodindeks eller som et indeks, der bruges til andre formål, da <ph name="PRODUCT_NAME" /> administrerer indholdet.

      Gå til https://www.chromium.org/administrators/policy-list-3/user-data-directory-variables for at se en liste over variabler, der kan bruges.

      Hvis denne politik ikke angives, anvendes standardcacheindekset, og brugeren vil kunne tilsidesætte det med kommandolinjemarkeringen ""--disk-cache-dir".</translation>
<translation id="7027785306666625591">Konfigurer strømstyring i <ph name="PRODUCT_OS_NAME" />.

      Med disse politikker kan du konfigurere, hvad <ph name="PRODUCT_OS_NAME" /> udfører, når brugeren er inaktiv i et givet tidsrum.</translation>
<translation id="7040229947030068419">Eksempelværdi:</translation>
<translation id="7044883996351280650">Styring af Android-tjenesten til sikkerhedskopiering og gendannelse</translation>
<translation id="7049373494483449255">Gør det muligt for <ph name="PRODUCT_NAME" /> at sende dokumenter til <ph name="CLOUD_PRINT_NAME" /> til udskrivning. BEMÆRK! Dette påvirker kun understøttelse af <ph name="CLOUD_PRINT_NAME" /> i <ph name="PRODUCT_NAME" />. Det forhindrer ikke brugerne i at sende udskriftsjob på websites. Hvis denne indstilling er aktiveret eller ikke er konfigureret, kan brugerne udskrive til <ph name="CLOUD_PRINT_NAME" /> via dialogboksen for udskrivning i <ph name="PRODUCT_NAME" />. Hvis denne indstilling er deaktiveret, kan brugerne ikke udskrive til <ph name="CLOUD_PRINT_NAME" /> via dialogboksen for udskrivning i <ph name="PRODUCT_NAME" />.</translation>
<translation id="7053678646221257043">Denne politik påtvinger import af bogmærker fra den nuværende standardbrowser, hvis det er aktiveret. Hvis det er aktiveret, påvirker denne politik også importdialogboksen. Hvis det er deaktiveret, importeres der ingen bogmærker. Hvis den ikke er angivet, kan brugeren blive bedt om at importere, eller importen kan ske automatisk.</translation>
<translation id="7063895219334505671">Tillad pop op-vinduer på disse websites</translation>
<translation id="706568410943497889">
      Hvis politikken er angivet som sand, har <ph name="PRODUCT_NAME" /> tilladelse til at indsamle WebRTC-hændelseslogfiler fra Google-tjenester (f.eks. Google Meet) og uploade de pågældende logfiler til Google.

      Hvis politikken er angivet som falsk eller ikke er angivet, må <ph name="PRODUCT_NAME" /> ikke indsamle eller uploade sådanne logfiler.

      Disse logfiler indeholder diagnosticeringsoplysninger, som er nyttige i forbindelse med fejlretning af problemer med lyd- og videoopkald i Chrome, f.eks. tidspunkt for og størrelsen på sendte og modtagne RTP-pakker, feedback om belastning af netværket samt metadata om varigheden og kvaliteten af lyd- og videorammer. Logfilerne omfatter ikke lyd- eller videoindhold fra opkald.

      Denne dataindsamling af Chrome kan kun aktiveres af Google-webtjenester såsom Google Hangouts eller Google Meet.

      Google kan ved hjælp af et sessions-id knytte disse logfiler til andre logfiler, der er indsamlet af selve Google-tjenesten. Dette kan gøre fejlretningen nemmere.
      </translation>
<translation id="706669471845501145">Tillad, at websites viser skrivebordsunderretninger</translation>
<translation id="7072208053150563108">Hvor ofte computeradgangskoden skiftes</translation>
<translation id="7079519252486108041">Bloker pop op-vinduer på disse websites</translation>
<translation id="7085803328069945025">Giver dig mulighed for at angive en liste med webadressemønstre, der angiver websites, som gerne må anmode brugeren om adgang til en USB-enhed.

          Hvis denne politik ikke angives, anvendes den globale standardværdi på alle websites, enten fra politikken "DefaultWebUsbGuardSetting", hvis den er angivet, eller alternativt brugerens personlige konfiguration.

          Webadressemønstre i denne politik må ikke være i strid med dem, der er konfigureret via WebUsbBlockedForUrls. Det er ikke angivet, hvilken af de to politikker der har forrang, hvis en webadresse matcher begge.</translation>
<translation id="7086677522575756117">Angiver den procentdel, som nedtoningsforsinkelsen på skærmen skaleres med, når brugeraktivitet overvåges, mens skærmen er nedtonet, eller kort tid efter, at skærmen er blevet slukket.

          Hvis denne politik er konfigureret, angives den procentdel, som nedtoningsforsinkelsen på skærmen skaleres med, når brugeraktivitet overvåges, mens skærmen er nedtonet, eller kort tid efter, at skærmen er blevet slukket. Når nedtoningsforsinkelsen på skærmen er skaleret, tilpasses skærmsluk, skærmlås og inaktive forsinkelser for at bevare de samme afstande fra nedtoningsforsinkelsen på skærmen som i den oprindelige konfiguration.

          Hvis politikken ikke er konfigureret, anvendes en standardfaktor til skalering.

          Politikken anvendes kun, hvis <ph name="POWER_SMART_DIM_ENABLED_POLICY_NAME" /> er deaktiveret. Hvis ikke det er tilfældet, ignoreres politikken, da nedtoningsforsinkelsen på skærmen afhænger af en model til maskinlæring.

          Skaleringsfaktoren skal være mindst 100 %.</translation>
<translation id="7106631983877564505">Aktivér låsen, når <ph name="PRODUCT_OS_NAME" />-enheder bliver inaktive eller suspenderes.

      Hvis du aktiverer denne indstilling, vil brugerne blive bedt om en adgangskode for at låse enheden op fra dvale.

      Hvis du deaktiverer denne indstilling, vil brugerne ikke blive bedt om en adgangskode til at vække enheden fra dvale.

      Hvis du aktiverer eller deaktiverer denne indstilling, kan brugerne ikke ændre eller tilsidesætte den.

      Hvis politikken ikke angives, kan brugeren vælge, om der skal angives en adgangskode for at låse enheden op.</translation>
<translation id="7115494316187648452">Afgør, om en <ph name="PRODUCT_NAME" />-proces startes ved OS-login og bliver ved med at køre, når det sidste browservindue lukkes, så baggrundsapps og den aktuelle browsersession forbliver aktiv, inklusive eventuelle sessionscookies. Baggrundsprocessen viser et ikon i systembakken og kan altid lukkes derfra.

      Hvis denne politik er angivet til Sand, er baggrundstilstanden aktiveret og kan ikke styres af brugeren i browserindstillingerne.

      Hvis denne politik er angivet til Falsk, er baggrundstilstanden deaktiveret og kan ikke styres af brugeren i browserindstillingerne.

      Hvis denne politik ikke er indstillet, er baggrundstillingen i første omgang deaktiveret og kan styres af brugeren i browserindstillingerne.</translation>
<translation id="7123266440503901785"><ph name="PRODUCT_NAME" /> giver sikker opdatering og installation af udvidelser. Indholdet i nogle udvidelser, der hostes uden for Chrome Webshop, er dog muligvis kun beskyttet af usikkert login eller hashing-algoritmer som f.eks. SHA1. Hvis politikken deaktiveres, tillader Chrome ikke nye installationer og opdateringer af sådanne udvidelser (indtil udvidelsernes udviklere har genopbygget udvidelserne med stærkere algoritmer). Hvis politikken aktiveres, tillades installation og opdateringer af sådanne udvidelser.

          Hvis den ikke konfigureres, anvendes den aktiverede adfærd som standard.
          Hvis den ikke konfigureres, anvendes den deaktiverede adfærd som standard fra og med <ph name="PRODUCT_NAME" /> 75.

          Politikken ignoreres og behandles som deaktiveret fra og med <ph name="PRODUCT_NAME" /> 77.</translation>
<translation id="7126716959063786004">Gør det muligt at afslutte processer via Jobliste</translation>
<translation id="7127892035367404455">Gå tilbage til målversion</translation>
<translation id="7128918109610518786">Angiver applikationsid'er på en liste, som <ph name="PRODUCT_OS_NAME" /> viser som fastgjorte apps på applisten.

      Hvis denne politik er konfigureret, er applikationssættet fast og kan ikke ændres af brugeren.

      Hvis politikken ikke er angivet, kan brugeren ændre listen over fastgjorte apps på applisten.</translation>
<translation id="7132877481099023201">Webadresser, der får adgang til videooptagelsesenheder, uden at du skal give tilladelse hertil.</translation>
<translation id="7138678301420049075">Andet</translation>
<translation id="7140629953254369759">Instruerer <ph name="PRODUCT_OS_NAME" /> i at bruge den konfiguration af opgaveplanlægning, der identificeres af det angivne navn.

      Politikken kan angives som "conservative" og "performance", hvilket vælger konfigurationer af opgaveplanlægning, som er justeret for henholdsvis stabilitet og maksimal effektivitet.

      Hvis politikken ikke konfigureres, kan brugeren selv vælge.</translation>
<translation id="7145335384492396213">Standardtilstand for udskrivning med pinkode</translation>
<translation id="7158064522994309072">Politikken styrer, hvilken kommando der skal bruges til at åbne webadresser i en alternativ browser.

      Hvis politikken ikke konfigureres, anvendes der en platformspecifik standard: Internet Explorer til Windows eller Safari til Mac OS X. I Linux kan der ikke åbnes en alternativ browser, medmindre politikken er konfigureret.

      Hvis en af browserne ${ie}, ${firefox}, ${safari} eller
      ${opera} er angivet for politikken, åbnes den pågældende browser, hvis den er installeret. ${ie} er kun
      tilgængelig i Windows, og ${safari} er kun tilgængelig i Windows og Mac
      OS X.

      Hvis der er angivet en filsti for politikken, anvendes den pågældende fil som en eksekverbar
      fil.</translation>
<translation id="7167436895080860385">Tillad, at brugerne kan se adgangskoder i adgangskodeadministratoren</translation>
<translation id="7173856672248996428">Efemerisk profil</translation>
<translation id="717630378807352957">Tillad alle printere fra konfigurationsfilen.</translation>
<translation id="7176721759719212761">Angiver, om aktiveringslåse til skærme er tilladt. Udvidelser kan anmode om aktiveringslåse til skærme via Power Management Extension API og ARC-apps.

          Hvis denne politik er angivet som sand eller ikke er angivet, indfries aktiveringslåse til skærme i forbindelse med strømstyring, medmindre AllowWakeLocks er angivet som falsk.

          Hvis denne politik er angivet som falsk, nedrykkes anmodninger om aktiveringslåse for skærme til anmodninger om aktiveringslåse for systemet.</translation>
<translation id="7185078796915954712">TLS 1.3</translation>
<translation id="718956142899066210">Forbindelsestyper, der tillades til opdateringer</translation>
<translation id="7194407337890404814">Standardsøgemaskinens navn</translation>
<translation id="7202925763179776247">Tillad begrænsninger af download</translation>
<translation id="7207095846245296855">Gennemtving Google Beskyttet søgning</translation>
<translation id="7216442368414164495">Giv brugerne tilladelse til at tilvælge udvidet rapportering af Beskyttet browsing</translation>
<translation id="7221822638060296742">Giver dig mulighed for at angive, om websites må køre <ph name="FLASH_PLUGIN_NAME" />-pluginnet automatisk. Automatisk kørsel af <ph name="FLASH_PLUGIN_NAME" />-pluginnet kan enten tillades for alle websites eller forbydes for alle websites.

          Klik for at afspille giver tilladelse til at køre <ph name="FLASH_PLUGIN_NAME" />-pluginnet, men brugeren skal klikke på pladsholderen for at starte det.

          Automatisk afspilning er kun tilladt på domæner, der udtrykkeligt er angivet i politikken <ph name="PLUGINS_ALLOWED_FOR_URLS_POLICY_NAME" />. Hvis du vil aktivere automatisk afspilning på alle websites, kan du eventuelt føje http://* og https://* til denne liste.

          Hvis denne politik ikke angives, kan brugeren ændre indstillingen manuelt.</translation>
<translation id="7229876938563670511">Konfigurerer webadressen for standardstartsiden i <ph name="PRODUCT_NAME" /> og forhindrer, at brugerne ændrer den.

          Startsiden åbnes ved hjælp af knappen Start. De sider, der åbnes ved opstart, styres af RestoreOnStartup-politikkerne.

          Startsiden kan enten være en webadresse, du angiver her, eller indstillet til siden Ny fane. Hvis du vælger siden Ny fane, træder denne politik ikke i kraft.

          Hvis du aktiverer denne indstilling, kan brugerne ikke ændre webadressen for deres startside i <ph name="PRODUCT_NAME" />, men de kan stadig vælge siden Ny fane som startside.

          Hvis hverken denne politik eller HomepageIsNewTabPage er angivet, kan brugerne selv vælge startside.

          Denne politik er kun tilgængelig for Windows-forekomster, der er knyttet til et <ph name="MS_AD_NAME" />-domæne, eller Windows 10 Pro- eller Enterprise-forekomster, der er tilmeldt administration af enheder.</translation>
<translation id="7229975860249300121">Indeholder et regulært udtryk, som bruges til at afgøre, hvilke Google-konti der kan angives som primære konti for browseren i <ph name="PRODUCT_NAME" /> (dvs. den konto, der vælges i forbindelse med tilmeldingen til synkronisering).

      Der vises en fejl, hvis en bruger forsøger at angive en primær konto for browseren med et brugernavn, som ikke stemmer overens med dette mønster.

      Hvis denne politik ikke angives eller efterlades tom, kan brugeren angive en hvilken som helst Google-konto som primær konto for browseren i <ph name="PRODUCT_NAME" />.</translation>
<translation id="723103540848640830">Angiv minimumslængden for pinkoden til låseskærmen</translation>
<translation id="7232816984286843471">Hvis politikken er angivet som Falsk, har brugere uden tilknytning ikke tilladelse til at bruge Crostini.

      Hvis politikken ikke er angivet eller er angivet som Sand, har alle brugere tilladelse til at bruge Crostini, så længe andre indstillinger også tillader det.
      Alle tre politikker, VirtualMachinesAllowed, CrostiniAllowed og DeviceUnaffiliatedCrostiniAllowed, skal være angivet som Sand, når de anvendes for at tillade, at Crostini køres.
      Når politikken ændres til Falsk, gælder den for opstart af nye Crostini-containere, men lukker ikke containere, som allerede kører.</translation>
<translation id="7234280155140786597">Navne på forbudte indbyggede beskedhosts (eller * for alle)</translation>
<translation id="7236775576470542603">Indstil standardtypen for den lup, der er aktiveret på loginskærmen.

          Hvis denne politik indstilles, kontrollerer den den type lup, der aktiveres, når loginskærmen vises. Hvis politikken indstilles til "Ingen", deaktiveres luppen.

          Hvis du indstiller denne politik, kan brugerne midlertidigt tilsidesætte den ved at aktivere eller deaktivere luppen. Men brugerens valg er ikke endegyldigt, og standarden gendannes, når loginskærmen vises igen, eller hvis brugeren forbliver inaktiv på skærmen i et minut.

          Hvis denne politik ikke indstilles, deaktiveres luppen, når loginskærmen vises første gang. Brugerne kan når som helst aktivere eller deaktivere luppen, og dens status på loginskærmen fastholdes hos brugerne.</translation>
<translation id="7249828445670652637">Aktivér CA-certifikater i <ph name="PRODUCT_OS_NAME" /> til ARC-apps</translation>
<translation id="7252681704926980614">Send brugernavn og filnavn til native-printerens server ved alle udskriftsjob. Standardindstillingen er ikke at sende.

      Hvis denne politik angives som sand, deaktiveres printere, der bruger andre protokoller end IPPS, USB eller IPP via USB, da brugernavn og filnavn ikke bør sendes åbent over netværket.</translation>
<translation id="7258823566580374486">Aktivér skærmning af eksterne adgangsværter</translation>
<translation id="7260204423892780600">Styrer indstillingerne for Google Assistent.</translation>
<translation id="7260277299188117560">Automatisk opdatering af p2p er aktiveret</translation>
<translation id="7261252191178797385">Baggrundsbillede på enheden</translation>
<translation id="7264704483008663819">Denne politik er udfaset i M68. Brug DeveloperToolsAvailability i stedet for.

      Deaktiverer Udviklerværktøjer og JavaScript-konsollen.

      Hvis du aktiverer denne indstilling, kan der ikke opnås adgang til Udviklerværktøjer, og elementer på websites kan ikke længere inspiceres. Alle tastaturgenveje og alle menuer eller genvejsmenuer, der åbner Udviklerværktøjer eller JavaScript-konsollen, deaktiveres.

      Hvis du angiver denne indstilling som deaktiveret eller ikke angiver den, kan brugeren benytte Udviklerværktøjer og JavaScript-konsollen.

      Hvis politikken DeveloperToolsAvailability er angivet, ignoreres værdien af politikken DeveloperToolsDisabled.</translation>
<translation id="7266471712301230894">Denne politik er fjernet fra og med <ph name="PRODUCT_NAME" /> 64.

      Automatisk søgning efter og installation af manglende plugins understøttes ikke længere.</translation>
<translation id="7267809745244694722">Medietaster indstilles automatisk til funktionstaster</translation>
<translation id="7271085005502526897">Import af startside fra standardbrowser ved første visning</translation>
<translation id="7273823081800296768">Hvis denne indstilling er aktiveret eller ikke konfigureret, kan brugerne fravælge at parre klienter og hosts på forbindelsestidspunktet, hvilket fjerner behovet for at indtaste en pinkode hver gang.

          Hvis denne indstilling deaktiveres, vil denne funktion ikke være tilgængelig.</translation>
<translation id="7275334191706090484">Administrerede bogmærker</translation>
<translation id="7295019613773647480">Aktivér administrerede brugere</translation>
<translation id="7301543427086558500">Angiver en liste over alternative webadresser, som kan bruges til at udlede søgetermer fra søgemaskinen. Webadresserne bør indeholde strengen <ph name="SEARCH_TERM_MARKER" />, som bruges til at udlede søgetermer.

          Politikken er valgfri. Hvis den ikke angives, bruges ingen alternative webadresser til at udlede søgetermer.

           Denne politik respekteres kun, hvis politikken "DefaultSearchProviderEnabled" er aktiveret.</translation>
<translation id="7302043767260300182">Skærmlåsforsinkelse, når strømforsyning er tilsluttet</translation>
<translation id="7311458740754205918">Hvis denne politik er angivet som Sand eller ikke er angivet, viser siden Ny fane muligvis forslag til indhold baseret på brugerens browserhistorik, interesser eller placering.

      Hvis politikken er angivet som Falsk, vises automatisk genererede forslag til indhold ikke på siden Ny fane.</translation>
<translation id="7313793931637495417">Denne politik styrer, om der skal rapporteres oplysninger om versionen, f.eks. operativsystemets version, operativsystemets arkitektur, <ph name="PRODUCT_NAME" />-version og <ph name="PRODUCT_NAME" />-kanal.

      Hvis denne politik ikke er angivet eller er angivet som Sand, indhentes versionsoplysningerne.
      Hvis denne politik er angivet som Falsk, indhentes versionsoplysningerne ikke.

      Denne politik gælder kun, hvis <ph name="CHROME_REPORTING_EXTENSION_NAME" /> er aktiveret, og maskinen er tilmeldt <ph name="MACHINE_LEVEL_USER_CLOUD_POLICY_ENROLLMENT_TOKEN_POLICY_NAME" />.</translation>
<translation id="7323896582714668701">Yderligere kommandolinjeparametre for <ph name="PRODUCT_NAME" /></translation>
<translation id="7326394567531622570">Minder om Wipe (værdi 2), men forsøger at bevare logintokens, så brugeren ikke behøver at logge ind igen.</translation>
<translation id="7329842439428490522">Angiver den tid uden brugerinput, der aktiverer skærmsluk, når batteriet bruges.

          Hvis denne politik indstilles til en værdi, der er højere end nul, angives den tid, som brugeren skal være inaktiv, før <ph name="PRODUCT_OS_NAME" /> slukker skærmen.

          Hvis denne politik indstilles til nul, slukker <ph name="PRODUCT_OS_NAME" /> ikke skærmen, når brugeren er inaktiv.

          Hvis politikken ikke indstilles, anvendes standardindstillingen.

          Politikkens værdi skal angives i millisekunder. Værdierne reduceres, så de er mindre end eller lig med inaktivitetsforsinkelsen.</translation>
<translation id="7329968046053403405">Angiver kontotypen for de konti, der leveres af Android-godkendelsesappen, som understøtter <ph name="HTTP_NEGOTIATE" />-godkendelse (f.eks. Kerberos-godkendelse). Disse oplysninger kan indhentes fra leverandøren af godkendelsesappen. Få flere oplysninger på https://goo.gl/hajyfN.

          Hvis der ikke er angivet nogen indstilling, deaktiveres <ph name="HTTP_NEGOTIATE" />-godkendelse i Android.</translation>
<translation id="7331962793961469250">Når dette er angivet som Sandt, vises kampagner for apps i Chrome Webshop ikke på siden Ny fane.

      Hvis indstillingen angives til Falsk eller ikke angives, vises kampagner for apps i Chrome Webshop på den nye fane</translation>
<translation id="7332963785317884918">Denne politik er udfaset. <ph name="PRODUCT_OS_NAME" /> vil altid anvende oprydningsstrategien "RemoveLRU".

      Kontrollerer adfærden for automatisk oprydning på <ph name="PRODUCT_OS_NAME" />-enheder. Automatisk oprydning aktiveres, når mængden af ledig plads på harddisken når et kritisk niveau, i et forsøg på at frigøre plads.

      Hvis denne politik er angivet til "RemoveLRU", vil den automatiske oprydningsfunktion fortsætte med at fjerne brugere fra enheden startende med den senest indloggede bruger, indtil der er tilstrækkelig ledig plads.

      Hvis denne politik er angivet til "RemoveLRUIfDormant", vil den automatiske oprydningsfunktion fortsætte med at fjerne brugere, der ikke har været logget ind i minimum tre måneder, startende med den bruger, der ikke har været logget ind i længst tid, indtil der er tilstrækkelig ledig plads.

      Hvis denne politik ikke er indstillet, anvender den automatiske oprydningsfunktion standardstrategien. Denne strategi er i øjeblikket "RemoveLRUIfDormant".</translation>
<translation id="7336785017449297672">Styrer indstillingerne for tidszone</translation>
<translation id="7336878834592315572">Behold cookies under sessionen</translation>
<translation id="7339315111520512972">Tving netværkskoden til at køre i browserprocessen</translation>
<translation id="7340034977315324840">Rapportér tidspunkter for aktiviteter på enheden</translation>
<translation id="7343497214039883642">Fil til konfiguration af virksomhedsprintere for enheder</translation>
<translation id="7349338075015720646">Angiver en liste over websites, som installeres uovervåget uden brugerinteraktion, og som ikke kan afinstalleres af brugeren.

      Hvert listepunkt i politikken er et objekt med to medlemmer: "url" og "launch_container". "url" bør være webadressen til den webapp, der skal installeres, og "launch_container" bør enten være "window" eller "tab" for at indikere, hvordan webappen åbnes, når den er installeret. Hvis "launch_container" udelades, åbnes appen i et vindue, hvis Chrome betragter den som en progressiv webapp, og ellers åbnes den på en fane.</translation>
<translation id="735902178936442460">Denne politik styrer, om der skal rapporteres oplysninger, der kan bruges til at identificere maskiner, f.eks. maskinnavn og netværksadresser.

     Hvis denne politik ikke er angivet eller er angivet som Sand, indhentes der oplysninger, der kan bruges til at identificere maskinerne.
      Hvis denne politik er angivet som Falsk, indhentes der ikke oplysninger, der kan bruges til at identificere maskinerne.

      Denne politik gælder kun, hvis <ph name="CHROME_REPORTING_EXTENSION_NAME" /> er aktiveret, og maskinen er tilmeldt <ph name="MACHINE_LEVEL_USER_CLOUD_POLICY_ENROLLMENT_TOKEN_POLICY_NAME" />.</translation>
<translation id="737655323154569539">Begrænser størrelsen på udskrivningssiden. En ikke-angivet politik og en tom indstilling behandles som ingen begrænsning.</translation>
<translation id="7417972229667085380">Den procentdel, som inaktivitetsforsinkelsen i præsentationstilstand skaleres efter (udfases)</translation>
<translation id="7421483919690710988">Angiv størrelsen på mediediskcache i bytes</translation>
<translation id="7424751532654212117">Liste over undtagelser for listen over ​​deaktiverede plugins</translation>
<translation id="7426112309807051726">Angiver, om <ph name="TLS_FALSE_START" />-optimeringen skal deaktiveres. Af historiske årsager har denne politik fået navnet DisableSSLRecordSplitting.

      Hvis politikken ikke indstilles eller indstilles til falsk, aktiveres <ph name="TLS_FALSE_START" />. Hvis den indstilles til sand, deaktiveres <ph name="TLS_FALSE_START" />.</translation>
<translation id="7433714841194914373">Aktiver Direkte</translation>
<translation id="7443061725198440541">Hvis denne politik ikke er indstillet eller aktiveret, har brugeren tilladelse til at bruge stavekontrol.

      Hvis denne politik er deaktiveret, har brugeren ikke tilladelse til at bruge stavekontrol. Politikken SpellcheckLanguage ignoreres også, når denne politik er deaktiveret.
      </translation>
<translation id="7443616896860707393">Påmindelser om HTTP Basic Auth med krydsoprindelse</translation>
<translation id="7458437477941640506">Gå ikke tilbage til målversionen, hvis OS-versionen er nyere end målet. Opdateringer deaktiveres også.</translation>
<translation id="7464991223784276288">Begræns cookies fra matchende webadresser til den aktuelle session</translation>
<translation id="7469554574977894907">Aktiver søgeforslag</translation>
<translation id="7474249562477552702">Om certifikater med SHA-1-signatur, som er udstedt af lokale tillidsankre, er tilladt eller ej</translation>
<translation id="7485481791539008776">Regler for valg af standardprinter</translation>
<translation id="749556411189861380">Rapportér OS- og firmwareversion for tilmeldte enheder.

      Hvis denne indstilling ikke er angivet eller er angivet til Sand, rapporterer tilmeldte enheder med jævne mellemrum OS- og firmwareversionen. Hvis denne indstilling er angivet til Falsk, rapporteres versionsoplysningerne ikke</translation>
<translation id="7498946151094347510">Angiver, hvilke printere en bruger ikke kan anvende.

      Denne politik anvendes kun, hvis <ph name="PRINTERS_BLACKLIST" /> er valgt for <ph name="DEVICE_PRINTERS_ACCESS_MODE" />.

      Hvis denne politik anvendes, har brugeren adgang til alle printere bortset fra dem med id'er, der er angivet i denne politik. Id'erne skal stemme overens med feltet "id" eller "guid" i den fil, der er angivet i <ph name="DEVICE_PRINTERS_POLICY" />.
      </translation>
<translation id="7511361072385293666">Hvis denne politik er angivet som Sand eller ikke er indstillet, er brug i QUIC-protokollen i <ph name="PRODUCT_NAME" /> tilladt.
      Hvis denne politik er angivet som Falsk, er brug i QUIC-protokollen ikke tilladt.</translation>
<translation id="7517845714620372896">Angiver skærmens lysstyrke i procent.
          Når denne politik er angivet, justeres den oprindelige lysstyrke for skærmen til den værdi, der er angivet i politikken, men brugeren kan ændre dette senere. Funktioner for automatisk lysstyrke er deaktiveret.
          Når denne politik ikke er angivet, påvirkes funktionerne for brugerens skærmstyring og automatisk lysstyrke ikke.
          Værdierne i politikken skal angives som en procentdel inden for intervallet 0-100.</translation>
<translation id="7517846421386644905">Giver en administrator tilladelse til at styre, om telemetri- og diagnostikdata skal indsamles, behandles og rapporteres af Wilco DTC (Diagnostics and Telemetry Controller).

      Hvis politikken er angivet som Falsk eller ikke er konfigureret, deaktiveres DTC, som dermed ikke kan indsamle, behandle og rapportere telemetri- og diagnostikdata fra enheden.
      Hvis Wilco DTC er tilgængelig på den pågældende enhed, og politikken er angivet som Sand, aktiveres indsamlingen, behandlingen og rapporteringen af telemetri- og diagnostikdata.</translation>
<translation id="7519251620064708155">Tillad nøglegenerering på disse websites</translation>
<translation id="7529100000224450960">Giver dig mulighed for at oprette en liste over webadressemønstre med websites, der må åbne pop op-vinduer. Hvis denne politik ikke angives, anvendes den globale standardværdi på alle websites, enten fra politikken "DefaultPopupsSetting", hvis den er angivet, eller brugerens personlige konfiguration.</translation>
<translation id="7529144158022474049">Automatisk opdatering af spredningsfaktor</translation>
<translation id="7534199150025803530">Denne politik påvirker ikke Google Drev-appen til Android. Hvis du vil forhindre, at Google Drev bruges via mobildataforbindelser, skal du ikke tillade installation af Google Drev-appen til Android.</translation>
<translation id="7540622499178214923">Tillader Wilco DTC (Diagnostics and Telemetry Controller)</translation>
<translation id="7547549430720182663">Flet</translation>
<translation id="7553535237300701827">Når denne politik er indstillet, sker godkendelsesprocessen for login på én af følgende måder afhængigt af værdien for indstillingen:

      Hvis den er indstillet til GAIA, sker login via den normale godkendelsesproces for GAIA.

      Hvis den er indstillet til SAML_INTERSTITIAL, vises der ved login en mellemliggende skærm, som giver brugeren mulighed for enten at fortsætte med godkendelse via SAML IdP for enhedens registreringsdomæne eller gå tilbage til den normale loginproces for GAIA.</translation>
<translation id="755951849901630953">Aktiverer komponentopdateringer for alle komponenter i <ph name="PRODUCT_NAME" />, hvis politikken ikke er angivet eller er angivet som Sand.

      Hvis den er angivet som Falsk, deaktiveres opdateringer af komponenter. Visse komponenter er dog fritaget fra denne politik. Opdateringer til en komponent, som ikke indeholder eksekverbar kode, som ikke ændrer browserens adfærd markant, eller som er afgørende for sikkerheden, deaktiveres ikke.
      Eksempler på sådanne komponenter er bl.a. lister over tilbagekaldte certifikater og data for Beskyttet browsing.
      Få flere oplysninger om Beskyttet browsing på https://developers.google.com/safe-browsing.</translation>
<translation id="7566878661979235378">Godkendelsestype for SAML-login</translation>
<translation id="757395965347379751">Når denne indstilling er aktiveret, tillader <ph name="PRODUCT_NAME" /> certifikater med SHA-1-signatur, så længe de bekræfter og sammenkædes med lokalt installerede CA-certifikater.

      Bemærk, at denne politik afhænger af, at certifikatets bekræftelsesstak for operativsystemet tillader SHA-1-signaturer. Hvis en opdatering af operativsystemet ændrer operativsystemets håndtering af SHA-1-certifikater, er denne politik muligvis ikke længere aktiv. Denne politik er desuden beregnet som en midlertidig løsning, der giver virksomheder mere tid til at bevæge sig væk fra SHA-1. Denne politik vil blive fjernet omkring d. 1. januar 2019.

      Hvis denne politik ikke er angivet, eller hvis den er angivet til Falsk, følger <ph name="PRODUCT_NAME" /> den officielle plan for udfasning af SHA-1.</translation>
<translation id="7578049687634719313">Politikken styrer, hvor længe der går i millisekunder, før en alternativ browser åbnes.

      Hvis 0 angives for politikken, eller den ikke konfigureres, åbnes en angivet webadresse med det samme i en alternativ browser.

      Hvis der angives et tal for politikken, viser Chrome en meddelelse i det pågældende antal millisekunder, hvorefter den alternative browser åbnes.</translation>
<translation id="7593523670408385997">Konfigurerer cachestørrelsen, som <ph name="PRODUCT_NAME" /> vil bruge til at lagre cachelagrede filer på disken.

      Hvis du indstiller denne politik, vil <ph name="PRODUCT_NAME" /> bruge den angivne cachestørrelse, uanset om brugeren har markeret flaget "--disk-cache-size" eller ej. Værdien, der er angivet i denne politik, er ikke en hård grænse, men snarere et forslag til et cachelagringssystem, Enhver værdi under et par megabyte er for lille og vil blive rundet op til et fornuftigt minimum.

      Hvis værdien af denne politik er 0, anvendes standardcachestørrelsen, men brugeren vil ikke kunne ændre den.

      Hvis denne politik ikke er indstillet, bruges standardstørrelsen, og brugeren vil kunne tilsidesætte den med flaget "--disk-cache-size".</translation>
<translation id="759957074386651883">Indstillinger for Beskyttet browsing</translation>
<translation id="7604169113182304895">Android-apps vælger selv, om de vil overholde denne liste. Du kan ikke tvinge dem til at overholde den.</translation>
<translation id="7612157962821894603">Markeringer for hele systemet kan angives ved opstart af <ph name="PRODUCT_NAME" /></translation>
<translation id="7614663184588396421">Liste over deaktiverede protokolskemaer</translation>
<translation id="7617319494457709698">Denne politik angiver de udvidelser, der har tilladelse til at bruge <ph name="ENTERPRISE_PLATFORM_KEYS_API" />-funktionen <ph name="CHALLENGE_USER_KEY_FUNCTION" /> til fjernbekræftelse. Udvidelser skal føjes til denne liste for at kunne anvende API'en.

          Hvis en udvidelse ikke findes på listen, eller listen ikke er angivet, vil kaldet til API'en mislykkes og returnere en fejlkode.</translation>
<translation id="7618907117929117943">Træk udgivelsen tilbage, og behold målversionen, hvis OS-versionen er nyere end målversionen, og hvis det er muligt at overføre konfiguration på enhedsniveau (herunder loginoplysninger til netværket) via tilbagetrækning, hvor OOBE også springes over efter tilbagetrækning. Udfør ikke eller annuller tilbagetrækningen, hvis dette ikke er muligt (fordi målversionen ikke understøtter gendannelse af data eller på grund af en ikke-kompatibel ændring tilbage).
          Understøttes i <ph name="PRODUCT_OS_NAME" /> version 70 og nyere. Ved ældre klienter betyder denne værdi, at tilbagetrækning er deaktiveret.</translation>
<translation id="7620869951155758729">Denne politik angiver en konfiguration, som bruges til at generere og bekræfte en forældreadgangskode.

      |current_config| bruges altid til at generere adgangskoder og bør kun anvendes til validering af adgangskoder, når disse ikke kan valideres ved hjælp af |future_config|.
      |future_config| er den mest brugte konfiguration til validering af adgangskoder.
      |old_configs| bør kun bruges til validering af adgangskoder, når disse ikke kan valideres ved hjælp af |future_config| eller |current_config|.

      Denne politik bruges normalt ved gradvist at rotere konfigurationen af den pågældende adgangskode. Nye konfigurationer lægges altid i |future_config|, og samtidig flyttes
      eksisterende værdier til |current_config|. Tidligere værdier for |current_config| flyttes til |old_configs| og fjernes, når rotationscyklussen er afsluttet.

      Denne politik gælder kun for børn.
      Når politikken er angivet, kan en forældreadgangskode bekræftes på barnets enhed.
      Hvis politikken ikke er angivet, er det ikke muligt at bekræfte en forældreadgangskode på barnets enhed.</translation>
<translation id="7625444193696794922">Angiver den udgivelseskanal, som denne enhed skal være låst til.</translation>
<translation id="7632724434767231364">Navn på GSSAPI-samling</translation>
<translation id="7635471475589566552">Konfigurerer applikationens landestandard i <ph name="PRODUCT_NAME" /> og forhindrer brugerne i at ændre landestandarden. Hvis du aktiverer denne indstilling, anvender <ph name="PRODUCT_NAME" /> den angivne landestandard. Hvis den konfigurerede landestandard ikke understøttes, bruges "en-US" i stedet. Hvis denne indstilling er deaktiveret eller ikke konfigureret, bruger <ph name="PRODUCT_NAME" /> enten den brugerdefinerede landestandard (hvis denne er konfigureret), systemets landestandard eller reservelandestandarden "en-US".</translation>
<translation id="7641363659597330616">Konfigurerer typen af downloads, som <ph name="PRODUCT_NAME" /> blokerer fuldstændig uden at give brugerne mulighed for at tilsidesætte sikkerhedsbeslutningen.

      Hvis politikken angives, forhindrer <ph name="PRODUCT_NAME" /> visse typer downloads, og brugerne kan ikke omgå sikkerhedsadvarslerne.

      Når muligheden "Bloker farlige downloads" vælges, tillades alle downloads undtagen dem, der har Beskyttet browsing-advarsler.

      Når muligheden "Bloker potentielt farlige downloads" vælges, tillades alle downloads undtagen dem, der har Beskyttet browsing-advarsler om potentielt skadelige downloads.

      Når muligheden "Bloker alle downloads" vælges, blokeres alle downloads.

      Hvis politikken ikke angives, (eller muligheden "Ingen særlige begrænsninger" vælges), går downloads gennem de sædvanlige sikkerhedsbegrænsninger baseret på analyseresultater fra Beskyttet browsing.

      Bemærk, at disse begrænsninger gælder for downloads, der aktiveres af websiteindhold såvel som genvejsmenuvalget "download link...". Disse begrænsninger gælder ikke i forbindelse med muligheden for at gemme/downloade den aktuelle side. De gælder heller ikke, når der gemmes som PDF-fil fra udskrivningsmulighederne.

      Få flere oplysninger om Beskyttet browsing på https://developers.google.com/safe-browsing.</translation>
<translation id="7643883929273267746">Begræns konti, der er synlige i <ph name="PRODUCT_NAME" /></translation>
<translation id="7651739109954974365">Bestemmer, om dataroaming skal aktiveres for enheden. Hvis den er indstillet til sand, tillades dataroaming. Hvis den ikke er konfigureret eller er angivet til falsk, vil dataroaming ikke være tilgængelig.</translation>
<translation id="7657261947024629645">Optimer for at øge effektiviteten.</translation>
<translation id="7673194325208122247">Tidsrum (millisekunder)</translation>
<translation id="7676708657861783864">Cookies, der er angivet af sider, og som matcher disse webadressemønstre, begrænses til den aktuelle session, dvs. de slettes, når browseren lukkes.

          For webadresser, der ikke er dækket af de mønstre, der er angivet her, eller for alle webadresser, hvis denne politik ikke er angivet, bruges den globale standardværdi enten fra politikken "DefaultCookiesSetting", hvis den er angivet, eller brugerens personlige konfiguration.

          Bemærk! Hvis <ph name="PRODUCT_NAME" /> kører i "baggrundstilstand", lukkes sessionen muligvis ikke, når det sidste browservindue lukkes, men forbliver i stedet aktiv, indtil browseren lukkes. Se politikken "BackgroundModeEnabled" for at få flere oplysninger om konfiguration af denne adfærd.

          Se også politikkerne "CookiesAllowedForUrls" og "CookiesBlockedForUrls". Bemærk, at der ikke må være nogen modstridende webadressemønstre mellem disse tre politikker – det er ikke angivet, hvilken politik der har forrang.

          Hvis politikken "RestoreOnStartup" er indstillet til at gendanne webadresser fra tidligere sessioner, overholdes denne politik ikke, og cookies gemmes permanent for disse websites.</translation>
<translation id="7683777542468165012">Dynamisk opdatering af politikker</translation>
<translation id="7694807474048279351">Planlæg en automatisk genstart efter opdatering af <ph name="PRODUCT_OS_NAME" />

      Når denne politik indstilles til sand, planlægges der en automatisk genstart, når <ph name="PRODUCT_OS_NAME" /> er blevet opdateret, og en genstart er nødvendig for at fuldføre opdateringen. Genstarten planlægges med det samme, men den kan være forsinket med op til 24 timer på enheden, hvis en bruger er i færd med at bruge enheden.

      Når denne politik indstilles til falsk, planlægges der ingen automatisk genstart efter opdateringen af <ph name="PRODUCT_OS_NAME" />. Opdateringen fuldføres, når brugeren næste gang genstarter enheden.

      Hvis du indstiller denne politik, kan brugerne ikke ændre eller tilsidesætte den.

      Bemærk! Automatisk genstart aktiveres kun, når loginskærmen vises, eller hvis en terminalapp kører. Dette vil ændre sig med tiden, og politikken vil altid være gældende, uanset om en hvilken som helst type kører eller ej.</translation>
<translation id="7701341006446125684">Angiv cachestørrelse (i bytes) for apps og udgivelser</translation>
<translation id="7709537117200051035">En ordbog, der knytter værtsnavne til en boolesk markering, angiver, om adgang til hosten tillades (sand) eller blokeres (falsk).

          <ph name="PRODUCT_NAME" /> bruger selv politikken internt.</translation>
<translation id="7712109699186360774">Spørg mig, hver gang et website ønsker at få adgang til kameraet og/eller mikrofonen</translation>
<translation id="7713608076604149344">Begrænsninger af download</translation>
<translation id="7715711044277116530">Procentdel, som nedtoningsforsinkelsen på skærmen skaleres i præsentationstilstand</translation>
<translation id="7717938661004793600">Konfigurer hjælpefunktioner for <ph name="PRODUCT_OS_NAME" />.</translation>
<translation id="7724994675283793633">Denne politik aktiverer HTTP/0.9 på andre porte end 80 for HTTP og 443 for HTTPS.

      Denne politik er som standard deaktiveret. Hvis den aktiveres, kan brugerne blive udsat for sikkerhedsproblemet https://crbug.com/600352.

      Denne politik har til formål at give virksomheder mulighed for at migrere eksisterende servere væk fra HTTP/0.9 og vil blive fjernet på et senere tidspunkt.

      Hvis denne politik ikke er angivet, deaktiveres HTTP/0.9 på ikke-standard-porte.</translation>
<translation id="7747447585227954402">Tillad, at enheder anvender en <ph name="PLUGIN_VM_NAME" /> i <ph name="PRODUCT_OS_NAME" />.</translation>
<translation id="7749402620209366169">Aktiverer godkendelse med to faktorer for værter med fjernadgang i stedet for en brugerangivet pinkode.

          Hvis denne indstilling er aktiveret, skal brugerne angive en gyldig kode med to faktorer, når de forsøger at få adgang til en vært.

          Hvis indstillingen er deaktiveret eller ikke angivet, aktiveres de to faktorer ikke, og standardadfærden for brugerdefinerede pinkoder anvendes.</translation>
<translation id="7750991880413385988">Åbn siden Ny fane</translation>
<translation id="7754704193130578113">Spørg, hvor hver enkelt fil skal gemmes, inden download begynder</translation>
<translation id="7761446981238915769">Konfigurer listen over installerede apps på loginskærmen</translation>
<translation id="7763479091692861127"> De forbindelsestyper, der er tilladt at bruge ved OS-opdateringer. OS-opdateringer kan lægge et stort pres på forbindelsen, fordi de fylder meget, og kan forårsage yderligere omkostninger. Derfor er de som standard ikke aktiveret for forbindelsestyper, der betragtes som dyre, hvilket i øjeblikket er WiMax, Bluetooth og mobil.

      De genkendte forbindelsestype-id'er er "ethernet", "wifi", "wimax", "bluetooth" og "mobil".</translation>
<translation id="7763614521440615342">Vis forslag til indhold på siden Ny fane</translation>
<translation id="7765879851993224640">Tillad brug af login med Smart Lock.</translation>
<translation id="7774768074957326919">Brug systemets proxyindstillinger</translation>
<translation id="7775831859772431793">Du kan angive webadressen til proxyserveren her.

          Denne politik træder kun i kraft, hvis du har valgt manuelle proxyindstillinger i "Vælg, hvordan indstillinger for proxyservere skal angives".

          Du bør ikke angive denne politik, hvis du har valgt en anden tilstand til angivelse af proxypolitikker.

          Du kan finde flere valgmuligheder og detaljerede eksempler på:
          <ph name="PROXY_HELP_URL" />.</translation>
<translation id="7781069478569868053">Siden Ny fane</translation>
<translation id="7788511847830146438">Pr. profil</translation>
<translation id="780603170519840350">Deaktiverer håndhævelse af krav vedrørende Certifikatgennemsigtighed for en liste over hash-koder fra subjectPublicKeyInfo.

      Politikken tillader, at kravene om offentliggørelse via Certifikatgennemsigtighed ikke håndhæves for certifikatkæder, der indeholder certifikater med en af de angivne hash-koder fra subjectPublicKeyInfo. Dermed kan certifikater, der ellers ikke ville være godkendt, fordi de ikke er blevet offentliggjort korrekt, fortsat anvendes til virksomhedshosts.

      For at håndhævelse af Certifikatgennemsigtighed kan deaktiveres, når politikken er angivet, skal én af følgende betingelser være opfyldt:
      1. Hash-koden er fra servercertifikatets subjectPublicKeyInfo.
      2. Hash-koden er fra en subjectPublicKeyInfo, der indgår i et CA-certifikat i certifikatkæden, og det pågældende CA-certifikat er begrænset via udvidelsen X.509v3 nameConstraints. Derudover er én eller flere directoryName nameConstraints til stede i permittedSubtrees, og directoryName indeholder en attribut af typen organizationName.
      3. Hash-koden er fra subjectPublicKeyInfo, der indgår i CA-certifikatet i certifikatkæden, og CA-certifikatet har én eller flere attributter af typen organizationName i certifikatets Emne. Derudover indeholder serverens certifikat det samme antal attributter af typen organizationName i samme rækkefølge og med identiske værdier byte for byte.

      En hash-kode fra subjectPublicKeyInfo angives ved at sammenføje navnet på hash-algoritmen, tegnet "/" og Base64-kodningen for den pågældende hash-algoritme, der anvendes i subjectPublicKeyInfo med DER-kodning i det angivne certifikat. Denne Base64-kodning har samme format som et SPKI-fingeraftryk, som beskrevet i afsnit 2.4 i RFC 7469. Ukendte hash-algoritmer ignoreres. Det er i øjeblikket kun hash-algoritmen "sha256", som understøttes.

      Hvis politikken ikke angives, behandles alle certifikater, der skal offentliggøres via Certifikatgennemsigtighed, som ikke-godkendte, hvis de ikke offentliggøres i overensstemmelse med politikken for Certifikatgennemsigtighed.</translation>
<translation id="7818131573217430250">Indstil standardtilstanden for høj kontrast på loginskærmen</translation>
<translation id="7822837118545582721">Når denne politik er angivet som sand, kan brugerne ikke skrive noget til eksterne lagerenheder.

      Hvis denne indstilling er angivet til falsk eller ikke er konfigureret, kan brugere oprette og ændre filer på eksterne lagerenheder, der er fysisk skrivbare.

      Politikken ExternalStorageDisabled har forrang over denne politik. Hvis ExternalStorageDisabled er angivet til sand, er al adgang til eksternt lager deaktiveret, og dermed ignoreres denne politik.

Dynamisk opdatering af denne politik understøttes i M56 og nyere versioner.</translation>
<translation id="7831595031698917016">Specificerer den maksimale forsinkelse i millisekunder mellem modtagelse af en ugyldiggørelse af en politik og hentningen af den nye politik fra tjenesten til enhedshåndtering.

      Når denne politik angives, tilsidesættes standardværdien på 5000 millisekunder. Gyldige værdier for denne politik går fra 1000 (1 sekund) til 300000 (5 minutter). Værdier uden for intervallet rundes af til den nærmeste grænse.

      Hvis du ikke angiver denne politik, vil <ph name="PRODUCT_NAME" /> anvende standardværdien på 5000 millisekunder.</translation>
<translation id="7841880500990419427">Minimumsversion af TLS som backup</translation>
<translation id="7842869978353666042">Konfigurer indstillinger for Google Drev</translation>
<translation id="787125417158068494">Hvis den er angivet til SyncDisabled eller ikke er konfigureret, er certifikater i <ph name="PRODUCT_OS_NAME" /> ikke tilgængelige for ARC-apps.

      Hvis den er angivet til CopyCaCerts, er alle ONC-installerede CA-certifikater med <ph name="WEB_TRUSTED_BIT" /> tilgængelige for ARC-apps.</translation>
<translation id="7882585827992171421">Denne politik er kun aktiv i detailtilstand.

      Bestemmer id'et for den udvidelse, der skal bruges som pauseskærm på loginskærmen. Udvidelsen skal være en del af den AppPack, der er konfigureret til dette domæne via politikken DeviceAppPack.</translation>
<translation id="7882857838942884046">Hvis du deaktiverer Google Sync, fungerer Android-tjenesten til backup og gendannelse ikke korrekt.</translation>
<translation id="7882890448959833986">Ignorer advarslen om manglende understøttelse af OS</translation>
<translation id="7902255855035461275">Mønstre på denne liste sammenlignes med sikkerhedskilden for den anmodende webadresse. Hvis der findes et match, gives der adgang til videooptagelsesenheder, uden at du behøver give tilladelse til det.

BEMÆRK! Op til version 45 var denne funktion kun understøttet i terminaltilstand.</translation>
<translation id="7912255076272890813">Konfigurer tilladte app-/udvidelsestyper</translation>
<translation id="7915236031252389808">Du kan angive en webadresse til en proxyfil af typen .pac her.

          Denne politik fungerer kun, hvis du har valgt manuelle proxyindstillinger i "Vælg, hvordan indstillinger for proxyservere skal angives".

          Du bør ikke angive denne politik, hvis du har valgt en anden tilstand for angivelse af proxypolitikker.

          Få detaljerede eksempler på:
          <ph name="PROXY_HELP_URL" />.</translation>
<translation id="7922358664346625612">Hold den sidste fane åben i Chrome.</translation>
<translation id="793134539373873765">Angiver, om p2p skal anvendes til OS-opdateringsdata. Hvis denne politik angives til Sand, vil enheder dele og forsøge at forbruge opdateringsdata på LAN-netværket, hvor den potentielt kan reducere forbruget og overbelastningen af internetbåndbredden. Hvis opdateringsdata ikke er tilgængelige på LAN-netværket, vil enheden i stedet downloade fra en opdateringsserver. Hvis den angives til Falsk eller ikke konfigureres, vil p2p ikke blive anvendt.</translation>
<translation id="7933141401888114454">Aktivér oprettelse af administrerede brugere</translation>
<translation id="793473937901685727">Indstil certifikattilgængelighed for ARC-apps</translation>
<translation id="7937766917976512374">Tillad eller afvis videooptagelse</translation>
<translation id="7941975817681987555">Forudse ikke netværkshandlinger på nogen netværksforbindelse</translation>
<translation id="7953256619080733119">Manuel undtagelse for host for administreret bruger</translation>
<translation id="7961779417826583251">Deaktiver håndhævelse af Certifikatgennemsigtighed for en liste over forældede certifikatautoriteter</translation>
<translation id="7974114691960514888">Denne politik understøttes ikke længere. Muliggør brug af STUN- og relæservere ved oprettelse af forbindelse til en ekstern klient. Hvis denne indstilling er aktiveret, kan denne maskine finde og oprette forbindelse til eksterne værtsmaskiner, selvom de er adskilt af en firewall. Hvis denne indstilling er deaktiveret, og udgående UDP-forbindelser filtreres af firewallen, kan denne maskine kun oprette forbindelse til værtsmaskiner inden for det lokale netværk.</translation>
<translation id="7976157349247117979">Navnet på destinationen for <ph name="PRODUCT_NAME" /></translation>
<translation id="7980227303582973781">Ingen særlige begrænsninger</translation>
<translation id="7985242821674907985"><ph name="PRODUCT_NAME" /></translation>
<translation id="7992136759457836904">Giver dig mulighed for at styre, om det er tilladt for virtuelle maskiner at køre i Chrome OS.

      Hvis politikken er angivet som Sand, har enheden tilladelse til at køre virtuelle maskiner.
      Hvis politikken er angivet som Falsk, har enheden ikke tilladelse til at køre virtuelle maskiner.
      Alle tre politikker, VirtualMachinesAllowed, CrostiniAllowed og DeviceUnaffiliatedCrostiniAllowed, skal være angivet som Sand, når de anvendes for at tillade, at Crostini køres.
      Når politikken ændres til Falsk, gælder den for opstart af nye virtuelle maskiner, men lukker ikke maskiner, som allerede kører.
      Når denne politik ikke er angivet på en administreret enhed, har enheden ikke tilladelse til at køre virtuelle maskiner.
      Enheder, der ikke administreres, har tilladelse til at køre virtuelle maskiner.</translation>
<translation id="8001701200415781021">Begræns, hvilke Google-konti der må angives som primære konti i browseren i <ph name="PRODUCT_NAME" /></translation>
<translation id="8009554972280451023">Hvis du aktiverer denne indstilling, skrives indstillingerne, der er gemt i <ph name="PRODUCT_NAME" />-profiler, f.eks. bogmærker, autofylddata og adgangskoder, også i en fil, der er gemt i roamingmappen for brugerprofilen eller et andet sted, som angivet af administratoren via <ph name="ROAMING_PROFILE_LOCATION_POLICY_NAME" />-politikken. Hvis du aktiverer denne politik, deaktiveres synkronisering i skyen.

      Hvis politikken deaktiveres eller ikke konfigureres, er det kun de almindelige lokale profiler, der bruges.

      Politikken <ph name="SYNC_DISABLED_POLICY_NAME" /> deaktiverer al datasynkronisering og tilsidesætter <ph name="ROAMING_PROFILE_SUPPORT_ENABLED_POLICY_NAME" />.</translation>
<translation id="802147957407376460">Roter skærmen 0 grader</translation>
<translation id="8033913082323846868">Denne politik er udfaset i M70. Brug AutofillAddressEnabled og AutofillCreditCardEnabled i stedet for.

Aktiverer funktionen AutoFyld i <ph name="PRODUCT_NAME" /> og giver brugerne mulighed for automatisk at udfylde webformularer med oplysninger, der tidligere er gemt, såsom oplysninger om adresser og kreditkort.

Hvis du deaktiverer denne indstilling, er AutoFyld ikke tilgængelig for brugerne.

Hvis du aktiverer denne indstilling eller ikke konfigurerer en værdi, forbliver AutoFyld under brugerens kontrol. Dette giver brugerne mulighed for at konfigurere AutoFyld-profiler og for at aktivere og deaktivere AutoFyld efter eget valg.</translation>
<translation id="8044493735196713914">Rapportér genstart på enheden</translation>
<translation id="8050080920415773384">Indbygget udskrivning</translation>
<translation id="8053580360728293758">Tilsidesætter farvetilstanden for standardudskrivning. Hvis tilstanden ikke er tilgængelig, ignoreres denne politik.</translation>
<translation id="8059164285174960932">Den webadresse, hvor klienten til fjernadgang skal hente deres godkendelsestoken</translation>
<translation id="8078366200175825572">Gør det muligt at oprette en liste over webadressemønstre for at angive websites, som ikke må angive cookies.

          Hvis denne politik ikke angives, anvendes den globale standardværdi på alle websites, enten fra politikken "DefaultCookiesSetting", hvis den er angivet, eller brugerens personlige konfiguration.

          Se også politikkerne "CookiesAllowedForUrls" og "CookiesSessionOnlyForUrls". Bemærk, at der ikke må være nogen modstridende webadressemønstre mellem disse tre politikker – det er ikke angivet, hvilken af politikkerne der har forrang.</translation>
<translation id="8099880303030573137">Inaktivitetsforsinkelse, når batteriet bruges</translation>
<translation id="8102913158860568230">Standardindstilling for mediestrøm</translation>
<translation id="8104186956182795918">Giver dig mulighed for at angive, om websites må vise billeder. Visning af billeder kan enten tillades for alle websites eller forbydes for alle websites.

          Hvis denne politik ikke angives, anvendes "AllowImages", og brugeren kan ændre den.

          Bemærk, at denne politik tidligere ved en fejl blev aktiveret for Android, men denne funktionalitet har aldrig været understøttet fuldt ud af Android.</translation>
<translation id="8104962233214241919">Vælg automatisk klientcertifikater til disse websites</translation>
<translation id="8112122435099806139">Angiver, hvilket urformat der skal anvendes på enheden.

      Denne politik konfigurerer det urformat, der anvendes på loginskærmen og som standard i brugersessions. Brugere kan stadig tilsidesætte urformatet på deres konto.

      Hvis denne politik er indstillet til sand, bruger enheden et 24-timers urformat. Hvis politikken er indstillet til falsk, bruger enheden et 12-timers urformat.

      Hvis denne politik ikke indstilles, bruger enheden som standard et 24-timers urformat.</translation>
<translation id="8114382167597081590">Gennemtving ikke Begrænset tilstand på YouTube</translation>
<translation id="8118665053362250806">Angiv størrelse på mediediskcache</translation>
<translation id="8124468781472887384">Adgangspolitik for konfiguration af printere til enheder.</translation>
<translation id="8135937294926049787">Angiver den tid uden brugerinput, der aktiverer skærmsluk, når strømforsyningen er tilsluttet.

          Hvis denne politik indstilles til en højere værdi end nul, angives den tid, hvor brugeren skal være inaktiv, før <ph name="PRODUCT_OS_NAME" /> slukker skærmen.

          Hvis denne politik indstilles til nul, slukker <ph name="PRODUCT_OS_NAME" /> ikke skærmen, når brugeren er inaktiv.

          Hvis denne politik ikke indstilles, anvendes standardindstillingen.

          Politikkens værdi skal angives i millisekunder. Værdierne reduceres, så de er mindre end eller lig med inaktivitetsforsinkelsen.</translation>
<translation id="8138009212169037227">Denne politik styrer, om der skal rapporteres data om politikken og tidspunktet for hentning af politikken.

      Hvis denne politik ikke er angivet eller er angivet som Sand, indhentes der data om politikken og tidspunktet for hentning af politikken.
      Hvis denne politik er angivet til Falsk, indhentes der ikke data om politikken eller tidspunktet for hentning af politikken.

      Denne politik gælder kun, når <ph name="CHROME_REPORTING_EXTENSION_NAME" /> er aktiveret, og maskinen er tilmeldt <ph name="MACHINE_LEVEL_USER_CLOUD_POLICY_ENROLLMENT_TOKEN_POLICY_NAME" />.</translation>
<translation id="8140204717286305802">Rapportér en liste over netværksgrænseflader med deres typer og hardwareadresser til serveren.

      Hvis politikken er angivet til Falsk, rapporteres listen over grænseflader ikke.</translation>
<translation id="8141795997560411818">Denne politik forhindrer ikke brugeren i at bruge Google Drev-appen til Android. Hvis du vil forhindre adgang til Google Drev, skal du heller ikke tillade installation af Google Drev-appen til Android.</translation>
<translation id="8142894094385450823">Angiv de anbefalede landestandarder for en administreret session</translation>
<translation id="8146727383888924340">Tillad, at brugerne indløser kampagnetilbud via Chrome OS-registrering</translation>
<translation id="8148785525797916822">Ignorerer den advarsel, der vises, når <ph name="PRODUCT_NAME" /> kører på en computer eller et operativsystem, der ikke længere understøttes.</translation>
<translation id="8148901634826284024">Aktivér hjælpefunktionen Høj kontrast.

          Hvis denne politik angives som sand, vil høj kontrast altid være aktiveret.

          Hvis denne politik angives som falsk, vil høj kontrast altid være deaktiveret.

          Hvis du angiver denne politik, kan brugerne ikke ændre eller tilsidesætte den.

          Hvis denne politik ikke angives, vil høj kontrast være deaktiveret, men brugeren kan når som helst slå funktionen til.</translation>
<translation id="815061180603915310">Hvis denne politik er aktiveret, tvinger den profilen til at skifte til engangsbruger. Hvis denne politik er angivet som en OS-politik (f.eks. GPO i Windows), vil den være gældende for alle profiler i systemet. Hvis politikken er angivet som en cloudpolitik, vil den kun være gældende for en profil, der er logget ind med en administreret konto.

      I denne tilstand gemmes profildataene kun på harddisken, så længe brugersessionen varer. Funktioner som f.eks. browserhistorik, udvidelser og hertil knyttede webdata som f.eks. cookies og webdatabaser gemmes ikke, når browseren lukkes. Men dette forhindrer ikke brugeren i at downloade eventuelle data til harddisken manuelt, gemme sider eller udskrive dem.

      Hvis brugeren har aktiveret synkronisering, gemmes alle disse data i brugerens synkroniseringsprofil på samme måde som almindelige profiler. Inkognitotilstand er tilgængelig, medmindre den er udtrykkeligt deaktiveret i henhold til politikken.

      Hvis politikken er deaktiveret eller ikke er angivet, fører login til en almindelig profil.</translation>
<translation id="8158758865057576716">Aktivér oprettelse af roamingkopier til <ph name="PRODUCT_NAME" />-profildata.</translation>
<translation id="817455428376641507">Giver adgang til de angivne webadresser som undtagelser til sortlisten for webadresser.

     Se beskrivelsen af ​politikken for sortlistede webadresser for adgangsformen på denne liste. 

      Denne politik kan bruges til at åbne undtagelser til de restriktive sortlister. "*" kan f.eks. blive sortlistet for at blokere alle anmodninger, og denne politik kan bruges til at give adgang til en begrænset liste over webadresser. Den kan bruges til at åbne undtagelser til visse netværk, underdomæner af andre domæner, porte eller specifikke stier.

       Det mest konkrete filter vil fastslå, om en webadresse er blokeret eller tilladt. Hvidlisten har forrang for sortlisten.

      Denne politik er begrænset til 1000 adgange, og efterfølgende adgange ignoreres. 

      Hvis denne politik ikke angives, vil der ikke være nogen undtagelser til sortlisten fra politikken "URLBlacklist".</translation>
<translation id="8176035528522326671">Tillad, at kun virksomhedsbrugeren er primær multiprofilbruger (standardadfærd for virksomhedsadministrerede brugere)</translation>
<translation id="8214600119442850823">Konfigurerer adgangskodeadministratoren.</translation>
<translation id="8244525275280476362">Maksimal henteforsinkelse efter ugyldiggørelse af en politik</translation>
<translation id="8256688113167012935">Styrer det kontonavn, som <ph name="PRODUCT_OS_NAME" /> viser på loginskærmen for den tilsvarende enhedslokale konto.

      Hvis denne politik er indstillet, bruger loginskærmen den angivne streng i den billedbaserede loginvælger for den tilsvarende enhedslokale konto.

      Hvis politikken ikke er indstillet, bruger <ph name="PRODUCT_OS_NAME" /> den enhedslokale kontos e-mailkonto-id som det viste navn på loginskærmen.

      Denne politik ignoreres for almindelige brugerkonti.</translation>
<translation id="8259375588339409826">Både Chromium og Google Chrome understøtter den samme række politikker. Bemærk, at dette dokument kan indeholde politikker, der ikke er udgivet (dvs. angivelsen af "understøttes på" henviser til en ikke-udgivet version af <ph name="PRODUCT_NAME" />), som kan ændres eller fjernes uden varsel, og for hvilke ingen garantier stilles, herunder garantier vedrørende deres sikkerheds- og privatlivsegenskaber.

Disse politikker er udelukkende beregnet til at blive brugt til konfiguration af <ph name="PRODUCT_NAME" /> internt i din virksomhed. Brug af disse politikker uden for din virksomhed (f.eks. i et offentligt distribueret program) betragtes som malware og vil højst sandsynligt blive markeret som malware af Google og antivirusleverandører.

Du behøver ikke at konfigurere disse indstillinger manuelt. Du kan downloade tilgængelige Windows-, Mac- og Linux-skabeloner på <ph name="POLICY_TEMPLATE_DOWNLOAD_URL" />.

Den anbefalede fremgangsmåde til konfiguration af politikker i Windows er via GPO, selvom provisionering af politikker via registreringsdatabasen fortsat understøttes for forekomster i Windows, der er tilknyttet et <ph name="MS_AD_NAME" />-domæne.</translation>
<translation id="8264653492961233132">Angiver en liste over apps og udvidelser, der installeres uovervåget.
          Dette foregår i baggrunden uden brugerinteraktion, og hverken apps eller udvidelser kan
          afinstalleres af brugeren. Alle tilladelser, som apps/udvidelser
          anmoder om, gives implicit uden brugerinteraktion, herunder
          eventuelle ekstra tilladelser, der anmodes om af fremtidige
          versioner af appen/udvidelsen. Derudover gives der tilladelser til
          udvidelses-API'erne enterprise.deviceAttributes og enterprise.platformKeys.
          (Disse to API'er er ikke tilgængelige for apps/udvidelser, der ikke
          tvangsinstalleres).

          Denne politik prioriteres, hvis der skulle opstå en konflikt med en <ph name="EXTENSION_INSTALL_BLACKLIST_POLICY_NAME" />-politik. Hvis en app eller udvidelse, som tidligere er tvangsinstalleret, fjernes fra denne liste, afinstalleres den automatisk af <ph name="PRODUCT_NAME" />.

          I forbindelse med Windows-forekomster, som ikke er knyttet til et <ph name="MS_AD_NAME" />-domæne, er gennemtvunget installation begrænset til apps og udvidelser, som fås i Chrome Webshop.

          Bemærk, at kildekoden i alle udvidelser kan ændres af brugere via Udviklerværktøjer (hvilket kan medføre, at udvidelsen ikke fungerer). Hvis du vil undgå dette, skal politikken <ph name="DEVELOPER_TOOLS_POLICY_NAME" /> angives.

          Hvert listepunkt i politikken er en streng, som indeholder et udvidelses-id og en "opdateringswebadresse" adskilt af et semikolon (<ph name="SEMICOLON" />). Udvidelses-id'et er den streng på 32 bogstaver, som f.eks. kan findes på <ph name="CHROME_EXTENSIONS_LINK" />, når udviklertilstanden bruges. "Opdateringswebadressen" skal pege på et XML-dokument med et opdateringsmanifest som beskrevet på <ph name="LINK_TO_EXTENSION_DOC1" />. Bemærk, at "opdateringswebadressen", der angives i denne politik, kun bruges til den første installation. Efterfølgende opdateringer af udvidelsen anvender den opdateringswebadresse, som er angivet i udvidelsens manifest. Bemærk også, at det var påkrævet eksplicit at angive "opdateringswebadressen" i <ph name="PRODUCT_NAME" />-versioner op til og med 67.

          <ph name="EXTENSION_POLICY_EXAMPLE" /> installerer f.eks. appen <ph name="EXTENSION_POLICY_EXAMPLE_EXTENSION_NAME" /> fra "standardopdateringswebadressen" fra Chrome Webshop. Du kan få flere oplysninger om hosting af udvidelser her: <ph name="LINK_TO_EXTENSION_DOC2" />.

          Hvis denne politik ikke angives, installeres ingen apps eller udvidelser automatisk, og brugeren kan afinstallere alle apps og udvidelser i <ph name="PRODUCT_NAME" />.

          Bemærk, at denne politik ikke gælder for inkognitotilstand.</translation>
<translation id="8274603902181597201">Slet brugerens eCryptfs-hovedmapper, og start med en frisk ext4-krypteret hovedmappe.</translation>
<translation id="8285435910062771358">Lup i fuld skærm er aktiveret</translation>
<translation id="8288199156259560552">Aktivér Googles placeringstjeneste til Android</translation>
<translation id="8292322992383748446">Rapportér hardwarestatistik for chipsystemkomponenter.

      Hvis politikken angives som Falsk, rapporteres statistikken ikke.
      Hvis politikken angives som Sand eller ikke angives, rapporteres statistikken.</translation>
<translation id="8294750666104911727">Normalt vil sider, der er angivet med X-UAchrome=1, blive gengivet i <ph name="PRODUCT_FRAME_NAME" />, uanset politikken for 'ChromeFrameRendererSettings'.

          Hvis du aktiverer denne indstilling, vil sider ikke blive scannet for metatags.

          Hvis du deaktiverer denne indstilling, vil sider blive scannet for metatags.

          Hvis denne politik ikke indstilles, vil sider blive scannet for metatags.</translation>
<translation id="8300455783946254851">Deaktiverer Google Drev-synkronisering i appen Filer i <ph name="PRODUCT_OS_NAME" /> ved brug af en mobilforbindelse, hvis den er angivet til Sand. I dette tilfælde synkroniseres data kun med Google Drev, når der er oprettet forbindelse via Wi-Fi eller Ethernet.

          Hvis den ikke er indstillet eller er angivet til Falsk, kan brugerne overføre filer til Google Drev via mobilforbindelser.</translation>
<translation id="8300992833374611099">Bestem selv, hvor Udviklerværktøjer kan bruges</translation>
<translation id="8306117673860983372">Indstillinger for login</translation>
<translation id="8312129124898414409">Giver dig mulighed for at angive, om websites må anvende nøglegenerering. Brug af nøglegenerering kan enten være tilladt for alle websites eller nægtet for alle websites.

          Hvis denne politik ikke angives, anvendes "BlockKeygen", og brugeren vil kunne ændre den.</translation>
<translation id="8329984337216493753">Denne politik er kun aktiv i detailtilstand.

      Når DeviceIdleLogoutTimeout er angivet, definerer denne politik varigheden af advarselsfeltet med en nedtælling, der vises, inden brugeren logges ud.

      Politikværdien skal angives i millisekunder.</translation>
<translation id="8339420913453596618">Sekundær faktor er deaktiveret</translation>
<translation id="8344454543174932833">Importer bogmærker fra standardbrowser ved første visning</translation>
<translation id="8359734107661430198">Aktivér ExampleDeprecatedFeature API frem til 02/09/2008</translation>
<translation id="8367209241899435947">Aktivér Chrome-oprydning i Windows</translation>
<translation id="8369602308428138533">Skærmslukforsinkelse, når strømforsyning er tilsluttet</translation>
<translation id="8371178326720637170">Gør det muligt for administrerede udvidelser at bruge Enterprise Hardware Platform API</translation>
<translation id="8374747520743832795">Rapportér hardwarestatistik og id'er, der er relateret til strøm.

      Hvis politikken angives som Falsk, rapporteres statistikken ikke.
      Hvis politikken angives som Sand eller ikke angives, rapporteres statistikken.</translation>
<translation id="8377433219608936819">
      Hvis politikken er angivet som sand, har cloudpolitikken forrang, hvis den er i uoverensstemmelse med maskinpolitikken.
      Hvis politikken er angivet til falsk eller ikke konfigureret, har maskinpolitikken forrang, hvis den er i uoverensstemmelse med cloudpolitikken.
      Du kan få flere oplysninger om politikprioriteter på: https://support.google.com/chrome?p=set_chrome_policies_for_devices

      Denne politik er kun tilgængelig for Windows-forekomster, der er knyttet til et <ph name="MS_AD_NAME" />-domæne, eller Windows 10 Pro- eller Enterprise-forekomster, der er tilmeldt administration af enheder.</translation>
<translation id="8382184662529825177">Aktivér brug af fjernattestering til indholdsbeskyttelse for enheden.</translation>
<translation id="838870586332499308">Aktivér dataroaming</translation>
<translation id="8390049129576938611">Deaktiverer den interne PDF-fremviser i <ph name="PRODUCT_NAME" />. Behandler den i stedet som download og gør det muligt for brugeren at åbne PDF-filer via standardapplikationen.

      Hvis politikken ikke angives, eller hvis den deaktiveres, anvendes PDF-pluginnet til at åbne PDF-filer, medmindre brugeren deaktiverer pluginnet.</translation>
<translation id="8395749934754392549">Styrer indstillingerne for Android-containeren (ARC) og Android-apps.</translation>
<translation id="8396145449084377015">Politikken styrer, om der skal indlæses regler fra politikken SiteList for Internet Explorer.

      Hvis politikken er angivet som Falsk eller ikke er konfigureret, anvender <ph name="PRODUCT_NAME" /> ikke politikken <ph name="IEEM_SITELIST_POLICY" /> for Internet Explorer som en kilde til regler for browserskift.

      Hvis politikken er angivet som Sand, læser <ph name="PRODUCT_NAME" /> Internet Explorers <ph name="IEEM_SITELIST_POLICY" /> for at indhente websitelistens webadresse. <ph name="PRODUCT_NAME" /> downloader derefter websitelisten fra den pågældende webadresse og anvender reglerne, som om de var blevet konfigureret med politikken <ph name="SITELIST_POLICY_NAME" />.

      Få flere oplysninger om politikken <ph name="IEEM_SITELIST_POLICY" /> for Internet Explorer: https://docs.microsoft.com/internet-explorer/ie11-deploy-guide/what-is-enterprise-mode</translation>
<translation id="8402079500086185021">Åbn altid PDF-filer eksternt</translation>
<translation id="8412312801707973447">Om der udføres online kontrol af OCSP/CRL</translation>
<translation id="8417305981081876834">Angiv den maksimale længde for pinkoden til låseskærmen</translation>
<translation id="841977920223099909">Udløser af advarsler via adgangskodebeskyttelse</translation>
<translation id="8424255554404582727">Angiv en standardrotation for visningen, som genanvendes ved hver genstart</translation>
<translation id="8426231401662877819">Roter skærmen 90 grader med uret</translation>
<translation id="8433186206711564395">Netværksindstillinger</translation>
<translation id="8433423491036718210">Konfigurer listen over webadresser til virksomhedslogin, hvor tjenesten til adgangskodebeskyttelse skal registrere fingeraftryk som adgangskoder.</translation>
<translation id="8451988835943702790">Brug siden Ny fane som startside</translation>
<translation id="8459216513698220096">Angiver, hvorvidt og hvordan brugerpolitikken fra et computerrelateret gruppepolitikobjekt (GPO) skal behandles.

      Hvis politikken er indstillet til "Standard" eller ikke er angivet, læses brugerpolitikken kun fra brugerrelaterede GPO'er (computerrelaterede GPO'er ignoreres).

      Hvis politikken er indstillet til "Flet", flettes brugerpolitikken i brugerrelaterede GPO'er med brugerpolitikken i computerrelaterede GPO'er (computerrelaterede GPO'er har forrang).

      Hvis politikken er indstillet til "Erstat", erstattes brugerpolitikken i brugerrelaterede GPO'er med brugerpolitikken i computerrelaterede GPO'er (brugerrelaterede GPO'er ignoreres).</translation>
<translation id="8465065632133292531">Parametre for direkte webadresse, som bruger POST</translation>
<translation id="847472800012384958">Tillad ikke, at websites viser pop op-vinduer</translation>
<translation id="8477885780684655676">TLS 1.0</translation>
<translation id="8483004350080020634">Renser webadresser af typen https:// for følsomme dele vedrørende personlige oplysninger og sikkerhed, før de overføres til PAC-scripter (Proxy Auto Config), som anvendes af <ph name="PRODUCT_NAME" /> under proxyfortolkning.

      Hvis politikken er angivet som Sand, er sikkerhedsfunktionen aktiveret, og webadresser af typen https://
      renses, før de indsendes til et PAC-script. På den måde kan
      PAC-scriptet ikke se data, der normalt er beskyttet af en
      krypteret kanal (som f.eks. webadressens sti og forespørgsel).

      Hvis politikken er angivet som Falsk, er sikkerhedsfunktionen deaktiveret, og PAC-scripts får
      implicit tilladelse til at se alle komponenter i en webadresse af typen https://.
      Dette gælder for alle PAC-scripts uanset oprindelse (inklusive
      scripts, der hentes via en usikker overførsel eller opdages på en usikker måde
      via WPAD).

      Politikken er som standard angivet som Sand (sikkerhedsfunktionen er aktiveret).

      Det anbefales, at politikken angives som Sand. Den eneste grund til at angive den som
      Falsk, er hvis den forårsager et kompatibilitetsproblem med eksisterende PAC-scripts.

      Politikken bliver fjernet i M75.</translation>
<translation id="8484458986062090479">Tilpas listen over webstedsmønstre, der altid bør gengives af hostbrowseren.

          Hvis denne politik ikke er angivet, anvendes standardgengivelsen på alle websites, sådan som det er angivet i politikken "ChromeFrameRendererSettings".

          Se eksempler på mønstre på https://www.chromium.org/developers/how-tos/chrome-frame-getting-started.</translation>
<translation id="8489964335640955763">PluginVm</translation>
<translation id="8493645415242333585">Deaktiver lagring af browserhistorik</translation>
<translation id="8499172469244085141">Standardindstillinger (brugere kan tilsidesætte)</translation>
<translation id="8507835864888987300">Angiver en målversion for automatiske opdateringer.

      Angiver præfikset for en målversion, som <ph name="PRODUCT_OS_NAME" /> skal opdatere til. Hvis enheden kører en version, som er ældre end det angivne præfiks, opdateres den til den seneste udgave med det givne præfiks. Hvis enheden allerede kører en nyere udgave, er det værdien af <ph name="DEVICE_ROLLBACK_TO_TARGET_VERSION_POLICY_NAME" />, som afgør effekten. Præfiksformatet fungerer som en komponent, som det fremgår af følgende eksempel:

      "" (eller ikke konfigureret): Opdater til den nyeste tilgængelige version.
      "1412.": Opdater til en underversion af  1412 (f.eks. 1412.24.34 eller 1412.60.2)
      "1412.2.": Opdater til en underversion af 1412.2 (f.eks. 1412.2.34 eller 1412.2.2)
      "1412.24.34": Opdater kun til denne specifikke version

      Advarsel! Det frarådes at konfigurere versionsbegrænsninger, da det kan forhindre brugerne i at modtage softwareopdateringer og kritiske sikkerhedsrettelser. Begrænsning af opdateringer til et bestemt præfiks for versionen kan udgøre en risiko for brugerne.</translation>
<translation id="8519264904050090490">Webadresser for manuel undtagelse af administreret bruger</translation>
<translation id="8525526490824335042">Linux-container</translation>
<translation id="8538235451413605457">Konfigurerer kravene for den <ph name="PRODUCT_NAME" />-version, der som minimum tillades. De versioner, der ikke opfylder kravene, betragtes som forældede, og enheden tillader ikke, at brugere logger ind, før OS er opdateret.
      Hvis den nuværende version bliver forældet under brugersessionen, logges brugeren ud ved tvang.

      Hvis denne politik ikke er angivet, gælder der ingen begrænsninger, og brugeren kan logge ind i alle <ph name="PRODUCT_NAME" />-versioner.

      Her kan "Version" være enten en eksakt version såsom "61.0.3163.120" eller et præfiks for versionen, f.eks. "61.0"  </translation>
<translation id="8544375438507658205">Standard HTML-gengivelse for <ph name="PRODUCT_FRAME_NAME" /></translation>
<translation id="8544465954173828789">Tillad, at sms-beskeder synkroniseres mellem telefon og Chromebook.</translation>
<translation id="8548832052135586762">Indstiller udskrivning til kun farveudskrivning, kun udskrivning i sort/hvid eller ingen begrænsning af farvetilstand. En ikke-angivet politik behandles som ingen begrænsning.</translation>
<translation id="8549772397068118889">Vis en advarsel, når du er på websites uden for indholdspakkerne</translation>
<translation id="8566842294717252664">Skjul webshoppen fra siden Ny fane og applisten</translation>
<translation id="857369585509260201">Denne politik er udfaset. Overvej at bruge BrowserSignin i stedet.

      Hvis denne politik er angivet som Sand, skal brugeren logge ind i <ph name="PRODUCT_NAME" /> med sin profil, inden browseren anvendes. Standardværdien for BrowserGuestModeEnabled angives dermed som Falsk. Bemærk! Eksisterende profiler, hvor der ikke er logget ind, låses og kan ikke længere anvendes efter aktivering af denne politik. Du kan få flere oplysninger i artiklen i Hjælp.

      Hvis politikken er angivet som Falsk eller ikke er konfigureret, kan brugeren anvende browseren uden at logge ind i <ph name="PRODUCT_NAME" />.</translation>
<translation id="8586528890725660268">Angiver, hvilke printere en bruger ikke kan anvende.

      Denne politik anvendes kun, hvis <ph name="PRINTERS_BLACKLIST" /> er valgt for <ph name="BULK_PRINTERS_ACCESS_MODE" />.

      Hvis denne politik anvendes, har brugeren adgang til alle printere bortset fra dem med id'er, der er angivet i denne politik. Id'erne skal stemme overens med feltet "id" eller "guid" i den fil, der er angivet i <ph name="BULK_PRINTERS_POLICY" />.
      </translation>
<translation id="8587229956764455752">Tillad oprettelse af nye brugerkonti</translation>
<translation id="8598350264853261122">Hvis politikken er indstillet til falsk, har brugere uden tilknytning ikke tilladelse til at bruge ARC.

      Hvis politikken ikke er indstillet eller er indstillet til sand, har alle brugere tilladelse til at bruge ARC (medmindre ARC deaktiveres på anden måde).

      Ændringer i politikken anvendes kun, når ARC ikke kører, dvs. når Chrome OS starter op.</translation>
<translation id="8615400197788843468">Aktiverer den begrænsede funktion til login i G Suite for <ph name="PRODUCT_NAME" /> og forhindrer brugerne i at ændre denne indstilling.

      Hvis du definerer denne indstilling, kan brugerne kun få adgang til Google
      Apps via konti fra de angivne domæner (bemærk, at hvis konti af typen
      gmail.com/googlemail.com skal tillades, skal du føje "consumer_accounts"
      (uden citationstegn) til listen over domæner).

      Denne indstilling forhindrer brugeren i at logge ind og tilføjer en sekundær
      konto på en administreret konto, der kræver Google-godkendelse, hvis denne
      konto ikke tilhører den tidligere nævnte liste over tilladte domæner.

      Hvis du undlader at markere/konfigurere denne indstilling, kan brugerne
      få adgang til G Suite via enhver konto.

      Som følge af denne politik føjes headeren X-GoogApps-Allowed-Domains til
      alle HTTP- og HTTPS-anmodninger på alle google.com-domæner som beskrevet på
      https://support.google.com/a/answer/1668854.

      Brugerne kan ikke ændre eller tilsidesætte denne indstilling.</translation>
<translation id="8631434304112909927">indtil version <ph name="UNTIL_VERSION" /></translation>
<translation id="8649763579836720255">Chrome OS-enheder kan bruge ekstern attestation (bekræftet adgang) til at få udstedt et certifikat af Chrome OS CA, som bekræfter, at enheden er kvalificeret til at afspille beskyttet indhold. Denne proces involverer afsendelse af oplysninger om hardwaregodkendelse til Chrome OS CA, som identificerer enheden.

          Hvis denne indstilling er angivet som falsk, anvender enheden ikke ekstern attestation til indholdsbeskyttelse, og enheden kan muligvis ikke afspille beskyttet indhold.

          Hvis denne indstilling er angivet som sand, eller hvis den ikke er angivet, anvendes ekstern attestation muligvis i forbindelse med indholdsbeskyttelse.</translation>
<translation id="8650974590712548439">Placering i Windows-registreringsdatabasen for Windows-klienter:</translation>
<translation id="8654286232573430130">Angiver, hvilke servere der skal føjes til hvidlisten til integreret godkendelse. Integreret godkendelse aktiveres kun, når <ph name="PRODUCT_NAME" /> modtager en godkendelsesanmodning fra en proxy eller fra en server, der er tilladt på denne liste.

          Adskil servernavne med kommaer. Jokertegn (*) er tilladt.

          Hvis denne politik ikke indstilles, prøver <ph name="PRODUCT_NAME" /> at registrere, om der er en server på intranettet, og kun i det tilfælde reageres der på IWA-anmodninger. Hvis en server registreres som internet, ignoreres IWA-anmodninger af <ph name="PRODUCT_NAME" />.</translation>
<translation id="8672321184841719703">Målversion for automatiske opdateringer</translation>
<translation id="867410340948518937">U2F (Universal Second Factor)</translation>
<translation id="8682611302223077049">Giver dig mulighed for at angive et tidsrum i millisekunder, hvor brugerne underrettes om, at <ph name="PRODUCT_NAME" /> eller en <ph name="PRODUCT_OS_NAME" />-enhed skal genstartes for at anvende en afventende opdatering.

      I dette tidsrum informeres brugeren gentagne gange om nødvendigheden af en opdatering. Når der registreres en opdatering til <ph name="PRODUCT_OS_NAME" />-enheder, vises en notifikation om genstart i systembakken. For <ph name="PRODUCT_NAME" />-browsere ændres appmenuen for at vise, at genstart er nødvendig, når en tredjedel af notifikationsperioden er gået. Notifikationen skifter farve, når to tredjedele af notifikationsperioden er gået, og igen når hele notifikationsperioden er udløbet. De yderligere notifikationer, der aktiveres af politikken <ph name="RELAUNCH_NOTIFICATION_POLICY_NAME" />, følger samme tidsplan.

      Hvis politikken ikke konfigureres, anvendes standardtidsrummet på 345600000 millisekunder (fire dage) for <ph name="PRODUCT_OS_NAME" />-enheder og 604800000 millisekunder (én uge) for <ph name="PRODUCT_NAME" />.</translation>
<translation id="8685024486845674965">Advarsler via adgangskodebeskyttelse udløses ved genbrug af adgangskoder</translation>
<translation id="8693243869659262736">Brug den indbyggede DNS-klient</translation>
<translation id="8703488928438047864">Rapportér tavlestatus</translation>
<translation id="8704831857353097849">Liste over deaktiverede plugins</translation>
<translation id="8711086062295757690">Angiver det nøgleord, som er den genvej, der bruges i omnifeltet til at aktivere søgningen for denne udbyder. Denne politik er valgfri. Hvis den ikke angives, vil ingen søgeord aktivere søgemaskinen. Denne politik tages kun i betragtning, hvis politikken "DefaultSearchProviderEnabled" er aktiveret.</translation>
<translation id="8731693562790917685">Indstillinger for indhold giver dig mulighed for at angive, hvordan en bestemt type indhold (for eksempel cookies, billeder eller JavaScript) skal behandles.</translation>
<translation id="8733448613597049197">Aktiverer udvidet rapportering af Beskyttet browsing for <ph name="PRODUCT_NAME" /> og forhindrer brugerne i at ændre denne indstilling.

      Udvidet rapportering sender visse former for systemoplysninger og sideindhold til Googles servere som en hjælp til at registrere skadelige apps og websites.

      Hvis indstillingen er angivet som Sand, oprettes og sendes der rapporter efter behov (f.eks. når der vises en mellemliggende sikkerhedsannonce).

      Hvis indstillingen er angivet som Falsk, sendes der aldrig rapporter.

      Hvis politikken er angivet som Sand eller Falsk, kan brugerne ikke ændre indstillingen.

      Hvis politikken ikke angives, kan brugerne ændre indstillingen og bestemme, om der skal sendes rapporter.

      Få flere oplysninger om Beskyttet browsing på https://developers.google.com/safe-browsing.</translation>
<translation id="8736538322216687231">Gennemtving som minimum Begrænset tilstand på YouTube</translation>
<translation id="8749370016497832113">Aktiverer sletning af browserhistorik og downloadhistorik i <ph name="PRODUCT_NAME" /> og forhindrer brugerne i at ændre denne indstilling.

      Bemærk, at selv når denne politik er deaktiveret, er det ikke sikkert, at browser- og downloadhistorik gemmes. Brugerne kan muligvis redigere eller slette historikfilerne direkte, og browseren kan til enhver tid udløbe eller arkivere alle historikelementer.

      Hvis denne indstilling er aktiveret eller ikke er angivet, kan browser- og downloadhistorik slettes.

      Hvis denne indstilling er deaktiveret, kan browser- og downloadhistorik ikke slettes.</translation>
<translation id="8758831693895931466">Aktivér obligatorisk tilmelding til cloud managemant</translation>
<translation id="8759829385824155666">Tilladte Kerberos-krypteringstyper</translation>
<translation id="8764119899999036911">Angiver, om den genererede Kerberos SPN er baseret på det kanoniske DNS-navn eller det navn, der oprindeligt blev indtastet. Hvis du aktiverer denne indstilling, springes CNAME-opslag over, og servernavnet anvendes, sådan som det er indtastet. Hvis du deaktiverer denne indstilling eller ikke angiver den, vil det kanoniske navn på den pågældende server blive fastlagt via CNAME-opslag.</translation>
<translation id="8765776988041674792">Konfigurer webadressen til ændring af adgangskode (kun HTTP- og HTTPS-skemaer). Tjenesten til adgangskodebeskyttelse sender brugerne til denne webadresse, hvor de kan ændre deres adgangskode efter at have set en advarsel i browseren.
      Før <ph name="PRODUCT_NAME" /> kan registrere fingeraftrykket for den nye adgangskode korrekt på denne side til ændring af adgangskoder, skal du sørge for, at din side til ændring af adgangskoder følger retningslinjerne på https://www.chromium.org/developers/design-documents/create-amazing-password-forms.

      Hvis denne indstilling er aktiveret, sender tjenesten til beskyttelse af adgangskoder brugerne til denne webadresse, så de kan ændre adgangskoden, når de har set en advarsel i browseren.
      Hvis denne indstilling er deaktiveret, eller der ikke er angivet en værdi, sender tjenesten til beskyttelse af adgangskoder brugerne til https://myaccounts.google.com, så adgangskoden kan ændres der.
      Denne politik er kun tilgængelig for Windows-forekomster, der er knyttet til et <ph name="MS_AD_NAME" />-domæne, eller Windows 10 Pro- eller Enterprise-forekomster, der er tilmeldt administration af enheder.</translation>
<translation id="8798099450830957504">Standard</translation>
<translation id="8801680448782904838">Underret en bruger om, at genstart af browseren eller enheden anbefales eller påkræves</translation>
<translation id="8818173863808665831">Rapportér enhedens geografiske placering.

      Hvis politikken ikke er angivet eller angivet til falsk, rapporteres placeringen ikke.</translation>
<translation id="8818768076343557335">Forudse netværkshandlinger på alle andre netværk end mobilnetværk.
          (Udfaset i 50, fjernet i 52. Efter 52 behandles værdi 1, hvis denne er angivet, som 0. Forudse netværkshandlinger på enhver netværksforbindelse).</translation>
<translation id="8825782996899863372">Advarsler via adgangskodebeskyttelse udløses ved genbrug af adgangskoder på en phishingside</translation>
<translation id="8828766846428537606">Konfigurerer standardstartsiden i <ph name="PRODUCT_NAME" /> og forhindrer brugerne i at ændre den. Brugerens startsideindstillinger låses kun helt, hvis du enten vælger, at startsiden skal være siden Ny fane eller indstiller den til at være en webadresse og angiver en webadresse for startsiden. Hvis du ikke angiver webadressen for startsiden, kan brugeren stadig angive siden Ny fane som startside ved at angive "chrome://newtab".</translation>
<translation id="8833109046074170275">Godkendelse via standardprocessen for GAIA</translation>
<translation id="8838303810937202360"><ph name="PRODUCT_OS_NAME" /> cachelagrer apps og udvidelser til installation af flere brugere på den samme enhed for at undgå at downloade dem for hver bruger én gang til.
      Hvis denne politik ikke er konfigureret, eller hvis værdien er lavere end 1 MB, anvender <ph name="PRODUCT_OS_NAME" /> standardstørrelsen for cachen.</translation>
<translation id="8858642179038618439">Gennemtving Beskyttet tilstand på YouTube</translation>
<translation id="8860342862142842017">Deaktiver håndhævelse af Certifikatgennemsigtighed for en liste over hash-koder fra subjectPublicKeyInfo</translation>
<translation id="8864975621965365890">Undertrykker opfordringen til afvisning, som vises, når et website gengives af <ph name="PRODUCT_FRAME_NAME" />.</translation>
<translation id="8867464911288727016">Aktiverer den integrerede tjeneste Google Oversæt i <ph name="PRODUCT_NAME" />.

      Hvis du aktiverer denne indstilling, viser <ph name="PRODUCT_NAME" /> en integreret værktøjslinje, der tilbyder brugeren oversættelse, når det er relevant, og en oversættelsesmulighed i genvejsmenuen ved højreklik.

      Hvis du deaktiverer denne indstilling, deaktiveres alle indbyggede oversættelsesfunktioner.

      Hvis du aktiverer eller deaktiverer denne indstilling, kan brugerne ikke ændre eller tilsidesætte indstillingen i <ph name="PRODUCT_NAME" />.

      Hvis indstillingen ikke konfigureres, kan brugerne selv bestemme, om de vil bruge denne funktion eller ej.</translation>
<translation id="8870318296973696995">Startside</translation>
<translation id="8876188741456358123">Tilsidesætter standardudskrivning i duplex-tilstand. Hvis tilstanden ikke er tilgængelig, ignoreres denne politik.</translation>
<translation id="8882006618241293596">Bloker <ph name="FLASH_PLUGIN_NAME" />-pluginnet på disse websites</translation>
<translation id="890403179930035128">Gennemtvinger aktivering af stavekontrol af sprog. Ikke-genkendte sprog på denne liste ignoreres.

      Hvis du aktiverer denne politik, aktiveres stavekontrol for de angivne sprog samt de sprog, for hvilke brugeren har aktiveret stavekontrol.

      Hvis du ikke indstiller denne politik, eller hvis du deaktiverer den, vil der ikke være nogen ændring af brugerens præferencer i forhold til stavekontrol.

      Hvis politikken SpellcheckEnabled er deaktiveret, har denne politik ikke nogen effekt.

      De aktuelt understøttede sprog er følgende: af, bg, ca, cs, da, de, el, en-AU, en-CA, en-GB, en-US, es, es-419, es-AR, es-ES, es-MX, es-US, et, fa, fo, fr, he, hi, hr, hu, id, it, ko, lt, lv, nb, nl, pl, pt-BR, pt-PT, ro, ru, sh, sk, sl, sq, sr, sv, ta, tg, tr, uk, vi.</translation>
<translation id="8906768759089290519">Aktivér gæstetilstand</translation>
<translation id="8908294717014659003">Giver dig mulighed for at angive, om websites skal have adgang til optageenheder. Der kan gives adgang til optageenheder som standard, eller brugeren kan blive spurgt, hver gang et website ønsker at få adgang til optageenheder.

          Hvis denne politik ikke indstilles, anvendes "PromptOnAccess", og brugeren vil være i stand til at ændre den.</translation>
<translation id="8909280293285028130">Angiver den tid uden brugerinput, der aktiverer skærmlås, når strømforsyningen er tilsluttet.

          Hvis denne politik indstilles til en værdi, der er større end nul, angiver den en tid, som brugeren skal være inaktiv, før <ph name="PRODUCT_OS_NAME" /> låser skærmen.

          Hvis politikken indstilles til nul, låser <ph name="PRODUCT_OS_NAME" /> ikke skærmen, når brugeren er inaktiv.

          Hvis politikken ikke indstilles, anvendes standardindstillingen.

          Den anbefalede metode til skærmlåsning ved inaktivitet er ved at aktivere skærmlås ved suspendering og suspendere <ph name="PRODUCT_OS_NAME" /> efter inaktivitetsforsinkelsen. Denne politik bør kun bruges, hvis skærmlåsning finder sted markant hurtigere end suspendering, eller hvis suspendering ved inaktivitet ikke ønskes.

          Politikkens værdi skal angives i millisekunder. Værdierne reduceres, så de er mindre end inaktivitetsforsinkelsen.</translation>
<translation id="891435090623616439">kodet som en JSON-streng. Få flere oplysninger på <ph name="COMPLEX_POLICIES_URL" /></translation>
<translation id="8934944553121392674">Bestemmer, hvilke printere fra <ph name="DEVICE_PRINTERS_POLICY" /> der kan anvendes af brugerne.

      Angiver, hvilken adgangspolitik der anvendes til konfiguration af flere printere. Hvis <ph name="PRINTERS_ALLOW_ALL" /> er valgt, vises alle printere. Hvis <ph name="PRINTERS_BLACKLIST" /> er valgt, anvendes <ph name="DEVICE_PRINTERS_BLACKLIST" /> til at begrænse adgangen til de angivne printere. Hvis <ph name="PRINTERS_WHITELIST" /> er valgt, angiver <ph name="DEVICE_PRINTERS_WHITELIST" /> kun de printere, der kan vælges.

      Hvis politikken ikke angives, anvendes <ph name="PRINTERS_ALLOW_ALL" /> som standard.
      </translation>
<translation id="8938932171964587769">Udfaset i M69. Brug OverrideSecurityRestrictionsOnInsecureOrigin i stedet for.

Denne politik angiver en liste over kilder (webadresser) eller mønstre (f.eks. "*example.com") for hostnames, hvor sikkerhedsbegrænsninger på usikre kilder ikke anvendes.

Hensigten er at give organisationer mulighed for at angive hvidlistekilder for forældede apps, der ikke kan implementere TLS, eller konfigurere en testserver til intern webudvikling, så deres udviklere kan teste funktioner, der kræver sikre kontekster, uden at skulle anvende TLS på testserveren. Denne politik forhindrer desuden, at kilden mærkes som "Ikke sikker" i omnifeltet.

Angivelse af en liste over webadresser i denne politik har den samme effekt som indstilling af kommandolinjemarkeringen "--unsafely-treat-insecure-origin-as-secure" på en kommasepareret liste over de samme webadresser. Hvis politikken er angivet, tilsidesætter den kommandolinjemarkeringen.

Denne politik er udfaset i M69 til fordel for OverrideSecurityRestrictionsOnInsecureOrigin. Hvis begge politikker er til stede, tilsidesættes denne politik af OverrideSecurityRestrictionsOnInsecureOrigin.

Du kan få flere oplysninger om sikre kontekster på https://www.w3.org/TR/secure-contexts/
      </translation>
<translation id="8942616385591203339">Denne politik styrer, hvorvidt samtykke til synkronisering kan vises til brugeren ved første login. Den bør angives som falsk, hvis brugeren aldrig behøver at bruge samtykke til synkronisering.
      Hvis den angives som falsk, vises samtykke til synkronisering ikke.
      Hvis den angives som sand eller slet ikke angives, vises samtykke til synkronisering.</translation>
<translation id="8947415621777543415">Rapportér enhedens placering</translation>
<translation id="8951350807133946005">Angiv mappen for diskens cache</translation>
<translation id="8952317565138994125">Deaktiverer datasynkronisering i <ph name="PRODUCT_NAME" /> ved hjælp af Google-hostede synkroniseringstjenester og forhindrer brugerne i at ændre denne indstilling.

      Hvis du aktiverer denne indstilling, kan brugerne ikke ændre eller tilsidesætte den i <ph name="PRODUCT_NAME" />.

      Hvis denne politik ikke er angivet, kan brugeren vælge, om Google Sync skal anvendes eller ej.

      Hvis du vil deaktivere Google Sync helt, anbefaler vi, at du deaktiverer tjenesten Google Sync i Google Administrationskonsol.

      Denne politik bør ikke være aktiveret, når politikken <ph name="ROAMING_PROFILE_SUPPORT_ENABLED_POLICY_NAME" /> er aktiveret, da de benytter den samme funktion hos klienten. I så fald deaktiveres Google-hostet synkronisering helt.</translation>
<translation id="8955719471735800169">Tilbage til toppen</translation>
<translation id="8959992920425111821">Standardkonfiguration</translation>
<translation id="8960850473856121830">Mønstre på denne liste sammenlignes med sikkerhedskilden
      for den anmodende webadresse. Hvis der findes et match, gives der adgang
      til lydoptagelsesenheder, uden at du behøver give tilladelse til det.

      BEMÆRK! Op til version 45 var denne funktion kun understøttet i terminaltilstand.</translation>
<translation id="8970205333161758602">Undertryk opfordringen til afvisning for <ph name="PRODUCT_FRAME_NAME" /></translation>
<translation id="8976248126101463034">Tillad gnubby-godkendelse for hosts for fjernadgang</translation>
<translation id="8976531594979650914">Brug systemets standardprinter som standard</translation>
<translation id="8992176907758534924">Tillad ikke, at websites viser billeder</translation>
<translation id="9035964157729712237">Udvidelses-id'er, der skal udelades fra sortlisten</translation>
<translation id="9042911395677044526">Tillader, at netværkskonfigurationen gøres gældende pr. bruger til en <ph name="PRODUCT_OS_NAME" />-enhed. Netværkskonfigurationen er en JSON-formateret streng, sådan som den er defineret af formatet Open Network Configuration som beskrevet på <ph name="ONC_SPEC_URL" /></translation>
<translation id="906631898352326790">
      Hvis politikken er aktiveret, kører hvert af de angivne websites
      på en kommasepareret liste sin egen proces. Dette isolerer også websites,
      der er angivet af underdomæner. Hvis f.eks. https://eksempel.dk/ angives,
      isoleres https://foo.eksempel.dk/ også som en del af
      websitet https://eksempel.dk/.
      Hvis politikken er deaktiveret, deaktiveres begge funktionerne IsolateOrigins og SitePerProcess. Brugere kan stadig aktivere IsolateOrigins manuelt via kommandolinjerapportering.
      Hvis politikken ikke konfigureres, kan brugerne ændre denne indstilling.
      I <ph name="PRODUCT_OS_NAME" /> anbefales det, at der også angives den samme værdi for enhedspolitikken <ph name="DEVICE_LOGIN_SCREEN_ISOLATE_ORIGINS_POLICY_NAME" />. Hvis de to politikker har forskellige værdier, kan der ske forsinkelser ved opstart af en brugersession, mens den værdi, der er angivet af brugerpolitikken, anvendes.

      BEMÆRK! Denne politik anvendes ikke på Android-enheder. Hvis du vil aktivere IsolateOrigins på en Android-enhed, skal du bruge politikindstillingen IsolateOriginsAndroid.
      </translation>
<translation id="9077227880520270584">Timer for automatisk login lokalt på enhed</translation>
<translation id="9084985621503260744">Angiv, om videoaktiviteten påvirker strømstyringen</translation>
<translation id="9088433379343318874">Aktivér indholdsudbyderen for den administrerede bruger</translation>
<translation id="9088444059179765143">Konfigurer metoden for automatisk registrering af tidszone.</translation>
<translation id="9094064873808699479">Træk udgivelsen tilbage, og behold målversionen, hvis versionen af operativsystemet er nyere end målversionen. Forsøg at overføre konfigurationen på enhedsniveau (herunder loginoplysninger til netværket) via tilbagetrækningsprocessen, hvis det er muligt, men udfør tilbagetrækningen med en fuldstændig Powerwash, selvom det ikke er muligt at gendanne dataene (eftersom målversionen ikke understøtter gendannelse af data eller på grund af en ikke-kompatibel ændring tilbage).
          Understøttes i <ph name="PRODUCT_OS_NAME" /> version 70 og nyere. Ved ældre klienter betyder denne værdi, at tilbagetrækning er deaktiveret.</translation>
<translation id="9096086085182305205">Hvidliste til godkendelse af server</translation>
<translation id="9098553063150791878">Politikker for HTTP-godkendelse</translation>
<translation id="9105265795073104888">Det er kun bestemte muligheder for proxykonfiguration, der er tilgængelige for Android-apps. Android-apps kan vælge at anvende proxyen. Du kan ikke tvinge dem til at anvende en proxy.</translation>
<translation id="9106865192244721694">Tillad WebUSB på disse websites</translation>
<translation id="9112727953998243860">Fil til konfiguration af virksomhedsprintere</translation>
<translation id="9112897538922695510">Giver dig mulighed for at registrere en liste over protokolhandlere. Dette kan kun være en anbefalet politik. Egenskaben |protocol| skal indstilles til ordningen, f.eks. "mailto", og egenskaben |url| bør indstilles til webadressemønsteret for den applikation, der handler ordningen. Dette mønster kan omfatte et "%s", som, hvis det findes, erstattes med den handlede webadresse.

          De protokolhandlere, der er registreret via politikker, flettes med dem, der er registreret af brugeren, og begge er tilgængelige og kan anvendes. Brugeren kan tilsidesætte protokolhandlere, der er installeret via en politik, ved at installere en ny standardhandler, men kan ikke fjerne en protokolhandler, der er registreret via en politik.</translation>
<translation id="9123211093995421438">Angiver, hvor mange gange tidligere versioner af <ph name="PRODUCT_OS_NAME" /> der mindst skal kunne gendannes, regnet fra den aktuelle stabile version.

      Standardværdien er 0 for forbrugerenheder og 4 (ca. et halvt år) for enheder, der er tilmeldt via en virksomhed.

      Hvis politikken angives, gælder beskyttelsen mod gendannelse ikke for mindst dette antal tidligere versioner.

      Hvis der angives en lavere værdi for politikken, er virkningen permanent: Enheden kan muligvis ikke længere gendanne tidligere versioner, heller ikke selv om der efterfølgende angives en større værdi for politikken.

      De egentlige muligheder for gendannelse kan også afhænge af enhedsmodellen og kritiske programrettelser.</translation>
<translation id="9126014181388780690">"Giv Google Assistent adgang til skærmindhold"</translation>
<translation id="913195841488580904">Bloker adgang til en liste over webadresser</translation>
<translation id="9135033364005346124">Aktiver <ph name="CLOUD_PRINT_NAME" />-proxyen</translation>
<translation id="9136399279941091445">Intervaller, hvor enheden ikke anvendes, og de angivne enhedspolitikker finder anvendelse</translation>
<translation id="9147029539363974059">Send systemlogfiler til administrationsserveren for at tillade,
      at administratorer overvåger systemlogfilerne.

      Hvis denne politik er angivet til Sand, sendes der systemlogfiler. Hvis
      den er angivet til Falsk eller ikke er angivet, sendes der ingen systemlogfiler.</translation>
<translation id="9150416707757015439">Denne politik er udfaset. Brug i stedet IncognitoModeAvailability. Aktiverer inkognitotilstand i <ph name="PRODUCT_NAME" />. Hvis denne indstilling er aktiveret eller ikke er konfigureret, kan brugerne åbne websider i inkognitotilstand. Hvis denne indstilling er deaktiveret, kan brugerne ikke åbne websider i inkognitotilstand. Hvis denne politik ikke er angivet, vil dette blive aktiveret, så brugeren kan bruge inkognitotilstand.</translation>
<translation id="915194831143859291">Hvis denne politik er angivet til Falsk eller ikke er konfigureret, tillader <ph name="PRODUCT_OS_NAME" />, at brugeren lukker enheden ned.
      Hvis denne politik er angivet til Sand, aktiverer <ph name="PRODUCT_OS_NAME" /> en genstart, når brugeren lukker enheden ned. <ph name="PRODUCT_OS_NAME" /> erstatter alle forekomster af Luk-knapper i grænsefladen med genstartsknapper. Hvis brugeren lukker enheden ved hjælp af afbryderknappen, genstartes den ikke automatisk, selvom politikken er aktiveret.</translation>
<translation id="9152473318295429890">Aktivér indholdsbestemte forslag for relaterede websider</translation>
<translation id="9158929520101169054">Tillad samlet login fra flere konti i browseren</translation>
<translation id="9159126470527871268">Underretter brugeren om, at <ph name="PRODUCT_NAME" /> eller <ph name="PRODUCT_OS_NAME" /> skal genstartes for at anvende en afventende opdatering.

      Denne politikindstilling aktiverer notifikationer, som anbefaler eller kræver, at brugeren genstarter browseren eller enheden. Hvis politikken ikke angives, indikerer <ph name="PRODUCT_NAME" /> over for brugeren via diskrete ændringer af menuen, at en genstart er nødvendig, mens <ph name="PRODUCT_OS_NAME" /> indikerer det samme via en notifikation i systembakken. Hvis "Anbefales" angives for politikken, får brugeren vist en fast advarsel med en anbefaling om, at browseren genstartes. Brugeren kan afvise advarslen for at udskyde genstarten. Hvis "Påkrævet" angives for politikken, får brugeren vist en fast advarsel, som angiver, at der gennemtvinges en genstart af browseren, når notifikationsperioden er udløbet. Denne periode er som standard syv dage for <ph name="PRODUCT_NAME" /> og fire dage for <ph name="PRODUCT_OS_NAME" />, og den kan konfigureres via politikindstillingen <ph name="RELAUNCH_NOTIFICATION_PERIOD_POLICY_NAME" />.

      Brugerens session gendannes efter genstarten.</translation>
<translation id="9165792353046089850">Giver dig mulighed for at angive, om websites må få adgang til tilsluttede USB-enheder. Adgangen kan være fuldstændig blokeret, eller brugeren kan blive spurgt, hver gang et website vil have adgang til tilsluttede USB-enheder.

          Denne politik kan tilsidesættes for bestemte webadressemønstre ved hjælp af politikkerne "WebUsbAskForUrls" og "WebUsbBlockedForUrls".

          Hvis politikken ikke angives, anvendes "3", og brugeren kan ændre denne indstilling.</translation>
<translation id="9167719789236691545">Deaktiver Drev i appen Filer i <ph name="PRODUCT_OS_NAME" /></translation>
<translation id="9187743794267626640">Deaktiver isætning af eksternt lager</translation>
<translation id="9197740283131855199">Den procentdel, som nedtoningsforsinkelsen på skærmen skaleres, hvis brugeren bliver aktiv efter nedtoningen</translation>
<translation id="9200828125069750521">Parametre for billedets webadresse, som anvender POST</translation>
<translation id="920209539000507585">Tving "sidehoveder og sidefødder" til at være slået til eller fra i dialogboksen for udskrivning.

      Hvis politikken ikke er angivet, kan brugeren bestemme, om sidehoveder og sidefødder skal udskrives.

      Hvis politikken er angivet som Falsk, er "Sidehoveder og sidefødder" ikke markeret i dialogboksen Vis udskrift, og brugeren kan ikke ændre den.

      Hvis politikken er angivet som Sand, er "Sidehoveder og sidefødder" markeret i dialogboksen Vis udskrift, og brugeren kan ikke ændre det.</translation>
<translation id="9210953373038593554">Konfigurerer godkendelsestypen for SAML-logins.

      Hvis politikken ikke er angivet eller er angivet som Standard (med værdien 0), bestemmes SAML-loginadfærden af browseren afhængigt af andre faktorer. I det mest grundlæggende scenarie baseres brugergodkendelsen og beskyttelsen af cachelagrede brugerdata på de adgangskoder, som brugerne angiver manuelt.

      Hvis politikken er angivet som ClientCertificate (med værdien 1), anvendes godkendelse af klientcertifikat til brugere, der er tilføjet for nylig, og som logger ind via SAML. Der bruges ingen adgangskoder til sådanne brugere, og deres cachelagrede lokale data beskyttes ved hjælp af tilsvarende kryptografiske nøgler. Med denne indstilling kan der f.eks. konfigureres et chipkort på baggrund af brugergodkendelse (bemærk, at middleware-apps til chipkort skal installeres via politikken DeviceLoginScreenAppInstallList).

      Politikken berører kun brugere, der godkender via SAML.</translation>
<translation id="9213347477683611358">Konfigurer baggrundsbillede på enhedsniveau, der vises på loginskærmen, hvis der ikke er nogen bruger, der er logget ind på enheden. Politikken angives ved at angive den webadresse, som Chrome OS-enheden kan downloade baggrundsbilledet fra, samt et kryptografisk hash, der bruges til at bekræfte downloadens integritet. Billedet skal være i JPEG-format, og filstørrelsen må ikke overskride 16 MB. Webadressen skal være tilgængelig uden godkendelse. Baggrundsbilledet downloades og gemmes i cachen. Det downloades på ny, hver gang webadressen eller hashet ændres.

      Politikken bør angives som en streng, der viser webadressen og hashet i JSON-format, f.eks.,
      {
        "url": "https://example.com/device_wallpaper.jpg",
        "hash": "examplewallpaperhash"
      }

      Hvis baggrundsbilledepolitikken for enheden er angivet, downloader og bruger Chrome OS baggrundsbilledet på loginskærmen, hvis der ikke er nogen bruger, der er logget ind på enheden endnu. Når brugeren logger ind, starter brugerens baggrundsbilledepolitik.

      Hvis enhedens baggrundsbilledepolitik ikke angives, bestemmer brugerens baggrundsbilledepolitik, hvad der skal vises, hvis brugerens baggrundsbilledepolitik er angivet.</translation>
<translation id="9217154963008402249">Hyppighed for netværkspakker til overvågning</translation>
<translation id="922540222991413931">Konfigurer udvidelser, apps og installationskilder til brugerscripts</translation>
<translation id="924557436754151212">Importer gemte adgangskoder fra standardbrowser på første visning</translation>
<translation id="930930237275114205">Angiv brugerdatamappe for <ph name="PRODUCT_FRAME_NAME" /></translation>
<translation id="944817693306670849">Angiv diskcachens størrelse</translation>
<translation id="981346395360763138">Googles placeringstjenester er deaktiveret</translation>
<translation id="982497069985795632">Aktivér stavekontrol</translation>
<translation id="991560005425213776">Send brugernavn og filnavn til native-printere</translation>
</translationbundle>