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

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

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

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

<resources xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
    <string name="yes" msgid="4676390750360727396">"Po"</string>
    <string name="no" msgid="6731231425810196216">"Jo"</string>
    <string name="create" msgid="3578857613172647409">"Krijo"</string>
    <string name="allow" msgid="3349662621170855910">"Lejo"</string>
    <string name="deny" msgid="6947806159746484865">"Refuzo"</string>
    <string name="device_info_default" msgid="7847265875578739287">"I panjohur"</string>
    <plurals name="show_dev_countdown" formatted="false" msgid="7201398282729229649">
      <item quantity="other">Tani je <xliff:g id="STEP_COUNT_1">%1$d</xliff:g> hapa larg të qenët programues.</item>
      <item quantity="one">Tani je <xliff:g id="STEP_COUNT_0">%1$d</xliff:g> hap larg të qenët programues.</item>
    </plurals>
    <string name="show_dev_on" msgid="1110711554982716293">"Tani je zhvillues!"</string>
    <string name="show_dev_already" msgid="2151632240145446227">"Nuk ka nevojë, ti je programues tashmë!"</string>
    <string name="dev_settings_disabled_warning" msgid="4909448907673974370">"Aktivizo opsionet e zhvilluesit në fillim."</string>
    <string name="header_category_wireless_networks" msgid="5110914332313954940">"Rrjetet me valë"</string>
    <string name="header_category_system" msgid="2816866961183068977">"Sistemi"</string>
    <string name="radio_info_data_connection_enable" msgid="8656750679353982712">"Aktivizo lidhjen e të dhënave"</string>
    <string name="radio_info_data_connection_disable" msgid="8541302390883231216">"Çaktivizo lidhjen e të dhënave"</string>
    <string name="volte_provisioned_switch_string" msgid="7979882929810283786">"VoLTE e përgatitur"</string>
    <string name="vt_provisioned_switch_string" msgid="7876998291744854759">"Telefonata me video u parapërgatit"</string>
    <string name="wfc_provisioned_switch_string" msgid="3985406545172898078">"Telefonata me Wifi u parapërgatit"</string>
    <string name="eab_provisioned_switch_string" msgid="3482272907448592975">"EAB/prania është parapërgatitur"</string>
    <string name="cbrs_data_switch_string" msgid="2811485394350106691">"Të dhënat e Crbs"</string>
    <string name="dsds_switch_string" msgid="4832797810509029243">"Aktivizo DSDS"</string>
    <string name="dsds_dialog_title" msgid="4031918551366689574">"Të riniset pajisja?"</string>
    <string name="dsds_dialog_message" msgid="8593083316067158412">"Duhet të rinisësh pajisjen tënde për të ndryshuar këtë cilësim."</string>
    <string name="dsds_dialog_confirm" msgid="2853118984344309612">"Rinis"</string>
    <string name="dsds_dialog_cancel" msgid="654653450305828711">"Anulo"</string>
    <string name="radio_info_radio_power" msgid="7187666084867419643">"Fuqia e radios së rrjetit celular"</string>
    <string name="radioInfo_menu_viewADN" msgid="7069468158519465139">"Shiko librin e adresave të kartës SIM"</string>
    <string name="radioInfo_menu_viewFDN" msgid="7934301566925610318">"Shiko numrat me telefonim të përzgjedhur"</string>
    <string name="radioInfo_menu_viewSDN" msgid="7130280686244955669">"Shiko numrat e telefonit të shërbimit"</string>
    <string name="radioInfo_menu_getIMS" msgid="185171476413967831">"Statusi i Shërbimit IMS"</string>
    <string name="radio_info_ims_reg_status_title" msgid="16971785902696970">"Statusi IMS"</string>
    <string name="radio_info_ims_reg_status_registered" msgid="5614116179751126247">"Regjistruar"</string>
    <string name="radio_info_ims_reg_status_not_registered" msgid="4438054067642750717">"Paregjistruar"</string>
    <string name="radio_info_ims_feature_status_available" msgid="3687807290327566879">"I disponueshëm"</string>
    <string name="radio_info_ims_feature_status_unavailable" msgid="4606182208970114368">"I padisponueshëm"</string>
    <string name="radio_info_ims_reg_status" msgid="7534612158445529715">"Regjistrimi IMS: <xliff:g id="STATUS">%1$s</xliff:g>\nZëri përmes LTE: <xliff:g id="AVAILABILITY_0">%2$s</xliff:g>\nZëri përmes Wi-Fi: <xliff:g id="AVAILABILITY_1">%3$s</xliff:g>\nVideo telefonatat: <xliff:g id="AVAILABILITY_2">%4$s</xliff:g>\nNdërfaqja UT: <xliff:g id="AVAILABILITY_3">%5$s</xliff:g>"</string>
    <string name="radioInfo_service_in" msgid="1697703164394784618">"Në shërbim"</string>
    <string name="radioInfo_service_out" msgid="7999094221728929681">"Jashtë shërbimit"</string>
    <string name="radioInfo_service_emergency" msgid="6274434235469661525">"Vetëm telefonata urgjence"</string>
    <string name="radioInfo_service_off" msgid="7536423790014501173">"Radioja joaktive"</string>
    <string name="radioInfo_roaming_in" msgid="9045363884600341051">"Roaming"</string>
    <string name="radioInfo_roaming_not" msgid="4849214885629672819">"Jo në roaming"</string>
    <string name="radioInfo_phone_idle" msgid="7489244938838742820">"Në gjendje joaktive"</string>
    <string name="radioInfo_phone_ringing" msgid="4883724645684297895">"Po bie zilja"</string>
    <string name="radioInfo_phone_offhook" msgid="5873835692449118954">"Telefonatë në vazhdim"</string>
    <string name="radioInfo_data_disconnected" msgid="1959735267890719418">"I shkëputur"</string>
    <string name="radioInfo_data_connecting" msgid="8404571440697917823">"Po lidhet"</string>
    <string name="radioInfo_data_connected" msgid="7074301157399238697">"Lidhur"</string>
    <string name="radioInfo_data_suspended" msgid="5315325487890334196">"I pezulluar"</string>
    <string name="radioInfo_unknown" msgid="1476509178755955088">"E panjohur"</string>
    <string name="radioInfo_display_packets" msgid="8654359809877290639">"paketa"</string>
    <string name="radioInfo_display_bytes" msgid="4018206969492931883">"bajte"</string>
    <string name="radioInfo_display_dbm" msgid="3621221793699882781">"dBm"</string>
    <string name="radioInfo_display_asu" msgid="1422248392727818082">"asu"</string>
    <string name="radioInfo_lac" msgid="8415219164758307156">"LAC"</string>
    <string name="radioInfo_cid" msgid="4362599198392643138">"CID"</string>
    <string name="sdcard_unmount" product="nosdcard" msgid="6325292633327972272">"Shkëput hapësirën për ruajtje të USB-së"</string>
    <string name="sdcard_unmount" product="default" msgid="3364184561355611897">"Shkëput kartën SD"</string>
    <string name="sdcard_format" product="nosdcard" msgid="6285310523155166716">"Spastro hapësirën për ruajtje të USB-së"</string>
    <string name="sdcard_format" product="default" msgid="6713185532039187532">"Spastroje kartën SD"</string>
    <string name="preview_pager_content_description" msgid="8926235999291761243">"Pamja paraprake"</string>
    <string name="preview_page_indicator_content_description" msgid="4821343428913401264">"Shiko paraprakisht, faqja <xliff:g id="CURRENT_PAGE">%1$d</xliff:g> nga <xliff:g id="NUM_PAGES">%2$d</xliff:g>"</string>
    <string name="font_size_summary" msgid="1690992332887488183">"Bëje tekstin në ekran më të vogël ose më të madh."</string>
    <string name="font_size_make_smaller_desc" msgid="7919995133365371569">"Zvogëlo"</string>
    <string name="font_size_make_larger_desc" msgid="4316986572233686061">"Zmadho"</string>
    <!-- no translation found for font_size_preview_text (4818424565068376732) -->
    <skip />
    <string name="font_size_preview_text_headline" msgid="7955317408475392247">"Teksti shembull"</string>
    <string name="font_size_preview_text_title" msgid="1310536233106975546">"Magjistari i mrekullueshëm i Ozit"</string>
    <string name="font_size_preview_text_subtitle" msgid="4231671528173110093">"Kapitulli 11: Qyteti i mrekullueshëm i smeraldtë i Ozit"</string>
    <string name="font_size_preview_text_body" msgid="2846183528684496723">"Edhe me sytë e mbrojtur nga syzet e gjelbra Doroti dhe shokët e saj u dalldisën në fillim nga shkëlqimi i Qytetit të mrekullueshëm. Rrugët ishin të mbushura me shtëpi të bukura të gjitha të ndërtuara me mermer të gjelbër dhe kudo shkëlqenin prej tyre smeralde. Ata shëtitën në një trotuar me po të njëjtin mermer të gjelbër dhe aty ku blloqet bashkoheshin kishte radhë të tjera smeraldi, ngjitur me njëra-tjetrën, dhe që shkëlqenin nën ndriçimin e diellit. Dritaret ishin me xhama të gjelbër; edhe qielli mbi Qytet kishte një nuancë të gjelbër, dhe rrezet e diellit ishin të gjelbra. \n\nKishte shumë njerëz, burra, gra dhe fëmijë, që shëtisnin dhe të gjithë ishin të veshur me rroba të gjelbra dhe kishin lëkurë të gjelbër. Ata e shikonin Dorotin dhe shoqëruesit e saj të çuditshëm me sy të habitur, dhe fëmijët të gjithë u trembën dhe u fshehën pas nënave kur panë Luanin, por askush nuk u foli. Në rrugë kishte shumë dyqane dhe Doroti pa se gjithçka brenda tyre ishte e gjelbër. Shiteshin karamele të gjelbra dhe kokoshka të gjelbra, si dhe këpucë të gjelbra, kapele të gjelbra dhe rroba të gjelbra të të gjitha llojeve. Në një vend dikush shiste limonadë të gjelbër dhe kur fëmijët blinin, Doroti pa se ata paguanin me monedha të gjelbra. \n\nDukej sikur nuk kishte kuaj apo kafshë të ndonjë lloji; burrat i transportonin sendet me karroca të vogla të gjelbra, të cilat i shtynin përpara. Të gjithë dukeshin të kënaqur, të lumtur dhe të begatë."</string>
    <string name="font_size_save" msgid="3450855718056759095">"Në rregull"</string>
    <string name="sdcard_setting" product="nosdcard" msgid="8281011784066476192">"Hapësira ruajtëse e USB-së"</string>
    <string name="sdcard_setting" product="default" msgid="5922637503871474866">"Karta SD"</string>
    <string name="bluetooth" msgid="5549625000628014477">"Bluetooth-i"</string>
    <string name="bluetooth_is_discoverable" msgid="8373421452106840526">"E dukshme për të gjitha pajisjet me \"Bluetooth\" në afërsi (<xliff:g id="DISCOVERABLE_TIME_PERIOD">%1$s</xliff:g>)"</string>
    <string name="bluetooth_is_discoverable_always" msgid="2849387702249327748">"E dukshme për të gjitha pajisjet me \"Bluetooth\" në afërsi"</string>
    <string name="bluetooth_not_visible_to_other_devices" msgid="9120274591523391910">"Nuk është e dukshme te pajisjet e tjera me \"Bluetooth\""</string>
    <string name="bluetooth_only_visible_to_paired_devices" msgid="2049983392373296028">"E dukshme vetëm për pajisjet e çiftuara"</string>
    <string name="bluetooth_visibility_timeout" msgid="8002247464357005429">"Koha e veprimit mbi dukshmërinë skadoi pa sukses"</string>
    <string name="bluetooth_lock_voice_dialing" msgid="3139322992062086225">"Kyç formimin e numrit me zë"</string>
    <string name="bluetooth_lock_voice_dialing_summary" msgid="4741338867496787042">"Parandalo përdorimin e formuesit të numrit me Bluetooth kur ekrani është i kyçur."</string>
    <string name="bluetooth_devices" msgid="1886018064039454227">"Pajisjet me Bluetooth"</string>
    <string name="bluetooth_device_name" msgid="8415828355207423800">"Emri i pajisjes"</string>
    <string name="bluetooth_device_details" msgid="4594773497930028085">"Cilësimet e pajisjes"</string>
    <string name="bluetooth_profile_details" msgid="6823621790324933337">"Cilësimet e profilit"</string>
    <string name="bluetooth_name_not_set" msgid="2653752006416027426">"Nuk është caktuar emër, po përdoret emri i llogarisë"</string>
    <string name="bluetooth_scan_for_devices" msgid="9214184305566815727">"Skano për pajisje"</string>
    <string name="bluetooth_rename_device" msgid="4352483834491958740">"Riemërto këtë pajisje"</string>
    <string name="bluetooth_rename_button" msgid="1648028693822994566">"Riemërto"</string>
    <string name="bluetooth_disconnect_title" msgid="7830252930348734303">"Të shkëputet pajisja?"</string>
    <string name="bluetooth_disconnect_all_profiles" product="default" msgid="8208712728668714199">"Telefoni yt do të shkëputet nga <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="bluetooth_disconnect_all_profiles" product="tablet" msgid="6611038575213485336">"Tableti yt do të shkëputet nga <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="bluetooth_disconnect_all_profiles" product="device" msgid="3995834526315103965">"Pajisja jote do të shkëputet nga <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="bluetooth_disconnect_dialog_ok" msgid="3308586619539119106">"Shkëput"</string>
    <string name="bluetooth_empty_list_user_restricted" msgid="603521233563983689">"Nuk ke leje për të ndryshuar cilësimet e \"Bluetooth-it\"."</string>
    <string name="bluetooth_pairing_pref_title" msgid="7429413067477968637">"Çifto pajisjen e re"</string>
    <string name="bluetooth_is_visible_message" msgid="6222396240776971862">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g> është e dukshme për pajisjet në afërsi kur Cilësimet e Bluetooth-it janë të hapura."</string>
    <string name="bluetooth_footer_mac_message" product="default" msgid="1109366350000220283">"Adresa e Bluetooth-it e telefonit: <xliff:g id="BLUETOOTH_MAC_ADDRESS">%1$s</xliff:g>"</string>
    <string name="bluetooth_footer_mac_message" product="tablet" msgid="6807634484499166486">"Adresa e Bluetooth-it e tabletit: <xliff:g id="BLUETOOTH_MAC_ADDRESS">%1$s</xliff:g>"</string>
    <string name="bluetooth_footer_mac_message" product="device" msgid="8413944740341742061">"Adresa e Bluetooth-it e pajisjes: <xliff:g id="BLUETOOTH_MAC_ADDRESS">%1$s</xliff:g>"</string>
    <string name="bluetooth_is_disconnect_question" msgid="5334933802445256306">"Të shkëputet <xliff:g id="DEVICE_NAME">%1$s</xliff:g>?"</string>
    <string name="bluetooth_broadcasting" msgid="16583128958125247">"Transmetimi"</string>
    <string name="bluetooth_device" msgid="5291950341750186887">"Pajisje me \"Bluetooth\" e paemërtuar"</string>
    <string name="progress_scanning" msgid="192587958424295789">"Po kërkon"</string>
    <string name="bluetooth_no_devices_found" msgid="1085232930277181436">"Nuk u gjet asnjë pajisje me Bluetooth në afërsi."</string>
    <string name="bluetooth_notif_ticker" msgid="4726721390078512173">"Kërkesë çiftimi me Bluetooth"</string>
    <string name="bluetooth_notif_title" msgid="2485175521845371514">"Kërkesa e çiftimit"</string>
    <string name="bluetooth_notif_message" msgid="5057417127600942904">"Trokit për ta çiftuar me <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="bluetooth_show_received_files" msgid="3144149432555230410">"Skedarët e marrë"</string>
    <string name="bluetooth_show_files_received_via_bluetooth" msgid="5445105773989432594">"Skedarët e marrë me Bluetooth"</string>
    <string name="device_picker" msgid="4978696506172252813">"Zgjidh pajisjen me Bluetooth"</string>
    <string name="bluetooth_ask_enablement" msgid="3387222809404177525">"<xliff:g id="APP_NAME">%1$s</xliff:g> kërkon të aktivizojë Bluetooth-in"</string>
    <string name="bluetooth_ask_disablement" msgid="5890386255790160573">"<xliff:g id="APP_NAME">%1$s</xliff:g> kërkon të çaktivizojë Bluetooth-in"</string>
    <string name="bluetooth_ask_enablement_no_name" msgid="1644353686104482763">"Një aplikacion kërkon të aktivizojë Bluetooth-in"</string>
    <string name="bluetooth_ask_disablement_no_name" msgid="9218830122674868548">"Një aplikacion kërkon të çaktivizojë Bluetooth-in"</string>
    <string name="bluetooth_ask_discovery" product="tablet" msgid="4791779658660357386">"<xliff:g id="APP_NAME">%1$s</xliff:g> kërkon ta bëjë tabletin tënd të dukshëm ndaj pajisjeve të tjera me Bluetooth për <xliff:g id="TIMEOUT">%2$d</xliff:g> sekonda."</string>
    <string name="bluetooth_ask_discovery" product="default" msgid="1308225382575535366">"<xliff:g id="APP_NAME">%1$s</xliff:g> kërkon ta bëjë telefonin tënd të dukshëm ndaj pajisjeve të tjera me Bluetooth për <xliff:g id="TIMEOUT">%2$d</xliff:g> sekonda."</string>
    <string name="bluetooth_ask_discovery_no_name" product="tablet" msgid="225715443477752935">"Një aplikacion kërkon ta bëjë tabletin tënd të dukshëm ndaj pajisjeve të tjera me Bluetooth për <xliff:g id="TIMEOUT">%1$d</xliff:g> sekonda."</string>
    <string name="bluetooth_ask_discovery_no_name" product="default" msgid="4949152735544109994">"Një aplikacion kërkon ta bëjë telefonin tënd të dukshëm ndaj pajisjeve të tjera me Bluetooth për <xliff:g id="TIMEOUT">%1$d</xliff:g> sekonda."</string>
    <string name="bluetooth_ask_lasting_discovery" product="tablet" msgid="8528329166577187961">"<xliff:g id="APP_NAME">%1$s</xliff:g> kërkon ta bëjë tabletin tënd të dukshëm ndaj pajisjeve të tjera me Bluetooth. Këtë mund ta ndryshosh më vonë te cilësimet e Bluetooth-it."</string>
    <string name="bluetooth_ask_lasting_discovery" product="default" msgid="4398738575307583138">"<xliff:g id="APP_NAME">%1$s</xliff:g> kërkon ta bëjë telefonin tënd të dukshëm ndaj pajisjeve të tjera me Bluetooth. Këtë mund ta ndryshosh më vonë te cilësimet e Bluetooth-it."</string>
    <string name="bluetooth_ask_lasting_discovery_no_name" product="tablet" msgid="1702590641426207062">"Një aplikacion kërkon ta bëjë telefonin tënd të dukshëm ndaj pajisjeve të tjera me Bluetooth. Këtë mund ta ndryshosh më vonë te cilësimet e Bluetooth-it."</string>
    <string name="bluetooth_ask_lasting_discovery_no_name" product="default" msgid="8549952177383992238">"Një aplikacion kërkon ta bëjë telefonin tënd të dukshëm ndaj pajisjeve të tjera me Bluetooth. Këtë mund ta ndryshosh më vonë te cilësimet e Bluetooth-it."</string>
    <string name="bluetooth_ask_enablement_and_discovery" product="tablet" msgid="1141843490422565755">"<xliff:g id="APP_NAME">%1$s</xliff:g> kërkon të aktivizojë Bluetooth-in dhe ta bëjë tabletin tënd të dukshëm ndaj pajisjeve të tjera për <xliff:g id="TIMEOUT">%2$d</xliff:g> sekonda."</string>
    <string name="bluetooth_ask_enablement_and_discovery" product="default" msgid="5195836980079191473">"<xliff:g id="APP_NAME">%1$s</xliff:g> kërkon të aktivizojë Bluetooth-in dhe ta bëjë telefonin tënd të dukshëm ndaj pajisjeve të tjera për <xliff:g id="TIMEOUT">%2$d</xliff:g> sekonda."</string>
    <string name="bluetooth_ask_enablement_and_discovery_no_name" product="tablet" msgid="7009338445281693765">"Një aplikacion kërkon të aktivizojë Bluetooth-in dhe ta bëjë tabletin tënd të dukshëm ndaj pajisjeve të tjera për <xliff:g id="TIMEOUT">%1$d</xliff:g> sekonda."</string>
    <string name="bluetooth_ask_enablement_and_discovery_no_name" product="default" msgid="8386904242279878734">"Një aplikacion kërkon të aktivizojë Bluetooth-in dhe ta bëjë telefonin tënd të dukshëm ndaj pajisjeve të tjera për <xliff:g id="TIMEOUT">%1$d</xliff:g> sekonda."</string>
    <string name="bluetooth_ask_enablement_and_lasting_discovery" product="tablet" msgid="2279471426575892686">"<xliff:g id="APP_NAME">%1$s</xliff:g> kërkon të aktivizojë Bluetooth-in dhe ta bëjë tabletin tënd të dukshëm ndaj pajisjeve të tjera. Këtë mund ta ndryshosh më vonë te cilësimet e Bluetooth-it."</string>
    <string name="bluetooth_ask_enablement_and_lasting_discovery" product="default" msgid="6961969825475461450">"<xliff:g id="APP_NAME">%1$s</xliff:g> kërkon të aktivizojë Bluetooth-in dhe ta bëjë telefonin tënd të dukshëm ndaj pajisjeve të tjera. Këtë mund ta ndryshosh më vonë te cilësimet e Bluetooth-it."</string>
    <string name="bluetooth_ask_enablement_and_lasting_discovery_no_name" product="tablet" msgid="692477613671555006">"Një aplikacion kërkon të aktivizojë Bluetooth-in dhe ta bëjë tabletin të dukshëm ndaj pajisjeve të tjera. Këtë mund ta ndryshosh më vonë te cilësimet e Bluetooth-it."</string>
    <string name="bluetooth_ask_enablement_and_lasting_discovery_no_name" product="default" msgid="6374480121751597648">"Një aplikacion kërkon të aktivizojë Bluetooth-in për ta bërë telefonin tënd të dukshëm ndaj pajisjeve të tjera me Bluetooth. Këtë mund ta ndryshosh më vonë te cilësimet e Bluetooth-it."</string>
    <string name="bluetooth_turning_on" msgid="4850574877288036646">"Po aktivizon Bluetooth-in…"</string>
    <string name="bluetooth_turning_off" msgid="2337747302892025192">"Po çaktivizon \"Bluetooth-in\"…"</string>
    <string name="bluetooth_connection_permission_request" msgid="4747918249032890077">"Kërkesa e lidhjes së Bluetooth-it"</string>
    <string name="bluetooth_connection_notif_message" msgid="3603316575471431846">"Trokit për t\'u lidhur me \"<xliff:g id="DEVICE_NAME">%1$s</xliff:g>\"."</string>
    <string name="bluetooth_connection_dialog_text" msgid="8455427559949998023">"Dëshiron që të lidhesh me \"<xliff:g id="DEVICE_NAME">%1$s</xliff:g>\"?"</string>
    <string name="bluetooth_phonebook_request" msgid="3951420080540915279">"Kërkesë për qasje në numërator"</string>
    <string name="bluetooth_pb_acceptance_dialog_text" msgid="8930347091018455505">"<xliff:g id="DEVICE_NAME_0">%1$s</xliff:g> kërkon të ketë qasje te kontaktet dhe historiku i telefonatave. Të lejohet qasja për <xliff:g id="DEVICE_NAME_1">%2$s</xliff:g>?"</string>
    <string name="bluetooth_remember_choice" msgid="6919682671787049800">"Mos pyet përsëri"</string>
    <string name="bluetooth_pb_remember_choice" msgid="3622898084442402071">"Mos pyet më"</string>
    <string name="bluetooth_map_request" msgid="4595727689513143902">"Kërkesë për qasje në mesazhe"</string>
    <string name="bluetooth_map_acceptance_dialog_text" msgid="8712508202081143737">"%1$s kërkon të ketë qasje te mesazhet e tua. Të lejohet qasja për %2$s?"</string>
    <string name="bluetooth_sap_request" msgid="2669762224045354417">"Kërkesa për qasje në kartën SIM"</string>
    <string name="bluetooth_sap_acceptance_dialog_text" msgid="4414253873553608690">"Pajisja <xliff:g id="DEVICE_NAME_0">%1$s</xliff:g> dëshiron të ketë qasje në kartën tënde SIM. Dhënia e të drejtës për qasje në kartën SIM do të çaktivizojë lidhjen e të dhënave në pajisjen tënde gjatë kohëzgjatjes së lidhjes. Jepi qasje pajisjes <xliff:g id="DEVICE_NAME_1">%2$s?</xliff:g>"</string>
    <string name="bluetooth_device_name_summary" msgid="522235742194965734">"E dukshme si \"<xliff:g id="DEVICE_NAME">^1</xliff:g>\" për pajisjet e tjera"</string>
    <string name="bluetooth_off_footer" msgid="8406865700572772936">"Aktivizo Bluetooth-in për t\'u lidhur me pajisje të tjera."</string>
    <string name="bluetooth_paired_device_title" msgid="8638994696317952019">"Pajisjet e tua"</string>
    <string name="bluetooth_pairing_page_title" msgid="7712127387361962608">"Çifto pajisjen e re"</string>
    <string name="bluetooth_pref_summary" product="tablet" msgid="3520035819421024105">"Lejo që tableti yt të komunikojë me pajisjet me Bluetooth në afërsi"</string>
    <string name="bluetooth_pref_summary" product="device" msgid="2205100629387332862">"Lejo që pajisja jote të komunikojë me pajisjet me Bluetooth në afërsi"</string>
    <string name="bluetooth_pref_summary" product="default" msgid="782032074675157079">"Lejo që telefoni yt të komunikojë me pajisjet me Bluetooth në afërsi"</string>
    <string name="bluetooth_disable_a2dp_hw_offload" msgid="4936610906348223810">"Çaktivizo shkarkimin e harduerit të Bluetooth A2DP"</string>
    <string name="bluetooth_disable_a2dp_hw_offload_dialog_title" msgid="4340101417209145308">"Të riniset pajisja?"</string>
    <string name="bluetooth_disable_a2dp_hw_offload_dialog_message" msgid="8827019472003234568">"Duhet të rinisësh pajisjen tënde për të ndryshuar këtë cilësim."</string>
    <string name="bluetooth_disable_a2dp_hw_offload_dialog_confirm" msgid="2053793518537051975">"Rinis"</string>
    <string name="bluetooth_disable_a2dp_hw_offload_dialog_cancel" msgid="2382443064737856652">"Anulo"</string>
    <string name="connected_device_available_media_title" msgid="2560067541413280645">"Pajisjet e ofruara për median"</string>
    <string name="connected_device_available_call_title" msgid="697154660967595684">"Pajisjet e ofruara për telefonata"</string>
    <string name="connected_device_connected_title" msgid="5871712271201945606">"Të lidhur aktualisht"</string>
    <string name="connected_device_saved_title" msgid="688364359746674536">"Pajisjet e ruajtura"</string>
    <string name="connected_device_add_device_summary" msgid="4041865900298680338">"Bluetooth-i do të aktivizohet për çiftimin"</string>
    <string name="connected_device_connections_title" msgid="5988939345181466770">"Preferencat e lidhjes"</string>
    <string name="connected_device_previously_connected_title" msgid="491765792822244604">"Pajisjet e lidhura më parë"</string>
    <string name="connected_device_previously_connected_screen_title" msgid="6196066429488377795">"Të lidhura më parë"</string>
    <string name="connected_device_bluetooth_turned_on_toast" msgid="5683648191381637533">"Bluetooth-i është i aktivizuar"</string>
    <string name="previous_connected_see_all" msgid="3626779872898778415">"Shiko të gjitha"</string>
    <string name="date_and_time" msgid="9062980487860757694">"Data dhe ora"</string>
    <string name="choose_timezone" msgid="1362834506479536274">"Zgjidh brezin orar"</string>
    <!-- no translation found for intent_sender_data_label (6332324780477289261) -->
    <skip />
    <string name="intent_sender_sendbroadcast_text" msgid="1415735148895872715">"Dërgo <xliff:g id="BROADCAST">broadcast</xliff:g>"</string>
    <string name="intent_sender_action_label" msgid="616458370005452389">"<xliff:g id="ACTION">Action</xliff:g>:"</string>
    <string name="intent_sender_startactivity_text" msgid="5080516029580421895">"Fillo <xliff:g id="ACTIVITY">activity</xliff:g>"</string>
    <string name="intent_sender_resource_label" msgid="6963659726895482829">"<xliff:g id="RESOURCE">Resource</xliff:g>:"</string>
    <string name="intent_sender_account_label" msgid="465210404475603404">"Llogaria:"</string>
    <string name="proxy_settings_title" msgid="9049437837600320881">"Përfaqësuesi"</string>
    <string name="proxy_clear_text" msgid="5555400754952012657">"Pastro"</string>
    <string name="proxy_port_label" msgid="5655276502233453400">"Porta e përfaqësuesit"</string>
    <string name="proxy_exclusionlist_label" msgid="7700491504623418701">"Anashkalo përfaqësuesin për"</string>
    <string name="proxy_defaultView_text" msgid="6387985519141433291">"Restauro parazgjedhjet"</string>
    <string name="proxy_action_text" msgid="2957063145357903951">"U krye"</string>
    <string name="proxy_hostname_label" msgid="8490171412999373362">"Emri pritës i përfaqësuesit"</string>
    <string name="proxy_error" msgid="8926675299638611451">"Kujdes!"</string>
    <string name="proxy_error_dismiss" msgid="4993171795485460060">"Në rregull"</string>
    <string name="proxy_error_invalid_host" msgid="6865850167802455230">"Emri i pritësit që shkrove nuk është i vlefshëm."</string>
    <string name="proxy_error_invalid_exclusion_list" msgid="678527645450894773">"Lista e përjashtimeve që shkrove nuk është e formatuar si duhet. Shkruaj një listë të ndarë me presje për domenet e përjashtuara."</string>
    <string name="proxy_error_empty_port" msgid="5539106187558215246">"Duhet të plotësosh fushën e portës."</string>
    <string name="proxy_error_empty_host_set_port" msgid="2451694104858226781">"Fusha e portës duhet të jetë boshe nëse fusha e pritësit është boshe."</string>
    <string name="proxy_error_invalid_port" msgid="5988270202074492710">"Porta që shkrove nuk është e vlefshme."</string>
    <string name="proxy_warning_limited_support" msgid="7229337138062837422">"Përfaqësuesi HTTP përdoret zakonisht nga shfletuesi. Ai mund të mos përdoret nga aplikacionet e tjera."</string>
    <string name="proxy_url_title" msgid="7185282894936042359">"URL-ja e përfaqësuesit: "</string>
    <string name="radio_info_subid" msgid="204582608052503412">"ID-ja dytësore aktuale:"</string>
    <string name="radio_info_dds" msgid="5471937791273237508">"ID-ja dytësore e kartës SIM të parazgjedhur të të dhënave:"</string>
    <string name="radio_info_dl_kbps" msgid="6894556071523815984">"Gjerësia e bandës DL (kbps):"</string>
    <string name="radio_info_ul_kbps" msgid="946464073571185678">"Gjerësia e bandës UL (kbps):"</string>
    <string name="radio_info_signal_location_label" msgid="3242990404410530456">"Informacionet e vendndodhjes të rrjetit celular (e vjetruar):"</string>
    <string name="radio_info_phy_chan_config" msgid="7133247058801474028">"Konfigurimi i kanalit fizik LTE:"</string>
    <string name="radio_info_cell_info_refresh_rate" msgid="7062777594049622128">"Shpejtësia e rifreskimit të informacioneve të rrjetit celular"</string>
    <string name="radio_info_cellinfo_label" msgid="6213223844927623098">"Të gjitha informacionet e matjes së rrjetit celular:"</string>
    <string name="radio_info_gprs_service_label" msgid="4209624131644060517">"Shërbimi i të dhënave:"</string>
    <string name="radio_info_roaming_label" msgid="6141505430275138647">"Roaming:"</string>
    <string name="radio_info_imei_label" msgid="1220524224732944192">"IMEI:"</string>
    <string name="radio_info_call_redirect_label" msgid="2743797189722106231">"Ridrejtimi i telefonatës:"</string>
    <string name="radio_info_ppp_resets_label" msgid="3587319503902576102">"Numri i rivendosjeve të PPP-së që nga rifillimi:"</string>
    <string name="radio_info_current_network_label" msgid="9151285540639134945">"Rrjeti aktual:"</string>
    <string name="radio_info_ppp_received_label" msgid="363579470428151850">"Të dhënat e marra:"</string>
    <string name="radio_info_gsm_service_label" msgid="1370863866816125489">"Shërbimi zanor:"</string>
    <string name="radio_info_signal_strength_label" msgid="5155734002519307416">"Fuqia e sinjalit:"</string>
    <string name="radio_info_call_status_label" msgid="2611065018172747413">"Statusi i telefonatës zanore:"</string>
    <string name="radio_info_ppp_sent_label" msgid="7748668735880404586">"Të dhënat e dërguara:"</string>
    <string name="radio_info_message_waiting_label" msgid="1037302619943328273">"Mesazh në pritje:"</string>
    <string name="radio_info_phone_number_label" msgid="7942153178953255231">"Numri i telefonit:"</string>
    <string name="radio_info_band_mode_label" msgid="8730871744887454509">"Përzgjidh brezin e radios"</string>
    <string name="radio_info_voice_network_type_label" msgid="1443496502370667071">"Lloji i rrjetit të zërit:"</string>
    <string name="radio_info_data_network_type_label" msgid="7094323145105149312">"Lloji i rrjetit të të dhënave:"</string>
    <string name="phone_index_label" msgid="1934407597576454430">"Zgjidh indeksin e telefonit"</string>
    <string name="radio_info_set_perferred_label" msgid="3511830813500105512">"Cakto llojin e preferuar të rrjetit:"</string>
    <string name="radio_info_ping_hostname_v4" msgid="7045103377818314709">"Verifiko emrin e pritësit (www.google.com) IPv4:"</string>
    <string name="radio_info_ping_hostname_v6" msgid="1130906124160553954">"Verifiko emrin e pritësit (www.google.com) IPv6:"</string>
    <string name="radio_info_http_client_test" msgid="2382286093023138339">"Testi i klientit HTTP:"</string>
    <string name="ping_test_label" msgid="579228584343892613">"Ekzekuto testin e verifikimit \"ping\""</string>
    <string name="radio_info_smsc_label" msgid="6399460520126501354">"SMSC:"</string>
    <string name="radio_info_smsc_update_label" msgid="7258686760358791539">"Përditëso"</string>
    <string name="radio_info_smsc_refresh_label" msgid="6902302130315125102">"Rifresko"</string>
    <string name="radio_info_toggle_dns_check_label" msgid="6625185764803245075">"Ndrysho kontrollin e DNS-së"</string>
    <string name="oem_radio_info_label" msgid="6163141792477958941">"Informacion/cilësime specifike për OEM"</string>
    <string name="band_mode_title" msgid="4071411679019296568">"Cakto modalitetin e brezit të radios"</string>
    <string name="band_mode_loading" msgid="3555063585133586152">"Po ngarkon listën e brezave…"</string>
    <string name="band_mode_set" msgid="5730560180249458484">"Cakto"</string>
    <string name="band_mode_failed" msgid="1495968863884716379">"Pa sukses"</string>
    <string name="band_mode_succeeded" msgid="2701016190055887575">"Me sukses!"</string>
    <string name="sdcard_changes_instructions" msgid="4482324130377280131">"Ndryshimet do të zbatohen kur të rilidhet kablloja e USB-së."</string>
    <string name="sdcard_settings_screen_mass_storage_text" msgid="3741220147296482474">"Aktivizo hapësirën ruajtëse masive të USB-së"</string>
    <string name="sdcard_settings_total_bytes_label" msgid="9184160745785062144">"Bajte në total:"</string>
    <string name="sdcard_settings_not_present_status" product="nosdcard" msgid="1636218515775929394">"Hapësira ruajtëse e USB-së nuk është lidhur."</string>
    <string name="sdcard_settings_not_present_status" product="default" msgid="2048419626134861599">"Nuk ka një kartë SD."</string>
    <string name="sdcard_settings_available_bytes_label" msgid="763232429899373001">"Bajtet e lira:"</string>
    <string name="sdcard_settings_mass_storage_status" product="nosdcard" msgid="7993410985895217054">"USB-ja po përdoret si masive."</string>
    <string name="sdcard_settings_mass_storage_status" product="default" msgid="2742075324087038036">"Karta SD po përdoret si pajisje e ruajtjes masive."</string>
    <string name="sdcard_settings_unmounted_status" product="nosdcard" msgid="5128923500235719226">"Hapësira USB mund të hiqet."</string>
    <string name="sdcard_settings_unmounted_status" product="default" msgid="666233604712540408">"Tani nuk ka rrezik të heqësh kartën SD."</string>
    <string name="sdcard_settings_bad_removal_status" product="nosdcard" msgid="7761390725880773697">"USB-ja u hoq gjatë përdorimit!"</string>
    <string name="sdcard_settings_bad_removal_status" product="default" msgid="5145797653495907970">"Karta SD u hoq kur ishte ende në përdorim!"</string>
    <string name="sdcard_settings_used_bytes_label" msgid="8820289486001170836">"Bajtet e përdorura:"</string>
    <string name="sdcard_settings_scanning_status" product="nosdcard" msgid="7503429447676219564">"Po skanon hapësirën ruajtëse të USB-së për media…"</string>
    <string name="sdcard_settings_scanning_status" product="default" msgid="2763464949274455656">"Po skanon kartën SD për media…"</string>
    <string name="sdcard_settings_read_only_status" product="nosdcard" msgid="3624143937437417788">"Hapësira ruajtëse e USB-së e lidhur është vetëm për lexim."</string>
    <string name="sdcard_settings_read_only_status" product="default" msgid="4518291824764698112">"Karta SD e lidhur vetëm për lexim."</string>
    <string name="skip_label" msgid="47510779345218297">"Kapërce"</string>
    <string name="next_label" msgid="4693520878012668114">"Përpara"</string>
    <string name="language_picker_title" msgid="3596315202551687690">"Gjuhët"</string>
    <string name="locale_remove_menu" msgid="7651301406723638854">"Hiqe"</string>
    <string name="add_a_language" msgid="2330538812283783022">"Shto gjuhë"</string>
    <plurals name="dlg_remove_locales_title" formatted="false" msgid="4276642359346122396">
      <item quantity="other">Të hiqet gjuha e zgjedhur?</item>
      <item quantity="one">Të hiqet gjuha e zgjedhur?</item>
    </plurals>
    <string name="dlg_remove_locales_message" msgid="1361354927342876114">"Teksti do të shfaqet në një gjuhë tjetër."</string>
    <string name="dlg_remove_locales_error_title" msgid="2653242337224911425">"Nuk mund të hiqen të gjitha gjuhët"</string>
    <string name="dlg_remove_locales_error_message" msgid="6697381512654262821">"Mbaj të paktën një gjuhë të preferuar"</string>
    <string name="locale_not_translated" msgid="516862628177166755">"Munsd të mos jetë i disponueshëm në disa aplikacione"</string>
    <string name="action_drag_label_move_up" msgid="9052210023727612540">"Lëvize lart"</string>
    <string name="action_drag_label_move_down" msgid="7448713844582912157">"Lëvize poshtë"</string>
    <string name="action_drag_label_move_top" msgid="557081389352288310">"Lëvize në krye"</string>
    <string name="action_drag_label_move_bottom" msgid="2468642142414126482">"Lëvize në fund"</string>
    <string name="action_drag_label_remove" msgid="2861038147166966206">"Hiq gjuhën"</string>
    <string name="activity_picker_label" msgid="6295660302548177109">"Zgjidh aktivitetin"</string>
    <string name="device_info_label" msgid="6551553813651711205">"Informacioni i pajisjes"</string>
    <string name="display_label" msgid="8074070940506840792">"Ekrani"</string>
    <string name="phone_info_label" product="tablet" msgid="7820855350955963628">"Informacion mbi tabletin"</string>
    <string name="phone_info_label" product="default" msgid="2127552523124277664">"Informacioni i telefonit"</string>
    <string name="sd_card_settings_label" product="nosdcard" msgid="8101475181301178428">"Hapësira për ruajtje e USB-së"</string>
    <string name="sd_card_settings_label" product="default" msgid="5743100901106177102">"Karta SD"</string>
    <string name="proxy_settings_label" msgid="3271174136184391743">"Cilësimet e përfaqësuesit"</string>
    <string name="cancel" msgid="6859253417269739139">"Anulo"</string>
    <string name="okay" msgid="1997666393121016642">"Në rregull"</string>
    <string name="forget" msgid="1400428660472591263">"Harro"</string>
    <string name="save" msgid="879993180139353333">"Ruaj"</string>
    <string name="done" msgid="6942539184162713160">"U krye!"</string>
    <string name="apply" msgid="1577045208487259229">"Zbato"</string>
    <string name="share" msgid="6791534619806355910">"Ndaj"</string>
    <string name="add" msgid="3709942705501136412">"Shto"</string>
    <string name="settings_label" msgid="1626402585530130914">"Cilësimet"</string>
    <string name="settings_label_launcher" msgid="8344735489639482340">"Cilësimet"</string>
    <string name="settings_shortcut" msgid="3936651951364030415">"Shkurtorja e cilësimeve"</string>
    <string name="airplane_mode" msgid="8837269988154128601">"Modaliteti i aeroplanit"</string>
    <string name="wireless_networks_settings_title" msgid="3643009077742794212">"Wi-Fi dhe rrjetet"</string>
    <string name="radio_controls_summary" msgid="1838624369870907268">"Menaxho Wi‑Fi, Bluetooth, modalitetin \"në aeroplan\", rrjetet celulare dhe rrjetet VPN"</string>
    <string name="cellular_data_title" msgid="6835451574385496662">"Të dhënat celulare"</string>
    <string name="calls_title" msgid="1262096900483238572">"Lejo telefonatat"</string>
    <string name="sms_messages_title" msgid="1778636286080572535">"Mesazhe MMS"</string>
    <string name="cellular_data_summary" msgid="4660351864416939504">"Lejo përdorimin e të dhënave nëpërmjet rrjetit celular"</string>
    <string name="allow_data_usage_title" msgid="2238205944729213062">"Lejo përdorimin e të dhënave kur je në roaming"</string>
    <string name="roaming" msgid="2619521775007402005">"Roaming"</string>
    <string name="roaming_enable" msgid="3737380951525303961">"Lidhu me shërbimet e të dhënave kur je në roaming"</string>
    <string name="roaming_disable" msgid="1295279574370898378">"Lidhu me shërbimet e të dhënave kur je në roaming"</string>
    <string name="roaming_reenable_message" msgid="9141007271031717369">"Ke humbur lidhshmërinë e të dhënave sepse u largove nga rrjeti vendor me të dhënat e roaming-ut që çaktivizove."</string>
    <string name="roaming_turn_it_on_button" msgid="4387601818162120589">"Aktivizoje"</string>
    <string name="roaming_warning" msgid="4275443317524544705">"Mund të shkaktohen tarifa të larta."</string>
    <string name="roaming_warning_multiuser" product="tablet" msgid="6458990250829214777">"Nëse lejon përdorim të dhënash gjatë kohës që je në roaming, mund të shkaktosh tarifa të konsiderueshme!\n\nKy cilësim ndikon te të gjithë përdoruesit në këtë tablet."</string>
    <string name="roaming_warning_multiuser" product="default" msgid="6368421100292355440">"Nëse lejon përdorim të dhënash gjatë kohës që je në roaming, mund të shkaktosh tarifa të konsiderueshme!\n\nKy cilësim ndikon te të gjithë përdoruesit në këtë telefon."</string>
    <string name="roaming_reenable_title" msgid="6068100976707316772">"Të lejohet shfrytëzimi i roaming-ut?"</string>
    <string name="networks" msgid="6333316876545927039">"Zgjedhja e operatorit"</string>
    <string name="sum_carrier_select" msgid="3616956422251879163">"Zgjidh një operator rrjeti"</string>
    <string name="date_and_time_settings_title" msgid="3350640463596716780">"Data dhe ora"</string>
    <string name="date_and_time_settings_title_setup_wizard" msgid="2391530758339384324">"Vendos datën dhe orën"</string>
    <string name="date_and_time_settings_summary" msgid="7095318986757583584">"Vendos datën, orën, brezin orar dhe formatet"</string>
    <string name="date_time_auto" msgid="4290527098376721491">"Përdor orën e ofruar nga rrjeti"</string>
    <string name="zone_auto_title" msgid="3217703906014135437">"Përdor brezin orar të ofruar nga rrjeti"</string>
    <string name="date_time_24hour_auto" msgid="6276269188890332084">"Përdor parazgjedhjen e lokalitetit"</string>
    <string name="date_time_24hour_title" msgid="3203537578602803850">"Formati \"24 orë\""</string>
    <string name="date_time_24hour" msgid="1193032284921000063">"Përdor formatin 24 orë"</string>
    <string name="date_time_set_time_title" msgid="6296795651349047016">"Ora"</string>
    <string name="time_format_category_title" msgid="736190761036057769">"Formati i orës"</string>
    <string name="date_time_set_timezone_title" msgid="3047322337368233197">"Brezi orar"</string>
    <string name="date_time_set_timezone" msgid="5045627174274377814">"Brezi orar"</string>
    <string name="date_time_set_date_title" msgid="6928286765325608604">"Data"</string>
    <string name="date_time_search_region" msgid="2478334699004021972">"Rajoni i kërkimit"</string>
    <string name="date_time_select_region" msgid="5434001881313168586">"Rajoni"</string>
    <string name="date_time_select_fixed_offset_time_zones" msgid="6084375085203448645">"Zgjidh ndryshimin në UTC"</string>
    <string name="zone_change_to_from_dst" msgid="118656001224045590">"<xliff:g id="TIME_TYPE">%1$s</xliff:g> fillon më <xliff:g id="TRANSITION_DATE">%2$s</xliff:g>."</string>
    <string name="zone_info_exemplar_location_and_offset" msgid="1359698475641349336">"<xliff:g id="EXEMPLAR_LOCATION">%1$s</xliff:g> (<xliff:g id="OFFSET">%2$s</xliff:g>)"</string>
    <string name="zone_info_offset_and_name" msgid="164876167707284017">"<xliff:g id="TIME_TYPE">%2$s</xliff:g> (<xliff:g id="OFFSET">%1$s</xliff:g>)"</string>
    <string name="zone_info_footer" msgid="4192803402331390389">"Përdor <xliff:g id="OFFSET_AND_NAME">%1$s</xliff:g>. <xliff:g id="DST_TIME_TYPE">%2$s</xliff:g> fillon më <xliff:g id="TRANSITION_DATE">%3$s</xliff:g>."</string>
    <string name="zone_info_footer_no_dst" msgid="8652423870143056964">"Përdor <xliff:g id="OFFSET_AND_NAME">%1$s</xliff:g>. Nuk ka orë verore."</string>
    <string name="zone_time_type_dst" msgid="8850494578766845276">"Ora verore"</string>
    <string name="zone_time_type_standard" msgid="3462424485380376522">"Ora standarde"</string>
    <string name="zone_menu_by_region" msgid="8370437123807764346">"Zgjidh sipas rajonit"</string>
    <string name="zone_menu_by_offset" msgid="7161573994228041794">"Zgjidh sipas ndryshimit në UTC"</string>
    <string name="date_picker_title" msgid="1338210036394128512">"Data"</string>
    <string name="time_picker_title" msgid="483460752287255019">"Ora"</string>
    <string name="lock_after_timeout" msgid="3041497579354520533">"Kyçe pas kohës së pritjes së ekranit"</string>
    <string name="lock_after_timeout_summary" msgid="6446294520193562658">"<xliff:g id="TIMEOUT_STRING">%1$s</xliff:g> pas kohës së pritjes"</string>
    <string name="lock_immediately_summary_with_exception" msgid="4887058374400817711">"Menjëherë pas kohës së pritjes, përveçse kur mbahet i shkyçur nga <xliff:g id="TRUST_AGENT_NAME">%1$s</xliff:g>"</string>
    <string name="lock_after_timeout_summary_with_exception" msgid="5693037914721259546">"<xliff:g id="TIMEOUT_STRING">%1$s</xliff:g> pas kohës së pritjes, përveçse kur mbahet i shkyçur nga <xliff:g id="TRUST_AGENT_NAME">%2$s</xliff:g>"</string>
    <string name="show_owner_info_on_lockscreen_label" msgid="5074906168357568434">"Shfaq informacionin e zotëruesit në ekranin e kyçjes"</string>
    <string name="owner_info_settings_title" msgid="5530285568897386122">"Mesazhi i ekranit të kyçjes"</string>
    <string name="security_enable_widgets_title" msgid="2754833397070967846">"Aktivizo miniapl."</string>
    <string name="security_enable_widgets_disabled_summary" msgid="6392489775303464905">"Çaktivizuar nga administratori"</string>
    <string name="lockdown_settings_title" msgid="7393790212603280213">"Shfaq opsionin e bllokimit"</string>
    <string name="lockdown_settings_summary" msgid="4359438673563318171">"Shfaq opsionin e butonit të energjisë që çaktivizon Smart Lock, shkyçjen biometrike dhe njoftimet në ekranin e kyçjes"</string>
    <string name="trust_agents_extend_unlock_title" msgid="2796555263565097031">"Shkyçja e zgjeruar vetëm për agjentët e besimit"</string>
    <string name="trust_agents_extend_unlock_summary" msgid="3976344969220255010">"Nëse janë aktivizuar, agjentët e besimit do ta mbajnë pajisjen tënde të shkyçur për një kohë më të gjatë, por nuk mund ta shkyçin më një pajisje të kyçur."</string>
    <string name="trust_lost_locks_screen_title" msgid="2992742466966021682">"Kyçe ekranin kur të humbasë besimi"</string>
    <string name="trust_lost_locks_screen_summary" msgid="693784434582021206">"Nëse është aktivizuar, pajisja do të kyçet kur agjenti i fundit i besimit të humbasë besimin"</string>
    <string name="owner_info_settings_summary" msgid="7472393443779227052">"Asnjë"</string>
    <string name="owner_info_settings_status" msgid="120407527726476378">"<xliff:g id="COUNT_0">%1$d</xliff:g> / <xliff:g id="COUNT_1">%2$d</xliff:g>"</string>
    <string name="owner_info_settings_edit_text_hint" msgid="7591869574491036360">"P.sh., pajisja Android e Admirit."</string>
    <string name="user_info_settings_title" msgid="1195015434996724736">"Informacioni i përdoruesit"</string>
    <string name="show_profile_info_on_lockscreen_label" msgid="2741208907263877990">"Shfaq informacionin e profilit në ekranin e kyçjes"</string>
    <string name="profile_info_settings_title" msgid="3518603215935346604">"Inform. i profilit"</string>
    <string name="Accounts_settings_title" msgid="1643879107901699406">"Llogaritë"</string>
    <string name="location_settings_title" msgid="1369675479310751735">"Vendndodhja"</string>
    <string name="location_settings_master_switch_title" msgid="3560242980335542411">"Përdor vendndodhjen"</string>
    <string name="location_settings_summary_location_off" msgid="794370259612167176">"Joaktiv"</string>
    <plurals name="location_settings_summary_location_on" formatted="false" msgid="5513447650619485188">
      <item quantity="other">Aktiv - <xliff:g id="COUNT_1">%1$d</xliff:g> aplikacione kanë qasje te vendndodhja</item>
      <item quantity="one">Aktiv - <xliff:g id="COUNT_0">%1$d</xliff:g> aplikacion ka qasje te vendndodhja</item>
    </plurals>
    <string name="location_settings_loading_app_permission_stats" msgid="8523775367089431611">"Po ngarkohet…"</string>
    <string name="account_settings_title" msgid="626177544686329806">"Llogaritë"</string>
    <string name="security_settings_title" msgid="7945465324818485460">"Siguria"</string>
    <string name="encryption_and_credential_settings_title" msgid="6514904533438791561">"Enkriptimi dhe kredencialet"</string>
    <string name="encryption_and_credential_settings_summary" product="default" msgid="8721883002237981248">"Telefoni është i enkriptuar"</string>
    <string name="decryption_settings_summary" product="default" msgid="5671817824042639849">"Telefoni nuk është i enkriptuar"</string>
    <string name="encryption_and_credential_settings_summary" product="tablet" msgid="7200428573872395685">"Pajisja është e enkriptuar"</string>
    <string name="decryption_settings_summary" product="tablet" msgid="5794135636155570977">"Pajisja nuk është e enkriptuar"</string>
    <string name="lockscreen_settings_title" msgid="1099738951060387656">"Afishimi i ekranit të kyçjes"</string>
    <string name="lockscreen_settings_what_to_show_category" msgid="278055252361575926">"Çfarë të shfaqet"</string>
    <string name="security_settings_summary" msgid="967393342537986570">"Cakto \"Vendndodhjen time\", shkyçjen e ekranit, kyçjen e kartës SIM, kyçjen e hapësirës për ruajtjen e kredencialeve"</string>
    <string name="cdma_security_settings_summary" msgid="6068799952798901542">"Cakto \"Vendndodhja ime\", shkyçjen e ekranit, kyçjen e hapësirës ruajtëse të kredencialeve"</string>
    <string name="security_passwords_title" msgid="2881269890053568809">"Privatësia"</string>
    <string name="disabled_by_administrator_summary" msgid="1601828700318996341">"Çaktivizuar nga administratori"</string>
    <string name="security_status_title" msgid="5848766673665944640">"Statusi i sigurisë"</string>
    <string name="security_dashboard_summary_face" msgid="268234254306703218">"Kyçja e ekranit, shkyçja me fytyrë"</string>
    <string name="security_dashboard_summary" msgid="6757421634477554939">"Kyçja e ekranit, gjurma e gishtit"</string>
    <string name="security_dashboard_summary_no_fingerprint" msgid="8129641548372335540">"Kyçja e ekranit"</string>
    <string name="security_settings_face_preference_summary" msgid="1290187225482642821">"Fytyra u shtua"</string>
    <string name="security_settings_face_preference_summary_none" msgid="5596571291522936724">"Konfiguro shkyçjen me fytyrë"</string>
    <string name="security_settings_face_preference_title" msgid="5277300443693527785">"Shkyçja me fytyrë"</string>
    <string name="security_settings_face_profile_preference_title" msgid="3906383224724942953">"Shkyç me fytyrë për profilin e punës"</string>
    <string name="security_settings_face_enroll_education_title" msgid="6027417312490791135">"Si të konfigurosh \"Shkyçjen me fytyrë\""</string>
    <string name="security_settings_face_enroll_education_title_accessibility" msgid="4233918594329755623">"Konfiguro shkyçjen me fytyrë"</string>
    <string name="security_settings_face_enroll_education_title_unlock_disabled" msgid="4697363240703556987">"Përdor fytyrën për të vërtetuar"</string>
    <string name="security_settings_face_enroll_education_message" msgid="4401918487764636333"></string>
    <string name="security_settings_face_enroll_education_start" msgid="6186306855277346454">"Nis"</string>
    <string name="security_settings_face_enroll_introduction_accessibility" msgid="7784083491315229721">"Përdor konfigurimin e qasshmërisë"</string>
    <string name="security_settings_face_enroll_introduction_accessibility_expanded" msgid="5924018301323255439"></string>
    <string name="security_settings_face_enroll_introduction_accessibility_diversity" msgid="4455532390587307262"></string>
    <string name="security_settings_face_enroll_introduction_accessibility_vision" msgid="7075186169796301461"></string>
    <string name="security_settings_face_enroll_introduction_cancel" msgid="4277182322482408514">"Anulo"</string>
    <string name="security_settings_face_enroll_introduction_no_thanks" msgid="8771760983171429187">"Jo, faleminderit"</string>
    <string name="security_settings_face_enroll_introduction_agree" msgid="6370134135096047691">"Pranoj"</string>
    <string name="security_settings_face_enroll_introduction_title" msgid="2694505011712885439">"Shkyç me fytyrë"</string>
    <string name="security_settings_face_enroll_introduction_title_unlock_disabled" msgid="8180330567034286589">"Përdor fytyrën për të vërtetuar"</string>
    <string name="security_settings_face_enroll_introduction_message" msgid="6150611993438981458">"Përdor fytyrën për të shkyçur telefonin, për të autorizuar blerjet ose për t\'u identifikuar në aplikacione"</string>
    <string name="security_settings_face_enroll_introduction_message_unlock_disabled" msgid="6393270235632444857">"Përdor fytyrën për të shkyçur telefonin ose për të miratuar blerjet.\n\nShënim. Nuk mund ta përdorësh fytyrën tënde për të shkyçur këtë pajisje. Për më shumë informacione, kontakto me administratorin e organizatës sate."</string>
    <string name="security_settings_face_enroll_introduction_message_setup" msgid="5704661081718707858">"Përdor fytyrën për të shkyçur telefonin, për të autorizuar blerjet ose për t\'u identifikuar në aplikacione"</string>
    <string name="security_settings_face_enroll_introduction_footer_part_0" msgid="3316520154949466889"></string>
    <string name="security_settings_face_enroll_introduction_footer_part_1" msgid="5594630288374571903"></string>
    <string name="security_settings_face_enroll_introduction_footer_part_2" msgid="7576241712527601978"></string>
    <string name="security_settings_face_enroll_introduction_footer_part_3" msgid="7355240941877607603"></string>
    <string name="security_settings_face_enroll_repeat_title" msgid="4019853239039918762">"Mbaje fytyrën në mes të rrethit"</string>
    <string name="security_settings_face_enroll_enrolling_skip" msgid="5808832403353263368">"Kapërce"</string>
    <string name="face_add_max" msgid="4408683751143942949">"Mund të shtosh deri në <xliff:g id="COUNT">%d</xliff:g> fytyra"</string>
    <string name="face_intro_error_max" msgid="160022811747660581">"Ke shtuar numrin maksimal të fytyrave"</string>
    <string name="face_intro_error_unknown" msgid="6367721696446677261">"Nuk mund të shtohen më shumë fytyra"</string>
    <string name="security_settings_face_enroll_error_dialog_title" msgid="2869110702072655323">"Regjistrimi nuk përfundoi"</string>
    <string name="security_settings_face_enroll_dialog_ok" msgid="2980238861223265089">"OK"</string>
    <string name="security_settings_face_enroll_error_timeout_dialog_message" msgid="1701191960569185087">"U arrit kufiri kohor për regjistrimin e fytyrës. Provo përsëri."</string>
    <string name="security_settings_face_enroll_error_generic_dialog_message" msgid="3825066262969499407">"Regjistrimi i fytyrës nuk funksionoi"</string>
    <string name="security_settings_face_enroll_finish_title" msgid="8268014305067971249">"Gjithçka gati. Duket mirë."</string>
    <string name="security_settings_face_enroll_done" msgid="6670735678797960484">"U krye"</string>
    <string name="security_settings_face_settings_use_face_category" msgid="4087133372842623883">"Përdor shkyçjen me fytyrën për"</string>
    <string name="security_settings_face_settings_use_face_unlock_phone" msgid="8780794239930621913">"Shkyçja e telefonit"</string>
    <string name="security_settings_face_settings_use_face_for_apps" msgid="5751549943998662469">"Identifikimi dhe pagesat e aplikacionit"</string>
    <string name="security_settings_face_settings_require_category" msgid="2523822050054597822">"Kërkesat për shkyçjen me fytyrë"</string>
    <string name="security_settings_face_settings_require_attention" msgid="8523824066748480516">"Kërkon që sytë të jenë të hapur"</string>
    <string name="security_settings_face_settings_require_attention_details" msgid="6595676992796133643">"Për ta shkyçur telefonin, sytë e tu duhet të jenë të hapur"</string>
    <string name="security_settings_face_settings_require_confirmation" msgid="2559602923985027572">"Kërko gjithmonë konfirmimin"</string>
    <string name="security_settings_face_settings_require_confirmation_details" msgid="6466094680756211420">"Kërko gjithmonë hapin e konfirmimit kur përdor shkyçjen me fytyrë në aplikacione"</string>
    <string name="security_settings_face_settings_remove_face_data" msgid="304401377141467791">"Fshi të dhënat e fytyrës"</string>
    <string name="security_settings_face_settings_enroll" msgid="495403103503629382">"Konfiguro shkyçjen me fytyrë"</string>
    <string name="security_settings_face_settings_footer" msgid="1233594882557106034">"Përdor \"Shkyçjen me fytyrën\" për të shkyçur pajisjen, për t\'u identifikuar tek aplikacionet dhe për të konfirmuar pagesat.\n\nKi parasysh:\nShikimi te telefoni mund ta shkyçë atë kur nuk planifikon këtë.\n\nTelefoni yt mund të shkyçet nga dikush tjetër nëse ai mbahet te fytyra jote, edhe nëse sytë i ke të mbyllur.\n\nTelefoni yt mund të shkyçet nga dikush që ngjan shumë me ty, p.sh. nga një binjak."</string>
    <string name="security_settings_face_settings_remove_dialog_title" msgid="4829278778459836075">"Do t\'i fshish të dhënat e fytyrës?"</string>
    <string name="security_settings_face_settings_remove_dialog_details" msgid="4820545735354901641">"Imazhet dhe modeli i fytyrës të përdorura nga shkyçja me fytyrë do të fshihen përgjithmonë dhe në mënyrë të sigurt. Pas heqjes, do të të duhet kodi PIN, motivi ose fjalëkalimi për ta shkyçur telefonin, për t\'u identifikuar në aplikacione dhe për të konfirmuar pagesat."</string>
    <string name="security_settings_face_settings_context_subtitle" msgid="4381276009777294566">"Përdor shkyçjen me fytyrë për të shkyçur telefonin tënd"</string>
    <string name="security_settings_fingerprint_preference_title" msgid="2488725232406204350">"Gjurma e gishtit"</string>
    <string name="fingerprint_manage_category_title" msgid="8293801041700001681">"Menaxho gjurm. gishtit"</string>
    <string name="fingerprint_usage_category_title" msgid="8438526918999536619">"Përdor gjurmën për"</string>
    <string name="fingerprint_add_title" msgid="1926752654454033904">"Shto gjurmë gishti"</string>
    <string name="fingerprint_enable_keyguard_toggle_title" msgid="5078060939636911795">"kyçja e ekranit"</string>
    <plurals name="security_settings_fingerprint_preference_summary" formatted="false" msgid="624961700033979880">
      <item quantity="other"><xliff:g id="COUNT_1">%1$d</xliff:g> gjurmë gishti u konfiguruan</item>
      <item quantity="one"><xliff:g id="COUNT_0">%1$d</xliff:g> gjurmë gishti u konfigurua</item>
    </plurals>
    <string name="security_settings_fingerprint_preference_summary_none" msgid="1507739327565151923"></string>
    <string name="security_settings_fingerprint_enroll_introduction_title" msgid="3201556857492526098">"Shkyçe me gjurmën e gishtit"</string>
    <string name="security_settings_fingerprint_enroll_introduction_title_unlock_disabled" msgid="7066417934622827305">"Përdor gjurmën e gishtit"</string>
    <string name="security_settings_fingerprint_enroll_introduction_message" msgid="3508870672887336095">"Thjesht prek te sensori i gjurmës së gishtit për të shkyçur telefonin, për të autorizuar blerjet ose për t\'u identifikuar tek aplikacionet. Trego kujdes se gjurmët e kujt shton. Çdo gjurmë gishti e shtuar do të mund t\'i kryejë këto gjëra. \n\nShënim: Gjurma jote e gishtit mund të jetë më pak e sigurt se një motiv ose një kod PIN i fortë."</string>
    <string name="security_settings_fingerprint_enroll_introduction_message_unlock_disabled" msgid="1550756694054944874">"Përdor gjurmën e gishtit për të shkyçur telefonin ose për të miratuar blerjet.\n\nShënim. Nuk mund ta përdorësh gjurmën tënde të gishtit për të shkyçur këtë pajisje. Për më shumë informacione, kontakto me administratorin e organizatës tënde."</string>
    <string name="security_settings_fingerprint_enroll_introduction_message_setup" msgid="6817326798834882531">"Përdor gjurmën e gishtit për të shkyçur telefonin ose për të miratuar blerjet.\n\nShënim. Gjurma e gishtit mund të jetë më pak e sigurt se sa një kod PIN ose motiv i fortë."</string>
    <string name="security_settings_fingerprint_enroll_introduction_cancel" msgid="3199351118385606526">"Anulo"</string>
    <string name="security_settings_fingerprint_enroll_introduction_continue" msgid="7472492858148162530">"Vazhdo"</string>
    <string name="security_settings_fingerprint_enroll_introduction_cancel_setup" msgid="5021369420474432665">"Kapërce"</string>
    <string name="security_settings_fingerprint_enroll_introduction_continue_setup" msgid="1961957425135180242">"Përpara"</string>
    <string name="setup_fingerprint_enroll_skip_title" msgid="362050541117362034">"Të kapërcehet gjurma e gishtit?"</string>
    <string name="setup_fingerprint_enroll_skip_after_adding_lock_text" msgid="958990414356204763">"Konfigurimi i gjurmëve të gishtave zgjat vetëm një ose dy minuta. Nëse e kapërcen këtë, mund të shtosh gjurmën tënde të gishtit më vonë te cilësimet."</string>
    <string name="lock_screen_intro_skip_title" msgid="4988210105913705679">"Të kapërcehet kyçja e ekranit?"</string>
    <string name="lock_screen_intro_skip_dialog_text_frp" product="tablet" msgid="1581834104051243425">"Funksionet e mbrojtjes së pajisjes nuk do të aktivizohen. Ti nuk do mund të parandalosh që të tjerët të mos e përdorin këtë tablet nëse ai humb, vidhet ose rivendoset."</string>
    <string name="lock_screen_intro_skip_dialog_text_frp" product="device" msgid="4629503416877189572">"Funksionet e mbrojtjes së pajisjes nuk do të aktivizohen. Ti nuk do mund të parandalosh që të tjerët të mos e përdorin këtë pajisje nëse ajo humb, vidhet ose rivendoset."</string>
    <string name="lock_screen_intro_skip_dialog_text_frp" product="default" msgid="2423428240245737909">"Funksionet e mbrojtjes së pajisjes nuk do të aktivizohen. Ti nuk do mund të parandalosh që të tjerët të mos e përdorin këtë telefon nëse ai humb, vidhet ose rivendoset."</string>
    <string name="lock_screen_intro_skip_dialog_text" product="tablet" msgid="5219287483885558525">"Funksionet e mbrojtjes së pajisjes nuk do të aktivizohen. Ti nuk do mund të parandalosh që të tjerët të mos e përdorin këtë tablet nëse ai humb ose vidhet."</string>
    <string name="lock_screen_intro_skip_dialog_text" product="device" msgid="1466238255429527112">"Funksionet e mbrojtjes së pajisjes nuk do të aktivizohen. Ti nuk do mund të parandalosh që të tjerët të mos e përdorin këtë pajisje nëse ajo humb ose vidhet."</string>
    <string name="lock_screen_intro_skip_dialog_text" product="default" msgid="3008526710555416125">"Funksionet e mbrojtjes së pajisjes nuk do të aktivizohen. Ti nuk do mund të parandalosh që të tjerët të mos e përdorin këtë telefon nëse ai humb ose vidhet."</string>
    <string name="skip_anyway_button_label" msgid="2323522873558834513">"Kapërceje gjithsesi"</string>
    <string name="go_back_button_label" msgid="4745265266186209467">"Kthehu prapa"</string>
    <string name="skip_lock_screen_dialog_button_label" msgid="7478349557867790778">"Kapërce"</string>
    <string name="cancel_lock_screen_dialog_button_label" msgid="4525833484240246349">"Anulo"</string>
    <string name="security_settings_fingerprint_enroll_find_sensor_title" msgid="3051496861358227199">"Prek sensorin"</string>
    <string name="security_settings_fingerprint_enroll_find_sensor_message" msgid="8793966374365960368">"Ndodhet në pjesën e pasme të telefonit. Përdor gishtin tregues."</string>
    <string name="security_settings_fingerprint_enroll_find_sensor_content_description" msgid="2058830032070449160">"Ilustrim me pajisjen dhe vendndodhjen e sensorit të gjurmës së gjishtit"</string>
    <string name="security_settings_fingerprint_enroll_dialog_name_label" msgid="7086763077909041106">"Emri"</string>
    <string name="security_settings_fingerprint_enroll_dialog_ok" msgid="4150384963879569750">"Në rregull"</string>
    <string name="security_settings_fingerprint_enroll_dialog_delete" msgid="4114615413240707936">"Fshi"</string>
    <string name="security_settings_fingerprint_enroll_start_title" msgid="2068961812439460133">"Prek sensorin"</string>
    <string name="security_settings_fingerprint_enroll_start_message" msgid="3909929328942564524">"Vendose gishtin mbi sensor dhe ngrije pasi të ndjesh një dridhje"</string>
    <string name="security_settings_fingerprint_enroll_repeat_title" msgid="2819679722403209778">"Ngrije dhe më pas prek përsëri"</string>
    <string name="security_settings_fingerprint_enroll_repeat_message" msgid="6158989350522518586">"Vazhdo ta ngresh gishtin për të shtuar pjesë të ndryshme të gjurmës së gishtit"</string>
    <string name="security_settings_fingerprint_enroll_finish_title" msgid="7567276170287972230">"Gjurma e gishtit u shtua"</string>
    <string name="security_settings_fingerprint_enroll_finish_message" msgid="8970048776120548976">"Kur shikon këtë ikonë, përdor gjurmën e gishtit për identifikim ose për të miratuar blerjet"</string>
    <string name="security_settings_fingerprint_enroll_enrolling_skip" msgid="3710211704052369752">"Bëje më vonë"</string>
    <string name="setup_fingerprint_enroll_enrolling_skip_title" msgid="6808422329107426923">"Kapërce konfigurimin e gjurmës së gishtit?"</string>
    <string name="setup_fingerprint_enroll_enrolling_skip_message" msgid="274849306857859783">"Ke zgjedhur që të përdorësh gjurmën e gishtit si një mënyrë për ta shkyçur telefonin. Nëse e kapërcen teni, do të duhet ta konfigurosh këtë më vonë. Konfigurimi do të zgjasë vetëm afro një minutë."</string>
    <string name="fingerprint_lock_screen_setup_skip_dialog_text" product="tablet" msgid="7914950545902198894">"Mbroje tabletin tënd me një opsion për kyçjen e ekranit në mënyrë që askush të mos jetë në gjendje ta përdorë nëse të humb ose vidhet. Të duhet gjithashtu edhe një opsion për kyçjen e ekranit për të konfiguruar gjurmën e gishtit. Trokit tek \"Anulo\" dhe më pas vendos një kod PIN, një motiv ose fjalëkalim."</string>
    <string name="fingerprint_lock_screen_setup_skip_dialog_text" product="device" msgid="2300047476104528001">"Mbroje pajisjen tënde me një opsion për kyçjen e ekranit në mënyrë që askush të mos jetë në gjendje ta përdorë nëse të humb ose vidhet. Të duhet gjithashtu edhe një opsion për kyçjen e ekranit për të konfiguruar gjurmën e gishtit. Trokit tek \"Anulo\" dhe më pas vendos një kod PIN, një motiv ose fjalëkalim."</string>
    <string name="fingerprint_lock_screen_setup_skip_dialog_text" product="default" msgid="5823994499768751994">"Mbroje telefonin tënd me një opsion për kyçjen e ekranit në mënyrë që askush të mos jetë në gjendje ta përdorë nëse të humb ose vidhet. Të duhet gjithashtu edhe një opsion për kyçjen e ekranit për të konfiguruar gjurmën e gishtit. Trokit tek \"Anulo\" dhe më pas vendos një kod PIN, një motiv ose fjalëkalim."</string>
    <string name="face_lock_screen_setup_skip_dialog_text" product="tablet" msgid="2053646029913482047">"Duke mbrojtur tabletin tënd me një opsion për kyçjen e ekranit, askush nuk do të jetë në gjendje ta përdorë nëse të humb ose vidhet. Të duhet gjithashtu edhe një opsion për kyçjen e ekranit për të konfiguruar shkyçjen me fytyrë. Për t\'u kthyer, trokit tek \"Anulo\"."</string>
    <string name="face_lock_screen_setup_skip_dialog_text" product="device" msgid="8884769457436280503">"Duke mbrojtur pajisjen tënde me një opsion për kyçjen e ekranit, askush nuk do të jetë në gjendje ta përdorë nëse të humb ose vidhet. Të duhet gjithashtu edhe një opsion për kyçjen e ekranit për të konfiguruar shkyçjen me fytyrë. Për t\'u kthyer, trokit tek \"Anulo\"."</string>
    <string name="face_lock_screen_setup_skip_dialog_text" product="default" msgid="1752907123591111728">"Duke mbrojtur telefonin tënd me një opsion për kyçjen e ekranit, askush nuk do të jetë në gjendje ta përdorë nëse të humb ose vidhet. Të duhet gjithashtu edhe një opsion për kyçjen e ekranit për të konfiguruar shkyçjen me fytyrë. Për t\'u kthyer, trokit tek \"Anulo\"."</string>
    <string name="lock_screen_pin_skip_title" msgid="8064328201816780457">"Do ta kapërcesh konfigurimin e kodit PIN?"</string>
    <string name="lock_screen_password_skip_title" msgid="4155009417576409182">"Do ta kapërcesh konfigurimin e fjalëkalimit?"</string>
    <string name="lock_screen_pattern_skip_title" msgid="6467327818577283960">"Do ta kapërcesh konfigurimin e motivit?"</string>
    <string name="security_settings_fingerprint_enroll_setup_screen_lock" msgid="1195743489835505376">"Konfiguro kyçjen e ekranit"</string>
    <string name="security_settings_fingerprint_enroll_done" msgid="4014607378328187567">"U krye"</string>
    <string name="security_settings_fingerprint_enroll_touch_dialog_title" msgid="1863561601428695160">"Jo, sensori nuk është ai"</string>
    <string name="security_settings_fingerprint_enroll_touch_dialog_message" msgid="2989019978041986175">"Prek sensorin në pjesën e pasme të telefonit. Përdor gishtin tregues."</string>
    <string name="security_settings_fingerprint_enroll_error_dialog_title" msgid="3618021988442639280">"Regjistrimi nuk përfundoi"</string>
    <string name="security_settings_fingerprint_enroll_error_timeout_dialog_message" msgid="2942551158278899627">"U arrit kufiri kohor për regjistrimin e gjurmës së gishtit. Provo përsëri."</string>
    <string name="security_settings_fingerprint_enroll_error_generic_dialog_message" msgid="3624760637222239293">"Regjistrimi i gjurmës së gishtit nuk funksionoi. Provo përsëri ose përdor një gisht tjetër."</string>
    <string name="fingerprint_enroll_button_add" msgid="6317978977419045463">"Shto një tjetër"</string>
    <string name="fingerprint_enroll_button_next" msgid="6247009337616342759">"Përpara"</string>
    <string name="security_settings_fingerprint_enroll_disclaimer" msgid="2624905914239271751">"Përveç shkyçjes së telefonit, gjurmën e gishtit mund ta përdorësh edhe për të autorizuar blerjet dhe qasjen në aplikacione. "<annotation id="url">"Mëso më shumë"</annotation></string>
    <string name="security_settings_fingerprint_enroll_disclaimer_lockscreen_disabled" msgid="7846871823167357942">" Opsioni i kyçjes së ekranit është çaktivizuar. Kontakto me administratorin e organizatës tënde për të mësuar më shumë. "<annotation id="admin_details">"Më shumë detaje"</annotation>\n\n"Mund të vazhdosh të përdorësh gjurmën e gishtit për të autorizuar blerjet dhe për qasje në aplikacion. "<annotation id="url">"Mëso më shumë"</annotation></string>
    <string name="security_settings_fingerprint_enroll_lift_touch_again" msgid="1888772560642539718">"Ngrije gishtin dhe më pas preke përsëri sensorin"</string>
    <string name="fingerprint_add_max" msgid="1020927549936895822">"Mund të shtosh deri në <xliff:g id="COUNT">%d</xliff:g> gjurma të gishtave"</string>
    <string name="fingerprint_intro_error_max" msgid="6864066984678078441">"Ke shtuar numrin maksimal të gjurmëve të gishtave"</string>
    <string name="fingerprint_intro_error_unknown" msgid="1905692132326523040">"Nuk mund të shtohen gjurmë të tjera të gishtave"</string>
    <string name="fingerprint_last_delete_title" msgid="6410310101247028988">"Të hiqen të gjitha gjurmët e gishtave?"</string>
    <string name="fingerprint_delete_title" msgid="1368196182612202898">"Hiq \"<xliff:g id="FINGERPRINT_ID">%1$s</xliff:g>\""</string>
    <string name="fingerprint_delete_message" msgid="8597787803567398131">"Dëshiron ta fshish këtë gjurmë gishti?"</string>
    <string name="fingerprint_last_delete_message" msgid="7852321001254275878">"Nuk do të jesh në gjendje të përdorësh gjurmët e gishtave për të shkyçur telefonin, për të autorizuar blerjet ose për t\'u identifikuar në aplikacione me to"</string>
    <string name="fingerprint_last_delete_message_profile_challenge" msgid="6521520787746771912">"Nuk do të jesh në gjendje të përdorësh gjurmët e gishtave për të shkyçur profilin tënd të punës, për të autorizuar blerjet ose për t\'u identifikuar në aplikacionet e punës"</string>
    <string name="fingerprint_last_delete_confirm" msgid="2634726361059274289">"Po, hiqe"</string>
    <string name="crypt_keeper_settings_title" msgid="4219233835490520414">"Enkriptimi"</string>
    <string name="crypt_keeper_encrypt_title" product="tablet" msgid="1060273569887301457">"Enkripto tabletin"</string>
    <string name="crypt_keeper_encrypt_title" product="default" msgid="1878996487755806122">"Enkripto telefonin"</string>
    <string name="crypt_keeper_encrypted_summary" msgid="1868233637888132906">"I enkriptuar"</string>
    <string name="crypt_keeper_desc" product="tablet" msgid="503014594435731275">"Mund të enkriptosh llogaritë e tua, cilësimet, aplikacionet e shkarkuara dhe të dhënat e tyre, klipet \"media\" (muzikë e fotografi) si dhe skedarë të tjerë. Pasi të kesh enkriptuar tabletin, do të të nevojitet një kod PIN numerik apo fjalëkalim që të shkyçësh ekranin për ta deshifruar atë çdo herë që e ndez. E vetmja mënyrë tjetër për të deshifruar tabletin është rivendosja në gjendje fabrike, duke spastruar të gjitha të dhënat.\n\nEnkriptimi zgjat një orë ose më shumë. Kur të fillosh, sigurohu të kesh baterinë e karikuar dhe ta mbash tabletin në prizë gjatë gjithë procesit. Nëse e ndërpret, do të humbësh disa nga të dhënat ose të gjitha."</string>
    <string name="crypt_keeper_desc" product="default" msgid="2579929266645543631">"Mund të enkriptosh llogaritë e tua, cilësimet, aplikacionet e shkarkuara dhe të dhënat e tyre, klipet \"media\" (muzikë e fotografi) si dhe skedarë të tjerë. Pasi ta kesh enkriptuar telefonin, do të të nevojitet një kod PIN numerik apo fjalëkalim që të shkyçësh ekranin e për ta deshifruar atë çdo herë që e ndez. E vetmja mënyrë tjetër për të deshifruar telefonin është rivendosja në gjendje fabrike, duke spastruar të gjitha të dhënat.\n\nEnkriptimi zgjat një orë ose më shumë. Kur të fillosh, sigurohu të kesh baterinë e karikuar dhe ta mbash telefonin në prizë gjatë gjithë procesit. Nëse e ndërpret, do të humbësh disa nga të dhënat ose të gjitha."</string>
    <string name="crypt_keeper_button_text" product="tablet" msgid="1189623490604750854">"Enkripto tabletin"</string>
    <string name="crypt_keeper_button_text" product="default" msgid="2008346408473255519">"Enkripto telefonin"</string>
    <string name="crypt_keeper_low_charge_text" msgid="2029407131227814893">"Ngarko baterinë dhe provo përsëri."</string>
    <string name="crypt_keeper_unplugged_text" msgid="4785376766063053901">"Vëre karikuesin në prizë dhe provo përsëri."</string>
    <string name="crypt_keeper_dialog_need_password_title" msgid="4058971800557767">"Nuk ka një kod PIN ose fjalëkalim të ekranit të kyçjes"</string>
    <string name="crypt_keeper_dialog_need_password_message" msgid="4071395977297369642">"Duhet të caktosh një PIN të ekranit të kyçjes ose një fjalëkalim para se të mund të nisësh enkriptimin."</string>
    <string name="crypt_keeper_confirm_title" msgid="5100339496381875522">"Të enkriptohet?"</string>
    <string name="crypt_keeper_final_desc" product="tablet" msgid="517662068757620756">"Operacioni i enkriptimit është i pakthyeshëm dhe nëse e ndërpret, do të humbësh të dhënat. Enkriptimi zgjat një orë ose më shumë, kohë gjatë të cilës tableti do të riniset disa herë."</string>
    <string name="crypt_keeper_final_desc" product="default" msgid="287503113671320916">"Operacioni i enkriptimit është i pakthyeshëm dhe nëse e ndërpret, do të humbësh të dhënat. Enkriptimi zgjat një orë ose më shumë, kohë gjatë të cilës telefoni do të riniset disa herë."</string>
    <string name="crypt_keeper_setup_title" msgid="1783951453124244969">"Po enkripton"</string>
    <string name="crypt_keeper_setup_description" product="tablet" msgid="6689952371032099350">"Prit ndërsa tableti po enkriptohet. <xliff:g id="PERCENT">^1</xliff:g>% të përfunduara."</string>
    <string name="crypt_keeper_setup_description" product="default" msgid="951918761585534875">"Prit ndërsa telefoni po enkriptohet. <xliff:g id="PERCENT">^1</xliff:g>% e përfunduar."</string>
    <string name="crypt_keeper_setup_time_remaining" product="tablet" msgid="1655047311546745695">"Prit ndërsa tableti enkriptohet. Koha e mbetur: <xliff:g id="DURATION">^1</xliff:g>"</string>
    <string name="crypt_keeper_setup_time_remaining" product="default" msgid="1862964662304683072">"Prit ndërsa telefoni po enkriptohet. Koha e mbetur: <xliff:g id="DURATION">^1</xliff:g>"</string>
    <string name="crypt_keeper_force_power_cycle" product="tablet" msgid="556504311511212648">"Për të shkyçur tabletin, fike dhe pastaj ndize."</string>
    <string name="crypt_keeper_force_power_cycle" product="default" msgid="1794353635603020327">"Për të shkyçur telefonin, fike dhe më pas ndize."</string>
    <string name="crypt_keeper_warn_wipe" msgid="2738374897337991667">"Paralajmërim! Pajisja jote do të fshihet pas <xliff:g id="COUNT">^1</xliff:g> përpjekjeve të tjera të dështuara për shkyçje!"</string>
    <string name="crypt_keeper_enter_password" msgid="2223340178473871064">"Shkruaj fjalëkalimin tënd"</string>
    <string name="crypt_keeper_failed_title" msgid="7133499413023075961">"Enkriptimi ishte i pasuksesshëm"</string>
    <string name="crypt_keeper_failed_summary" product="tablet" msgid="8219375738445017266">"Enkriptimi u ndërpre dhe nuk mund të përfundojë. Si rezultat, nuk është më e mundur qasja te të dhënat në tablet. \n\nPër të rifilluar përdorimin e tabletit, duhet të kryesh një rivendosje në gjendje fabrike. Kur ta konfigurosh tabletin pas rivendosjes, do të kesh mundësinë për të restauruar çdo të dhënë që është rezervuar në llogarinë e Google."</string>
    <string name="crypt_keeper_failed_summary" product="default" msgid="3270131542549577953">"Enkriptimi u ndërpre dhe nuk mund të përfundojë. Si rezultat, nuk është më e mundur qasja te të dhënat në telefon. \n\nPër të rifilluar përdorimin e telefonit, duhet të kryesh një rivendosje në gjendje fabrike. Kur ta konfigurosh telefonin pas rivendosjes, do të kesh mundësinë për të restauruar çdo të dhënë që është rezervuar në llogarinë e Google."</string>
    <string name="crypt_keeper_data_corrupt_title" msgid="8759119849089795751">"Dekriptimi ishte i pasuksesshëm"</string>
    <string name="crypt_keeper_data_corrupt_summary" product="tablet" msgid="840107296925798402">"Fjalëkalimi që fute është i saktë, por fatkeqësisht të dhënat e tua janë të dëmtuara. \n\nPër të rifilluar përdorimin e tabletit, duhet të kryesh një vendosje në gjendje fabrike. Pas kësaj, do të kesh mundësinë për të restauruar çdo të dhënë që është rezervuar në llogarinë e Google."</string>
    <string name="crypt_keeper_data_corrupt_summary" product="default" msgid="8843311420059663824">"Fjalëkalimi që fute është i saktë, por fatkeqësisht të dhënat e tua janë të dëmtuara. \n\nPër të rifilluar përdorimin e telefonit, duhet të kryesh një vendosje në gjendje fabrike. Pas kësaj, do të kesh mundësinë për të restauruar çdo të dhënë që është rezervuar në llogarinë e Google."</string>
    <string name="crypt_keeper_switch_input_method" msgid="4168332125223483198">"Ndërro metodën e hyrjes"</string>
    <string name="suggested_lock_settings_title" msgid="8498743819223200961">"Siguro telefonin tënd"</string>
    <string name="suggested_lock_settings_summary" product="tablet" msgid="2296800316150748710">"Cakto kyçjen e ekranit për të mbrojtur tabletin"</string>
    <string name="suggested_lock_settings_summary" product="device" msgid="7562847814806365373">"Cakto kyçjen e ekranit për të mbrojtur pajisjen"</string>
    <string name="suggested_lock_settings_summary" product="default" msgid="1526355348444658181">"Cakto kyçjen e ekranit për të mbrojtur telefonin"</string>
    <string name="suggested_fingerprint_lock_settings_title" msgid="2174553391551398081">"Shto gjurmën e gishtit për ta shkyçur"</string>
    <string name="suggested_fingerprint_lock_settings_summary" product="tablet" msgid="5738274583658668124"></string>
    <string name="suggested_fingerprint_lock_settings_summary" product="device" msgid="5738274583658668124"></string>
    <string name="suggested_fingerprint_lock_settings_summary" product="default" msgid="5738274583658668124"></string>
    <string name="lock_settings_picker_title" msgid="1095755849152582712">"Zgjidh kyçjen e ekranit"</string>
    <string name="lock_settings_picker_title_profile" msgid="8822511284992306796">"Zgjidh kyçjen e punës"</string>
    <string name="setup_lock_settings_picker_title" product="tablet" msgid="90329443364067215">"Mbroje tabletin tënd"</string>
    <string name="setup_lock_settings_picker_title" product="device" msgid="2399952075134938929">"Mbroje pajisjen tënde"</string>
    <string name="setup_lock_settings_picker_title" product="default" msgid="1572244299605153324">"Mbroje telefonin tënd"</string>
    <string name="lock_settings_picker_biometrics_added_security_message" msgid="1507307757032207572">"Për më shumë siguri, cakto një kyçje rezervë për ekranin"</string>
    <string name="setup_lock_settings_picker_message" product="tablet" msgid="8919671129189936210">"Parandalo që të tjerët ta përdorin këtë tablet pa lejen tënde duke aktivizuar funksionet e mbrojtjes së pajisjes. Zgjidh kyçjen e ekranit që dëshiron të përdorësh."</string>
    <string name="setup_lock_settings_picker_message" product="device" msgid="3787276514406353777">"Parandalo që të tjerët ta përdorin këtë pajisje pa lejen tënde duke aktivizuar funksionet e mbrojtjes së pajisjes. Zgjidh kyçjen e ekranit që dëshiron të përdorësh."</string>
    <string name="setup_lock_settings_picker_message" product="default" msgid="3692856437543730446">"Parandalo që të tjerët ta përdorin këtë telefon pa lejen tënde duke aktivizuar funksionet e mbrojtjes së pajisjes. Zgjidh kyçjen e ekranit që dëshiron të përdorësh."</string>
    <string name="lock_settings_picker_fingerprint_message" msgid="4755230324778371292">"Zgjidh mënyrën rezervë të kyçjes së ekranit"</string>
    <string name="lock_settings_picker_face_message" msgid="197106534637556054">"Zgjidh mënyrën rezervë të kyçjes së ekranit"</string>
    <string name="setup_lock_settings_options_button_label" msgid="8511153243629402929">"Opsionet e kyçjes së ekranit"</string>
    <string name="setup_lock_settings_options_dialog_title" msgid="5058207955455973917">"Opsionet e kyçjes së ekranit"</string>
    <string name="unlock_set_unlock_launch_picker_title" msgid="2084576942666016993">"Kyçja e ekranit"</string>
    <string name="unlock_set_unlock_launch_picker_summary_lock_immediately" msgid="5967714169972542586">"<xliff:g id="UNLOCK_METHOD">%1$s</xliff:g> / menjëherë pas gjumit"</string>
    <string name="unlock_set_unlock_launch_picker_summary_lock_after_timeout" msgid="4696710373399258413">"<xliff:g id="UNLOCK_METHOD">%1$s</xliff:g> / <xliff:g id="TIMEOUT_STRING">%2$s</xliff:g> pas gjumit"</string>
    <string name="unlock_set_unlock_launch_picker_title_profile" msgid="124176557311393483">"Kyçja e profilit të punës"</string>
    <string name="unlock_set_unlock_launch_picker_change_title" msgid="5045866882028324941">"Ndrysho ekranin e kyçjes"</string>
    <string name="unlock_set_unlock_launch_picker_change_summary" msgid="2790960639554590668">"Ndrysho ose çaktivizo sigurinë e motivit, kodit PIN ose fjalëkalimit"</string>
    <string name="unlock_set_unlock_launch_picker_enable_summary" msgid="4791110798817242301">"Zgjidh një metodë për të kyçur ekranin"</string>
    <string name="unlock_set_unlock_off_title" msgid="7117155352183088342">"Asnjë"</string>
    <string name="unlock_set_unlock_off_summary" msgid="94361581669110415"></string>
    <string name="unlock_set_unlock_none_title" msgid="5679243878975864640">"Me rrëshqitje"</string>
    <string name="unlock_set_unlock_none_summary" msgid="8914673583104628191">"Pa siguri"</string>
    <string name="unlock_set_unlock_pattern_title" msgid="2912067603917311700">"Me motiv"</string>
    <string name="unlock_set_unlock_pattern_summary" msgid="7062696666227725593">"Siguria mesatare"</string>
    <string name="unlock_set_unlock_pin_title" msgid="5846029709462329515">"Me kod PIN"</string>
    <string name="unlock_set_unlock_pin_summary" msgid="907878650556383388">"Siguri mesatare deri në të lartë"</string>
    <string name="unlock_set_unlock_password_title" msgid="8775603825675090937">"Me fjalëkalim"</string>
    <string name="unlock_set_unlock_password_summary" msgid="8856220848940929546">"Siguri e lartë"</string>
    <string name="unlock_set_do_later_title" msgid="4894767558414979243">"Jo tani"</string>
    <string name="current_screen_lock" msgid="4104091715420072219">"Kyçja aktuale e ekranit"</string>
    <string name="fingerprint_unlock_set_unlock_pattern" msgid="4939057588092120368">"Gjurma e gishtit + Motivi"</string>
    <string name="fingerprint_unlock_set_unlock_pin" msgid="8010746824051056986">"Gjurma e gishtit + Kodi PIN"</string>
    <string name="fingerprint_unlock_set_unlock_password" msgid="7351131075806338634">"Gjurma e gishtit + Fjalëkalimi"</string>
    <string name="fingerprint_unlock_skip_fingerprint" msgid="1441077909803666681">"Vazhdo pa gjurmën e gishtit"</string>
    <string name="fingerprint_unlock_title" msgid="2826226740306003991">"Mund ta shkyçësh telefonin duke përdorur gjurmën e gishtit. Për siguri, ky opsion kërkon një kyçje rezervë të ekranit."</string>
    <string name="face_unlock_set_unlock_pattern" msgid="4077659104229192018">"Shkyçje me fytyrë + Motivi"</string>
    <string name="face_unlock_set_unlock_pin" msgid="1359249613033276716">"Shkyçja me fytyrë + Kodi PIN"</string>
    <string name="face_unlock_set_unlock_password" msgid="7135335310498158870">"Shkyçja me fytyrë + Fjalëkalimi"</string>
    <string name="face_unlock_skip_face" msgid="3481956557015165094">"Vazhdo pa shkyçjen me fytyrë"</string>
    <string name="face_unlock_title" msgid="9042382084472444316">"Mund ta shkyçësh telefonin duke përdorur fytyrën. Për siguri, ky opsion kërkon një kyçje rezervë të ekranit."</string>
    <string name="unlock_set_unlock_disabled_summary" msgid="2051593894736282302">"Çaktivizuar nga administratori, politika e enkriptimit ose hapësira ruajtëse e kredencialeve"</string>
    <string name="unlock_set_unlock_mode_off" msgid="5881952274566013651">"Asnjë"</string>
    <string name="unlock_set_unlock_mode_none" msgid="8467360084676871617">"Me rrëshqitje"</string>
    <string name="unlock_set_unlock_mode_pattern" msgid="7837270780919299289">"Motivi"</string>
    <string name="unlock_set_unlock_mode_pin" msgid="3541326261341386690">"Kodi PIN"</string>
    <string name="unlock_set_unlock_mode_password" msgid="1203938057264146610">"Fjalëkalimi"</string>
    <string name="unlock_setup_wizard_fingerprint_details" msgid="7893457665921363009">"Pasi të kesh konfiguruar një kyçje të ekranit, mund të konfigurosh po ashtu gjurmën e gishtit te Cilësimet &gt; Siguria."</string>
    <string name="unlock_disable_lock_title" msgid="1427036227416979120">"Çakt. kyçjen e ekranit"</string>
    <string name="unlock_disable_frp_warning_title" msgid="264008934468492550">"Të hiqet mbrojtja e pajisjes?"</string>
    <string name="unlock_disable_frp_warning_title_profile" msgid="5507136301904313583">"Të hiqet mbrojtja e profilit?"</string>
    <string name="unlock_disable_frp_warning_content_pattern" msgid="8869767290771023461">"Funksionet e mbrojtjes së pajisjes nuk do të funksionojnë pa motivin tënd."</string>
    <string name="unlock_disable_frp_warning_content_pattern_fingerprint" msgid="2986105377420905314">"Funksionet e mbrojtjes së pajisjes nuk do të funksionojnë pa motivin tënd.<xliff:g id="EMPTY_LINE">

</xliff:g>Gjurmët e gishtave të ruajtura do të hiqen nga kjo pajisje dhe nuk do të jesh në gjendje të shkyçësh telefonin, të autorizosh blerjet apo të identifikohesh në aplikacione me to."</string>
    <string name="unlock_disable_frp_warning_content_pin" msgid="586996206210265131">"Funksionet e mbrojtjes së pajisjes nuk do të funksionojnë pa kodin tënd PIN."</string>
    <string name="unlock_disable_frp_warning_content_pin_fingerprint" msgid="3370462835533123695">"Funksionet e mbrojtjes së pajisjes nuk do të funksionojnë pa kodin tënd PIN.<xliff:g id="EMPTY_LINE">

</xliff:g>Gjurmët e gishtave të ruajtura do të hiqen nga kjo pajisje dhe nuk do të jesh në gjendje të shkyçësh telefonin, të autorizosh blerjet apo të identifikohesh në aplikacione me to."</string>
    <string name="unlock_disable_frp_warning_content_password" msgid="5420612686852555537">"Funksionet e mbrojtjes së pajisjes nuk do të funksionojnë pa fjalëkalimin tënd."</string>
    <string name="unlock_disable_frp_warning_content_password_fingerprint" msgid="3595476296430536798">"Funksionet e mbrojtjes së pajisjes nuk do të funksionojnë pa fjalëkalimin tënd.<xliff:g id="EMPTY_LINE">

</xliff:g>Gjurmët e gishtave të ruajtura do të hiqen nga kjo pajisje dhe nuk do të jesh në gjendje të shkyçësh telefonin, të autorizosh blerjet apo të identifikohesh në aplikacione me to."</string>
    <string name="unlock_disable_frp_warning_content_unknown" msgid="1550718040483548220">"Funksionet e mbrojtjes së pajisjes nuk do të funksionojnë pa kyçjen tënde të ekranit."</string>
    <string name="unlock_disable_frp_warning_content_unknown_fingerprint" msgid="3679351662094349506">"Funksionet e mbrojtjes së pajisjes nuk do të funksionojnë pa kyçjen tënde të ekranit.<xliff:g id="EMPTY_LINE">

</xliff:g>Gjurmët e gishtave të ruajtura do të hiqen nga kjo pajisje dhe nuk do të jesh në gjendje të shkyçësh telefonin, të autorizosh blerjet apo të identifikohesh në aplikacione me to."</string>
    <string name="unlock_disable_frp_warning_content_pattern_profile" msgid="8682200103576359918">"Funksionet e mbrojtjes së profilit nuk do të funksionojnë pa motivin tënd."</string>
    <string name="unlock_disable_frp_warning_content_pattern_fingerprint_profile" msgid="6718155854303231675">"Funksionet e mbrojtjes së pajisjes nuk do të funksionojnë pa motivin tënd.<xliff:g id="EMPTY_LINE">

</xliff:g>Gjurmët e gishtave të ruajtura do të hiqen nga ky profil dhe nuk do të jesh në gjendje të shkyçësh telefonin, të autorizosh blerjet apo të identifikohesh në aplikacione me to."</string>
    <string name="unlock_disable_frp_warning_content_pin_profile" msgid="7790688070593867767">"Funksionet e mbrojtjes së profilit nuk do të funksionojnë pa kodin tënd PIN."</string>
    <string name="unlock_disable_frp_warning_content_pin_fingerprint_profile" msgid="4209564603132870532">"Funksionet e mbrojtjes së profilit nuk do të funksionojnë pa kodin tënd PIN.<xliff:g id="EMPTY_LINE">

</xliff:g>Gjurmët e gishtave të ruajtura do të hiqen nga ky profil dhe nuk do të jesh në gjendje të shkyçësh telefonin, të autorizosh blerjet apo të identifikohesh në aplikacione me to."</string>
    <string name="unlock_disable_frp_warning_content_password_profile" msgid="7569285520567674461">"Funksionet e mbrojtjes së profilit nuk do të funksionojnë pa fjalëkalimin tënd."</string>
    <string name="unlock_disable_frp_warning_content_password_fingerprint_profile" msgid="2994300676764706047">"Funksionet e mbrojtjes së profilit nuk do të funksionojnë pa fjalëkalimin tënd.<xliff:g id="EMPTY_LINE">

</xliff:g>Gjurmët e gishtave të ruajtura do të hiqen nga ky profil dhe nuk do të jesh në gjendje të shkyçësh telefonin, të autorizosh blerjet apo të identifikohesh në aplikacione me to."</string>
    <string name="unlock_disable_frp_warning_content_unknown_profile" msgid="6984215718701688202">"Funksionet e mbrojtjes së profilit nuk do të funksionojnë pa kyçjen tënde të ekranit."</string>
    <string name="unlock_disable_frp_warning_content_unknown_fingerprint_profile" msgid="4994062501123299418">"Funksionet e mbrojtjes së profilit nuk do të funksionojnë pa ekranin tënd të kyçjes.<xliff:g id="EMPTY_LINE">

</xliff:g>Gjurmët e gishtave të ruajtura do të hiqen nga ky profil dhe nuk do të jesh në gjendje të shkyçësh telefonin, të autorizosh blerjet apo të identifikohesh në aplikacione me to."</string>
    <string name="unlock_disable_frp_warning_ok" msgid="7075138677177748705">"Po, hiqe"</string>
    <string name="unlock_change_lock_pattern_title" msgid="2044092014872741130">"Ndrysho motivin e shkyçjes"</string>
    <string name="unlock_change_lock_pin_title" msgid="806629901095938484">"Ndrysho kodin PIN"</string>
    <string name="unlock_change_lock_password_title" msgid="5606298470358768865">"Ndrysho fjalk. shkyçjes"</string>
    <string name="unlock_footer_high_complexity_requested" msgid="7529087063617325912">"<xliff:g id="APP_NAME">%1$s</xliff:g> rekomandon një kod PIN ose fjalëkalim të fortë dhe nuk do të funksionojë siç pritet pa një të tillë"</string>
    <string name="unlock_footer_medium_complexity_requested" msgid="4195620619469851350">"<xliff:g id="APP_NAME">%1$s</xliff:g> rekomandon një kod PIN ose fjalëkalim të ri dhe nuk do të funksionojë siç pritet pa një të tillë"</string>
    <string name="unlock_footer_low_complexity_requested" msgid="428655972363263817">"<xliff:g id="APP_NAME">%1$s</xliff:g> rekomandon një motiv, kod PIN ose fjalëkalim të ri dhe nuk do të funksionojë siç pritet pa një të tillë"</string>
    <string name="unlock_footer_none_complexity_requested" msgid="6275441987228550440">"<xliff:g id="APP_NAME">%1$s</xliff:g> rekomandon një kyçje të re ekrani"</string>
    <string name="lock_failed_attempts_before_wipe" msgid="2219711062197089783">"Provo sërish. Tentativa <xliff:g id="CURRENT_ATTEMPTS">%1$d</xliff:g> nga <xliff:g id="TOTAL_ATTEMPTS">%2$d</xliff:g>."</string>
    <string name="lock_last_attempt_before_wipe_warning_title" msgid="4277765862798876826">"Të dhënat e tua do të fshihen"</string>
    <string name="lock_last_pattern_attempt_before_wipe_device" msgid="1688030823464420974">"Nëse fut një motiv të pasaktë në tentativën tjetër, të dhënat e kësaj pajisjeje do të fshihen"</string>
    <string name="lock_last_pin_attempt_before_wipe_device" msgid="5350785938296254352">"Nëse fut një kod PIN të pasaktë në tentativën tjetër, të dhënat e kësaj pajisjeje do të fshihen"</string>
    <string name="lock_last_password_attempt_before_wipe_device" msgid="6208035114731421034">"Nëse fut një fjalëkalim të pasaktë në tentativën tjetër, të dhënat e kësaj pajisjeje do të fshihen"</string>
    <string name="lock_last_pattern_attempt_before_wipe_user" msgid="7851504071368235547">"Nëse fut një motiv të pasaktë në tentativën tjetër, ky përdorues do të fshihet"</string>
    <string name="lock_last_pin_attempt_before_wipe_user" msgid="4049024921333961715">"Nëse fut një kod PIN të pasaktë në tentativën tjetër, ky përdorues do të fshihet"</string>
    <string name="lock_last_password_attempt_before_wipe_user" msgid="4660886542496781672">"Nëse fut një fjalëkalim të pasaktë në tentativën tjetër, ky përdorues do të fshihet"</string>
    <string name="lock_last_pattern_attempt_before_wipe_profile" msgid="2437716252059050291">"Nëse fut një motiv të pasaktë në tentativën tjetër, profili yt i punës dhe të dhënat e tij do të fshihen"</string>
    <string name="lock_last_pin_attempt_before_wipe_profile" msgid="5799931839127476913">"Nëse fut një kod PIN të pasaktë në tentativën tjetër, profili yt i punës dhe të dhënat e tij do të fshihen"</string>
    <string name="lock_last_password_attempt_before_wipe_profile" msgid="6786586046975042158">"Nëse fut një fjalëkalim të pasaktë në tentativën tjetër, profili yt i punës dhe të dhënat e tij do të fshihen"</string>
    <string name="lock_failed_attempts_now_wiping_device" msgid="5047439819181833824">"Shumë tentativa të pasakta. Të dhënat e kësaj pajisjeje do të fshihen."</string>
    <string name="lock_failed_attempts_now_wiping_user" msgid="6188180643494518001">"Shumë tentativa të pasakta. Ky përdorues do të fshihet."</string>
    <string name="lock_failed_attempts_now_wiping_profile" msgid="1745475043685915442">"Shumë tentativa të pasakta. Ky profil pune dhe të dhënat e tij do të fshihen."</string>
    <string name="lock_failed_attempts_now_wiping_dialog_dismiss" msgid="8246716090548717312">"Hiqe"</string>
    <plurals name="lockpassword_password_too_short" formatted="false" msgid="1957883871187697796">
      <item quantity="other">Duhet të përmbajë të paktën <xliff:g id="COUNT_1">%d</xliff:g> karaktere</item>
      <item quantity="one">Duhet të përmbajë të paktën <xliff:g id="COUNT_0">%d</xliff:g> karakter</item>
    </plurals>
    <plurals name="lockpassword_pin_too_short" formatted="false" msgid="5019935246875659237">
      <item quantity="other">Kodi PIN duhet të përmbajë të paktën <xliff:g id="COUNT_1">%d</xliff:g> shifra</item>
      <item quantity="one">Kodi PIN duhet të përmbajë të paktën <xliff:g id="COUNT_0">%d</xliff:g> shifër</item>
    </plurals>
    <string name="lockpassword_continue_label" msgid="4602203784934526940">"Vazhdo"</string>
    <plurals name="lockpassword_password_too_long" formatted="false" msgid="4581209996591221075">
      <item quantity="other">Duhet të ketë më pak se <xliff:g id="NUMBER_1">%d</xliff:g> karaktere</item>
      <item quantity="one">Duhet të ketë më pak se <xliff:g id="NUMBER_0">%d</xliff:g> karakter</item>
    </plurals>
    <plurals name="lockpassword_pin_too_long" formatted="false" msgid="185568652740755131">
      <item quantity="other">Duhet të ketë më pak se <xliff:g id="NUMBER_1">%d</xliff:g> shifra</item>
      <item quantity="one">Duhet të ketë më pak se <xliff:g id="NUMBER_0">%d</xliff:g> shifër</item>
    </plurals>
    <string name="lockpassword_pin_contains_non_digits" msgid="7284664023164191198">"Duhet të përmbajë vetëm shifrat 0-9"</string>
    <string name="lockpassword_pin_recently_used" msgid="1401569207976460727">"Administratori i pajisjes nuk e lejon përdorimin e një kodi PIN të përdorur së fundi"</string>
    <string name="lockpassword_pin_blacklisted_by_admin" msgid="8563366383328811472">"Kodet e zakonshme PIN janë bllokuar nga administratori i TI-së. Provo një kod tjetër PIN."</string>
    <string name="lockpassword_illegal_character" msgid="8049611046639943217">"Kjo nuk mund të përfshijë një karakter të pavlefshëm"</string>
    <string name="lockpassword_password_requires_alpha" msgid="3036589522150097731">"Duhet të përmbajë të paktën një germë"</string>
    <string name="lockpassword_password_requires_digit" msgid="5140062925787058765">"Duhet të përmbajë të paktën një shifër"</string>
    <string name="lockpassword_password_requires_symbol" msgid="5944350865681510893">"Duhet të përmbajë të paktën një simbol"</string>
    <plurals name="lockpassword_password_requires_letters" formatted="false" msgid="9013132344745898400">
      <item quantity="other">Duhet të përmbajë të paktën <xliff:g id="COUNT">%d</xliff:g> shkronja</item>
      <item quantity="one">Duhet të përmbajë të paktën 1 shkronjë</item>
    </plurals>
    <plurals name="lockpassword_password_requires_lowercase" formatted="false" msgid="2626327674921055486">
      <item quantity="other">Duhet të pëmrbajë të paktën <xliff:g id="COUNT">%d</xliff:g> shkronja të vogla</item>
      <item quantity="one">Duhet të përmbajë të paktën 1 shkronjë të vogël</item>
    </plurals>
    <plurals name="lockpassword_password_requires_uppercase" formatted="false" msgid="7860796359913920356">
      <item quantity="other">Duhet të përmbajë të paktën <xliff:g id="COUNT">%d</xliff:g> shkronja të mëdha</item>
      <item quantity="one">Duhet të përmbajë të paktën 1 shkronjë të madhe</item>
    </plurals>
    <plurals name="lockpassword_password_requires_numeric" formatted="false" msgid="1967587658356336828">
      <item quantity="other">Duhet të përmbajë të paktën <xliff:g id="COUNT">%d</xliff:g> shifra numerike</item>
      <item quantity="one">Duhet të përmbajë të paktën 1 shifër numerike</item>
    </plurals>
    <plurals name="lockpassword_password_requires_symbols" formatted="false" msgid="6751305770863640574">
      <item quantity="other">Duhet të përmbajë të paktën <xliff:g id="COUNT">%d</xliff:g> simbole të veçanta</item>
      <item quantity="one">Duhet të përmbajë të paktën 1 simbol të veçantë</item>
    </plurals>
    <plurals name="lockpassword_password_requires_nonletter" formatted="false" msgid="4440596998172043055">
      <item quantity="other">Duhet të përmbajë të paktën <xliff:g id="COUNT">%d</xliff:g> karaktere që nuk janë shkronja</item>
      <item quantity="one">Duhet të përmbajë të paktën 1 karakter që nuk është shkronjë</item>
    </plurals>
    <string name="lockpassword_password_recently_used" msgid="942665351220525547">"Administratori i pajisjes nuk e lejon përdorimin e një fjalëkalimi të përdorur së fundi"</string>
    <string name="lockpassword_password_blacklisted_by_admin" msgid="9105101266246197027">"Fjalëkalimet e zakonshme janë bllokuar nga administratori i TI-së. Provo një fjalëkalim tjetër."</string>
    <string name="lockpassword_pin_no_sequential_digits" msgid="680765285206990584">"Nuk lejohet një sekuencë shifrash në rritje, në zbritje ose me përsëritje"</string>
    <string name="lockpassword_confirm_label" msgid="8176726201389902380">"Konfirmo"</string>
    <string name="lockpassword_cancel_label" msgid="8818529276331121899">"Anulo"</string>
    <string name="lockpassword_clear_label" msgid="5724429464960458155">"Pastro"</string>
    <string name="lockpassword_credential_changed" msgid="581649578639853343">"Kyçja e ekranit është ndryshuar tashmë. Provo përsëri me kyçjen e re të ekranit."</string>
    <string name="lockpattern_tutorial_cancel_label" msgid="6431583477570493261">"Anulo"</string>
    <string name="lockpattern_tutorial_continue_label" msgid="3559793618653400434">"Përpara"</string>
    <string name="lock_setup" msgid="3355847066343753943">"Konfigurimi përfundoi."</string>
    <string name="manage_device_admin" msgid="537804979483211453">"Apl. e admin. të pajisjes"</string>
    <string name="number_of_device_admins_none" msgid="7185056721919496069">"Asnjë aplikacion aktiv"</string>
    <plurals name="number_of_device_admins" formatted="false" msgid="3361891840111523393">
      <item quantity="other"><xliff:g id="COUNT_1">%d</xliff:g> aplikacione aktive</item>
      <item quantity="one"><xliff:g id="COUNT_0">%d</xliff:g> aplikacion aktiv</item>
    </plurals>
    <string name="manage_trust_agents" msgid="4629279457536987768">"Agjentët e besuar"</string>
    <string name="disabled_because_no_backup_security" msgid="6877660253409580377">"Për ta përdorur, në fillim cakto një kyçje ekrani"</string>
    <string name="manage_trust_agents_summary" msgid="1475819820389620546">"Asnjë"</string>
    <plurals name="manage_trust_agents_summary_on" formatted="false" msgid="3935182396726101824">
      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> agjentë aktivë të besimit</item>
      <item quantity="one">1 agjent aktiv i besimit</item>
    </plurals>
    <string name="bluetooth_quick_toggle_title" msgid="1037056952714061893">"Bluetooth-i"</string>
    <string name="bluetooth_quick_toggle_summary" msgid="5293641680139873341">"Aktivizo \"Bluetooth-in\""</string>
    <string name="bluetooth_settings" msgid="1810521656168174329">"Bluetooth-i"</string>
    <string name="bluetooth_settings_title" msgid="1908745291161353016">"Bluetooth-i"</string>
    <string name="bluetooth_settings_summary" msgid="2091062709530570462">"Menaxho lidhjet, cakto emrin e pajisjes dhe zbulueshmërinë"</string>
    <string name="bluetooth_pairing_request" msgid="2605098826364694673">"Të çiftohet me <xliff:g id="DEVICE_NAME">%1$s</xliff:g>?"</string>
    <string name="bluetooth_pairing_key_msg" msgid="418124944140102021">"Kodi i çiftimit të \"bluetooth-it\""</string>
    <string name="bluetooth_enter_passkey_msg" msgid="6813273136442138444">"Shkruaj kodin e çiftimit, pastaj shtyp \"Kthehu\" ose \"Hyr\""</string>
    <string name="bluetooth_enable_alphanumeric_pin" msgid="7222713483058171357">"Kodi PIN përmban shkronja ose simbole"</string>
    <string name="bluetooth_pin_values_hint" msgid="3815897557875873646">"Zakonisht 0000 ose 1234"</string>
    <string name="bluetooth_pin_values_hint_16_digits" msgid="7849359451584101077">"Duhet të ketë 16 shifra"</string>
    <string name="bluetooth_enter_pin_other_device" msgid="4637977124526813470">"Mund të duhet gjithashtu ta shkruash këtë kod PIN në pajisjen tjetër."</string>
    <string name="bluetooth_enter_passkey_other_device" msgid="2798719004030279602">"Mund të duhet gjithashtu ta shkruash këtë kod në pajisjen tjetër."</string>
    <string name="bluetooth_confirm_passkey_msg" msgid="3708312912841950052">"Për ta çiftuar me:&lt;br&gt;&lt;b&gt;<xliff:g id="DEVICE_NAME">%1$s</xliff:g>&lt;/b&gt;&lt;br&gt;&lt;br&gt;sigurohu që të tregojë këtë kod:&lt;br&gt;&lt;b&gt;<xliff:g id="PASSKEY">%2$s</xliff:g>&lt;/b&gt;"</string>
    <string name="bluetooth_incoming_pairing_msg" msgid="1615930853859551491">"Nga:&lt;br&gt;&lt;b&gt;<xliff:g id="DEVICE_NAME">%1$s</xliff:g>&lt;/b&gt;&lt;br&gt;&lt;br&gt;Të çiftohet me këtë pajisje?"</string>
    <string name="bluetooth_display_passkey_pin_msg" msgid="2796550001376088433">"Për ta çiftuar me:<xliff:g id="BOLD1_0">&lt;br&gt;&lt;b&gt;</xliff:g><xliff:g id="DEVICE_NAME">%1$s</xliff:g><xliff:g id="END_BOLD1">&lt;/b&gt;&lt;br&gt;&lt;br&gt;</xliff:g>Shkruaj në të:<xliff:g id="BOLD2_1">&lt;br&gt;&lt;b&gt;</xliff:g><xliff:g id="PASSKEY">%2$s</xliff:g><xliff:g id="END_BOLD2">&lt;/b&gt;</xliff:g> dhe më pas shtyp Kthehu ose Hyr."</string>
    <string name="bluetooth_pairing_shares_phonebook" msgid="9082518313285787097">"Lejo qasjen te kontaktet dhe historiku i telefonatave"</string>
    <string name="bluetooth_error_title" msgid="6850384073923533096"></string>
    <string name="bluetooth_connecting_error_message" msgid="1397388344342081090">"Nuk mundi të lidhej me <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="bluetooth_preference_scan_title" msgid="2277464653118896016">"Skano për pajisje"</string>
    <string name="bluetooth_search_for_devices" msgid="2754007356491461674">"Rifresko"</string>
    <string name="bluetooth_searching_for_devices" msgid="9203739709307871727">"Po kërkon..."</string>
    <string name="bluetooth_preference_device_settings" msgid="907776049862799122">"Cilësimet e pajisjes"</string>
    <string name="bluetooth_preference_paired_dialog_title" msgid="8875124878198774180">"Pajisja e çiftuar"</string>
    <string name="bluetooth_preference_paired_dialog_internet_option" msgid="7112953286863428412">"Lidhje me internet"</string>
    <string name="bluetooth_preference_paired_dialog_keyboard_option" msgid="2271954176947879628">"Tastiera"</string>
    <string name="bluetooth_preference_paired_dialog_contacts_option" msgid="7747163316331917594">"Kontaktet dhe historiku i telefonatave"</string>
    <string name="bluetooth_pairing_dialog_title" msgid="1417255032435317301">"Të çiftohet me këtë pajisje?"</string>
    <string name="bluetooth_pairing_dialog_sharing_phonebook_title" msgid="7664141669886358618">"Të ndahet numëratori telefonik?"</string>
    <string name="bluetooth_pairing_dialog_contants_request" msgid="5531109163573611348">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g> kërkon të ketë qasje te kontaktet dhe historiku i telefonatave."</string>
    <string name="bluetooth_pairing_dialog_paring_request" msgid="8451248193517851958">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g> kërkon të çiftohet me Bluetooth. Kur të lidhet, pajisja do të ketë qasje te kontaktet e tua dhe historiku i telefonatave."</string>
    <string name="bluetooth_preference_found_media_devices" msgid="1617401232446299411">"Pajisjet që ofrohen"</string>
    <string name="bluetooth_preference_no_found_devices" msgid="7594339669961811591">"Nuk ofrohet asnjë pajisje"</string>
    <string name="bluetooth_device_context_connect" msgid="3997659895003244941">"Lidh"</string>
    <string name="bluetooth_device_context_disconnect" msgid="8220072022970148683">"Shkëput"</string>
    <string name="bluetooth_device_context_pair_connect" msgid="7611522504813927727">"Ҫifto dhe lidh"</string>
    <string name="bluetooth_device_context_unpair" msgid="662992425948536144">"Hiq nga çiftimi"</string>
    <string name="bluetooth_device_context_disconnect_unpair" msgid="7644014238070043798">"Shkëput dhe hiq nga çiftimi"</string>
    <string name="bluetooth_device_context_connect_advanced" msgid="2643129703569788771">"Opsionet..."</string>
    <string name="bluetooth_menu_advanced" msgid="8572178316357220524">"Të përparuara"</string>
    <string name="bluetooth_advanced_titlebar" msgid="2142159726881547669">"Cilësimet e përparuara të Bluetooth-it"</string>
    <string name="bluetooth_empty_list_bluetooth_off" msgid="6351930724051893423">"Kur Bluetooth-i është i aktivizuar, pajisja jote mund të komunikojë me pajisjet e tjera me Bluetooth në afërsi."</string>
    <string name="bluetooth_scanning_on_info_message" msgid="824285504325592644">"Kur Bluetooth-i është i aktivizuar, pajisja jote mund të komunikojë me pajisjet e tjera me Bluetooth në afërsi.\n\nPër të përmirësuar përvojën e pajisjes, aplikacionet dhe shërbimet mund të skanojnë për pajisje në afërsi në çdo moment, edhe kur Bluetooth është joaktiv. Kjo mund të përdoret, për shembull, për të përmirësuar funksionet dhe shërbimet e bazuara te vendndodhja. Këtë mund ta ndryshosh te "<annotation id="link">"cilësimet e skanimit"</annotation>"."</string>
    <string name="ble_scan_notify_text" msgid="1295915006005700650">"Për të përmirësuar saktësinë e vendndodhjes, aplikacionet dhe shërbimet e sistemit mund t\'i zbulojnë akoma pajisjet me Bluetooth. Këtë mund ta ndryshosh te <xliff:g id="LINK_BEGIN_0">LINK_BEGIN</xliff:g>cilësimet e skanimit<xliff:g id="LINK_END_1">LINK_END</xliff:g>."</string>
    <string name="bluetooth_connect_failed" msgid="4500234659813241053">"Nuk mund të lidhej. Provo përsëri."</string>
    <string name="device_details_title" msgid="6576953269221085300">"Detajet e pajisjes"</string>
    <string name="bluetooth_device_mac_address" msgid="2513724313558236181">"Adresa e Bluetooth-it e pajisjes: <xliff:g id="ADDRESS">%1$s</xliff:g>"</string>
    <string name="bluetooth_unpair_dialog_title" msgid="38467834196432400">"Të harrohet pajisja?"</string>
    <string name="bluetooth_unpair_dialog_body" product="default" msgid="9087609557757135712">"Telefoni yt nuk do të jetë më i çiftuar me <xliff:g id="DEVICE_NAME">%1$s</xliff:g>"</string>
    <string name="bluetooth_unpair_dialog_body" product="tablet" msgid="7785695793007576501">"Tableti yt nuk do të jetë më i çiftuar me <xliff:g id="DEVICE_NAME">%1$s</xliff:g>"</string>
    <string name="bluetooth_unpair_dialog_body" product="device" msgid="251257782642157557">"Pajisja jote nuk do të jetë më e çiftuar me <xliff:g id="DEVICE_NAME">%1$s</xliff:g>"</string>
    <string name="bluetooth_untethered_unpair_dialog_body" msgid="5932168717642676140">"Pajisja <xliff:g id="DEVICE_NAME">%1$s</xliff:g> nuk do të jetë më e çiftuar me asnjë pajisje të lidhur me këtë llogari"</string>
    <string name="bluetooth_unpair_dialog_forget_confirm_button" msgid="3829370108973879006">"Harroje pajisjen"</string>
    <string name="bluetooth_connect_specific_profiles_title" msgid="6952214406025825164">"Lidhu me…"</string>
    <string name="bluetooth_disconnect_a2dp_profile" msgid="3524648279150937177">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g> do të shkëputet nga audioja e medias."</string>
    <string name="bluetooth_disconnect_headset_profile" msgid="8635908811168780720">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g> do të shkëputet nga audioja \"pa duar\"."</string>
    <string name="bluetooth_disconnect_hid_profile" msgid="3282295189719352075">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g> do të shkëputet nga pajisja e hyrjes."</string>
    <string name="bluetooth_disconnect_pan_user_profile" msgid="8037627994382458698">"Qasja në internet përmes <xliff:g id="DEVICE_NAME">%1$s</xliff:g> do të shkëputet."</string>
    <string name="bluetooth_disconnect_pan_nap_profile" product="tablet" msgid="8355910926439312604">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g> do të shkëputet nga ndarja e lidhjes së internetit të këtij tableti."</string>
    <string name="bluetooth_disconnect_pan_nap_profile" product="default" msgid="6251611115860359886">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g> do të shkëputet nga ndarja e lidhjes së internetit të këtij telefoni."</string>
    <string name="bluetooth_device_advanced_title" msgid="6066342531927499308">"Pajisja me Bluetooth e çiftuar"</string>
    <string name="bluetooth_device_advanced_online_mode_title" msgid="3689050071425683114">"Lidh"</string>
    <string name="bluetooth_device_advanced_online_mode_summary" msgid="1204424107263248336">"Lidhu me pajisjen me Bluetooth"</string>
    <string name="bluetooth_device_advanced_profile_header_title" msgid="102745381968579605">"Përdore për"</string>
    <string name="bluetooth_device_advanced_rename_device" msgid="5148578059584955791">"Riemërto"</string>
    <string name="bluetooth_device_advanced_enable_opp_title" msgid="8222550640371627365">"Lejo transferimet e skedarëve hyrës"</string>
    <string name="bluetooth_pan_user_profile_summary_connected" msgid="6436258151814414028">"Lidhur me pajisjen për qasje në internet"</string>
    <string name="bluetooth_pan_nap_profile_summary_connected" msgid="1322694224800769308">"Po ndan lidhjen lokale të internetit me pajisjen"</string>
    <string name="bluetooth_dock_settings" msgid="3218335822716052885">"Cilësimet e stacionit"</string>
    <string name="bluetooth_dock_settings_title" msgid="5543069893044375188">"Përdor stacionin për audion"</string>
    <string name="bluetooth_dock_settings_headset" msgid="1001821426078644650">"Si altoparlant"</string>
    <string name="bluetooth_dock_settings_a2dp" msgid="8791004998846630574">"Për muzikë dhe media"</string>
    <string name="bluetooth_dock_settings_remember" msgid="5551459057010609115">"Kujto cilësimet"</string>
    <string name="bluetooth_max_connected_audio_devices_string" msgid="6752690395207847881">"Numri maksimal i pajisjeve të lidhura audio me Bluetooth"</string>
    <string name="bluetooth_max_connected_audio_devices_dialog_title" msgid="5936561749790095473">"Zgjidh numrin maksimal të pajisjeve të lidhura audio me Bluetooth"</string>
    <string name="wifi_display_settings_title" msgid="8740852850033480136">"Transmetimi"</string>
    <string name="wifi_display_enable_menu_item" msgid="4883036464138167674">"Aktivizo shfaqjen e rrjetit valor"</string>
    <string name="wifi_display_no_devices_found" msgid="1382012407154143453">"Nuk u gjet asnjë pajisje në afërsi."</string>
    <string name="wifi_display_status_connecting" msgid="5688608834000748607">"Po lidhet"</string>
    <string name="wifi_display_status_connected" msgid="8364125226376985558">"Të lidhura"</string>
    <string name="wifi_display_status_in_use" msgid="8556830875615434792">"Në përdorim"</string>
    <string name="wifi_display_status_not_available" msgid="5714978725794210102">"Nuk ofrohet"</string>
    <string name="wifi_display_details" msgid="7791118209992162698">"Shfaq cilësimet"</string>
    <string name="wifi_display_options_title" msgid="5740656401635054838">"Opsionet e shfaqjes së Wi-Fi"</string>
    <string name="wifi_display_options_forget" msgid="9119048225398894580">"Harro"</string>
    <string name="wifi_display_options_done" msgid="5703116500357822557">"U krye!"</string>
    <string name="wifi_display_options_name" msgid="4756080222307467898">"Emri"</string>
    <string name="wifi_band_24ghz" msgid="852929254171856911">"2,4 GHz"</string>
    <string name="wifi_band_5ghz" msgid="6433822023268515117">"5 GHz"</string>
    <string name="wifi_sign_in_button_text" msgid="8404345621836792112">"Identifikohu"</string>
    <string name="wifi_tap_to_sign_in" msgid="6990161842394669054">"Trokit këtu për t\'u identifikuar në rrjet"</string>
    <string name="tx_link_speed" msgid="6139577455916971837">"<xliff:g id="TRANSMIT_LINK_SPEED">%1$d</xliff:g> Mbps"</string>
    <string name="rx_link_speed" msgid="5729003360923133988">"<xliff:g id="RECEIVE_LINK_SPEED">%1$d</xliff:g> Mbps"</string>
    <string name="wifi_ask_enable" msgid="2795469717302060104">"<xliff:g id="REQUESTER">%s</xliff:g> kërkon të aktivizojë Wi-Fi"</string>
    <string name="wifi_ask_disable" msgid="728366570145493573">"<xliff:g id="REQUESTER">%s</xliff:g> kërkon të çaktivizojë Wi-Fi"</string>
    <string name="art_verifier_for_debuggable_title" msgid="6029838014407791341">"Verifiko kodin me bajte për apl. e korrigjueshme"</string>
    <string name="art_verifier_for_debuggable_summary" msgid="2250352478065428399">"Lejo që ART të verifikojë kodin me bajte për aplikacionet e korrigjueshme"</string>
    <string name="nfc_quick_toggle_title" msgid="6769159366307299004">"NFC"</string>
    <string name="nfc_quick_toggle_summary" product="tablet" msgid="8302974395787498915">"Lejo shkëmbimin e të dhënave kur tableti prek një tjetër pajisje"</string>
    <string name="nfc_quick_toggle_summary" product="default" msgid="5237208142892767592">"Lejo shkëmbimin e të dhënave kur telefoni prek një tjetër pajisje"</string>
    <string name="nfc_disclaimer_title" msgid="4364003873202264039">"Aktivizo NFC-në"</string>
    <string name="nfc_disclaimer_content" msgid="5566907911915158075">"Të dhënat e shkëmbimit NFC mes kësaj pajisjeje dhe pajisjeve ose objektivave të tjera në afërsi, siç janë terminalet e pagesave, lexuesit e qasjes dhe reklamat apo etiketat interaktive."</string>
    <string name="nfc_secure_settings_title" msgid="150400737244061585">"NFC-ja e sigurt"</string>
    <string name="nfc_secure_toggle_summary" product="default" msgid="2135032222065627938">"Lejo përdorimin e \"Pagesave me NFC\" dhe \"Tranzitit\" vetëm kur ekrani është i shkyçur"</string>
    <string name="android_beam_settings_title" msgid="7832812974600338649">"Dërgimi me rreze i Androidit"</string>
    <string name="android_beam_on_summary" msgid="3618057099355636830">"Gati për të transmetuar përmbajtjen e aplikacionit përmes NFC-së"</string>
    <string name="android_beam_off_summary" msgid="4663095428454779138">"Çaktivizuar"</string>
    <string name="nfc_disabled_summary" msgid="3507017304297395467">"Nuk ofrohet sepse NFC-ja është e çaktivizuar"</string>
    <string name="android_beam_label" msgid="6257036050366775040">"Dërgimi me rreze i Androidit"</string>
    <string name="android_beam_explained" msgid="1810540319385192758">"Kur ky funksion është i aktivizuar, mund t\'i transmetosh përmbajtjet e aplikacioneve te një pajisje tjetër me NFC duke i mbajtur pajisjet afër. Për shembull, mund të transmetosh faqet e uebit, videot në YouTube, kontaktet etj.\n\nThjesht, afroji pajisjet me njëra-tjetrën (zakonisht nga pjesa e pasme) dhe më pas trokit tek ekrani. Aplikacioni përcakton se çfarë do të transmetohet."</string>
    <string name="wifi_quick_toggle_title" msgid="8850161330437693895">"Wi-Fi"</string>
    <string name="wifi_quick_toggle_summary" msgid="2696547080481267642">"Aktivizo Wi-Fi"</string>
    <string name="wifi_settings" msgid="29722149822540994">"Wi‑Fi"</string>
    <string name="wifi_settings_master_switch_title" msgid="4746267967669683259">"Përdor Wi-Fi"</string>
    <string name="wifi_settings_category" msgid="8719175790520448014">"Cilësimet e Wi-Fi"</string>
    <string name="wifi_settings_title" msgid="3103415012485692233">"Wi‑Fi"</string>
    <string name="wifi_settings_summary" msgid="668767638556052820">"Cakto dhe menaxho zonat e qasjes të rrjetit me valë"</string>
    <string name="wifi_select_network" msgid="4210954938345463209">"Zgjidh Wi‑Fi"</string>
    <string name="wifi_starting" msgid="6732377932749942954">"Po aktivizon Wi‑Fi…"</string>
    <string name="wifi_stopping" msgid="8952524572499500804">"Po çaktivizon Wi‑Fi…"</string>
    <string name="wifi_error" msgid="3207971103917128179">"Gabim"</string>
    <string name="wifi_sap_no_channel_error" msgid="3108445199311817111">"Brezi 5 GHz nuk ofrohet në këtë vend"</string>
    <string name="wifi_in_airplane_mode" msgid="8652520421778203796">"Në modalitetin e aeroplanit"</string>
    <string name="wifi_notify_open_networks" msgid="76298880708051981">"Hap njoftimin e rrjetit"</string>
    <string name="wifi_notify_open_networks_summary" msgid="2761326999921366960">"Njofto kur ofrohet një rrjet publik me cilësi të lartë"</string>
    <string name="wifi_wakeup" msgid="8815640989361538036">"Aktivizo automatikisht Wi‑Fi"</string>
    <string name="wifi_wakeup_summary" msgid="2530814331062997163">"Wi-Fi do të aktivizohet përsëri në afërsi të rrjeteve të ruajtura me cilësi të lartë, si p.sh. rrjetin e shtëpisë"</string>
    <string name="wifi_wakeup_summary_no_location" msgid="7494539594649967699">"Nuk ofrohet sepse vendndodhja është e çaktivizuar. Aktivizo "<annotation id="link">"vendndodhjen"</annotation>"."</string>
    <string name="wifi_wakeup_summary_scanning_disabled" msgid="7247227922074840445">"Nuk ofrohet sepse skanimi i Wi-Fi është çaktivizuar"</string>
    <string name="wifi_wakeup_summary_scoring_disabled" msgid="108339002136866897">"Për ta përdorur, zgjidh një ofrues të vlerësimit të rrjetit"</string>
    <string name="wifi_poor_network_detection" msgid="4925789238170207169">"Shmang lidhjet e dobëta"</string>
    <string name="wifi_poor_network_detection_summary" msgid="7016103106105907127">"Mos përdor rrjet Wi‑Fi nëse nuk ka lidhje të mirë interneti"</string>
    <string name="wifi_avoid_poor_network_detection_summary" msgid="1644292503152790501">"Përdor vetëm rrjete që kanë lidhje të mirë interneti"</string>
    <string name="use_open_wifi_automatically_title" msgid="6851951242903078588">"Lidhu me rrjete të hapura"</string>
    <string name="use_open_wifi_automatically_summary" msgid="2982091714252931713">"Lidhu automatikisht me rrjete publike me cilësi të lartë"</string>
    <string name="use_open_wifi_automatically_summary_scoring_disabled" msgid="593964217679325831">"Për ta përdorur, zgjidh një ofrues të vlerësimit të rrjetit"</string>
    <string name="use_open_wifi_automatically_summary_scorer_unsupported_disabled" msgid="8472122600853650258">"Për ta përdorur, zgjidh një ofrues të përputhshëm të vlerësimit të rrjetit"</string>
    <string name="wifi_install_credentials" msgid="3551143317298272860">"Instalo certifikatat"</string>
    <string name="wifi_scan_notify_text" msgid="5544778734762998889">"Për të përmirësuar saktësinë e vendndodhjes, aplikacionet dhe shërbimet mund të skanojnë përsëri për rrjete Wi‑Fi në çdo kohë, edhe kur Wi‑Fi është joaktiv. Kjo mund të përdoret, për shembull, për të përmirësuar funksionet dhe shërbimet e bazuara te vendndodhja. Mund ta ndryshosh këtë te <xliff:g id="LINK_BEGIN_0">LINK_BEGIN</xliff:g>cilësimet e skanimit<xliff:g id="LINK_END_1">LINK_END</xliff:g>."</string>
    <string name="wifi_scan_notify_text_scanning_off" msgid="3426075479272242098">"Për të përmirësuar saktësinë e vendndodhjes, aktivizo skanimin e Wi-Fi te <xliff:g id="LINK_BEGIN_0">LINK_BEGIN</xliff:g>cilësimet e skanimit<xliff:g id="LINK_END_1">LINK_END</xliff:g>."</string>
    <string name="wifi_scan_notify_remember_choice" msgid="7104867814641144485">"Mos e shfaq përsëri"</string>
    <string name="wifi_setting_sleep_policy_title" msgid="5149574280392680092">"Wi-Fi aktiv kur fiket ekrani"</string>
    <string name="wifi_setting_on_during_sleep_title" msgid="8308975500029751565">"Wi-Fi gjatë qendrimit në gjendje gjumi"</string>
    <string name="wifi_setting_sleep_policy_error" msgid="8174902072673071961">"Kishte një problem me ndryshimin e cilësimit"</string>
    <string name="wifi_suspend_efficiency_title" msgid="2338325886934703895">"Përmirëso efikasitetin"</string>
    <string name="wifi_suspend_optimizations" msgid="1220174276403689487">"Optimizimi i Wi-Fi"</string>
    <string name="wifi_suspend_optimizations_summary" msgid="4151428966089116856">"Minimizo përdorimin e baterisë kur Wi‑Fi është aktiv"</string>
    <string name="wifi_limit_optimizations_summary" msgid="9000801068363468950">"Kufizo baterinë në Wi-Fi"</string>
    <string name="wifi_switch_away_when_unvalidated" msgid="8593144541347373394">"Kalo te të dhënat celulare nëse Wi‑Fi humbet qasjen në internet."</string>
    <string name="wifi_cellular_data_fallback_title" msgid="8753386877755616476">"Kalo automatikisht te të dhënat celulare"</string>
    <string name="wifi_cellular_data_fallback_summary" msgid="1403505355490119307">"Përdor të dhënat celulare kur Wi-Fi nuk ka qasje në internet. Mund të zbatohen tarifa për të dhënat."</string>
    <string name="wifi_add_network" msgid="6234851776910938957">"Shto një rrjet"</string>
    <string name="wifi_configure_settings_preference_title" msgid="2913345003906899146">"Preferencat e Wi‑Fi"</string>
    <string name="wifi_configure_settings_preference_summary_wakeup_on" msgid="646393113104367290">"Wi‑Fi aktivizohet përsëri automatikisht"</string>
    <string name="wifi_configure_settings_preference_summary_wakeup_off" msgid="2782566279864356713">"Wi‑Fi nuk aktivizohet përsëri automatikisht"</string>
    <string name="wifi_access_points" msgid="7053990007031968609">"Rrjetet Wi‑Fi"</string>
    <string name="wifi_menu_more_options" msgid="2448097861752719396">"Opsione të tjera"</string>
    <string name="wifi_menu_p2p" msgid="7619851399250896797">"Wi‑Fi Direct"</string>
    <string name="wifi_menu_scan" msgid="1470911530412095868">"Skano"</string>
    <string name="wifi_menu_advanced" msgid="7522252991919573664">"Të përparuara"</string>
    <string name="wifi_menu_configure" msgid="6150926852602171938">"Konfiguro"</string>
    <string name="wifi_menu_connect" msgid="4996220309848349408">"Lidhu me rrjetin"</string>
    <string name="wifi_menu_remember" msgid="8814185749388713796">"Kujto rrjetin"</string>
    <string name="wifi_menu_forget" msgid="8736964302477327114">"Harro rrjetin"</string>
    <string name="wifi_menu_modify" msgid="2068554918652440105">"Modifiko rrjetin"</string>
    <string name="wifi_empty_list_wifi_off" msgid="8056223875951079463">"Për të parë rrjetet që ofrohen, aktivizo Wi-Fi."</string>
    <string name="wifi_empty_list_wifi_on" msgid="8746108031587976356">"Po kërkon për rrjete Wi‑Fi…"</string>
    <string name="wifi_empty_list_user_restricted" msgid="7322372065475939129">"Nuk ke leje të ndryshosh rrjetin Wi-Fi."</string>
    <string name="wifi_more" msgid="3195296805089107950">"Më shumë"</string>
    <string name="wifi_setup_wps" msgid="8128702488486283957">"Konfigurimi automatik (WPS)"</string>
    <string name="wifi_settings_scanning_required_title" msgid="3815269816331500375">"Të aktivizohet skanimi i Wi‑Fi?"</string>
    <string name="wifi_settings_scanning_required_summary" msgid="6352918945128328916">"Për të aktivizuar automatikisht Wi‑Fi, në fillim duhet të aktivizosh skanimin e Wi‑Fi."</string>
    <string name="wifi_settings_scanning_required_info" msgid="3155631874578023647">"Skanimi i Wi-Fi lejon që aplikacionet dhe shërbimet të skanojnë për rrjete Wi-Fi në çdo kohë, edhe kur Wi-Fi është joaktiv. Kjo mund të përdoret, për shembull, për të përmirësuar funksionet dhe shërbimet e bazuara te vendndodhja."</string>
    <string name="wifi_settings_scanning_required_turn_on" msgid="1364287182804820646">"Aktivizo"</string>
    <string name="wifi_settings_scanning_required_enabled" msgid="5527653791584018157">"Skanimi i Wi‑Fi është aktivizuar"</string>
    <string name="wifi_show_advanced" msgid="3409422789616520979">"Opsionet e përparuara"</string>
    <string name="wifi_advanced_toggle_description_expanded" msgid="2380600578544493084">"\"Opsionet e përparuara\" të listës me lëshim poshtë. Trokit dy herë për ta palosur."</string>
    <string name="wifi_advanced_toggle_description_collapsed" msgid="1463812308429197263">"\"Opsionet e përparuara\" të listës me lëshim poshtë. Trokit dy herë për ta zgjeruar."</string>
    <string name="wifi_ssid" msgid="5519636102673067319">"Emri i rrjetit"</string>
    <string name="wifi_ssid_hint" msgid="897593601067321355">"Fut SSID-në"</string>
    <string name="wifi_security" msgid="6603611185592956936">"Siguria"</string>
    <string name="wifi_hidden_network" msgid="973162091800925000">"Rrjet i fshehur"</string>
    <string name="wifi_hidden_network_warning" msgid="6674068093531603452">"Nëse rrugëzuesi nuk po transmeton një ID rrjeti, por dëshiron të lidhesh me të në të ardhmen, mund ta caktosh rrjetin si të fshehur.\n\nKjo mund të krijojë një rrezik për sigurinë pasi telefoni yt do të transmetojë rregullisht sinjalin e tij për të gjetur rrjetin.\n\nCaktimi i rrjetit si të fshehur nuk do të ndryshojë cilësimet e router-it."</string>
    <string name="wifi_signal" msgid="5514120261628065287">"Fuqia e sinjalit"</string>
    <string name="wifi_status" msgid="4824568012414605414">"Statusi"</string>
    <string name="tx_wifi_speed" msgid="2994278184097786511">"Shpejtësia e lidhjes së transmetimit"</string>
    <string name="rx_wifi_speed" msgid="7206089638282839236">"Merr shpejtësinë e lidhjes"</string>
    <string name="wifi_frequency" msgid="7791090119577812214">"Frekuenca"</string>
    <string name="wifi_ip_address" msgid="1440054061044402918">"Adresa e IP-së"</string>
    <string name="passpoint_label" msgid="6381371313076009926">"U ruajt me"</string>
    <string name="passpoint_content" msgid="8447207162397870483">"Kredencialet e <xliff:g id="NAME">%1$s</xliff:g>"</string>
    <string name="wifi_eap_method" msgid="8529436133640730382">"Metoda EAP"</string>
    <string name="please_select_phase2" msgid="5231074529772044898">"Vërtetimi i Fazës 2"</string>
    <string name="wifi_eap_ca_cert" msgid="3521574865488892851">"Certifikata CA"</string>
    <string name="wifi_eap_domain" msgid="8471124344218082064">"Domeni"</string>
    <string name="wifi_eap_user_cert" msgid="1291089413368160789">"Certifikata e përdoruesit"</string>
    <string name="wifi_eap_identity" msgid="4359453783379679103">"Identiteti"</string>
    <string name="wifi_eap_anonymous" msgid="2989469344116577955">"Identitet anonim"</string>
    <string name="wifi_password" msgid="5948219759936151048">"Fjalëkalimi"</string>
    <string name="wifi_show_password" msgid="6461249871236968884">"Shfaq fjalëkalimin"</string>
    <string name="wifi_ap_band_config" msgid="1611826705989117930">"Zgjidh bandën AP"</string>
    <string name="wifi_ap_choose_auto" msgid="2677800651271769965">"Automatik"</string>
    <string name="wifi_ap_choose_2G" msgid="8724267386885036210">"Bandë 2,4 GHz"</string>
    <string name="wifi_ap_choose_5G" msgid="8813128641914385634">"Banda 5,0 GHz"</string>
    <string name="wifi_ap_prefer_5G" msgid="2501070491623803139">"Preferohet banda 5,0 GHz"</string>
    <string name="wifi_ap_2G" msgid="8378132945192979364">"2,4 GHz"</string>
    <string name="wifi_ap_5G" msgid="4020713496716329468">"5,0 GHz"</string>
    <string name="wifi_ap_band_select_one" msgid="3476254666116431650">"Zgjidh të paktën një brez për zonën e qasjes për internet për Wi‑Fi:"</string>
    <string name="wifi_ip_settings" msgid="3359331401377059481">"Cilësimet e IP-së"</string>
    <string name="wifi_privacy_settings" msgid="5500777170960315928">"Privatësia"</string>
    <string name="wifi_privacy_settings_ephemeral_summary" msgid="1539659414108891004">"Adresa MAC e rastësishme"</string>
    <string name="wifi_dpp_add_device_to_network" msgid="8674936581557695411">"Shto një pajisje"</string>
    <string name="wifi_dpp_center_qr_code" msgid="6244508369721032655">"Vendos në qendër më poshtë kodin QR për ta shtuar pajisjen te “<xliff:g id="SSID">%1$s</xliff:g>”"</string>
    <string name="wifi_dpp_scan_qr_code" msgid="4794621158747044107">"Skano kodin QR"</string>
    <string name="wifi_dpp_scan_qr_code_join_network" msgid="4371771604088014396">"Vendos në qendër kodin QR më poshtë për t\'u lidhur me “<xliff:g id="SSID">%1$s</xliff:g>”"</string>
    <string name="wifi_dpp_scan_qr_code_join_unknown_network" msgid="8096370383700478819">"Bashkohu me Wi-Fi duke skanuar një kod QR"</string>
    <string name="wifi_dpp_share_wifi" msgid="9065890131734833809">"Ndaj Wi‑Fi"</string>
    <string name="wifi_dpp_scan_qr_code_with_another_device" msgid="5854392840857123065">"Skano këtë kod QR për t\'u lidhur me “<xliff:g id="SSID">%1$s</xliff:g>” dhe ndaj fjalëkalimin"</string>
    <string name="wifi_dpp_scan_open_network_qr_code_with_another_device" msgid="4436318319178361543">"Skano këtë kod QR për t\'u lidhur me “<xliff:g id="SSID">%1$s</xliff:g>”"</string>
    <string name="wifi_dpp_could_not_detect_valid_qr_code" msgid="641893675646330576">"Kodi QR nuk mund të lexohej Vendose përsëri kodin në qendër dhe provo përsëri"</string>
    <string name="wifi_dpp_failure_authentication_or_configuration" msgid="3372757783382381044">"Provo sërish. Nëse problemi vazhdon, kontakto me prodhuesin e pajisjes"</string>
    <string name="wifi_dpp_failure_not_compatible" msgid="2829930473520603740">"Ndodhi një gabim"</string>
    <string name="wifi_dpp_failure_timeout" msgid="5228320772245820458">"Sigurohu që pajisja është në prizë, e karikuar dhe e ndezur"</string>
    <string name="wifi_dpp_failure_generic" msgid="8030831192606098356">"Sigurohu që pajisja është në prizë, e karikuar dhe e ndezur. Nëse problemi vazhdon, kontakto me prodhuesin e pajisjes"</string>
    <string name="wifi_dpp_failure_not_supported" msgid="2643768115109632725">"Shtimi i “<xliff:g id="SSID">%1$s</xliff:g>” nuk mbështetet nga kjo pajisje"</string>
    <string name="wifi_dpp_check_connection_try_again" msgid="2632966336733361805">"Kontrollo lidhjen dhe provo përsëri"</string>
    <string name="wifi_dpp_choose_network" msgid="7139308800110200281">"Zgjidh rrjetin"</string>
    <string name="wifi_dpp_choose_network_to_connect_device" msgid="4025269026652486605">"Për të lidhur pajisjen, zgjidh një rrjet"</string>
    <string name="wifi_dpp_add_device_to_wifi" msgid="5459084866460319042">"Të shtohet kjo pajisje te “<xliff:g id="SSID">%1$s</xliff:g>”?"</string>
    <string name="wifi_dpp_wifi_shared_with_device" msgid="7669684043486750097">"Wi‑Fi është ndarë me këtë pajisje"</string>
    <string name="wifi_dpp_add_another_device" msgid="8415243205104666929">"Shto pajisje tjetër"</string>
    <string name="wifi_dpp_choose_different_network" msgid="4081965219206680361">"Zgjidh një rrjet tjetër"</string>
    <string name="wifi_dpp_could_not_add_device" msgid="1598945041477461501">"Pajisja nuk mund të shtohej"</string>
    <string name="wifi_dpp_device_found" msgid="8618134150169810107">"U gjet pajisje"</string>
    <string name="wifi_dpp_sharing_wifi_with_this_device" msgid="5579154298588011712">"Po ndan Wi‑Fi me këtë pajisje…"</string>
    <string name="wifi_dpp_connecting" msgid="7111851118215580428">"Po lidhet…"</string>
    <string name="wifi_dpp_share_hotspot" msgid="762408459341741405">"Ndaje zonën e qasjes për internet"</string>
    <string name="wifi_dpp_lockscreen_title" msgid="8401802203867904622">"Verifiko që je ti"</string>
    <string name="wifi_dpp_wifi_password" msgid="4938294574591503213">"Fjalëkalimi i Wi‑Fi: <xliff:g id="PASSWORD">%1$s</xliff:g>"</string>
    <string name="wifi_dpp_hotspot_password" msgid="4120419278831581613">"Fjalëkalimi i zonës së qasjes për internet: <xliff:g id="PASSWORD">%1$s</xliff:g>"</string>
    <string name="wifi_dpp_add_device" msgid="4072206063308645677">"Shto pajisje"</string>
    <string name="wifi_dpp_connect_network_using_qr_code" msgid="3887335309163999665">"Përdor një kod QR për të shtuar një pajisje në këtë rrjet"</string>
    <string name="retry" msgid="6472609612090877557">"Riprovo"</string>
    <string name="wifi_shared" msgid="844142443226926070">"Ndaje me përdoruesit e tjerë të pajisjes"</string>
    <string name="wifi_unchanged" msgid="3410422020930397102">"(i pandryshuar)"</string>
    <string name="wifi_unspecified" msgid="4917316464723064807">"Zgjidh"</string>
    <string name="wifi_multiple_cert_added" msgid="3240743501460165224">"(U shtuan shumë certifikata)"</string>
    <string name="wifi_use_system_certs" msgid="5270879895056893783">"Përdor certifikatat e sistemit"</string>
    <string name="wifi_do_not_provide_eap_user_cert" msgid="5160499244977160665">"Mos e ofro"</string>
    <string name="wifi_do_not_validate_eap_server" msgid="4266754430576348471">"Mos e mirato"</string>
    <string name="wifi_do_not_validate_eap_server_warning" msgid="1787190245542586660">"Nuk u specifikua asnjë certifikatë. Lidhja jote nuk do të jetë private."</string>
    <string name="wifi_ssid_too_long" msgid="3474753269579895244">"Emri i rrjetit është shumë i gjatë."</string>
    <string name="wifi_no_domain_warning" msgid="5223011964091727376">"Duhet të specifikohet një domen."</string>
    <string name="wifi_wps_available_first_item" msgid="4422547079984583502">"Ofrohet WPS"</string>
    <string name="wifi_wps_available_second_item" msgid="8427520131718215301">" (Ofrohet WPS)"</string>
    <string name="wifi_carrier_connect" msgid="8174696557882299911">"Rrjeti Wi-Fi i operatorit celular"</string>
    <string name="wifi_carrier_content" msgid="4634077285415851933">"E lidhur përmes <xliff:g id="NAME">%1$s</xliff:g>"</string>
    <string name="wifi_scan_always_turnon_message" msgid="203123538572122989">"Për të përmirësuar saktësinë e vendndodhjes dhe për qëllime të tjera, <xliff:g id="APP_NAME">%1$s</xliff:g> dëshiron të aktivizojë skanimin e rrjetit, edhe kur Wi-Fi është joaktiv.\n\nTë lejohet kjo për të gjitha aplikacionet që dëshirojnë të skanojnë?"</string>
    <string name="wifi_scan_always_turn_on_message_unknown" msgid="6162424298483845679">"Për të përmirësuar saktësinë e vendndodhjes dhe për qëllime të tjera, një aplikacion i panjohur dëshiron të aktivizojë skanimin e rrjetit, edhe kur Wi-Fi është joaktiv.\n\nTë lejohet kjo për të gjitha aplikacionet që dëshirojnë të skanojnë?"</string>
    <string name="wifi_scan_always_turnoff_message" msgid="5538901671131941043">"Për ta çaktivizuar këtë, shko te \"Të përparuara\" në menynë e tejkalimit."</string>
    <string name="wifi_scan_always_confirm_allow" msgid="5355973075896817232">"Lejo"</string>
    <string name="wifi_scan_always_confirm_deny" msgid="4463982053823520710">"Refuzo"</string>
    <string name="wifi_hotspot_title" msgid="7726205804813286950">"Dëshiron të identifikohesh për t\'u lidhur?"</string>
    <string name="wifi_hotspot_message" msgid="3673833421453455747">"<xliff:g id="APP_NAME">%1$s</xliff:g> kërkon që të identifikohesh në linjë para se të lidhesh me rrjetin."</string>
    <string name="wifi_hotspot_connect" msgid="5065506390164939225">"LIDHE"</string>
    <string name="no_internet_access_text" msgid="5926979351959279577">"Ky rrjet nuk ka qasje në internet. Dëshiron të qëndrosh i lidhur?"</string>
    <string name="partial_connectivity_text" msgid="1287030663891772340">"Disa aplikacione dhe shërbime mund të mos funksionojnë për shkak të lidhshmërisë së kufizuar. Do ta përdorësh gjithsesi?"</string>
    <string name="no_internet_access_remember" msgid="4697314331614625075">"Mos pyet përsëri për këtë rrjet"</string>
    <string name="lost_internet_access_title" msgid="5779478650636392426">"Wi-Fi nuk është i lidhur me internetin"</string>
    <string name="lost_internet_access_text" msgid="9029649339816197345">"Mund të kalosh në rrjetin celular sa herë që Wi‑Fi ka një lidhje të keqe. Mund të zbatohen tarifime për përdorimin e të dhënave."</string>
    <string name="lost_internet_access_switch" msgid="2262459569601190039">"Kalo te rrjeti celular"</string>
    <string name="lost_internet_access_cancel" msgid="338273139419871110">"Qëndro në Wi‑Fi"</string>
    <string name="lost_internet_access_persist" msgid="7634876061262676255">"Kurrë mos e trego përsëri"</string>
    <string name="wifi_connect" msgid="1076622875777072845">"Lidh"</string>
    <string name="wifi_turned_on_message" msgid="4432839393213448846">"Wi-Fi është i aktivizuar"</string>
    <!-- no translation found for wifi_connected_to_message (2265022072754345638) -->
    <skip />
    <string name="wifi_connecting" msgid="8760426806460651215">"Po lidhet…"</string>
    <!-- no translation found for wifi_disconnect (3445234285136039895) -->
    <skip />
    <string name="wifi_failed_connect_message" msgid="8491902558970292871">"Lidhja me rrjetin dështoi"</string>
    <string name="wifi_not_in_range_message" msgid="6616864204007424228">"Rrjeti nuk është brenda rrezes"</string>
    <string name="wifi_forget" msgid="8168174695608386644">"Harro"</string>
    <string name="wifi_modify" msgid="6100248070440710782">"Modifiko"</string>
    <string name="wifi_failed_forget_message" msgid="1348172929201654986">"Dështoi në harrimin e rrjetit"</string>
    <string name="wifi_save" msgid="3331121567988522826">"Ruaj"</string>
    <string name="wifi_failed_save_message" msgid="6650004874143815692">"Dështoi në ruajtjen e rrjetit"</string>
    <string name="wifi_cancel" msgid="6763568902542968964">"Anulo"</string>
    <string name="wifi_forget_dialog_title" msgid="6224151903586192426">"Dëshiron ta harrosh rrjetin?"</string>
    <string name="wifi_forget_dialog_message" msgid="2337060138532166680">"Të gjitha fjalëkalimet për këtë rrjet do të fshihen"</string>
    <plurals name="wifi_saved_access_points_summary" formatted="false" msgid="6094679048871529675">
      <item quantity="other">%d rrjete</item>
      <item quantity="one">1 rrjet</item>
    </plurals>
    <plurals name="wifi_saved_passpoint_access_points_summary" formatted="false" msgid="8256430439661111672">
      <item quantity="other">%d abonime</item>
      <item quantity="one">1 abonim</item>
    </plurals>
    <plurals name="wifi_saved_all_access_points_summary" formatted="false" msgid="2504425359919617586">
      <item quantity="other">%d rrjete dhe abonime</item>
      <item quantity="one">1 rrjet dhe abonim</item>
    </plurals>
    <string name="wifi_advanced_titlebar" msgid="4485841401774142908">"Cilësimet e Wi‑Fi"</string>
    <string name="wifi_advanced_ssid_title" msgid="1552309166043760291">"SSID"</string>
    <string name="wifi_advanced_mac_address_title" msgid="6571335466330978393">"Adresa MAC"</string>
    <string name="wifi_advanced_ip_address_title" msgid="6215297094363164846">"Adresa e IP-së"</string>
    <string name="wifi_details_title" msgid="8954667664081737098">"Detajet e rrjetit"</string>
    <string name="wifi_details_subnet_mask" msgid="6720279144174924410">"Maska e nënrrjetit"</string>
    <string name="wifi_details_dns" msgid="8648826607751830768">"DNS"</string>
    <string name="wifi_details_ipv6_address_header" msgid="6734119149106422148">"Adresat IPv6"</string>
    <string name="wifi_saved_access_points_label" msgid="2013409399392285262">"Rrjetet e ruajtura"</string>
    <string name="wifi_subscribed_access_points_tab" msgid="6480224551765489055">"Abonimet"</string>
    <!-- no translation found for wifi_saved_access_points_tab (2659675386657663705) -->
    <skip />
    <string name="wifi_advanced_settings_label" msgid="3654366894867838338">"Cilësimet e IP-së"</string>
    <string name="wifi_advanced_not_available" msgid="5823045095444154586">"Cilësimet e Wi-Fi nuk disponohen për këtë përdorues"</string>
    <string name="wifi_ip_settings_menu_save" msgid="7296724066102908366">"Ruaj"</string>
    <string name="wifi_ip_settings_menu_cancel" msgid="6582567330136502340">"Anulo"</string>
    <string name="wifi_ip_settings_invalid_ip_address" msgid="2513142355364274970">"Shkruaj një adresë të vlefshme IP-je."</string>
    <string name="wifi_ip_settings_invalid_gateway" msgid="8164264988361096450">"Shkruaj një adresë të vlefshme porte kalimi."</string>
    <string name="wifi_ip_settings_invalid_dns" msgid="8744583948328391047">"Shkruaj një adresë të vlefshme DNS-je."</string>
    <string name="wifi_ip_settings_invalid_network_prefix_length" msgid="40470058023181052">"Shkruaj një gjatësi prefiksi rrjeti mes 0 dhe 32."</string>
    <string name="wifi_dns1" msgid="7344118050720080045">"DNS 1"</string>
    <string name="wifi_dns2" msgid="1368601006824882659">"DNS 2"</string>
    <string name="wifi_gateway" msgid="163914742461092086">"Porta e kalimit"</string>
    <string name="wifi_network_prefix_length" msgid="3028785234245085998">"Gjatësia e prefiksit të rrjetit"</string>
    <string name="wifi_p2p_settings_title" msgid="5444461191435291082">"Wi-Fi Direct"</string>
    <string name="wifi_p2p_device_info" msgid="3191876744469364173">"Informacioni i pajisjes"</string>
    <string name="wifi_p2p_persist_network" msgid="1646424791818168590">"Kujtoje këtë lidhje"</string>
    <string name="wifi_p2p_menu_search" msgid="3436429984738771974">"Kërko pajisje"</string>
    <string name="wifi_p2p_menu_searching" msgid="2396704492143633876">"Po kërkon..."</string>
    <string name="wifi_p2p_menu_rename" msgid="8448896306960060415">"Riemërto pajisjen"</string>
    <string name="wifi_p2p_peer_devices" msgid="299526878463303432">"Pajisjet homologe"</string>
    <string name="wifi_p2p_remembered_groups" msgid="3847022927914068230">"Grupet r ruajtura në memorie"</string>
    <string name="wifi_p2p_failed_connect_message" msgid="8491862096448192157">"Nuk mund të lidhej."</string>
    <string name="wifi_p2p_failed_rename_message" msgid="2562182284946936380">"Riemërtimi i pajisjes dështoi."</string>
    <string name="wifi_p2p_disconnect_title" msgid="3216846049677448420">"Të shkëputet?"</string>
    <string name="wifi_p2p_disconnect_message" msgid="8227342771610125771">"Nëse shkëputesh, lidhja me <xliff:g id="PEER_NAME">%1$s</xliff:g> do të mbyllet."</string>
    <string name="wifi_p2p_disconnect_multiple_message" msgid="3283805371034883105">"Nëse shkëputesh, lidhja jote me <xliff:g id="PEER_NAME">%1$s</xliff:g> dhe <xliff:g id="PEER_COUNT">%2$s</xliff:g> pajisje të tjera do të përfundojë."</string>
    <string name="wifi_p2p_cancel_connect_title" msgid="255267538099324413">"Të anulohet ftesa?"</string>
    <string name="wifi_p2p_cancel_connect_message" msgid="7477756213423749402">"Dëshiron të anulosh ftesën për t\'u lidhur me <xliff:g id="PEER_NAME">%1$s</xliff:g>?"</string>
    <string name="wifi_p2p_delete_group_message" msgid="834559380069647086">"Të harrohet ky grup?"</string>
    <string name="wifi_hotspot_checkbox_text" msgid="7763495093333664887">"Zonë e lirë qasjeje për Wi-Fi"</string>
    <string name="wifi_hotspot_off_subtext" msgid="2199911382555864644">"Nuk po ndan internetin ose përmbajtje me pajisjet e tjera"</string>
    <string name="wifi_hotspot_tethering_on_subtext" product="tablet" msgid="5936710887156133458">"Po ndan lidhjen e internetit të këtij tableti nëpërmjet zonës së qasjes së internetit"</string>
    <string name="wifi_hotspot_tethering_on_subtext" product="default" msgid="5556202634866621632">"Po ndan lidhjen e internetit të këtij telefoni nëpërmjet zonës së qasjes së internetit"</string>
    <string name="wifi_hotspot_on_local_only_subtext" msgid="5017191966153008">"Aplikacioni po ndan përmbajtje. Për të ndarë lidhjen e internetit, çaktivizo zonën e qasjes së internetit dhe më pas aktivizoje përsëri."</string>
    <string name="wifi_hotspot_no_password_subtext" msgid="353306131026431089">"Nuk është caktuar fjalëkalim"</string>
    <string name="wifi_hotspot_name_title" msgid="8237000746618636778">"Emri i zonës së qasjes për internet"</string>
    <string name="wifi_hotspot_name_summary_connecting" msgid="3378299995508671967">"<xliff:g id="WIFI_HOTSPOT_NAME">%1$s</xliff:g> po aktivizohet..."</string>
    <string name="wifi_hotspot_name_summary_connected" msgid="3888672084861445362">"Pajisjet e tjera mund të lidhen me <xliff:g id="WIFI_HOTSPOT_NAME">%1$s</xliff:g>"</string>
    <string name="wifi_hotspot_password_title" msgid="8676859981917573801">"Fjalëkalimi i zonës së qasjes për internet"</string>
    <string name="wifi_hotspot_ap_band_title" msgid="1165801173359290681">"Banda AP"</string>
    <string name="wifi_hotspot_footer_info_regular" msgid="4789553667374849566">"Përdor zonën e qasjes së internetit për të krijuar një rrjet Wi‑Fi për pajisjet e tua të tjera. Zona e qasjes e internetit ofron internet duke përdorur lidhjen e të dhënave celulare. Mund të zbatohen tarifa shtesë për të dhënat celulare."</string>
    <string name="wifi_hotspot_footer_info_local_only" msgid="857988412470694109">"Aplikacionet mund të krijojnë një zonë qasjeje të internetit për të ndarë përmbajtje me pajisjet në afërsi."</string>
    <string name="wifi_hotspot_auto_off_title" msgid="1590313508558948079">"Çaktivizo automatikisht zonën e qasjes për internet"</string>
    <string name="wifi_hotspot_auto_off_summary" msgid="5858098059725925084">"Zona e qasjes për internet e Wi‑Fi do të çaktivizohet nëse nuk është lidhur asnjë pajisje"</string>
    <string name="wifi_tether_starting" msgid="1322237938998639724">"Po aktivizon zonën e qasjes..."</string>
    <string name="wifi_tether_stopping" msgid="4835852171686388107">"Po çaktivizon zonën e qasjes..."</string>
    <string name="wifi_tether_enabled_subtext" msgid="7842111748046063857">"<xliff:g id="NETWORK_SSID">%1$s</xliff:g> është aktiv"</string>
    <string name="wifi_tether_failed_subtext" msgid="1484941858530919002">"Gabim në zonën e lirë të qasjes Wi-Fi"</string>
    <string name="wifi_tether_configure_ap_text" msgid="7974681394041609308">"Konfiguro zonën e qasjes Wi‑Fi"</string>
    <string name="wifi_hotspot_configure_ap_text" msgid="5478614731464220432">"Konfigurimi i zonës së qasjes Wi‑Fi"</string>
    <string name="wifi_hotspot_configure_ap_text_summary" msgid="5560680057727007011">"Zona e qasjes e AndroidAP WPA2 PSK"</string>
    <string name="wifi_tether_configure_ssid_default" msgid="8467525402622138547">"Zona Android e qasjes së lirë për internet"</string>
    <string name="wifi_calling_settings_title" msgid="4102921303993404577">"Telefonata me Wi-Fi"</string>
    <string name="wifi_calling_suggestion_title" msgid="5702964371483390024">"Zgjero telefonatat me Wi‑Fi"</string>
    <string name="wifi_calling_suggestion_summary" msgid="1331793267608673739">"Aktivizo telefonatat me Wi‑Fi për të zgjeruar mbulimin"</string>
    <string name="wifi_calling_mode_title" msgid="2164073796253284289">"Preferenca e telefonatës"</string>
    <string name="wifi_calling_mode_dialog_title" msgid="7105195222267749226">"Preferenca për telefonatën"</string>
    <string name="wifi_calling_roaming_mode_title" msgid="1565039047187685115">"Preferenca e roaming-ut"</string>
    <!-- no translation found for wifi_calling_roaming_mode_summary (8642014873060687717) -->
    <skip />
    <string name="wifi_calling_roaming_mode_dialog_title" msgid="7800926602662078576">"Preferenca e roaming-ut"</string>
  <string-array name="wifi_calling_mode_choices_v2">
    <item msgid="742988808283756263">"Wi-Fi"</item>
    <item msgid="7715869266611010880">"Celular"</item>
    <item msgid="2838022395783120596">"Vetëm Wi-Fi"</item>
  </string-array>
  <string-array name="wifi_calling_mode_choices_v2_without_wifi_only">
    <item msgid="6132150507201243768">"Wi-Fi"</item>
    <item msgid="1118703915148755405">"Celular"</item>
  </string-array>
    <string name="wifi_calling_mode_wifi_preferred_summary" msgid="9092988115148569860">"Nëse Wi‑Fi nuk ofrohet, përdor rrjetin celular"</string>
    <string name="wifi_calling_mode_cellular_preferred_summary" msgid="240885549023046403">"Nëse rrjeti celular nuk ofrohet, përdor Wi‑Fi"</string>
    <string name="wifi_calling_mode_wifi_only_summary" msgid="3688265826855460036">"Telefono nëpërmjet Wi-Fi. Nëse humb Wi‑Fi, telefonata do të mbyllet."</string>
    <string name="wifi_calling_off_explanation" msgid="564780186974911501">"Kur telefonata me Wi-Fi është e aktivizuar, telefoni mund t\'i kalojë telefonatat nëpërmjet rrjeteve Wi-Fi ose nëpërmjet rrjetit të operatorit celular, në varësi të preferencës dhe se cili sinjal është më i fortë. Para se të aktivizosh këtë funksion, kontakto me operatorin celular në lidhje me tarifat dhe detaje të tjera.<xliff:g id="ADDITIONAL_TEXT">%1$s</xliff:g>"</string>
    <string name="wifi_calling_off_explanation_2" msgid="2329334487851497223"></string>
    <string name="emergency_address_title" msgid="932729250447887545">"Adresa e urgjencës"</string>
    <string name="emergency_address_summary" msgid="7751971156196115129">"Përdoret si vendndodhja jote kur kryen një telefonatë urgjence me Wi‑Fi"</string>
    <string name="private_dns_help_message" msgid="3299567069152568958"><annotation id="url">"Mëso më shumë"</annotation>" rreth funksioneve të \"DNS-së private\""</string>
    <string name="wifi_calling_pref_managed_by_carrier" msgid="6845711858866828986">"Cilësimi menaxhohet nga operatori celular"</string>
    <string name="wifi_calling_settings_activation_instructions" msgid="7492509632478260955">"Aktivizo \"Telefonatën me Wi-Fi\""</string>
    <string name="wifi_calling_turn_on" msgid="1171403510313983983">"Aktivizo \"Telefonatën me Wi-Fi\""</string>
    <string name="wifi_calling_not_supported" msgid="7878640438907807754">"\"Telefonata me Wi‑Fi\" nuk mbështetet për %1$s"</string>
    <string name="carrier" msgid="5264014738689761132">"Operatori celular"</string>
    <string name="display_settings_title" msgid="1708697328627382561">"Paraqitja"</string>
    <string name="sound_settings" msgid="5534671337768745343">"Tingulli"</string>
    <string name="all_volume_title" msgid="4296957391257836961">"Volumet"</string>
    <string name="musicfx_title" msgid="3415566786340790345">"Efektet e muzikës"</string>
    <string name="ring_volume_title" msgid="5592466070832128777">"Volumi i ziles"</string>
    <string name="vibrate_in_silent_title" msgid="3897968069156767036">"Dridhje kur është \"në heshtje\""</string>
    <string name="notification_sound_title" msgid="5137483249425507572">"Zëri i parazgjedhur i njoftimit"</string>
    <string name="incoming_call_volume_title" msgid="8073714801365904099">"Toni i ziles"</string>
    <string name="notification_volume_title" msgid="2012640760341080408">"Njoftimi"</string>
    <string name="checkbox_notification_same_as_incoming_call" msgid="1073644356290338921">"Përdor volumin e telefonatës hyrëse për njoftime"</string>
    <string name="home_work_profile_not_supported" msgid="1357721012342357037">"Profilet e punës nuk mbështeten"</string>
    <string name="notification_sound_dialog_title" msgid="3805140135741385667">"Tingulli i parazgjedhur i njoftimit"</string>
    <string name="media_volume_title" msgid="3576565767317118106">"Media"</string>
    <string name="media_volume_summary" msgid="5363248930648849974">"Cakto volumin për muzikë dhe video"</string>
    <string name="alarm_volume_title" msgid="2285597478377758706">"Alarmi"</string>
    <string name="dock_settings_summary" msgid="455802113668982481">"Cilësimet e audios për stacionin e bashkëngjitur"</string>
    <string name="dtmf_tone_enable_title" msgid="8533399267725365088">"Tonet e bllokut të tasteve"</string>
    <string name="sound_effects_enable_title" msgid="4429690369187229592">"Tingujt e trokitjes"</string>
    <string name="lock_sounds_enable_title" msgid="450098505659399520">"Tingulli i kyçjes së ekranit"</string>
    <string name="audio_record_proc_title" msgid="4271091199976457534">"Anulimi i zhurmës"</string>
    <string name="volume_media_description" msgid="7949355934788807863">"Muzikë, video, lojëra dhe media të tjera"</string>
    <string name="volume_ring_description" msgid="5936851631698298989">"Toni i ziles dhe njoftimet"</string>
    <string name="volume_notification_description" msgid="5810902320215328321">"Njoftimet"</string>
    <string name="volume_alarm_description" msgid="8322615148532654841">"Alarmet"</string>
    <string name="volume_ring_mute" msgid="3018992671608737202">"Hiq tingullin e ziles dhe njoftimeve"</string>
    <string name="volume_media_mute" msgid="3399059928695998166">"Çaktivizo zërin për muzikën dhe \"mediat\" e tjera"</string>
    <string name="volume_notification_mute" msgid="7955193480006444159">"Vendosi në heshtje njoftimet"</string>
    <string name="volume_alarm_mute" msgid="4452239420351035936">"Çaktivizo zërin e alarmeve"</string>
    <string name="dock_settings" msgid="1820107306693002541">"lidh me stacionin"</string>
    <string name="dock_settings_title" msgid="9161438664257429372">"Cilësimet e stacionit"</string>
    <string name="dock_audio_settings_title" msgid="3324750259959570305">"Audio"</string>
    <string name="dock_audio_summary_desk" msgid="6487784412371139335">"Cilësimet për stacionin e lidhur të desktopit"</string>
    <string name="dock_audio_summary_car" msgid="6740897586006248450">"Cilësimet për stacionin e lidhur të makinës"</string>
    <string name="dock_audio_summary_none" product="tablet" msgid="8215337394914283607">"Tableti nuk u stacionua"</string>
    <string name="dock_audio_summary_none" product="default" msgid="289909253741048784">"Telefoni nuk u stacionua"</string>
    <string name="dock_audio_summary_unknown" msgid="4465059868974255693">"Cilësimet për stacionin e lidhur"</string>
    <string name="dock_not_found_title" msgid="3290961741828952424">"Stacioni nuk u gjet"</string>
    <string name="dock_not_found_text" product="tablet" msgid="8405432495282299143">"Duhet të futësh tabletin në stacion para se të konfigurosh audion e stacionit."</string>
    <string name="dock_not_found_text" product="default" msgid="1460497923342627801">"Duhet të vendosësh telefonin te stacioni para se të konfigurosh audion e stacionit."</string>
    <string name="dock_sounds_enable_title" msgid="885839627097024110">"Tingulli i vendosjes në stacion"</string>
    <string name="dock_sounds_enable_summary_on" product="tablet" msgid="838102386448981339">"Lësho një tingull kur futet ose hiqet tableti nga stacioni"</string>
    <string name="dock_sounds_enable_summary_on" product="default" msgid="8491180514199743771">"Lësho një tingull kur futet ose hiqet telefoni nga stacioni"</string>
    <string name="dock_sounds_enable_summary_off" product="tablet" msgid="4308252722466813560">"Mos lësho asnjë tingull kur futet ose hiqet tableti nga stacioni"</string>
    <string name="dock_sounds_enable_summary_off" product="default" msgid="2034927992716667672">"Mos lësho asnjë tingull kur futet ose hiqet telefoni nga stacioni"</string>
    <string name="account_settings" msgid="6403589284618783461">"Llogaritë"</string>
    <string name="accessibility_category_work" msgid="4339262969083355720">"Llogaritë e profilit të punës - <xliff:g id="MANAGED_BY">%s</xliff:g>"</string>
    <string name="accessibility_category_personal" msgid="1263518850905945594">"Llogaritë e profilit personal"</string>
    <string name="accessibility_work_account_title" msgid="1231830766637939527">"Llogari pune - <xliff:g id="MANAGED_BY">%s</xliff:g>"</string>
    <string name="accessibility_personal_account_title" msgid="2169071663029067826">"Llogari personale - <xliff:g id="MANAGED_BY">%s</xliff:g>"</string>
    <string name="search_settings" msgid="1910951467596035063">"Kërko"</string>
    <string name="display_settings" msgid="7965901687241669598">"Ekrani"</string>
    <string name="accelerometer_title" msgid="7854608399547349157">"Ekran me rrotullim automatik"</string>
    <string name="color_mode_title" msgid="9186249332902370471">"Ngjyrat"</string>
    <string name="color_mode_option_natural" msgid="5013837483986772758">"Natyrale"</string>
    <string name="color_mode_option_boosted" msgid="8588223970257287524">"Të theksuara"</string>
    <string name="color_mode_option_saturated" msgid="4569683960058798843">"E gjallë"</string>
    <string name="color_mode_option_automatic" msgid="7996505473528529568">"Me përshtatje"</string>
    <string name="color_mode_summary_natural" msgid="6624188642920403099">"Përdor vetëm ngjyrat e sakta"</string>
    <string name="color_mode_summary_automatic" msgid="4669516973360709431">"Rregullo mes ngjyrave të gjalla dhe të sakta"</string>
    <string name="accelerometer_summary_on" product="tablet" msgid="429982132339828942">"Ndërro orientimin automatikisht kur rrotullon tabletin"</string>
    <string name="accelerometer_summary_on" product="default" msgid="1133737282813048021">"Ndrysho automatikisht orientimin kur rrotullon telefonin"</string>
    <string name="accelerometer_summary_off" product="tablet" msgid="4781734213242521682">"Ndërro orientimin automatikisht kur rrotullon tabletin"</string>
    <string name="accelerometer_summary_off" product="default" msgid="5485489363715740761">"Ndrysho orientimin automatik kur rrotullon telefonin"</string>
    <string name="brightness" msgid="8480105032417444275">"Niveli i ndriçimit"</string>
    <string name="brightness_title" msgid="5746272622112982836">"Ndriçimi"</string>
    <string name="brightness_summary" msgid="838917350127550703">"Rregullo ndriçimin e ekranit"</string>
    <string name="auto_brightness_title" msgid="6341042882350279391">"Ndriçimi i përshtatshëm"</string>
    <string name="auto_brightness_summary" msgid="5652108419977937800">"Ndriçimi i ekranit përshtatet me ambientin"</string>
    <string name="auto_brightness_summary_on" msgid="3519854265558828744">"Aktiv"</string>
    <string name="auto_brightness_summary_off" msgid="2802336459335410626">"Joaktiv"</string>
    <string name="auto_brightness_summary_very_low" msgid="6483976609035853764">"Ndriçimi i preferuar është shumë i ulët"</string>
    <string name="auto_brightness_summary_low" msgid="5609877905833960427">"Ndriçimi i preferuar është i ulët"</string>
    <string name="auto_brightness_summary_default" msgid="7225666614394726845">"Ndriçimi i preferuar është i parazgjedhur"</string>
    <string name="auto_brightness_summary_high" msgid="7172304165631136027">"Ndriçimi i preferuar është i lartë"</string>
    <string name="auto_brightness_summary_very_high" msgid="979277812582279078">"Ndriçimi i preferuar është shumë i lartë"</string>
    <string name="auto_brightness_off_title" msgid="2996864829946190795">"Joaktiv"</string>
    <string name="auto_brightness_very_low_title" msgid="8252988638614126320">"Shumë i ulët"</string>
    <string name="auto_brightness_low_title" msgid="1632186441514863377">"I ulët"</string>
    <string name="auto_brightness_default_title" msgid="936771997353506620">"I parazgjedhur"</string>
    <string name="auto_brightness_high_title" msgid="2527853305981497345">"I lartë"</string>
    <string name="auto_brightness_very_high_title" msgid="8867164854439331022">"Shumë i lartë"</string>
    <string name="auto_brightness_subtitle" msgid="6454652530864093466">"Niveli yt i preferuar i ndriçimit"</string>
    <string name="auto_brightness_off_summary" msgid="7629228736838155268">"Mos e rregullo sipas dritës së ambientit"</string>
    <string name="auto_brightness_very_high_summary" msgid="4551003097086220709">"Përdorimi i rritur i baterisë"</string>
    <string name="auto_brightness_disclaimer" msgid="871436423746343406">"Optimizo nivelin e ndriçimit sipas dritës së ambientit. Kur ky funksion është aktiv, mund ta rregullosh përsëri përkohësisht ndriçimin."</string>
    <string name="auto_brightness_description" msgid="7310335517128283729">"Ndriçimi i ekranit tënd do t\'i përshtatet automatikisht mjedisit dhe aktiviteteve të tua. Mund ta lëvizësh rrëshqitësin manualisht për të ndihmuar ndriçimin përshtatës që të mësojë preferencat e tua."</string>
    <string name="display_white_balance_title" msgid="4093966473741329340">"Shfaq balancimin e të bardhës"</string>
    <string name="display_white_balance_summary" msgid="2432539678792029039"></string>
    <string name="adaptive_sleep_title" msgid="455088457232472047">"Vëmendja ndaj ekranit"</string>
    <string name="adaptive_sleep_summary_on" msgid="410222811715459549">"Aktiv / Ekrani nuk do të fiket nëse shikon tek ai"</string>
    <string name="adaptive_sleep_summary_off" msgid="3099674463517017514">"Joaktiv"</string>
    <string name="adaptive_sleep_title_no_permission" msgid="7893003608238361004">"Nevojitet qasja te kamera"</string>
    <string name="adaptive_sleep_summary_no_permission" msgid="2875851728693203108">"Trokit për të menaxhuar autorizimet për \"Shërbimet e personalizimit të pajisjes\""</string>
    <string name="adaptive_sleep_description" msgid="3741651460279997459">"Parandalon fikjen e ekranit nëse shikon tek ai"</string>
    <string name="adaptive_sleep_privacy" msgid="5335695648960686765">"Vëmendja ndaj ekranit përdor kamerën e përparme për të parë nëse dikush po shikon tek ekrani. Funksionon në pajisje dhe imazhet nuk dërgohen apo ruhen asnjëherë te Google."</string>
    <string name="adaptive_sleep_contextual_slice_summary" msgid="6922838078388927214">"Mbaje ekranin aktiv kur e shikon"</string>
    <string name="night_display_title" msgid="2626451512200357686">"Drita e natës"</string>
    <string name="night_display_text" msgid="1837277457033025056">"Drita e natës e ngjyros ekranin në ngjyrë qelibari. Kjo e bën më të lehtë shikimin e ekranit ose leximin në dritë të zbehtë dhe mund të të ndihmojë të flesh gjumë më lehtë."</string>
    <string name="night_display_auto_mode_title" msgid="6574111412154833409">"Planifikimi"</string>
    <string name="night_display_auto_mode_never" msgid="2483761922928753400">"Asnjë"</string>
    <string name="night_display_auto_mode_custom" msgid="2379394568898721765">"Aktivizohet në kohë të personalizuar"</string>
    <string name="night_display_auto_mode_twilight" msgid="589042813708244059">"Aktivizohet nga perëndimi deri në agim"</string>
    <string name="night_display_start_time_title" msgid="8918016772613689584">"Koha e nisjes"</string>
    <string name="night_display_end_time_title" msgid="8286061578083519350">"Koha e përfundimit"</string>
    <string name="night_display_status_title" msgid="1784041143360286267">"Statusi"</string>
    <string name="night_display_temperature_title" msgid="1435292789272017136">"Intensiteti"</string>
    <string name="night_display_summary_off" msgid="1792750041697946539">"Joaktiv / <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="night_display_summary_off_auto_mode_never" msgid="3583590137322963513">"Nuk do të aktivizohet asnjëherë automatikisht"</string>
    <string name="night_display_summary_off_auto_mode_custom" msgid="6365668239253173208">"Do të aktivizohet automatikisht në <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="night_display_summary_off_auto_mode_twilight" msgid="3596291693781757392">"Do të aktivizohet automatikisht kur të perëndojë dielli"</string>
    <string name="night_display_summary_on" msgid="1355713529996456744">"Aktiv / <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="night_display_summary_on_auto_mode_never" msgid="9117830821363119835">"Nuk do të çaktivizohet asnjëherë automatikisht"</string>
    <string name="night_display_summary_on_auto_mode_custom" msgid="5510753572245577263">"Do të çaktivizohet automatikisht në <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="night_display_summary_on_auto_mode_twilight" msgid="852270120144683507">"Do të çaktivizohet automatikisht në agim"</string>
    <string name="night_display_activation_on_manual" msgid="277343561277625826">"Aktivizo tani"</string>
    <string name="night_display_activation_off_manual" msgid="4074557720918572883">"Çaktivizo tani"</string>
    <string name="night_display_activation_on_twilight" msgid="6976051971534953845">"Aktivizo deri në lindjen e diellit"</string>
    <string name="night_display_activation_off_twilight" msgid="7196227685059907233">"Çaktivizo deri në perëndim të diellit"</string>
    <string name="night_display_activation_on_custom" msgid="5472029024427933598">"Çaktivizo deri në <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="night_display_activation_off_custom" msgid="6169984658293744715">"Çaktivizo deri në <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="night_display_not_currently_on" msgid="6273540991113206401">"\"Drita e natës\" aktualisht nuk është aktive"</string>
    <string name="screen_timeout" msgid="4882669461447531301">"Koha e pritjes së ekranit"</string>
    <string name="screen_timeout_title" msgid="5130038655092628247">"Ekrani çaktivizohet"</string>
    <string name="screen_timeout_summary" msgid="327761329263064327">"Pas <xliff:g id="TIMEOUT_DESCRIPTION">%1$s</xliff:g> pa aktivitet"</string>
    <string name="wallpaper_settings_title" msgid="5449180116365824625">"Imazhi i sfondit"</string>
    <string name="style_and_wallpaper_settings_title" msgid="3608097576881470764">"Stilet dhe imazhet e sfondit"</string>
    <string name="wallpaper_settings_summary_default" msgid="3395741565658711416">"I parazgjedhur"</string>
    <string name="wallpaper_settings_summary_custom" msgid="515035303981687172">"I personalizuar"</string>
    <string name="wallpaper_suggestion_title" msgid="8583988696513822528">"Ndrysho imazhin e sfondit"</string>
    <string name="wallpaper_suggestion_summary" msgid="1579144009898110491">"Personalizo ekranin"</string>
    <string name="wallpaper_settings_fragment_title" msgid="519078346877860129">"Zgjidh imazhin e sfondit nga"</string>
    <string name="style_suggestion_title" msgid="4710867417147087928">"Personalizo Pixel"</string>
    <string name="style_suggestion_summary" msgid="1811974280164432649">"Provo stile, imazhe sfondi të ndryshme etj."</string>
    <string name="screensaver_settings_title" msgid="1770575686476851778">"Mbrojtësi i ekranit"</string>
    <string name="screensaver_settings_summary_either_long" msgid="7302740999250873332">"Gjatë karikimit ose lidhjes me stacionin"</string>
    <string name="screensaver_settings_summary_either_short" msgid="6140527286137331478">"Në të dyja rastet"</string>
    <string name="screensaver_settings_summary_sleep" msgid="9086186698140423493">"Gjatë karikimit"</string>
    <string name="screensaver_settings_summary_dock" msgid="2072657401664633283">"Kur vendoset në stacion"</string>
    <string name="screensaver_settings_summary_never" msgid="5165622985174349585">"Asnjëherë"</string>
    <string name="screensaver_settings_summary_off" msgid="2481581696365146473">"Çaktivizuar"</string>
    <string name="screensaver_settings_disabled_prompt" msgid="1239088321034437608">"Për të kontrolluar se çfarë ndodh kur telefonin e vendos te stacioni dhe/ose në gjumë, aktivizo mbrojtësin e ekranit."</string>
    <string name="screensaver_settings_when_to_dream" msgid="7262410541382890146">"Kur të fillojë"</string>
    <string name="screensaver_settings_current" msgid="4663846038247130023">"Mbrojtësi aktual i ekranit"</string>
    <string name="screensaver_settings_dream_start" msgid="4998187847985120168">"Fillo tani"</string>
    <string name="screensaver_settings_button" msgid="7292214707625717013">"Cilësimet"</string>
    <string name="automatic_brightness" msgid="5014143533884135461">"Ndriçimi automatik"</string>
    <string name="lift_to_wake_title" msgid="4555378006856277635">"Ngrije për ta zgjuar"</string>
    <string name="ambient_display_screen_title" msgid="4252755516328775766">"Shfaqja e ambientit"</string>
    <string name="ambient_display_category_triggers" msgid="4359289754456268573">"Kur të shfaqet"</string>
    <string name="doze_title" msgid="2375510714460456687">"Njoftimet e reja"</string>
    <string name="doze_summary" msgid="3846219936142814032">"Zgjoje ekranin kur të merren njoftime"</string>
    <string name="doze_always_on_title" msgid="1046222370442629646">"Gjithmonë aktiv"</string>
    <string name="doze_always_on_summary" msgid="6978257596231155345">"Shfaq orën, ikonat e njoftimeve dhe informacione të tjera. Përdorim i rritur i baterisë."</string>
    <string name="title_font_size" msgid="4405544325522105222">"Madhësia e shkrimit"</string>
    <string name="short_summary_font_size" msgid="6819778801232989076">"Bëje tekstin më të madh ose më të vogël"</string>
    <string name="sim_lock_settings" msgid="3392331196873564292">"Kyçja e kartës SIM"</string>
    <string name="sim_lock_settings_category" msgid="6242052161214271091">"Kyçja e kartës SIM"</string>
    <string name="sim_lock_settings_summary_off" msgid="8028944267104896401">"Joaktive"</string>
    <string name="sim_lock_settings_summary_on" msgid="39103355956342985">"Kyçur"</string>
    <string name="sim_lock_settings_title" msgid="9018585580955414596">"Kyçja e kartës SIM"</string>
    <string name="sim_pin_toggle" msgid="1742123478029451888">"Kyçe kartën SIM"</string>
    <string name="sim_lock_on" product="tablet" msgid="5058355081270397764">"Kërko kodin PIN për të përdorur tabletin"</string>
    <string name="sim_lock_on" product="default" msgid="2503536505568814324">"Kërko kod PIN për të përdorur telefonin"</string>
    <string name="sim_lock_off" product="tablet" msgid="2813800553917012356">"Kërko kodin PIN për të përdorur tabletin"</string>
    <string name="sim_lock_off" product="default" msgid="258981978215428916">"Kërko kod PIN për të përdorur telefonin"</string>
    <string name="sim_pin_change" msgid="6311414184279932368">"Ndrysho PIN-in e kartës SIM"</string>
    <string name="sim_enter_pin" msgid="6608715137008508432">"PIN-i i kartës SIM"</string>
    <string name="sim_enable_sim_lock" msgid="4517742794997166918">"Kyçe kartën SIM"</string>
    <string name="sim_disable_sim_lock" msgid="7664729528754784824">"Shkyçe kartën SIM"</string>
    <string name="sim_enter_old" msgid="6074196344494634348">"Kodi i vjetër PIN i kartës SIM"</string>
    <string name="sim_enter_new" msgid="8742727032729243562">"PIN-i i ri i kartës SIM"</string>
    <string name="sim_reenter_new" msgid="6523819386793546888">"Shkruaj përsëri kodin e ri PIN"</string>
    <string name="sim_change_pin" msgid="7328607264898359112">"Kodi PIN i kartës SIM"</string>
    <string name="sim_bad_pin" msgid="2345230873496357977">"Kodi PIN është i pasaktë"</string>
    <string name="sim_pins_dont_match" msgid="1695021563878890574">"Kodet PIN nuk përputhen"</string>
    <string name="sim_change_failed" msgid="3602072380172511475">"Kodi PIN nuk ndryshoi.\nKod PIN i gabuar."</string>
    <string name="sim_change_succeeded" msgid="8556135413096489627">"PIN-i i kartës SIM u ndryshua me sukses."</string>
    <string name="sim_lock_failed" msgid="2489611099235575984">"Karta SIM ende e kyçur.\nKod PIN i gabuar."</string>
    <string name="sim_pin_disable_failed" msgid="7932981135799678220">"Kodi PIN nuk mund të çaktivizohet."</string>
    <string name="sim_pin_enable_failed" msgid="3414621075632931753">"Kodi PIN nuk mund të aktivizohet."</string>
    <string name="sim_enter_ok" msgid="6475946836899218919">"Në rregull"</string>
    <string name="sim_enter_cancel" msgid="6240422158517208036">"Anulo"</string>
    <string name="sim_multi_sims_title" msgid="9159427879911231239">"U gjetën shumë karta SIM"</string>
    <string name="sim_multi_sims_summary" msgid="2698176447067691396">"Zgjidh kartën SIM që preferon për të dhënat celulare."</string>
    <string name="sim_change_data_title" msgid="5045967581557404143">"Do të përdorësh <xliff:g id="CARRIER">%1$s</xliff:g> për të dhënat celulare?"</string>
    <string name="sim_change_data_message" msgid="4307243848083368600">"Po përdor <xliff:g id="CARRIER2_0">%2$s</xliff:g> për të dhënat celulare. Nëse kalon te <xliff:g id="CARRIER1">%1$s</xliff:g>, <xliff:g id="CARRIER2_1">%2$s</xliff:g> nuk do të përdoret më për të dhënat celulare."</string>
    <string name="sim_change_data_ok" msgid="7929746101841679535">"Përdor <xliff:g id="CARRIER">%1$s</xliff:g>"</string>
    <string name="sim_preferred_title" msgid="5567909634636045268">"Të përditësohet karta e preferuar SIM?"</string>
    <string name="sim_preferred_message" msgid="8466930554330635780">"<xliff:g id="NEW_SIM">%1$s</xliff:g> është karta e vetme SIM në pajisjen tënde. Dëshiron që ta përdorësh këtë kartë SIM për të dhënat celulare, telefonatat dhe mesazhet SMS?"</string>
    <string name="wrong_pin_code_pukked" msgid="4003655226832658066">"PIN-i i kartës SIM është i pasaktë. Tani duhet të kontaktosh operatorin për ta shkyçur pajisjen tënde."</string>
    <plurals name="wrong_pin_code" formatted="false" msgid="1582398808893048097">
      <item quantity="other">Kodi PIN i kartës SIM është i pasaktë. Të kanë mbetur edhe <xliff:g id="NUMBER_1">%d</xliff:g> tentativa.</item>
      <item quantity="one">Kodi PIN i kartës SIM është i pasaktë. Të ka mbetur edhe <xliff:g id="NUMBER_0">%d</xliff:g> tentativë para se të duhet të kontaktosh me operatorin tënd celular për të shkyçur pajisjen.</item>
    </plurals>
    <string name="pin_failed" msgid="1848423634948587645">"Operac. kodit PIN të kartës SIM dështoi!"</string>
    <string name="system_update_settings_list_item_title" msgid="3342887311059985961">"Përditësimet e sistemit"</string>
    <string name="system_update_settings_list_item_summary" msgid="3853057315907710747"></string>
    <string name="firmware_version" msgid="4801135784886859972">"Versioni i Android-it"</string>
    <string name="security_patch" msgid="8438384045870296634">"Niveli i korrigjimit të sigurisë së Android"</string>
    <string name="model_info" msgid="1952009518045740889">"Modeli"</string>
    <string name="model_summary" msgid="8306235877567782987">"Modeli: %1$s"</string>
    <string name="hardware_info" msgid="2605080746512527805">"Modeli dhe hardueri"</string>
    <string name="hardware_revision" msgid="8893547686367095527">"Versioni i harduerit"</string>
    <string name="fcc_equipment_id" msgid="149114368246356737">"ID-ja e pajsjes"</string>
    <string name="baseband_version" msgid="1848990160763524801">"Versioni i brezit të bazës"</string>
    <string name="kernel_version" msgid="9192574954196167602">"Versioni i bërthamës"</string>
    <string name="build_number" msgid="3075795840572241758">"Numri i ndërtimit"</string>
    <string name="module_version" msgid="7329118610303805859">"Përditësimi i sistemit të Google Play"</string>
    <string name="device_info_not_available" msgid="8062521887156825182">"Nuk ofrohet"</string>
    <string name="device_status_activity_title" msgid="1411201799384697904">"Statusi"</string>
    <string name="device_status" msgid="607405385799807324">"Statusi"</string>
    <string name="device_status_summary" product="tablet" msgid="3292717754497039686">"Statusi i baterisë, rrjeti dhe informacione të tjera"</string>
    <string name="device_status_summary" product="default" msgid="2599162787451519618">"Numri i telefonit, sinjali etj."</string>
    <string name="storage_settings" msgid="4211799979832404953">"Hapësira ruajtëse"</string>
    <string name="storage_settings_for_app" msgid="1922207623125501014">"Hapësira ruajtëse dhe memoria specifike"</string>
    <string name="storage_usb_settings" msgid="7293054033137078060">"Hapësira ruajtëse"</string>
    <string name="storage_settings_title" msgid="8746016738388094064">"Cilësimet e hapësirës ruajtëse"</string>
    <string name="storage_settings_summary" product="nosdcard" msgid="3543813623294870759">"Shkëput hapësirën ruajtëse të USB-së dhe shiko hapësirën ruajtëse të lirë"</string>
    <string name="storage_settings_summary" product="default" msgid="9176693537325988610">"Shkëput kartën SD. Shiko hapësirën e lirë për ruajtje."</string>
    <string name="imei_multi_sim" msgid="6387012961838800539">"IMEI (foleja %1$d e kartës SIM)"</string>
    <string name="status_number" product="tablet" msgid="1138837891091222272">"MDN"</string>
    <string name="status_number" product="default" msgid="5948892105546651296">"Numri i telefonit"</string>
    <string name="status_number_sim_slot" product="tablet" msgid="2755592991367858860">"MDN (foleja %1$d e kartës SIM)"</string>
    <string name="status_number_sim_slot" product="default" msgid="1898212200138025729">"Numri i telefonit (foleja %1$d e SIM)"</string>
    <string name="status_number_sim_status" product="tablet" msgid="1367110147304523864">"MDN në kartën SIM"</string>
    <string name="status_number_sim_status" product="default" msgid="9123351360569466330">"Numri i telefonit në kartën SIM"</string>
    <string name="status_min_number" msgid="3519504522179420597">"MINUTA"</string>
    <string name="status_msid_number" msgid="909010114445780530">"MSID"</string>
    <string name="status_prl_version" msgid="1007470446618081441">"Versioni PRL"</string>
    <string name="meid_multi_sim" msgid="748999971744491771">"MEID (foleja %1$d e kartës SIM)"</string>
    <string name="scanning_status_text_wifi_on_ble_on" msgid="5262263689045962681">"Skanimi i Wi‑Fi dhe Bluetooth-it janë të dy aktivë"</string>
    <string name="scanning_status_text_wifi_on_ble_off" msgid="2115399719199757550">"Skanimi i Wi‑Fi është aktiv, skanimi i Bluetooth-it është joaktiv"</string>
    <string name="scanning_status_text_wifi_off_ble_on" msgid="3212656150021004088">"Skanimi i Bluetooth-it është aktiv, skanimi i Wi-Fi është joaktiv"</string>
    <string name="scanning_status_text_wifi_off_ble_off" msgid="6381094990708345188">"Skanimi i Wi‑Fi dhe Bluetooth-it janë të dy joaktivë"</string>
    <string name="status_meid_number" msgid="1751442889111731088">"MEID"</string>
    <string name="status_icc_id" msgid="943368755577172747">"ICCID"</string>
    <string name="status_data_network_type" msgid="7570837037428932780">"Lloji i rrjetit të të dhënave celulare"</string>
    <string name="status_voice_network_type" msgid="5663112239742353547">"Lloji i rrjetit zanor celular"</string>
    <string name="status_latest_area_info" msgid="7222470836568238054">"Informacioni i operatorit"</string>
    <string name="status_data_state" msgid="5503181397066522950">"Gjendja e rrjetit celular"</string>
    <string name="status_esim_id" msgid="6456255368300906317">"EID"</string>
    <string name="status_service_state" msgid="2323931627519429503">"Gjendja e shërbimit"</string>
    <string name="status_signal_strength" msgid="3732655254188304547">"Fuqia e sinjalit"</string>
    <string name="status_roaming" msgid="2638800467430913403">"Roaming"</string>
    <string name="status_operator" msgid="2274875196954742087">"Rrjeti"</string>
    <string name="status_wifi_mac_address" msgid="2202206684020765378">"Adresa MAC e Wi‑Fi"</string>
    <string name="status_bt_address" msgid="4195174192087439720">"Adresa e Bluetooth-it"</string>
    <string name="status_serial_number" msgid="2257111183374628137">"Numri i serisë"</string>
    <string name="status_up_time" msgid="7294859476816760399">"Koha aktive"</string>
    <string name="status_awake_time" msgid="2393949909051183652">"Koha e zgjimit"</string>
    <string name="internal_memory" msgid="9129595691484260784">"Hapësira e brendshme për ruajtje"</string>
    <string name="sd_memory" product="nosdcard" msgid="2510246194083052841">"Hapësira për ruajtje e USB-së"</string>
    <string name="sd_memory" product="default" msgid="151871913888051515">"Karta SD"</string>
    <string name="memory_available" msgid="5052397223077021181">"E lirë"</string>
    <string name="memory_available_read_only" msgid="6497534390167920206">"E gatshme (vetëm për lexim)"</string>
    <string name="memory_size" msgid="6629067715017232195">"Hapësira totale"</string>
    <string name="memory_calculating_size" msgid="2188358544203768588">"Po llogarit…"</string>
    <string name="memory_apps_usage" msgid="5128673488173839077">"Apl. dhe të dhënat e tyre"</string>
    <string name="memory_media_usage" msgid="3738830697707880405">"Media"</string>
    <string name="memory_downloads_usage" msgid="3755173051677533027">"Shkarkimet"</string>
    <string name="memory_dcim_usage" msgid="558887013613822577">"Fotografitë, videot"</string>
    <string name="memory_music_usage" msgid="1363785144783011606">"Audio (muzikë, zile etj.)"</string>
    <string name="memory_media_misc_usage" msgid="6094866738586451683">"Skedarë të tjerë"</string>
    <string name="memory_media_cache_usage" msgid="6704293333141177910">"Të dhënat e memories specifike"</string>
    <string name="sd_eject" product="nosdcard" msgid="4988563376492400073">"Shkëput hapësirën ruajtëse të ndarë"</string>
    <string name="sd_eject" product="default" msgid="6915293408836853020">"Shkëput kartën SD"</string>
    <string name="sd_eject_summary" product="nosdcard" msgid="5009296896648072891">"Çmonto hapësirën ruajtëse të brendshme të USB-së"</string>
    <string name="sd_eject_summary" product="default" msgid="3300599435073550246">"Çmontoje kartën SD që ta heqësh në mënyrë të sigurt"</string>
    <string name="sd_insert_summary" product="nosdcard" msgid="5264016886409577313">"Fut USB-në për lidhje"</string>
    <string name="sd_insert_summary" product="default" msgid="2048640010381803841">"Vendos një kartë SD për lidhje"</string>
    <string name="sd_mount" product="nosdcard" msgid="8966695015677343116">"Lidh hapësirën për ruajtje të USB-së"</string>
    <string name="sd_mount" product="default" msgid="5940523765187704135">"Lidh kartën SD"</string>
    <string name="sd_mount_summary" product="nosdcard" msgid="4673411327373419641"></string>
    <string name="sd_mount_summary" product="default" msgid="4673411327373419641"></string>
    <string name="sd_format" product="nosdcard" msgid="2148179271623099054">"Spastro hapësirën USB"</string>
    <string name="sd_format" product="default" msgid="2576054280507119870">"Spastro kartën SD"</string>
    <string name="sd_format_summary" product="nosdcard" msgid="6331905044907914603">"Spastron të gjitha të dhënat në hapësirën ruajtëse të brendshme të USB-së, sikurse muzikën dhe fotografitë"</string>
    <string name="sd_format_summary" product="default" msgid="212703692181793109">"Spastro të gjitha të dhënat në kartën SD, si muzikën dhe fotografitë"</string>
    <string name="memory_clear_cache_title" msgid="5423840272171286191">"Të pastrohen të dhënat e memories specifike?"</string>
    <string name="memory_clear_cache_message" msgid="4550262490807415948">"Kjo do të pastrojë të dhënat e memories specifike për të gjitha aplikacionet."</string>
    <string name="mtp_ptp_mode_summary" msgid="3710436114807789270">"Funksioni MTP ose PTP është aktiv"</string>
    <string name="dlg_confirm_unmount_title" product="nosdcard" msgid="3077285629197874055">"Të shkëputet USB-ja?"</string>
    <string name="dlg_confirm_unmount_title" product="default" msgid="3634502237262534381">"Të çmontohet karta SD?"</string>
    <string name="dlg_confirm_unmount_text" product="nosdcard" msgid="4322636662873269018">"Nëse e çmonton hapësirën ruajtëse të USB-së, disa aplikacione që po përdor do të ndalojnë dhe mund të mos mundësohen deri sa ta montosh përsëri hapësirën ruajtëse të USB-së."</string>
    <string name="dlg_confirm_unmount_text" product="default" msgid="6998379994779187692">"Nëse shkëput kartën SD, disa aplikacione që po përdor do të ndalojnë dhe mund të bëhen të papërdorshme derisa të lidhësh sërish kartën SD."</string>
    <string name="dlg_error_unmount_title" product="nosdcard" msgid="4642742385125426529"></string>
    <string name="dlg_error_unmount_title" product="default" msgid="4642742385125426529"></string>
    <string name="dlg_error_unmount_text" product="nosdcard" msgid="9191518889746166147">"Nuk mundi të shkëpuste hapësirën për ruajtje të USB-së. Provo sërish më vonë."</string>
    <string name="dlg_error_unmount_text" product="default" msgid="3500976899159848422">"Karta SD nuk mund të shkëputej. Provo përsëri më vonë."</string>
    <string name="unmount_inform_text" product="nosdcard" msgid="7120241136790744265">"Hapësira ruajtëse e USB-së do të shkëputet."</string>
    <string name="unmount_inform_text" product="default" msgid="1904212716075458402">"Karta SD do të shkëputet."</string>
    <string name="sd_ejecting_title" msgid="8824572198034365468">"Po çmontohet"</string>
    <string name="sd_ejecting_summary" msgid="2028753069184908491">"Çmontimi në vazhdim"</string>
    <string name="storage_low_title" msgid="1388569749716225155">"Hapësira e ruajtjes po mbaron"</string>
    <string name="storage_low_summary" msgid="7737465774892563129">"Disa funksione të sistemit, si sinkronizimi, mund të mos punojnë si duhet. Provo të lirosh hapësirën duke fshirë ose duke hequr artikujt, si për shembull aplikacione ose përmbajtje \"media\"."</string>
    <string name="storage_menu_rename" msgid="7141058657592615390">"Riemërto"</string>
    <string name="storage_menu_mount" msgid="1014683672493425425">"Monto"</string>
    <string name="storage_menu_unmount" msgid="681485356885955898">"Nxirr"</string>
    <string name="storage_menu_format" msgid="7690626079653152152">"Formato"</string>
    <string name="storage_menu_format_public" msgid="7464714208010125682">"Formato si të lëvizshme"</string>
    <string name="storage_menu_format_private" msgid="546017531835902096">"Formato si të brendshme"</string>
    <string name="storage_menu_migrate" msgid="3969621494238154294">"Migro të dhënat"</string>
    <string name="storage_menu_forget" msgid="6305824238997983426">"Harroje"</string>
    <string name="storage_menu_set_up" msgid="4263294929451685366">"Konfiguro"</string>
    <string name="storage_menu_explore" msgid="4637496051816521560">"Eksploro"</string>
    <string name="storage_menu_free" msgid="6386070442027135427">"Liro hapësirën"</string>
    <string name="storage_menu_manage" msgid="5914482953856430780">"Menaxho hapësirën e ruajtjes"</string>
    <string name="storage_title_usb" msgid="679612779321689418">"Lidhja e kompjuterit me USB-në"</string>
    <string name="usb_connection_category" msgid="7805945595165422882">"Lidh si"</string>
    <string name="usb_mtp_title" msgid="3399663424394065964">"Pajisje e jashtme \"media\" (MTP)"</string>
    <string name="usb_mtp_summary" msgid="4617321473211391236">"Lejon që të transferosh skedarët \"media\" në Windows ose duke përdorur \"Transferimin e skedarëve të Androidit\" në Mac (shiko www.android.com/filetransfer)"</string>
    <string name="usb_ptp_title" msgid="3852760810622389620">"Kamera (PTP)"</string>
    <string name="usb_ptp_summary" msgid="7406889433172511530">"Lejon që të transferosh fotografi duke përdorur softuerin e kamerës dhe të transferosh çdo skedar në kompjuterë që nuk e mbështesin MTP-në"</string>
    <string name="usb_midi_title" msgid="3069990264258413994">"MIDI"</string>
    <string name="usb_midi_summary" msgid="539169474810956358">"Lejo që aplikacionet e aktivizuara të MIDI-së të funksionojnë në USB me softuerin MIDI në kompjuterin tënd."</string>
    <string name="storage_other_users" msgid="808708845102611856">"Përdorues të tjerë"</string>
    <string name="storage_internal_title" msgid="690771193137801021">"Hapësira për ruajtje e pajisjes"</string>
    <string name="storage_external_title" msgid="3433462910096848696">"Hapësira ruajtëse e lëvizshme"</string>
    <string name="storage_volume_summary" msgid="7023441974367853372">"<xliff:g id="USED">%1$s</xliff:g> të përdorura nga <xliff:g id="TOTAL">%2$s</xliff:g>"</string>
    <string name="storage_size_large" msgid="5691585991420946254">"<xliff:g id="NUMBER">^1</xliff:g>"<small><small>" <xliff:g id="UNIT">^2</xliff:g>"</small></small>""</string>
    <string name="storage_volume_used" msgid="1303803057698959872">"Përdorur nga gjithsej <xliff:g id="TOTAL">%1$s</xliff:g>"</string>
    <string name="storage_volume_used_total" msgid="6113121714019000244">"Përdorur nga gjithsej <xliff:g id="TOTAL">%1$s</xliff:g>"</string>
    <string name="storage_mount_success" msgid="687641090137253647">"<xliff:g id="NAME">%1$s</xliff:g> u montua"</string>
    <string name="storage_mount_failure" msgid="1042621107954547316">"Nuk mundi të lidhte <xliff:g id="NAME">%1$s</xliff:g>"</string>
    <string name="storage_unmount_success" msgid="5737203344673441677">"<xliff:g id="NAME">%1$s</xliff:g> u nxorr në mënyrë të sigurt"</string>
    <string name="storage_unmount_failure" msgid="5758387106579519489">"<xliff:g id="NAME">%1$s</xliff:g> nuk mund të nxirrej në mënyrë të sigurt"</string>
    <string name="storage_format_success" msgid="3023144070597190555">"<xliff:g id="NAME">%1$s</xliff:g> është i formatuar"</string>
    <string name="storage_format_failure" msgid="6032640952779735766">"<xliff:g id="NAME">%1$s</xliff:g> nuk mund të formatohej"</string>
    <string name="storage_rename_title" msgid="8242663969839491485">"Riemërto hapësirën ruajtëse"</string>
    <string name="storage_dialog_unmounted" msgid="6403320870103261477">"Kjo <xliff:g id="NAME_0">^1</xliff:g> është nxjerrë në mënyrë të sigurt, por është akoma e disponueshme. \n\nPër të përdorur këtë <xliff:g id="NAME_1">^1</xliff:g>, duhet ta montosh në fillim."</string>
    <string name="storage_dialog_unmountable" msgid="3732209361668282254">"Kjo <xliff:g id="NAME_0">^1</xliff:g> është e dëmtuar. \n\nPër të përdorur këtë <xliff:g id="NAME_1">^1</xliff:g>, duhet ta konfigurosh në fillim."</string>
    <string name="storage_dialog_unsupported" msgid="4503128224360482228">"Kjo pajisje nuk e mbështet këtë <xliff:g id="NAME_0">^1</xliff:g>. \n\nPër të përdorur këtë <xliff:g id="NAME_1">^1</xliff:g> me këtë pajisje, duhet ta konfigurosh në fillim."</string>
    <string name="storage_internal_format_details" msgid="4018647158382548820">"Pas formatimit, kartën <xliff:g id="NAME_0">^1</xliff:g> mund ta përdorësh në pajisje të tjera. \n\nTë gjitha të dhënat në <xliff:g id="NAME_1">^1</xliff:g> do të fshihen. Rekomandohet që të kryesh rezervimin në fillim. \n\n"<b>"Rezervo fotografitë dhe artikujt e tjerë \"media\""</b>" \nZhvendosi skedarët \"media\" në hapësira alternative ruajtjeje në këtë pajisje ose transferoji ato në një kompjuter duke përdorur një kabllo USB-je. \n\n"<b>"Rezervo aplikacionet"</b>" \nTë gjitha aplikacionet e ruajtura në <xliff:g id="NAME_6">^1</xliff:g> do të çinstalohen dhe të dhënat e tyre do të fshihen. Për t\'i ruajtur këto aplikacione, zhvendosi në hapësira alternative ruajtjeje në këtë pajisje."</string>
    <string name="storage_internal_unmount_details" msgid="3582802571684490057"><b>"Kur ta nxjerrësh këtë <xliff:g id="NAME_0">^1</xliff:g>, aplikacionet e ruajtura në të do të ndalojnë së funksionuari ndërsa skedarët \"media\" nuk do të jenë të përdorshëm derisa ta fusësh atë sërish."</b>" \n\n<xliff:g id="NAME_1">^1</xliff:g> është formatuar për të funksionuar vetëm me këtë pajisje dhe nuk do të funksionojë me pajisje të tjera."</string>
    <string name="storage_internal_forget_details" msgid="9028875424669047327">"Për të përdorur aplikacionet, fotografitë ose të dhënat që përmban <xliff:g id="NAME">^1</xliff:g>, rifute atë. \n\nSi alternativë, mund të zgjedhësh ta harrosh këtë magazinë nëse pajisja nuk mund të përdoret. \n\nNëse zgjedh që ta harrosh, të gjitha të dhënat që përmban pajisja do të humbasin përgjithmonë. \n\nAplikacionet mund t\'i instalosh sërish më vonë, por të dhënat e ruajtura në këtë pajisje do të humbasin."</string>
    <string name="storage_internal_forget_confirm_title" msgid="1370847944388479245">"Harroje <xliff:g id="NAME">^1</xliff:g>?"</string>
    <string name="storage_internal_forget_confirm" msgid="1148446041396902905">"Të gjitha aplikacionet, fotografitë dhe të dhënat e ruajtura në këtë <xliff:g id="NAME">^1</xliff:g> do të humbasin përgjithmonë."</string>
    <string name="storage_detail_apps" msgid="6141154016753507490">"Aplikacionet"</string>
    <string name="storage_detail_images" msgid="6950678857740634769">"Imazhet"</string>
    <string name="storage_detail_videos" msgid="2919743464827110953">"Videot"</string>
    <string name="storage_detail_audio" msgid="1197685141676483213">"Audio"</string>
    <string name="storage_detail_cached" msgid="8547136365247818567">"Të dhënat e memories specifike"</string>
    <string name="storage_detail_other" msgid="8404938385075638238">"Tjetër"</string>
    <string name="storage_detail_system" msgid="4629506366064709687">"Sistemi"</string>
    <string name="storage_detail_explore" msgid="7911344011431568294">"Eksploro <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_detail_dialog_other" msgid="8845766044697204852">"Përfshin po ashtu skedarët e ndarë që janë ruajtur nga aplikacionet, skedarët e shkarkuar nga interneti ose me Bluetooth, skedarët e Android e të tjera. \n\nPër të parë të gjitha përmbajtjet e dukshme në këtë <xliff:g id="NAME">^1</xliff:g>, trokit tek \"Eksploro\"."</string>
    <string name="storage_detail_dialog_system" msgid="862835644848361569">"Sistemi përfshin skedarët e përdorur për ekzekutimin e versionit <xliff:g id="VERSION">%s</xliff:g> të Android"</string>
    <string name="storage_detail_dialog_user" msgid="3267254783294197804">"<xliff:g id="USER_0">^1</xliff:g> mund të ketë ruajtur fotografi, muzikë, aplikacione ose të dhëna të tjera, duke përdorur <xliff:g id="SIZE">^2</xliff:g> nga hapësira ruajtëse. \n\nPër të parë detajet, kalo te <xliff:g id="USER_1">^1</xliff:g>."</string>
    <string name="storage_wizard_init_title" msgid="5085400514028585772">"Konfiguro <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_init_external_title" msgid="4867326438945303598">"Përdore si hapësirë portative ruajtjeje"</string>
    <string name="storage_wizard_init_external_summary" msgid="7476105886344565074">"Për të zhvendosur fotografi dhe artikuj të tjerë \"media\" mes pajisjeve."</string>
    <string name="storage_wizard_init_internal_title" msgid="9100613534261408519">"Përdore si hapësirë të brendshme ruajtjeje"</string>
    <string name="storage_wizard_init_internal_summary" msgid="6240417501036216410">"Për të ruajtur diçka vetëm në këtë pajisje, duke përfshirë aplikacionet dhe fotografitë. Kërkon formatim që e parandalon atë të funksionojë me pajisje të tjera."</string>
    <string name="storage_wizard_format_confirm_title" msgid="2814021794538252546">"Formato si hapësirë të brendshme ruajtjeje"</string>
    <string name="storage_wizard_format_confirm_body" msgid="4401758710076806509">"Kjo kërkon që <xliff:g id="NAME_0">^1</xliff:g> të formatohet për ta bërë të sigurt atë. \n\nPas formatimit, <xliff:g id="NAME_1">^1</xliff:g> do të funksionojë vetëm në këtë pajisje. \n\n"<b>"Formatimi fshin të gjitha të dhënat që ruhen aktualisht në <xliff:g id="NAME_2">^1</xliff:g>."</b>" Për të shmangur humbjen e të dhënave, rekomandohet rezervimi i tyre."</string>
    <string name="storage_wizard_format_confirm_public_title" msgid="4905690038882041566">"Formatoje si hapësirë ruajtëse të lëvizshme"</string>
    <string name="storage_wizard_format_confirm_public_body" msgid="1516932692920060272">"Kjo kërkon që <xliff:g id="NAME_0">^1</xliff:g> të formatohet. \n\n"<b>"Formatimi fshin të gjitha të dhënat e ruajtura aktualisht te <xliff:g id="NAME_1">^1</xliff:g>."</b>" Për të shmangur humbjen e të dhënave, rekomandohet rezervimi i tyre."</string>
    <string name="storage_wizard_format_confirm_next" msgid="2774557300531702572">"Fshi dhe formato"</string>
    <string name="storage_wizard_format_progress_title" msgid="6487352396450582292">"<xliff:g id="NAME">^1</xliff:g> po formatohet..."</string>
    <string name="storage_wizard_format_progress_body" msgid="3983764797223576658">"Mos e hiq <xliff:g id="NAME">^1</xliff:g> gjatë formatimit."</string>
    <string name="storage_wizard_migrate_title" msgid="1363078147938160407">"Zhvendos të dhënat në hapësirën e re të ruajtjes"</string>
    <string name="storage_wizard_migrate_body" msgid="890751699549542345">"Mund të zhvendosësh fotografitë, skedarët dhe disa aplikacione te kjo <xliff:g id="NAME">^1</xliff:g> e re. \n\nZhvendosja kërkon rreth <xliff:g id="TIME">^2</xliff:g> dhe do të lirojë <xliff:g id="SIZE">^3</xliff:g> në hapësirën e brendshme. Disa aplikacione nuk do të funksionojnë gjatë këtij procesi."</string>
    <string name="storage_wizard_migrate_now" msgid="4523444323744239143">"Zhvendos tani"</string>
    <string name="storage_wizard_migrate_later" msgid="3173482328116026253">"Zhvendos më vonë"</string>
    <string name="storage_wizard_migrate_confirm_title" msgid="8564833529613286965">"Zhvendos të dhënat"</string>
    <string name="storage_wizard_migrate_confirm_body" msgid="4212060581792135962"><b>"Zhvendosja kërkon rreth <xliff:g id="TIME">^1</xliff:g> dhe do të lirojë <xliff:g id="SIZE">^2</xliff:g> nga <xliff:g id="NAME">^3</xliff:g>."</b></string>
    <string name="storage_wizard_migrate_confirm_next" msgid="5509475628423823202">"Zhvendos"</string>
    <string name="storage_wizard_migrate_progress_title" msgid="1665479429044202868">"Po zhvendos të dhënat..."</string>
    <string name="storage_wizard_migrate_details" msgid="3709728824651136227">"Gjatë zhvendosjes: \n• <xliff:g id="NAME">^1</xliff:g> nuk duhet të hiqet. \n• Disa apl. nuk do të funksionojnë si duhet. \n• Mbaje pajisjen të karikuar."</string>
    <string name="storage_wizard_ready_title" msgid="6553867088682695655">"<xliff:g id="NAME">^1</xliff:g> është gati për përdorim"</string>
    <string name="storage_wizard_ready_external_body" msgid="2879508114260597474">"<xliff:g id="NAME">^1</xliff:g> është gati për t\'u përdorur me fotografitë dhe skedarët e tjerë."</string>
    <string name="storage_wizard_ready_internal_body" msgid="122532674037860197">"<xliff:g id="NAME">^1</xliff:g> po funksionon. \n\nPër të zhvendosur fotografitë, skedarët dhe të dhënat e aplikacioneve te kjo pajisje, shko te Cilësimet &gt; Hapësira ruajtëse."</string>
    <string name="storage_wizard_move_confirm_title" msgid="292782012677890250">"Zhvendos <xliff:g id="APP">^1</xliff:g>"</string>
    <string name="storage_wizard_move_confirm_body" msgid="5176432115206478941">"Zhvendosja e aplikacionit <xliff:g id="APP">^1</xliff:g> dhe të dhënave të tij te <xliff:g id="NAME_0">^2</xliff:g> do të zgjasë vetëm pak çaste. Nuk do të jesh në gjendje ta përdorësh aplikacionin derisa zhvendosja të përfundojë. \n\n<xliff:g id="NAME_1">^2</xliff:g> nuk duhet të hiqet gjatë zhvendosjes."</string>
    <string name="storage_wizard_move_unlock" msgid="1526216561023200694">"Për të hequr të dhënat të nevojitet të shkyçësh përdoruesin <xliff:g id="APP">^1</xliff:g>."</string>
    <string name="storage_wizard_move_progress_title" msgid="4443920302548035674">"Po zhvendos <xliff:g id="APP">^1</xliff:g> ..."</string>
    <string name="storage_wizard_move_progress_body" msgid="7802577486578105609">"Mos e hiq kartën <xliff:g id="NAME">^1</xliff:g> gjatë zhvendosjes. \n\nAplikacioni <xliff:g id="APP">^2</xliff:g> në këtë pajisje nuk do të mund të përdoret derisa të përfundojë zhvendosja."</string>
    <string name="storage_wizard_move_progress_cancel" msgid="542047237524588792">"Anulo zhvendosjen"</string>
    <string name="storage_wizard_slow_body" msgid="8010127667184768025">"Kjo <xliff:g id="NAME_0">^1</xliff:g> duket se është e ngadaltë. \n\nMund të vazhdosh, por aplikacionet e zhvendosura në këtë vend mund të pengohen dhe transferimi i të dhënave mund të kërkojë shumë kohë. \n\nKi parasysh të përdorësh një <xliff:g id="NAME_1">^1</xliff:g> më të shpejtë për një cilësi më të mirë të funksionimit."</string>
    <string name="storage_wizard_init_v2_title" msgid="8858395869710288372">"Si do ta përdorësh këtë <xliff:g id="NAME">^1</xliff:g>?"</string>
    <string name="storage_wizard_init_v2_internal_title" product="tablet" msgid="4315585580670552654">"Përdore si hapësirë ruajtëse shtesë të tabletit"</string>
    <string name="storage_wizard_init_v2_internal_summary" product="tablet" msgid="570443086512059390">"Për aplikacionet, skedarët dhe median vetëm në këtë tablet"</string>
    <string name="storage_wizard_init_v2_internal_action" product="tablet" msgid="7760758592993284143">"Hapësira ruajtëse e tabletit"</string>
    <string name="storage_wizard_init_v2_internal_title" product="default" msgid="8373070138732653456">"Përdore si hapësirë ruajtëse shtesë të telefonit"</string>
    <string name="storage_wizard_init_v2_internal_summary" product="default" msgid="685194340141573218">"Për aplikacionet, skedarët dhe median vetëm në këtë telefon"</string>
    <string name="storage_wizard_init_v2_internal_action" product="default" msgid="904425171564310150">"Hapësira ruajtëse e telefonit"</string>
    <string name="storage_wizard_init_v2_or" msgid="1958295749349454436">"Ose"</string>
    <string name="storage_wizard_init_v2_external_title" msgid="3565348221712759463">"Përdore si hapësirë të lëvizshme"</string>
    <string name="storage_wizard_init_v2_external_summary" msgid="801198071793584445">"Për transferimin e skedarëve dhe medias mes pajisjeve"</string>
    <string name="storage_wizard_init_v2_external_action" msgid="8662451480642784031">"Hapësira ruajtëse e lëvizshme"</string>
    <string name="storage_wizard_init_v2_later" msgid="1080613420170749130">"Konfiguro më vonë"</string>
    <string name="storage_wizard_format_confirm_v2_title" msgid="5744790239994621663">"Të formatohet kjo <xliff:g id="NAME">^1</xliff:g>?"</string>
    <string name="storage_wizard_format_confirm_v2_body" msgid="4614199613500900975">"Kjo <xliff:g id="NAME_0">^1</xliff:g> duhet të formatohet për të ruajtur aplikacione, skedarë dhe media. \n\nFormatimi do të spastrojë përmbajtjen ekzistuese në <xliff:g id="NAME_1">^2</xliff:g>. Për të shmangur humbjen e përmbajtjes, krijo një kopje rezervë në një <xliff:g id="NAME_2">^3</xliff:g> ose në një pajisje tjetër."</string>
    <string name="storage_wizard_format_confirm_v2_action" msgid="8258363472135537500">"Formato <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_migrate_v2_title" msgid="31406330052996898">"Të zhvendoset përmbajtja te <xliff:g id="NAME">^1</xliff:g>?"</string>
    <string name="storage_wizard_migrate_v2_body" product="tablet" msgid="4476553430145054781">"Mund të zhvendosësh skedarët, median dhe aplikacione të caktuara në këtë <xliff:g id="NAME">^1</xliff:g>. \n\nKjo zhvendosje do të lirojë deri në <xliff:g id="SIZE">^2</xliff:g> nga hapësira ruajtëse e tabletit dhe duhet të zgjasë rreth <xliff:g id="DURATION">^3</xliff:g>."</string>
    <string name="storage_wizard_migrate_v2_body" product="default" msgid="744760728669284385">"Mund të zhvendosësh skedarët, median dhe aplikacione të caktuara në këtë <xliff:g id="NAME">^1</xliff:g>. \n\nKjo zhvendosje do të lirojë deri në <xliff:g id="SIZE">^2</xliff:g> nga hapësira ruajtëse e telefonit dhe duhet të zgjasë rreth <xliff:g id="DURATION">^3</xliff:g>."</string>
    <string name="storage_wizard_migrate_v2_checklist" msgid="1239103359606165360">"Gjatë zhvendosjes:"</string>
    <string name="storage_wizard_migrate_v2_checklist_media" msgid="7176991995007075843">"Mos e hiq <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_migrate_v2_checklist_apps" msgid="3671266712947078734">"Disa aplikacione nuk do të funksionojnë"</string>
    <string name="storage_wizard_migrate_v2_checklist_battery" product="tablet" msgid="346012901366624052">"Mbaje këtë tablet të karikuar"</string>
    <string name="storage_wizard_migrate_v2_checklist_battery" product="default" msgid="3061158350109289521">"Mbaje këtë telefon të karikuar"</string>
    <string name="storage_wizard_migrate_v2_now" msgid="1279041707982039591">"Zhvendos përmbajtjen"</string>
    <string name="storage_wizard_migrate_v2_later" msgid="8201360307047198853">"Zhvendose përmbajtjen më vonë"</string>
    <string name="storage_wizard_migrate_progress_v2_title" msgid="1323344099111423785">"Përmbajtja po zhvendoset…"</string>
    <string name="storage_wizard_slow_v2_title" msgid="1318285829973607727">"<xliff:g id="NAME">^1</xliff:g> e ngadaltë"</string>
    <string name="storage_wizard_slow_v2_body" msgid="6897444467730463117">"Mund ta përdorësh përsëri këtë <xliff:g id="NAME_0">^1</xliff:g>, por mund të jetë e ngadaltë. \n\nAplikacionet e ruajtura në këtë <xliff:g id="NAME_1">^2</xliff:g> mund të mos funksionojnë si duhet dhe transferimet e përmbajtjeve mund të kërkojnë shumë kohë. \n\nProvo të përdorësh një <xliff:g id="NAME_2">^3</xliff:g> më të shpejtë ose përdor më mirë këtë <xliff:g id="NAME_3">^4</xliff:g> për hapësirë ruajtëse të lëvizshme."</string>
    <string name="storage_wizard_slow_v2_start_over" msgid="4126873669723115805">"Fillo nga e para"</string>
    <string name="storage_wizard_slow_v2_continue" msgid="49399942893518218">"Vazhdo"</string>
    <string name="storage_wizard_ready_v2_external_body" msgid="11937346870534608">"Mund ta zhvendosësh përmbajtjen te <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_ready_v2_internal_body" msgid="4658433206901211269">"Për të zhvendosur përmbajtjen te <xliff:g id="NAME">^1</xliff:g>, shko te "<b>"Cilësimet &gt; Hapësira ruajtëse"</b></string>
    <string name="storage_wizard_ready_v2_internal_moved_body" msgid="6239886818487538806">"Përmbajtja jote u zhvendos te <xliff:g id="NAME_0">^1</xliff:g>. \n\nPër të menaxhuar këtë <xliff:g id="NAME_1">^2</xliff:g>, shko te "<b>"Cilësimet &gt; Hapësira ruajtëse"</b>"."</string>
    <string name="battery_status_title" msgid="9159414319574976203">"Statusi i baterisë"</string>
    <string name="battery_level_title" msgid="2965679202786873272">"Niveli i baterisë"</string>
    <string name="apn_settings" msgid="3743170484827528406">"APN-të"</string>
    <string name="apn_edit" msgid="1354715499708424718">"Redakto pikën e qasjes"</string>
    <string name="apn_not_set" msgid="4974192007399968164">"Nuk është caktuar"</string>
    <string name="apn_name" msgid="4115580098369824123">"Emri"</string>
    <string name="apn_apn" msgid="2479425126733513353">"APN-ja"</string>
    <string name="apn_http_proxy" msgid="1826885957243696354">"Përfaqësuesi"</string>
    <string name="apn_http_port" msgid="3763259523984976226">"Porta"</string>
    <string name="apn_user" msgid="455637547356117761">"Emri i përdoruesit"</string>
    <string name="apn_password" msgid="5412301994998250968">"Fjalëkalimi"</string>
    <string name="apn_server" msgid="2436185314756372858">"Serveri"</string>
    <string name="apn_mmsc" msgid="3670124402105585737">"MMSC-ja"</string>
    <string name="apn_mms_proxy" msgid="5374082621073999275">"Përfaqësuesi i MMS-ve"</string>
    <string name="apn_mms_port" msgid="4074188088199243040">"Porta e MMS-ve"</string>
    <string name="apn_mcc" msgid="4258628382260674636">"MCC-ja"</string>
    <string name="apn_mnc" msgid="8629374076888809874">"MNC-ja"</string>
    <string name="apn_auth_type" msgid="6167205395676037015">"Lloji i vërtetimit"</string>
    <string name="apn_auth_type_none" msgid="5069592676845549926">"Asnjë"</string>
    <string name="apn_auth_type_pap" msgid="1666934536996033383">"PAP"</string>
    <string name="apn_auth_type_chap" msgid="3369626283789068360">"CHAP"</string>
    <string name="apn_auth_type_pap_chap" msgid="9102343063036134541">"PAP ose CHAP"</string>
    <string name="apn_type" msgid="469613123902220544">"Lloji i APN-së"</string>
    <string name="apn_protocol" msgid="3272222921649348640">"Protokolli i APN-së"</string>
    <string name="apn_roaming_protocol" msgid="3386954381510788422">"Protokolli i APN-së në roaming"</string>
    <string name="carrier_enabled" msgid="407655861175280806">"Aktivizo/çaktivizo APN-në"</string>
    <string name="carrier_enabled_summaryOn" msgid="6338915271908057531">"Rrjeti APN u aktivizua"</string>
    <string name="carrier_enabled_summaryOff" msgid="4300790190221203756">"Rrjeti APN u çaktivizua"</string>
    <string name="bearer" msgid="594270280031923558">"Bartësi"</string>
    <string name="mvno_type" msgid="2543253857818336421">"Lloji i MVNO-së"</string>
    <string name="mvno_match_data" msgid="4560671695220540466">"Vlera e MVNO-së"</string>
    <string name="menu_delete" msgid="6981294422841124659">"Fshi APN-në"</string>
    <string name="menu_new" msgid="3014205883303921729">"APN e re"</string>
    <string name="menu_save" msgid="8109345640668285399">"Ruaj"</string>
    <string name="menu_cancel" msgid="2194502410474697474">"Injoro"</string>
    <string name="error_title" msgid="7631322303341024692"></string>
    <string name="error_name_empty" msgid="5508155943840201232">"Fusha Emri nuk mund të jetë bosh."</string>
    <string name="error_apn_empty" msgid="4932211013600863642">"Rrjeti APN nuk mund të jetë bosh."</string>
    <string name="error_mcc_not3" msgid="4560171714156251661">"Fusha e MCC-së duhet të ketë 3 shifra."</string>
    <string name="error_mnc_not23" msgid="8418177072458379439">"Fusha e MNC-së duhet të ketë 2 ose 3 shifra."</string>
    <string name="error_adding_apn_type" msgid="4181334016628549645">"Operatori nuk lejon shtimin e APN-ve të llojit %s."</string>
    <string name="restore_default_apn" msgid="8178010218751639581">"Po restauron cilësimet e APN-së me parazgjedhje."</string>
    <string name="menu_restore" msgid="8260067415075573273">"Rivendos të parazgjedhurën"</string>
    <string name="restore_default_apn_completed" msgid="2824775307377604897">"Rivendosja e cilësimeve të APN-së me parazgjedhje përfundoi."</string>
    <string name="reset_dashboard_title" msgid="6254873816990678620">"Opsionet e rivendosjes"</string>
    <string name="reset_dashboard_summary" msgid="4851012632493522755">"Rrjeti, aplikacionet ose pajisja mund të rivendosen"</string>
    <string name="reset_network_title" msgid="6166025966016873843">"Rivendos Wi-Fi, lidhjen celulare dhe Bluetooth"</string>
    <string name="reset_network_desc" msgid="5547979398298881406">"Kjo do të rivendosë të gjitha cilësimet e rrjetit, duke përfshirë:\n\n"<li>"Wi‑Fi"</li>\n<li>"Të dhënat celulare"</li>\n<li>"Bluetooth"</li></string>
    <string name="reset_esim_title" msgid="1979762943163078939">"Spastro kartat SIM të shkarkuara"</string>
    <string name="reset_esim_desc" msgid="5940105242448544634">"Për të shkarkuar karta SIM zëvendësuese, kontakto me operatorin celular. Kjo nuk do të anulojë asnjë plan të shërbimit celular."</string>
    <string name="reset_network_button_text" msgid="2035676527471089853">"Rivendos cilësimet"</string>
    <string name="reset_network_final_desc" msgid="4690205209934596665">"Të rivendosen të gjitha cilësimet e rrjetit? Ky veprim nuk mund të zhbëhet."</string>
    <string name="reset_network_final_desc_esim" msgid="6641433458865914227">"Do t\'i rivendosësh të gjitha cilësimet dhe t\'i spastrosh kartat SIM të shkarkuara? Nuk mund ta zhbësh këtë veprim."</string>
    <string name="reset_network_final_button_text" msgid="1797434793741744635">"Rivendos cilësimet"</string>
    <string name="reset_network_confirm_title" msgid="1759888886976962773">"Të rivendosen?"</string>
    <string name="network_reset_not_available" msgid="7188610385577164676">"Rivendosja e rrjetit nuk është e disponueshme për këtë përdorues"</string>
    <string name="reset_network_complete_toast" msgid="787829973559541880">"Cilësimet e rrjetit janë rivendosur"</string>
    <string name="reset_esim_error_title" msgid="2679159494023044398">"Kartat SIM nuk mund të spastrohen"</string>
    <string name="reset_esim_error_msg" msgid="1356899750645220749">"Kartat SIM të shkarkuara nuk mund të spastrohen për shkak të një gabimi.\n\nRinise pajisjen dhe provo përsëri."</string>
    <string name="master_clear_title" msgid="3531267871084279512">"Spastro të gjitha të dhënat (rivendosja e fabrikës)"</string>
    <string name="master_clear_short_title" msgid="8652450915870274285">"Spastro të gjitha të dhënat (rivendosja e fabrikës)"</string>
    <string name="master_clear_desc" product="tablet" msgid="2314458161059569301">"Kjo do të spastrojë të gjitha të dhënat nga "<b>"hapësira ruajtëse e brendshme"</b>" e tabletit, duke përfshirë:\n\n"<li>"Llogarinë e Google"</li>\n<li>"Të dhënat e sistemit dhe aplikacioneve si dhe cilësimet"</li>\n<li>"Aplikacionet e shkarkuara"</li></string>
    <string name="master_clear_desc" product="default" msgid="7647628092266675099">"Kjo do të spastrojë të gjitha të dhënat nga "<b>"hapësira ruajtëse e brendshme"</b>" e telefonit, duke përfshirë:\n\n"<li>"Llogarinë e Google"</li>\n<li>"Të dhënat e sistemit dhe aplikacioneve si dhe cilësimet"</li>\n<li>"Aplikacionet e shkarkuara"</li></string>
    <string name="master_clear_accounts" product="default" msgid="6412857499147999073">\n\n"Je i identifikuar aktualisht në llogaritë e mëposhtme:\n"</string>
    <string name="master_clear_other_users_present" product="default" msgid="5161423070702470742">\n\n"Ka përdorues të tjerë të pranishëm në këtë pajisje.\n"</string>
    <string name="master_clear_desc_also_erases_external" msgid="1903185203791274237"><li>"Muzika"</li>\n<li>"Fotografitë"</li>\n<li>"Të dhëna të tjera të përdoruesit"</li></string>
    <string name="master_clear_desc_also_erases_esim" msgid="6008213558725767177"><li>"Kartat eSIM"</li></string>
    <string name="master_clear_desc_no_cancel_mobile_plan" msgid="5460926449093211144">\n\n"Kjo nuk do ta anulojë planin tënd të shërbimit celular."</string>
    <string name="master_clear_desc_erase_external_storage" product="nosdcard" msgid="7744115866662613411">\n\n"Për të hequr muzikën, fotografitë dhe të dhëna të tjera të përdoruesit, "<b>"hapësira ruajtëse e USB-së"</b>" duhet të spastrohet."</string>
    <string name="master_clear_desc_erase_external_storage" product="default" msgid="4801026652617377093">\n\n"Për të hequr muzikën, fotografitë dhe të dhëna të tjera të përdoruesit, "<b>"karta SD"</b>" duhet të spastrohet."</string>
    <string name="erase_external_storage" product="nosdcard" msgid="969364037450286809">"Fshi hapësirën ruajtëse të USB-së"</string>
    <string name="erase_external_storage" product="default" msgid="1397239046334307625">"Spastroje kartën SD"</string>
    <string name="erase_external_storage_description" product="nosdcard" msgid="4728558173931599429">"Spastro të gjitha të dhënat në hapësirën ruajtëse të brendshme të USB-së, si muzikën ose fotografitë"</string>
    <string name="erase_external_storage_description" product="default" msgid="1737638779582964966">"Spastro të gjitha të dhënat në kartën SD, si muzikën ose fotografitë"</string>
    <string name="master_clear_button_text" product="tablet" msgid="1893179883931194922">"Spastro të gjitha të dhënat"</string>
    <string name="master_clear_button_text" product="default" msgid="1893179883931194922">"Spastro të gjitha të dhënat"</string>
    <string name="master_clear_final_desc" msgid="8219087639717327355">"Të gjitha informacionet e tua personale dhe aplikacionet e shkarkuara do të fshihen. Nuk mund ta zhbësh këtë veprim."</string>
    <string name="master_clear_final_desc_esim" msgid="4580223096319568030">"Të gjitha informacionet e tua personale, duke përfshirë aplikacionet e shkarkuara dhe kartat SIM, do të fshihen. Nuk mund ta zhbësh këtë veprim."</string>
    <string name="master_clear_final_button_text" msgid="5390908019019242910">"Spastroji të gjitha"</string>
    <string name="master_clear_failed" msgid="2503230016394586353">"Nuk u krye një rivendosje sepse shërbimi Pastrimi i sistemit nuk është i disponueshëm."</string>
    <string name="master_clear_confirm_title" msgid="1134724452049918413">"Të spastrohen të gjitha të dhënat?"</string>
    <string name="master_clear_not_available" msgid="1000370707967468909">"Rivendosja në gjendjen e fabrikës nuk ofrohet për këtë përdorues"</string>
    <string name="master_clear_progress_title" msgid="5194793778701994634">"Po spastron"</string>
    <string name="master_clear_progress_text" msgid="6559096229480527510">"Qëndro në pritje..."</string>
    <string name="call_settings_title" msgid="5188713413939232801">"Cilësimet e telefonatave"</string>
    <string name="call_settings_summary" msgid="7291195704801002886">"Konfiguro postën zanore, transferimin e telefonatave, telefonatat në pritje dhe ID-në e telefonuesit"</string>
    <string name="tether_settings_title_usb" msgid="6688416425801386511">"Ndarje përmes USB-së"</string>
    <string name="tether_settings_title_wifi" msgid="3277144155960302049">"Zona e qasjes e lëvizshme"</string>
    <string name="tether_settings_title_bluetooth" msgid="355855408317564420">"Ndarje interneti përmes Bluetooth-it"</string>
    <string name="tether_settings_title_usb_bluetooth" msgid="5355828977109785001">"Ndarja e internetit"</string>
    <string name="tether_settings_title_all" msgid="3058586928118801157">"Zona e qasjes dhe ndarja e internetit"</string>
    <string name="tether_settings_summary_hotspot_on_tether_on" msgid="930464462687425777">"Zona e qasjes së internetit aktive, interneti po ndahet"</string>
    <string name="tether_settings_summary_hotspot_on_tether_off" msgid="3473671453891735907">"Zona e qasjes së internetit aktive"</string>
    <string name="tether_settings_summary_hotspot_off_tether_on" msgid="1618256180720077354">"Ndarja e internetit"</string>
    <string name="tether_settings_disabled_on_data_saver" msgid="1576908608463904152">"Nuk mund të ndajë internetin ose të përdorë zonat e qasjes në internet kur \"Kursyesi i të dhënave\" është aktiv"</string>
    <string name="usb_title" msgid="7483344855356312510">"USB"</string>
    <string name="usb_tethering_button_text" msgid="585829947108007917">"Ndarje përmes USB-së"</string>
    <string name="usb_tethering_subtext" product="default" msgid="3711893746716442706">"Ndaj lidhjen e internetit të telefonit nëpërmjet USB-së"</string>
    <string name="usb_tethering_subtext" product="tablet" msgid="2292916486612255069">"Ndaj lidhjen e internetit të tabletit nëpërmjet USB-së"</string>
    <string name="bluetooth_tether_checkbox_text" msgid="2379175828878753652">"Ndarje interneti përmes Bluetooth-it"</string>
    <string name="bluetooth_tethering_subtext" product="tablet" msgid="8828883800511737077">"Ndaj lidhjen e internetit të tabletit nëpërmjet Bluetooth-it"</string>
    <string name="bluetooth_tethering_subtext" product="default" msgid="1904667146601254812">"Ndaj lidhjen e internetit të telefonit nëpërmjet Bluetooth-it"</string>
    <string name="bluetooth_tethering_off_subtext_config" msgid="376389105752995580">"Po e ndan lidhjen e internetit të kësaj pajisjeje <xliff:g id="DEVICE_NAME">%1$d</xliff:g> përmes Bluetooth-it"</string>
    <string name="bluetooth_tethering_overflow_error" msgid="2135590598511178690">"Ndarja e internetit nuk mund të bëhet për më shumë se <xliff:g id="MAXCONNECTION">%1$d</xliff:g> pajisje."</string>
    <string name="bluetooth_untether_blank" msgid="2871192409329334813">"Ndarja e internetit do të çaktivizohet për <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="tethering_footer_info" msgid="7112228674056306147">"Përdor zonën e qasjes dhe ndarjen e internetit për t\'u ofruar internet pajisjeve të tjera nëpërmjet lidhjes tënde të të dhënave celulare. Aplikacionet mund të krijojnë po ashtu një zonë qasjeje të internetit për të ndarë përmbajtje me pajisjet në afërsi."</string>
    <string name="tethering_help_button_text" msgid="656117495547173630">"Ndihma"</string>
    <string name="network_settings_title" msgid="2876509814832830757">"Rrjeti celular"</string>
    <string name="manage_mobile_plan_title" msgid="7630170375010107744">"Plani celular"</string>
    <string name="sms_application_title" msgid="4903928270533250448">"Aplikacioni për SMS"</string>
    <string name="sms_change_default_dialog_title" msgid="1958688831875804286">"Të ndryshohet aplikacioni i SMS-ve?"</string>
    <string name="sms_change_default_dialog_text" msgid="1522783933230274787">"Të përdoret <xliff:g id="NEW_APP">%1$s</xliff:g> në vend të <xliff:g id="CURRENT_APP">%2$s</xliff:g> si aplikacioni për SMS?"</string>
    <string name="sms_change_default_no_previous_dialog_text" msgid="602683880284921998">"Të përdoret <xliff:g id="NEW_APP">%s</xliff:g> si aplikacioni për SMS-të?"</string>
    <string name="network_scorer_picker_title" msgid="6383879578279046456">"Ofruesi i vlerësimit të rrjetit"</string>
    <string name="network_scorer_picker_none_preference" msgid="9028375117241790936">"Asnjë"</string>
    <string name="network_scorer_change_active_dialog_title" msgid="3776301550387574975">"Të ndryshohet ndihmësi i Wi‑Fi?"</string>
    <string name="network_scorer_change_active_dialog_text" msgid="8035173880322990715">"Të përdoret <xliff:g id="NEW_APP">%1$s</xliff:g> në vend të <xliff:g id="CURRENT_APP">%2$s</xliff:g> për të menaxhuar lidhjet e rrjetit?"</string>
    <string name="network_scorer_change_active_no_previous_dialog_text" msgid="7444620909047611601">"Të përdoret <xliff:g id="NEW_APP">%s</xliff:g> për të menaxhuar lidhjet e rrjetit?"</string>
    <string name="mobile_unknown_sim_operator" msgid="2156912373230276157">"Operatori i kartës SIM është i panjohur"</string>
    <string name="mobile_no_provisioning_url" msgid="9053814051811634125">"<xliff:g id="OPERATOR">%1$s</xliff:g> nuk ka faqe të sigurt e të njohur"</string>
    <string name="mobile_insert_sim_card" msgid="9052590985784056395">"Vendos kartën SIM dhe rinise"</string>
    <string name="mobile_connect_to_internet" msgid="1733894125065249639">"Lidhu me internetin"</string>
    <string name="location_category_recent_location_requests" msgid="1938721350424447421">"Kërkesat e vendndodhjeve të fundit"</string>
    <string name="location_recent_location_requests_see_all" msgid="9063541547120162593">"Shfaq çdo gjë"</string>
    <string name="location_category_location_services" msgid="7437150886946685979">"Shërbimet e vendndodhjes"</string>
    <string name="location_title" msgid="1029961368397484576">"Vendndodhja ime"</string>
    <string name="managed_profile_location_switch_title" msgid="6712332547063039683">"Vend. për profilin e punës"</string>
    <string name="location_app_level_permissions" msgid="2777033567595680764">"Autorizimi i aplikacionit"</string>
    <string name="location_app_permission_summary_location_off" msgid="2790918244874943070">"Vendndodhja është joaktive"</string>
    <plurals name="location_app_permission_summary_location_on" formatted="false" msgid="5336807018727349708">
      <item quantity="other"> <xliff:g id="PERMITTED_LOCATION_APP_COUNT_2">%1$d</xliff:g> nga <xliff:g id="TOTAL_LOCATION_APP_COUNT_3">%2$d</xliff:g> aplikacione kanë qasje te vendndodhja</item>
      <item quantity="one"> <xliff:g id="PERMITTED_LOCATION_APP_COUNT_0">%1$d</xliff:g> nga <xliff:g id="TOTAL_LOCATION_APP_COUNT_1">%2$d</xliff:g> aplikacione ka qasje te vendndodhja</item>
    </plurals>
    <string name="location_category_recent_location_access" msgid="4911449278675337490">"Qasja te vendndodhja e fundit"</string>
    <string name="location_recent_location_access_view_details" msgid="1955078513330927035">"Shiko detajet"</string>
    <string name="location_no_recent_apps" msgid="2800907699722178041">"Asnjë aplikacion nuk ka kërkuar vendndodhje kohët e fundit"</string>
    <string name="location_no_recent_accesses" msgid="7489449862187886009">"Asnjë aplikacion nuk ka pasur qasje te vendndodhja së fundi"</string>
    <string name="location_high_battery_use" msgid="517199943258508020">"Përdorimi i lartë i baterisë"</string>
    <string name="location_low_battery_use" msgid="8602232529541903596">"Përdorim i ulët baterie"</string>
    <string name="location_scanning_screen_title" msgid="2297479353298444503">"Skanimi për Wi‑Fi dhe Bluetooth"</string>
    <string name="location_scanning_wifi_always_scanning_title" msgid="6216705505621183645">"Skanimi i Wi-Fi"</string>
    <string name="location_scanning_wifi_always_scanning_description" msgid="2691110218127379249">"Lejo që aplikacionet dhe shërbimet të skanojnë për rrjete Wi-Fi në çdo moment, edhe kur Wi-Fi është joaktiv. Kjo mund të përdoret, për shembull, për të përmirësuar funksionet dhe shërbimet e bazuara te vendndodhja."</string>
    <string name="location_scanning_bluetooth_always_scanning_title" msgid="5444989508204520019">"Skanimi i Bluetooth-it"</string>
    <string name="location_scanning_bluetooth_always_scanning_description" msgid="1285526059945206128">"Lejo që aplikacionet dhe shërbimet të skanojnë për pajisje në afërsi në çdo moment, edhe kur Bluetooth është joaktiv. Kjo mund të përdoret, për shembull, për të përmirësuar funksionet dhe shërbimet e bazuara te vendndodhja."</string>
    <string name="managed_profile_location_services" msgid="4723268446874715222">"Shërbimet e vendndodhjes për punë"</string>
    <string name="location_network_based" msgid="9134175479520582215">"Vend. rrjetit Wi‑Fi e celular"</string>
    <string name="location_neighborhood_level" msgid="5141318121229984788">"Lejo aplikacionet të përdorin shërbimin e vendndodhjes së Google për të llogaritur më shpejt vendndodhjen tënde. Të dhënat e vendndodhjes do të jenë anonime dhe do të mblidhen e do t\'i dërgohen Google."</string>
    <string name="location_neighborhood_level_wifi" msgid="4234820941954812210">"Vendndodhja u përcaktua nga Wi‑Fi"</string>
    <string name="location_gps" msgid="8392461023569708478">"Satelitët GPS"</string>
    <string name="location_street_level" product="tablet" msgid="1669562198260860802">"Lejo aplikacionet të përdorin GPS-në në tablet për të shënuar vendndodhjen tënde"</string>
    <string name="location_street_level" product="default" msgid="4617445745492014203">"Lejo aplikacionet të përdorin GPS-në në telefon për të përcaktuar me saktësi vendndodhjen tënde"</string>
    <string name="assisted_gps" msgid="4649317129586736885">"Përdor GPS-në e ndihmuar"</string>
    <string name="assisted_gps_enabled" msgid="8751899609589792803">"Përdor serverin për të ndihmuar GPS-në (anulo zgjedhjen për të zvogëluar përdorimin e rrjetit)"</string>
    <string name="assisted_gps_disabled" msgid="6982698333968010748">"Përdor serverin për të ndihmuar GPS-në (anulo zgjedhjen për të përmirësuar veprimtarinë e GPS-së)"</string>
    <string name="use_location_title" msgid="5206937465504979977">"Vendndodhja dhe kërkimi në Google"</string>
    <string name="use_location_summary" msgid="3978805802386162520">"Lejo Google të përdorë vendndodhjen për të përmirësuar rezultatet e kërkimit dhe shërbime të tjera"</string>
    <string name="location_access_title" msgid="7064108942964081243">"Qasja në vendndodhjen time"</string>
    <string name="location_access_summary" msgid="69031404093194341">"Lejoji aplikacionet që kanë kërkuar lejen tënde të përdorin informacionin e vendndodhjes"</string>
    <string name="location_sources_heading" msgid="1278732419851088319">"Burimet e vendndodhjes"</string>
    <string name="about_settings" product="tablet" msgid="593457295516533765">"Rreth tabletit"</string>
    <string name="about_settings" product="default" msgid="1743378368185371685">"Informacion mbi telefonin"</string>
    <string name="about_settings" product="device" msgid="6717640957897546887">"Informacione rreth pajisjes"</string>
    <string name="about_settings" product="emulator" msgid="221313099578564438">"Rreth emulatorit"</string>
    <string name="about_settings_summary" msgid="3371517697156165959">"Shiko informacionin ligjor, statusin dhe versionin e softuerit"</string>
    <string name="legal_information" msgid="5769301644270604095">"Informacioni ligjor"</string>
    <string name="contributors_title" msgid="5917703088825286504">"Kontribuuesit"</string>
    <string name="manual" msgid="3025943393642974445">"Manuale"</string>
    <string name="regulatory_labels" msgid="1293050314122427492">"Etiketat rregullatore"</string>
    <string name="safety_and_regulatory_info" msgid="5103161279848427185">"Manuali rregullator dhe i sigurisë"</string>
    <string name="copyright_title" msgid="865906688917260647">"Të drejtat e autorit"</string>
    <string name="license_title" msgid="1990487604356037871">"Licenca"</string>
    <string name="module_license_title" msgid="258743239066841860">"Licencat e përditësimit të sistemit të Google Play"</string>
    <string name="terms_title" msgid="7697580845616764642">"Kushtet e përgjithshme"</string>
    <string name="webview_license_title" msgid="2813507464175738967">"Licenca e WebView në sistem"</string>
    <string name="wallpaper_attributions" msgid="3645880512943433928">"Imazhet e sfondit"</string>
    <string name="wallpaper_attributions_values" msgid="2996183537914690469">"Ofruesit e imazheve satelitore:\n©2014 CNES / Astrium, DigitalGlobe, Bluesky"</string>
    <string name="settings_manual_activity_title" msgid="8133150693616006051">"Manuale"</string>
    <string name="settings_manual_activity_unavailable" msgid="4752403782883814898">"Ka një problem me ngarkimin e manualit."</string>
    <string name="settings_license_activity_title" msgid="8525014571806471216">"Licencat e palëve të treta"</string>
    <string name="settings_license_activity_unavailable" msgid="4210539215951487627">"Ka një problem me ngarkimin e licencave."</string>
    <string name="settings_license_activity_loading" msgid="3337535809093591740">"Po ngarkon..."</string>
    <string name="settings_safetylegal_title" msgid="1289483965535937431">"Informacioni i sigurisë"</string>
    <string name="settings_safetylegal_activity_title" msgid="6901214628496951727">"Informacioni i sigurisë"</string>
    <string name="settings_safetylegal_activity_unreachable" msgid="142307697309858185">"Nuk ke një lidhje të dhënash. Për të parë këtë informacion tani, shko te %s nga një kompjuter i lidhur me internetin."</string>
    <string name="settings_safetylegal_activity_loading" msgid="8059022597639516348">"Po ngarkon..."</string>
    <string name="confirm_device_credential_pin" msgid="5308435093406166355">"Përdor kodin PIN"</string>
    <string name="confirm_device_credential_pattern" msgid="1350321840134412900">"Përdor motivin"</string>
    <string name="confirm_device_credential_password" msgid="2195705238498478704">"Përdor fjalëkalimin"</string>
    <string name="lockpassword_choose_your_screen_lock_header" msgid="2942199737559900752">"Vendos kyçjen e ekranit"</string>
    <string name="lockpassword_choose_your_password_message" msgid="5377842480961577542">"Për siguri, cakto një fjalëkalim"</string>
    <string name="lockpassword_choose_your_password_header_for_fingerprint" msgid="6624409510609085450">"Për të përdorur gjurmën e gishtit, vendos fjalëkalimin"</string>
    <string name="lockpassword_choose_your_pattern_header_for_fingerprint" msgid="5901096361617543819">"Për të përdorur gjurmën e gishtit, vendos motivin"</string>
    <string name="lockpassword_choose_your_pin_message" msgid="6658264750811929338">"Për siguri, cakto një kod PIN"</string>
    <string name="lockpassword_choose_your_pin_header_for_fingerprint" msgid="765344692615917183">"Për të përdorur gjurmën e gishtit, vendos kodin PIN"</string>
    <string name="lockpassword_choose_your_pattern_message" msgid="8631545254345759087">"Për siguri, cakto një motiv"</string>
    <string name="lockpassword_confirm_your_password_header" msgid="1266027268220850931">"Fut përsëri fjalëkalimin"</string>
    <string name="lockpassword_confirm_your_pattern_header" msgid="7543433733032330821">"Konfirmo motivin"</string>
    <string name="lockpassword_confirm_your_pin_header" msgid="7744513791910572550">"Fut përsëri kodin PIN"</string>
    <string name="lockpassword_confirm_passwords_dont_match" msgid="5140892109439191415">"Fjalëkalimet nuk përputhen"</string>
    <string name="lockpassword_confirm_pins_dont_match" msgid="7226244811505606217">"Kodet PIN nuk përputhen"</string>
    <string name="lockpassword_draw_your_pattern_again_header" msgid="2872194349688886781">"Vizato sërish motivin tënd"</string>
    <string name="lockpassword_choose_lock_generic_header" msgid="3811438094903786145">"Përzgjedhja e shkyçjes"</string>
    <string name="lockpassword_password_set_toast" msgid="4875050283108629383">"Fjalëkalimi është caktuar"</string>
    <string name="lockpassword_pin_set_toast" msgid="6011826444725291475">"Kodi PIN është caktuar"</string>
    <string name="lockpassword_pattern_set_toast" msgid="6867259621331406236">"Motivi është caktuar"</string>
    <string name="lockpassword_choose_your_password_header_for_face" msgid="6696331060928616331">"Për të përdorur shkyçjen me fytyrë, cakto fjalëkalimin"</string>
    <string name="lockpassword_choose_your_pattern_header_for_face" msgid="3981667199682290816">"Për të përdorur shkyçjen me fytyrë, cakto motivin"</string>
    <string name="lockpassword_choose_your_pin_header_for_face" msgid="3692990199320431002">"Për të përdorur kyçjen me fytyrë, cakto kodin PIN"</string>
    <string name="lockpassword_confirm_your_pattern_generic" msgid="2920960858283879113">"Përdor motivin e pajisjes për të vazhduar"</string>
    <string name="lockpassword_confirm_your_pin_generic" msgid="4062335874438910487">"Fut kodin PIN të pajisjes për të vazhduar"</string>
    <string name="lockpassword_confirm_your_password_generic" msgid="3976394862548354966">"Fut fjalëkalimin e pajisjes për të vazhduar"</string>
    <string name="lockpassword_confirm_your_pattern_generic_profile" msgid="4435638308193361861">"Përdor motivin tënd të punës për të vazhduar"</string>
    <string name="lockpassword_confirm_your_pin_generic_profile" msgid="3730141667547002246">"Fut kodin tënd PIN të punës për të vazhduar"</string>
    <string name="lockpassword_confirm_your_password_generic_profile" msgid="4250642723467019894">"Fut fjalëkalimin tënd të punës për të vazhduar"</string>
    <string name="lockpassword_strong_auth_required_device_pattern" msgid="530802132223800623">"Për më shumë siguri, përdor motivin e pajisjes"</string>
    <string name="lockpassword_strong_auth_required_device_pin" msgid="7829294830078036417">"Për më shumë siguri, fut kodin PIN të pajisjes"</string>
    <string name="lockpassword_strong_auth_required_device_password" msgid="3552644641574796973">"Për më shumë siguri, fut fjalëkalimin e pajisjes"</string>
    <string name="lockpassword_strong_auth_required_work_pattern" msgid="3003781907040522053">"Për më shumë siguri, përdor motivin e punës"</string>
    <string name="lockpassword_strong_auth_required_work_pin" msgid="3367491332598821552">"Për më shumë siguri, fut kodin PIN të punës"</string>
    <string name="lockpassword_strong_auth_required_work_password" msgid="8159775129968582940">"Për më shumë siguri, fut fjalëkalimin e punës"</string>
    <string name="lockpassword_confirm_your_pattern_details_frp" msgid="6757336656791723193">"Telefoni u vendos në cilësimet e fabrikës. Për ta përdorur këtë telefon, fut motivin e mëparshëm."</string>
    <string name="lockpassword_confirm_your_pin_details_frp" msgid="826520613445990470">"Telefoni u vendos në cilësimet e fabrikës. Për ta përdorur këtë telefon, fut kodin PIN të mëparshëm."</string>
    <string name="lockpassword_confirm_your_password_details_frp" msgid="8944081074615739040">"Telefoni u vendos në cilësimet e fabrikës. Për ta përdorur këtë telefon, fut fjalëkalimin e mëparshëm."</string>
    <string name="lockpassword_confirm_your_pattern_header_frp" msgid="2898036091609128286">"Verifiko motivin"</string>
    <string name="lockpassword_confirm_your_pin_header_frp" msgid="4141601774778898803">"Verifiko kodin PIN"</string>
    <string name="lockpassword_confirm_your_password_header_frp" msgid="3762615419295360480">"Verifiko fjalëkalimin"</string>
    <string name="lockpassword_invalid_pin" msgid="15588049067548470">"Kod PIN i gabuar"</string>
    <string name="lockpassword_invalid_password" msgid="4038507398784975200">"Fjalëkalim i gabuar"</string>
    <string name="lockpattern_need_to_unlock_wrong" msgid="1745247595356012176">"Motiv i gabuar"</string>
    <string name="lock_settings_title" msgid="4213839087748988686">"Siguria e pajisjes"</string>
    <string name="lockpattern_change_lock_pattern_label" msgid="5679630792003440352">"Ndrysho motivin e shkyçjes"</string>
    <string name="lockpattern_change_lock_pin_label" msgid="266707138486731661">"Ndrysho kodin PIN të shkyçjes"</string>
    <string name="lockpattern_recording_intro_header" msgid="308287052221942814">"Vizato një motiv shkyçjeje"</string>
    <string name="lockpattern_recording_intro_footer" msgid="1118579101409152113">"Shtyp Menynë për ndihmë."</string>
    <string name="lockpattern_recording_inprogress" msgid="6667844062721656773">"Hiqe gishtin kur të mbarosh"</string>
    <string name="lockpattern_recording_incorrect_too_short" msgid="1348234155120957561">"Lidh të paktën <xliff:g id="NUMBER">%d</xliff:g> pika. Provo përsëri."</string>
    <string name="lockpattern_pattern_entered_header" msgid="4316818983675591604">"Motivi u regjistrua"</string>
    <string name="lockpattern_need_to_confirm" msgid="8054853451639221265">"Vizato sërish motivin për ta konfirmuar"</string>
    <string name="lockpattern_pattern_confirmed_header" msgid="8455614172231880211">"Motivi i ri i shkyçjes"</string>
    <string name="lockpattern_confirm_button_text" msgid="1128204343957002841">"Konfirmo"</string>
    <string name="lockpattern_restart_button_text" msgid="3337574403350953926">"Tërhiq sërish"</string>
    <string name="lockpattern_retry_button_text" msgid="3480423193273588166">"Pastro"</string>
    <string name="lockpattern_continue_button_text" msgid="4723771754714471410">"Vazhdo"</string>
    <string name="lockpattern_settings_title" msgid="3207750489460466680">"Motivi i shkyçjes"</string>
    <string name="lockpattern_settings_enable_title" msgid="6920616873671115281">"Kërko motivin"</string>
    <string name="lockpattern_settings_enable_summary" msgid="1165707416664252167">"Duhet të vizatosh motivin për të shkyçur ekranin"</string>
    <string name="lockpattern_settings_enable_visible_pattern_title" msgid="2615606088906120711">"Bëje motivin të dukshëm"</string>
    <string name="lockpattern_settings_enable_visible_pattern_title_profile" msgid="4864525074768391381">"Bëje të dukshëm motivin e profilit"</string>
    <string name="lockpattern_settings_enable_tactile_feedback_title" msgid="4389015658335522989">"Dridhje pas trokitjes"</string>
    <string name="lockpattern_settings_enable_power_button_instantly_locks" msgid="5735444062633666327">"Butoni i fikjes e kyç menjëherë"</string>
    <string name="lockpattern_settings_power_button_instantly_locks_summary" msgid="8196258755143711694">"Përveçse kur mbahet i shkyçur nga <xliff:g id="TRUST_AGENT_NAME">%1$s</xliff:g>"</string>
    <string name="lockpattern_settings_choose_lock_pattern" msgid="1652352830005653447">"Cakto motivin e shkyçjes"</string>
    <string name="lockpattern_settings_change_lock_pattern" msgid="1123908306116495545">"Ndrysho motivin e shkyçjes"</string>
    <string name="lockpattern_settings_help_how_to_record" msgid="2614673439060830433">"Si të vizatosh një motiv shkyçjeje"</string>
    <string name="lockpattern_too_many_failed_confirmation_attempts" msgid="6909161623701848863">"Shumë tentativa të pasakta. Provo sërish brenda <xliff:g id="NUMBER">%d</xliff:g> sekondash."</string>
    <string name="activity_not_found" msgid="5551664692991605325">"Aplikacioni nuk është i instaluar në telefonin tënd."</string>
    <string name="lock_settings_profile_title" msgid="2121876391814535295">"Siguria e profilit të punës"</string>
    <string name="lock_settings_profile_screen_lock_title" msgid="3334747927367115256">"Kyçja e ekranit të profilit të punës"</string>
    <string name="lock_settings_profile_unification_title" msgid="4973102698492659123">"Përdor një kyçje të vetme"</string>
    <string name="lock_settings_profile_unification_summary" msgid="7178299172998641303">"Përdorni një kyçje të vetme për profilin e punës dhe ekranin e pajisjes"</string>
    <string name="lock_settings_profile_unification_dialog_title" msgid="4824620230229285301">"Të përdoret një kyçje e vetme?"</string>
    <string name="lock_settings_profile_unification_dialog_body" msgid="7128305504872026659">"Pajisja jote do të përdorë ekranin e kyçjes së profilit të punës. Politikat e punës do të zbatohen për të dyja kyçjet."</string>
    <string name="lock_settings_profile_unification_dialog_uncompliant_body" msgid="3221303098797469900">"Kyçja e ekranit e punës nuk i plotëson kërkesat e sigurisë së organizatës tënde. Mund të përdorësh të njëjtën kyçje për ekranin e pajisjes tënde dhe për profilin e punës, por do të zbatohet çdo politikë për kyçjen e punës."</string>
    <string name="lock_settings_profile_unification_dialog_confirm" msgid="8249970828159656518">"Përdor një kyçje të vetme"</string>
    <string name="lock_settings_profile_unification_dialog_uncompliant_confirm" msgid="5943758576756482777">"Përdor një kyçje të vetme"</string>
    <string name="lock_settings_profile_unified_summary" msgid="9008819078132993492">"Njësoj si kyçja e ekranit të pajisjes"</string>
    <string name="manageapplications_settings_title" msgid="7041951105633616745">"Menaxho aplikacionet"</string>
    <string name="manageapplications_settings_summary" msgid="1794401500935451259">"Menaxho dhe hiq aplikacionet e instaluara"</string>
    <string name="applications_settings" msgid="5281808652705396152">"Informacioni mbi aplikacionin"</string>
    <string name="applications_settings_summary" msgid="6683465446264515367">"Menaxho aplikacionet, konfiguro shkurtoret e hapjes së shpejtë"</string>
    <string name="applications_settings_header" msgid="1014813055054356646">"Cilësimet e apl."</string>
    <string name="install_applications" msgid="4872012136210802181">"Burime të panjohura"</string>
    <string name="install_applications_title" msgid="4987712352256508946">"Lejo të gjitha burimet e apl."</string>
    <string name="recent_app_category_title" msgid="6673071268966003928">"Aplikacionet e hapura së fundi"</string>
    <string name="see_all_apps_title" msgid="1317153498074308438">"Shiko të <xliff:g id="COUNT">%1$d</xliff:g> aplikacionet"</string>
    <string name="install_all_warning" product="tablet" msgid="8310489909586138165">"Tableti dhe të dhënat e tua personale janë më të cenueshme për t\'u sulmuar nga aplikacione të panjohura. Duke instaluar aplikacionet nga ky burim, ti pranon se je plotësisht përgjegjës për çdo dëm ndaj tabletit ose çdo humbje të dhënash që mund të rezultojë nga përdorimi i tyre."</string>
    <string name="install_all_warning" product="default" msgid="1952257127370115988">"Telefoni dhe të dhënat e tua personale janë më të cenueshme për t\'u sulmuar nga aplikacione të panjohura. Duke instaluar aplikacionet nga ky burim, ti pranon se je plotësisht përgjegjës për çdo dëm ndaj telefonit ose çdo humbje të dhënash që mund të rezultojë nga përdorimi i tyre."</string>
    <string name="install_all_warning" product="device" msgid="3648003301476423145">"Pajisja dhe të dhënat e tua personale janë më të cenueshme nga sulmet nga aplikacionet e panjohura. Duke instaluar aplikacionet nga ky burim, ti pranon se je përgjegjës për çdo dëm ndaj pajisjes tënde ose çdo humbje të të dhënave që mund të rezultojë nga përdorimi i tyre."</string>
    <string name="advanced_settings" msgid="1777249286757067969">"Cilësimet e përparuara"</string>
    <string name="advanced_settings_summary" msgid="4016682978071086747">"Aktivizo më shumë opsione të cilësimeve"</string>
    <string name="application_info_label" msgid="5736524913065714880">"Informacioni i apl."</string>
    <string name="storage_label" msgid="8700867073480107253">"Hapësira ruajtëse"</string>
    <string name="auto_launch_label" msgid="2669236885531442195">"Hap me parazgjedhje"</string>
    <string name="auto_launch_label_generic" msgid="3230569852551968694">"Parazgjedhjet"</string>
    <string name="screen_compatibility_label" msgid="663250687205465394">"Përputhshmëria e ekranit"</string>
    <string name="permissions_label" msgid="2605296874922726203">"Lejet"</string>
    <string name="cache_header_label" msgid="1877197634162461830">"Memoria specifike"</string>
    <string name="clear_cache_btn_text" msgid="5756314834291116325">"Pastro memorien specifike"</string>
    <string name="cache_size_label" msgid="7505481393108282913">"Memoria specifike"</string>
    <plurals name="uri_permissions_text" formatted="false" msgid="3983110543017963732">
      <item quantity="other">%d artikuj</item>
      <item quantity="one">1 artikull</item>
    </plurals>
    <string name="clear_uri_btn_text" msgid="8575655132961012158">"Qasje e pastër"</string>
    <string name="controls_label" msgid="7611113077086853799">"Kontrollet"</string>
    <string name="force_stop" msgid="7435006169872876756">"Ndalo me forcë"</string>
    <string name="total_size_label" msgid="1048676419552557254">"Totali"</string>
    <string name="application_size_label" msgid="7376689739076506885">"Madhësia e aplikacionit"</string>
    <string name="external_code_size_label" msgid="3459343140355961335">"Aplikacioni i hapësirës ruajtëse të USB-së"</string>
    <string name="data_size_label" msgid="6117971066063850416">"Të dhënat e përdoruesit"</string>
    <string name="external_data_size_label" product="nosdcard" msgid="7533821466482000453">"Të dhënat e hapësirës ruajtëse të USB-së"</string>
    <string name="external_data_size_label" product="default" msgid="626414192825329708">"Karta SD"</string>
    <string name="uninstall_text" msgid="3644892466144802466">"Çinstalo"</string>
    <string name="uninstall_all_users_text" msgid="851857393177950340">"Çinstaloje për të gjithë përdoruesit"</string>
    <string name="install_text" msgid="884360662922471113">"Instalo"</string>
    <string name="disable_text" msgid="6544054052049395202">"Çaktivizo"</string>
    <string name="enable_text" msgid="9217362512327828987">"Aktivizo"</string>
    <string name="clear_user_data_text" msgid="355574089263023363">"Pastro hapësirën ruajtëse"</string>
    <string name="app_factory_reset" msgid="6635744722502563022">"Çinstalo përditësimet"</string>
    <string name="auto_launch_enable_text" msgid="4275746249511874845">"Ke zgjedhur që ta hapësh këtë aplikacion në mënyrë të parazgjedhur për disa veprime."</string>
    <string name="always_allow_bind_appwidgets_text" msgid="566822577792032925">"Ke zgjedhur ta lejosh këtë aplikacion të krijojë dhe të ketë qasje te të dhënat e tyre."</string>
    <string name="auto_launch_disable_text" msgid="7800385822185540166">"Nuk ka parazgjedhje të caktuara."</string>
    <string name="clear_activities" msgid="7408923511535174430">"Fshi parazgjedhjet"</string>
    <string name="screen_compatibility_text" msgid="1616155457673106022">"Ky aplikacion mund të mos jetë i projektuar për ekranin tënd. Mund të kontrollosh si përputhet me ekranin tënd këtu."</string>
    <string name="ask_compatibility" msgid="7225195569089607846">"Pyet kur të hapet"</string>
    <string name="enable_compatibility" msgid="5806819252068617811">"Shkallëzo aplikacionin"</string>
    <string name="unknown" msgid="1592123443519355854">"I panjohur"</string>
    <string name="sort_order_alpha" msgid="1410278099123670628">"Rendit sipas emrit"</string>
    <string name="sort_order_size" msgid="7024513286636502362">"Rendit sipas madhësisë"</string>
    <string name="sort_order_recent_notification" msgid="6064103501358974282">"Më të fundit"</string>
    <string name="sort_order_frequent_notification" msgid="1733204081305830670">"Më të shpeshta"</string>
    <string name="show_running_services" msgid="5736278767975544570">"Shfaq shërbimet që po ekzekutohen"</string>
    <string name="show_background_processes" msgid="2009840211972293429">"Shfaq proceset specifike"</string>
    <string name="default_emergency_app" msgid="1951760659640369980">"Aplikacioni i emergjencave"</string>
    <string name="reset_app_preferences" msgid="1321050641018356925">"Rivendos preferencat e apl."</string>
    <string name="reset_app_preferences_title" msgid="6093179367325336662">"Të rivendosen preferencat e aplikacionit?"</string>
    <string name="reset_app_preferences_desc" msgid="4822447731869201512">"Kjo do t\'i rivendosë të gjitha preferencat për:\n\n"<li>"Aplikacionet e çaktivizuara"</li>\n<li>"Njoftimet e aplikacioneve të çaktivizuara"</li>\n<li>"Aplikacionet e parazgjedhura për veprimet"</li>\n<li>"Kufizimet e të dhënave në sfond për aplikacionet"</li>\n<li>"Çdo kufizim të lejes"</li>\n\n" Nuk do të humbësh asnjë të dhënë aplikacioni."</string>
    <string name="reset_app_preferences_button" msgid="2559089511841281242">"Rivendos aplikacionet"</string>
    <string name="manage_space_text" msgid="8852711522447794676">"Menaxho hapësirën"</string>
    <string name="filter" msgid="2018011724373033887">"Filtro"</string>
    <string name="filter_dlg_title" msgid="8693024463731076091">"Zgjidh opsionet e filtrit"</string>
    <string name="filter_apps_all" msgid="8899612398848280352">"Të gjitha aplikacionet"</string>
    <string name="filter_apps_disabled" msgid="5862632369555319938">"Aplikacionet e çaktivizuara"</string>
    <string name="filter_apps_third_party" msgid="7786348047690140979">"Të shkarkuara"</string>
    <string name="filter_apps_running" msgid="7767071454371350486">"Vrapim"</string>
    <string name="filter_apps_onsdcard" product="nosdcard" msgid="4843063154701023349">"Hapësira ruajtëse e USB-së"</string>
    <string name="filter_apps_onsdcard" product="default" msgid="1477351142334784771">"Në kartën SD"</string>
    <string name="not_installed" msgid="2797554494953450291">"Nuk është i instaluar për këtë përdorues"</string>
    <string name="installed" msgid="3070865169422600098">"I instaluar"</string>
    <string name="no_applications" msgid="7336588977497084921">"Asnjë aplikacion."</string>
    <string name="internal_storage" msgid="1584700623164275282">"Hapësira e brendshme ruajtëse"</string>
    <string name="recompute_size" msgid="7722567982831691718">"Po llogarit përsëri madhësinë…"</string>
    <string name="clear_data_dlg_title" msgid="5605258400134511197">"Të fshihen të dhënat e aplikacionit?"</string>
    <string name="clear_data_dlg_text" msgid="3951297329833822490">"Të gjitha të dhënat e këtij aplikacioni do të fshihen përgjithmonë. Kjo përfshin të gjithë skedarët, cilësimet, llogaritë, bazat e të dhënave etj."</string>
    <string name="dlg_ok" msgid="2402639055725653590">"Në rregull"</string>
    <string name="dlg_cancel" msgid="1674753358972975911">"Anulo"</string>
    <string name="app_not_found_dlg_title" msgid="3127123411738434964"></string>
    <string name="app_not_found_dlg_text" msgid="4893589904687340011">"Aplikacioni nuk u gjet në listën e aplikacioneve të instaluara."</string>
    <string name="clear_failed_dlg_text" msgid="8651231637137025815">"Nuk mund të pastrohet hapësira për aplikacionin."</string>
    <string name="join_two_items" msgid="1336880355987539064">"<xliff:g id="FIRST_ITEM">%1$s</xliff:g> dhe <xliff:g id="SECOND_ITEM">%2$s</xliff:g>"</string>
    <string name="join_two_unrelated_items" msgid="1873827777191260824">"<xliff:g id="FIRST_ITEM">%1$s</xliff:g>, <xliff:g id="SECOND_ITEM">%2$s</xliff:g>"</string>
    <string name="computing_size" msgid="1599186977475211186">"Po llogarit…"</string>
    <string name="invalid_size_value" msgid="1582744272718752951">"Madhësia e paketës nuk mund të llogaritej."</string>
    <string name="version_text" msgid="9189073826278676425">"versioni <xliff:g id="VERSION_NUM">%1$s</xliff:g>"</string>
    <string name="move_app" msgid="5042838441401731346">"Zhvendos"</string>
    <string name="move_app_to_internal" product="tablet" msgid="2299714147283854957">"Zhvendos te tableti"</string>
    <string name="move_app_to_internal" product="default" msgid="3895430471913858185">"Zhvendos te telefoni"</string>
    <string name="move_app_to_sdcard" product="nosdcard" msgid="4350451696315265420">"Zhvendose në USB"</string>
    <string name="move_app_to_sdcard" product="default" msgid="1143379049903056407">"Zhvendos te karta SD"</string>
    <string name="another_migration_already_in_progress" msgid="7817354268848365487">"Një migrim tjetër është tashmë në vazhdim."</string>
    <string name="insufficient_storage" msgid="481763122991093080">"Nuk ka hapësirë ruajtëse të mjaftueshme."</string>
    <string name="does_not_exist" msgid="1501243985586067053">"Aplikacioni nuk ekziston."</string>
    <string name="invalid_location" msgid="4354595459063675191">"Vendndodhja e instalimit nuk është e vlefshme."</string>
    <string name="system_package" msgid="1352722848400644991">"Përditësimet e sistemit nuk mund të instalohen në median e jashtme."</string>
    <string name="move_error_device_admin" msgid="8673026002690505763">"Aplikacioni i administratorit të pajisjes nuk mund të instalohet në media të jashtme"</string>
    <string name="force_stop_dlg_title" msgid="977530651470711366">"Të ndalohet me forcë?"</string>
    <string name="force_stop_dlg_text" msgid="7208364204467835578">"Nëse e ndalon me forcë një aplikacion, ai mund të përjetojë çrregullime në funksionim."</string>
    <string name="app_install_location_title" msgid="2068975150026852168">"Vendndodhja e preferuar e instalimit"</string>
    <string name="app_install_location_summary" msgid="5155453752692959098">"Ndrysho vendndodhjen e preferuar të instalimit për aplikacione të reja"</string>
    <string name="app_disable_dlg_positive" msgid="7375627244201714263">"Çaktivizo aplikacionin"</string>
    <string name="app_disable_dlg_text" msgid="1234624266290478136">"Nëse e çaktivizon këtë aplikacion, Android dhe aplikacionet e tjera mund të mos funksionojnë më siç pritet. Ki parasysh se nuk mund ta fshish këtë aplikacion pasi ai ka ardhur i instaluar paraprakisht në pajisjen tënde. Duke e çaktivizuar, mund ta kalosh këtë aplikacion në joaktiv dhe ta fshehësh në pajisjen tënde."</string>
    <string name="app_disable_notifications_dlg_title" msgid="7669264654851761857">"Të çaktivizohen njoftimet?"</string>
    <string name="app_install_details_group_title" msgid="7084623031296083574">"Dyqani"</string>
    <string name="app_install_details_title" msgid="6905279702654975207">"Detajet e aplikacioneve"</string>
    <string name="app_install_details_summary" msgid="6464796332049327547">"Aplikacioni i instaluar nga <xliff:g id="APP_STORE">%1$s</xliff:g>"</string>
    <string name="instant_app_details_summary" msgid="4529934403276907045">"Më shumë informacion rreth <xliff:g id="APP_STORE">%1$s</xliff:g>"</string>
    <string name="app_ops_running" msgid="7706949900637284122">"Në funksionim"</string>
    <string name="app_ops_never_used" msgid="9114608022906887802">"(Nuk përdoret asnjëherë)"</string>
    <string name="no_default_apps" msgid="2915315663141025400">"Asnjë apl. i parazgjedhur"</string>
    <string name="storageuse_settings_title" msgid="5657014373502630403">"Përdorimi i hapësirës ruajtëse"</string>
    <string name="storageuse_settings_summary" msgid="3748286507165697834">"Shiko hapësirën për ruajtje të përdorur nga aplikacionet"</string>
    <string name="service_restarting" msgid="2242747937372354306">"Po rinis..."</string>
    <string name="cached" msgid="1059590879740175019">"Procesi në sfond i ruajtur në memorien specifike"</string>
    <string name="no_running_services" msgid="2059536495597645347">"Nuk po ekzekutohet asgjë."</string>
    <string name="service_started_by_app" msgid="818675099014723551">"U nis nga aplikacioni."</string>
    <!-- no translation found for service_client_name (4037193625611815517) -->
    <skip />
    <string name="service_background_processes" msgid="6844156253576174488">"<xliff:g id="MEMORY">%1$s</xliff:g> të lira"</string>
    <string name="service_foreground_processes" msgid="7583975676795574276">"<xliff:g id="MEMORY">%1$s</xliff:g> përdorur"</string>
    <string name="memory" msgid="6609961111091483458">"RAM"</string>
    <!-- no translation found for service_process_name (4098932168654826656) -->
    <skip />
    <string name="running_process_item_user_label" msgid="3129887865552025943">"Përdoruesi: <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="running_process_item_removed_user_label" msgid="8250168004291472959">"Përdorues i hequr"</string>
    <string name="running_processes_item_description_s_s" msgid="5790575965282023145">"<xliff:g id="NUMPROCESS">%1$d</xliff:g> proces dhe <xliff:g id="NUMSERVICES">%2$d</xliff:g> shërbim"</string>
    <string name="running_processes_item_description_s_p" msgid="8019860457123222953">"<xliff:g id="NUMPROCESS">%1$d</xliff:g> proces dhe <xliff:g id="NUMSERVICES">%2$d</xliff:g> shërbime"</string>
    <string name="running_processes_item_description_p_s" msgid="744424668287252915">"<xliff:g id="NUMPROCESS">%1$d</xliff:g> procese dhe <xliff:g id="NUMSERVICES">%2$d</xliff:g> shërbim"</string>
    <string name="running_processes_item_description_p_p" msgid="1607384595790852782">"<xliff:g id="NUMPROCESS">%1$d</xliff:g> procese dhe <xliff:g id="NUMSERVICES">%2$d</xliff:g> shërbime"</string>
    <string name="running_processes_header_title" msgid="6588371727640789560">"Memoria e pajisjes"</string>
    <string name="running_processes_header_footer" msgid="723908176275428442">"Përdorimi i RAM-it nga aplikacionet"</string>
    <string name="running_processes_header_system_prefix" msgid="6104153299581682047">"Sistemi"</string>
    <string name="running_processes_header_apps_prefix" msgid="5787594452716832727">"Aplikacionet"</string>
    <string name="running_processes_header_free_prefix" msgid="4620613031737078415">"E lirë"</string>
    <string name="running_processes_header_used_prefix" msgid="5924288703085123978">"Në përdorim"</string>
    <string name="running_processes_header_cached_prefix" msgid="7950853188089434987">"Në memorien specifike"</string>
    <string name="running_processes_header_ram" msgid="996092388884426817">"<xliff:g id="RAM_0">%1$s</xliff:g> nga RAM-i"</string>
    <string name="runningservicedetails_settings_title" msgid="3224004818524731568">"Aplikacioni në ekzekutim"</string>
    <string name="no_services" msgid="7133900764462288263">"Jo aktiv"</string>
    <string name="runningservicedetails_services_title" msgid="391168243725357375">"Shërbimet"</string>
    <string name="runningservicedetails_processes_title" msgid="928115582044655268">"Proceset"</string>
    <string name="service_stop" msgid="6369807553277527248">"Ndalo"</string>
    <string name="service_manage" msgid="1876642087421959194">"Cilësimet"</string>
    <string name="service_stop_description" msgid="9146619928198961643">"Ky shërbim u nis nga aplikacioni i vet. Ndalimi i tij mund të shkarkojë dështimin e aplikacionit."</string>
    <string name="heavy_weight_stop_description" msgid="6050413065144035971">"Ky aplikacion nuk mund të ndalohet në mënyrë të sigurt. Nëse e ndalon, mund të humbësh disa nga puna jote aktuale."</string>
    <string name="background_process_stop_description" msgid="3834163804031287685">"Ky është një proces i vjetër i aplikacionit që po vazhdon të ekzekutohet për çdo rast nëse nevojitet sërish. Zakonisht nuk ka arsye për ta ndaluar."</string>
    <string name="service_manage_description" msgid="479683614471552426">"<xliff:g id="CLIENT_NAME">%1$s</xliff:g>: aktualisht në përdorim. Trokit te \"Cilësimet\" për ta kontrolluar."</string>
    <string name="main_running_process_description" msgid="1130702347066340890">"Procesi kryesor është në përdorim."</string>
    <string name="process_service_in_use_description" msgid="8993335064403217080">"Shërbimi <xliff:g id="COMP_NAME">%1$s</xliff:g> është në përdorim."</string>
    <string name="process_provider_in_use_description" msgid="5586603325677678940">"Ofruesi <xliff:g id="COMP_NAME">%1$s</xliff:g> është në përdorim."</string>
    <string name="runningservicedetails_stop_dlg_title" msgid="4253292537154337233">"Të ndalohet shërbimi i sistemit?"</string>
    <string name="runningservicedetails_stop_dlg_text" product="tablet" msgid="3371302398335665793">"Nëse e ndalon këtë shërbim, disa funksione të tabletit tënd mund të mos punojnë më si duhet, deri sa ta fikësh dhe më pas ta ndezësh përsëri."</string>
    <string name="runningservicedetails_stop_dlg_text" product="default" msgid="3920243762189484756">"Nëse e ndalon këtë shërbim, disa funksione të telefonit tënd mund të mos punojnë më si duhet deri sa ta fikësh dhe më pas ta ndezësh përsëri."</string>
    <string name="language_input_gesture_title" msgid="8749227808244881255">"Gjuhët, hyrja dhe gjestet"</string>
    <string name="language_input_gesture_summary_on_with_assist" msgid="7219895055450633449"></string>
    <string name="language_input_gesture_summary_on_non_assist" msgid="756147879200943161"></string>
    <string name="language_input_gesture_summary_off" msgid="4617198819416948217"></string>
    <string name="language_settings" msgid="8758655933029560944">"Gjuhët dhe të dhënat"</string>
    <string name="language_empty_list_user_restricted" msgid="5984015900102140696">"Nuk ke leje të ndryshosh gjuhën e pajisjes."</string>
    <string name="language_keyboard_settings_title" msgid="3709159207482544398">"Gjuhët dhe të dhënat"</string>
    <string name="input_assistance" msgid="7392740255874966807">"Veglat"</string>
    <string name="keyboard_settings_category" msgid="8275523930352487827">"Tastiera dhe metodat e hyrjes"</string>
    <string name="phone_language" msgid="7116581601133118044">"Gjuhët"</string>
    <string name="phone_language_summary" msgid="3871309445655554211"></string>
    <string name="auto_replace" msgid="6199184757891937822">"Zëvendëso automatikisht"</string>
    <string name="auto_replace_summary" msgid="370288728200084466">"Korrigjo fjalët e shkruara gabim"</string>
    <string name="auto_caps" msgid="6379232078052591265">"Kapitalizim automatik"</string>
    <string name="auto_caps_summary" msgid="6358102538315261466">"Filloji fjalitë me shkronjë të madhe"</string>
    <string name="auto_punctuate" msgid="4595367243950425833">"Vendos automatikisht pikësimin"</string>
    <string name="hardkeyboard_category" msgid="5957168411305769899">"Cilësimet e tastierës fizike"</string>
    <string name="auto_punctuate_summary" msgid="4372126865670574837">"Shtyp dy herë tastin Hapësirë për të futur \".\""</string>
    <string name="show_password" msgid="4837897357002495384">"Shfaq fjalëkalimet"</string>
    <string name="show_password_summary" msgid="3365397574784829969">"Shfaq karakteret shkurtimisht kur shkruan"</string>
    <string name="spellchecker_security_warning" msgid="9060897418527708922">"Ky kontrollues germëzimi mund të jenë në gjendje të mbledhë të gjithë tekstin që shkruan, përfshirë të dhëna personale si fjalëkalime dhe numra kartash krediti. Kjo vjen nga aplikacioni <xliff:g id="SPELLCHECKER_APPLICATION_NAME">%1$s</xliff:g>. Të përdoret ky kontrollues germëzimi?"</string>
    <string name="spellchecker_quick_settings" msgid="246728645150092058">"Cilësimet"</string>
    <string name="spellchecker_language" msgid="6041050114690541437">"Gjuha"</string>
    <string name="keyboard_and_input_methods_category" msgid="4580907662493721491">"Tastierat"</string>
    <string name="virtual_keyboard_category" msgid="1012830752318677119">"Tastiera virtuale"</string>
    <string name="available_virtual_keyboard_category" msgid="7645766574969139819">"Tastiera virtuale e disponueshme"</string>
    <string name="add_virtual_keyboard" msgid="3302152381456516928">"Menaxho tastierat"</string>
    <string name="keyboard_assistance_category" msgid="5843634175231134014">"Asistenca e tastierës"</string>
    <string name="physical_keyboard_title" msgid="8285149877925752042">"Tastiera fizike"</string>
    <string name="show_ime" msgid="2658582193437188227">"Shfaq tastierën virtuale"</string>
    <string name="show_ime_summary" msgid="8164993045923240698">"Mbaje në ekran ndërsa tastiera fizike është aktive"</string>
    <string name="keyboard_shortcuts_helper" msgid="4839453720463798145">"Ndihmësi i shkurtoreve të tastierës"</string>
    <string name="keyboard_shortcuts_helper_summary" msgid="5871299901459743288">"Shfaq shkurtoret e disponueshme"</string>
    <string name="language_and_input_for_work_category_title" msgid="3825906835886710498">"Tastierat dhe veglat e profilit të punës"</string>
    <string name="virtual_keyboards_for_work_title" msgid="2646946676585390499">"Tastiera virtuale për punë"</string>
    <string name="default_keyboard_layout" msgid="4172606673510531271">"E parazgjedhur"</string>
    <string name="pointer_speed" msgid="1221342330217861616">"Shpejtësia e treguesit"</string>
    <string name="game_controller_settings_category" msgid="8794508575329923718">"Kontrolluesi i lojës"</string>
    <string name="vibrate_input_devices" msgid="421936611134697943">"Ridrejto dridhjen"</string>
    <string name="vibrate_input_devices_summary" msgid="82093256723774584">"Dërgoji dridhjet te kontrolluesi i lojës kur të lidhet"</string>
    <string name="keyboard_layout_dialog_title" msgid="8030087214949381372">"Zgjidh planin e tastierës"</string>
    <string name="keyboard_layout_dialog_setup_button" msgid="8514583747236476384">"Konfiguro planet e tastierës"</string>
    <string name="keyboard_layout_dialog_switch_hint" msgid="3889961090676293795">"Për kalimin, shtyp \"Kontroll\" dhe \"Hapësirë\""</string>
    <string name="keyboard_layout_default_label" msgid="2952672513543482165">"E parazgjedhur"</string>
    <string name="keyboard_layout_picker_title" msgid="556081931972771610">"Planet e tastierës"</string>
    <string name="user_dict_settings_title" msgid="3427169369758733521">"Fjalori personal"</string>
    <string name="user_dict_settings_for_work_title" msgid="7634659414713254169">"Fjalori personal për punë"</string>
    <string name="user_dict_settings_summary" msgid="7965571192902870454"></string>
    <string name="user_dict_settings_add_menu_title" msgid="4056762757149923551">"Shto"</string>
    <string name="user_dict_settings_add_dialog_title" msgid="4702613990174126482">"Shto në fjalor"</string>
    <string name="user_dict_settings_add_screen_title" msgid="742580720124344291">"Fraza"</string>
    <string name="user_dict_settings_add_dialog_more_options" msgid="8848798370746019825">"Opsione të tjera"</string>
    <string name="user_dict_settings_add_dialog_less_options" msgid="2441785268726036101">"Më pak opsione"</string>
    <string name="user_dict_settings_add_dialog_confirm" msgid="6225823625332416144">"Në rregull"</string>
    <string name="user_dict_settings_add_word_option_name" msgid="7868879174905963135">"Fjala:"</string>
    <string name="user_dict_settings_add_shortcut_option_name" msgid="660089258866063925">"Shkurtorja:"</string>
    <string name="user_dict_settings_add_locale_option_name" msgid="5696358317061318532">"Gjuha:"</string>
    <string name="user_dict_settings_add_word_hint" msgid="5725254076556821247">"Shkruaj një fjalë"</string>
    <string name="user_dict_settings_add_shortcut_hint" msgid="7333763456561873445">"Shkurtore opsionale"</string>
    <string name="user_dict_settings_edit_dialog_title" msgid="8967476444840548674">"Redakto fjalën"</string>
    <string name="user_dict_settings_context_menu_edit_title" msgid="2210564879320004837">"Redakto"</string>
    <string name="user_dict_settings_context_menu_delete_title" msgid="9140703913776549054">"Fshi"</string>
    <string name="user_dict_settings_empty_text" msgid="1971969756133074922">"Nuk ke asnjë fjalë në fjalorin e përdoruesit. Për të shtuar një fjalë, trokit te butoni \"Shto (+)\"."</string>
    <string name="user_dict_settings_all_languages" msgid="6742000040975959247">"Për të gjitha gjuhët"</string>
    <string name="user_dict_settings_more_languages" msgid="7316375944684977910">"Gjuhë të tjera…"</string>
    <string name="testing" msgid="6584352735303604146">"Testimi"</string>
    <string name="testing_phone_info" product="tablet" msgid="193561832258534798">"Informacion për tabletin"</string>
    <string name="testing_phone_info" product="default" msgid="8656693364332840056">"Informacioni i telefonit"</string>
    <string name="input_methods_settings_title" msgid="6800066636850553887">"Hyrjet e tekstit"</string>
    <string name="input_method" msgid="5434026103176856164">"Metoda e hyrjes"</string>
    <string name="current_input_method" msgid="2636466029213488159">"Tastiera aktuale"</string>
    <string name="input_method_selector" msgid="4311213129681430709">"Fut përzgjedhësin e metodës"</string>
    <string name="input_method_selector_show_automatically_title" msgid="1001612945471546158">"Automatik"</string>
    <string name="input_method_selector_always_show_title" msgid="3891824124222371634">"Shfaq gjithmonë"</string>
    <string name="input_method_selector_always_hide_title" msgid="7699647095118680424">"Fshih gjithmonë"</string>
    <string name="configure_input_method" msgid="1317429869771850228">"Konfiguro metodat e hyrjes"</string>
    <string name="input_method_settings" msgid="5801295625486269553">"Cilësimet"</string>
    <string name="input_method_settings_button" msgid="6778344383871619368">"Cilësimet"</string>
    <string name="input_methods_settings_label_format" msgid="6002887604815693322">"Cilësimet e <xliff:g id="IME_NAME">%1$s</xliff:g>"</string>
    <string name="input_methods_and_subtype_enabler_title" msgid="4421813273170250462">"Zgjidh metodat aktive të hyrjes"</string>
    <string name="onscreen_keyboard_settings_summary" msgid="5841558383556238653">"Cilësimet e tastierës në ekran"</string>
    <string name="builtin_keyboard_settings_title" msgid="7688732909551116798">"Tastiera fizike"</string>
    <string name="builtin_keyboard_settings_summary" msgid="2392531685358035899">"Cilësimet e tastierës fizike"</string>
    <string name="gadget_picker_title" msgid="98374951396755811">"Zgjidh veglën"</string>
    <string name="widget_picker_title" msgid="9130684134213467557">"Zgjidh miniprogramin"</string>
    <string name="allow_bind_app_widget_activity_allow_bind_title" msgid="2538303018392590627">"Të krijohet miniaplikacion dhe të lejohet qasja në të?"</string>
    <string name="allow_bind_app_widget_activity_allow_bind" msgid="1584388129273282080">"Pasi të krijosh miniaplikacionin, <xliff:g id="WIDGET_HOST_NAME">%1$s</xliff:g> mund të qaset te të gjitha të dhënat që shfaq ai."</string>
    <string name="allow_bind_app_widget_activity_always_allow_bind" msgid="7037503685859688034">"Lejo gjithmonë që <xliff:g id="WIDGET_HOST_NAME">%1$s</xliff:g> të krijojë miniaplikacione dhe të ketë qasje te të dhënat e tyre"</string>
    <string name="usage_stats_label" msgid="5890846333487083609">"Statistikat e përdorimit"</string>
    <string name="testing_usage_stats" msgid="7823048598893937339">"Statistikat e përdorimit"</string>
    <string name="display_order_text" msgid="8592776965827565271">"Rendit sipas:"</string>
    <string name="app_name_label" msgid="5440362857006046193">"Aplikacioni"</string>
    <string name="last_time_used_label" msgid="8459441968795479307">"Përdorur për herë të fundit"</string>
    <string name="usage_time_label" msgid="295954901452833058">"Koha e përdorimit"</string>
    <string name="accessibility_settings" msgid="3975902491934816215">"Qasshmëria"</string>
    <string name="accessibility_settings_title" msgid="2130492524656204459">"Cilësimet e qasjes"</string>
    <string name="accessibility_settings_summary" msgid="981260486011624939">"Lexues ekrani, ekran, kontrolle ndërveprimi"</string>
    <string name="vision_settings_title" msgid="4204111425716868288">"Cilësimet e shikimit"</string>
    <string name="vision_settings_description" msgid="5679491180156408260">"Mund ta personalizosh këtë pajisje për t\'iu përshtatur nevojave të tua. Këto funksione të qasjes mund të ndryshohen më vonë te \"Cilësimet\"."</string>
    <string name="vision_settings_suggestion_title" msgid="8058794060304707004">"Ndrysho madhësinë e shkrimit"</string>
    <string name="screen_reader_category_title" msgid="7739154903913400641">"Lexuesit e ekranit"</string>
    <string name="audio_and_captions_category_title" msgid="3420727114421447524">"Audioja dhe teksti në ekran"</string>
    <string name="display_category_title" msgid="685461049938269166">"Ekrani"</string>
    <string name="interaction_control_category_title" msgid="7836591031872839151">"Kontrollet e ndërveprimeve"</string>
    <string name="user_installed_services_category_title" msgid="6426376488922158647">"Shërbimet e shkarkuara"</string>
    <string name="experimental_category_title" msgid="5272318666666893547">"Eksperimentale"</string>
    <string name="feature_flags_dashboard_title" msgid="778619522682769966">"Raportimet e funksioneve"</string>
    <string name="talkback_title" msgid="7912059827205988080">"Talkback"</string>
    <string name="talkback_summary" msgid="8331244650729024963">"Një lexues i ekranit kryesisht për personat e verbër dhe me shikim të dobët"</string>
    <string name="select_to_speak_summary" msgid="4282846695497544515">"Trokit artikujt në ekran për t\'i dëgjuar të lexuar me zë të lartë"</string>
    <string name="accessibility_captioning_title" msgid="8068289534732163115">"Preferencat e titrave"</string>
    <string name="accessibility_screen_magnification_title" msgid="6001128808776506021">"Zmadhimi"</string>
    <string name="accessibility_screen_magnification_gestures_title" msgid="3719929521571489913">"Zmadho me tre trokitje"</string>
    <string name="accessibility_screen_magnification_navbar_title" msgid="4203215572713684224">"Zmadho me shkurtore"</string>
    <string name="accessibility_screen_magnification_state_navbar_gesture" msgid="8416035446297644642">"Zmadho me shkurtore dhe tri trokitje"</string>
    <string name="accessibility_preference_magnification_summary" msgid="5867883657521404509">"Zmadho ekranin"</string>
    <string name="accessibility_screen_magnification_short_summary" msgid="3411979839172752057">"Trokit 3 herë për ta zmadhuar"</string>
    <string name="accessibility_screen_magnification_navbar_short_summary" msgid="3693116360267980492">"Trokit te një buton për të zmadhuar"</string>
    <string name="accessibility_screen_magnification_summary" msgid="5258868553337478505"><b>"Për të zmadhuar"</b>", trokit me shpejtësi tek ekrani 3 herë.\n"<ul><li>"Zvarrit 2 ose më shumë gishta për të lëvizur"</li>\n<li>"Afro 2 ose më shumë gishta për të rregulluar zmadhimin"</li></ul>\n\n<b>"Për të zmadhuar përkohësisht"</b>", trokit me shpejtësi 3 herë tek ekrani dhe mbaj të shtypur gishtin në trokitjen e tretë.\n"<ul><li>"Zvarrite për të zhvendosur ekranin"</li>\n<li>"Ngrije gishtin për ta zvogëluar"</li></ul>\n\n"Nuk mund të zmadhosh te tastiera dhe te shiriti i navigimit."</string>
    <string name="accessibility_screen_magnification_navbar_summary" msgid="2272878354599332009">"Kur aktivizohet zmadhimi, mund të zmadhosh mbi ekranin tënd.\n\n"<b>"Për të zmadhuar"</b>", nis zmadhimin, më pas trokit diku në ekran.\n"<ul><li>"• Zvarrit 2 ose më shumë gishta për të lëvizur"</li>\n<li>"• Bashko 2 ose më shumë gishta për të rregulluar zmadhimin"</li></ul>\n\n<b>"Për të zmadhuar përkohësisht"</b>", nis zmadhimin, më pas prek dhe mbaj prekur diku në ekran.\n"<ul><li>"• Zvarrit për të lëvizur rrotull në ekran"</li>\n<li>"• Ngrije gishtin për të vogëluar"</li></ul>\n\n"Nuk mund të zmadhosh mbi tastierë ose shiritin e navigimit."</string>
    <string name="accessibility_tutorial_dialog_title_button" msgid="3682222614034474845">"Përdor butonin e qasshmërisë për të hapur"</string>
    <string name="accessibility_tutorial_dialog_title_gesture" msgid="1342726230497913398">"Përdor gjestin për të hapur"</string>
    <string name="accessibility_tutorial_dialog_title_gesture_settings" msgid="8539392614235820285">"Përdor gjestin e ri të qasshmërisë"</string>
    <string name="accessibility_tutorial_dialog_message_button" msgid="4803108127318033537">"Për të aktivizuar ose çaktivizuar këtë shërbim, trokit mbi butonin e qasshmërisë<xliff:g id="ACCESSIBILITY_ICON">%s</xliff:g>në fund të ekranit.\n\nPër të kaluar mes shërbimeve, prek dhe mbaj prekur butonin e qasshmërisë."</string>
    <string name="accessibility_tutorial_dialog_message_gesture_without_talkback" msgid="5331865763478710038">"Për të aktivizuar ose çaktivizuar këtë shërbim, rrëshqit shpejt lart nga fundi i ekranit me dy gishta.\n\nPër të kaluar mes pajisjeve, rrëshqit shpejt lart me dy gishta dhe mbaje prekur."</string>
    <string name="accessibility_tutorial_dialog_message_gesture_with_talkback" msgid="7656710338811226339">"Për të aktivizuar ose çaktivizuar këtë shërbim, rrëshqit lart nga fundi i ekranit me tre gishta.\n\nPër të kaluar mes pajisjeve, rrëshqit shpejt lart me tre gishta dhe mbaje prekur."</string>
    <string name="accessibility_tutorial_dialog_message_gesture_settings_without_talkback" msgid="3582632565941330367">"Për të aktivizuar ose çaktivizuar një shërbim qasshmërie, rrëshqit shpejt lart nga fundi i ekranit me dy gishta.\n\nPër të kaluar mes pajisjeve, rrëshqit shpejt lart me dy gishta dhe mbaje prekur."</string>
    <string name="accessibility_tutorial_dialog_message_gesture_settings_with_talkback" msgid="8539343463529744661">"Për të aktivizuar ose çaktivizuar një shërbim qasshmërie, rrëshqit shpejt lart nga fundi i ekranit me tre gishta.\n\nPër të kaluar mes pajisjeve, rrëshqit shpejt lart me tre gishta dhe mbaje prekur."</string>
    <string name="accessibility_tutorial_dialog_button" msgid="8530755446904847423">"E kuptova"</string>
    <string name="accessibility_screen_magnification_navbar_configuration_warning" msgid="70533120652758190">"Butoni i \"Qasshmërisë\" është caktuar te <xliff:g id="SERVICE">%1$s</xliff:g>. Për të përdorur zmadhimin, prek dhe mbaj butonin e \"Qasshmërisë\" dhe më pas zgjidh zmadhimin."</string>
    <string name="accessibility_screen_magnification_gesture_navigation_warning" msgid="5558685139615434791">"Gjesti i qasshmërisë është caktuar në <xliff:g id="SERVICE">%1$s</xliff:g>. Për të përdorur zmadhimin, rrëshqit lart me dy gishta nga fundi i ekranit dhe mbaje. Më pas zgjidh zmadhimin."</string>
    <string name="accessibility_global_gesture_preference_title" msgid="2048884356166982714">"Shkurtorja e tastit të volumit"</string>
    <string name="accessibility_shortcut_service_title" msgid="4779360749706905640">"Shërbimi i shkurtores"</string>
    <string name="accessibility_shortcut_service_on_lock_screen_title" msgid="5490636079625489534">"Lejo nga ekrani i kyçjes"</string>
    <string name="accessibility_shortcut_description" msgid="1765853731190717372">"Kur shkurtorja është aktive, mund të shtypësh të dy tastet e volumit për 3 sekonda për të nisur një funksion të qasshmërisë."</string>
    <string name="accessibility_toggle_high_text_contrast_preference_title" msgid="2567402942683463779">"Tekst me kontrast të lartë"</string>
    <string name="accessibility_toggle_screen_magnification_auto_update_preference_title" msgid="7218498768415430963">"Përditëso auto. zmadhimin e ekranit"</string>
    <string name="accessibility_toggle_screen_magnification_auto_update_preference_summary" msgid="4392059334816220155">"Përditëso zmadhimin e ekranit në kalimet e apl."</string>
    <string name="accessibility_power_button_ends_call_prerefence_title" msgid="6673851944175874235">"Butoni i fikjes mbyll telefonatën"</string>
    <string name="accessibility_toggle_large_pointer_icon_title" msgid="535173100516295580">"Kursor i madh miu"</string>
    <string name="accessibility_disable_animations" msgid="5876035711526394795">"Hiq animacionet"</string>
    <string name="accessibility_toggle_master_mono_title" msgid="4363806997971905302">"Audioja mono"</string>
    <string name="accessibility_toggle_master_mono_summary" msgid="5634277025251530927">"Ndërthur kanalet kur luan audion"</string>
    <string name="accessibility_toggle_master_balance_title" msgid="551441665399043471">"Balanca e audios"</string>
    <string name="accessibility_toggle_master_balance_left_label" msgid="840973259765894310">"Majtas"</string>
    <string name="accessibility_toggle_master_balance_right_label" msgid="7349959407092157385">"Djathtas"</string>
    <string name="accessibility_timeout_default" msgid="8316215621219570607">"E parazgjedhur"</string>
    <string name="accessibility_timeout_10secs" msgid="1976492627730727871">"10 sekonda"</string>
    <string name="accessibility_timeout_30secs" msgid="8055710148052265579">"30 sekonda"</string>
    <string name="accessibility_timeout_1min" msgid="6314276027668784112">"1 minutë"</string>
    <string name="accessibility_timeout_2mins" msgid="9062685014853095180">"2 minuta"</string>
    <string name="accessibility_setting_item_control_timeout_title" msgid="870367947690762063">"Veprimi (koha e pritjes së \"Qasshmërisë\")"</string>
    <string name="accessibility_control_timeout_preference_title" msgid="3076566452307147390">"Koha për të kryer veprime"</string>
    <string name="accessibility_control_timeout_preference_summary" msgid="6557680564604287459">"Zgjidh se për sa kohë të shfaqen mesazhet që të kërkojnë të kryesh një veprim, por që janë të dukshme vetëm përkohësisht.\n\nKy cilësim nuk mbështetet nga të gjitha aplikacionet."</string>
    <string name="accessibility_long_press_timeout_preference_title" msgid="6708467774619266508">"Vonesa e prekjes dhe e mbajtjes shtypur"</string>
    <string name="accessibility_display_inversion_preference_title" msgid="2119647786141420802">"Kthimi i ngjyrës"</string>
    <string name="accessibility_display_inversion_preference_subtitle" msgid="7052959202195368109">"Mund të ndikojë te cilësia e funksionimit"</string>
    <string name="accessibility_autoclick_preference_title" msgid="2434062071927416098">"Koha e qëndrimit pa lëvizur"</string>
    <string name="accessibility_autoclick_description" msgid="4908960598910896933">"Nëse po përdor një mi, mund të caktosh që kursori të kryejë automatikisht një veprim kur ai të ndalojë lëvizjen për një kohë të caktuar."</string>
    <string name="accessibility_autoclick_delay_preference_title" msgid="3962261178385106006">"Vonesa përpara klikimit"</string>
    <string name="accessibility_vibration_settings_title" msgid="3196059463767462026">"Fuqia e dridhjeve dhe e prekjes"</string>
    <string name="accessibility_notification_vibration_title" msgid="3009997451790678444">"Dridhjet e njoftimeve"</string>
    <string name="accessibility_ring_vibration_title" msgid="5369395955680650778">"Dridhjet e ziles"</string>
    <string name="accessibility_touch_vibration_title" msgid="3548641513105226156">"Reagimi me prekje"</string>
    <string name="accessibility_service_master_switch_title" msgid="6835441300276358239">"Përdor shërbimin"</string>
    <string name="accessibility_daltonizer_master_switch_title" msgid="8655284637968823154">"Përdor korrigjimin e ngjyrave"</string>
    <string name="accessibility_caption_master_switch_title" msgid="4010227386676077826">"Përdor titrat"</string>
    <string name="accessibility_caption_preference_summary" msgid="7898443636143430927">"Jo të gjitha aplikacionet e mbështesin këtë cilësim."</string>
    <string name="accessibility_hearingaid_instruction_continue_button" msgid="974461729380409972">"Vazhdo"</string>
    <string name="accessibility_hearingaid_title" msgid="8312145423610648518">"Aparatet e dëgjimit"</string>
    <string name="accessibility_hearingaid_not_connected_summary" msgid="6240237523789614599">"Nuk ka asnjë aparat dëgjimi të lidhur"</string>
    <string name="accessibility_hearingaid_adding_summary" msgid="2947474468412309778">"Shto aparate dëgjimi"</string>
    <string name="accessibility_hearingaid_pair_instructions_first_message" msgid="3912093691643131154">"Për të çiftuar aparatin e dëgjimit, gjej e trokit pajisjen tënde në ekranin tjetër."</string>
    <string name="accessibility_hearingaid_pair_instructions_second_message" msgid="5596683393607650243">"Sigurohu që aparatet e tua të dëgjimit të jenë në modalitetin e çiftimit."</string>
    <string name="accessibility_hearingaid_active_device_summary" msgid="3924362383258688984">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g> është aktive"</string>
    <plurals name="show_number_hearingaid_count" formatted="false" msgid="3160782397139295486">
      <item quantity="other"><xliff:g id="NUMBER_DEVICE_COUNT_1">%1$d</xliff:g> aparate dëgjimi të ruajtura</item>
      <item quantity="one"><xliff:g id="NUMBER_DEVICE_COUNT_0">%1$d</xliff:g> aparat dëgjimi i ruajtur</item>
    </plurals>
    <string name="accessibility_summary_state_enabled" msgid="7914278500885887763">"Aktiv"</string>
    <string name="accessibility_summary_state_disabled" msgid="2984230257590246745">"Joaktiv"</string>
    <string name="accessibility_summary_state_stopped" msgid="1144156815350270876">"Nuk funksionon. Trokit për informacione."</string>
    <string name="accessibility_description_state_stopped" msgid="6953539746047006596">"Ky shërbim nuk po funksionon mirë."</string>
    <string name="enable_quick_setting" msgid="2366999897816894536">"Shfaq në Cilësimet e shpejta"</string>
    <string name="daltonizer_type" msgid="1124178250809091080">"Modaliteti i korrigjimit"</string>
    <plurals name="accessibilty_autoclick_preference_subtitle_extremely_short_delay" formatted="false" msgid="7340347830562315800">
      <item quantity="other">Vonesë jashtëzakonisht e shkurtër (<xliff:g id="CLICK_DELAY_LABEL_1">%1$d</xliff:g> ms)</item>
      <item quantity="one">Vonesë jashtëzakonisht e shkurtër (<xliff:g id="CLICK_DELAY_LABEL_0">%1$d</xliff:g> ms)</item>
    </plurals>
    <plurals name="accessibilty_autoclick_preference_subtitle_very_short_delay" formatted="false" msgid="5589565607652364932">
      <item quantity="other">Vonesë shumë e shkurtër (<xliff:g id="CLICK_DELAY_LABEL_1">%1$d</xliff:g> ms)</item>
      <item quantity="one">Vonesë shumë e shkurtër (<xliff:g id="CLICK_DELAY_LABEL_0">%1$d</xliff:g> ms)</item>
    </plurals>
    <plurals name="accessibilty_autoclick_preference_subtitle_short_delay" formatted="false" msgid="5887754135102768400">
      <item quantity="other">Vonesë e shkurtër (<xliff:g id="CLICK_DELAY_LABEL_1">%1$d</xliff:g> ms)</item>
      <item quantity="one">Vonesë e shkurtër (<xliff:g id="CLICK_DELAY_LABEL_0">%1$d</xliff:g> ms)</item>
    </plurals>
    <plurals name="accessibilty_autoclick_preference_subtitle_long_delay" formatted="false" msgid="6340683412750219405">
      <item quantity="other">Vonesë e gjatë (<xliff:g id="CLICK_DELAY_LABEL_1">%1$d</xliff:g> ms)</item>
      <item quantity="one">Vonesë e gjatë (<xliff:g id="CLICK_DELAY_LABEL_0">%1$d</xliff:g> ms)</item>
    </plurals>
    <plurals name="accessibilty_autoclick_preference_subtitle_very_long_delay" formatted="false" msgid="3503199424330634970">
      <item quantity="other">Vonesë shumë e gjatë (<xliff:g id="CLICK_DELAY_LABEL_1">%1$d</xliff:g> ms)</item>
      <item quantity="one">Vonesë shumë e gjatë (<xliff:g id="CLICK_DELAY_LABEL_0">%1$d</xliff:g> ms)</item>
    </plurals>
    <string name="accessibility_vibration_summary" msgid="4272038147476749536">"Zilja <xliff:g id="SUMMARY_RING">%1$s</xliff:g>, njoftimi <xliff:g id="SUMMARY_NOTIFICATION">%2$s</xliff:g>, prekja <xliff:g id="SUMMARY_TOUCH">%3$s</xliff:g>"</string>
    <string name="accessibility_vibration_summary_off" msgid="1753566394591809629">"Zilja dhe njoftimi janë vendosur në \"Joaktiv\""</string>
    <string name="accessibility_vibration_summary_low" msgid="7628418309029013867">"Zilja dhe njoftimi janë vendosur në \"I ulët\""</string>
    <string name="accessibility_vibration_summary_medium" msgid="3422136736880414093">"Zilja dhe njoftimi janë vendosur në \"Mesatar\""</string>
    <string name="accessibility_vibration_summary_high" msgid="3239807793182635729">"Zilja dhe njoftimi janë vendosur në \"I lartë\""</string>
    <string name="accessibility_vibration_intensity_off" msgid="4613890213008630847">"Joaktiv"</string>
    <string name="accessibility_vibration_intensity_low" msgid="2017572546489862987">"I ulët"</string>
    <string name="accessibility_vibration_intensity_medium" msgid="3782136025830279769">"Mesatar"</string>
    <string name="accessibility_vibration_intensity_high" msgid="2543921139337952491">"I lartë"</string>
    <string name="accessibility_menu_item_settings" msgid="3344942964710773365">"Cilësimet"</string>
    <string name="accessibility_feature_state_on" msgid="2864292320042673806">"Aktivizuar"</string>
    <string name="accessibility_feature_state_off" msgid="4172584906487070211">"Çaktivizuar"</string>
    <string name="captioning_preview_title" msgid="1234015253497016890">"Shikim paraprak"</string>
    <string name="captioning_standard_options_title" msgid="3284211791180335844">"Opsionet standarde"</string>
    <string name="captioning_locale" msgid="4559155661018823503">"Gjuha"</string>
    <string name="captioning_text_size" msgid="6737002449104466028">"Madhësia e tekstit"</string>
    <string name="captioning_preset" msgid="8939737196538429044">"Stili i titrave"</string>
    <string name="captioning_custom_options_title" msgid="5067500939930322405">"Personalizo opsionet"</string>
    <string name="captioning_background_color" msgid="9053011212948992570">"Ngjyra e sfondit"</string>
    <string name="captioning_background_opacity" msgid="6029993616419971202">"Niveli i transparencës së sfondit"</string>
    <string name="captioning_window_color" msgid="6902052743419717394">"Ngjyra e dritares së titrave"</string>
    <string name="captioning_window_opacity" msgid="5041556024849862376">"Transparenca e dritares së titrave"</string>
    <string name="captioning_foreground_color" msgid="85623486537640059">"Ngjyra e tekstit"</string>
    <string name="captioning_foreground_opacity" msgid="4370967856995419788">"Niveli i transparencës së tekstit"</string>
    <string name="captioning_edge_color" msgid="3670094753735263238">"Ngjyra e skajit"</string>
    <string name="captioning_edge_type" msgid="5997247394951682154">"Lloji i skajeve"</string>
    <string name="captioning_typeface" msgid="1826169240566563259">"Familja e shkrimit"</string>
    <string name="captioning_preview_text" msgid="4067935959797375065">"Titrat do të duken kështu"</string>
    <string name="captioning_preview_characters" msgid="7105909138497851769">"Aa"</string>
    <string name="locale_default" msgid="2593883646136326969">"E parazgjedhur"</string>
    <string name="color_title" msgid="4258931051732243983">"Ngjyra"</string>
    <string name="color_unspecified" msgid="5179683785413568326">"E parazgjedhur"</string>
    <string name="color_none" msgid="3475640044925814795">"Asnjë"</string>
    <string name="color_white" msgid="8045195170201590239">"E bardhë"</string>
    <string name="color_gray" msgid="9192312087142726313">"Gri"</string>
    <string name="color_black" msgid="7517353520909872561">"E zezë"</string>
    <string name="color_red" msgid="4949354900304125428">"E kuqe"</string>
    <string name="color_green" msgid="5537717328428845841">"E gjelbër"</string>
    <string name="color_blue" msgid="7731984529016953223">"E kaltër"</string>
    <string name="color_cyan" msgid="7033027180641173211">"Gurkali"</string>
    <string name="color_yellow" msgid="9112680561610873529">"E verdhë"</string>
    <string name="color_magenta" msgid="5059212823607815549">"E purpurt"</string>
    <string name="enable_service_title" msgid="2813477981936919847">"Të lejohet \"<xliff:g id="SERVICE">%1$s</xliff:g>\" që të ketë kontroll të plotë të pajisjes sate?"</string>
    <string name="capabilities_list_title" msgid="86713361724771971">"\"<xliff:g id="SERVICE">%1$s</xliff:g>\" ka nevojë të:"</string>
    <string name="touch_filtered_warning" msgid="8644034725268915030">"Duke qenë se një aplikacion po bllokon një kërkesë për leje, \"Cilësimet\" nuk mund të verifikojnë përgjigjen tënde."</string>
    <string name="enable_service_encryption_warning" msgid="3064686622453974606">"Nëse aktivizon <xliff:g id="SERVICE">%1$s</xliff:g>, pajisja nuk do të përdorë kyçjen e ekranit për të rritur enkriptimin e të dhënave."</string>
    <string name="secure_lock_encryption_warning" msgid="460911459695077779">"Për shkak se ke aktivizuar shërbimin e qasshmërisë, pajisja jote nuk do të përdorë kyçen e ekranit për përmirësimin e enkriptimit të të dhënave."</string>
    <string name="enable_service_pattern_reason" msgid="777577618063306751">"Meqenëse aktivizimi i <xliff:g id="SERVICE">%1$s</xliff:g> ndikon në enkriptimin e të dhënave, duhet të konfirmosh motivin tënd."</string>
    <string name="enable_service_pin_reason" msgid="7882035264853248228">"Duke qenë se aktivizimi i <xliff:g id="SERVICE">%1$s</xliff:g> ndikon në enkriptimin e të dhënave, duhet të konfirmosh kodin PIN."</string>
    <string name="enable_service_password_reason" msgid="1224075277603097951">"Meqenëse aktivizimi i <xliff:g id="SERVICE">%1$s</xliff:g> ndikon në enkriptimin e të dhënave, duhet të konfirmosh fjalëkalimin tënd."</string>
    <string name="accessibility_service_warning" msgid="846312597054899472">"<xliff:g id="SERVICE">%1$s</xliff:g> po kërkon kontroll të plotë të kësaj pajisjeje. Shërbimi mund të lexojë ekranin dhe të veprojë në emër të përdoruesve me nevoja qasshmërie. Ky nivel kontrolli nuk është i përshtatshëm për shumicën e aplikacioneve."</string>
    <string name="accessibility_service_warning_description" msgid="5678294638592090340">"Kontrolli i plotë është i përshtatshëm për aplikacionet që të ndihmojnë me nevojat e qasshmërisë, por jo për shumicën e aplikacioneve."</string>
    <string name="accessibility_service_screen_control_title" msgid="1262218781398117580">"Shiko dhe kontrollo ekranin"</string>
    <string name="accessibility_service_screen_control_description" msgid="5263900135083661468">"Ai mund të lexojë të gjithë përmbajtjen në ekran dhe të shfaqë përmbajtjen mbi aplikacione të tjera."</string>
    <string name="accessibility_service_action_perform_title" msgid="3591350033271419253">"Shiko dhe kryej veprimet"</string>
    <string name="accessibility_service_action_perform_description" msgid="2402904134246069476">"Ai mund të monitorojë ndërveprimet me një aplikacion ose një sensor hardueri dhe të ndërveprojë me aplikacionet në emrin tënd."</string>
    <string name="accessibility_dialog_button_allow" msgid="8427955451281232788">"Lejo"</string>
    <string name="accessibility_dialog_button_deny" msgid="4307331121783796869">"Refuzo"</string>
    <string name="accessibility_dialog_button_stop" msgid="7861331860214808622">"Ndalo"</string>
    <string name="accessibility_dialog_button_cancel" msgid="5006357240387387028">"Anulo"</string>
    <string name="disable_service_title" msgid="3624005212728512896">"Të ndalohet shërbimi \"<xliff:g id="SERVICE">%1$s</xliff:g>\"?"</string>
    <string name="disable_service_message" msgid="4593387199926310801">"Trokitja te <xliff:g id="STOP">%1$s</xliff:g> do të ndalojë <xliff:g id="SERVICE">%2$s</xliff:g>."</string>
    <string name="accessibility_no_services_installed" msgid="7200948194639038807">"Nuk është instaluar asnjë shërbim"</string>
    <string name="accessibility_no_service_selected" msgid="2840969718780083998">"Nuk është zgjedhur asnjë shërbim"</string>
    <string name="accessibility_service_default_description" msgid="1072730037861494125">"Nuk është dhënë asnjë përshkrim."</string>
    <string name="settings_button" msgid="3006713718908152930">"Cilësimet"</string>
    <string name="print_settings" msgid="4742428530112487843">"Printimi"</string>
    <string name="print_settings_summary_no_service" msgid="6354322414246865875">"Joaktive"</string>
    <plurals name="print_settings_summary" formatted="false" msgid="6005468025646083029">
      <item quantity="other"><xliff:g id="COUNT">%1$d</xliff:g> shërbime printimi janë aktive</item>
      <item quantity="one">1 shërbim printimi është aktiv</item>
    </plurals>
    <plurals name="print_jobs_summary" formatted="false" msgid="5810106725778525400">
      <item quantity="other"><xliff:g id="COUNT">%1$d</xliff:g> punë printimi</item>
      <item quantity="one">1 punë printimi</item>
    </plurals>
    <string name="print_settings_title" msgid="3685449667822217816">"Shërbimet e printimit"</string>
    <string name="print_no_services_installed" msgid="8443039625463872294">"Nuk është instaluar asnjë shërbim"</string>
    <string name="print_no_printers_found" msgid="989018646884973683">"Nuk u gjet asnjë printer"</string>
    <string name="print_menu_item_settings" msgid="6591330373682227082">"Cilësimet"</string>
    <string name="print_menu_item_add_printers" msgid="2890738028215834012">"Shto printerë"</string>
    <string name="print_feature_state_on" msgid="8098901852502441048">"Aktivizuar"</string>
    <string name="print_feature_state_off" msgid="7294876968403966040">"Çaktivizuar"</string>
    <string name="print_menu_item_add_service" msgid="3811645167869797802">"Shto shërbim"</string>
    <string name="print_menu_item_add_printer" msgid="8251218970577291032">"Shto printer"</string>
    <string name="print_menu_item_search" msgid="7025589328240514553">"Kërko"</string>
    <string name="print_searching_for_printers" msgid="4680248496457576358">"Po kërkon për printerë"</string>
    <string name="print_service_disabled" msgid="7739452396114245222">"Shërbimi është çaktivizuar"</string>
    <string name="print_print_jobs" msgid="3582094777756968793">"Punët e printimit"</string>
    <string name="print_print_job" msgid="7563741676053287211">"Punë printimi"</string>
    <string name="print_restart" msgid="8373999687329384202">"Rifillo"</string>
    <string name="print_cancel" msgid="3621199386568672235">"Anulo"</string>
    <string name="print_job_summary" msgid="8472427347192930694">"<xliff:g id="PRINTER">%1$s</xliff:g>\n<xliff:g id="TIME">%2$s</xliff:g>"</string>
    <string name="print_configuring_state_title_template" msgid="1228890182762324249">"Po konfiguron <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_printing_state_title_template" msgid="5736107667714582025">"Po printon <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_cancelling_state_title_template" msgid="7102968925358219875">"Po anulon <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_failed_state_title_template" msgid="1436099128973357969">"Gabim i printerit për <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_blocked_state_title_template" msgid="9065391617425962424">"Printeri bllokoi <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_search_box_shown_utterance" msgid="7730361832020726951">"Kutia e kërkimit është e shfaqur"</string>
    <string name="print_search_box_hidden_utterance" msgid="7980832833405818400">"Kutia e kërkimit është e fshehur"</string>
    <string name="printer_info_desc" msgid="5824995108703060003">"Më shumë informacione mbi këtë printer"</string>
    <string name="power_usage_summary_title" msgid="7190304207330319919">"Bateria"</string>
    <string name="power_usage_summary" msgid="7237084831082848168">"Kush e ka harxhuar baterinë"</string>
    <string name="power_usage_not_available" msgid="3109326074656512387">"Të dhënat nuk ofrohen."</string>
    <string name="power_usage_level_and_status" msgid="7449847570973811784">"<xliff:g id="LEVEL">%1$s</xliff:g> - <xliff:g id="STATUS">%2$s</xliff:g>"</string>
    <string name="power_discharge_remaining" msgid="4925678997049911808">"<xliff:g id="REMAIN">%1$s</xliff:g> të mbetura"</string>
    <string name="power_charge_remaining" msgid="6132074970943913135">"<xliff:g id="UNTIL_CHARGED">%1$s</xliff:g> për të karikuar"</string>
    <string name="background_activity_title" msgid="8482171736539410135">"Kufizimi i përdorimit në sfond"</string>
    <string name="background_activity_summary" msgid="8140094430510517362">"Lejo që aplikacioni të ekzekutohet në sfond"</string>
    <string name="background_activity_summary_disabled" msgid="3710669050484599847">"Nuk lejohet që aplikacioni të ekzekutohet në sfond"</string>
    <string name="background_activity_summary_whitelisted" msgid="1079899502347973947">"Përdorimi në sfond nuk mund të kufizohet"</string>
    <string name="background_activity_warning_dialog_title" msgid="2216249969149568871">"Të kufizohet aktiviteti në sfond?"</string>
    <string name="background_activity_warning_dialog_text" msgid="7049624449246121981">"Nëse e kufizon aktivitetin në sfond për një aplikacion, mund të ketë çrregullime në funksionimin e tij"</string>
    <string name="background_activity_disabled_dialog_text" msgid="6133420589651880824">"Duke qenë se ky aplikacion nuk është caktuar për të optimizuar baterinë, nuk mund ta kufizosh atë.\n\nPër të kufizuar aplikacionin, në fillim aktivizo optimizimin e baterisë."</string>
    <string name="device_screen_usage" msgid="3386088035570409683">"Përdorimi i ekranit që nga karikimi i plotë"</string>
    <string name="power_usage_list_summary" msgid="5584049564906462506">"Përdorimi i baterisë që prej karikimit të plotë"</string>
    <string name="screen_usage_summary" msgid="6687403051423153550">"Sasia e kohës për të cilën ekrani ka qenë aktiv që nga karikimi i plotë"</string>
    <string name="device_usage_list_summary" msgid="5623036661468763251">"Përdorimi i pajisjes që nga karikimi i plotë"</string>
    <string name="battery_since_unplugged" msgid="338073389740738437">"Përdorimi i baterisë që nga heqja nga ngarkimi"</string>
    <string name="battery_since_reset" msgid="7464546661121187045">"Përdorimi i baterisë që nga rivendosja"</string>
    <string name="battery_stats_on_battery" msgid="4970762168505236033">"<xliff:g id="TIME">%1$s</xliff:g> me bateri"</string>
    <string name="battery_stats_duration" msgid="7464501326709469282">"<xliff:g id="TIME">%1$s</xliff:g> që nga heqja nga priza"</string>
    <string name="battery_stats_charging_label" msgid="4223311142875178785">"Ngarkimi"</string>
    <string name="battery_stats_screen_on_label" msgid="7150221809877509708">"Qëndrimi aktiv i ekranit"</string>
    <string name="battery_stats_gps_on_label" msgid="1193657533641951256">"GPS-ja aktive"</string>
    <string name="battery_stats_camera_on_label" msgid="4935637383628414968">"Kamera aktive"</string>
    <string name="battery_stats_flashlight_on_label" msgid="4319637669889411307">"Blici aktiv"</string>
    <string name="battery_stats_wifi_running_label" msgid="1845839195549226252">"Wi-Fi"</string>
    <string name="battery_stats_wake_lock_label" msgid="1908942681902324095">"Qëndrimi zgjuar"</string>
    <string name="battery_stats_phone_signal_label" msgid="4137799310329041341">"Sinjali i rrjetit celular"</string>
    <!-- no translation found for battery_stats_last_duration (1535831453827905957) -->
    <skip />
    <string name="awake" msgid="387122265874485088">"Koha e zgjimit të pajisjes"</string>
    <string name="wifi_on_time" msgid="3208518458663637035">"Koha e aktivizimit të Wi‑Fi"</string>
    <string name="bluetooth_on_time" msgid="3056108148042308690">"Koha e aktivizimit të Wi‑Fi"</string>
    <string name="advanced_battery_title" msgid="6768618303037280828">"Përdorimi i baterisë"</string>
    <string name="history_details_title" msgid="3608240585315506067">"Detajet e historikut"</string>
    <string name="battery_details_title" msgid="6101394441569858580">"Përdorimi i baterisë"</string>
    <string name="details_subtitle" msgid="32593908269911734">"Përdor detajet"</string>
    <string name="controls_subtitle" msgid="390468421138288702">"Rregullo përdorimin e energjisë"</string>
    <string name="packages_subtitle" msgid="4736416171658062768">"Paketat e përfshira"</string>
    <string name="battery_tip_summary_title" msgid="368729969313047399">"Aplikacionet po funksionojnë normalisht"</string>
    <string name="battery_tip_summary_summary" product="default" msgid="2198778125778121221">"Telefoni ka një përdorim normal të baterisë në sfond"</string>
    <string name="battery_tip_summary_summary" product="tablet" msgid="1183976728682325345">"Tableti ka një përdorim normal të baterisë në sfond"</string>
    <string name="battery_tip_summary_summary" product="device" msgid="363718204492523920">"Pajisja ka një përdorim normal të baterisë në sfond"</string>
    <string name="battery_tip_low_battery_title" msgid="5103420355109677385">"Kapacitet i ulët i baterisë"</string>
    <string name="battery_tip_low_battery_summary" msgid="4702986182940709150">"Bateria nuk mund të ofrojë jetëgjatësi të mirë"</string>
    <string name="battery_tip_smart_battery_title" product="default" msgid="2542822112725248683">"Përmirëso kohëzgjatjen e baterisë së telefonit"</string>
    <string name="battery_tip_smart_battery_title" product="tablet" msgid="6452567046912954866">"Përmirëso kohëzgjatjen e baterisë së tabletit"</string>
    <string name="battery_tip_smart_battery_title" product="device" msgid="4445149029390556382">"Përmirëso kohëzgjatjen e baterisë së pajisjes"</string>
    <string name="battery_tip_smart_battery_summary" msgid="2326809294592208069">"Aktivizo \"Menaxherin e baterisë\""</string>
    <string name="battery_tip_early_heads_up_title" msgid="5788492366387119807">"Aktivizo \"Kursyesin e baterisë\""</string>
    <string name="battery_tip_early_heads_up_summary" msgid="1639271439914224547">"Bateria mund të mbarojë më herët se zakonisht"</string>
    <string name="battery_tip_early_heads_up_done_title" msgid="4294083319255926811">"\"Kursyesi i baterisë\" është i aktivizuar"</string>
    <string name="battery_tip_early_heads_up_done_summary" msgid="7054036010928794364">"Disa funksione mund të jenë të kufizuara"</string>
    <string name="battery_tip_high_usage_title" product="default" msgid="1282187115295901930">"Telefoni është përdorur më shumë se zakonisht"</string>
    <string name="battery_tip_high_usage_title" product="tablet" msgid="7422137233845959351">"Tableti është përdorur më shumë se zakonisht"</string>
    <string name="battery_tip_high_usage_title" product="device" msgid="5483320224273724068">"Pajisja është përdorur më shumë se zakonisht"</string>
    <string name="battery_tip_high_usage_summary" msgid="5343363604280323738">"Bateria mund të mbarojë më herët se zakonisht"</string>
    <string name="battery_tip_dialog_message" product="default" msgid="797225122502556066">"Telefoni yt është përdorur më shumë se zakonisht. Bateria mund të mbarojë më shpejt nga sa pritet.\n\nAplikacionet kryesore sipas përdorimit të baterisë:"</string>
    <string name="battery_tip_dialog_message" product="tablet" msgid="49788591262480482">"Tableti yt është përdorur më shumë se zakonisht. Bateria mund të mbarojë më shpejt nga sa pritet.\n\nAplikacionet kryesore sipas përdorimit të baterisë:"</string>
    <string name="battery_tip_dialog_message" product="device" msgid="7959652003221931962">"Pajisja jote është përdorur më shumë se zakonisht. Bateria mund të mbarojë më shpejt nga sa pritet.\n\nAplikacionet kryesore sipas përdorimit të baterisë:"</string>
    <string name="battery_tip_dialog_message_footer" msgid="2560019187096011163">"Përfshin aktivitetin me nivel të lartë të energjisë në sfond"</string>
    <plurals name="battery_tip_restrict_title" formatted="false" msgid="467228882789275512">
      <item quantity="other">Kufizo %1$d aplikacione</item>
      <item quantity="one">Kufizo %1$d aplikacion</item>
    </plurals>
    <plurals name="battery_tip_restrict_handled_title" formatted="false" msgid="2996094393897875408">
      <item quantity="other">%2$d aplikacione u kufizuan së fundi</item>
      <item quantity="one">%1$s u kufizua së fundi</item>
    </plurals>
    <plurals name="battery_tip_restrict_summary" formatted="false" msgid="5768962491638423979">
      <item quantity="other">%2$d aplikacione kanë përdorim të lartë baterie në sfond</item>
      <item quantity="one">%1$s ka përdorim të lartë baterie në sfond</item>
    </plurals>
    <plurals name="battery_tip_restrict_handled_summary" formatted="false" msgid="1040488674178753191">
      <item quantity="other">Këto aplikacione nuk mund të ekzekutohen në sfond</item>
      <item quantity="one">Ky aplikacion nuk mund të ekzekutohet në sfond</item>
    </plurals>
    <plurals name="battery_tip_restrict_app_dialog_title" formatted="false" msgid="8130618585820429591">
      <item quantity="other">Të kufizohen %1$d aplikacione?</item>
      <item quantity="one">Të kufizohet aplikacioni?</item>
    </plurals>
    <string name="battery_tip_restrict_app_dialog_message" msgid="7271391929137806299">"Për të kursyer baterinë, ndalo përdorimin e baterisë në sfond nga <xliff:g id="APP">%1$s</xliff:g>. Ky aplikacion mund të mos funksionojë si duhet dhe njoftimet mund të vonohen."</string>
    <string name="battery_tip_restrict_apps_less_than_5_dialog_message" msgid="3175700359860699627">"Për të kursyer baterinë, ndalo përdorimin e baterisë në sfond nga këto aplikacione. Aplikacionet e kufizuara mund të mos funksionojnë si duhet dhe njoftimet mund të vonohen.\n\nAplikacionet:"</string>
    <string name="battery_tip_restrict_apps_more_than_5_dialog_message" msgid="582641081128076191">"Për të kursyer baterinë, ndalo përdorimin e baterisë në sfond nga këto aplikacione. Aplikacionet e kufizuara mund të mos funksionojnë si duhet dhe njoftimet mund të vonohen.\n\nAplikacionet:\n<xliff:g id="APP_LIST">%1$s</xliff:g>."</string>
    <string name="battery_tip_restrict_app_dialog_ok" msgid="8291115820018013353">"Kufizo"</string>
    <string name="battery_tip_unrestrict_app_dialog_title" msgid="4321334634106715162">"Të hiqet kufizimi?"</string>
    <string name="battery_tip_unrestrict_app_dialog_message" msgid="6537761705584610231">"Ky aplikacion do të mund ta përdorë baterinë në sfond. Bateria mund të mbarojë më shpejt nga sa pritet."</string>
    <string name="battery_tip_unrestrict_app_dialog_ok" msgid="6022058431218137646">"Hiq"</string>
    <string name="battery_tip_unrestrict_app_dialog_cancel" msgid="3058235875830858902">"Anulo"</string>
    <string name="battery_tip_dialog_summary_message" product="default" msgid="4628448253185085796">"Aplikacionet e tua po përdorin një sasi normale të baterisë. Nëse aplikacionet përdorin një sasi të madhe të baterisë, telefoni yt do të japë sugjerime për veprimet që mund të kryesh.\n\nMund të aktivizosh gjithmonë \"Kursyesin e baterisë\" nëse bateria është në nivel të ulët."</string>
    <string name="battery_tip_dialog_summary_message" product="tablet" msgid="8327950887399420971">"Aplikacionet e tua po përdorin një sasi normale të baterisë. Nëse aplikacionet përdorin një sasi të madhe të baterisë, tableti yt do të japë sugjerime për veprimet që mund të kryesh.\n\nMund të aktivizosh gjithmonë \"Kursyesin e baterisë\" nëse bateria është në nivel të ulët."</string>
    <string name="battery_tip_dialog_summary_message" product="device" msgid="6753742263807939789">"Aplikacionet e tua po përdorin një sasi normale të baterisë. Nëse aplikacionet përdorin një sasi të madhe të baterisë, pajisja jote do të japë sugjerime për veprimet që mund të kryesh.\n\nMund të aktivizosh gjithmonë \"Kursyesin e baterisë\" nëse bateria është në nivel të ulët."</string>
    <string name="smart_battery_manager_title" msgid="870632749556793417">"Menaxheri i baterisë"</string>
    <string name="smart_battery_title" msgid="6218785691872466076">"Menaxho automatikisht aplikacionet"</string>
    <string name="smart_battery_summary" msgid="1339184602000004058">"Kufizo baterinë për aplikacionet që nuk i përdor shpesh"</string>
    <string name="smart_battery_footer" product="default" msgid="5555604955956219544">"Kur \"Menaxheri i baterisë\" të zbulojë se këto aplikacione po shkarkojnë baterinë, do të kesh opsionin që t\'i kufizosh këto aplikacione. Aplikacionet e kufizuara mund të mos funksionojnë si duhet dhe njoftimet mund të vonohen."</string>
    <string name="smart_battery_footer" product="tablet" msgid="5555604955956219544">"Kur \"Menaxheri i baterisë\" të zbulojë se këto aplikacione po shkarkojnë baterinë, do të kesh opsionin që t\'i kufizosh këto aplikacione. Aplikacionet e kufizuara mund të mos funksionojnë si duhet dhe njoftimet mund të vonohen."</string>
    <string name="smart_battery_footer" product="device" msgid="5555604955956219544">"Kur \"Menaxheri i baterisë\" të zbulojë se këto aplikacione po shkarkojnë baterinë, do të kesh opsionin që t\'i kufizosh këto aplikacione. Aplikacionet e kufizuara mund të mos funksionojnë si duhet dhe njoftimet mund të vonohen."</string>
    <string name="restricted_app_title" msgid="8982477293044330653">"Aplikacionet e kufizuara"</string>
    <plurals name="restricted_app_summary" formatted="false" msgid="7355687633914223530">
      <item quantity="other">Përdorimi i baterisë po kufizohet për %1$d aplikacione</item>
      <item quantity="one">Përdorimi i baterisë po kufizohet për %1$d aplikacion</item>
    </plurals>
    <string name="restricted_app_time_summary" msgid="6983512391277778623">"Kufizuar <xliff:g id="TIME">%1$s</xliff:g>"</string>
    <string name="restricted_app_detail_footer" msgid="6739863162364046859">"Këto aplikacione kanë përdorur bateri në sfond. Aplikacionet e kufizuara mund të mos funksionojnë siç duhet dhe njoftimet mund të vonohen."</string>
    <string name="battery_auto_restriction_title" msgid="6553271897488963709">"Përdor \"Menaxherin e baterisë\""</string>
    <string name="battery_auto_restriction_summary" msgid="8561335400991281062">"Zbulo kur aplikacionet shkarkojnë baterinë"</string>
    <string name="battery_manager_on" msgid="8643310865054362396">"Aktiv / Po zbulon kur aplikacionet shkarkojnë baterinë"</string>
    <string name="battery_manager_off" msgid="5473135235710343576">"Joaktiv"</string>
    <plurals name="battery_manager_app_restricted" formatted="false" msgid="1026141135861471129">
      <item quantity="other">%1$d aplikacione të kufizuara</item>
      <item quantity="one">%1$d aplikacion i kufizuar</item>
    </plurals>
    <string name="battery_header_title_alternate" msgid="1766047545950757380">"<xliff:g id="NUMBER">^1</xliff:g>"<small>" "<font size="20">"<xliff:g id="UNIT">%</xliff:g>"</font></small>""</string>
    <string name="dialog_stop_title" msgid="6395127715596746479">"Të ndalohet aplikacioni?"</string>
    <string name="dialog_stop_message" product="default" msgid="4006631636646776488">"Telefoni yt nuk mund ta menaxhojë baterinë në mënyrë normale pasi aplikacioni <xliff:g id="APP">%1$s</xliff:g> po e mban zgjuar telefonin.\n\nPër t\'u përpjekur të zgjidhësh këtë problem, mund ta ndalosh aplikacionin.\n\nNëse kjo vazhdon të ndodhë, mund të jetë e nevojshme ta çinstalosh aplikacionin për të përmirësuar cilësinë e funksionimit të baterisë."</string>
    <string name="dialog_stop_message" product="tablet" msgid="2369957934555162428">"Tableti yt nuk mund ta menaxhojë baterinë në mënyrë normale pasi aplikacioni <xliff:g id="APP">%1$s</xliff:g> po e mban zgjuar tabletin.\n\nPër t\'u përpjekur të zgjidhësh këtë problem, mund ta ndalosh aplikacionin.\n\nNëse kjo vazhdon të ndodhë, mund të jetë e nevojshme ta çinstalosh aplikacionin për të përmirësuar cilësinë e funksionimit të baterisë."</string>
    <string name="dialog_stop_message" product="device" msgid="6195430620406365292">"Pajisja jote nuk mund ta menaxhojë baterinë në mënyrë normale pasi aplikacioni <xliff:g id="APP">%1$s</xliff:g> po e mban zgjuar pajisjen.\n\nPër t\'u përpjekur të zgjidhësh këtë problem, mund ta ndalosh aplikacionin.\n\nNëse kjo vazhdon të ndodhë, mund të jetë e nevojshme ta çinstalosh aplikacionin për të përmirësuar cilësinë e funksionimit të baterisë."</string>
    <string name="dialog_stop_message_wakeup_alarm" product="default" msgid="1638726742782558262">"Telefoni yt nuk mund ta menaxhojë baterinë në mënyrë normale pasi <xliff:g id="APP_0">%1$s</xliff:g> vazhdon ta zgjojë telefonin.\n\nPër t\'u përpjekur të zgjidhësh këtë problem, mund ta ndalosh <xliff:g id="APP_1">%1$s</xliff:g>.\n\nNëse kjo vazhdon të ndodhë, mund të jetë e nevojshme ta çinstalosh aplikacionin për të përmirësuar cilësinë e funksionimit të baterisë."</string>
    <string name="dialog_stop_message_wakeup_alarm" product="tablet" msgid="8771690983566539742">"Tableti yt nuk mund ta menaxhojë baterinë në mënyrë normale pasi <xliff:g id="APP_0">%1$s</xliff:g> vazhdon ta zgjojë tabletin.\n\nPër t\'u përpjekur të zgjidhësh këtë problem, mund ta ndalosh <xliff:g id="APP_1">%1$s</xliff:g>.\n\nNëse kjo vazhdon të ndodhë, mund të jetë e nevojshme ta çinstalosh aplikacionin për të përmirësuar cilësinë e funksionimit të baterisë."</string>
    <string name="dialog_stop_message_wakeup_alarm" product="device" msgid="2854944538238649520">"Pajisja jote nuk mund ta menaxhojë baterinë në mënyrë normale pasi <xliff:g id="APP_0">%1$s</xliff:g> vazhdon ta zgjojë pajisjen.\n\nPër t\'u përpjekur të zgjidhësh këtë problem, mund ta ndalosh <xliff:g id="APP_1">%1$s</xliff:g>.\n\nNëse kjo vazhdon të ndodhë, mund të jetë e nevojshme ta çinstalosh aplikacionin për të përmirësuar cilësinë e funksionimit të baterisë."</string>
    <string name="dialog_stop_ok" msgid="2319777211264004900">"Ndalo aplikacionin"</string>
    <string name="dialog_background_check_title" msgid="6936542136153283692">"Të çaktivizohet përdorimi në sfond dhe të ndalohet aplikacioni?"</string>
    <string name="dialog_background_check_message" product="default" msgid="4045827746349279563">"Telefoni yt nuk mund ta menaxhojë baterinë në mënyrë normale pasi aplikacioni <xliff:g id="APP_0">%1$s</xliff:g> vazhdon ta zgjojë telefonin.\n\nQë të provosh të rregullosh këtë problem, mund të ndalosh <xliff:g id="APP_1">%1$s</xliff:g> dhe të mos lejosh që ai të ekzekutohet në sfond."</string>
    <string name="dialog_background_check_message" product="tablet" msgid="8348214419901788270">"Tableti yt nuk mund ta menaxhojë baterinë në mënyrë normale pasi aplikacioni <xliff:g id="APP_0">%1$s</xliff:g> vazhdon ta zgjojë tabletin.\n\nQë të provosh të rregullosh këtë problem, mund të ndalosh <xliff:g id="APP_1">%1$s</xliff:g> dhe të mos lejosh që ai të ekzekutohet në sfond."</string>
    <string name="dialog_background_check_message" product="device" msgid="5847977433118915863">"Pajisja jote nuk mund ta menaxhojë baterinë në mënyrë normale pasi aplikacioni <xliff:g id="APP_0">%1$s</xliff:g> vazhdon ta zgjojë pajisjen.\n\nQë të provosh të rregullosh këtë problem, mund të ndalosh <xliff:g id="APP_1">%1$s</xliff:g> dhe të mos lejosh që ai të ekzekutohet në sfond."</string>
    <string name="dialog_background_check_ok" msgid="412876934682899659">"Çaktivizo"</string>
    <string name="dialog_location_title" msgid="5888917530725874727">"Të çaktivizohet vendndodhja?"</string>
    <string name="dialog_location_message" product="default" msgid="7774807745601479888">"Telefoni yt nuk mund ta menaxhojë baterinë në mënyrë normale pasi aplikacioni <xliff:g id="APP">%1$s</xliff:g> vazhdon të kërkojë vendndodhjen kur nuk e përdor aplikacionin.\n\nPër të zgjidhur këtë problem, mund ta çaktivizosh vendndodhjen për këtë aplikacion."</string>
    <string name="dialog_location_message" product="tablet" msgid="118745801732181618">"Tableti yt nuk mund ta menaxhojë baterinë në mënyrë normale pasi aplikacioni <xliff:g id="APP">%1$s</xliff:g> vazhdon të kërkojë vendndodhjen kur nuk e përdor aplikacionin.\n\nPër të zgjidhur këtë problem, mund ta çaktivizosh vendndodhjen për këtë aplikacion."</string>
    <string name="dialog_location_message" product="device" msgid="6783678153382298295">"Pajisja jote nuk mund ta menaxhojë baterinë në mënyrë normale pasi aplikacioni <xliff:g id="APP">%1$s</xliff:g> vazhdon të kërkojë vendndodhjen kur nuk e përdor aplikacionin.\n\nPër të zgjidhur këtë problem, mund ta çaktivizosh vendndodhjen për këtë aplikacion."</string>
    <string name="dialog_location_ok" msgid="4572391197601313986">"Çaktivizo"</string>
    <string name="power_screen" msgid="3023346080675904613">"Ekrani"</string>
    <string name="power_flashlight" msgid="7794409781003567614">"Blici"</string>
    <string name="power_camera" msgid="4976286950934622605">"Kamera"</string>
    <string name="power_wifi" msgid="1135085252964054957">"Wi‑Fi"</string>
    <string name="power_bluetooth" msgid="4373329044379008289">"Bluetooth-i"</string>
    <string name="power_cell" msgid="3392999761958982492">"Rrjeti celular në gatishmëri"</string>
    <string name="power_phone" msgid="5392641106474567277">"Telefonatat zanore"</string>
    <string name="power_idle" product="tablet" msgid="4612478572401640759">"Tableti në gjendje joaktive"</string>
    <string name="power_idle" product="default" msgid="9055659695602194990">"Telefoni në gjendje joaktive"</string>
    <string name="power_unaccounted" msgid="709925017022660740">"Të ndryshme"</string>
    <string name="power_overcounted" msgid="2762354976171358445">"Numëruar më shumë sa duhet"</string>
    <string name="usage_type_cpu" msgid="715162150698338714">"CPU-ja në total"</string>
    <string name="usage_type_cpu_foreground" msgid="6500579611933211831">"CPU-ja në plan të parë"</string>
    <string name="usage_type_wake_lock" msgid="5125438890233677880">"Mbaje të zgjuar"</string>
    <string name="usage_type_gps" msgid="7989688715128160790">"GPS"</string>
    <string name="usage_type_wifi_running" msgid="3134357198266380400">"Wi‑Fi në ekzekutim"</string>
    <string name="usage_type_phone" product="tablet" msgid="262638572890253393">"Tableti"</string>
    <string name="usage_type_phone" product="default" msgid="9108247984998041853">"Telefoni"</string>
    <string name="usage_type_data_send" msgid="8971710128438365919">"Paketat celulare të dërguara"</string>
    <string name="usage_type_data_recv" msgid="5468564329333954445">"Paketat celulare u morën"</string>
    <string name="usage_type_radio_active" msgid="1732647857619420121">"Radioja celulare është aktive"</string>
    <string name="usage_type_data_wifi_send" msgid="1847552143597396162">"Paketat e Wi‑Fi u dërguan"</string>
    <string name="usage_type_data_wifi_recv" msgid="5678475911549183829">"Paketat e Wi‑Fi u morën"</string>
    <string name="usage_type_audio" msgid="6957269406840886290">"Audio"</string>
    <string name="usage_type_video" msgid="4295357792078579944">"Video"</string>
    <string name="usage_type_camera" msgid="8299433109956769757">"Kamera"</string>
    <string name="usage_type_flashlight" msgid="1516392356962208230">"Blici"</string>
    <string name="usage_type_on_time" msgid="3351200096173733159">"Koha e lënies ndezur"</string>
    <string name="usage_type_no_coverage" msgid="3797004252954385053">"Koha pa sinjal"</string>
    <string name="usage_type_total_battery_capacity" msgid="3798285287848675346">"Kapaciteti total i baterisë"</string>
    <string name="usage_type_computed_power" msgid="5862792259009981479">"Përdorimi i llogaritur i energjisë"</string>
    <string name="usage_type_actual_power" msgid="7047814738685578335">"Përdorimi i vërejtur i energjisë"</string>
    <string name="battery_action_stop" msgid="649958863744041872">"Ndalo me forcë"</string>
    <string name="battery_action_app_details" msgid="7861051816778419018">"Informacioni i apl."</string>
    <string name="battery_action_app_settings" msgid="4570481408106287454">"Cilësimet e apl."</string>
    <string name="battery_action_display" msgid="7338551244519110831">"Cilësimet e ekranit"</string>
    <string name="battery_action_wifi" msgid="8181553479021841207">"Cilësimet e Wi-Fi"</string>
    <string name="battery_action_bluetooth" msgid="8374789049507723142">"Cilësimet e Bluetooth-it"</string>
    <string name="battery_desc_voice" msgid="8980322055722959211">"Bateria e përdorur nga telefonatat zanore"</string>
    <string name="battery_desc_standby" product="tablet" msgid="6284747418668280364">"Bateria e përdorur kur tableti nuk është në punë"</string>
    <string name="battery_desc_standby" product="default" msgid="3009080001948091424">"Bateria e përdorur kur telefoni nuk është në punë"</string>
    <string name="battery_desc_radio" msgid="5479196477223185367">"Bateria e përdorur nga radioja celulare"</string>
    <string name="battery_sugg_radio" msgid="8211336978326295047">"Kalo te modaliteti \'në aeroplan\" për të kursyer energjinë në zonat pa mbulim të rrjetit celular"</string>
    <string name="battery_desc_flashlight" msgid="2908579430841025494">"Bateria e përdorur nga blici"</string>
    <string name="battery_desc_camera" msgid="7375389919760613499">"Bateria e përdorur nga kamera"</string>
    <string name="battery_desc_display" msgid="5432795282958076557">"Bateria e përdorur nga ekrani dhe drita e sfondit"</string>
    <string name="battery_sugg_display" msgid="3370202402045141760">"Ul ndriçimin e ekranit dhe/ose kohën e pritjes së ekranit"</string>
    <string name="battery_desc_wifi" msgid="2375567464707394131">"Bateria e përdorur nga Wi-Fi"</string>
    <string name="battery_sugg_wifi" msgid="7776093125855397043">"Çaktivizo Wi‑Fi kur nuk e përdor ose kur nuk ofrohet"</string>
    <string name="battery_desc_bluetooth" msgid="8069070756186680367">"Bateria e përdorur nga Bluetooth-i"</string>
    <string name="battery_sugg_bluetooth_basic" msgid="4565141162650835009">"Çaktivizo \"Bluetooth-in\" kur nuk e përdor."</string>
    <string name="battery_sugg_bluetooth_headset" msgid="4071352514714259230">"Provo të lidhesh me një pajisje tjetër me \"Bluetooth\""</string>
    <string name="battery_desc_apps" msgid="8530418792605735226">"Bateria e përdorur nga aplikacioni"</string>
    <string name="battery_sugg_apps_info" msgid="6907588126789841231">"Ndalo ose çinstalo aplikacionin"</string>
    <string name="battery_sugg_apps_gps" msgid="5959067516281866135">"Përzgjidh modalitetin e kursimit të baterisë"</string>
    <string name="battery_sugg_apps_settings" msgid="3974902365643634514">"Aplikacioni mund të ofrojë cilësimet për të zvogëluar përdorimin e baterisë"</string>
    <string name="battery_desc_users" msgid="7682989161885027823">"Bateria e përdorur nga përdoruesi"</string>
    <string name="battery_desc_unaccounted" msgid="7404256448541818019">"Përdorime të ndryshme të energjisë"</string>
    <string name="battery_msg_unaccounted" msgid="1963583522633067961">"Përdorimi i baterisë është një llogaritje e përafërt e përdorimit të energjisë dhe nuk përfshin çdo burim të shkarkimit të baterisë. \"Të ndryshme\" nënkupton ndryshimin midis përdorimit të llogaritur në mënyrë të përafërt të energjisë dhe shkarkimit aktual të vërejtur në bateri."</string>
    <string name="battery_desc_overcounted" msgid="5481865509489228603">"Përdorimi i energjisë i numëruar më shumë sa duhet"</string>
    <string name="mah" msgid="95245196971239711">"<xliff:g id="NUMBER">%d</xliff:g> mAh"</string>
    <string name="battery_used_for" msgid="2690821851327075443">"Përdorur për <xliff:g id="TIME">^1</xliff:g>"</string>
    <string name="battery_active_for" msgid="2964359540508103032">"Aktiv për <xliff:g id="TIME">^1</xliff:g>"</string>
    <string name="battery_screen_usage" msgid="6537658662149713585">"Përdorimi i ekranit <xliff:g id="TIME">^1</xliff:g>"</string>
    <string name="battery_used_by" msgid="1135316757755282999">"<xliff:g id="PERCENT">%1$s</xliff:g> përdorur nga <xliff:g id="APP">%2$s</xliff:g>"</string>
    <string name="battery_overall_usage" msgid="2093409063297375436">"<xliff:g id="PERCENT">%1$s</xliff:g> nga e gjithë bateria"</string>
    <string name="battery_detail_since_full_charge" msgid="7515347842046955855">"Analiza që nga karikimi i fundit i plotë"</string>
    <string name="battery_last_full_charge" msgid="7151251641099019361">"Karikimi i fundit i plotë"</string>
    <string name="battery_full_charge_last" msgid="8892335687734288031">"Ngarkimi i plotë zgjat rreth"</string>
    <string name="battery_footer_summary" msgid="67169726550144016">"Të dhënat e përdorimit të baterisë janë të përafërta dhe mund të ndryshojnë bazuar në përdorimin"</string>
    <string name="battery_detail_foreground" msgid="3350401514602032183">"Kur është në përdorim aktiv"</string>
    <string name="battery_detail_background" msgid="1929644393553768999">"Kur është në sfond"</string>
    <string name="battery_detail_power_usage" msgid="6485766868610469101">"Përdorimi i baterisë"</string>
    <string name="battery_detail_info_title" msgid="8227822131405620369">"Që nga karikimi i plotë"</string>
    <string name="battery_detail_manage_title" msgid="9094314252105828014">"Menaxho përdorimin e baterisë"</string>
    <string name="advanced_battery_graph_subtext" msgid="5621073891377915877">"Përllogaritja për baterinë e mbetur bazohet në përdorimin e pajisjes tënde"</string>
    <string name="estimated_time_left" msgid="7514194472683370877">"Koha e vlerësuar e mbetur"</string>
    <string name="estimated_charging_time_left" msgid="5614442409326164691">"Deri në ngarkimin e plotë"</string>
    <string name="estimated_time_description" msgid="8760210909000037089">"Vlerësimi mund të ndryshojë sipas përdorimit"</string>
    <string name="menu_stats_unplugged" msgid="8296577130840261624">"<xliff:g id="UNPLUGGED">%1$s</xliff:g> që kur ka qenë në prizë"</string>
    <string name="menu_stats_last_unplugged" msgid="5922246077592434526">"Kur ishte në prizë për herë të fundit për <xliff:g id="UNPLUGGED">%1$s</xliff:g>"</string>
    <string name="menu_stats_total" msgid="8973377864854807854">"Totalet e përdorimit"</string>
    <string name="menu_stats_refresh" msgid="1676215433344981075">"Rifresko"</string>
    <string name="process_kernel_label" msgid="3916858646836739323">"Sistemi operativ Android"</string>
    <string name="process_mediaserver_label" msgid="6500382062945689285">"Serveri i medias"</string>
    <string name="process_dex2oat_label" msgid="2592408651060518226">"Optimizimi i aplikacionit"</string>
    <string name="battery_saver" msgid="8172485772238572153">"Kursyesi i baterisë"</string>
    <string name="battery_saver_auto_title" msgid="8368709389419695611">"Aktivizo automatikisht"</string>
    <string name="battery_saver_auto_no_schedule" msgid="632243833320671052">"Nuk ka asnjë orar"</string>
    <string name="battery_saver_auto_routine" msgid="8076053160450346731">"Bazuar në rutinën tënde"</string>
    <string name="battery_saver_auto_percentage" msgid="9000542338151528905">"Bazuar në përqindjen"</string>
    <string name="battery_saver_auto_routine_summary" msgid="3030089882678228374">"\"Kursyesi i baterisë\" aktivizohet nëse bateria mund të mbarojë përpara karikimit të zakonshëm të radhës"</string>
    <string name="battery_saver_auto_percentage_summary" msgid="3653601117764171846">"Do të aktivizohet në <xliff:g id="PERCENT">%1$s</xliff:g>"</string>
    <string name="battery_saver_schedule_settings_title" msgid="6000660866895036589">"Cakto një orar"</string>
    <string name="battery_saver_turn_on_summary" msgid="5552800757174173459">"Zgjat kohëzgjatjen e baterisë"</string>
    <string name="battery_saver_sticky_title_new" msgid="613272902035943099">"Çaktivizoje kur të jetë karikuar plotësisht"</string>
    <string name="battery_saver_sticky_description_new" product="default" msgid="6659545534053937371">"\"Kursyesi i baterisë\" çaktivizohet kur telefoni yt është në <xliff:g id="PERCENT">%1$s</xliff:g>"</string>
    <string name="battery_saver_sticky_description_new" product="tablet" msgid="6537930800784858686">"\"Kursyesi i baterisë\" çaktivizohet kur tableti yt është në <xliff:g id="PERCENT">%1$s</xliff:g>"</string>
    <string name="battery_saver_sticky_description_new" product="device" msgid="8309483774864505603">"\"Kursyesi i baterisë\" çaktivizohet kur pajisja jote është në <xliff:g id="PERCENT">%1$s</xliff:g>"</string>
    <!-- no translation found for battery_saver_seekbar_title (3795833548145424276) -->
    <skip />
    <string name="battery_saver_seekbar_title_placeholder" msgid="1138980155985636295">"Aktivizo"</string>
    <string name="battery_saver_master_switch_title" msgid="622539414546588436">"Përdor \"Kursyesin e baterisë\""</string>
    <string name="battery_saver_turn_on_automatically_title" msgid="9023847300114669426">"Aktivizim automatikisht"</string>
    <string name="battery_saver_turn_on_automatically_never" msgid="6610846456314373">"Asnjëherë"</string>
    <string name="battery_saver_turn_on_automatically_pct" msgid="8665950426992057191">"me <xliff:g id="PERCENT">%1$s</xliff:g> bateri"</string>
    <string name="battery_percentage" msgid="723291197508049369">"Përqindja e baterisë"</string>
    <string name="battery_percentage_description" msgid="8511658577507384014">"Shfaq përqindjen e baterisë në shiritin e statusit"</string>
    <string name="process_stats_summary_title" msgid="1144688045609771677">"Statistikat e procesit"</string>
    <string name="process_stats_summary" msgid="109387941605607762">"Statistikat teknike për proceset në ekzekutim"</string>
    <string name="app_memory_use" msgid="7849258480392171939">"Përdorimi i memories"</string>
    <string name="process_stats_total_duration" msgid="7417201400853728029">"<xliff:g id="USEDRAM">%1$s</xliff:g> nga <xliff:g id="TOTALRAM">%2$s</xliff:g> të përdorura gjatë <xliff:g id="TIMEDURATION">%3$s</xliff:g> të fundit"</string>
    <string name="process_stats_total_duration_percentage" msgid="6522457033380025618">"<xliff:g id="PERCENT">%1$s</xliff:g> e memories RAM është përdorur për <xliff:g id="TIMEDURATION">%2$s</xliff:g>"</string>
    <string name="process_stats_type_background" msgid="3934992858120683459">"Sfondi"</string>
    <string name="process_stats_type_foreground" msgid="7713118254089580536">"Plani i parë"</string>
    <string name="process_stats_type_cached" msgid="6314925846944806511">"Në memorien specifike"</string>
    <string name="process_stats_os_label" msgid="4813434110442733392">"Sistemi operativ Android"</string>
    <string name="process_stats_os_native" msgid="5322428494231768472">"Vendas"</string>
    <string name="process_stats_os_kernel" msgid="1938523592369780924">"Bërthamë"</string>
    <string name="process_stats_os_zram" msgid="677138324651671575">"Z-Ram"</string>
    <string name="process_stats_os_cache" msgid="6432533624875078233">"Memoriet specifike"</string>
    <string name="process_stats_ram_use" msgid="976912589127397307">"Përdorimi i RAM-it"</string>
    <string name="process_stats_bg_ram_use" msgid="5398191511030462404">"Përdorimi i RAM-it (sfond)"</string>
    <string name="process_stats_run_time" msgid="6520628955709369115">"Koha në funksionim"</string>
    <string name="processes_subtitle" msgid="6827502409379462438">"Përpunime"</string>
    <string name="services_subtitle" msgid="4296402367067266425">"Shërbimet"</string>
    <string name="menu_proc_stats_duration" msgid="2323483592994720196">"Kohëzgjatja"</string>
    <string name="mem_details_title" msgid="6548392825497290498">"Detajet e memories"</string>
    <string name="menu_duration_3h" msgid="4714866438374738385">"3 orë"</string>
    <string name="menu_duration_6h" msgid="1940846763432184132">"6 orë"</string>
    <string name="menu_duration_12h" msgid="7890465404584356294">"12 orë"</string>
    <string name="menu_duration_1d" msgid="3393631127622285458">"1 ditë"</string>
    <string name="menu_show_system" msgid="8864603400415567635">"Shfaq sistemin"</string>
    <string name="menu_hide_system" msgid="4106826741703745733">"Fshih sistemin"</string>
    <string name="menu_show_percentage" msgid="4717204046118199806">"Tregoji në përqindje"</string>
    <string name="menu_use_uss" msgid="467765290771543089">"Përdor Uss-në"</string>
    <string name="menu_proc_stats_type" msgid="4700209061072120948">"Lloji i statistikave"</string>
    <string name="menu_proc_stats_type_background" msgid="2236161340134898852">"Sfondi"</string>
    <string name="menu_proc_stats_type_foreground" msgid="2286182659954958586">"Në plan të parë"</string>
    <string name="menu_proc_stats_type_cached" msgid="5084272779786820693">"Në memorien specifike"</string>
    <string name="voice_input_output_settings" msgid="1336135218350444783">"Hyrjet dhe daljet e zërit"</string>
    <string name="voice_input_output_settings_title" msgid="2442850635048676991">"Cilësimet e hyrjes dhe daljes së zërit"</string>
    <string name="voice_search_settings_title" msgid="2775469246913196536">"Kërkimi me zë"</string>
    <string name="keyboard_settings_title" msgid="5080115226780201234">"Tastierë për \"Android\""</string>
    <string name="voice_input_settings" msgid="1099937800539324567">"Cilësimet e hyrjes zanore"</string>
    <string name="voice_input_settings_title" msgid="2676028028084981891">"Të dhënat zanore"</string>
    <string name="voice_service_preference_section_title" msgid="3778706644257601021">"Shërbime të hyrjes zanore"</string>
    <string name="voice_interactor_preference_summary" msgid="1801414022026937190">"Ndërveprimi dhe fjalëkyçi i aktivizimit (hotword), i plotë"</string>
    <string name="voice_recognizer_preference_summary" msgid="669880813593690527">"Shërbim i thjeshtë \"ligjërim-në-tekst\""</string>
    <string name="voice_interaction_security_warning" msgid="6378608263983737325">"Ky shërbim i hyrjes së zërit do të kryejë gjithmonë monitorim të zërit si dhe do të kontrollojë në emrin tënd, të gjitha aplikacionet që mundësohen me zë. Ai ofrohet nga aplikacioni <xliff:g id="VOICE_INPUT_SERVICE_APP_NAME">%s</xliff:g>. Të aktivizohet përdorimi e këtij shërbimi?"</string>
    <string name="tts_engine_preference_title" msgid="1578826947311494239">"Motori i preferuar"</string>
    <string name="tts_engine_settings_title" msgid="6886964122861384818">"Cilësimet e motorit"</string>
    <string name="tts_sliders_title" msgid="992059150784095263">"Shpejtësia e të folurës dhe intonacioni"</string>
    <string name="tts_engine_section_title" msgid="6289240207677024034">"Motori"</string>
    <string name="tts_install_voice_title" msgid="6275828614052514320">"Zërat"</string>
    <string name="tts_spoken_language" msgid="5542499183472504027">"Gjuha e folur"</string>
    <string name="tts_install_voices_title" msgid="8808823756936022641">"Instalo zërat"</string>
    <string name="tts_install_voices_text" msgid="5292606786380069134">"Vazhdo tek aplikacioni <xliff:g id="TTS_APP_NAME">%s</xliff:g> për të instaluar zërat"</string>
    <string name="tts_install_voices_open" msgid="667467793360277465">"Hap aplikacionin"</string>
    <string name="tts_install_voices_cancel" msgid="4711492804851107459">"Anulo"</string>
    <string name="tts_reset" msgid="2661752909256313270">"Rivendos"</string>
    <string name="tts_play" msgid="2628469503798633884">"Luaj"</string>
    <string name="vpn_settings_title" msgid="5662579425832406705">"VPN"</string>
    <string name="credentials_title" msgid="4446234003860769883">"Ruajtja e kredencialeve"</string>
    <string name="credentials_install" product="nosdcard" msgid="466093273825150847">"Instalo nga hapësira ruajtëse"</string>
    <string name="credentials_install" product="default" msgid="953914549998062317">"Instalo nga karta SD"</string>
    <string name="credentials_install_summary" product="nosdcard" msgid="4220422806818210676">"Instalo certifikatat nga hapësira ruajtëse"</string>
    <string name="credentials_install_summary" product="default" msgid="5737658257407822713">"Instalo certifikatat nga karta SD"</string>
    <string name="credentials_reset" msgid="3239382277144980418">"Pastro kredencialet"</string>
    <string name="credentials_reset_summary" msgid="3369361230171260282">"Hiqi të gjitha certifikatat"</string>
    <string name="trusted_credentials" msgid="4266945289534242402">"Kredencialet e besuara"</string>
    <string name="trusted_credentials_summary" msgid="6735221351155686632">"Shfaq certifikatat CA të besuara"</string>
    <string name="user_credentials" msgid="3719013347787187083">"Kredencialet e përdoruesit"</string>
    <string name="user_credentials_summary" msgid="7271228342106080167">"Shiko dhe modifiko kredencialet e ruajtura"</string>
    <string name="advanced_security_title" msgid="2434776238010578865">"Të përparuara"</string>
    <string name="credential_storage_type" msgid="8629968543494001364">"Lloji i hapësirës ruajtëse"</string>
    <string name="credential_storage_type_hardware" msgid="6077193544333904427">"E mbështetur nga hardueri"</string>
    <string name="credential_storage_type_software" msgid="4403117271207715378">"Vetëm ajo e softuerit"</string>
    <string name="credentials_settings_not_available" msgid="7968275634486624215">"Kredencialet nuk ofrohen për këtë përdorues"</string>
    <string name="credential_for_vpn_and_apps" msgid="4168197158768443365">"Instaluar për VPN dhe aplikacione"</string>
    <string name="credential_for_wifi" msgid="6228425986551591864">"Instaluar për Wi-Fi"</string>
    <string name="credentials_reset_hint" msgid="6297256880896133631">"Të hiqen të gjitha përmbajtjet?"</string>
    <string name="credentials_erased" msgid="2907836028586342969">"Hapësira ruajtëse e kredencialeve është spastruar."</string>
    <string name="credentials_not_erased" msgid="7685932772284216097">"Ruajtja e kred. s\'mund të fshihej."</string>
    <string name="usage_access_title" msgid="332333405495457839">"Aplikacionet me qasje përdorimi"</string>
    <string name="emergency_tone_title" msgid="254495218194925271">"Sinjali i telefonimit të urgjencës"</string>
    <string name="emergency_tone_summary" msgid="722259232924572153">"Cakto sjelljen kur kryhet një telefonatë urgjence"</string>
    <string name="privacy_settings_title" msgid="2978878794187459190">"Rezervimi"</string>
    <string name="backup_summary_state_on" msgid="6407084627816231202">"Aktiv"</string>
    <string name="backup_summary_state_off" msgid="7388321532624105594">"Joaktiv"</string>
    <string name="backup_section_title" msgid="7952232291452882740">"Rezervo dhe restauro"</string>
    <string name="personal_data_section_title" msgid="7815209034443782061">"Të dhënat personale"</string>
    <string name="backup_data_title" msgid="1239105919852668016">"Rezervo të dhënat e mia"</string>
    <string name="backup_data_summary" msgid="708773323451655666">"Rezervo të dhënat e aplikacioneve, fjalëkalimet e Wi-Fi dhe cilësimet e tjera në serverët e Google"</string>
    <string name="backup_configure_account_title" msgid="3790872965773196615">"Llogaria rezervë"</string>
    <string name="backup_data_management_title" msgid="4059093462647090064">"Menaxho llogarinë e rezervimit"</string>
    <string name="include_app_data_title" msgid="2829970132260278394">"Përfshi të dhënat e aplikacionit"</string>
    <string name="auto_restore_title" msgid="5397528966329126506">"Restaurimi automatik"</string>
    <string name="auto_restore_summary" msgid="4235615056371993807">"Në rast të ri-instalimit të një aplikacioni, cilësimet dhe të dhënat e rezervuara do të restaurohen"</string>
    <string name="backup_inactive_title" msgid="685838037986644604">"Shërbimi i rezervimit nuk është aktiv"</string>
    <string name="backup_configure_account_default_summary" msgid="2436933224764745553">"Asnjë llogari nuk po ruan aktualisht të dhënat e kopjes rezervë"</string>
    <string name="backup_erase_dialog_title" msgid="1027640829482174106"></string>
    <string name="backup_erase_dialog_message" msgid="5221011285568343155">"Të ndalohet rezervimi i fjalëkalimeve të Wi-Fi, faqeshënuesve, të dhënave të aplikacioneve dhe cilësimeve të tjera? Të fshihen gjithashtu edhe të gjitha kopjet në serverët e Google?"</string>
    <string name="fullbackup_erase_dialog_message" msgid="694766389396659626">"Ndalo rezervimin e të dhënave të pajisjes (si p.sh. fjalëkalimet e Wi-Fi dhe historikun e telefonatave) dhe të dhënave të aplikacioneve (si p.sh. cilësimet dhe skedarët e ruajtur nga aplikacionet) dhe spastro të gjitha kopjet në serverët në largësi?"</string>
    <string name="fullbackup_data_summary" msgid="960850365007767734">"Rezervo automatikisht në largësi të dhënat e pajisjes (si p.sh. fjalëkalimet e Wi-Fi dhe historikun e telefonatave) dhe të dhënat e aplikacioneve (si p.sh. cilësimet dhe skedarët e ruajtur nga aplikacionet).\n\nKur aktivizon rezervimin automatik, të dhënat e pajisjes dhe të aplikacioneve ruhen periodikisht në largësi. Të dhënat e aplikacioneve mund të jenë çdo e dhënë që ka ruajtur një aplikacion (bazuar në cilësimet e zhvilluesit), duke përfshirë të dhëna ndoshta delikate si kontaktet, mesazhet dhe fotografitë."</string>
    <string name="device_admin_settings_title" msgid="4960761799560705902">"Cilësimet e administratorit të pajisjes"</string>
    <string name="active_device_admin_msg" msgid="578748451637360192">"Apl. administrimi i pajisjes"</string>
    <string name="remove_device_admin" msgid="9207368982033308173">"Çaktivizo këtë aplikacion të administratorit të pajisjes"</string>
    <string name="uninstall_device_admin" msgid="271120195128542165">"Çinstalo aplikacionin"</string>
    <string name="remove_and_uninstall_device_admin" msgid="3837625952436169878">"Çaktivizo dhe çinstalo"</string>
    <string name="select_device_admin_msg" msgid="7347389359013278077">"Apl. e admin. të pajisjes"</string>
    <string name="no_device_admins" msgid="4846602835339095768">"Nuk ka asnjë aplikacion administrimi të pajisjes në dispozicion"</string>
    <string name="personal_device_admin_title" msgid="2849617316347669861">"Personal"</string>
    <string name="managed_device_admin_title" msgid="7853955652864478435">"Punë"</string>
    <string name="sms_access_restriction_enabled" msgid="7054488078710530278">"Kufizo qasjen tek evidenca e telefonatave dhe SMS-ve"</string>
    <string name="sms_access_restriction_enabled_summary" msgid="6851339654677842328">"Vetëm aplikacionet e parazgjedhura të mesazheve dhe telefonit kanë leje për evidencën e telefonatave dhe SMS-ve"</string>
    <string name="no_trust_agents" msgid="7450273545568977523">"Nuk mundësohet asnjë agjent i besuar"</string>
    <string name="add_device_admin_msg" msgid="1501847129819382149">"Të aktivizohet aplikacioni i administratorit të pajisjes?"</string>
    <string name="add_device_admin" msgid="4192055385312215731">"Aktivizo këtë aplikacion të administratorit të pajisjes"</string>
    <string name="device_admin_add_title" msgid="3140663753671809044">"Administratori i pajisjes"</string>
    <string name="device_admin_warning" msgid="7482834776510188134">"Aktivizimi i këtij aplikacioni të administratorit do të lejojë që aplikacioni <xliff:g id="APP_NAME">%1$s</xliff:g> të kryejë veprimet e mëposhtme:"</string>
    <string name="device_admin_warning_simplified" msgid="8085544856342321981">"Kjo pajisje do të menaxhohet dhe do të monitorohet nga <xliff:g id="APP_NAME">%1$s</xliff:g>."</string>
    <string name="device_admin_status" msgid="7234814785374977990">"Ky aplikacion administratori është aktiv dhe lejon apl. <xliff:g id="APP_NAME">%1$s</xliff:g> të kryejë veprimet e mëposhtme:"</string>
    <string name="profile_owner_add_title" msgid="6249331160676175009">"Të aktivizohet menaxheri i profilit?"</string>
    <string name="profile_owner_add_title_simplified" msgid="6856400286736117006">"Të lejohet mbikëqyrja?"</string>
    <string name="adding_profile_owner_warning" msgid="1354474524852805802">"Duke vazhduar, profili yt si \"përdorues\" do të menaxhohet nga administratori yt, i cili mund të ruajë të dhënat e lidhura, përveç të dhënave të tua personale.\n\nAdministratori yt ka aftësinë që të monitorojë dhe të menaxhojë cilësimet, qasjen, aplikacionet dhe të dhënat e lidhura me këtë përdorues, duke përfshirë aktivitetin e rrjetit dhe informacionet e vendndodhjes së pajisjes tënde."</string>
    <string name="admin_disabled_other_options" msgid="7712694507069054530">"Opsionet e tjera janë çaktivizuar nga administratori yt"</string>
    <string name="admin_more_details" msgid="7901420667346456102">"Më shumë detaje"</string>
    <string name="notification_log_title" msgid="3766148588239398464">"Regjistri i njoftimeve"</string>
    <string name="sound_category_call_ringtone_vibrate_title" msgid="1543777228646645163">"Zilja dhe dridhja e telefonit."</string>
    <string name="wifi_setup_detail" msgid="2336990478140503605">"Detajet e rrjetit"</string>
    <string name="accessibility_sync_enabled" msgid="558480439730263116">"Sinkronizimi u aktivizua"</string>
    <string name="accessibility_sync_disabled" msgid="1741194106479011384">"Sinkronizimi u çaktivizua"</string>
    <string name="accessibility_sync_in_progress" msgid="4501160520879902723">"Po sinkronizon tani"</string>
    <string name="accessibility_sync_error" msgid="8703299118794272041">"Gabim në sinkronizim."</string>
    <string name="sync_failed" msgid="1696499856374109647">"Sinkronizimi dështoi"</string>
    <string name="sync_active" msgid="8476943765960863040">"Sinkronizimi është aktiv"</string>
    <string name="account_sync_settings_title" msgid="5131314922423053588">"Sinkronizo"</string>
    <string name="sync_is_failing" msgid="1591561768344128377">"Sinkronizimi ka aktualisht probleme. Do të ofrohet sërish së shpejti."</string>
    <string name="add_account_label" msgid="7811707265834013767">"Shto një llogari"</string>
    <string name="managed_profile_not_available_label" msgid="852263300911325904">"Profili i punës nuk ofrohet ende"</string>
    <string name="work_mode_label" msgid="7157582467956920750">"Profili i punës"</string>
    <string name="work_mode_on_summary" msgid="3628349169847990263">"Menaxhohet nga organizata jote"</string>
    <string name="work_mode_off_summary" msgid="2657138190560082508">"Aplikacionet dhe njoftimet janë joaktive"</string>
    <string name="remove_managed_profile_label" msgid="3856519337797285325">"Hiq profilin e punës"</string>
    <string name="background_data" msgid="5779592891375473817">"Të dhënat në sfond"</string>
    <string name="background_data_summary" msgid="8328521479872763452">"Aplikacionet mund të sinkronizojnë, dërgojnë dhe marrin të dhëna në çdo kohë"</string>
    <string name="background_data_dialog_title" msgid="6059217698124786537">"Të çaktivizohen të dhënat në sfond?"</string>
    <string name="background_data_dialog_message" msgid="6981661606680941633">"Ҫaktivizimi i të dhënave në sfond zgjat jetëgjatësinë e baterisë dhe zvogëlon përdorimin e të dhënave. Disa aplikacione mund të përdorin akoma lidhjen e të dhënave në sfond."</string>
    <string name="sync_automatically" msgid="1682730255435062059">"Auto-sinkronizo të dhënat e apl."</string>
    <string name="sync_enabled" msgid="4551148952179416813">"Sinkronizimi është aktiv"</string>
    <string name="sync_disabled" msgid="8511659877596511991">"Sinkronizimi është JOAKTIV"</string>
    <string name="sync_error" msgid="5060969083117872149">"Gabim gjatë sinkronizimit"</string>
    <string name="last_synced" msgid="4242919465367022234">"Sinkronizuar për herë të fundit <xliff:g id="LAST_SYNC_TIME">%1$s</xliff:g>"</string>
    <string name="sync_in_progress" msgid="5151314196536070569">"Po sinkronizon tani…"</string>
    <string name="settings_backup" msgid="2274732978260797031">"Cilësimet e rezervimit"</string>
    <string name="settings_backup_summary" msgid="7916877705938054035">"Rezervo cilësimet e mia"</string>
    <string name="sync_menu_sync_now" msgid="6154608350395805683">"Sinkronizo tani"</string>
    <string name="sync_menu_sync_cancel" msgid="8292379009626966949">"Anulo sinkronizimin"</string>
    <string name="sync_one_time_sync" msgid="3733796114909082260">"Trokit për ta sinkronizuar tani<xliff:g id="LAST_SYNC_TIME">
%1$s</xliff:g>"</string>
    <string name="sync_gmail" msgid="714886122098006477">"Gmail"</string>
    <string name="sync_calendar" msgid="9056527206714733735">"Kalendari"</string>
    <string name="sync_contacts" msgid="9174914394377828043">"Kontaktet"</string>
    <string name="sync_plug" msgid="3905078969081888738"><font fgcolor="#ffffffff">"Mirë se erdhe në sinkronizimin e Google!"</font>" \nNjë metodë e Google për të sinkronizuar të dhënat për të të lejuar qasje te kontaktet, takimet dhe të tjera, kudo ku të ndodhesh."</string>
    <string name="header_application_sync_settings" msgid="6205903695598000286">"Cilësimet e sinkronizimit të apl."</string>
    <string name="header_data_and_synchronization" msgid="5165024023936509896">"Të dhënat dhe sinkronizimi"</string>
    <string name="preference_change_password_title" msgid="8955581790270130056">"Ndërro fjalëkalimin"</string>
    <string name="header_account_settings" msgid="5382475087121880626">"Cilësimet e llogarisë"</string>
    <string name="remove_account_label" msgid="5921986026504804119">"Hiq llogarinë"</string>
    <string name="header_add_an_account" msgid="756108499532023798">"Shto një llogari"</string>
    <string name="really_remove_account_title" msgid="8800653398717172460">"Të hiqet llogaria?"</string>
    <string name="really_remove_account_message" product="tablet" msgid="1936147502815641161">"Heqja e kësaj llogarie do të fshijë të gjitha mesazhet, kontaktet dhe të dhëna të tjera të saj nga tableti!"</string>
    <string name="really_remove_account_message" product="default" msgid="3483528757922948356">"Heqja e kësaj llogarie do të fshijë nga telefoni të gjitha mesazhet dhe kontaktet e saj, si dhe të dhëna të tjera!"</string>
    <string name="really_remove_account_message" product="device" msgid="7507474724882080166">"Heqja e kësaj llogarie do të fshijë të gjitha mesazhet, kontaktet e saj dhe të dhëna të tjera nga pajisja!"</string>
    <string name="remove_account_failed" msgid="3901397272647112455">"Ky ndryshim nuk lejohet nga administratori yt"</string>
    <string name="cant_sync_dialog_title" msgid="2777238588398046285">"Nuk mund të sinkronizojë manualisht"</string>
    <string name="cant_sync_dialog_message" msgid="1938380442159016449">"Sinkronizimi për këtë artikull është aktualisht i çaktivizuar. Për ta ndryshuar këtë cilësim, aktivizo përkohësisht të dhënat në sfond dhe sinkronizimin automatik."</string>
    <string name="enter_password" msgid="8035706727471334122">"Për të nisur Androidin, fut fjalëkalimin"</string>
    <string name="enter_pin" msgid="5305333588093263790">"Për të nisur Androidin, fut kodin PIN"</string>
    <string name="enter_pattern" msgid="4187435713036808566">"Për të nisur Androidin, vizato motivin tënd"</string>
    <string name="cryptkeeper_wrong_pattern" msgid="8423835922362956999">"Motivi është i gabuar"</string>
    <string name="cryptkeeper_wrong_password" msgid="5200857195368904047">"Fjalëkalim i gabuar"</string>
    <string name="cryptkeeper_wrong_pin" msgid="755720788765259382">"Kod PIN i gabuar"</string>
    <string name="checking_decryption" msgid="8287458611802609493">"Po kontrollon..."</string>
    <string name="starting_android" msgid="4001324195902252681">"Po nis Android..."</string>
    <string name="delete" msgid="4219243412325163003">"Fshi"</string>
    <string name="misc_files" msgid="6720680815969643497">"Skedarë të ndryshëm"</string>
    <string name="misc_files_selected_count" msgid="4647048020823912088">"u zgjodhën <xliff:g id="NUMBER">%1$d</xliff:g> nga <xliff:g id="TOTAL">%2$d</xliff:g> në total"</string>
    <string name="misc_files_selected_count_bytes" msgid="2876232009069114352">"<xliff:g id="NUMBER">%1$s</xliff:g> nga <xliff:g id="TOTAL">%2$s</xliff:g>"</string>
    <string name="select_all" msgid="1562774643280376715">"Përzgjidhi të gjtiha"</string>
    <string name="data_usage_summary_title" msgid="3804110657238092929">"Përdorimi i të dhënave"</string>
    <string name="data_usage_app_summary_title" msgid="5571051159374290375">"Të dhënat celulare dhe Wi‑Fi"</string>
    <string name="data_usage_accounting" msgid="7170028915873577387">"Llogaritja e të dhënave nga operatori mund të ndryshojë nga ajo e pajisjes tënde."</string>
    <string name="data_usage_app" msgid="4970478397515423303">"Përdorimi i aplikacionit"</string>
    <string name="data_usage_app_info_label" msgid="3409931235687866706">"INFORMACIONI I APL."</string>
    <string name="data_usage_cellular_data" msgid="9168928285122125137">"Të dhënat celulare"</string>
    <string name="data_usage_data_limit" msgid="1193930999713192703">"Cakto kufirin e të dhënave"</string>
    <string name="data_usage_cycle" msgid="5652529796195787949">"Cikli i përdorimit të të dhënave"</string>
    <string name="data_usage_app_items_header_text" msgid="5017850810459372828">"Përdorimi i aplikacionit"</string>
    <string name="data_usage_menu_roaming" msgid="8042359966835203296">"Të dhënat në roaming"</string>
    <string name="data_usage_menu_restrict_background" msgid="1989394568592253331">"Kufizo të dhënat në sfond"</string>
    <string name="data_usage_menu_allow_background" msgid="2694761978633359223">"Lejo të dhënat në sfond"</string>
    <string name="data_usage_menu_split_4g" msgid="5322857680792601899">"Përdorimi i 4G i ndarë"</string>
    <string name="data_usage_menu_show_wifi" msgid="2296217964873872571">"Shfaq Wi-Fi"</string>
    <string name="data_usage_menu_hide_wifi" msgid="7290056718050186769">"Fshih Wi-Fi"</string>
    <string name="data_usage_menu_show_ethernet" msgid="5181361208532314097">"Shfaq përdorimin e Eternetit"</string>
    <string name="data_usage_menu_hide_ethernet" msgid="3326702187179943681">"Fshih përdorimin e eternetit"</string>
    <string name="data_usage_menu_metered" msgid="6235119991372755026">"Kufizimet e rrjetit"</string>
    <string name="data_usage_menu_auto_sync" msgid="8203999775948778560">"Të dhënat e autosinkronizimit"</string>
    <string name="data_usage_menu_sim_cards" msgid="6410498422797244073">"Kartat SIM"</string>
    <string name="data_usage_cellular_data_summary" msgid="8413357481361268285">"U ndërpre në kufi"</string>
    <string name="account_settings_menu_auto_sync" msgid="6243013719753700377">"Auto-sinkronizo të dhënat"</string>
    <string name="account_settings_menu_auto_sync_personal" msgid="785541379617346438">"Sinkronizo automatikisht të dhënat personale"</string>
    <string name="account_settings_menu_auto_sync_work" msgid="329565580969147026">"Sinkronizo automatikisht të dhënat e punës"</string>
    <string name="data_usage_change_cycle" msgid="7776556448920114866">"Ndrysho ciklin…"</string>
    <string name="data_usage_pick_cycle_day" msgid="4470796861757050966">"Dita për rivendosjen e ciklit të përdorimit të të dhënave:"</string>
    <string name="data_usage_empty" msgid="8621855507876539282">"Nuk janë përdorur të dhëna gjatë kësaj periudhe."</string>
    <string name="data_usage_label_foreground" msgid="4938034231928628164">"Plani i parë"</string>
    <string name="data_usage_label_background" msgid="3225844085975764519">"Sfondi"</string>
    <string name="data_usage_app_restricted" msgid="3568465218866589705">"i kufizuar"</string>
    <string name="data_usage_disable_mobile" msgid="8656552431969276305">"Të çaktivizohen të dhënat celulare?"</string>
    <string name="data_usage_disable_mobile_limit" msgid="4644364396844393848">"Cakto kufirin e të dhënave"</string>
    <string name="data_usage_disable_4g_limit" msgid="6233554774946681175">"Cakto kufirin e të dhënave 4G"</string>
    <string name="data_usage_disable_3g_limit" msgid="2558557840444266906">"Cakto kufirin për 2G-3G"</string>
    <string name="data_usage_disable_wifi_limit" msgid="1394901415264660888">"Cakto kufirin e të dhënave të Wi-Fi"</string>
    <string name="data_usage_tab_wifi" msgid="481146038146585749">"Wi‑Fi"</string>
    <string name="data_usage_tab_ethernet" msgid="7298064366282319911">"Eternet"</string>
    <string name="data_usage_tab_mobile" msgid="454140350007299045">"Celulare"</string>
    <string name="data_usage_tab_4g" msgid="1301978716067512235">"4G"</string>
    <string name="data_usage_tab_3g" msgid="6092169523081538718">"2G-3G"</string>
    <string name="data_usage_list_mobile" msgid="5588685410495019866">"Celulare"</string>
    <string name="data_usage_list_none" msgid="3933892774251050735">"Asnjë"</string>
    <string name="data_usage_enable_mobile" msgid="986782622560157977">"Të dhënat celulare"</string>
    <string name="data_usage_enable_3g" msgid="6304006671869578254">"Të dhënat 2G-3G"</string>
    <string name="data_usage_enable_4g" msgid="3635854097335036738">"Të dhënat 4G"</string>
    <string name="data_roaming_enable_mobile" msgid="1523331545457578362">"Roaming"</string>
    <string name="data_usage_forground_label" msgid="7654319010655983591">"Plani i parë:"</string>
    <string name="data_usage_background_label" msgid="2722008379947694926">"Sfondi:"</string>
    <string name="data_usage_app_settings" msgid="2279171379771253165">"Cilësimet e apl."</string>
    <string name="data_usage_app_restrict_background" msgid="7359227831562303223">"Të dhënat në sfond"</string>
    <string name="data_usage_app_restrict_background_summary" msgid="5853552187570622572">"Aktivizo përdorimin e të dhënave celulare në sfond"</string>
    <string name="data_usage_app_restrict_background_summary_disabled" msgid="7401927377070755054">"Për të kufizuar të dhënat në sfond për këtë aplikacion, në fillim cakto një kufi të të dhënave celulare."</string>
    <string name="data_usage_app_restrict_dialog_title" msgid="1613108390242737923">"Të kufizohen të dhënat në sfond?"</string>
    <string name="data_usage_app_restrict_dialog" msgid="1466689968707308512">"Ky funksion mund bëjë që një aplikacion, i cili mbështetet në të dhënat në sfond, të mos funksionojë kur ofrohen vetëm rrjetet celulare.\n\nMund të gjesh kontrolle të tjera më të përshtatshme përdorimi të të dhënave në cilësimet që ofrohen në aplikacion."</string>
    <string name="data_usage_restrict_denied_dialog" msgid="55012417305745608">"Kufizimi i të dhënave në sfond është i mundur vetëm kur ke caktuar një kufi të të dhënave celulare."</string>
    <string name="data_usage_auto_sync_on_dialog_title" msgid="2438617846762244389">"Të aktivizohen të dhënat e sinkronizimit automatik?"</string>
    <string name="data_usage_auto_sync_on_dialog" product="tablet" msgid="8581983093524041669">"Çdo ndryshim që bën në llogaritë e tua në ueb do të kopjohet automatikisht te tableti.\n\nDisa llogari mund të kopjojnë po ashtu automatikisht çdo ndryshim që bën në tablet, për ta sinkronizuar në ueb. Kështu funksionon llogaria e Google."</string>
    <string name="data_usage_auto_sync_on_dialog" product="default" msgid="8651376294887142858">"Çdo ndryshim që bën në llogaritë e tua në ueb do të kopjohet automatikisht te telefoni.\n\nDisa llogari mund të kopjojnë po ashtu automatikisht çdo ndryshim që bën në telefon, për ta sinkronizuar në ueb. Kjo është mënyra se si funksionon llogaria e Google."</string>
    <string name="data_usage_auto_sync_off_dialog_title" msgid="9013139130490125793">"Të çaktivizohen të dhënat e sinkronizimit automatik?"</string>
    <string name="data_usage_auto_sync_off_dialog" msgid="4025938250775413864">"Ky funksion do të kursejë përdorimin e të dhënave dhe të baterisë, por për të mbledhur informacionet më të fundit, do të të duhet të sinkronizosh në mënyrë manuale çdo llogari. Nuk do të marrësh njoftime kur të ndodhin përditësimet."</string>
    <string name="data_usage_cycle_editor_title" msgid="1373797281540188533">"Data e rivendosjes së ciklit të përdorimit"</string>
    <string name="data_usage_cycle_editor_subtitle" msgid="5512903797979928416">"Data e secilit muaj:"</string>
    <string name="data_usage_cycle_editor_positive" msgid="8821760330497941117">"Cakto"</string>
    <string name="data_usage_warning_editor_title" msgid="3704136912240060339">"Cakto paralajmërimin për përdorimin e të dhënave"</string>
    <string name="data_usage_limit_editor_title" msgid="9153595142385030015">"Cakto kufirin e përdorimit të të dhënave"</string>
    <string name="data_usage_limit_dialog_title" msgid="3023111643632996097">"Kufizimi i përdorimit të të dhënave"</string>
    <string name="data_usage_limit_dialog_mobile" product="tablet" msgid="4983487893343645667">"Tableti do të çaktivizojë të dhënat celulare sapo të arrijë kufirin që cakton ti.\n\nMeqenëse përdorimi i të dhënave matet nga tableti yt dhe operatori celular mund ta llogarisë ndryshe përdorimin, ki parasysh të vendosësh një kufi të menduar mirë."</string>
    <string name="data_usage_limit_dialog_mobile" product="default" msgid="3926320594049434225">"Telefoni yt do t\'i çaktivizojë të dhënat celulare kur të arrihet kufiri që cakton ti.\n\nMeqenëse përdorimi i të dhënave matet nga telefoni yt dhe operatori celular mund ta llogarisë ndryshe përdorimin, ki parasysh të vendosësh një kufi të menduar mirë."</string>
    <string name="data_usage_restrict_background_title" msgid="2201315502223035062">"Të kufizohen të dhënat në sfond?"</string>
    <string name="data_usage_restrict_background" msgid="434093644726734586">"Nëse kufizon të dhënat celulare në sfond, disa aplikacione dhe shërbime nuk do të funksionojnë nëse nuk je i lidhur me Wi‑Fi."</string>
    <string name="data_usage_restrict_background_multiuser" product="tablet" msgid="7096707497743363380">"Nëse kufizon të dhënat celulare në sfond, disa aplikacione dhe shërbime nuk do të funksionojnë nëse nuk je i lidhur me Wi‑Fi.\n\nKy cilësim ndikon te të gjithë përdoruesit në këtë tablet."</string>
    <string name="data_usage_restrict_background_multiuser" product="default" msgid="7910798414964288424">"Nëse kufizon të dhënat celulare në sfond, disa aplikacione dhe shërbime nuk do të funksionojnë nëse nuk je i lidhur me Wi-Fi.\n\nKy cilësim ndikon te të gjithë përdoruesit në këtë telefon."</string>
    <string name="data_usage_sweep_warning" msgid="6387081852568846982"><font size="18">"<xliff:g id="NUMBER">^1</xliff:g>"</font>" "<font size="9">"<xliff:g id="UNIT">^2</xliff:g>"</font>\n<font size="12">"paralajmërim"</font></string>
    <string name="data_usage_sweep_limit" msgid="860566507375933039">"Kufiri "<font size="18">"<xliff:g id="NUMBER">^1</xliff:g>"</font>" "<font size="9">"<xliff:g id="UNIT">^2</xliff:g>"</font>\n<font size="12"></font></string>
    <string name="data_usage_uninstalled_apps" msgid="614263770923231598">"Aplikacionet e hequra"</string>
    <string name="data_usage_uninstalled_apps_users" msgid="7986294489899813194">"Aplikacionet dhe përdoruesit e hequr"</string>
    <string name="data_usage_received_sent" msgid="5039699009276621757">"<xliff:g id="RECEIVED">%1$s</xliff:g> të marra, <xliff:g id="SENT">%2$s</xliff:g> të dërguara"</string>
    <string name="data_usage_total_during_range" msgid="4091294280619255237">"<xliff:g id="RANGE">%2$s</xliff:g>: rreth <xliff:g id="TOTAL">%1$s</xliff:g> të përdorura."</string>
    <string name="data_usage_total_during_range_mobile" product="tablet" msgid="1925687342154538972">"<xliff:g id="RANGE">%2$s</xliff:g>: rreth <xliff:g id="TOTAL">%1$s</xliff:g> të përdorura të matura nga tableti yt. Llogaritja e përdorimit të të dhënave të operatorit tënd mund të ndryshojë."</string>
    <string name="data_usage_total_during_range_mobile" product="default" msgid="5063981061103812900">"<xliff:g id="RANGE">%2$s</xliff:g>: rreth <xliff:g id="TOTAL">%1$s</xliff:g> të përdorura, siç është matur nga telefoni yt. Llogaritja e përdorimit të të dhënave nga operatori celular mund të ndryshojë."</string>
    <string name="data_usage_metered_title" msgid="7383175371006596441">"Kufizimet e rrjetit"</string>
    <string name="data_usage_metered_body" msgid="7655851702771342507">"Rrjetet me konsum të kufizuar trajtohen si rrjetet celulare kur të dhënat në sfond janë të kufizuara. Aplikacionet mund të të paralajmërojnë për shkarkime të mëdha para se t\'i përdorësh këto rrjete."</string>
    <string name="data_usage_metered_mobile" msgid="5423305619126978393">"Rrjetet celulare"</string>
    <string name="data_usage_metered_wifi" msgid="1761738002328299714">"Rrjetet Wi‑Fi me konsum të kufizuar"</string>
    <string name="data_usage_metered_wifi_disabled" msgid="727808462375941567">"Për të zgjedhur rrjetet me konsum të kufizuar, aktivizo Wi‑Fi."</string>
    <string name="data_usage_metered_auto" msgid="1262028400911918865">"Automatike"</string>
    <string name="wifi_metered_title" msgid="5536703738895222444">"Përdorimi i rrjetit"</string>
    <string name="data_usage_metered_yes" msgid="9217539611385225894">"Me matje"</string>
    <string name="data_usage_metered_no" msgid="4025232961929071789">"Pa matje"</string>
    <string name="data_usage_disclaimer" msgid="6887858149980673444">"Llogaritja e të dhënave nga operatori mund të ndryshojë nga ajo e pajisjes tënde."</string>
    <string name="cryptkeeper_emergency_call" msgid="198578731586097145">"Telefonata e urgjencës"</string>
    <string name="cryptkeeper_return_to_call" msgid="5613717339452772491">"Kthehu te telefonata"</string>
    <string name="vpn_name" msgid="4689699885361002297">"Emri"</string>
    <string name="vpn_type" msgid="5435733139514388070">"Lloji"</string>
    <string name="vpn_server" msgid="2123096727287421913">"Adresa e serverit"</string>
    <string name="vpn_mppe" msgid="6639001940500288972">"Enkriptimi PPP (MPPE)"</string>
    <string name="vpn_l2tp_secret" msgid="529359749677142076">"Sekreti L2TP"</string>
    <string name="vpn_ipsec_identifier" msgid="4098175859460006296">"Identifikuesi IPSec"</string>
    <string name="vpn_ipsec_secret" msgid="4526453255704888704">"Çelësi IPSec i parashkëmbyer"</string>
    <string name="vpn_ipsec_user_cert" msgid="6880651510020187230">"Certifikata e përdoruesit IPSec"</string>
    <string name="vpn_ipsec_ca_cert" msgid="91338213449148229">"Certifikata CA e protokollit IPSec"</string>
    <string name="vpn_ipsec_server_cert" msgid="6599276718456935010">"Certifikata e serverit IPSec"</string>
    <string name="vpn_show_options" msgid="7182688955890457003">"Shfaq opsionet e përparuara"</string>
    <string name="vpn_search_domains" msgid="5391995501541199624">"Domenet e kërkimit të DNS-së"</string>
    <string name="vpn_dns_servers" msgid="5570715561245741829">"Serverët DNS (p.sh. 8.8.8.8)"</string>
    <string name="vpn_routes" msgid="3818655448226312232">"Rrugët e transferimit (p.sh. 10.0.0.0/8)"</string>
    <string name="vpn_username" msgid="1863901629860867849">"Emri i përdoruesit"</string>
    <string name="vpn_password" msgid="6756043647233596772">"Fjalëkalimi"</string>
    <string name="vpn_save_login" msgid="6350322456427484881">"Ruaj informacionet e llogarisë"</string>
    <string name="vpn_not_used" msgid="9094191054524660891">"(nuk përdoret)"</string>
    <string name="vpn_no_ca_cert" msgid="8776029412793353361">"(mos e verifiko serverin)"</string>
    <string name="vpn_no_server_cert" msgid="2167487440231913330">"(marrë nga serveri)"</string>
    <string name="vpn_always_on_invalid_reason_type" msgid="7574518311224455825">"Ky lloj i VPN-së nuk mund të qëndrojë i lidhur gjatë gjithë kohës"</string>
    <string name="vpn_always_on_invalid_reason_server" msgid="477304620899799383">"Rrjeti VPN gjithmonë aktiv mbështet adresat numerike të serverit"</string>
    <string name="vpn_always_on_invalid_reason_no_dns" msgid="2226648961940273294">"Duhet të specifikohet një server DNS për rrjetin VPN gjthmonë aktiv"</string>
    <string name="vpn_always_on_invalid_reason_dns" msgid="3551394495620249972">"Adresat e serverit të DNS-së duhet të jenë numerike për rrjetin VPN gjithmonë aktiv"</string>
    <string name="vpn_always_on_invalid_reason_other" msgid="5959352052515258208">"Informacionet e futura nuk e mbështesin rrjetin VPN gjithmonë aktiv"</string>
    <string name="vpn_cancel" msgid="1979937976123659332">"Anulo"</string>
    <string name="vpn_done" msgid="8678655203910995914">"Injoro"</string>
    <string name="vpn_save" msgid="4233484051644764510">"Ruaj"</string>
    <string name="vpn_connect" msgid="8469608541746132301">"Lidh"</string>
    <string name="vpn_replace" msgid="5442836256121957861">"Zëvendëso"</string>
    <string name="vpn_edit" msgid="8647191407179996943">"Redakto profilin e VPN-së"</string>
    <string name="vpn_forget" msgid="3684651372749415446">"Harroje"</string>
    <string name="vpn_connect_to" msgid="5965299358485793260">"Lidhu me <xliff:g id="PROFILE">%s</xliff:g>"</string>
    <string name="vpn_disconnect_confirm" msgid="3743970132487505659">"Shkëpute këtë rrjet VPN"</string>
    <string name="vpn_disconnect" msgid="7426570492642111171">"Shkëpute"</string>
    <string name="vpn_version" msgid="1939804054179766249">"Versioni <xliff:g id="VERSION">%s</xliff:g>"</string>
    <string name="vpn_forget_long" msgid="2232239391189465752">"Harroje rrjetin VPN"</string>
    <string name="vpn_replace_vpn_title" msgid="2963898301277610248">"Të zëvendësohet rrjeti ekzistues VPN?"</string>
    <string name="vpn_set_vpn_title" msgid="4009987321156037267">"Të caktohet rrjeti VPN gjithmonë aktiv?"</string>
    <string name="vpn_first_always_on_vpn_message" msgid="7144543717673197102">"Kur ky cilësim është aktiv, nuk do të kesh një lidhje interneti deri sa rrjeti VPN të lidhet me sukses"</string>
    <string name="vpn_replace_always_on_vpn_enable_message" msgid="798121133114824006">"Rrjeti yt ekzistues VPN do të zëvendësohet dhe nuk do të kesh një lidhje interneti deri sa rrjeti VPN të lidhet me sukses"</string>
    <string name="vpn_replace_always_on_vpn_disable_message" msgid="3011818750025879902">"Je tashmë i lidhur me një rrjet VPN gjithmonë aktiv. Nëse je lidhur me një tjetër, rrjeti yt ekzistues VPN do të zëvendësohet dhe modaliteti gjithmonë aktiv do të çaktivizohet."</string>
    <string name="vpn_replace_vpn_message" msgid="5611635724578812860">"Je tashmë i lidhur me një rrjet VPN. Nëse je lidhur me një tjetër, rrjeti yt ekzistues VPN do të zëvendësohet."</string>
    <string name="vpn_turn_on" msgid="2363136869284273872">"Aktivizo"</string>
    <string name="vpn_cant_connect_title" msgid="4517706987875907511">"<xliff:g id="VPN_NAME">%1$s</xliff:g> nuk mund të lidhet"</string>
    <string name="vpn_cant_connect_message" msgid="1352832123114214283">"Ky aplikacion nuk e mbështet rrjetin VPN gjithmonë aktiv"</string>
    <string name="vpn_title" msgid="6317731879966640551">"VPN"</string>
    <string name="vpn_create" msgid="5628219087569761496">"Shto profil VPN-je"</string>
    <string name="vpn_menu_edit" msgid="408275284159243490">"Modifiko profilin"</string>
    <string name="vpn_menu_delete" msgid="8098021690546891414">"Fshi profilin"</string>
    <string name="vpn_menu_lockdown" msgid="7863024538064268139">"Rrjeti VPN gjithmonë aktiv"</string>
    <string name="vpn_no_vpns_added" msgid="5002741367858707244">"Nuk u shtua asnjë rrjet VPN"</string>
    <string name="vpn_always_on_summary" msgid="2821344524094363617">"Qëndro i lidhur me rrjetin VPN gjatë të gjithë kohës"</string>
    <string name="vpn_always_on_summary_not_supported" msgid="592304911378771510">"Nuk mbështetet nga ky aplikacion"</string>
    <string name="vpn_always_on_summary_active" msgid="8800736191241875669">"Gjithnjë aktiv është aktiv"</string>
    <string name="vpn_require_connection" msgid="8388183166574269666">"Blloko lidhjet pa rrjetin VPN"</string>
    <string name="vpn_require_connection_title" msgid="159053539340576331">"Të kërkohet lidhja e VPN-së?"</string>
    <string name="vpn_lockdown_summary" msgid="2200032066376720339">"Zgjidh një profil VPN-je për të qëndruar gjithmonë i lidhur. Trafiku i rrjetit do të lejohet vetëm kur të lidhet me këtë VPN."</string>
    <string name="vpn_lockdown_none" msgid="9214462857336483711">"Asnjë"</string>
    <string name="vpn_lockdown_config_error" msgid="3898576754914217248">"VPN-ja gjithnjë e aktivizuar kërkon një adresë IP-je për serverin dhe DNS-në."</string>
    <string name="vpn_no_network" msgid="3050233675132726155">"Nuk ka lidhje rrjeti. Provo sërish më vonë."</string>
    <string name="vpn_disconnected" msgid="280531508768927471">"Shkëputur nga VPN"</string>
    <string name="vpn_disconnected_summary" msgid="3082851661207900606">"Asnjë"</string>
    <string name="vpn_missing_cert" msgid="5357192202207234745">"Mungon një certifikatë. Provo të redaktosh profilin."</string>
    <string name="trusted_credentials_system_tab" msgid="3984284264816924534">"Sistemi"</string>
    <string name="trusted_credentials_user_tab" msgid="2244732111398939475">"Përdoruesi"</string>
    <string name="trusted_credentials_disable_label" msgid="3864493185845818506">"Çaktivizo"</string>
    <string name="trusted_credentials_enable_label" msgid="2498444573635146913">"Aktivizo"</string>
    <string name="trusted_credentials_remove_label" msgid="3633691709300260836">"Hiq"</string>
    <string name="trusted_credentials_trust_label" msgid="8003264222650785429">"Beso"</string>
    <string name="trusted_credentials_enable_confirmation" msgid="83215982842660869">"Të aktivizohet certifikata CA e sistemit?"</string>
    <string name="trusted_credentials_disable_confirmation" msgid="8199697813361646792">"Të çaktivizohet certifikata CA e sistemit?"</string>
    <string name="trusted_credentials_remove_confirmation" msgid="443561923016852941">"Të hiqet përgjithmonë certifikata CA e përdoruesit?"</string>
    <string name="credential_contains" msgid="3984922924723974084">"Ky regjistrim përmban:"</string>
    <string name="one_userkey" msgid="6034020579534914349">"çelës për një përdorues"</string>
    <string name="one_usercrt" msgid="2150319011101639509">"certifikatë për një përdorues"</string>
    <string name="one_cacrt" msgid="6844397037970164809">"një certifikatë CA"</string>
    <string name="n_cacrts" msgid="5979300323482053820">"%d certifikata CA"</string>
    <string name="user_credential_title" msgid="1954061209643070652">"Detajet e kredencialeve"</string>
    <string name="user_credential_removed" msgid="6514189495799401838">"Kredenciali i hequr: <xliff:g id="CREDENTIAL_NAME">%s</xliff:g>"</string>
    <string name="user_credential_none_installed" msgid="3729607560420971841">"Nuk ka kredenciale të përdoruesit të instaluara"</string>
    <string name="spellcheckers_settings_title" msgid="399981228588011501">"Kontrolluesi drejtshkrimor"</string>
    <string name="spellcheckers_settings_for_work_title" msgid="4114555511355171248">"Kontrolluesi drejtshkrimor për punë"</string>
    <string name="current_backup_pw_prompt" msgid="7735254412051914576">"Shkruaj fjalëkalimin aktual për rezervimin e plotë"</string>
    <string name="new_backup_pw_prompt" msgid="8755501377391998428">"Shkruaj fjalëkalimin e ri për rezervimin e plotë"</string>
    <string name="confirm_new_backup_pw_prompt" msgid="3238728882512787864">"Rishkruaj fjalëkalimin e ri për rezervimin e plotë"</string>
    <string name="backup_pw_set_button_text" msgid="2387480910044648795">"Vendos fjalëkalimin"</string>
    <string name="backup_pw_cancel_button_text" msgid="8845630125391744615">"Anulo"</string>
    <string name="additional_system_update_settings_list_item_title" msgid="214987609894661992">"Përditësime të sistemit"</string>
    <string name="ssl_ca_cert_warning" msgid="2045866713601984673">"Rrjeti mund të jetë i monitoruar"</string>
    <string name="done_button" msgid="1991471253042622230">"U krye!"</string>
    <plurals name="ssl_ca_cert_dialog_title" formatted="false" msgid="7145092748045794650">
      <item quantity="other">Besoji ose hiqi certifikatat</item>
      <item quantity="one">Besoje ose hiqe certifikatën</item>
    </plurals>
    <plurals name="ssl_ca_cert_info_message_device_owner" formatted="false" msgid="1489335297837656666">
      <item quantity="other"><xliff:g id="MANAGING_DOMAIN_1">%s</xliff:g> ka instaluar autoritete certifikatash në pajisjen tënde, të cilat mund ta lejojë atë të monitorojë aktivitetin e rrjetit të pajisjes, duke përfshirë mail-et, aplikacionet dhe sajtet e sigurta të uebit..\n\nPër më shumë informacione rreth këtyre certifikatave, kontakto me administratorin.</item>
      <item quantity="one"><xliff:g id="MANAGING_DOMAIN_0">%s</xliff:g> ka instaluar një autoritet certifikate në pajisjen tënde, i cili mund ta lejojë atë të monitorojë aktivitetin e rrjetit të pajisjes, duke përfshirë mail-et, aplikacionet dhe sajtet e sigurta të uebit.\n\nPër më shumë informacione rreth kësaj certifikate, kontakto me administratorin.</item>
    </plurals>
    <plurals name="ssl_ca_cert_info_message" formatted="false" msgid="30645643499556573">
      <item quantity="other"><xliff:g id="MANAGING_DOMAIN_1">%s</xliff:g> ka instaluar autoritete certifikate për profilin tënd të punës që mund ta lejojë atë të monitorojë aktivitetin tënd të rrjetit të punës, duke përfshirë mail-et, aplikacionet dhe sajtet e sigurta të uebit.\n\nPër më shumë informacione rreth këtyre certifikatave, kontakto me administratorin.</item>
      <item quantity="one"><xliff:g id="MANAGING_DOMAIN_0">%s</xliff:g> ka instaluar një autoritet certifikate për profilin tënd të punës që mund ta lejojë atë të monitorojë aktivitetin tënd të rrjetit të punës, duke përfshirë mail-et, aplikacionet dhe sajtet e sigurta të uebit.\n\nPër më shumë informacione rreth kësaj certifikate, kontakto me administratorin.</item>
    </plurals>
    <string name="ssl_ca_cert_warning_message" msgid="8216218659139190498">"Një palë e tretë është në gjendje të monitorojë aktivitetin e rrjetit, përfshirë mail-in, aplikacionet dhe faqet e sigurta të internetit.\n\nKëtë po e bën këtë të mundur një kredencial i besuar i instaluar në pajisjen tënde."</string>
    <plurals name="ssl_ca_cert_settings_button" formatted="false" msgid="2426799352517325228">
      <item quantity="other">Kontrollo certifikatat</item>
      <item quantity="one">Kontrollo certifikatën</item>
    </plurals>
    <string name="user_settings_title" msgid="3493908927709169019">"Disa përdorues"</string>
    <string name="user_settings_footer_text" product="device" msgid="5947601460660791129">"Ndaje pajisjen tënde duke shtuar përdorues të rinj. Secili përdorues ka një hapësirë personale në pajisje për ekrane bazë të personalizuara, llogari, aplikacione, cilësime etj."</string>
    <string name="user_settings_footer_text" product="tablet" msgid="2153761434649733502">"Ndaje tabletin tënd duke shtuar përdorues të rinj. Secili përdorues ka një hapësirë personale në tablet për ekrane bazë të personalizuara, llogari, aplikacione, cilësime etj."</string>
    <string name="user_settings_footer_text" product="default" msgid="2844602828189838075">"Ndaje telefonin tënd duke shtuar përdorues të rinj. Secili përdorues ka një hapësirë personale në telefon për ekrane bazë të personalizuara, llogari, aplikacione, cilësime etj."</string>
    <string name="user_list_title" msgid="7937158411137563543">"Përdoruesit dhe profilet"</string>
    <string name="user_add_user_or_profile_menu" msgid="6923838875175259418">"Shto një përdorues ose një profil"</string>
    <string name="user_add_user_menu" msgid="1675956975014862382">"Shto përdorues"</string>
    <string name="user_summary_restricted_profile" msgid="6354966213806839107">"Profil i kufizuar"</string>
    <string name="user_need_lock_message" msgid="5879715064416886811">"Para se të mund të krijosh një profil të kufizuar, duhet të konfigurosh një kyçje të ekranit për të mbrojtur aplikacionet dhe të dhënat e tua personale."</string>
    <string name="user_set_lock_button" msgid="8311219392856626841">"Cakto kyçjen"</string>
    <string name="user_summary_not_set_up" msgid="8778205026866794909">"Nuk është konfiguruar"</string>
    <string name="user_summary_restricted_not_set_up" msgid="1628116001964325544">"E pakonfiguruar - Profil i kufizuar"</string>
    <string name="user_summary_managed_profile_not_set_up" msgid="1659125858619760573">"Nuk është konfiguruar - profili i punës"</string>
    <string name="user_admin" msgid="993402590002400782">"Administrator"</string>
    <string name="user_you" msgid="1639158809315025986">"Ti (<xliff:g id="NAME">%s</xliff:g>)"</string>
    <string name="user_nickname" msgid="5148818000228994488">"Pseudonimi"</string>
    <string name="user_add_user_type_title" msgid="2146438670792322349">"Shto"</string>
    <string name="user_add_max_count" msgid="5405885348463433157">"Mund të shtosh deri në <xliff:g id="USER_COUNT">%1$d</xliff:g> përdorues"</string>
    <string name="user_add_user_item_summary" msgid="4702776187132008661">"Përdoruesit kanë aplikacionet dhe përmbajtjet e tyre"</string>
    <string name="user_add_profile_item_summary" msgid="5931663986889138941">"Mund të kufizosh qasjen në aplikacione dhe përmbajtje nga llogaria jote"</string>
    <string name="user_add_user_item_title" msgid="8212199632466198969">"Përdoruesi"</string>
    <string name="user_add_profile_item_title" msgid="8353515490730363621">"Profil i kufizuar"</string>
    <string name="user_add_user_title" msgid="2108112641783146007">"Të shtohet përdorues i ri?"</string>
    <string name="user_add_user_message_long" msgid="6768718238082929201">"Mund ta ndash këtë pajisje me persona të tjerë duke krijuar përdorues shtesë. Çdo përdorues ka hapësirën e vet, të cilën mund ta personalizojë me aplikacione, me imazhin e sfondit etj. Përdoruesit mund të rregullojnë po ashtu cilësimet e pajisjes, si Wi‑Fi, të cilat ndikojnë te të gjithë.\n\nKur shton një përdorues të ri, ai person duhet të konfigurojë hapësirën e vet.\n\nÇdo përdorues mund t\'i përditësojë aplikacionet për të gjithë përdoruesit e tjerë. Cilësimet e qasshmërisë dhe shërbimet mund të mos transferohen te përdoruesi i ri."</string>
    <string name="user_add_user_message_short" msgid="1511354412249044381">"Kur shton një përdorues të ri, ai person duhet të konfigurojë hapësirën e vet.\n\nÇdo përdorues mund t\'i përditësojë aplikacionet për të gjithë përdoruesit e tjerë."</string>
    <string name="user_setup_dialog_title" msgid="1765794166801864563">"Të konfig. përdoruesi tani?"</string>
    <string name="user_setup_dialog_message" msgid="1004068621380867148">"Sigurohu që personi të jetë i gatshëm të marrë pajisjen dhe të caktojë hapësirën e vet"</string>
    <string name="user_setup_profile_dialog_message" msgid="3896568553327558731">"Të konfigurohet tani profili?"</string>
    <string name="user_setup_button_setup_now" msgid="3391388430158437629">"Konfiguro tani"</string>
    <string name="user_setup_button_setup_later" msgid="3068729597269172401">"Jo tani"</string>
    <string name="user_cannot_manage_message" product="tablet" msgid="7153048188252553320">"Vetëm zotëruesi i tabletit mund t\'i menaxhojë përdoruesit."</string>
    <string name="user_cannot_manage_message" product="default" msgid="959315813089950649">"Vetëm zotëruesi i telefonit mund t\'i menaxhojë përdoruesit."</string>
    <string name="user_cannot_add_accounts_message" msgid="5116692653439737050">"Profilet e kufizuar nuk mund të shtojnë llogari"</string>
    <string name="user_remove_user_menu" msgid="6897150520686691355">"Fshije <xliff:g id="USER_NAME">%1$s</xliff:g> nga pajisja"</string>
    <string name="user_lockscreen_settings" msgid="4965661345247084878">"Cilësimet e ekranit të kyçjes"</string>
    <string name="user_add_on_lockscreen_menu" msgid="9072312646546364619">"Shto përdoruesit nga ekrani i kyçjes"</string>
    <string name="user_new_user_name" msgid="369856859816028856">"Përdorues i ri"</string>
    <string name="user_new_profile_name" msgid="2632088404952119900">"Profili i ri"</string>
    <string name="user_confirm_remove_self_title" msgid="8432050170899479556">"Do e fshish veten?"</string>
    <string name="user_confirm_remove_title" msgid="8068422695175097315">"Të fshihet ky përdorues?"</string>
    <string name="user_profile_confirm_remove_title" msgid="5573161550669867342">"Të hiqet ky profil?"</string>
    <string name="work_profile_confirm_remove_title" msgid="2017323555783522213">"Të hiqet profili i punës?"</string>
    <string name="user_confirm_remove_self_message" product="tablet" msgid="2391372805233812410">"Do të humbësh hapësirën tënde dhe të dhënat në këtë tablet. Nuk mund ta zhbësh këtë veprim."</string>
    <string name="user_confirm_remove_self_message" product="default" msgid="7943645442479360048">"Do të humbësh hapësirën tënde dhe të dhënat në këtë telefon. Nuk mund ta zhbësh këtë veprim!"</string>
    <string name="user_confirm_remove_message" msgid="1020629390993095037">"Të gjitha aplikacionet dhe të dhënat do të fshihen."</string>
    <string name="work_profile_confirm_remove_message" msgid="323856589749078140">"Të gjitha aplikacionet dhe të dhënat në këtë profil do të fshihen nëse vazhdon."</string>
    <string name="user_profile_confirm_remove_message" msgid="7373754145959298522">"Të gjitha aplikacionet dhe të dhënat do të fshihen."</string>
    <string name="user_adding_new_user" msgid="1521674650874241407">"Po shton përdorues të ri..."</string>
    <string name="user_delete_user_description" msgid="3158592592118767056">"Fshi përdoruesin"</string>
    <string name="user_delete_button" msgid="5131259553799403201">"Fshi"</string>
    <string name="user_guest" msgid="8475274842845401871">"I ftuar"</string>
    <string name="user_exit_guest_title" msgid="5613997155527410675">"Hiq të ftuarin"</string>
    <string name="user_exit_guest_confirm_title" msgid="3405527634738147409">"Të hiqet i ftuari?"</string>
    <string name="user_exit_guest_confirm_message" msgid="2194459201944413257">"Të gjitha aplikacionet dhe të dhënat në këtë sesion do të fshihen."</string>
    <string name="user_exit_guest_dialog_remove" msgid="6351370829952745350">"Hiq!"</string>
    <string name="user_enable_calling" msgid="5128605672081602348">"Aktivizo telefonatat"</string>
    <string name="user_enable_calling_sms" msgid="9172507088023097063">"Aktivizo telefonatat dhe SMS-të"</string>
    <string name="user_remove_user" msgid="3612979309028881318">"Fshi përdoruesin"</string>
    <string name="user_enable_calling_confirm_title" msgid="4315789475268695378">"Të aktivizohen telefonatat?"</string>
    <string name="user_enable_calling_confirm_message" msgid="8061594235219352787">"Historiku i telefonatave do të ndahet me këtë përdorues."</string>
    <string name="user_enable_calling_and_sms_confirm_title" msgid="7243308401401932681">"Të aktivizohen telefonatat dhe SMS-të?"</string>
    <string name="user_enable_calling_and_sms_confirm_message" msgid="4025082715546544967">"Historiku i telefonatave dhe SMS-ve do të ndahet me këtë përdorues."</string>
    <string name="emergency_info_title" msgid="208607506217060337">"Informacioni i urgjencës"</string>
    <string name="emergency_info_summary" msgid="5062945162967838521">"Informacionet dhe kontaktet për <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="application_restrictions" msgid="8207332020898004394">"Lejo aplikacionet dhe përmbajtjen"</string>
    <string name="apps_with_restrictions_header" msgid="3660449891478534440">"Aplikacionet me kufizime"</string>
    <string name="apps_with_restrictions_settings_button" msgid="3841347287916635821">"Zgjeroji cilësimet për aplikacionin"</string>
    <string name="nfc_payment_settings_title" msgid="1807298287380821613">"Trokit dhe paguaj"</string>
    <string name="nfc_payment_how_it_works" msgid="3028822263837896720">"Si funksionon"</string>
    <string name="nfc_payment_no_apps" msgid="5477904979148086424">"Paguaj me telefonin tënd në dyqane"</string>
    <string name="nfc_payment_default" msgid="8648420259219150395">"Aplikacioni i parazgjedhur për pagesat"</string>
    <string name="nfc_payment_default_not_set" msgid="7485060884228447765">"Nuk është caktuar"</string>
    <string name="nfc_payment_app_and_desc" msgid="7942415346564794258">"<xliff:g id="APP">%1$s</xliff:g> - <xliff:g id="DESCRIPTION">%2$s</xliff:g>"</string>
    <string name="nfc_payment_use_default" msgid="3234730182120288495">"Përdor opsionin e parazgjedhur"</string>
    <string name="nfc_payment_favor_default" msgid="5743781166099608372">"Gjithmonë!"</string>
    <string name="nfc_payment_favor_open" msgid="1923314062109977944">"Përveçse kur është i hapur një aplikacion tjetër pagese"</string>
    <string name="nfc_payment_pay_with" msgid="7524904024378144072">"Në terminalin \"Prek dhe paguaj\", paguaj me:"</string>
    <string name="nfc_how_it_works_title" msgid="1984068457698797207">"Pagesa në terminal"</string>
    <string name="nfc_how_it_works_content" msgid="4749007806393224934">"Konfiguro një aplikacion pagese. Më pas thjesht mbaj shtypur pjesën e pasme të telefonit me një terminal me simbolin e pagesave pa kontakt."</string>
    <string name="nfc_how_it_works_got_it" msgid="259653300203217402">"E kuptova"</string>
    <string name="nfc_more_title" msgid="815910943655133280">"Më shumë..."</string>
    <string name="nfc_payment_set_default_label" msgid="7315817259485674542">"Të caktohet si preferencë?"</string>
    <string name="nfc_payment_set_default" msgid="8532426406310833489">"Të përdoret gjithmonë <xliff:g id="APP">%1$s</xliff:g> për \"Prek dhe paguaj\"?"</string>
    <string name="nfc_payment_set_default_instead_of" msgid="6993301165940432743">"Të përdoret gjithmonë <xliff:g id="APP_0">%1$s</xliff:g> në vend të <xliff:g id="APP_1">%2$s</xliff:g> për \"Prek dhe paguaj\"?"</string>
    <string name="restriction_settings_title" msgid="4233515503765879736">"Kufizimet"</string>
    <string name="restriction_menu_reset" msgid="2067644523489568173">"Hiq kufizimet"</string>
    <string name="restriction_menu_change_pin" msgid="740081584044302775">"Ndrysho kodin PIN"</string>
    <string name="app_notifications_switch_label" msgid="9124072219553687583">"Shfaq njoftimet"</string>
    <string name="help_label" msgid="6886837949306318591">"Ndihmë dhe komente"</string>
    <string name="support_summary" msgid="2705726826263742491">"Artikuj ndihme, telefoni dhe biseda, fillimi"</string>
    <string name="user_account_title" msgid="1127193807312271167">"Llogaria për përmbajtjen"</string>
    <string name="user_picture_title" msgid="7297782792000291692">"ID-ja e fotos"</string>
    <string name="extreme_threats_title" msgid="6549541803542968699">"Kërcënimet ekstreme"</string>
    <string name="extreme_threats_summary" msgid="8777860706500920667">"Merr sinjalizime për kërcënime ekstreme mbi jetën dhe pronën"</string>
    <string name="severe_threats_title" msgid="8362676353803170963">"Kërcënime serioze"</string>
    <string name="severe_threats_summary" msgid="8848126509420177320">"Merr alarme për kërcënime serioze kundër jetës dhe pronës"</string>
    <string name="amber_alerts_title" msgid="2772220337031146529">"Sinjalizimet AMBER"</string>
    <string name="amber_alerts_summary" msgid="4312984614037904489">"Merr buletine rreth rrëmbimeve të fëmijëve"</string>
    <string name="repeat_title" msgid="6473587828597786996">"Përsërit"</string>
    <string name="call_manager_enable_title" msgid="7718226115535784017">"Aktivizo \"Menaxherin e telefonatave\""</string>
    <string name="call_manager_enable_summary" msgid="8458447798019519240">"Lejo këtë shërbim të menaxhojë si kryhen telefonatat."</string>
    <string name="call_manager_title" msgid="4479949569744516457">"Menaxheri i telefonatave"</string>
    <!-- no translation found for call_manager_summary (5918261959486952674) -->
    <skip />
    <string name="cell_broadcast_settings" msgid="4124461751977706019">"Sinjalizimet e urgjencës"</string>
    <string name="network_operators_settings" msgid="2583178259504630435">"Operatorët e rrjetit"</string>
    <string name="access_point_names" msgid="1381602020438634481">"Emrat e pikës së qasjes"</string>
    <string name="enhanced_4g_lte_mode_title" msgid="2544026384901010606">"VoLTE"</string>
    <string name="enhanced_4g_lte_mode_title_advanced_calling" msgid="480304128966864221">"Telefonatë e përparuar"</string>
    <string name="enhanced_4g_lte_mode_title_4g_calling" msgid="6839553611093179243">"Telefonatat me 4G"</string>
    <string name="enhanced_4g_lte_mode_summary" msgid="4156658595226379286">"Përdor shërbimet LTE për të përmirësuar komunikimet zanore dhe të tjera (rekomandohet)"</string>
    <string name="enhanced_4g_lte_mode_summary_4g_calling" msgid="6145184730437907078">"Përdor shërbimet 4G për të përmirësuar komunikimet zanore dhe të tjera (rekomandohet)"</string>
    <string name="preferred_network_type_title" msgid="3431041717309776341">"Lloji i preferuar i rrjetit"</string>
    <string name="preferred_network_type_summary" msgid="6564884693884755019">"LTE (rekomandohet)"</string>
    <string name="mms_message_title" msgid="6068098013612041440">"Mesazhet MMS"</string>
    <string name="mms_message_summary" msgid="8408985719331988420">"Dërgo dhe merr kur të dhënat celulare janë joaktive"</string>
    <string name="data_during_calls_title" msgid="4476240693784306761">"Të dhënat gjatë telefonatave"</string>
    <string name="data_during_calls_summary" msgid="497978580819604521">"Lejo që kjo kartë SIM të përdoret për të dhënat celulare vetëm gjatë telefonatave"</string>
    <string name="work_sim_title" msgid="4843322164662606891">"Karta SIM e punës"</string>
    <string name="user_restrictions_title" msgid="5794473784343434273">"Qasja tek aplikacioni e përmbajtja"</string>
    <string name="user_rename" msgid="8523499513614655279">"Riemërto"</string>
    <string name="app_restrictions_custom_label" msgid="6160672982086584261">"Cakto kufizimet e aplikacionit"</string>
    <string name="user_restrictions_controlled_by" msgid="3164078767438313899">"Kontrollohet nga <xliff:g id="APP">%1$s</xliff:g>"</string>
    <string name="app_sees_restricted_accounts" msgid="7503264525057246240">"Ky aplikacion mund të ketë qasje në llogaritë e tua"</string>
    <string name="app_sees_restricted_accounts_and_controlled_by" msgid="6968697624437267294">"Ky aplikacion mund të qaset te llogaritë e tua. Kontrollohet nga <xliff:g id="APP">%1$s</xliff:g>"</string>
    <string name="restriction_wifi_config_title" msgid="8889556384136994814">"Wi‑Fi dhe rrjeti celular"</string>
    <string name="restriction_wifi_config_summary" msgid="70888791513065244">"Lejo modifikimin e cilësimeve Wi-Fi dhe atyre celulare"</string>
    <string name="restriction_bluetooth_config_title" msgid="8871681580962503671">"Bluetooth-i"</string>
    <string name="restriction_bluetooth_config_summary" msgid="8372319681287562506">"Lejo modifikimin e çiftimeve të \"Bluetooth-it\" dhe cilësimet"</string>
    <string name="restriction_nfc_enable_title" msgid="5888100955212267941">"NFC"</string>
    <string name="restriction_nfc_enable_summary_config" msgid="3232480757215851738">"Lejo shkëmbimin e të dhënave kur pajisja <xliff:g id="DEVICE_NAME">%1$s</xliff:g> prek një tjetër pajisje NFC"</string>
    <string name="restriction_nfc_enable_summary" product="tablet" msgid="3891097373396149915">"Lejo shkëmbimin e të dhënave kur tableti prek një tjetër pajisje"</string>
    <string name="restriction_nfc_enable_summary" product="default" msgid="825331120501418592">"Lejo shkëmbimin e të dhënave kur telefoni prek një tjetër pajisje"</string>
    <string name="restriction_location_enable_title" msgid="5020268888245775164">"Vendndodhja"</string>
    <string name="restriction_location_enable_summary" msgid="3489765572281788755">"Lejo aplikacionet të përdorin informacionin e vendndodhjes tënde"</string>
    <string name="wizard_back" msgid="5567007959434765743">"Prapa"</string>
    <string name="wizard_next" msgid="3606212602795100640">"Përpara"</string>
    <string name="wizard_finish" msgid="3286109692700083252">"Përfundo"</string>
    <string name="user_image_take_photo" msgid="4038201220173969126">"Bëj një fotografi"</string>
    <string name="user_image_choose_photo" msgid="7643300431215339631">"Zgjidh një imazh"</string>
    <string name="user_image_photo_selector" msgid="5492565707299454873">"Zgjidh një fotografi"</string>
    <string name="regulatory_info_text" msgid="5623087902354026557"></string>
    <string name="sim_setup_wizard_title" msgid="1732682852692274928">"Kartat SIM"</string>
    <string name="sim_settings_title" msgid="6822745211458959756">"Kartat SIM"</string>
    <string name="sim_settings_summary" msgid="4050372057097516088">"<xliff:g id="SIM_NAME">%1$s</xliff:g> - <xliff:g id="SIM_NUMBER">%2$s</xliff:g>"</string>
    <string name="sim_cards_changed_message" msgid="7900721153345139783">"Kartat SIM kanë ndryshuar"</string>
    <string name="sim_cards_changed_message_summary" msgid="8258058274989383204">"Trokit për të caktuar aktivitetet"</string>
    <string name="sim_cellular_data_unavailable" msgid="9109302537004566098">"Të dhënat celulare nuk ofrohen"</string>
    <string name="sim_cellular_data_unavailable_summary" msgid="5416535001368135327">"Trokit për të zgjedhur një kartë SIM për të dhëna"</string>
    <string name="sim_calls_always_use" msgid="7936774751250119715">"Përdor gjithmonë këtë për telefonatat"</string>
    <string name="select_sim_for_data" msgid="2366081042162853044">"Përzgjidh një kartë SIM për të dhënat"</string>
    <string name="select_sim_for_sms" msgid="6232060107120265044">"Zgjidh një kartë SIM për mesazhet SMS"</string>
    <string name="data_switch_started" msgid="2040761479817166311">"Po ndërron SIM-in e të dhënave. Kjo mund të zgjasë deri në një minutë..."</string>
    <string name="select_sim_for_calls" msgid="3503094771801109334">"Telefono me"</string>
    <string name="sim_select_card" msgid="211285163525563293">"Zgjidh një kartë SIM"</string>
    <string name="sim_card_number_title" msgid="7845379943474336488">"SIM <xliff:g id="CARD_NUMBER">%1$d</xliff:g>"</string>
    <string name="sim_slot_empty" msgid="8964505511911854688">"Karta SIM është bosh"</string>
    <string name="sim_editor_name" msgid="1722945976676142029">"Emri i kartës SIM"</string>
    <string name="sim_name_hint" msgid="7038643345238968930">"Fut emrin e kartës SIM"</string>
    <string name="sim_editor_title" msgid="4034301817366627870">"Foleja e kartës SIM %1$d"</string>
    <string name="sim_editor_carrier" msgid="5684523444677746573">"Operatori celular"</string>
    <string name="sim_editor_number" msgid="6705955651035440667">"Numri"</string>
    <string name="sim_editor_color" msgid="2542605938562414355">"Ngjyra e kartës SIM"</string>
    <string name="sim_card_select_title" msgid="6668492557519243456">"Zgjidh kartën SIM"</string>
    <string name="color_orange" msgid="4417567658855022517">"portokalli"</string>
    <string name="color_purple" msgid="3888532466427762504">"Vjollcë"</string>
    <string name="sim_no_inserted_msg" msgid="210316755353227087">"Nuk janë futur karta SIM"</string>
    <string name="sim_status_title" msgid="6744870675182447160">"Statusi i kartës SIM"</string>
    <string name="sim_status_title_sim_slot" msgid="5725659316463979194">"Statusi i kartës SIM (foleja %1$d e SIM)"</string>
    <string name="sim_call_back_title" msgid="5181549885999280334">"Telefono mbrapsht nga karta SIM e parazgjedhur"</string>
    <string name="sim_outgoing_call_title" msgid="1019763076116874255">"Karta SIM për telefonatat dalëse"</string>
    <string name="sim_other_call_settings" msgid="8247802316114482477">"Cilësime të tjera të telefonatës"</string>
    <string name="preferred_network_offload_title" msgid="1605829724169550275">"Shkarkimi në rrjetin e preferuar"</string>
    <string name="preferred_network_offload_header" msgid="2321173571529106767">"Çaktivizo transmetimin e emrit të rrjetit"</string>
    <string name="preferred_network_offload_footer" msgid="5857279426054744020">"Çaktivizimi i \"Transferimit të emrit të rrjetit\" mbron që të tjerë të mos qasen në informacionin e rrjetit."</string>
    <string name="preferred_network_offload_popup" msgid="2252915199889604600">"Çaktivizimi i transmetimit të emrit të rrjetit do të parandalojë lidhjen automatike me rrjetet e fshehura."</string>
    <string name="sim_signal_strength" msgid="9144010043784767984">"<xliff:g id="DBM">%1$d</xliff:g> dBm <xliff:g id="ASU">%2$d</xliff:g> asu"</string>
    <string name="sim_notification_title" msgid="6272913297433198340">"Kartat SIM kanë ndryshuar."</string>
    <string name="sim_notification_summary" msgid="8858043655706669772">"Trokit për ta konfiguruar"</string>
    <string name="sim_pref_divider" msgid="6778907671867621874">"Karta SIM e preferuar për"</string>
    <string name="sim_calls_ask_first_prefs_title" msgid="7941299533514115976">"Pyet çdo herë"</string>
    <string name="sim_selection_required_pref" msgid="3446721423206414652">"Kërkohet përzgjedhja"</string>
    <string name="sim_selection_channel_title" msgid="2760909074892782589">"Zgjedhja e kartës SIM"</string>
    <string name="dashboard_title" msgid="5453710313046681820">"Cilësimet"</string>
    <plurals name="settings_suggestion_header_summary_hidden_items" formatted="false" msgid="5597356221942118048">
      <item quantity="other">Shfaq %d artikuj të fshehur</item>
      <item quantity="one">Shfaq %d artikull të fshehur</item>
    </plurals>
    <string name="network_dashboard_title" msgid="3135144174846753758">"Rrjeti dhe interneti"</string>
    <string name="network_dashboard_summary_mobile" msgid="3851083934739500429">"celular"</string>
    <string name="network_dashboard_summary_data_usage" msgid="3843261364705042212">"përdorimi i të dhënave"</string>
    <string name="network_dashboard_summary_hotspot" msgid="8494210248613254574">"zona e qasjes për internet"</string>
    <string name="connected_devices_dashboard_title" msgid="2355264951438890709">"Pajisje të lidhura"</string>
    <string name="connected_devices_dashboard_summary" msgid="2665221896894251402">"Bluetooth, modaliteti \"me makinë\", NFC"</string>
    <string name="connected_devices_dashboard_no_nfc_summary" msgid="3840842725283655533">"Bluetooth, modaliteti \"me makinë\""</string>
    <string name="connected_devices_dashboard_no_driving_mode_summary" msgid="5018708106066758867">"Bluetooth, NFC"</string>
    <string name="connected_devices_dashboard_no_driving_mode_no_nfc_summary" msgid="5250078362483148199">"Bluetooth"</string>
    <string name="app_and_notification_dashboard_title" msgid="7838365599185397539">"Apl. dhe njoftimet"</string>
    <string name="app_and_notification_dashboard_summary" msgid="3285151907659820564">"Aplikacionet së fundi, aplikacionet e parazgjedhura"</string>
    <string name="notification_settings_work_profile" msgid="3186757479243373003">"Qasja te njoftimet nuk ofrohet për aplikacionet në profilin e punës."</string>
    <string name="account_dashboard_title" msgid="5895948991491438911">"Llogaritë"</string>
    <string name="account_dashboard_default_summary" msgid="3998347400161811075">"Nuk u shtua asnjë llogari"</string>
    <string name="app_default_dashboard_title" msgid="7342549305933047317">"Apl. e parazgjedhura"</string>
    <string name="system_dashboard_summary" msgid="6839969589170062254">"Gjuhët, gjestet, koha, rezervimi"</string>
    <string name="search_results_title" msgid="1796252422574886932">"Cilësimet"</string>
    <string name="keywords_wifi" msgid="3646884600964177062">"wifi, wi-fi, lidhja e rrjetit, internet, pa tel, të dhëna, wi fi"</string>
    <string name="keywords_wifi_notify_open_networks" msgid="8745178424405564885">"Njoftimi i Wi‑Fi, njoftimi i wifi"</string>
    <string name="keywords_vibrate_on_touch" msgid="1494239633254176598">"Ndalo dridhjet, trokit, tastiera"</string>
    <string name="keywords_time_format" msgid="5581515674151927461">"Përdor formatin 24-orësh"</string>
    <string name="keywords_storage_files" msgid="7075933058850826819">"Shkarko"</string>
    <string name="keywords_app_default" msgid="5822717006354487071">"Hap me"</string>
    <string name="keywords_applications_settings" msgid="1268353611121497450">"Aplikacionet"</string>
    <string name="keywords_time_zone" msgid="998254736898753085">"brezi orar"</string>
    <string name="keywords_draw_overlay" msgid="4130899177619041842">"Koka e bisedës"</string>
    <string name="keywords_flashlight" msgid="6161632177705233710">"Elektriku, drita, feneri"</string>
    <string name="keywords_change_wifi_state" msgid="627068244033681010">"wifi, wi-fi, ndrysho, kontrolli"</string>
    <string name="keywords_more_mobile_networks" msgid="8995946622054642367">"celular, celular, operator celular, pa tel, të dhëna, 4g, 3g, 2g, lte"</string>
    <string name="keywords_wifi_calling" msgid="1784064367330122679">"wifi, wi-fi, telefonatë, telefono"</string>
    <string name="keywords_display" msgid="8910345814565493016">"ekran, ekran me prekje"</string>
    <string name="keywords_display_brightness_level" msgid="3138350812626210404">"zbeh ekranin, ekran me prekje, bateri, e ndritshme"</string>
    <string name="keywords_display_night_display" msgid="2534032823231355074">"zbeh ekranin, natë, nuancë, orari i natës, ndriçimi, ngjyra e ekranit, ngjyrë, ngjyra"</string>
    <string name="keywords_display_wallpaper" msgid="7362076351860131776">"sfondi, personalizo, personalizo ekranin"</string>
    <string name="keywords_display_font_size" msgid="3404655440064726124">"madhësia e tekstit"</string>
    <string name="keywords_display_cast_screen" msgid="1209288893924324904">"projektoj, transmetoj, Pasqyrimi i ekranit, Ndarja e ekranit, pasqyrimi, ndaj ekranin, transmetimi i ekranit"</string>
    <string name="keywords_storage" msgid="3299217909546089225">"hapësirë, disk, njësi disku e ngurtë, përdorimi i pajisjes"</string>
    <string name="keywords_battery" msgid="1173830745699768388">"përdorimi i energjisë, karikim"</string>
    <string name="keywords_spell_checker" msgid="1399641226370605729">"gërmëzim, fjalor, kontroll ortografik, korrigjim automatik"</string>
    <string name="keywords_voice_input" msgid="769778245192531102">"njohës, hyrje, fjalim, fol, gjuhë, pa duar, dorë, falas, njohje, ofenduese, fjalë, audio, historik, aparat, bluetooth"</string>
    <string name="keywords_text_to_speech_output" msgid="5150660047085754699">"vlerëso, gjuhë e parazgjedhur, fol, duke folur, tts, qasje, lexues ekrani, i verbër"</string>
    <string name="keywords_date_and_time" msgid="758325881602648204">"ora, ushtarake"</string>
    <string name="keywords_network_reset" msgid="6024276007080940820">"rivendos, restauro, gjendje fabrike"</string>
    <string name="keywords_factory_data_reset" msgid="2261491208836438871">"pastro, fshi, restauro, spastro, hiq, rivendosja e gjendjes së fabrikës"</string>
    <string name="keywords_printing" msgid="1701778563617114846">"printeri"</string>
    <string name="keywords_sounds" msgid="5633386070971736608">"sinjali bip i altoparlantit, altoparlanti, volumi, hiq zërin, heshtje, audio, muzikë"</string>
    <string name="keywords_sounds_and_notifications_interruptions" msgid="5426093074031208917">"mos, mos shqetëso, ndërprit, ndërprerje, pushim"</string>
    <string name="keywords_app" msgid="6334757056536837791">"RAM"</string>
    <string name="keywords_location" msgid="4132655528196729043">"në afërsi, vendndodhje, historik, raportim, GPS"</string>
    <string name="keywords_accounts" msgid="1957925565953357627">"llogaria"</string>
    <string name="keywords_users" msgid="3434190133131387942">"kufizimi, kufizo, të kufizuara"</string>
    <string name="keywords_keyboard_and_ime" msgid="9143339015329957107">"korrigjim teksti, saktë, zë, dridhje, automatike, gjuhë, gjest, sugjero, sugjerim, temë, ofenduese, fjalë, emoji. ndërkombëtare"</string>
    <string name="keywords_reset_apps" msgid="5293291209613191845">"rivendos, preferencat, e parazgjedhur"</string>
    <string name="keywords_all_apps" msgid="7814015440655563156">"apl, shkarkim, aplikacione, sistem"</string>
    <string name="keywords_app_permissions" msgid="4229936435938011023">"aplikacione, leje, siguria"</string>
    <string name="keywords_default_apps" msgid="223872637509160136">"aplikacionet, e parazgjedhura"</string>
    <string name="keywords_ignore_optimizations" msgid="6102579291119055029">"shpërfill optimizimet, sasia, aplikacioni në modalitet gatishmërie"</string>
    <string name="keywords_color_mode" msgid="6362744316886077510">"ngjyrë e gjallë, RGB, sRGB, ngjyrë, natyrale, standarde"</string>
    <string name="keywords_color_temperature" msgid="6239410718075715449">"ngjyrë, temperaturë, D65, D73, e bardhë, e verdhë, blu, e ngrohtë, e ftohtë"</string>
    <string name="keywords_lockscreen" msgid="5746561909668570047">"rrëshqit për ta shkyçur, fjalëkalim, motiv, PIN"</string>
    <string name="keywords_profile_challenge" msgid="789611397846512845">"sfidë në punë, punë, profil"</string>
    <string name="keywords_unification" msgid="1922900767659821025">"profili i punës, profili i menaxhuar, unifiko, unifikim, punë, profil"</string>
    <string name="keywords_gesture" msgid="3526905012224714078">"gjestet"</string>
    <string name="keywords_payment_settings" msgid="5220104934130446416">"paguaj, trokit, pagesa"</string>
    <string name="keywords_backup" msgid="470070289135403022">"rezervim, rezervo"</string>
    <string name="keywords_assist_gesture_launch" msgid="813968759791342591">"gjesti"</string>
    <string name="keywords_face_unlock" msgid="254144854349092754">"fytyrë, shkyçje, autorizim, identifikim"</string>
    <string name="keywords_imei_info" msgid="7230982940217544527">"imei, meid, min, versioni prl, imei sv"</string>
    <string name="keywords_sim_status" msgid="6682044233620329507">"rrjeti, gjendja e rrjetit celular, gjendja e shërbimit, fuqia e sinjalit, lloji i rrjetit celular, roaming, iccid, eid"</string>
    <string name="keywords_model_and_hardware" msgid="1459248377212829642">"numri i serisë, versioni i harduerit"</string>
    <string name="keywords_android_version" msgid="9069747153590902819">"niveli i korrigjimit të sigurisë së Android, versioni i brezit të bazës, versioni i bërthamës"</string>
    <string name="keywords_dark_ui_mode" msgid="8999745898782012625">"tema, e çelur, e errët, modaliteti"</string>
    <string name="keywords_systemui_theme" msgid="9112852512550404882">"tema e errët"</string>
    <string name="keywords_device_feedback" msgid="564493721125966719">"defekt në kod"</string>
    <string name="keywords_ambient_display_screen" msgid="5874969496073249362">"Shfaqja e ambientit, shfaqja e ekranit të kyçjes"</string>
    <string name="keywords_lock_screen_notif" msgid="6716392855813576197">"njoftimi i ekranit të kyçjes, njoftimet"</string>
    <string name="keywords_face_settings" msgid="7505388678116799329">"fytyrë"</string>
    <string name="keywords_fingerprint_settings" msgid="4425098764810291897">"gjurmë gishti, shto një gjurmë gishti"</string>
    <string name="keywords_display_auto_brightness" msgid="4561771351118904241">"errëso ekranin, ekrani me prekje, bateria, ndriçimi inteligjent, ndriçimi dinamik, ndriçimi automatik"</string>
    <string name="keywords_display_adaptive_sleep" msgid="6865504720946121402">"errëso ekranin, në gjumë, bateria, koha e pritjes, vëmendja, ekrani, mungesa e aktivitetit"</string>
    <string name="keywords_auto_rotate" msgid="5620879898668211494">"rrotullo, përmbys, rrotullim, portret, peizazh, orientimi, vertikal, horizontal"</string>
    <string name="keywords_system_update_settings" msgid="7752189778843741773">"përmirëso, android"</string>
    <string name="keywords_zen_mode_settings" msgid="6526742836231604995">"mos shqetëso, planifikimi, njoftimet, blloko, heshtje, dridhje, gjumë, punë, fokusi, tingull, hiq zërin, ditë, ditë jave, fundjavë, natë jave, ngjarje"</string>
    <string name="keywords_screen_timeout" msgid="8161370660970309476">"ekrani, koha e kyçjes, koha e pritjes, ekrani i kyçjes"</string>
    <string name="keywords_storage_settings" msgid="297283751968446577">"memorie, memorie specifike, të dhëna, fshi, pastro, e lirë, hapësirë"</string>
    <string name="keywords_bluetooth_settings" msgid="6804844062789439858">"e lidhur, pajisje, kufje, kufje me mikrofon, altoparlant, pa tela, çift, kufje të vogla, muzikë, media"</string>
    <string name="keywords_wallpaper" msgid="5058364390917429896">"sfond, ekran, ekrani i kyçjes, temë"</string>
    <string name="keywords_assist_input" msgid="5017533309492679287">"i parazgjedhur, asistenti"</string>
    <string name="keywords_default_payment_app" msgid="3838565809518896799">"pagesë, e parazgjedhur"</string>
    <string name="keywords_ambient_display" msgid="3103487805748659132">"njoftim hyrës"</string>
    <string name="keywords_hotspot_tethering" msgid="1137511742967410918">"ndaj internetin me usb, ndaj internetin me bluetooth, zona e qasjes për internet me wifi"</string>
    <string name="keywords_touch_vibration" msgid="5983211715076385822">"prekje, dridhje, ekran, ndjeshmëri"</string>
    <string name="keywords_ring_vibration" msgid="4652101158979064884">"prekje, dridhje, telefon, telefonatë, ndjeshmëri, zile"</string>
    <string name="keywords_notification_vibration" msgid="31924624421190547">"prekje, dridhje, ndjeshmëri"</string>
    <string name="keywords_battery_saver_sticky" msgid="5586215686021650278">"kursyesi i baterisë, i ngjitur, vazhdoj, kursyesi i energjisë, bateria"</string>
    <string name="keywords_battery_saver_schedule" msgid="7358789228486231944">"rutina, planifikimi, kursyesi i baterisë, kursyesi i energjisë, bateria, automatike, përqind"</string>
    <string name="keywords_add_an_account" msgid="6488139919428902434">"profili i punës"</string>
    <string name="default_sound" msgid="8821684447333687810">"Zëri i parazgjedhur"</string>
    <string name="sound_settings_summary" msgid="4100853606668287965">"Volumi i ziles në <xliff:g id="PERCENTAGE">%1$s</xliff:g>"</string>
    <string name="sound_dashboard_summary" msgid="3402435125958012986">"Volum, dridhje, \"Mos shqetëso\""</string>
    <string name="sound_settings_summary_vibrate" msgid="1869282574422220096">"Zilja u caktua me dridhje"</string>
    <string name="sound_settings_summary_silent" msgid="5074529767435584948">"Zilja u vendos në heshtje"</string>
    <string name="sound_settings_example_summary" msgid="2404914514266523165">"Volumi i ziles në 80%"</string>
    <string name="media_volume_option_title" msgid="2811531786073003825">"Volumi i medias"</string>
    <string name="remote_media_volume_option_title" msgid="7602586327091007461">"Volumi i transmetimit"</string>
    <string name="call_volume_option_title" msgid="1265865226974255384">"Volumi i telefonatës"</string>
    <string name="alarm_volume_option_title" msgid="8219324421222242421">"Volumi i alarmit"</string>
    <string name="ring_volume_option_title" msgid="6767101703671248309">"Volumi i ziles"</string>
    <string name="notification_volume_option_title" msgid="6064656124416882130">"Volumi i njoftimit"</string>
    <string name="ringtone_title" msgid="5379026328015343686">"Zilja e telefonit"</string>
    <string name="notification_ringtone_title" msgid="4468722874617061231">"Zëri i parazgjedhur i njoftimit"</string>
    <string name="notification_unknown_sound_title" msgid="2535027767851838335">"Tingulli i dhënë nga aplikacioni"</string>
    <string name="notification_sound_default" msgid="565135733949733766">"Tingulli i parazgjedhur i njoftimit"</string>
    <string name="alarm_ringtone_title" msgid="6344025478514311386">"Tingulli i parazgjedhur i alarmit"</string>
    <string name="vibrate_when_ringing_title" msgid="8658910997501323472">"Lësho dridhje për telefonatat"</string>
    <string name="other_sound_settings" msgid="3151004537006844718">"Tinguj të tjerë"</string>
    <string name="dial_pad_tones_title" msgid="1999293510400911558">"Tonet e bllokut të tasteve"</string>
    <string name="screen_locking_sounds_title" msgid="1340569241625989837">"Tingujt e kyçjes së ekranit"</string>
    <string name="charging_sounds_title" msgid="3379885700913955599">"Tingujt dhe dridhja e ngarkimit"</string>
    <string name="docking_sounds_title" msgid="155236288949940607">"Tingujt e stacionimit"</string>
    <string name="touch_sounds_title" msgid="5326587106892390176">"Tingujt e prekjes"</string>
    <string name="vibrate_on_touch_title" msgid="1510405818894719079">"Dridhje për prekjen"</string>
    <string name="vibrate_on_touch_summary" msgid="8015901758501868229">"Reagimi me prekje për trokitjen, tastierën etj."</string>
    <string name="dock_audio_media_title" msgid="1346838179626123900">"Luhet nga altoparlanti i stacionit"</string>
    <string name="dock_audio_media_disabled" msgid="3430953622491538080">"Të gjitha audiot"</string>
    <string name="dock_audio_media_enabled" msgid="667849382924908673">"Vetëm klipe \"media\" audio"</string>
    <string name="emergency_tone_silent" msgid="3750231842974733677">"Heshtje"</string>
    <string name="emergency_tone_alert" msgid="8523447641290736852">"Tonet"</string>
    <string name="emergency_tone_vibrate" msgid="2278872257053690683">"Dridhjet"</string>
    <string name="boot_sounds_title" msgid="567029107382343709">"Aktivizo tingujt"</string>
    <string name="live_caption_title" msgid="2241633148129286971">"Titra automatike"</string>
    <string name="live_caption_summary" msgid="3365960379606535783">"Media me titra automatike"</string>
    <string name="zen_mode_settings_summary_off" msgid="6119891445378113334">"Asnjëherë"</string>
    <plurals name="zen_mode_settings_summary_on" formatted="false" msgid="2249085722517252521">
      <item quantity="other"><xliff:g id="ON_COUNT">%d</xliff:g> aktive</item>
      <item quantity="one">1 aktiv</item>
    </plurals>
    <string name="zen_mode_settings_title" msgid="1066226840983908121">"Mos shqetëso"</string>
    <string name="zen_mode_slice_subtitle" msgid="1495506059205752083">"Kufizo ndërprerjet"</string>
    <string name="zen_mode_settings_turn_on_dialog_title" msgid="2297134204747331078">"Aktivizo \"Mos shqetëso\""</string>
    <string name="zen_mode_behavior_settings_title" msgid="5453115212674008032">"Përjashtime"</string>
    <string name="zen_mode_duration_settings_title" msgid="8471983919324532829">"Kohëzgjatja e parazgjedhur"</string>
    <string name="zen_mode_behavior_allow_title" msgid="3845615648136218141">"Lejo tingujt dhe dridhjet nga"</string>
    <string name="zen_mode_behavior_no_sound" msgid="1219626004723208056">"Asnjë tingull"</string>
    <string name="zen_mode_behavior_total_silence" msgid="2229976744274214528">"Heshtje e plotë"</string>
    <string name="zen_mode_behavior_no_sound_except" msgid="4968477585788243114">"Asnjë tingull përveç <xliff:g id="CATEGORIES">%1$s</xliff:g>"</string>
    <string name="zen_mode_behavior_alarms_only" msgid="6455884547877702466">"Asnjë tingull përveç alarmeve dhe medias"</string>
    <string name="zen_mode_automation_settings_title" msgid="6155298704165984370">"Oraret"</string>
    <string name="zen_mode_delete_automatic_rules" msgid="5975522152123354381">"Fshi oraret"</string>
    <string name="zen_mode_schedule_delete" msgid="5717258786128155695">"Fshi"</string>
    <string name="zen_mode_rule_name_edit" msgid="812185626159430507">"Redakto"</string>
    <string name="zen_mode_automation_settings_page_title" msgid="8995524726286378583">"Oraret"</string>
    <string name="zen_mode_automatic_rule_settings_page_title" msgid="4773111805919088437">"Orari"</string>
    <string name="zen_mode_schedule_category_title" msgid="5482757877262584975">"Orari"</string>
    <string name="zen_mode_automation_suggestion_title" msgid="4321254843908888574">"Vendose telefonin në heshtje në kohë të caktuara"</string>
    <string name="zen_mode_automation_suggestion_summary" msgid="6223252025075862701">"Cakto rregullat për \"Mos shqetëso\""</string>
    <string name="zen_mode_schedule_title" msgid="8616187805239590649">"Orari"</string>
    <string name="zen_mode_use_automatic_rule" msgid="489102635414919052">"Përdor orar"</string>
    <string name="zen_mode_option_important_interruptions" msgid="3903928008177972500">"Vetëm njoftimet me prioritet"</string>
    <string name="zen_mode_option_alarms" msgid="5785372117288803600">"Vetëm alarmet"</string>
    <string name="zen_mode_option_no_interruptions" msgid="8107126344850276878">"Heshtje e plotë"</string>
    <string name="zen_mode_summary_combination" msgid="8715563402849273459">"<xliff:g id="MODE">%1$s</xliff:g>: <xliff:g id="EXIT_CONDITION">%2$s</xliff:g>"</string>
    <string name="zen_mode_visual_interruptions_settings_title" msgid="6751708745442997940">"Blloko shqetësimet vizuale"</string>
    <string name="zen_mode_visual_signals_settings_subtitle" msgid="6308824824208120508">"Lejo sinjalet vizuale"</string>
    <string name="zen_mode_settings_category" msgid="8404473163624911791">"Kur modaliteti \"Mos shqetëso\" është aktiv"</string>
    <string name="zen_mode_restrict_notifications_title" msgid="8138441771855063771">"Kufizo njoftimet"</string>
    <string name="zen_mode_restrict_notifications_mute" msgid="3690261619682396872">"Asnjë tingull nga njoftimet"</string>
    <string name="zen_mode_restrict_notifications_mute_summary" msgid="5810076116489877312">"Do të shikosh njoftime në ekranin tënd"</string>
    <string name="zen_mode_restrict_notifications_mute_footer" msgid="3465600930732602159">"Kur mbërrijnë njoftime, telefoni nuk do të lëshojë tinguj apo dridhje."</string>
    <string name="zen_mode_restrict_notifications_hide" msgid="5305121630186687339">"Asnjë pamje apo tingull nga njoftimet"</string>
    <string name="zen_mode_restrict_notifications_hide_summary" msgid="7555448406901864904">"Nuk do të shohësh apo dëgjosh njoftime"</string>
    <string name="zen_mode_restrict_notifications_hide_footer" msgid="1069960859746788356">"Telefoni yt nuk do të shfaqë, dridhet ose lëshojë tingull për njoftimet e reja ose ekzistuese. Ki parasysh se njoftimet kritike për aktivitetin dhe statusin e telefonit do të vazhdojnë të shfaqen.\n\nKur çaktivizon \"Mos shqetëso\", gjej njoftimet e humbura duke rrëshqitur poshtë nga pjesa e sipërme e ekranit."</string>
    <string name="zen_mode_restrict_notifications_custom" msgid="7498689167767941034">"Personalizo"</string>
    <string name="zen_mode_restrict_notifications_enable_custom" msgid="4250962169561739747">"Aktivizo cilësimin e personalizuar"</string>
    <string name="zen_mode_restrict_notifications_disable_custom" msgid="6676997522330453597">"Hiq cilësimin e personalizuar"</string>
    <string name="zen_mode_restrict_notifications_summary_muted" msgid="5450158135853888485">"Asnjë tingull nga njoftimet"</string>
    <string name="zen_mode_restrict_notifications_summary_custom" msgid="7416121534987213074">"Pjesërisht i fshehur"</string>
    <string name="zen_mode_restrict_notifications_summary_hidden" msgid="3618285192806732504">"Asnjë pamje apo tingull nga njoftimet"</string>
    <string name="zen_mode_what_to_block_title" msgid="5480903548365697159">"Personalizo kufizimet"</string>
    <string name="zen_mode_block_effects_screen_on" msgid="4659484530849212827">"Kur ekrani është aktiv"</string>
    <string name="zen_mode_block_effects_screen_off" msgid="4276414460889400625">"Kur ekrani është joaktiv"</string>
    <string name="zen_mode_block_effect_sound" msgid="7383953383758025895">"Vendos tingullin dhe dridhjen në heshtje"</string>
    <string name="zen_mode_block_effect_intent" msgid="350764335391428447">"Mos e aktivizo ekranin"</string>
    <string name="zen_mode_block_effect_light" msgid="8106976110224107316">"Mos pulso dritën"</string>
    <string name="zen_mode_block_effect_peek" msgid="6836997464098657115">"Mos shfaq njoftime në ekran"</string>
    <string name="zen_mode_block_effect_status" msgid="1651527249762752921">"Fshih ikonat e shiritit të statusit në krye të ekranit"</string>
    <string name="zen_mode_block_effect_badge" msgid="214553506070597320">"Fshih pikat e njoftimeve në ikonat e aplikacioneve"</string>
    <string name="zen_mode_block_effect_ambient" msgid="4704755879961212658">"Mos zgjo për njoftimet"</string>
    <string name="zen_mode_block_effect_list" msgid="4722887783222298295">"Fshihe nga streha me tërheqje poshtë"</string>
    <string name="zen_mode_block_effect_summary_none" msgid="2617875282623486256">"Asnjëherë"</string>
    <string name="zen_mode_block_effect_summary_screen_off" msgid="1230265589026355094">"Kur ekrani është joaktiv"</string>
    <string name="zen_mode_block_effect_summary_screen_on" msgid="6017536991063513394">"Kur ekrani është aktiv"</string>
    <string name="zen_mode_block_effect_summary_sound" msgid="1065107568053759972">"Tingull dhe dridhje"</string>
    <string name="zen_mode_block_effect_summary_some" msgid="3635646031575107456">"Tingull, dridhje dhe disa shenja vizuale të njoftimeve"</string>
    <string name="zen_mode_block_effect_summary_all" msgid="1213328945418248026">"Tingull, dridhje dhe shenja vizuale të njoftimeve"</string>
    <string name="zen_mode_blocked_effects_footer" msgid="5710896246703497760">"Njoftimet që nevojiten për aktivitetin bazë të telefonit dhe statusin nuk do të fshihen asnjëherë"</string>
    <string name="zen_mode_no_exceptions" msgid="7653433997399582247">"Asnjë"</string>
    <string name="zen_mode_other_options" msgid="520015080445012355">"opsione të tjera"</string>
    <string name="zen_mode_add" msgid="90014394953272517">"Shto"</string>
    <string name="zen_mode_enable_dialog_turn_on" msgid="8287824809739581837">"Aktivizo"</string>
    <string name="zen_mode_button_turn_on" msgid="2824380626482175552">"Aktivizo tani"</string>
    <string name="zen_mode_button_turn_off" msgid="6181953727880503094">"Çaktivizo tani"</string>
    <string name="zen_mode_settings_dnd_manual_end_time" msgid="8860646554263965569">"Modaliteti \"Mos shqetëso\" është aktiv deri në <xliff:g id="FORMATTED_TIME">%s</xliff:g>"</string>
    <string name="zen_mode_settings_dnd_manual_indefinite" msgid="7186615007561990908">"Modaliteti \"Mos shqetëso\" do të qëndrojë aktiv deri sa ta çaktivizosh"</string>
    <string name="zen_mode_settings_dnd_automatic_rule" msgid="6195725842906270996">"Modaliteti \"Mos shqetëso\" është aktivizuar automatikisht nga një orar (<xliff:g id="RULE_NAME">%s</xliff:g>)"</string>
    <string name="zen_mode_settings_dnd_automatic_rule_app" msgid="1721179577382915270">"Modaliteti \"Mos shqetëso\" është aktivizuar automatikisht nga një aplikacion <xliff:g id="APP_NAME">%s</xliff:g>"</string>
    <string name="zen_mode_settings_dnd_custom_settings_footer" msgid="1965922539531521052">"Modaliteti \"Mos shqetëso\" është aktiv për <xliff:g id="RULE_NAMES">%s</xliff:g> me cilësimet e personalizuara."</string>
    <string name="zen_mode_settings_dnd_custom_settings_footer_link" msgid="7555742240858292255"><annotation id="link">" Shiko cilësimet e personalizuara"</annotation></string>
    <string name="zen_interruption_level_priority" msgid="2078370238113347720">"Vetëm me prioritet"</string>
    <string name="zen_mode_and_condition" msgid="4927230238450354412">"<xliff:g id="ZEN_MODE">%1$s</xliff:g>. <xliff:g id="EXIT_CONDITION">%2$s</xliff:g>"</string>
    <string name="zen_mode_sound_summary_on_with_info" msgid="1202632669798211342">"Aktiv / <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="zen_mode_sound_summary_off_with_info" msgid="2348629457144123849">"Joaktiv / <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="zen_mode_sound_summary_off" msgid="4375814717589425561">"Joaktiv"</string>
    <string name="zen_mode_sound_summary_on" msgid="7718273231309882914">"Aktiv"</string>
    <string name="zen_mode_duration_summary_always_prompt" msgid="3483258992533158479">"Pyet çdo herë"</string>
    <string name="zen_mode_duration_summary_forever" msgid="8597777321810802309">"Derisa ta çaktivizosh"</string>
    <plurals name="zen_mode_duration_summary_time_hours" formatted="false" msgid="3224363976852136871">
      <item quantity="other"><xliff:g id="NUM_HOURS">%d</xliff:g> orë</item>
      <item quantity="one">1 orë</item>
    </plurals>
    <string name="zen_mode_duration_summary_time_minutes" msgid="6238305783533884764">"<xliff:g id="NUM_MINUTES">%d</xliff:g> minuta"</string>
    <plurals name="zen_mode_sound_summary_summary_off_info" formatted="false" msgid="6751226506661227581">
      <item quantity="other"><xliff:g id="ON_COUNT">%d</xliff:g> orare mund të aktivizohen automatikisht</item>
      <item quantity="one">1 orar mund të aktivizohet automatikisht</item>
    </plurals>
    <string name="zen_category_behavior" msgid="554277240833452070">"Çaktivizo zërin e pajisjes, por lejo përjashtimet"</string>
    <string name="zen_category_exceptions" msgid="7601136604273265629">"Përjashtimet"</string>
    <string name="zen_category_schedule" msgid="9000447592251450453">"Orari"</string>
    <string name="zen_sound_title" msgid="4461494611692749446">"Shiko të gjitha përjashtimet"</string>
    <string name="zen_sound_footer" msgid="7621745273287208979">"Kur modaliteti \"Mos shqetëso\" është aktiv, tingujt dhe dridhjet do të jenë në heshtje, përveçse për artikujt që lejon më sipër."</string>
    <string name="zen_sound_category_title" msgid="4336596939661729188">"Çaktivizo audion për të gjitha përveçse për"</string>
    <string name="zen_sound_all_muted" msgid="4850363350480968114">"Pa zë"</string>
    <string name="zen_sound_none_muted" msgid="3938508512103612527">"Me zë"</string>
    <string name="zen_sound_one_allowed" msgid="8447313454438932276">"Pa zë, por lejo <xliff:g id="SOUND_TYPE">%1$s</xliff:g>"</string>
    <string name="zen_sound_two_allowed" msgid="980491120444358550">"Pa zë, por lejo <xliff:g id="SOUND_TYPE_0">%1$s</xliff:g> dhe <xliff:g id="SOUND_TYPE_1">%2$s</xliff:g>"</string>
    <string name="zen_sound_three_allowed" msgid="3455767205934547985">"Pa zë, por lejo <xliff:g id="SOUND_TYPE_0">%1$s</xliff:g>, <xliff:g id="SOUND_TYPE_1">%2$s</xliff:g> dhe <xliff:g id="SOUND_TYPE_2">%3$s</xliff:g>"</string>
    <string name="zen_custom_settings_dialog_title" msgid="3999383687283620283">"Cilësimet e personalizuara"</string>
    <string name="zen_custom_settings_dialog_review_schedule" msgid="7056997717364939238">"Rishiko orarin"</string>
    <string name="zen_custom_settings_dialog_ok" msgid="5302885851078421866">"E kuptova"</string>
    <string name="zen_custom_settings_notifications_header" msgid="6931035609369698584">"Njoftimet"</string>
    <string name="zen_custom_settings_duration_header" msgid="1190989278065507035">"Kohëzgjatja"</string>
    <string name="zen_msg_event_reminder_title" msgid="5137894077488924820">"Mesazhet, ngjarjet dhe alarmet rikujtuese"</string>
    <string name="zen_msg_event_reminder_footer" msgid="4376930591019535192">"Kur modaliteti \"Mos shqetëso\" është aktiv, mesazhet, alarmet rikujtuese dhe ngjarjet do të jenë në heshtje, përveçse për artikujt që lejon më sipër. Mund t\'i përshtatësh cilësimet e mesazheve për të lejuar shokët, familjen ose kontakte të tjera që të lidhen me ty."</string>
    <string name="zen_onboarding_ok" msgid="6131211000824433013">"U krye"</string>
    <string name="zen_onboarding_settings" msgid="9046451821239946868">"Cilësimet"</string>
    <string name="zen_onboarding_new_setting_title" msgid="1893095176110470711">"Asnjë pamje apo tingull nga njoftimet"</string>
    <string name="zen_onboarding_current_setting_title" msgid="776426065129609376">"Asnjë tingull nga njoftimet"</string>
    <string name="zen_onboarding_new_setting_summary" msgid="6293026064871880706">"Nuk do të shohësh apo dëgjosh njoftime. Lejohen telefonatat nga kontaktet me yll dhe telefonuesit e përsëritur."</string>
    <string name="zen_onboarding_current_setting_summary" msgid="1280614488924843713">"(Cilësimet aktuale)"</string>
    <string name="zen_onboarding_dnd_visual_disturbances_header" msgid="1352808651270918932">"Të ndryshohen cilësimet e njoftimeve të modalitetit \"Mos shqetëso\"?"</string>
    <string name="sound_work_settings" msgid="6774324553228566442">"Tingujt e profilit të punës"</string>
    <string name="work_use_personal_sounds_title" msgid="1148331221338458874">"Përdor tingujt e profilit personal"</string>
    <string name="work_use_personal_sounds_summary" msgid="6207040454949823153">"Tingujt janë të njëjtë për profilin tënd personal dhe atë të punës"</string>
    <string name="work_ringtone_title" msgid="5806657896300235315">"Toni telefonik i telefonit të punës"</string>
    <string name="work_notification_ringtone_title" msgid="6081247402404510004">"Tingulli i parazgjedhur i njoftimit të punës"</string>
    <string name="work_alarm_ringtone_title" msgid="1441926676833738891">"Tingulli i parazgjedhur i alarmit të punës"</string>
    <string name="work_sound_same_as_personal" msgid="3123383644475266478">"Njësoj si profili personal"</string>
    <string name="work_sync_dialog_title" msgid="7123973297187354813">"Të zëvendësohen tingujt?"</string>
    <string name="work_sync_dialog_yes" msgid="7243884940551635717">"Zëvendëso"</string>
    <string name="work_sync_dialog_message" msgid="7841728953710863208">"Tingujt e profilit tënd personal do të përdoren për profilin tënd të punës"</string>
    <string name="ringtones_install_custom_sound_title" msgid="5948792721161302255">"Të shtohet një tingull i personalizuar?"</string>
    <string name="ringtones_install_custom_sound_content" msgid="2195581481608512786">"Ky skedar do të kopjohet te dosja <xliff:g id="FOLDER_NAME">%s</xliff:g>"</string>
    <string name="ringtones_category_preference_title" msgid="5675912303120102366">"Zilet"</string>
    <string name="other_sound_category_preference_title" msgid="2521096636124314015">"Tinguj dhe dridhje të tjera"</string>
    <string name="configure_notification_settings" msgid="7616737397127242615">"Njoftimet"</string>
    <string name="recent_notifications" msgid="5660639387705060156">"Dërguar së fundi"</string>
    <string name="recent_notifications_see_all_title" msgid="8572160812124540326">"Shih të gjithë apl. në 7 ditët e fundit"</string>
    <string name="advanced_section_header" msgid="8833934850242546903">"Të përparuara"</string>
    <string name="profile_section_header" msgid="2320848161066912001">"Njoftimet e punës"</string>
    <string name="smart_notifications_title" msgid="3702411478231865970">"Njoftimet me përshtatje"</string>
    <string name="asst_capability_prioritizer_title" msgid="3854208223528908688">"Përparësia e njoftimeve me përshtatje"</string>
    <string name="asst_capability_prioritizer_summary" msgid="7553129095829077229">"Caktoji automatikisht njoftimet me prioritet më të ulët te \"Me rëndësi të ulët\""</string>
    <string name="asst_capabilities_actions_replies_title" msgid="8621608733904251499">"Veprimet dhe përgjigjet e sugjeruara"</string>
    <string name="asst_capabilities_actions_replies_summary" msgid="2367828721274129806">"Shfaq automatikisht veprimet dhe përgjigjet e sugjeruara"</string>
    <string name="snooze_options_title" msgid="7447722951050463793">"Lejo shtyrjen e njoftimeve"</string>
    <string name="hide_silent_icons_title" msgid="3803036978493857276">"Fshih ikonat nga njoftimet me rëndësi të ulët"</string>
    <string name="hide_silent_icons_summary" msgid="8422819235336628802">"Ikonat nga njoftimet me rëndësi të ulët nuk shfaqen në shiritin e statusit"</string>
    <string name="notification_badging_title" msgid="5938709971403474078">"Lejo pikat e njoftimeve"</string>
    <string name="notification_bubbles_title" msgid="526545466417027926">"Flluskat"</string>
    <string name="notification_bubbles_developer_setting_summary" msgid="5044678712656329427">"Disa njoftime mund të shfaqen si flluska në ekran"</string>
    <string name="bubbles_feature_education" msgid="69923617148394578">"Disa njoftime dhe përmbajtje të tjera mund të shfaqen si flluska në ekran. Për ta hapur një flluskë, trokit tek ajo. Për ta hequr, zvarrite poshtë në ekran."</string>
    <string name="bubbles_app_toggle_title" msgid="9143702245165359360">"Flluskat"</string>
    <string name="bubbles_app_toggle_summary" msgid="7714358008428342285">"Lejo që <xliff:g id="APP_NAME">%1$s</xliff:g> të shfaqë disa njoftime si flluska"</string>
    <string name="bubbles_feature_disabled_dialog_title" msgid="8013961655723563787">"Aktivizo flluskat"</string>
    <string name="bubbles_feature_disabled_dialog_text" msgid="3616822820657195387">"Për të aktivizuar flluskat për këtë aplikacion, në fillim duhet t\'i aktivizosh ato për pajisjen tënde. Kjo ka ndikim tek aplikacionet e tjera ku ke aktivizuar më parë flluskat."</string>
    <string name="bubbles_feature_disabled_button_approve" msgid="5317196831268846883">"Aktivizo për pajisjen"</string>
    <string name="bubbles_feature_disabled_button_cancel" msgid="8176870537170586852">"Anulo"</string>
    <string name="swipe_direction_title" msgid="6877543492435053137">"Veprimet me rrëshqitje"</string>
    <string name="swipe_direction_ltr" msgid="3623394320915041215">"Rrëshqit shpejt djathtas për ta hequr, ose majtas për të shfaqur menynë"</string>
    <string name="swipe_direction_rtl" msgid="4972099509548044938">"Rrëshqit shpejt majtas për ta hequr, ose djathtas për të shfaqur menynë"</string>
    <string name="gentle_notifications_title" msgid="3976374971153475110">"Njoftimet me rëndësi të ulët"</string>
    <string name="gentle_notifications_also_display" msgid="6455360420411828133">"Shfaq po ashtu në"</string>
    <string name="gentle_notifications_display_status" msgid="2904115658980383410">"Shiriti i statusit"</string>
    <string name="gentle_notifications_display_lock" msgid="1395567209329239992">"Ekrani i kyçjes"</string>
    <string name="gentle_notifications_education" msgid="8713358646047345762">"Njoftimet me rëndësi të ulët janë gjithmonë në heshtje dhe shfaqen gjithmonë në strehën me tërheqje poshtë"</string>
    <string name="gentle_notifications_display_summary_shade" msgid="6583107817329430916">"Shfaq vetëm në strehën me tërheqje poshtë"</string>
    <string name="gentle_notifications_display_summary_shade_lock" msgid="1434426811760016414">"Shfaq në strehën me tërheqje poshtë dhe në ekranin e kyçjes"</string>
    <string name="gentle_notifications_display_summary_shade_status" msgid="6113566548809874319">"Shfaq në strehën me tërheqje poshtë dhe shiritin e statusit"</string>
    <string name="gentle_notifications_display_summary_shade_status_lock" msgid="4222628772925544654">"Shfaq në strehën me tërheqje poshtë, shiritin e statusit dhe në ekranin e kyçjes"</string>
    <string name="notification_pulse_title" msgid="1905382958860387030">"Drita me pulsim"</string>
    <string name="lock_screen_notifications_title" msgid="7604704224172951090">"Ekrani i kyçjes"</string>
    <string name="lockscreen_bypass_title" msgid="3077831331856929085">"Kapërce ekranin e kyçjes"</string>
    <string name="lockscreen_bypass_summary" msgid="2767475923650816867">"Pas shkyçjes me fytyrë, shko direkt te ekrani i fundit i përdorur"</string>
    <string name="keywords_lockscreen_bypass" msgid="250300001805572693">"Ekrani i kyçjes, ekrani i bllokimit, kapërce, anashkalo"</string>
    <string name="locked_work_profile_notification_title" msgid="8327882003361551992">"Kur profili i punës është i kyçur"</string>
    <string name="lock_screen_notifs_title" msgid="3812061224136552712">"Njoftimet në ekranin e kyçjes"</string>
    <string name="lock_screen_notifs_show_all" msgid="5848645268278883539">"Shfaq njoftimet sinjalizuese dhe në heshtje"</string>
    <string name="lock_screen_notifs_show_alerting" msgid="3085615237751195449">"Shfaq vetëm njoftime sinjalizuese"</string>
    <string name="lock_screen_notifs_show_none" msgid="3357167536259901686">"Mos i shfaq njoftimet"</string>
    <string name="lock_screen_notifs_redact" msgid="3942294440983226225">"Njoftimet delikate"</string>
    <string name="lock_screen_notifs_redact_summary" msgid="3095153536179931941">"Shfaq përmbajtje delikate kur është i kyçur"</string>
    <string name="lock_screen_notifs_redact_work" msgid="6777821963954035608">"Njoftimet delikate të profilit të punës"</string>
    <string name="lock_screen_notifs_redact_work_summary" msgid="2179290697692276201">"Shfaq përmbajtje delikate të profilit të punës kur është i kyçur"</string>
    <string name="lock_screen_notifications_summary_show" msgid="6407527697810672847">"Shfaq të gjithë përmbajtjen e njoftimit"</string>
    <string name="lock_screen_notifications_summary_hide" msgid="1133085507139112569">"Shfaq përmbajtje delikate vetëm kur të shkyçet"</string>
    <string name="lock_screen_notifications_summary_disable" msgid="859628910427886715">"Mos shfaq asnjë njoftim"</string>
    <string name="lock_screen_notifications_interstitial_message" msgid="3143593517597479937">"Si dëshiron të shfaqet ekrani i kyçjes?"</string>
    <string name="lock_screen_notifications_interstitial_title" msgid="709573564312902481">"Ekrani i kyçjes"</string>
    <string name="lock_screen_notifications_summary_show_profile" msgid="835870815661120772">"Shfaq të gjitha përmbajtjet e njoftimeve të punës"</string>
    <string name="lock_screen_notifications_summary_hide_profile" msgid="2005907007779384635">"Fshihe përmbajtjen delikate të punës"</string>
    <string name="lock_screen_notifications_interstitial_message_profile" msgid="8307705621027472346">"Kur pajisja jote të jetë e kyçur, si dëshiron të shfaqen njoftimet e profilit?"</string>
    <string name="lock_screen_notifications_interstitial_title_profile" msgid="3169806586032521333">"Njoftimet e profilit"</string>
    <string name="notifications_title" msgid="8086372779371204971">"Njoftimet"</string>
    <string name="app_notifications_title" msgid="5810577805218003760">"Njoftimet e apl."</string>
    <string name="notification_channel_title" msgid="2260666541030178452">"Kategoria e njoftimeve"</string>
    <string name="notification_group_title" msgid="7180506440133859601">"Grupi i kategorisë së njoftimeve"</string>
    <string name="notification_importance_title" msgid="4368578960344731828">"Sjellja"</string>
    <string name="notification_importance_unspecified" msgid="6622173510486113958">"Lejo tingullin"</string>
    <string name="notification_importance_blocked" msgid="7938180808339386300">"Mos i shfaq asnjëherë njoftimet"</string>
    <string name="notification_importance_min" msgid="9054819132085066824">"Shfaq në heshtje dhe minimizo"</string>
    <string name="notification_importance_low" msgid="2445139943005315690">"Shfaq në heshtje"</string>
    <string name="notification_importance_default" msgid="5958338024601957516">"Bëj tingull"</string>
    <string name="notification_importance_high" msgid="2082429479238228527">"Bëj një tingull dhe shfaq në ekran"</string>
    <string name="notification_importance_high_silent" msgid="2667033773703765252">"Shfaq në ekran"</string>
    <string name="notification_importance_min_title" msgid="5024538864029341539">"Minimizo"</string>
    <string name="notification_importance_low_title" msgid="8131254047772814309">"Mesatare"</string>
    <string name="notification_importance_default_title" msgid="9120383978536089489">"E lartë"</string>
    <string name="notification_importance_high_title" msgid="8792310396497954857">"Shfaq në ekran"</string>
    <string name="notification_block_title" msgid="1366361048463539674">"Blloko"</string>
    <string name="notification_silence_title" msgid="6986752165900591125">"Në heshtje"</string>
    <string name="notification_alert_title" msgid="2267584776990348784">"Sinjalizimi"</string>
    <string name="allow_interruption" msgid="7136150018111848721">"Lejo ndërprerjet"</string>
    <string name="allow_interruption_summary" msgid="7870159391333957050">"Lejo që aplikacioni të lëshojë tingull, të dridhet dhe/ose të shfaqë njoftime në ekran"</string>
    <string name="notification_channel_summary_min" msgid="2965790706738495761">"Në strehën me tërheqje poshtë, palosi njoftimet në një rresht"</string>
    <string name="notification_channel_summary_low" msgid="7050068866167282765">"Të ndihmon të fokusohesh pa tinguj ose dridhje"</string>
    <string name="notification_channel_summary_default" msgid="5753454293847059695">"Të tërheq vëmendjen me tinguj ose dridhje"</string>
    <string name="notification_channel_summary_high" msgid="7737315941884569891">"Kur pajisja është e shkyçur, shfaq njoftimet si një banderolë përgjatë kreut të ekranit"</string>
    <string name="notification_switch_label" msgid="6843075654538931025">"Shfaq njoftimet"</string>
    <string name="default_notification_assistant" msgid="8441022088918117445">"Njoftimet me përshtatje"</string>
    <plurals name="notifications_sent_daily" formatted="false" msgid="6049014219388148161">
      <item quantity="other">~<xliff:g id="NUMBER_1">%d</xliff:g> njoftime në ditë</item>
      <item quantity="one">~<xliff:g id="NUMBER_0">%d</xliff:g> njoftim në ditë</item>
    </plurals>
    <plurals name="notifications_sent_weekly" formatted="false" msgid="5096638662520720959">
      <item quantity="other">~<xliff:g id="NUMBER_1">%d</xliff:g> njoftime në javë</item>
      <item quantity="one">~<xliff:g id="NUMBER_0">%d</xliff:g> njoftim në javë</item>
    </plurals>
    <string name="notifications_sent_never" msgid="1001964786456700536">"Asnjëherë"</string>
    <string name="manage_notification_access_title" msgid="7510080164564944891">"Qasja te njoftimet"</string>
    <string name="work_profile_notification_access_blocked_summary" msgid="8748026238701253040">"Qasja në njoftimet e profilit të punës është bllokuar"</string>
    <string name="manage_notification_access_summary_zero" msgid="2409912785614953348">"Aplikacionet nuk mund t\'i lexojnë njoftimet"</string>
    <plurals name="manage_notification_access_summary_nonzero" formatted="false" msgid="7930130030691218387">
      <item quantity="other"> aplikacione mund të lexojnë njoftime</item>
      <item quantity="one">%d aplikacion mund të lexojë njoftime</item>
    </plurals>
    <string name="notification_assistant_title" msgid="7531256823396529700">"Njoftimet me përshtatje"</string>
    <string name="no_notification_assistant" msgid="2818970196806227480">"Asnjë"</string>
    <string name="no_notification_listeners" msgid="3487091564454192821">"Asnjë apl. i instaluar nuk ka kërkuar qasje te njoftimet."</string>
    <string name="notification_assistant_security_warning_title" msgid="300600401595343861">"Të lejohet qasja e njoftimeve për <xliff:g id="SERVICE">%1$s</xliff:g>?"</string>
    <string name="notification_assistant_security_warning_summary" msgid="5829972610310154776">"<xliff:g id="NOTIFICATION_ASSISTANT_NAME">%1$s</xliff:g> do të jetë në gjendje të lexojë të gjitha njoftimet, duke përfshirë informacione personale të tilla si emrat e kontakteve dhe tekstin e mesazheve që merr. Ai do të jetë po ashtu në gjendje t\'i modifikojë ose t\'i heqë njoftimet ose të aktivizojë butonat e veprimeve që përmbajnë. \n\nKjo do t\'i japë aplikacionit aftësinë për të aktivizuar ose çaktivizuar \"Mos shqetëso\" dhe për të ndryshuar cilësimet përkatëse."</string>
    <string name="notification_listener_security_warning_title" msgid="5522924135145843279">"Të lejohet qasja te njoftimet për <xliff:g id="SERVICE">%1$s</xliff:g>?"</string>
    <string name="notification_listener_security_warning_summary" msgid="119203147791040151">"<xliff:g id="NOTIFICATION_LISTENER_NAME">%1$s</xliff:g> do të jetë në gjendje të lexojë të gjitha njoftimet, duke përfshirë informacione personale të tilla si emrat e kontakteve dhe tekstin e mesazheve që merr. Ai do të jetë po ashtu në gjendje t\'i heqë njoftimet ose të aktivizojë butonat e veprimeve që përmbajnë.\n\nKjo do t\'i japë aplikacionit aftësinë për të aktivizuar ose çaktivizuar \"Mos shqetëso\" dhe për të ndryshuar cilësimet përkatëse."</string>
    <string name="notification_listener_disable_warning_summary" msgid="6738915379642948000">"Nëse çaktivizon qasjen e njoftimeve për <xliff:g id="NOTIFICATION_LISTENER_NAME">%1$s</xliff:g>, mund të çaktivizohet edhe qasja e \"Mos shqetëso\"."</string>
    <string name="notification_listener_disable_warning_confirm" msgid="8333442186428083057">"Çaktivizo"</string>
    <string name="notification_listener_disable_warning_cancel" msgid="8586417377104211584">"Anulo"</string>
    <string name="vr_listeners_title" msgid="1318901577754715777">"Shërbimet e ndihmësit VR"</string>
    <string name="no_vr_listeners" msgid="2689382881717507390">"Asnjë aplikacion i instaluar nuk ka kërkuar të ekzekutohet si shërbim ndihmësi VR."</string>
    <string name="vr_listener_security_warning_title" msgid="8309673749124927122">"Të lejohet qasja e shërbimit VR për <xliff:g id="SERVICE">%1$s</xliff:g>?"</string>
    <string name="vr_listener_security_warning_summary" msgid="6931541068825094653">"<xliff:g id="VR_LISTENER_NAME">%1$s</xliff:g> do të jetë në gjendje të ekzekutohet kur përdoren aplikacionet në modalitetin e realitetit virtual."</string>
    <string name="display_vr_pref_title" msgid="8104485269504335481">"Kur pajisja është në modalitetin VR"</string>
    <string name="display_vr_pref_low_persistence" msgid="5707494209944718537">"Zvogëlo turbullimin (rekomandohet)"</string>
    <string name="display_vr_pref_off" msgid="2190091757123260989">"Zvogëlo luhatjet e dritës"</string>
    <string name="picture_in_picture_title" msgid="5824849294270017113">"Figurë brenda figurës"</string>
    <string name="picture_in_picture_empty_text" msgid="685224245260197779">"Asnjë aplikacion i instaluar nuk e mbështet figurën brenda figurës"</string>
    <string name="picture_in_picture_keywords" msgid="8361318686701764690">"fbf figurë brenda"</string>
    <string name="picture_in_picture_app_detail_title" msgid="4080800421316791732">"Figurë brenda figurës"</string>
    <string name="picture_in_picture_app_detail_switch" msgid="1131910667023738296">"Lejo figurë brenda figurës"</string>
    <string name="picture_in_picture_app_detail_summary" msgid="1264019085827708920">"Lejoje këtë aplikacion të krijojë dritare \"figurë brenda figure\" ndërkohë që aplikacioni është i hapur ose pasi të dalësh prej tij (për shembull, për të vazhduar shikimin e një videoje). Kjo dritare shfaqet mbi aplikacionet e tjera që po përdor."</string>
    <string name="manage_zen_access_title" msgid="2611116122628520522">"Qasja te \"Mos shqetëso\""</string>
    <string name="zen_access_detail_switch" msgid="1188754646317450926">"Lejo modalitetin \"Mos shqetëso\""</string>
    <string name="zen_access_empty_text" msgid="8772967285742259540">"Asnjë aplikacion i instaluar nuk ka kërkuar qasje te \"Mos shqetëso\""</string>
    <string name="loading_notification_apps" msgid="5031818677010335895">"Po ngarkon aplikacionet..."</string>
    <string name="app_notifications_off_desc" msgid="8289223211387083447">"Me kërkesën tënde, Android po bllokon shfaqjen e njoftimeve të këtij aplikacioni në këtë pajisje"</string>
    <string name="channel_notifications_off_desc" msgid="9013011134681491778">"Me kërkesën tënde, Android po bllokon shfaqjen e kësaj kategorie njoftimesh në këtë pajisje"</string>
    <string name="channel_group_notifications_off_desc" msgid="2315252834146837470">"Me kërkesën tënde, Android po bllokon shfaqjen e këtij grupi njoftimesh në këtë pajisje"</string>
    <string name="notification_channels" msgid="5346841743182627500">"Kategoritë"</string>
    <string name="notification_channels_other" msgid="5645317113885788226">"Të tjera"</string>
    <plurals name="notification_group_summary" formatted="false" msgid="3420621520561455358">
      <item quantity="other"><xliff:g id="COUNT_1">%d</xliff:g> kategori</item>
      <item quantity="one"><xliff:g id="COUNT_0">%d</xliff:g> kategori</item>
    </plurals>
    <string name="no_channels" msgid="3077375508177744586">"Ky aplikacion nuk ka postuar asnjë njoftim"</string>
    <string name="app_settings_link" msgid="8894946007543660906">"Cilësime shtesë në aplikacion"</string>
    <string name="app_notification_listing_summary_zero" msgid="8046168435207424440">"Aktiv për të gjitha aplikacionet"</string>
    <plurals name="app_notification_listing_summary_others" formatted="false" msgid="6709582776823665660">
      <item quantity="other">Joaktiv për <xliff:g id="COUNT_1">%d</xliff:g> aplikacione</item>
      <item quantity="one">Joaktiv për <xliff:g id="COUNT_0">%d</xliff:g> aplikacion</item>
    </plurals>
    <plurals name="deleted_channels" formatted="false" msgid="8028574302599397935">
      <item quantity="other"><xliff:g id="COUNT_1">%d</xliff:g> kategori u fshinë</item>
      <item quantity="one"><xliff:g id="COUNT_0">%d</xliff:g> kategori u fshi</item>
    </plurals>
    <string name="notification_toggle_on" msgid="650145396718191048">"Aktive"</string>
    <string name="notification_toggle_off" msgid="2142010737190671762">"Joaktive"</string>
    <string name="app_notification_block_title" msgid="4069351066849087649">"Bllokoji të gjitha"</string>
    <string name="app_notification_block_summary" msgid="4744020456943215352">"Mos i shfaq asnjëherë këto njoftime"</string>
    <string name="notification_content_block_title" msgid="5854232570963006360">"Shfaq njoftimet"</string>
    <string name="notification_content_block_summary" msgid="7746185794438882389">"Mos shfaq asnjëherë njoftime në hije ose në pajisje periferike"</string>
    <string name="notification_badge_title" msgid="6370122441168519809">"Lejo pikën e njoftimeve"</string>
    <string name="notification_channel_badge_title" msgid="2240827899882847087">"Shfaq pikën e njoftimeve"</string>
    <string name="app_notification_override_dnd_title" msgid="7867458246395884830">"Anulo \"Mos shqetëso\""</string>
    <string name="app_notification_override_dnd_summary" msgid="2612502099373472686">"Lejo shfaqjen e njoftimeve edhe kur modaliteti \"Mos shqetëso\" është aktiv"</string>
    <string name="app_notification_visibility_override_title" msgid="3618860781666494595">"Ekrani i kyçjes"</string>
    <string name="app_notification_row_banned" msgid="5983655258784814773">"I bllokuar"</string>
    <string name="app_notification_row_priority" msgid="7723839972982746568">"Me prioritet"</string>
    <string name="app_notification_row_sensitive" msgid="1809610030432329940">"Delikate"</string>
    <string name="app_notifications_dialog_done" msgid="3484067728568791014">"U krye!"</string>
    <string name="app_notification_importance_title" msgid="8002263131149345584">"Rëndësia"</string>
    <string name="notification_show_lights_title" msgid="7671781299688190532">"Drita me pulsim"</string>
    <string name="notification_vibrate_title" msgid="1646667807969755957">"Dridhje"</string>
    <string name="notification_channel_sound_title" msgid="3899212238513507941">"Tingulli"</string>
    <string name="zen_mode_rule_delete_button" msgid="903658142711011617">"Fshi"</string>
    <string name="zen_mode_rule_rename_button" msgid="4642843370946599164">"Riemërto"</string>
    <string name="zen_mode_rule_name" msgid="5607736317244760638">"Emri i orarit"</string>
    <string name="zen_mode_rule_name_hint" msgid="278109122579468433">"Vendos emrin e orarit"</string>
    <string name="zen_mode_rule_name_warning" msgid="3856485373110366912">"Emri i orarit është tashmë në përdorim"</string>
    <string name="zen_mode_add_rule" msgid="7459154136384467057">"Shto më shumë"</string>
    <string name="zen_mode_add_event_rule" msgid="4454759739839069898">"Shto orar ngjarjeje"</string>
    <string name="zen_mode_add_time_rule" msgid="7890557350868257760">"Shto orar"</string>
    <string name="zen_mode_delete_rule" msgid="8055032645990309096">"Fshi orarin"</string>
    <string name="zen_mode_choose_rule_type" msgid="40993242338494595">"Zgjidh llojin e orarit"</string>
    <string name="zen_mode_delete_rule_confirmation" msgid="6237882294348570283">"Të fshihet rregulli \"<xliff:g id="RULE">%1$s</xliff:g>\"?"</string>
    <string name="zen_mode_delete_rule_button" msgid="4248741120307752294">"Fshi"</string>
    <string name="zen_mode_rule_type_unknown" msgid="3049377282766700600">"I panjohur"</string>
    <string name="zen_mode_app_set_behavior" msgid="1534429320064381355">"Këto cilësime nuk mund të ndryshohen në këtë moment. Një aplikacion (<xliff:g id="APP_NAME">%1$s</xliff:g>) ka aktivizuar automatikisht modalitetin \"Mos shqetëso\" me sjelljen e personalizuar."</string>
    <string name="zen_mode_unknown_app_set_behavior" msgid="2558968232814237874">"Këto cilësime nuk mund të ndryshohen në këtë moment. Një aplikacion ka aktivizuar automatikisht modalitetin \"Mos shqetëso\" me sjelljen e personalizuar."</string>
    <string name="zen_mode_qs_set_behavior" msgid="6200424436456086312">"Këto cilësime nuk mund të ndryshohen në këtë moment. Modaliteti \"Mos shqetëso\" është aktivizuar manualisht me sjelljen e personalizuar."</string>
    <string name="zen_schedule_rule_type_name" msgid="6163149826036287324">"Koha"</string>
    <string name="zen_schedule_rule_enabled_toast" msgid="3379499360390382259">"Rregulli automatik u vendos. Ai do të aktivizojë gjendjen \"Mos shqetëso\" gjatë kohës së vendosur."</string>
    <string name="zen_event_rule_type_name" msgid="6503468472212606158">"Ngjarje"</string>
    <string name="zen_event_rule_enabled_toast" msgid="6910577623330811480">"Rregulli automatik u vendos. Ai do të aktivizojë gjendjen \"Mos shqetëso\" gjatë kohës së vendosur."</string>
    <string name="zen_mode_event_rule_calendar" msgid="8787906563769067418">"Gjatë ngjarjeve për"</string>
    <string name="zen_mode_event_rule_summary_calendar_template" msgid="5135844750232403975">"Gjatë ngjarjeve për <xliff:g id="CALENDAR">%1$s</xliff:g>"</string>
    <string name="zen_mode_event_rule_summary_any_calendar" msgid="4936646399126636358">"çdo kalendar"</string>
    <string name="zen_mode_event_rule_summary_reply_template" msgid="6590671260829837157">"Kur përgjigja është <xliff:g id="REPLY">%1$s</xliff:g>"</string>
    <string name="zen_mode_event_rule_calendar_any" msgid="6485568415998569885">"Çdo kalendar"</string>
    <string name="zen_mode_event_rule_reply" msgid="5166322024212403739">"Kur përgjigja është"</string>
    <string name="zen_mode_event_rule_reply_any_except_no" msgid="8868873496008825961">"\"Po\", \"Ndoshta\" ose \"Jo\""</string>
    <string name="zen_mode_event_rule_reply_yes_or_maybe" msgid="2769656565454495824">"\"Po\" ose \"Ndoshta\""</string>
    <string name="zen_mode_event_rule_reply_yes" msgid="1003598835878784659">"Po"</string>
    <string name="zen_mode_rule_not_found_text" msgid="8963662446092059836">"Rregulli nuk u gjet."</string>
    <string name="zen_mode_rule_summary_enabled_combination" msgid="976098744828219297">"Aktive / <xliff:g id="MODE">%1$s</xliff:g>"</string>
    <string name="zen_mode_rule_summary_provider_combination" msgid="2101201392041867409">"<xliff:g id="PACKAGE">%1$s</xliff:g>\n<xliff:g id="SUMMARY">%2$s</xliff:g>"</string>
    <string name="zen_mode_schedule_rule_days" msgid="3195058680641389948">"Ditët"</string>
    <string name="zen_mode_schedule_rule_days_none" msgid="4954143628634166317">"Asnjë"</string>
    <string name="zen_mode_schedule_rule_days_all" msgid="146511166522076034">"Çdo ditë"</string>
    <string name="zen_mode_schedule_alarm_title" msgid="767054141267122030">"Alarmi mund të anulojë kohën e përfundimit"</string>
    <string name="zen_mode_schedule_alarm_summary" msgid="1673667979187593693">"Orari çaktivizohet kur bie një alarm"</string>
    <string name="zen_mode_custom_behavior_title" msgid="1148856394866360783">"Sjellja e modalitetit \"Mos shqetëso\""</string>
    <string name="zen_mode_custom_behavior_summary_default" msgid="7750128187766412708">"Përdor cilësimet e parazgjedhura"</string>
    <string name="zen_mode_custom_behavior_summary" msgid="7458258833216726120">"Krijo cilësimet të personalizuara për këtë planifikim"</string>
    <string name="zen_mode_custom_behavior_category_title" msgid="4070854282812755247">"Për \"<xliff:g id="SCHEDULE_NAME">%1$s</xliff:g>\""</string>
    <string name="summary_divider_text" msgid="7228986578690919294">", "</string>
    <string name="summary_range_symbol_combination" msgid="5695218513421897027">"<xliff:g id="START">%1$s</xliff:g> - <xliff:g id="END">%2$s</xliff:g>"</string>
    <string name="summary_range_verbal_combination" msgid="8467306662961568656">"<xliff:g id="START">%1$s</xliff:g> deri ditën <xliff:g id="END">%2$s</xliff:g>"</string>
    <string name="zen_mode_calls" msgid="4769117032399813012">"Lejo telefonatat"</string>
    <string name="zen_mode_calls_title" msgid="2905770092665685857">"Telefonata"</string>
    <string name="zen_mode_calls_footer" msgid="2002070641802102110">"Sigurohu që telefonatat e lejuara të lëshojnë tingull, kontrollo nëse pajisja jote është caktuar me zile, dridhje ose heshtje."</string>
    <string name="zen_mode_custom_calls_footer" msgid="4764756801941329281">"Për \"<xliff:g id="SCHEDULE_NAME">%1$s</xliff:g>\" telefonatat hyrëse janë të bllokuara. Mund t\'i rregullosh cilësimet për të lejuar shokët, familjen ose kontakte të tjera të lidhen me ty."</string>
    <string name="zen_mode_starred_contacts_title" msgid="1848464279786960190">"Kontaktet me yll"</string>
    <plurals name="zen_mode_starred_contacts_summary_additional_contacts" formatted="false" msgid="500105380255018671">
      <item quantity="other"><xliff:g id="NUM_PEOPLE">%d</xliff:g> të tjerë</item>
      <item quantity="one">1 tjetër</item>
    </plurals>
    <string name="zen_mode_messages" msgid="6406892731721926170">"Lejo mesazhet"</string>
    <string name="zen_mode_messages_footer" msgid="2616568463646674149">"Sigurohu që mesazhet e lejuara të lëshojnë tingull, kontrollo nëse pajisja jote është caktuar me zile, dridhje ose heshtje."</string>
    <string name="zen_mode_custom_messages_footer" msgid="800067279796770040">"Për \"<xliff:g id="SCHEDULE_NAME">%1$s</xliff:g>\", mesazhet hyrëse janë të bllokuara. Mund t\'i rregullosh cilësimet për të lejuar shokët, familjen ose kontakte të tjera të lidhen me ty."</string>
    <string name="zen_mode_messages_title" msgid="7325983674655986445">"Aplikacionet për SMS, MMS dhe mesazhe"</string>
    <string name="zen_mode_from_anyone" msgid="2638322015361252161">"Nga të gjithë"</string>
    <string name="zen_mode_from_contacts" msgid="2232335406106711637">"Vetëm nga kontaktet"</string>
    <string name="zen_mode_from_starred" msgid="2678345811950997027">"Vetëm nga kontaktet me yll"</string>
    <string name="zen_calls_summary_starred_repeat" msgid="4046151920710059778">"Nga kontaktet me yll dhe telefonuesit e përsëritur"</string>
    <string name="zen_calls_summary_contacts_repeat" msgid="1528716671301999084">"Nga kontaktet ose telefonuesit e përsëritur"</string>
    <string name="zen_calls_summary_repeat_only" msgid="7105261473107715445">"Vetëm nga telefonuesit e përsëritur"</string>
    <string name="zen_mode_from_none" msgid="8219706639954614136">"Asnjë"</string>
    <string name="zen_mode_from_none_calls" msgid="7705112158761351044">"Mos lejo asnjë telefonatë"</string>
    <string name="zen_mode_from_none_messages" msgid="3300937656725582608">"Mos lejo mesazhe"</string>
    <string name="zen_mode_alarms" msgid="6510378757005935647">"Lejo alarmet"</string>
    <string name="zen_mode_alarms_list" msgid="1090332840207025714">"alarmet"</string>
    <string name="zen_mode_media" msgid="4529187475698084320">"Luaj tingujt e medias"</string>
    <string name="zen_mode_media_list" msgid="5483540766397328038">"media"</string>
    <string name="zen_mode_system" msgid="236278770843463810">"Lejo tingujt e prekjes"</string>
    <string name="zen_mode_system_list" msgid="6996104733185177115">"tingujt e prekjes"</string>
    <string name="zen_mode_reminders" msgid="5445657061499098675">"Lejo alarmet rikujtuese"</string>
    <string name="zen_mode_reminders_list" msgid="2853975802240340190">"alarmet rikujtuese"</string>
    <string name="zen_mode_events" msgid="6154853744271591007">"Lejo ngjarjet"</string>
    <string name="zen_mode_bypassing_apps" msgid="5493729796981237881">"Lejo aplikacionet ta anulojnë"</string>
    <string name="zen_mode_bypassing_apps_title" msgid="2072590348079644482">"Përjashtimet e aplikacioneve"</string>
    <plurals name="zen_mode_bypassing_apps_subtext" formatted="false" msgid="3726913165356014788">
      <item quantity="other">Njoftimet nga <xliff:g id="NUMBER">%1$d</xliff:g> aplikacione mund të anulojnë \"Mos shqetëso\"</item>
      <item quantity="one">Njoftimet nga 1 aplikacion mund të anulojnë \"Mos shqetëso\"</item>
    </plurals>
    <string name="zen_mode_events_list" msgid="5571368229052715098">"ngjarjet"</string>
    <string name="zen_mode_all_callers" msgid="2378065871253871057">"çdo person"</string>
    <string name="zen_mode_contacts_callers" msgid="5569804103920394175">"kontaktet"</string>
    <string name="zen_mode_starred_callers" msgid="1023167821338514140">"kontaktet me yll"</string>
    <string name="zen_mode_repeat_callers" msgid="5019521886428322131">"Telefonuesit e përsëritur"</string>
    <string name="zen_mode_repeat_callers_list" msgid="2529895519653237330">"telefonuesit e përsëritur"</string>
    <string name="zen_mode_repeat_callers_title" msgid="8553876328249671783">"Lejo telefonuesit e përsëritur"</string>
    <string name="zen_mode_calls_summary_one" msgid="1711737896388108388">"Lejo nga <xliff:g id="CALLER_TYPE">%1$s</xliff:g>"</string>
    <string name="zen_mode_calls_summary_two" msgid="8476861928783654064">"Lejo nga <xliff:g id="CALLER_TYPE">%1$s</xliff:g> dhe <xliff:g id="CALLERT_TPYE">%2$s</xliff:g>"</string>
    <string name="zen_mode_repeat_callers_summary" msgid="239685342222975733">"Nëse telefonon i njëjti person për herë të dytë në një periudhë prej <xliff:g id="MINUTES">%d</xliff:g> minutash, lejoje"</string>
    <string name="zen_mode_behavior_summary_custom" msgid="168127313238020146">"Personalizo"</string>
    <string name="zen_mode_when" msgid="2767193283311106373">"Aktivizo automatikisht"</string>
    <string name="zen_mode_when_never" msgid="8809494351918405602">"Asnjëherë!"</string>
    <string name="zen_mode_when_every_night" msgid="3122486110091921009">"Çdo natë"</string>
    <string name="zen_mode_when_weeknights" msgid="8354070633893273783">"Natën gjatë javës"</string>
    <string name="zen_mode_start_time" msgid="8102602297273744441">"Koha e nisjes"</string>
    <string name="zen_mode_end_time" msgid="8774327885892705505">"Koha e përfundimit"</string>
    <string name="zen_mode_end_time_next_day_summary_format" msgid="4201521691238728701">"<xliff:g id="FORMATTED_TIME">%s</xliff:g> ditën tjetër"</string>
    <string name="zen_mode_summary_alarms_only_indefinite" msgid="2061973221027570123">"Ndrysho në gjendjen \"vetëm alarmet\" për një kohë të pacaktuar"</string>
    <plurals name="zen_mode_summary_alarms_only_by_minute" formatted="false" msgid="6122003583875424601">
      <item quantity="other">Ndrysho në \"vetëm alarmet\" për <xliff:g id="DURATION">%1$d</xliff:g> minuta (deri në <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g>)</item>
      <item quantity="one">Ndrysho në \"vetëm alarmet\" për një minutë deri në <xliff:g id="FORMATTEDTIME_0">%2$s</xliff:g></item>
    </plurals>
    <plurals name="zen_mode_summary_alarms_only_by_hour" formatted="false" msgid="2407703455581767748">
      <item quantity="other">Kalo në \"vetëm alarme\" për <xliff:g id="DURATION">%1$d</xliff:g> orë deri në <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g></item>
      <item quantity="one">Kalo në \"vetëm alarme\" vetëm për një orë deri në <xliff:g id="FORMATTEDTIME_0">%2$s</xliff:g></item>
    </plurals>
    <string name="zen_mode_summary_alarms_only_by_time" msgid="7465525754879341907">"Ndrysho në gjendjen \"vetëm alarmet\" deri në <xliff:g id="FORMATTEDTIME">%1$s</xliff:g>"</string>
    <string name="zen_mode_summary_always" msgid="6172985102689237703">"Ndrysho te \"ndërprit gjithmonë\""</string>
    <string name="zen_mode_screen_on" msgid="8774571998575673502">"Kur ekrani është aktiv"</string>
    <string name="zen_mode_screen_on_summary" msgid="2208664848367443505">"Lejo që njoftimet e vendosura në heshtje nga \"Mos shqetëso\" të shfaqen në ekran dhe të shfaqin një ikonë të shiritit të statusit"</string>
    <string name="zen_mode_screen_off" msgid="3144446765110327937">"Kur ekrani është joaktiv"</string>
    <string name="zen_mode_screen_off_summary" msgid="7430034620565812258">"Lejo që njoftimet e vendosura në heshtje nga \"Mos shqetëso\" të aktivizojnë ekranin ose të bëjnë që drita të pulsojë"</string>
    <string name="zen_mode_screen_off_summary_no_led" msgid="2826121465026642017">"Lejo që njoftimet e vendosura në heshtje nga \"Mos shqetëso\" të aktivizojnë ekranin"</string>
    <string name="notification_app_settings_button" msgid="6685640230371477485">"Cilësimet e njoftimeve"</string>
    <string name="suggestion_button_text" msgid="3275010948381252006">"Në rregull"</string>
    <string name="device_feedback" msgid="3238056036766293294">"Dërgo përshtypjet për këtë pajisje"</string>
    <string name="restr_pin_enter_admin_pin" msgid="1085834515677448072">"Fut kodin PIN të administratorit"</string>
    <string name="switch_on_text" msgid="1124106706920572386">"Aktivizuar"</string>
    <string name="switch_off_text" msgid="1139356348100829659">"Joaktiv"</string>
    <string name="screen_pinning_title" msgid="2292573232264116542">"Gozhdimi i ekranit"</string>
    <string name="screen_pinning_description" msgid="1110847562111827766">"Kur ky funksion është i aktivizuar, mund të përdorësh gozhdimin e ekranit për të mbajtur pamjen aktuale të ekranit deri sa ta anulosh gozhdimin.\n\nPër të përdorur gozhdimin e ekranit:\n\n1. Sigurohu që gozhdimi i ekranit është i aktivizuar\n\n2. Hap \"Përmbledhja\"\n\n3. Trokit tek ikona e aplikacionit në krye të ekranit dhe më pas trokit te \"Gozhdo\""</string>
    <string name="screen_pinning_unlock_pattern" msgid="8282268570060313339">"Kërko motivin e shkyçjes para anulimit të mbërthimit"</string>
    <string name="screen_pinning_unlock_pin" msgid="8757588350454795286">"Zhgozhdimi kërkon PIN-in"</string>
    <string name="screen_pinning_unlock_password" msgid="2514079566873826434">"Kërko fjalëkalim para heqjes nga gozhdimi"</string>
    <string name="screen_pinning_unlock_none" msgid="3814188275713871856">"Kyçe pajisjen kur heq gozhdimin"</string>
    <string name="opening_paragraph_delete_profile_unknown_company" msgid="2232461523882170874">"Ky profil pune menaxhohet nga:"</string>
    <string name="managing_admin" msgid="8843802210377459055">"I menaxhuar nga <xliff:g id="ADMIN_APP_LABEL">%s</xliff:g>"</string>
    <string name="experimental_preference" msgid="7083015446690681376">"(Eksperimentale)"</string>
    <string name="encryption_interstitial_header" msgid="468015813904595613">"Nisje e sigurt"</string>
    <string name="encryption_continue_button" msgid="1121880322636992402">"Vazhdo"</string>
    <string name="encryption_interstitial_message_pin" msgid="2317181134653424679">"Mund ta mbrosh edhe më shumë këtë pajisje duke kërkuar kodin PIN para se të niset. Deri sa pajisja të niset, ajo nuk mund të marrë telefonata, mesazhe apo njoftime, duke përfshirë alarme. \n\nKjo ndihmon për mbrojtjen e të dhënave në pajisjet e humbura ose të vjedhura. Të kërkohet kodi PIN për të nisur pajisjen tënde?"</string>
    <string name="encryption_interstitial_message_pattern" msgid="7081249914068568570">"Mund ta mbrosh edhe më tepër këtë pajisje duke kërkuar motivin tënd para se të niset. Deri sa pajisja të niset, ajo nuk mund të marrë telefonata, mesazhe apo njoftime, përfshirë alarmet. \n\nKjo ndihmon për mbrojtjen e të dhënave në pajisjet e humbura ose të vjedhura. Të kërkohet motivi për të nisur pajisjen?"</string>
    <string name="encryption_interstitial_message_password" msgid="7796567133897436443">"Mund ta mbrosh edhe më tepër këtë pajisje duke kërkuar fjalëkalimin para se të niset. Deri sa pajisja të niset, ajo nuk mund të marrë telefonata, mesazhe apo njoftime, përfshirë alarmet. \n\nKjo ndihmon për mbrojtjen e të dhënave në pajisjet e humbura ose të vjedhura. Të kërkohet një fjalëkalim për të nisur pajisjen?"</string>
    <string name="encryption_interstitial_message_pin_for_fingerprint" msgid="4550632760119547492">"Përveç përdorimit të shenjave të gishtave për të shkyçur pajisjen tënde, mund ta mbrosh edhe më shumë këtë pajisje duke kërkuar kodin PIN para se të niset. Deri sa pajisja të niset, ajo nuk mund të marrë telefonata, mesazhe apo njoftime, duke përfshirë alarmet.\n\nKjo ndihmon për mbrojtjen e të dhënave në pajisjet e humbura ose të vjedhura. Të kërkohet kodi PIN për të nisur pajisjen?"</string>
    <string name="encryption_interstitial_message_pattern_for_fingerprint" msgid="932184823193006087">"Përveç përdorimit të shenjave të gishtave për të shkyçur pajisjen tënde, mund ta mbrosh edhe më shumë këtë pajisje duke kërkuar motivin para se të niset. Deri sa pajisja të niset, ajo nuk mund të marrë telefonata, mesazhe apo njoftime, duke përfshirë alarmet.\n\nKjo ndihmon për mbrojtjen e të dhënave në pajisjet e humbura ose të vjedhura. Të kërkohet motivi për të nisur pajisjen?"</string>
    <string name="encryption_interstitial_message_password_for_fingerprint" msgid="5560954719370251702">"Përveç përdorimit të gjurmës të gishtit për të shkyçur pajisjen tënde, mund ta mbrosh edhe më shumë këtë pajisje duke kërkuar fjalëkalimin tënd para se të niset. Deri sa pajisja të niset, ajo nuk mund të marrë telefonata, mesazhe apo njoftime, duke përfshirë alarmet.\n\nKjo ndihmon për mbrojtjen e të dhënave në pajisjet e humbura ose të vjedhura. Të kërkohet fjalëkalimi për të nisur pajisjen?"</string>
    <string name="encryption_interstitial_message_pin_for_face" msgid="2017438765366716760">"Përveç përdorimit të fytyrës për të shkyçur pajisjen tënde, mund ta mbrosh edhe më shumë këtë pajisje duke kërkuar fjalëkalimin tënd para se të niset. Deri sa pajisja të niset, ajo nuk mund të marrë telefonata, mesazhe apo njoftime, duke përfshirë alarmet.\n\nKjo ndihmon për mbrojtjen e të dhënave në pajisjet e humbura ose të vjedhura. Të kërkohet kodi PIN për të nisur pajisjen?"</string>
    <string name="encryption_interstitial_message_pattern_for_face" msgid="3551827507967661552">"Përveç përdorimit të fytyrës për të shkyçur pajisjen tënde, mund ta mbrosh edhe më shumë këtë pajisje duke kërkuar fjalëkalimin tënd para se të niset. Deri sa pajisja të niset, ajo nuk mund të marrë telefonata, mesazhe apo njoftime, duke përfshirë alarmet.\n\nKjo ndihmon për mbrojtjen e të dhënave në pajisjet e humbura ose të vjedhura. Të kërkohet motivi për të nisur pajisjen?"</string>
    <string name="encryption_interstitial_message_password_for_face" msgid="3452793542112093614">"Përveç përdorimit të fytyrës për të shkyçur pajisjen tënde, mund ta mbrosh edhe më shumë këtë pajisje duke kërkuar fjalëkalimin tënd para se të niset. Deri sa pajisja të niset, ajo nuk mund të marrë telefonata, mesazhe apo njoftime, duke përfshirë alarmet.\n\nKjo ndihmon për mbrojtjen e të dhënave në pajisjet e humbura ose të vjedhura. Të kërkohet fjalëkalimi për të nisur pajisjen?"</string>
    <string name="encryption_interstitial_yes" msgid="4439509435889513411">"Po"</string>
    <string name="encryption_interstitial_no" msgid="8935031349097025137">"Jo"</string>
    <string name="restricted_true_label" msgid="4761453839409220473">"I kufizuar"</string>
    <string name="restricted_false_label" msgid="3279282180297058755">"Aplikacioni mund të përdorë baterinë në sfond"</string>
    <string name="encrypt_talkback_dialog_require_pin" msgid="8299960550048989807">"Të kërkohet kodi PIN?"</string>
    <string name="encrypt_talkback_dialog_require_pattern" msgid="1499790256154146639">"Të kërkohet motivi?"</string>
    <string name="encrypt_talkback_dialog_require_password" msgid="8841994614218049215">"Të kërkohet fjalëkalim?"</string>
    <string name="encrypt_talkback_dialog_message_pin" msgid="7582096542997635316">"Kur fut kodin PIN për të nisur këtë pajisje, nuk do të ofrohen ende shërbimet e qasshmërisë si <xliff:g id="SERVICE">%1$s</xliff:g>."</string>
    <string name="encrypt_talkback_dialog_message_pattern" msgid="2020083142199612743">"Kur fut motivin për të nisur këtë pajisje, shërbimet e qasjes si <xliff:g id="SERVICE">%1$s</xliff:g> nuk do të jenë ende të gatshme."</string>
    <string name="encrypt_talkback_dialog_message_password" msgid="4155875981789127796">"Kur fut fjalëkalimin tënd për të nisur këtë pajisje, shërbimet si <xliff:g id="SERVICE">%1$s</xliff:g> nuk do të jenë ende të disponueshëm."</string>
    <string name="direct_boot_unaware_dialog_message" msgid="2433632805847985867">"Shënim: Nëse e rinis telefonin dhe ke caktuar një kyçje të ekranit, ky aplikacion nuk mund të niset derisa të shkyçësh telefonin"</string>
    <string name="imei_information_title" msgid="8499085421609752290">"Informacioni i IMEI-t"</string>
    <string name="imei_information_summary" msgid="2074095606556565233">"Informacioni përkatës i IMEI-t"</string>
    <string name="slot_number" msgid="3762676044904653577">"(Foleja <xliff:g id="SLOT_NUM">%1$d</xliff:g>)"</string>
    <string name="launch_by_default" msgid="1840761193189009248">"Hap me parazgjedhje"</string>
    <string name="app_launch_domain_links_title" msgid="1160925981363706090">"Lidhjet po hapen"</string>
    <string name="app_launch_open_domain_urls_title" msgid="8914721351596745701">"Hap lidhjet e mbështetura"</string>
    <string name="app_launch_open_domain_urls_summary" msgid="5367573364240712217">"Hape pa pyetur"</string>
    <string name="app_launch_supported_domain_urls_title" msgid="8250695258211477480">"Lidhjet e mbështetura"</string>
    <string name="app_launch_other_defaults_title" msgid="2516812499807835178">"Parazgjedhjet e tjera"</string>
    <string name="storage_summary_format" msgid="5419902362347539755">"<xliff:g id="SIZE">%1$s</xliff:g> përdorur në <xliff:g id="STORAGE_TYPE">%2$s</xliff:g>"</string>
    <string name="storage_type_internal" msgid="6042049833565674948">"Hapësira e brendshme për ruajtje"</string>
    <string name="storage_type_external" msgid="7738894330670001898">"Hap. e jashtme ruajtëse"</string>
    <string name="data_summary_format" msgid="6213211533341068366">"<xliff:g id="SIZE">%1$s</xliff:g> të përdorura që nga <xliff:g id="DATE">%2$s</xliff:g>"</string>
    <string name="storage_used" msgid="7128074132917008743">"Hapësirë ruajtëse e përdorur"</string>
    <string name="change" msgid="6657848623929839991">"Ndrysho"</string>
    <string name="change_storage" msgid="600475265207060436">"Ndrysho hapësirën ruajtëse"</string>
    <string name="notifications_label" msgid="2872668710589600731">"Njoftimet"</string>
    <string name="notifications_enabled" msgid="6983396130566021385">"Aktive"</string>
    <string name="notifications_enabled_with_info" msgid="5669544704839269901">"<xliff:g id="NOTIFICATIONS_SENT">%1$s</xliff:g> / <xliff:g id="NOTIFICATIONS_CATEGORIES_OFF">%2$s</xliff:g>"</string>
    <string name="notifications_disabled" msgid="1262114548434938079">"Joaktiv"</string>
    <string name="notifications_partly_blocked" msgid="592071133950126656">"<xliff:g id="COUNT_0">%1$d</xliff:g> nga <xliff:g id="COUNT_1">%2$d</xliff:g> kategori të çaktivizuara"</string>
    <string name="notifications_silenced" msgid="4728603513072110381">"Në heshtje"</string>
    <string name="notifications_redacted" msgid="4493588975742803160">"Përmbajtja delikate jo në ekranin e kyçjes"</string>
    <string name="notifications_hidden" msgid="3619610536038757468">"Jo në ekranin e kyçjes"</string>
    <string name="notifications_priority" msgid="1066342037602085552">"\"Mos shqetëso\" u anulua"</string>
    <string name="notifications_summary_divider" msgid="9013807608804041387">" / "</string>
    <string name="notification_summary_level" msgid="2726571692704140826">"Niveli %d"</string>
    <string name="notification_summary_channel" msgid="5831124672372023524">"<xliff:g id="CHANNEL_NAME">%1$s</xliff:g> • <xliff:g id="GROUP_NAME">%2$s</xliff:g>"</string>
    <plurals name="notifications_categories_off" formatted="false" msgid="5583365573683409754">
      <item quantity="other"><xliff:g id="COUNT_1">%d</xliff:g> kategori u çaktivizuan</item>
      <item quantity="one"><xliff:g id="COUNT_0">%d</xliff:g> kategori u çaktivizua</item>
    </plurals>
    <plurals name="permissions_summary" formatted="false" msgid="6402730318075959117">
      <item quantity="other"><xliff:g id="COUNT_1">%d</xliff:g> leje u dhanë</item>
      <item quantity="one"><xliff:g id="COUNT_0">%d</xliff:g> leje u dha</item>
    </plurals>
    <plurals name="runtime_permissions_summary" formatted="false" msgid="1564663886246010959">
      <item quantity="other"><xliff:g id="COUNT_2">%d</xliff:g> nga <xliff:g id="COUNT_3">%d</xliff:g> leje të dhëna</item>
      <item quantity="one"><xliff:g id="COUNT_0">%d</xliff:g> nga <xliff:g id="COUNT_1">%d</xliff:g> leje e dhënë</item>
    </plurals>
    <plurals name="runtime_permissions_additional_count" formatted="false" msgid="931276038884210752">
      <item quantity="other"><xliff:g id="COUNT_1">%d</xliff:g> leje shtesë</item>
      <item quantity="one"><xliff:g id="COUNT_0">%d</xliff:g> leje shtesë</item>
    </plurals>
    <string name="runtime_permissions_summary_no_permissions_granted" msgid="1679758182657005375">"Nuk është dhënë leje"</string>
    <string name="runtime_permissions_summary_no_permissions_requested" msgid="7655100570513818534">"Nuk është kërkuar leje"</string>
    <string name="filter_all_apps" msgid="1988403195820688644">"Të gjitha apl."</string>
    <string name="filter_enabled_apps" msgid="5395727306799456250">"Aplikacionet e instaluara"</string>
    <string name="filter_instant_apps" msgid="574277769963965565">"Aplikacionet e çastit"</string>
    <string name="filter_personal_apps" msgid="3277727374174355971">"Personale"</string>
    <string name="filter_work_apps" msgid="24519936790795574">"Punë"</string>
    <string name="filter_notif_all_apps" msgid="2299049859443680242">"Aplikacionet: Të gjitha"</string>
    <string name="filter_notif_blocked_apps" msgid="3383043508771300704">"Çaktivizuar"</string>
    <string name="filter_notif_urgent_channels" msgid="3972473613117159653">"Kategoritë: Rëndësia urgjente"</string>
    <string name="filter_notif_low_channels" msgid="4128487387390004604">"Kategoritë: Përparësia e ulët"</string>
    <string name="filter_notif_blocked_channels" msgid="5880190882221644289">"Kategoritë: Të çaktivizuara"</string>
    <string name="filter_notif_dnd_channels" msgid="1817930848881696728">"Kategoritë: Anulon \"Mos shqetëso\""</string>
    <string name="advanced_apps" msgid="4812975097124803873">"Të përparuara"</string>
    <string name="configure_apps" msgid="6685680790825882528">"Konfiguro aplikacionet"</string>
    <string name="unknown_app" msgid="5275921288718717656">"Aplikacion i panjohur"</string>
    <string name="app_permissions" msgid="5584182129908141622">"Menaxheri i lejeve"</string>
    <string name="app_permissions_summary" msgid="5163974162150406324">"Apl. që marrin të dhëna nga <xliff:g id="APPS">%1$s</xliff:g>"</string>
    <string name="tap_to_wake" msgid="7211944147196888807">"Trokit për ta zgjuar"</string>
    <string name="tap_to_wake_summary" msgid="4341387904987585616">"Trokit dy herë diku në ekran për ta zgjuar pajisjen."</string>
    <string name="domain_urls_title" msgid="3132983644568821250">"Lidhjet po hapen"</string>
    <string name="domain_urls_summary_none" msgid="2639588015479657864">"Mos i hap lidhjet e mbështetura"</string>
    <string name="domain_urls_summary_one" msgid="3704934031930978405">"Hap <xliff:g id="DOMAIN">%s</xliff:g>"</string>
    <string name="domain_urls_summary_some" msgid="3950089361819428455">"Hap <xliff:g id="DOMAIN">%s</xliff:g> dhe URL të tjera"</string>
    <string name="domain_urls_apps_summary_off" msgid="1833056772600031220">"Nuk ka asnjë aplikacion që hap lidhjet e mbështetura"</string>
    <plurals name="domain_urls_apps_summary_on" formatted="false" msgid="240214361240709399">
      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> aplikacione që hapin lidhjet e mbështetura</item>
      <item quantity="one">Një aplikacion që hap lidhjet e mbështetura</item>
    </plurals>
    <string name="app_link_open_always" msgid="2474058700623948148">"Hap në këtë aplikacion"</string>
    <string name="app_link_open_ask" msgid="7800878430190575991">"Pyet çdo herë"</string>
    <string name="app_link_open_never" msgid="3407647600352398543">"Mos e hap në këtë aplikacion"</string>
    <string name="default_apps_title" msgid="1660450272764331490">"Të parazgjedhura"</string>
    <string name="default_for_work" msgid="9152194239366247932">"Të parazgjedhura për punën"</string>
    <string name="assist_and_voice_input_title" msgid="1733165754793221197">"Asistenti dhe hyrja zanore"</string>
    <string name="default_assist_title" msgid="8868488975409247921">"Aplikacioni i asistentit"</string>
    <string name="assistant_security_warning_title" msgid="8673079231955467177">"Bëje <xliff:g id="ASSISTANT_APP_NAME">%s</xliff:g> asistentin tënd?"</string>
    <string name="assistant_security_warning" msgid="8498726261327239136">"Asistenti do të jetë në gjendje të lexojë informacion rreth aplikacioneve në përdorim në sistemin tënd, duke përfshirë informacionin e dukshëm në ekran ose të qasshëm brenda aplikacioneve."</string>
    <string name="assistant_security_warning_agree" msgid="7710290206928033908">"Pranoj"</string>
    <string name="assistant_security_warning_disagree" msgid="877419950830205913">"Nuk pranoj"</string>
    <string name="choose_voice_input_title" msgid="975471367067718019">"Zgjidh hyrjen zanore"</string>
    <string name="default_browser_title" msgid="8101772675085814670">"Aplikacioni për shfletim"</string>
    <string name="default_browser_title_none" msgid="2124785489953628553">"Nuk ka asnjë shfletues të parazgjedhur"</string>
    <string name="default_phone_title" msgid="282005908059637350">"Aplikacioni \"Telefoni\""</string>
    <string name="default_app" msgid="6864503001385843060">"(I parazgjedhur)"</string>
    <string name="system_app" msgid="9068313769550747372">"(Sistemi)"</string>
    <string name="system_default_app" msgid="3091113402349739037">"(Parazgjedhja e sistemit)"</string>
    <string name="apps_storage" msgid="4353308027210435513">"Hapësira ruajtëse e apl."</string>
    <string name="usage_access" msgid="5479504953931038165">"Qasja në përdorim"</string>
    <string name="permit_usage_access" msgid="4012876269445832300">"Lejoje qasjen te përdorimi"</string>
    <string name="app_usage_preference" msgid="7065701732733134991">"Preferencat e përdorimit të aplikacioneve"</string>
    <string name="time_spent_in_app_pref_title" msgid="9124796405314626532">"Koha para ekranit"</string>
    <string name="usage_access_description" msgid="1352111094596416795">"Qasja në përdorim lejon që një aplikacion të gjurmojë se çfarë përdorin aplikacionet e tjera dhe sa shpesh e përdorin, si edhe operatorin celular, cilësimet e gjuhës dhe detaje të tjera."</string>
    <string name="memory_settings_title" msgid="7490541005204254222">"Memoria"</string>
    <string name="memory_details_title" msgid="8542565326053693320">"Detajet e memories"</string>
    <string name="always_running" msgid="6042448320077429656">"Gjithmonë në funksionim (<xliff:g id="PERCENTAGE">%s</xliff:g>)"</string>
    <string name="sometimes_running" msgid="6611250683037700864">"Përdoret ndonjëherë (<xliff:g id="PERCENTAGE">%s</xliff:g>)"</string>
    <string name="rarely_running" msgid="348413460168817458">"Përdoret rrallë (<xliff:g id="PERCENTAGE">%s</xliff:g>)"</string>
    <string name="memory_max_use" msgid="6874803757715963097">"Maksimale"</string>
    <string name="memory_avg_use" msgid="7382015389130622870">"Mesatare"</string>
    <string name="memory_max_desc" msgid="2861832149718335864">"Maksimale <xliff:g id="MEMORY">%1$s</xliff:g>"</string>
    <string name="memory_avg_desc" msgid="1551240906596518412">"Mesatarisht <xliff:g id="MEMORY">%1$s</xliff:g>"</string>
    <string name="memory_use_running_format" msgid="4172488041800743760">"<xliff:g id="MEMORY">%1$s</xliff:g> / <xliff:g id="RUNNING">%2$s</xliff:g>"</string>
    <string name="process_format" msgid="77905604092541454">"<xliff:g id="APP_NAME">%1$s</xliff:g> (<xliff:g id="COUNT">%2$d</xliff:g>)"</string>
    <string name="high_power_apps" msgid="3459065925679828230">"Optimizimi i baterisë"</string>
    <string name="additional_battery_info" msgid="4754099329165411970">"Sinjalizimet për përdorimin"</string>
    <string name="show_all_apps" msgid="1512506948197818534">"Shfaq përdorimin e plotë të pajisjes"</string>
    <string name="hide_extra_apps" msgid="5016497281322459633">"Shfaq përdorimin e aplikacionit"</string>
    <plurals name="power_high_usage_summary" formatted="false" msgid="467347882627862744">
      <item quantity="other"><xliff:g id="NUMBER">%2$d</xliff:g> aplikacione kanë sjellje jonormale</item>
      <item quantity="one"><xliff:g id="APP">%1$s</xliff:g> ka sjellje jonormale</item>
    </plurals>
    <plurals name="power_high_usage_title" formatted="false" msgid="3826660033363082922">
      <item quantity="other">Aplikacionet po shkarkojnë baterinë</item>
      <item quantity="one"><xliff:g id="APP">%1$s</xliff:g> po shkarkon baterinë</item>
    </plurals>
    <string name="high_power_filter_on" msgid="3222265297576680099">"Jo të optimizuara"</string>
    <string name="high_power_on" msgid="6216293998227583810">"Nuk është i optimizuar"</string>
    <string name="high_power_off" msgid="3393904131961263278">"Optimizimi i përdorimit të baterisë"</string>
    <string name="high_power_system" msgid="7362862974428225301">"Optimizimi i baterisë nuk ofrohet"</string>
    <string name="high_power_desc" msgid="6283926163708585760">"Mos zbato optimizimin e baterisë. Kjo mund ta shkarkojë baterinë më shpejt."</string>
    <string name="high_power_prompt_title" msgid="6358673688590282655">"Të lejohet që aplikacioni të ekzekutohet gjithmonë në sfond?"</string>
    <string name="high_power_prompt_body" msgid="1031422980602565049">"Lejimi që <xliff:g id="APP_NAME">%1$s</xliff:g> të ekzekutohet gjithmonë në sfond mund të zvogëlojë kohëzgjatjen e baterisë. \n\nKëtë mund ta ndryshosh më vonë nga Cilësimet &gt; Aplikacionet dhe njoftimet."</string>
    <string name="battery_summary" msgid="8044042095190688654">"<xliff:g id="PERCENTAGE">%1$s</xliff:g> përdorim që prej karikimit të fundit të plotë"</string>
    <string name="battery_power_management" msgid="5571519699679107523">"Menaxhimi i energjisë"</string>
    <string name="no_battery_summary" msgid="3528036835462846814">"Asnjë përdorim i baterisë që prej karikimit të fundit të plotë"</string>
    <string name="app_notification_preferences" msgid="1599319335092722613">"Cilësimet e aplikacionit"</string>
    <string name="system_ui_settings" msgid="579824306467081123">"Shfaq sintonizuesin SystemUI"</string>
    <string name="additional_permissions" msgid="6463784193877056080">"Lejet shtesë"</string>
    <string name="additional_permissions_more" msgid="3538612272673191451">"<xliff:g id="COUNT">%1$d</xliff:g> të tjera"</string>
    <string name="share_remote_bugreport_dialog_title" msgid="1124840737776588602">"Të ndahet raporti i defektit në kod?"</string>
    <string name="share_remote_bugreport_dialog_message_finished" msgid="4973886976504823801">"Administratori i teknologjisë së informacionit kërkoi një raport të defekteve në kod për të ndihmuar me zgjidhjen e problemeve. Aplikacioni dhe të dhënat mund të ndahen."</string>
    <string name="share_remote_bugreport_dialog_message" msgid="3495929560689435496">"Administratori i teknologjisë së informacionit kërkoi një raport të defekteve në kod për të ndihmuar me zgjidhjen e problemeve. Aplikacioni dhe të dhënat mund të ndahen dhe kjo mund të ngadalësojë përkohësisht pajisjen tënde."</string>
    <string name="sharing_remote_bugreport_dialog_message" msgid="5859287696666024466">"Ky raport i defektit në kod po ndahet me administratorin tënd të IT-së. Kontaktoje atë për më shumë detaje."</string>
    <string name="share_remote_bugreport_action" msgid="532226159318779397">"Shpërndaj"</string>
    <string name="decline_remote_bugreport_action" msgid="518720235407565134">"Refuzo"</string>
    <string name="usb_use_charging_only" msgid="4800495064747543954">"Nuk ka transferim të të dhënave"</string>
    <string name="usb_use_charging_only_desc" msgid="3066256793008540627">"Vetëm karikoje këtë pajisje"</string>
    <string name="usb_use_power_only" msgid="3236391691786786070">"Ngarko pajisjen e lidhur"</string>
    <string name="usb_use_file_transfers" msgid="1223134119354320726">"Transferimi i skedarëve"</string>
    <string name="usb_use_file_transfers_desc" msgid="4235764784331804488">"Transfero skedarët te një pajisje tjetër"</string>
    <string name="usb_use_photo_transfers" msgid="8192719651229326283">"PTP"</string>
    <string name="usb_use_photo_transfers_desc" msgid="2963034811151325996">"Transfero foto ose dosje, nëse MTP-ja nuk mbështetet (PTP)"</string>
    <string name="usb_use_tethering" msgid="3944506882789422118">"Ndarja e internetit nëpërmjet USB-së"</string>
    <string name="usb_use_MIDI" msgid="5116404702692483166">"MIDI"</string>
    <string name="usb_use_MIDI_desc" msgid="8473936990076693175">"Përdore këtë pajisje si MIDI"</string>
    <string name="usb_use" msgid="3372728031108932425">"Opsionet e përdorimit të USB-së:"</string>
    <string name="usb_default_label" msgid="2211094045594574774">"Konfigurimi i parazgjedhur i USB-së"</string>
    <string name="usb_default_info" msgid="8864535445796200695">"Kur të lidhet një pajisje tjetër dhe telefoni yt të jetë i shkyçur, do të zbatohen këto cilësime. Lidhe vetëm me pajisje të besuara."</string>
    <string name="usb_pref" msgid="1400617804525116158">"USB"</string>
    <string name="usb_preference" msgid="7394265019817945275">"Preferencat e USB-së"</string>
    <string name="usb_control_title" msgid="4404322722995917160">"USB-ja kontrollohet nga"</string>
    <string name="usb_control_host" msgid="2276710819046647200">"Pajisja e lidhur"</string>
    <string name="usb_control_device" msgid="5821511964163469463">"Kjo pajisje"</string>
    <string name="usb_switching" msgid="8995313698715545619">"Po ndërrohet..."</string>
    <string name="usb_switching_failed" msgid="4156073015692409651">"Nuk mund të ndërrohej"</string>
    <string name="usb_summary_charging_only" msgid="7544327009143659751">"Karikimi i kësaj pajisjeje"</string>
    <string name="usb_summary_power_only" msgid="1996391096369798526">"Pajisja e lidhur po karikohet"</string>
    <string name="usb_summary_file_transfers" msgid="6925168380589489645">"Transferimi i skedarëve"</string>
    <string name="usb_summary_tether" msgid="951190049557074535">"Ndarja e internetit nëpërmjet USB-së"</string>
    <string name="usb_summary_photo_transfers" msgid="665584667685030007">"PTP"</string>
    <string name="usb_summary_MIDI" msgid="2399066753961085360">"MIDI"</string>
    <string name="usb_summary_file_transfers_power" msgid="7700800611455849806">"Transferimi i skedarëve dhe furnizimi me energji"</string>
    <string name="usb_summary_tether_power" msgid="5825335393952752238">"Ndarja e internetit dhe furnizimi i energjisë nëpërmjet USB-së"</string>
    <string name="usb_summary_photo_transfers_power" msgid="6826058111908423069">"PTP dhe furnizimi me energji"</string>
    <string name="usb_summary_MIDI_power" msgid="3308250484012677596">"MIDI dhe furnizimi me energji"</string>
    <string name="background_check_pref" msgid="7550258400138010979">"Kontrolli i sfondit"</string>
    <string name="background_check_title" msgid="4534254315824525593">"Qasje e plotë në sfond"</string>
    <string name="assist_access_context_title" msgid="2269032346698890257">"Përdor tekstin nga ekrani"</string>
    <string name="assist_access_context_summary" msgid="1991421283142279560">"Lejo që aplikacioni i asistentit të qaset te përmbajtjet e ekranit si tekst"</string>
    <string name="assist_access_screenshot_title" msgid="4034721336291215819">"Përdor pamjen e ekranit"</string>
    <string name="assist_access_screenshot_summary" msgid="6761636689013259901">"Lejo që aplikacioni i asistentit të qaset te një imazh i ekranit"</string>
    <string name="assist_flash_title" msgid="506661221230034891">"Pulso ekranin"</string>
    <string name="assist_flash_summary" msgid="9160668468824099262">"Pulso këndet e ekranit kur aplikacioni ndihmës qaset në tekstin nga ekrani apo pamja e ekranit"</string>
    <string name="assist_footer" msgid="1982791172085896864">"Aplikacionet e asistentit të ndihmojnë bazuar në informacionet nga ekrani ku je duke e shikuar. Disa aplikacione mbështesin shërbimet e nisësit dhe të hyrjes me zë për të të siguruar një ndihmë të integruar."</string>
    <string name="average_memory_use" msgid="829566450150198512">"Memoria mesatare në përdorim"</string>
    <string name="maximum_memory_use" msgid="7493720799710132496">"Përdorimi maksimal i memories"</string>
    <string name="memory_usage" msgid="1781358557214390033">"Përdorimi i memories"</string>
    <string name="app_list_memory_use" msgid="6987417883876419338">"Përdorimi i aplikacionit"</string>
    <string name="memory_details" msgid="5943436005716991782">"Detajet"</string>
    <string name="memory_use_summary" msgid="5608257211903075754">"Memoria mesatare e përdorur në 3 orët e fundit është <xliff:g id="SIZE">%1$s</xliff:g>"</string>
    <string name="no_memory_use_summary" msgid="2016900536806235588">"Nuk u përdor memoria në 3 orët e fundit"</string>
    <string name="sort_avg_use" msgid="3998036180505143129">"Rendit sipas përdorimit mesatar"</string>
    <string name="sort_max_use" msgid="4629247978290075124">"Rendit sipas përdorimit maksimal"</string>
    <string name="memory_performance" msgid="5661005192284103281">"Performanca"</string>
    <string name="total_memory" msgid="2017287600738630165">"Memoria totale"</string>
    <string name="average_used" msgid="5338339266517245782">"Mesatarja e përdorur (%)"</string>
    <string name="free_memory" msgid="4003936141603549746">"E lirë"</string>
    <string name="memory_usage_apps" msgid="5650192998273294098">"Memoria e përdorur nga aplikacionet"</string>
    <plurals name="memory_usage_apps_summary" formatted="false" msgid="6089210945574265774">
      <item quantity="other"><xliff:g id="COUNT">%1$d</xliff:g> aplikacione përdorën memorien në <xliff:g id="DURATION_1">%2$s</xliff:g> e fundit</item>
      <item quantity="one">1 aplikacion përdori memorien në <xliff:g id="DURATION_0">%2$s</xliff:g> e fundit</item>
    </plurals>
    <string name="running_frequency" msgid="6622624669948277693">"Frekuenca"</string>
    <string name="memory_maximum_usage" msgid="6513785462055278341">"Përdorimi maksimal"</string>
    <string name="no_data_usage" msgid="9131454024293628063">"Nuk janë përdorur të dhëna"</string>
    <string name="zen_access_warning_dialog_title" msgid="1198189958031157142">"Të lejohet qasja te \"Mos shqetëso\" për \"<xliff:g id="APP">%1$s</xliff:g>\"?"</string>
    <string name="zen_access_warning_dialog_summary" msgid="4015885767653010873">"Aplikacioni do të jetë në gjendje të aktivizojë/çaktivizojë opsionin \"Mos shqetëso\", si dhe të bëjë ndryshimet në cilësimet përkatëse."</string>
    <string name="zen_access_disabled_package_warning" msgid="302820100078584431">"Duhet të qëndrojë e aktivizuar sepse qasja e njoftimeve është e aktivizuar"</string>
    <string name="zen_access_revoke_warning_dialog_title" msgid="558779234015793950">"Të anulohet qasja te \"Mos shqetëso\" për <xliff:g id="APP">%1$s</xliff:g>?"</string>
    <string name="zen_access_revoke_warning_dialog_summary" msgid="5518216907304930148">"Të gjitha rregullat e \"Mos shqetëso\" të krijuara nga ky aplikacion, do të hiqen."</string>
    <string name="ignore_optimizations_on" msgid="6915689518016285116">"Mos optimizo"</string>
    <string name="ignore_optimizations_off" msgid="6153196256410296835">"Optimizo"</string>
    <string name="ignore_optimizations_on_desc" msgid="3549930955839111652">"Mund ta shkarkojë baterinë më shpejt. Aplikacioni nuk do të kufizohet më shumë nga përdorimi i baterisë në sfond."</string>
    <string name="ignore_optimizations_off_desc" msgid="5255731062045426544">"Rekomandohet për një jetëgjatësi më të mirë të baterisë"</string>
    <string name="ignore_optimizations_title" msgid="2829637961185027768">"Lejo që <xliff:g id="APP">%s</xliff:g> t\'i injorojë optimizimet e baterisë?"</string>
    <string name="app_list_preference_none" msgid="108006867520327904">"Asnjë"</string>
    <string name="work_profile_usage_access_warning" msgid="2918050775124911939">"Çaktivizimi i qasjes së përdorimit për këtë aplikacion nuk e parandalon administratorin tënd të monitorojë përdorimin e të dhënave për aplikacionet në profilin tënd të punës"</string>
    <string name="accessibility_lock_screen_progress" msgid="2408292742980383166">"<xliff:g id="COUNT_0">%1$d</xliff:g> nga <xliff:g id="COUNT_1">%2$d</xliff:g> karaktere u përdorën"</string>
    <string name="draw_overlay" msgid="6564116025404257047">"Shfaq mbi aplikacionet e tjera"</string>
    <string name="system_alert_window_settings" msgid="8466613169103527868">"Shfaq mbi aplikacionet e tjera"</string>
    <string name="system_alert_window_apps_title" msgid="7005760279028569491">"Aplikacionet"</string>
    <string name="system_alert_window_access_title" msgid="6297115362542361241">"Shfaq mbi aplikacionet e tjera"</string>
    <string name="permit_draw_overlay" msgid="7456536798718633432">"Lejo shfaqjen mbi aplikacionet e tjera"</string>
    <string name="allow_overlay_description" msgid="8961670023925421358">"Lejoje këtë aplikacion të shfaqet në krye të aplikacioneve të tjera që po përdor. Kjo mund të ndërhyjë me përdorimin tënd të atyre aplikacioneve ose mund të ndryshojë mënyrën se si ata duken ose sillen."</string>
    <string name="keywords_vr_listener" msgid="7441221822576384680">"vr realitet virtual dëgjues stereo ndihmues shërbim"</string>
    <string name="keywords_system_alert_window" msgid="5049498015597864850">"sistem sinjalizim dritare dialog shfaq mbi aplikacionet e tjera"</string>
    <string name="overlay_settings" msgid="6930854109449524280">"Shfaq mbi aplikacionet e tjera"</string>
    <string name="system_alert_window_summary" msgid="602892301318324492">"<xliff:g id="COUNT_0">%1$d</xliff:g> nga <xliff:g id="COUNT_1">%2$d</xliff:g> gjithsej lejohen të shfaqen mbi aplikacionet e tjera"</string>
    <string name="filter_overlay_apps" msgid="6965969283342557573">"Aplikacionet me leje"</string>
    <string name="app_permission_summary_allowed" msgid="1505409933012886711">"Lejohet"</string>
    <string name="app_permission_summary_not_allowed" msgid="2592617058101882802">"Nuk lejohet"</string>
    <string name="keywords_install_other_apps" msgid="761078076051006558">"instalo aplikacione nga burime të panjohura"</string>
    <string name="write_settings" msgid="4797457275727195681">"Modifiko cilësimet e sistemit"</string>
    <string name="keywords_write_settings" msgid="6415597272561105138">"shkruaj modifiko sistem cilësime"</string>
    <string name="write_settings_summary" msgid="4302268998611412696">"<xliff:g id="COUNT_0">%1$d</xliff:g> nga <xliff:g id="COUNT_1">%2$d</xliff:g> aplikacione lejohen të modifikojnë cilësimet e sistemit"</string>
    <string name="filter_install_sources_apps" msgid="3102976274848199118">"Mund të instalojë aplikacione të tjera"</string>
    <string name="filter_write_settings_apps" msgid="2914615026197322551">"Mund të modifikojë cilësimet e sistemit"</string>
    <string name="write_settings_title" msgid="4232152481902542284">"Mund të modifikojë cilësimet e sistemit"</string>
    <string name="write_system_settings" msgid="3482913590601096763">"Modifiko cilësimet e sistemit"</string>
    <string name="permit_write_settings" msgid="658555006453212691">"Lejo modifikimin e cilësimeve të sistemit"</string>
    <string name="write_settings_description" msgid="6868293938839954623">"Kjo leje e lejon një aplikacion të modifikojë cilësimet e sistemit."</string>
    <string name="write_settings_on" msgid="8230580416068832239">"Po"</string>
    <string name="write_settings_off" msgid="5156104383386336233">"Jo"</string>
    <string name="external_source_switch_title" msgid="3621381992793251070">"Lejo nga ky burim"</string>
    <string name="camera_gesture_title" msgid="1075838577642393011">"Rrotullo dy herë për kamerën"</string>
    <string name="camera_gesture_desc" msgid="1831390075255870960">"Hap aplikacionin e kamerës duke rrotulluar kyçin e dorës dy herë"</string>
    <string name="camera_double_tap_power_gesture_title" msgid="1651873760405034645">"Shtyp butonin e energjisë dy herë për kamerën"</string>
    <string name="camera_double_tap_power_gesture_desc" msgid="7355664631775680376">"Hap me shpejtësi kamerën pa e shkyçur ekranin"</string>
    <string name="screen_zoom_title" msgid="5233515303733473927">"Madhësia e paraqitjes"</string>
    <string name="screen_zoom_short_summary" msgid="7291960817349834688">"Bëji artikujt në ekran më të mëdhenj ose më të vegjël"</string>
    <string name="screen_zoom_keywords" msgid="9176477565403352552">"dendësia e pamjes, zmadhimi i ekranit, shkalla, shkallëzimi"</string>
    <string name="screen_zoom_summary" msgid="6445488991799015407">"Bëji artikujt në ekran më të vegjël ose më të mëdhenj. Disa aplikacione në ekran mund të ndryshojnë pozicionin."</string>
    <string name="screen_zoom_preview_title" msgid="4680671508172336572">"Pamja paraprake"</string>
    <string name="screen_zoom_make_smaller_desc" msgid="4622359904253364742">"Zvogëlo"</string>
    <string name="screen_zoom_make_larger_desc" msgid="2236171043607896594">"Zmadho"</string>
    <string name="screen_zoom_conversation_icon_alex" msgid="8443032489384985820">"A"</string>
    <string name="screen_zoom_conversation_icon_pete" msgid="998709701837681129">"P"</string>
    <string name="screen_zoom_conversation_message_1" msgid="6546951024984852686">"Përshëndetje Ani!"</string>
    <string name="screen_zoom_conversation_message_2" msgid="6935424214137738647">"Ej, do që të takohemi sot për një kafe?"</string>
    <string name="screen_zoom_conversation_message_3" msgid="5218221201861387402">"Patjetër. Di unë një vend jo larg që këtu."</string>
    <string name="screen_zoom_conversation_message_4" msgid="5564676794767555447">"Mrekulli!"</string>
    <string name="screen_zoom_conversation_timestamp_1" msgid="7453710416319650556">"E martë 18:00"</string>
    <string name="screen_zoom_conversation_timestamp_2" msgid="7107225702890747588">"E martë 18:01"</string>
    <string name="screen_zoom_conversation_timestamp_3" msgid="3785674344762707688">"E martë 18:02"</string>
    <string name="screen_zoom_conversation_timestamp_4" msgid="2511469395448561259">"E martë 18:03"</string>
    <string name="disconnected" msgid="4836600637485526329">"Nuk është i lidhur"</string>
    <string name="keyboard_disconnected" msgid="1495037256967224035">"Nuk është e lidhur"</string>
    <string name="data_usage_summary_format" msgid="7507047900192160585">"<xliff:g id="AMOUNT">%1$s</xliff:g> nga të dhënat janë përdorur"</string>
    <string name="data_usage_wifi_format" msgid="5417296451392612860">"<xliff:g id="AMOUNT">^1</xliff:g> të përdorura në Wi‑Fi"</string>
    <plurals name="notification_summary" formatted="false" msgid="3941492005316143599">
      <item quantity="other">Joaktive për <xliff:g id="COUNT">%d</xliff:g> aplikacione</item>
      <item quantity="one">Joaktive për 1 aplikacion</item>
    </plurals>
    <string name="notification_summary_none" msgid="4586376436702610">"Aktive për të gjitha aplikacionet"</string>
    <string name="apps_summary" msgid="193158055537070092">"<xliff:g id="COUNT">%1$d</xliff:g> aplikacione të instaluara"</string>
    <string name="apps_summary_example" msgid="2118896966712746139">"24 aplikacione të instaluara"</string>
    <string name="storage_summary" msgid="3801281635351732202">"<xliff:g id="PERCENTAGE">%1$s</xliff:g> të përdorura - <xliff:g id="FREE_SPACE">%2$s</xliff:g> të lira"</string>
    <string name="storage_summary_with_sdcard" msgid="3290457009629490121">"Hapësira ruajtëse e brendshme: <xliff:g id="PERCENTAGE">%1$s</xliff:g> e përdorur - <xliff:g id="FREE_SPACE">%2$s</xliff:g> e lirë"</string>
    <string name="display_summary" msgid="6737806235882127328">"Në gjumë pas <xliff:g id="TIMEOUT_DESCRIPTION">%1$s</xliff:g> pa aktivitet"</string>
    <string name="display_dashboard_summary" msgid="4145888780290131488">"Sfond, fjetje, madhësia e shkrimit"</string>
    <string name="display_dashboard_summary_with_style" msgid="870920274423314524">"Stilet, imazhet e sfondit, koha e pritjes së ekranit, madhësia e fontit"</string>
    <string name="display_dashboard_nowallpaper_summary" msgid="7840559323355210111">"Në gjumë, madhësia e fontit"</string>
    <string name="display_summary_example" msgid="9102633726811090523">"Në gjumë pas 10 minutash pa aktivitet"</string>
    <string name="memory_summary" msgid="8080825904671961872">"Mesatarisht <xliff:g id="USED_MEMORY">%1$s</xliff:g> nga <xliff:g id="TOTAL_MEMORY">%2$s</xliff:g> memorie të përdorura"</string>
    <string name="users_summary" msgid="1674864467098487328">"Identifikuar si <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="payment_summary" msgid="3472482669588561110">"<xliff:g id="APP_NAME">%1$s</xliff:g> është i parazgjedhur"</string>
    <string name="backup_disabled" msgid="485189128759595412">"Rezervimi u çaktivizua"</string>
    <string name="android_version_summary" msgid="2935995161657697278">"Përditësuar në Android <xliff:g id="VERSION">%1$s</xliff:g>"</string>
    <string name="android_version_pending_update_summary" msgid="487831391976523090">"Ofrohet përditësim"</string>
    <string name="disabled_by_policy_title" msgid="627023216027648534">"Veprimi nuk lejohet"</string>
    <string name="disabled_by_policy_title_adjust_volume" msgid="3208724801293696486">"Volumi nuk mund të ndryshohet"</string>
    <string name="disabled_by_policy_title_outgoing_calls" msgid="7919816644946067058">"Telefonata nuk lejohet"</string>
    <string name="disabled_by_policy_title_sms" msgid="5733307423899610340">"Mesazhi SMS nuk lejohet"</string>
    <string name="disabled_by_policy_title_camera" msgid="6225008536855644874">"Kamera nuk lejohet"</string>
    <string name="disabled_by_policy_title_screen_capture" msgid="4066913623298047094">"Pamja e ekranit nuk lejohet"</string>
    <string name="disabled_by_policy_title_suspend_packages" msgid="7872038990805477554">"Ky aplikacion nuk mund të hapet"</string>
    <string name="default_admin_support_msg" msgid="4489678214035485367">"Nëse ke pyetje, kontakto me administratorin e TI-së"</string>
    <string name="admin_support_more_info" msgid="8901377038510512654">"Më shumë detaje"</string>
    <string name="admin_profile_owner_message" msgid="5860816886981109626">"Administratori yt mund të monitorojë dhe të menaxhojë aplikacionet dhe të dhënat e lidhura me profilin tënd të punës, duke përfshirë cilësimet, lejet, qasjen e korporatës, aktivitetin e rrjetit dhe informacionet e vendndodhjes së pajisjes."</string>
    <string name="admin_profile_owner_user_message" msgid="3842630535450382172">"Administratori yt mund të monitorojë dhe të menaxhojë aplikacionet dhe të dhënat e lidhura me këtë përdorues, duke përfshirë cilësimet, lejet, qasjen e korporatës, aktivitetin e rrjetit dhe informacionet e vendndodhjes së pajisjes."</string>
    <string name="admin_device_owner_message" msgid="6232893638259790789">"Administratori yt mund të monitorojë dhe menaxhojë aplikacionet dhe të dhënat e lidhura me këtë pajisje, duke përfshirë cilësimet, lejet, qasjen e korporatës, aktivitetin e rrjetit dhe informacionet e vendndodhjes së pajisjes."</string>
    <string name="condition_turn_off" msgid="1960945836880080298">"Çaktivizo"</string>
    <string name="condition_turn_on" msgid="9089876276117874591">"Aktivizo"</string>
    <string name="condition_expand_show" msgid="608202020023489939">"Shfaq"</string>
    <string name="condition_expand_hide" msgid="948507739223760667">"Fshih"</string>
    <string name="condition_hotspot_title" msgid="5959815393203320845">"Zona e qasjes është aktive"</string>
    <string name="condition_airplane_title" msgid="287356299107070503">"Modaliteti i aeroplanit është aktiv"</string>
    <string name="condition_airplane_summary" msgid="2500054042183138980">"Rrjetet nuk ofrohen"</string>
    <string name="condition_zen_title" msgid="2897779738211625">"\"Mos shqetëso\" është aktiv"</string>
    <string name="condition_zen_summary_phone_muted" msgid="3644614024467141806">"Telefonit i është hequr zëri"</string>
    <string name="condition_zen_summary_with_exceptions" msgid="4047564276599301064">"Me përjashtime"</string>
    <string name="condition_battery_title" msgid="3272131008388575349">"Kursyesi i baterisë është i aktivizuar"</string>
    <string name="condition_battery_summary" msgid="5847532902924566572">"Funksionet e kufizuara"</string>
    <string name="condition_cellular_title" msgid="1327317003797575735">"Të dhënat celulare janë joaktive"</string>
    <string name="condition_cellular_summary" msgid="816822977403022625">"Interneti ofrohet vetëm nëpërmjet Wi‑Fi"</string>
    <string name="condition_bg_data_title" msgid="5475793236997935138">"Kursyesi i të dhënave"</string>
    <string name="condition_bg_data_summary" msgid="1852811387315557164">"Funksionet e kufizuara"</string>
    <string name="condition_work_title" msgid="7293722361184366648">"Profili i punës është i çaktivizuar"</string>
    <string name="condition_work_summary" msgid="9167580982244020746">"Për aplikacionet dhe njoftimet"</string>
    <string name="condition_device_muted_action_turn_on_sound" msgid="4930240942726349213">"Aktivizo tingullin"</string>
    <string name="condition_device_muted_title" msgid="3476439379918599716">"Ziles i është hequr zëri"</string>
    <string name="condition_device_muted_summary" msgid="6313274406443663781">"Për telefonatat dhe njoftimet"</string>
    <string name="condition_device_vibrate_title" msgid="8070177546359590131">"Vetëm me dridhje"</string>
    <string name="condition_device_vibrate_summary" msgid="5743200564646910423">"Për telefonatat dhe njoftimet"</string>
    <string name="night_display_suggestion_title" msgid="6602129097059325291">"Vendos planifikimin e \"Dritës së natës\""</string>
    <string name="night_display_suggestion_summary" msgid="228346372178218442">"Cakto automatikisht një nuancë të ekranit çdo natë"</string>
    <string name="condition_night_display_title" msgid="5599814941976856183">"\"Drita e natës\" është aktive"</string>
    <string name="condition_night_display_summary" msgid="7150932917610919907">"Ekrani me nuancë të verdhë në portokalli"</string>
    <string name="condition_grayscale_title" msgid="3426050703427823519">"Nuancat e grisë"</string>
    <string name="condition_grayscale_summary" msgid="7652835784223724625">"Shfaq vetëm në ngjyrën gri"</string>
    <string name="homepage_condition_footer_content_description" msgid="2335918927419018030">"Palos"</string>
    <string name="suggestions_title_v2" msgid="5601181602924147569">"Të sugjeruara për ty"</string>
    <string name="suggestions_title" msgid="7280792342273268377">"Sugjerime"</string>
    <string name="suggestions_summary" msgid="2509040178581728056">"+<xliff:g id="ID_1">%1$d</xliff:g>"</string>
    <string name="suggestions_more_title" msgid="8223690393059519879">"+<xliff:g id="ID_1">%1$d</xliff:g> të tjera"</string>
    <plurals name="suggestions_collapsed_title" formatted="false" msgid="1857433444865249823">
      <item quantity="other"><xliff:g id="COUNT">%1$d</xliff:g> sugjerime</item>
      <item quantity="one">1 sugjerim</item>
    </plurals>
    <plurals name="suggestions_collapsed_summary" formatted="false" msgid="7680263825371165461">
      <item quantity="other">+<xliff:g id="COUNT">%1$d</xliff:g> sugjerime</item>
      <item quantity="one">+1 sugjerim</item>
    </plurals>
    <string name="suggestion_remove" msgid="904627293892092439">"Hiqe"</string>
    <string name="color_temperature" msgid="2070126836910615605">"Temperatura e ftohtë e ngjyrës"</string>
    <string name="color_temperature_desc" msgid="4793729830226404052">"Përdor ngjyra të ftohta të ekranit"</string>
    <string name="color_temperature_toast" msgid="4974218172133854827">"Për të zbatuar ndryshimin e ngjyrës, çaktivizoje ekranin"</string>
    <string name="camera_laser_sensor_switch" msgid="8913588990743234440">"Sensori me laser i kamerës"</string>
    <string name="ota_disable_automatic_update" msgid="2319639631655915050">"Përditësimet automatike të sistemit"</string>
    <string name="ota_disable_automatic_update_summary" msgid="940729694354373087">"Zbato përditësimet kur të riniset pajisja"</string>
    <string name="usage" msgid="2977875522080448986">"Përdorimi"</string>
    <string name="cellular_data_usage" msgid="2155683719898158203">"Përdorimi i të dhënave celulare"</string>
    <string name="app_cellular_data_usage" msgid="5468472735806533448">"Përdorimi i të dhënave"</string>
    <string name="wifi_data_usage" msgid="771603760674507659">"Përdorimi i të dhënave me Wi-Fi"</string>
    <string name="ethernet_data_usage" msgid="5108764537574354616">"Përdorimi i të dhënave me eternet"</string>
    <string name="wifi" msgid="1081550856200013637">"Wi-Fi"</string>
    <string name="ethernet" msgid="6600095783781389720">"Eterneti"</string>
    <string name="cell_data_template" msgid="405684854174361041">"<xliff:g id="AMOUNT">^1</xliff:g> të dhëna celulare"</string>
    <string name="wifi_data_template" msgid="6265570748799357386">"<xliff:g id="AMOUNT">^1</xliff:g> të dhëna Wi-Fi"</string>
    <string name="ethernet_data_template" msgid="5782476509881033590">"<xliff:g id="AMOUNT">^1</xliff:g> të dhëna eterneti"</string>
    <string name="billing_cycle" msgid="6614597736285325497">"Paralajmërimi dhe kufiri i të dhënave"</string>
    <string name="app_usage_cycle" msgid="8877223251648092131">"Cikli i përd. të të dhënave të apl."</string>
    <string name="cell_data_warning" msgid="1985956818884847057">"Paralajmërimi i të dhënave <xliff:g id="ID_1">^1</xliff:g>"</string>
    <string name="cell_data_limit" msgid="1578367585799358854">"Kufiri i të dhënave <xliff:g id="ID_1">^1</xliff:g>"</string>
    <string name="cell_data_warning_and_limit" msgid="6888825370687743208">"Paralajmërimi i të dhënave <xliff:g id="ID_1">^1</xliff:g> / Kufiri i të dhënave <xliff:g id="ID_2">^2</xliff:g>"</string>
    <string name="billing_cycle_fragment_summary" msgid="8231066353654583106">"Çdo muaj në ditën <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="network_restrictions" msgid="8234695294536675380">"Kufizimet e rrjetit"</string>
    <plurals name="network_restrictions_summary" formatted="false" msgid="4301618027244595839">
      <item quantity="other"><xliff:g id="COUNT">%1$d</xliff:g> kufizime</item>
      <item quantity="one">1 kufizim</item>
    </plurals>
    <string name="operator_warning" msgid="1862988028996859195">"Llogaritja e të dhënave nga operatori mund të ndryshojë nga llogaritja e pajisjes"</string>
    <string name="data_used_template" msgid="3245919669966296505">"<xliff:g id="ID_1">%1$s</xliff:g> të përdorura"</string>
    <string name="set_data_warning" msgid="6115364758236594593">"Cakto paralajm. për të dhënat"</string>
    <string name="data_warning" msgid="209133958008062117">"Paralajmërimi i të dhënave"</string>
    <string name="data_warning_footnote" msgid="776341964125603711">"Paralajmërimi i të dhënave dhe kufiri i të dhënave maten nga pajisja jote. Kjo mund të jetë ndryshe nga të dhënat e operatorit celular."</string>
    <string name="set_data_limit" msgid="2901526323210516923">"Cakto kufirin e të dhënave"</string>
    <string name="data_limit" msgid="1885406964934590552">"Kufiri i të dhënave"</string>
    <string name="data_usage_template" msgid="2923744765873163859">"<xliff:g id="ID_1">%1$s</xliff:g> të përdorura në <xliff:g id="ID_2">%2$s</xliff:g>"</string>
    <string name="configure" msgid="1029654422228677273">"Konfiguro"</string>
    <string name="data_usage_other_apps" msgid="3272872663517382050">"Aplikacionet e tjera të përfshira në përdorim"</string>
    <plurals name="data_saver_unrestricted_summary" formatted="false" msgid="2635267833484232703">
      <item quantity="other"><xliff:g id="COUNT">%1$d</xliff:g> aplikacione lejohen të përdorin të dhëna të pakufizuara kur \"Kursyesi i të dhënave\" është aktiv</item>
      <item quantity="one">1 aplikacion lejohet të përdorë të dhëna të pakufizuara kur \"Kursyesi i të dhënave\" është aktiv</item>
    </plurals>
    <string name="data_usage_title" msgid="3659356290392241789">"Të dhënat kryesore"</string>
    <string name="data_usage_wifi_title" msgid="7063659423081820720">"Të dhënat e Wi‑Fi"</string>
    <string name="data_used" msgid="5116389957228457203">"<xliff:g id="ID_1">^1</xliff:g> të përdorura"</string>
    <string name="data_used_formatted" msgid="2989129931961311051">"<xliff:g id="ID_1">^1</xliff:g> <xliff:g id="ID_2">^2</xliff:g> të përdorura"</string>
    <string name="data_overusage" msgid="1134445012475270295">"<xliff:g id="ID_1">^1</xliff:g> mbi kufi"</string>
    <string name="data_remaining" msgid="8998091725895502181">"<xliff:g id="ID_1">^1</xliff:g> të mbetura"</string>
    <plurals name="billing_cycle_days_left" formatted="false" msgid="456503215317213651">
      <item quantity="other">%d ditë të mbetura</item>
      <item quantity="one">%d ditë e mbetur</item>
    </plurals>
    <string name="billing_cycle_none_left" msgid="5892754995098583472">"Nuk ka më kohë të mbetur"</string>
    <string name="billing_cycle_less_than_one_day_left" msgid="825838050296069404">"Mbetet më pak se 1 ditë"</string>
    <string name="carrier_and_update_text" msgid="7963409972475063897">"U përditësua nga <xliff:g id="ID_1">^1</xliff:g> <xliff:g id="ID_2">^2</xliff:g> më parë"</string>
    <string name="no_carrier_update_text" msgid="3277403390316201982">"U përditësua <xliff:g id="ID_1">^2</xliff:g> më parë"</string>
    <string name="carrier_and_update_now_text" msgid="4057997726060106722">"Sapo u përditësua nga <xliff:g id="ID_1">^1</xliff:g>"</string>
    <string name="no_carrier_update_now_text" msgid="1766859656868932996">"U përditësua pikërisht tani"</string>
    <string name="launch_mdp_app_text" msgid="6751296320061773169">"Shiko planin"</string>
    <string name="launch_wifi_text" msgid="2311424914664372687">"Shiko detajet"</string>
    <string name="data_saver_title" msgid="8034286939200289826">"Kursyesi i të dhënave"</string>
    <string name="unrestricted_data_saver" msgid="952796077540228711">"Të dhënat e pakufizuara"</string>
    <string name="restrict_background_blacklisted" msgid="3995443391711013068">"Të dhënat e sfondit janë të çaktivizuara"</string>
    <string name="data_saver_on" msgid="6774217590237934709">"Aktiv"</string>
    <string name="data_saver_off" msgid="6892309031162738794">"Joaktiv"</string>
    <string name="data_saver_switch_title" msgid="836312690356005669">"Përdor \"Kursyesin e të dhënave\""</string>
    <string name="unrestricted_app_title" msgid="4465437191723332066">"Përdorim i pakufizuar i të dhënave"</string>
    <string name="unrestricted_app_summary" msgid="6458008993501723912">"Lejo qasjen e pakufizuar të të dhënave kur \"Kursyesi i të dhënave\" është aktiv"</string>
    <string name="home_app" msgid="4066188520886810030">"Aplikacioni bazë"</string>
    <string name="no_default_home" msgid="7184117487704520238">"Nuk ka faqe bazë të parazgjedhur"</string>
    <string name="lockpattern_settings_require_cred_before_startup" msgid="3832020101401318248">"Nisje e sigurt"</string>
    <string name="lockpattern_settings_require_pattern_before_startup_summary" msgid="7873036097628404476">"Kërko motiv për të nisur pajisjen. Ndërsa është e fikur, kjo pajisje nuk mund të marrë telefonata, mesazhe, njoftime apo alarme."</string>
    <string name="lockpattern_settings_require_pin_before_startup_summary" msgid="6022831284097476933">"Kërko kod PIN për të nisur pajisjen. Ndërsa është e fikur, kjo pajisje nuk mund të marrë telefonata, mesazhe, njoftime apo alarme."</string>
    <string name="lockpattern_settings_require_password_before_startup_summary" msgid="6818285221244966231">"Kërko fjalëkalim për të nisur pajisjen. Ndërsa është e fikur, kjo pajisje nuk mund të marrë telefonata, mesazhe, njoftime apo alarme."</string>
    <string name="suggestion_additional_fingerprints" msgid="2214281455363797037">"Shto një gjurmë tjetër gishti"</string>
    <string name="suggestion_additional_fingerprints_summary" msgid="5471253233176471245">"Shkyçe me një gisht tjetër"</string>
    <string name="battery_saver_on_summary" msgid="7722791295871319534">"Aktiv"</string>
    <string name="battery_saver_off_scheduled_summary" msgid="3953785517002197881">"Do të aktivizohet në <xliff:g id="BATTERY_PERCENTAGE">%1$s</xliff:g>"</string>
    <string name="battery_saver_off_summary" msgid="784360321235698247">"Joaktiv"</string>
    <string name="battery_saver_button_turn_on" msgid="3699954061337848832">"Aktivizo tani"</string>
    <string name="battery_saver_button_turn_off" msgid="5916996792004611890">"Çaktivizo tani"</string>
    <string name="not_battery_optimizing" msgid="5362861851864837617">"Nuk po përdoret optimizimi i baterisë"</string>
    <string name="lockscreen_remote_input" msgid="969871538778211843">"Nëse pajisja është e kyçur, parandalo shkrimin e përgjigjeve ose teksteve të tjera te njoftimet"</string>
    <string name="default_spell_checker" msgid="8506899870026026660">"Kontrolluesi drejtshkrimor i parazgjedhur"</string>
    <string name="choose_spell_checker" msgid="6596539862291699367">"Zgjidh kontrolluesin drejtshkrimor"</string>
    <string name="spell_checker_master_switch_title" msgid="8763132750954344372">"Përdor kontrolluesin drejtshkrimor"</string>
    <string name="spell_checker_not_selected" msgid="8871083796179200696">"I pazgjedhur"</string>
    <string name="notification_log_no_title" msgid="5678029849672024215">"(asnjë)"</string>
    <string name="notification_log_details_delimiter" msgid="3116559361552416747">": "</string>
    <string name="notification_log_details_package" msgid="2596495677039100284">"paketa"</string>
    <string name="notification_log_details_key" msgid="2995791937075862968">"çelësi"</string>
    <string name="notification_log_details_group" msgid="2430467015200368698">"grupi"</string>
    <string name="notification_log_details_group_summary" msgid="7945543958255585829">"(përmbledhja)"</string>
    <string name="notification_log_details_visibility" msgid="2552873780715930971">"dukshmëria"</string>
    <string name="notification_log_details_public_version" msgid="4247242364605495240">"versioni publik"</string>
    <string name="notification_log_details_priority" msgid="8371354971235991398">"përparësia"</string>
    <string name="notification_log_details_importance" msgid="2153168790791683139">"rëndësia"</string>
    <string name="notification_log_details_explanation" msgid="1914295130775393551">"shpjegimi"</string>
    <string name="notification_log_details_badge" msgid="3258183328267662285">"mund të shfaqë simbol dallues"</string>
    <string name="notification_log_details_content_intent" msgid="1113554570409128083">"synimi"</string>
    <string name="notification_log_details_delete_intent" msgid="905118520685297007">"fshi synimin"</string>
    <string name="notification_log_details_full_screen_intent" msgid="7118560817013522978">"synimi i ekranit të plotë"</string>
    <string name="notification_log_details_actions" msgid="242523930165118066">"veprimet"</string>
    <string name="notification_log_details_title" msgid="7177091647508863295">"titulli"</string>
    <string name="notification_log_details_remoteinput" msgid="8328591329858827409">"hyrjet në largësi"</string>
    <string name="notification_log_details_content_view" msgid="6638731378278561786">"pamja e personalizuar"</string>
    <string name="notification_log_details_extras" msgid="4188418723779942047">"shtesë"</string>
    <string name="notification_log_details_icon" msgid="8939114059726188218">"ikona"</string>
    <string name="notification_log_details_parcel" msgid="243148037601903212">"madhësia e pakos"</string>
    <string name="notification_log_details_ashmem" msgid="7241814108477320636">"ashmem"</string>
    <string name="notification_log_details_alerted" msgid="6622944771989529320">"njoftimi u sinjalizua"</string>
    <string name="notification_log_details_sound" msgid="5506232879598808099">"tingulli"</string>
    <string name="notification_log_details_vibrate" msgid="6890065466625335940">"dridhje"</string>
    <string name="notification_log_details_vibrate_pattern" msgid="6076984056201975221">"motivi"</string>
    <string name="notification_log_details_default" msgid="2345249399796730861">"e parazgjedhur"</string>
    <string name="notification_log_details_none" msgid="184131801230614059">"asnjë"</string>
    <string name="notification_log_details_ranking_null" msgid="244660392058720919">"Objekti i renditjes mungon."</string>
    <string name="notification_log_details_ranking_none" msgid="599607025882587844">"Objekti i renditjes nuk e përmban këtë çelës."</string>
    <string name="theme_customization_category" msgid="1049181544004163283">"Krijimi i temës"</string>
    <string name="theme_customization_device_default" msgid="5058147707906551368">"Parazgjedhja e pajisjes"</string>
    <string name="display_cutout_emulation" msgid="7466869822418376317">"Prerja e ekranit"</string>
    <string name="display_cutout_emulation_keywords" msgid="4495418317471622562">"prerje ekrani, e prerë"</string>
    <string name="overlay_option_device_default" msgid="294510212512203638">"Parazgjedhja e pajisjes"</string>
    <string name="overlay_toast_failed_to_apply" msgid="3506731619973103346">"Zbatimi i mbivendosjes dështoi"</string>
    <string name="special_access" msgid="3458780842491881155">"Qasja e veçantë e apl."</string>
    <plurals name="special_access_summary" formatted="false" msgid="260765309935675867">
      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> aplikacione mund të përdorin të dhëna të pakufizuara</item>
      <item quantity="one">1 aplikacion mund të përdorë të dhëna të pakufizuara</item>
    </plurals>
    <string name="special_access_more" msgid="6927066457969301921">"Shiko më shumë"</string>
    <string name="confirm_convert_to_fbe_warning" msgid="1487005506049137659">"Të pastrohen vërtet të dhënat e përdoruesit dhe të konvertohen tek enkriptimi i skedarit?"</string>
    <string name="button_confirm_convert_fbe" msgid="7101855374850373091">"Pastro dhe konverto"</string>
    <string name="reset_shortcut_manager_throttling" msgid="6495066467198668994">"Rivendos kufizimin e normës së ShortcutManager"</string>
    <string name="reset_shortcut_manager_throttling_complete" msgid="1826770872063707900">"Është rivendosur kufizimi i normës së ShortcutManager"</string>
    <string name="notification_suggestion_title" msgid="387052719462473500">"Informacioni i kontrollit në ekranin e kyçjes"</string>
    <string name="notification_suggestion_summary" msgid="8521159741445416875">"Shfaq ose fshih përmbajtjet e njoftimeve"</string>
    <string name="page_tab_title_summary" msgid="4070309266374993258">"Të gjitha"</string>
    <string name="page_tab_title_support" msgid="4407600495101788249">"Këshilla dhe mbështetje"</string>
    <string name="developer_smallest_width" msgid="7516950434587313360">"Gjerësia më e vogël"</string>
    <string name="premium_sms_none" msgid="8268105565738040566">"Asnjë aplikacion i instaluar nuk ka kërkuar qasje te mesazhet SMS premium"</string>
    <string name="premium_sms_warning" msgid="9086859595338944882">"Mesazhet SMS premium mund të kushtojnë dhe do të rritin faturat e operatorit tënd celular. Nëse e aktivizon lejen për një aplikacion, do të mund të dërgosh mesazhe SMS premium me atë aplikacion."</string>
    <string name="premium_sms_access" msgid="4660047004791638305">"Qasja te mesazhet SMS premium"</string>
    <string name="bluetooth_disabled" msgid="6244000672828617410">"Joaktiv"</string>
    <string name="bluetooth_connected_summary" msgid="7672528674593152862">"Lidhur me <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="bluetooth_connected_multiple_devices_summary" msgid="9173661896296663932">"Lidhur me shumë pajisje"</string>
    <string name="demo_mode" msgid="2798762752209330277">"Modaliteti i demonstrimit i ndërfaqes së përdoruesit të sistemit"</string>
    <string name="dark_ui_mode" msgid="6795784845192720944">"Tema e errët"</string>
    <string name="dark_ui_mode_disabled_summary_dark_theme_on" msgid="5141126532745008289">"Aktive / Çaktivizuar për shkak të \"Kursyesit të baterisë\""</string>
    <string name="dark_ui_mode_disabled_summary_dark_theme_off" msgid="4619248181769223081">"Aktivizuar përkohësisht për shkak të \"Kursyesit të baterisë\""</string>
    <string name="dark_ui_settings_dark_summary" msgid="8205234847639399279">"Aplikacionet e mbështetura do të kalojnë po ashtu te tema e errët"</string>
    <string name="dark_ui_settings_dialog_acknowledge" msgid="8683868642329596059">"E kuptova"</string>
    <string name="quick_settings_developer_tiles" msgid="5947788063262762448">"Pllakëzat e zhvilluesit të cilësimeve të shpejta"</string>
    <string name="winscope_trace_quick_settings_title" msgid="1294290008255732032">"Gjurma e Winscope"</string>
    <string name="sensors_off_quick_settings_title" msgid="1487323753632515801">"Sensorët joaktivë"</string>
    <string name="managed_profile_settings_title" msgid="2729481936758125054">"Cilësimet e profilit të punës"</string>
    <string name="managed_profile_contact_search_title" msgid="6034734926815544221">"Kërkimi i kontakteve"</string>
    <string name="managed_profile_contact_search_summary" msgid="5431253552272970512">"Lejo kërkimet e kontakteve nga organizata jote për të identifikuar telefonuesit dhe kontaktet"</string>
    <string name="cross_profile_calendar_title" msgid="4414835261437899531">"Kalendari i profileve"</string>
    <string name="cross_profile_calendar_summary" msgid="8139424817135929870">"Shfaq ngjarjet e punës në kalendarin personal"</string>
    <string name="cross_profile_calendar_restricted_summary" msgid="295371538704418613">"Organizata jote nuk lejon që aplikacionet personale të kenë qasje te kalendari i punës"</string>
    <plurals name="hours" formatted="false" msgid="7020844602875333472">
      <item quantity="other"><xliff:g id="NUMBER">%s</xliff:g> orë</item>
      <item quantity="one">1 orë</item>
    </plurals>
    <plurals name="minutes" formatted="false" msgid="4666832442068789413">
      <item quantity="other"><xliff:g id="NUMBER">%s</xliff:g> minuta</item>
      <item quantity="one">1 minutë</item>
    </plurals>
    <plurals name="seconds" formatted="false" msgid="3876307354560025025">
      <item quantity="other"><xliff:g id="NUMBER">%s</xliff:g> sekonda</item>
      <item quantity="one">1 sekondë</item>
    </plurals>
    <string name="automatic_storage_manager_settings" msgid="7819434542155181607">"Menaxho hapësirën ruajtëse"</string>
    <string name="automatic_storage_manager_text" msgid="4562950476680600604">"Për të ndihmuar në lirimin e hapësirës ruajtëse, menaxheri i hapësirës ruajtëse i heq fotografitë dhe videot e rezervuara nga pajisja jote."</string>
    <string name="automatic_storage_manager_days_title" msgid="2017913896160914647">"Hiq fotografitë dhe videot"</string>
    <string name="automatic_storage_manager_preference_title" msgid="5753702798151073383">"Menaxheri i hapësirës ruajtëse"</string>
    <string name="automatic_storage_manager_master_switch_title" msgid="6792996736190821417">"Përdor \"Menaxherin e hapësirës ruajtëse\""</string>
    <string name="deletion_helper_automatic_title" msgid="6605660435498272520">"Automatike"</string>
    <string name="deletion_helper_manual_title" msgid="7947432164411214029">"Manual"</string>
    <string name="deletion_helper_preference_title" msgid="5271510052022285884">"Liro hapësirën tani"</string>
    <string name="gesture_preference_title" msgid="5280023307132819052">"Gjestet"</string>
    <string name="gesture_preference_summary" product="default" msgid="8627850388011956901">"Gjeste të shpejta për të kontrolluar telefonin"</string>
    <string name="gesture_preference_summary" product="tablet" msgid="4717535378272065510">"Gjestet e shpejta për të kontrolluar tabletin"</string>
    <string name="gesture_preference_summary" product="device" msgid="4205941452664950852">"Gjestet e shpejta për të kontrolluar pajisjen"</string>
    <string name="double_tap_power_for_camera_title" msgid="64716226816032800">"Kalo te kamera"</string>
    <string name="double_tap_power_for_camera_summary" msgid="242037150983277829">"Për të hapur me shpejtësi kamerën, shtyp dy herë te butoni i energjisë. Funksionon nga çdo ekran."</string>
    <string name="double_tap_power_for_camera_suggestion_title" msgid="6500405261202883589">"Hap kamerën me shpejtësi"</string>
    <string name="double_twist_for_camera_mode_title" msgid="4877834147983530479">"Rrotullo kamerën"</string>
    <string name="double_twist_for_camera_mode_summary" msgid="122977081337563340"></string>
    <string name="double_twist_for_camera_suggestion_title" msgid="4689410222517954869">"Bëj selfi më shpejt"</string>
    <string name="system_navigation_title" msgid="6797710220442338366">"Navigimi i sistemit"</string>
    <string name="swipe_up_to_switch_apps_title" msgid="7381617686249459562">"Navigimi me 2 butona"</string>
    <string name="swipe_up_to_switch_apps_summary" msgid="2158312695920408870">"Për të ndërruar aplikacionet, rrëshqit lart mbi butonin \"Kreu\". Për të parë të gjitha aplikacionet, rrëshqit lart sërish. Për t\'u kthyer, trokit te butoni \"Prapa\"."</string>
    <string name="swipe_up_to_switch_apps_suggestion_title" msgid="1465200107913259595">"Provo butonin e ri \"Ekrani bazë\""</string>
    <string name="swipe_up_to_switch_apps_suggestion_summary" msgid="4825314186907812743">"Aktivizo gjestin e ri për të ndryshuar aplikacionet"</string>
    <string name="edge_to_edge_navigation_title" msgid="4889073348091667667">"Navigimi me gjeste"</string>
    <string name="edge_to_edge_navigation_summary" msgid="511639046551586471">"Për të shkuar te \"Kreu\", rrëshqit lart nga fundi i ekranit. Për të ndërruar aplikacionet, rrëshqit lart nga fundi, mbaje dhe më pas lëshoje. Për t\'u kthyer pas, rrëshqit nga ana e majtë ose e djathtë."</string>
    <string name="legacy_navigation_title" msgid="2635061924638361565">"Navigimi me 3 butona"</string>
    <string name="legacy_navigation_summary" msgid="5631274479304544610">"Kthehu pas te \"Kreu\" dhe ndërro aplikacionet me butonat në fund të ekranit tënd."</string>
    <string name="keywords_system_navigation" msgid="5825645072714635357">"navigimi i sistemit, navigimi me 2 butona, navigimi me 3 butona, navigimi me gjeste"</string>
    <string name="gesture_not_supported_dialog_message" msgid="4315436164949864999">"Nuk mbështetet nga aplikacioni i parazgjedhur për ekranin bazë, <xliff:g id="DEFAULT_HOME_APP">%s</xliff:g>"</string>
    <string name="gesture_not_supported_positive_button" msgid="8233003373902032396">"Ndërro aplikacionin e parazgjedhur për ekranin bazë"</string>
    <string name="information_label" msgid="8133109685432913360">"Informacione"</string>
    <string name="low_label" msgid="1679136861385616813">"I ulët"</string>
    <string name="high_label" msgid="7278863493316447831">"I lartë"</string>
    <string name="back_sensitivity_dialog_message" msgid="1742132397253621623">\n"Ndjeshmëria më e lartë mund të bjerë në konflikt me gjestet e aplikacionit përgjatë anëve të ekranit."</string>
    <string name="back_sensitivity_dialog_title" msgid="5403946345652118253">"Ndjeshmëria e kthimit pas"</string>
    <string name="ambient_display_title" product="default" msgid="5144814600610448504">"Trokit dy herë për të kontrolluar telefonin"</string>
    <string name="ambient_display_title" product="tablet" msgid="8688795028609563837">"Trokit dy herë për të kontrolluar tabletin"</string>
    <string name="ambient_display_title" product="device" msgid="3423781975742145894">"Trokit dy herë për të kontrolluar pajisjen"</string>
    <string name="ambient_display_summary" msgid="8534654210539169707">"Për të kontrolluar orën, njoftimet dhe informacione të tjera, trokit dy herë tek ekrani."</string>
    <string name="ambient_display_pickup_title" product="default" msgid="818688002837687268">"Ngrije për ta kontrolluar telefonin"</string>
    <string name="ambient_display_pickup_title" product="tablet" msgid="4455864282995698097">"Ngrije për ta kontrolluar tabletin"</string>
    <string name="ambient_display_pickup_title" product="device" msgid="5380534405773531175">"Ngrije për ta kontrolluar pajisjen"</string>
    <string name="ambient_display_wake_screen_title" msgid="4091523525326925790">"Ekrani i zgjimit"</string>
    <string name="ambient_display_pickup_summary" product="default" msgid="3436302177038243869">"Për të kontrolluar orën, njoftimet dhe informacione të tjera, merre në duar telefonin tënd."</string>
    <string name="ambient_display_pickup_summary" product="tablet" msgid="4938504160398665156">"Për të kontrolluar orën, njoftimet dhe informacione të tjera, merre në duar tabletin tënd."</string>
    <string name="ambient_display_pickup_summary" product="device" msgid="4264958533375250254">"Për të kontrolluar orën, njoftimet dhe informacione të tjera, merre në duar pajisjen tënde."</string>
    <string name="ambient_display_tap_screen_title" product="default" msgid="5458679563086979424">"Trokit për të kontrolluar telefonin"</string>
    <string name="ambient_display_tap_screen_title" product="tablet" msgid="9108878716863882877">"Trokit për të kontrolluar tabletin"</string>
    <string name="ambient_display_tap_screen_title" product="device" msgid="7071150656699666085">"Trokit për të kontrolluar pajisjen"</string>
    <string name="ambient_display_tap_screen_summary" msgid="8862155601920379979">"Për të kontrolluar orën, njoftimet dhe informacione të tjera, trokit tek ekrani."</string>
    <string name="fingerprint_swipe_for_notifications_title" msgid="5816346492253270243">"Rrëshqit gjurmën e gishtit për njoftimet"</string>
    <string name="fingerprint_gesture_screen_title" msgid="8562169633234041196">"Rrëshqit gjurmën e gishtit"</string>
    <string name="fingerprint_swipe_for_notifications_summary" product="default" msgid="1770661868393713922">"Për të kontrolluar njoftimet, rrëshqit poshtë në sensorin e gjurmës së gishtit në pjesën e pasme të telefonit."</string>
    <string name="fingerprint_swipe_for_notifications_summary" product="tablet" msgid="902719947767712895">"Për të kontrolluar njoftimet, rrëshqit poshtë në sensorin e gjurmës së gishtit në pjesën e pasme të tabletit."</string>
    <string name="fingerprint_swipe_for_notifications_summary" product="device" msgid="5372926094116306647">"Për të kontrolluar njoftimet, rrëshqit poshtë në sensorin e gjurmës së gishtit në pjesën e pasme të pajisjes."</string>
    <string name="fingerprint_swipe_for_notifications_suggestion_title" msgid="1677291167470357802">"Shiko njoftimet me shpejtësi"</string>
    <string name="gesture_setting_on" msgid="3455094265233870280">"Aktiv"</string>
    <string name="gesture_setting_off" msgid="5230169535435881894">"Joaktiv"</string>
    <string name="oem_unlock_enable_disabled_summary_bootloader_unlocked" msgid="4265541229765635629">"Ngarkuesi i sistemit është i shkyçur tashmë"</string>
    <string name="oem_unlock_enable_disabled_summary_connectivity" msgid="3361344735430813695">"Lidhu me internetin fillimisht"</string>
    <string name="oem_unlock_enable_disabled_summary_connectivity_or_locked" msgid="2479038689567925511">"Lidhu me internetin ose kontakto me operatorin celular"</string>
    <string name="oem_unlock_enable_disabled_summary_sim_locked_device" msgid="4149387448213399630">"Nuk ofrohet në pajisjet e kyçura për një operator celular"</string>
    <string name="oem_lock_info_message" msgid="9218313722236417510">"Rinis pajisjen për të aktivizuar funksionin e mbrojtjes së pajisjes."</string>
    <string name="automatic_storage_manager_freed_bytes" msgid="7517560170441007788">"<xliff:g id="SIZE">%1$s</xliff:g> në total të bëra të disponueshme\n\nEkzekutimi i fundit në datën <xliff:g id="DATE">%2$s</xliff:g>"</string>
    <string name="web_action_enable_title" msgid="4051513950976670853">"Aplikacionet e çastit"</string>
    <string name="web_action_enable_summary" msgid="3108127559723396382">"Hap lidhjet në aplikacione, edhe nëse nuk janë të instaluara"</string>
    <string name="web_action_section_title" msgid="7364647086538399136">"Aplikacionet e çastit"</string>
    <string name="instant_apps_settings" msgid="8827777916518348213">"Preferencat për \"Aplikacionet e çastit\""</string>
    <string name="domain_url_section_title" msgid="7046835219056428883">"Aplikacionet e instaluara"</string>
    <string name="automatic_storage_manager_activation_warning" msgid="6353100011690933254">"Hapësira jote ruajtëse tani po menaxhohet nga menaxheri i hapësirës ruajtëse"</string>
    <string name="account_for_section_header" msgid="5356566418548737121">"Llogaritë që ka <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="configure_section_header" msgid="7391183586410814450">"Konfiguro"</string>
    <string name="auto_sync_account_title" msgid="898796354710116383">"Sinkronizo automatikisht të dhënat"</string>
    <string name="auto_sync_personal_account_title" msgid="8496263182646100610">"Sinkronizo automatikisht të dhënat personale"</string>
    <string name="auto_sync_work_account_title" msgid="4489172450037434152">"Sinkronizo automatikisht të dhënat e punës"</string>
    <string name="auto_sync_account_summary" msgid="692499211629185107">"Lejo që aplikacionet t\'i rifreskojnë automatikisht të dhënat"</string>
    <string name="account_sync_title" msgid="7214747784136106491">"Sinkronizimi i llogarisë"</string>
    <string name="account_sync_summary_some_on" msgid="3375930757891381175">"Sinkronizimi është aktiv për <xliff:g id="ID_1">%1$d</xliff:g> nga <xliff:g id="ID_2">%2$d</xliff:g> artikuj"</string>
    <string name="account_sync_summary_all_on" msgid="570431636622254156">"Sinkronizimi aktiv për të gjithë artikujt"</string>
    <string name="account_sync_summary_all_off" msgid="8782409931761182734">"Sinkronizimi joaktiv për të gjithë artikujt"</string>
    <string name="enterprise_privacy_settings" msgid="1177106810374146496">"Informacioni i pajisjes së menaxhuar"</string>
    <string name="enterprise_privacy_settings_summary_generic" msgid="5853292305730761128">"Ndryshimet dhe cilësimet menaxhohen nga organizata jote"</string>
    <string name="enterprise_privacy_settings_summary_with_name" msgid="4266234968317996188">"Ndryshimet dhe cilësimet menaxhohen nga <xliff:g id="ORGANIZATION_NAME">%s</xliff:g>"</string>
    <string name="enterprise_privacy_header" msgid="7402406406883832509">"Për të ofruar qasjen në të dhënat e tua të punës, organizata jote mund të ndryshojë cilësimet dhe të instalojë softuerë në pajisjen tënde.\n\nKontakto me administratorin e organizatës për më shumë detaje."</string>
    <string name="enterprise_privacy_exposure_category" msgid="7313392680107938517">"Llojet e informacionit që mund të shikojë organizata jote"</string>
    <string name="enterprise_privacy_exposure_changes_category" msgid="9079283547182933771">"Ndryshimet e kryera nga administratori i organizatës tënde"</string>
    <string name="enterprise_privacy_device_access_category" msgid="5423434164248819058">"Qasja jote në këtë pajisje"</string>
    <string name="enterprise_privacy_enterprise_data" msgid="2773968662865848413">"Të dhënat që shoqërojnë llogarinë tënde të punës, si mail-i dhe kalendari"</string>
    <string name="enterprise_privacy_installed_packages" msgid="2313698828178764590">"Lista e aplikacioneve në pajisjen tënde"</string>
    <string name="enterprise_privacy_usage_stats" msgid="4398411405572759370">"Sasia e kohës dhe të dhënat e harxhuara në çdo aplikacion"</string>
    <string name="enterprise_privacy_network_logs" msgid="161722817268849590">"Regjistri më i fundit i trafikut të rrjetit"</string>
    <string name="enterprise_privacy_bug_reports" msgid="843225086779037863">"Raporti më i fundit i defekteve në kod"</string>
    <string name="enterprise_privacy_security_logs" msgid="5377362481617301074">"Regjistri yt më i fundit i sigurisë"</string>
    <string name="enterprise_privacy_none" msgid="7706621148858381189">"Asnjë"</string>
    <string name="enterprise_privacy_enterprise_installed_packages" msgid="6353757812144878828">"Aplikacione të instaluara"</string>
    <string name="enterprise_privacy_apps_count_estimation_info" msgid="7433213592572082606">"Numri i aplikacioneve është i përafërt. Ai mund të mos përfshijë aplikacionet e instaluara jashtë \"Dyqanit të Play\"."</string>
    <plurals name="enterprise_privacy_number_packages_lower_bound" formatted="false" msgid="3005116533873542976">
      <item quantity="other">Minimumi <xliff:g id="COUNT_1">%d</xliff:g> aplikacione</item>
      <item quantity="one">Minimumi <xliff:g id="COUNT_0">%d</xliff:g> aplikacion</item>
    </plurals>
    <string name="enterprise_privacy_location_access" msgid="4158197200885270634">"Lejet e vendndodhjes"</string>
    <string name="enterprise_privacy_microphone_access" msgid="5717375623568864441">"Lejet e mikrofonit"</string>
    <string name="enterprise_privacy_camera_access" msgid="4858146118537519375">"Lejet e kamerës"</string>
    <string name="enterprise_privacy_enterprise_set_default_apps" msgid="3288495615791128724">"Apl. e parazgjedhura"</string>
    <plurals name="enterprise_privacy_number_packages" formatted="false" msgid="2765037387436064893">
      <item quantity="other"><xliff:g id="COUNT_1">%d</xliff:g> aplikacione</item>
      <item quantity="one"><xliff:g id="COUNT_0">%d</xliff:g> aplikacion</item>
    </plurals>
    <string name="enterprise_privacy_input_method" msgid="6531350246850814920">"Tastiera e parazgjedhur"</string>
    <string name="enterprise_privacy_input_method_name" msgid="4941106433683067953">"Caktuar në <xliff:g id="APP_LABEL">%s</xliff:g>"</string>
    <string name="enterprise_privacy_always_on_vpn_device" msgid="4409098287763221215">"Rrjeti VPN gjithmonë aktiv i aktivizuar"</string>
    <string name="enterprise_privacy_always_on_vpn_personal" msgid="9217774730260037434">"Rrjeti VPN gjithmonë aktiv i aktivizuar në profilin tënd personal"</string>
    <string name="enterprise_privacy_always_on_vpn_work" msgid="7244472958208315814">"Rrjeti VPN gjithmonë aktiv i aktivizuar në profilin tënd të punës"</string>
    <string name="enterprise_privacy_global_http_proxy" msgid="7936664553416257333">"Përfaqësuesi global HTTP i caktuar"</string>
    <string name="enterprise_privacy_ca_certs_device" msgid="2019652712782510262">"Kredencialet e besuara"</string>
    <string name="enterprise_privacy_ca_certs_personal" msgid="2279084820904076599">"Kredencialet e besuara në profilin tënd personal"</string>
    <string name="enterprise_privacy_ca_certs_work" msgid="6187377647815301809">"Kredencialet e besuara në profilin tënd të punës"</string>
    <plurals name="enterprise_privacy_number_ca_certs" formatted="false" msgid="526375234629534165">
      <item quantity="other">Minimumi <xliff:g id="COUNT_1">%d</xliff:g> certifikata CA</item>
      <item quantity="one">Minimumi <xliff:g id="COUNT_0">%d</xliff:g> certifikatë CA</item>
    </plurals>
    <string name="enterprise_privacy_lock_device" msgid="8791656477097208540">"Administratori mund ta kyçë pajisjen dhe rivendosë fjalëkalimin"</string>
    <string name="enterprise_privacy_wipe_device" msgid="2821960015797241790">"Administratori mund të fshijë të gjitha të dhënat e pajisjes"</string>
    <string name="enterprise_privacy_failed_password_wipe_device" msgid="1001255609345002878">"Përpjekje të dështuara për fjalëkalimin përpara se të fshihen të gjitha të dhënat e pajisjes"</string>
    <string name="enterprise_privacy_failed_password_wipe_work" msgid="4040565826652951057">"Përpjekje të dështuara për fjalëkalimin përpara se të fshihen të dhënat e profilit të punës"</string>
    <plurals name="enterprise_privacy_number_failed_password_wipe" formatted="false" msgid="5279099270351036696">
      <item quantity="other"><xliff:g id="COUNT_1">%d</xliff:g> përpjekje</item>
      <item quantity="one"><xliff:g id="COUNT_0">%d</xliff:g> përpjekje</item>
    </plurals>
    <string name="do_disclosure_generic" msgid="8653670456990823307">"Kjo pajisje menaxhohet nga organizata jote."</string>
    <string name="do_disclosure_with_name" msgid="1141081465968481380">"Kjo pajisje menaxhohet nga <xliff:g id="ORGANIZATION_NAME">%s</xliff:g>."</string>
    <string name="do_disclosure_learn_more_separator" msgid="3558079393757238670">" "</string>
    <string name="learn_more" msgid="2623878455042103404">"Mëso më shumë"</string>
    <plurals name="default_camera_app_title" formatted="false" msgid="1134677050353971363">
      <item quantity="other">Aplikacionet e kamerës</item>
      <item quantity="one">Aplikacioni i kamerës</item>
    </plurals>
    <string name="default_calendar_app_title" msgid="3545972964391065220">"Aplikacioni i kalendarit"</string>
    <string name="default_contacts_app_title" msgid="3497370557378660098">"Aplikacioni i kontakteve"</string>
    <plurals name="default_email_app_title" formatted="false" msgid="42826975161049245">
      <item quantity="other">Aplikacionet e klientit të mail-it</item>
      <item quantity="one">Aplikacioni i klientit të mail-it</item>
    </plurals>
    <string name="default_map_app_title" msgid="7560143381633608567">"Aplikacioni i hartës"</string>
    <plurals name="default_phone_app_title" formatted="false" msgid="6714041230953195024">
      <item quantity="other">Aplikacionet e telefonit</item>
      <item quantity="one">Aplikacioni i telefonit</item>
    </plurals>
    <string name="app_names_concatenation_template_2" msgid="4309216198909946380">"<xliff:g id="FIRST_APP_NAME">%1$s</xliff:g>, <xliff:g id="SECOND_APP_NAME">%2$s</xliff:g>"</string>
    <string name="app_names_concatenation_template_3" msgid="8949045544491604376">"<xliff:g id="FIRST_APP_NAME">%1$s</xliff:g>, <xliff:g id="SECOND_APP_NAME">%2$s</xliff:g>, <xliff:g id="THIRD_APP_NAME">%3$s</xliff:g>"</string>
    <string name="storage_photos_videos" msgid="319854636702241898">"Fotografitë dhe videot"</string>
    <string name="storage_music_audio" msgid="789779084825206838">"Muzika dhe audioja"</string>
    <string name="storage_games" msgid="7703159201697117621">"Lojëra"</string>
    <string name="storage_other_apps" msgid="5524321740031718083">"Aplikacionet e tjera"</string>
    <string name="storage_files" msgid="8581083146777364063">"Skedarët"</string>
    <string name="storage_size_large_alternate" msgid="3395208658399637645">"<xliff:g id="NUMBER">^1</xliff:g>"<small>" "<font size="20">"<xliff:g id="UNIT">^2</xliff:g>"</font></small>""</string>
    <string name="storage_volume_total" msgid="3499221850532701342">"Përdorur nga <xliff:g id="TOTAL">%1$s</xliff:g> gjithsej"</string>
    <string name="storage_percent_full" msgid="6095012055875077036">"e përdorur"</string>
    <string name="clear_instant_app_data" msgid="2004222610585890909">"Pastro aplikacionin"</string>
    <string name="clear_instant_app_confirmation" msgid="7451671214898856857">"Dëshiron që ta heqësh këtë aplikacion të çastit?"</string>
    <string name="launch_instant_app" msgid="391581144859010499">"Hap"</string>
    <string name="game_storage_settings" msgid="3410689937046696557">"Lojëra"</string>
    <string name="audio_files_title" msgid="4777048870657911307">"Skedarët audio"</string>
    <string name="app_info_storage_title" msgid="5554719444625611987">"Hapësira e përdorur"</string>
    <string name="webview_uninstalled_for_user" msgid="1819903169194420983">"(çinstaluar për përdoruesin <xliff:g id="USER">%s</xliff:g>)"</string>
    <string name="webview_disabled_for_user" msgid="1216426047631256825">"(çaktivizuar për përdoruesin <xliff:g id="USER">%s</xliff:g>)"</string>
    <string name="autofill_app" msgid="7338387238377914374">"Shërbimi i plotësimit automatik"</string>
    <string name="autofill_keywords" msgid="7485591824120812710">"plotësim, automatik, plotësim automatik"</string>
    <string name="autofill_confirmation_message" msgid="2784869528908005194">"&lt;b&gt;Sigurohu që ke besim te ky aplikacion&lt;/b&gt; &lt;br/&gt; &lt;br/&gt; &lt;xliff:g id=app_name example=\"Plotësimi automatik i Google&gt;%1$s&lt;/xliff:g&gt; përdor atë që ndodhet në ekranin tënd për të përcaktuar se çfarë mund të plotësohet automatikisht."</string>
    <string name="debug_autofill_category" msgid="8050326960545979035">"Plotësim automatik"</string>
    <string name="autofill_logging_level_title" msgid="899483289251346778">"Niveli i identifikimit"</string>
    <string name="autofill_max_partitions" msgid="7590272120101271461">"Kërkesat maksimale për seancë"</string>
    <string name="autofill_max_visible_datasets" msgid="4531033613378881109">"Setet maksimale të dukshme të të dhënave"</string>
    <string name="autofill_reset_developer_options" msgid="5819016237049525099">"Rivendos në vlerat e parazgjedhura"</string>
    <string name="autofill_reset_developer_options_complete" msgid="7548288932341619412">"Opsionet e plotësimit automatik të zhvilluesit janë rivendosur"</string>
    <string name="device_theme" msgid="4571803018917608588">"Tema e pajisjes"</string>
    <string name="default_theme" msgid="7085644992078579076">"I parazgjedhur"</string>
    <string name="show_operator_name_title" msgid="805135053530442951">"Emri i rrjetit"</string>
    <string name="show_operator_name_summary" msgid="5962567590205757550">"Shfaq emrin e rrjetit në shiritin e statusit"</string>
    <string name="storage_manager_indicator" msgid="1516810749625915020">"Menaxheri i hapësirës ruajtëse: <xliff:g id="STATUS">^1</xliff:g>"</string>
    <string name="storage_manager_indicator_off" msgid="7488057587180724388">"Joaktiv"</string>
    <string name="storage_manager_indicator_on" msgid="8625551710194584733">"Aktiv"</string>
    <string name="install_type_instant" msgid="3174425974536078647">"Aplikacioni i çastit"</string>
    <string name="automatic_storage_manager_deactivation_warning" msgid="5605210730828410482">"Të çaktivizohet menaxheri i hapësirës ruajtëse?"</string>
    <string name="storage_movies_tv" msgid="5498394447562086890">"Apl. e filmave dhe shfaqjeve televizive"</string>
    <string name="carrier_provisioning" msgid="4398683675591893169">"Informacionet e përgatitjes së operatorit celular"</string>
    <string name="trigger_carrier_provisioning" msgid="3434865918009286187">"Aktivizo përgatitjen e operatorit celular"</string>
    <string name="zen_suggestion_title" msgid="798067603460192693">"Përditëso modalitetin \"Mos shqetëso\""</string>
    <string name="zen_suggestion_summary" msgid="5928686804697233014">"Vendos njoftimet në pauzë për të qëndruar i fokusuar"</string>
    <string name="disabled_low_ram_device" msgid="3751578499721173344">"Ky funksion nuk ofrohet në këtë pajisje"</string>
    <string name="disabled_feature" msgid="3232554901854971743">"Veçoria nuk ofrohet"</string>
    <string name="disabled_feature_reason_slow_down_phone" msgid="3557117039415422481">"Kjo veçori është çaktivizuar sepse ngadalëson telefonin tënd"</string>
    <string name="enable_gnss_raw_meas_full_tracking" msgid="1294470289520660584">"Matjet GNSS me fuqi të plotë"</string>
    <string name="enable_gnss_raw_meas_full_tracking_summary" msgid="496344699046454200">"Gjurmo të gjitha koleksionet dhe frekuencat e GNSS pa ciklim të detyruar"</string>
    <string name="show_first_crash_dialog" msgid="8889957119867262599">"Gjithmonë shfaq dialogun e ndërprerjes aksidentale"</string>
    <string name="show_first_crash_dialog_summary" msgid="703224456285060428">"Shfaq dialogun sa herë që një aplikacion pëson ndërprerje aksidentale"</string>
    <string name="angle_enabled_app" msgid="1841862539745838255">"Zgjidh aplikacionin e aktivizuar për ANGLE"</string>
    <string name="angle_enabled_app_not_set" msgid="864740024581634768">"Nuk është caktuar aplikacion i aktivizuar për ANGLE"</string>
    <string name="angle_enabled_app_set" msgid="226015765615525056">"Aplikacioni i aktivizuar për ANGLE: <xliff:g id="APP_NAME">%1$s</xliff:g>"</string>
    <string name="game_driver_dashboard_title" msgid="8804074441354504919">"Preferencat e \"Drejtuesit të lojës\""</string>
    <string name="game_driver_dashboard_summary" msgid="2392113100578771289">"Modifiko cilësimet e \"Drejtuesit të lojës\""</string>
    <string name="game_driver_footer_text" msgid="3202576403048267763">"Kur \"Drejtuesi i lojës\" është i aktivizuar, mund të zgjedhësh të përdorësh drejtuesin e përditësuar të grafikës për aplikacionet e instaluara në pajisje."</string>
    <string name="game_driver_all_apps_preference_title" msgid="6067527642706295180">"Aktivizo për të gjitha aplikacionet"</string>
    <string name="game_driver_app_preference_title" msgid="5072626013346650374">"Zgjidh drejtuesin e grafikës"</string>
    <string name="game_driver_app_preference_default" msgid="7686384740483216333">"E parazgjedhur"</string>
    <string name="game_driver_app_preference_game_driver" msgid="6426312331295324606">"Drejtuesi i lojës"</string>
    <string name="game_driver_app_preference_prerelease_driver" msgid="1295460693830677733">"Drejtuesi para publikimit zyrtar"</string>
    <string name="game_driver_app_preference_system" msgid="8272672982113332753">"Drejtuesi i grafikës së sistemit"</string>
    <!-- no translation found for game_driver_all_apps_preference_values:0 (7193648562434970105) -->
    <!-- no translation found for game_driver_all_apps_preference_values:1 (7189663725490629463) -->
    <!-- no translation found for game_driver_app_preference_values:0 (4271044622117073985) -->
    <!-- no translation found for game_driver_app_preference_values:1 (6628516810440406199) -->
    <!-- no translation found for game_driver_app_preference_values:2 (1760397725970916076) -->
    <string name="unsupported_setting_summary" product="default" msgid="11246953620654225">"Cilësimi nuk mbështetet në këtë telefon"</string>
    <string name="unsupported_setting_summary" product="tablet" msgid="6328431665635673717">"Cilësimi nuk mbështetet në këtë tablet"</string>
    <string name="unsupported_setting_summary" product="device" msgid="2348970994972110886">"Cilësimi nuk mbështetet në këtë pajisje"</string>
    <string name="disabled_for_user_setting_summary" msgid="3388525317680711262">"Cilësimi nuk mund të ndryshohet nga përdoruesi aktual"</string>
    <string name="disabled_dependent_setting_summary" msgid="8291322239940946902">"Varet nga një cilësim tjetër"</string>
    <string name="unknown_unavailability_setting_summary" msgid="4589584678033059435">"Cilësimi nuk ofrohet"</string>
    <string name="my_device_info_account_preference_title" msgid="342933638925781861">"Llogaria"</string>
    <string name="my_device_info_device_name_preference_title" msgid="7104085224684165324">"Emri i pajisjes"</string>
    <string name="change_wifi_state_title" msgid="3261945855372885427">"Kontrolli i lidhjes Wi-Fi"</string>
    <string name="change_wifi_state_app_detail_switch" msgid="7942268646980694224">"Lejo që aplikacioni të kontrollojë lidhjen Wi-Fi"</string>
    <string name="change_wifi_state_app_detail_summary" msgid="8434262633905502679">"Lejo që ky aplikacion të aktivizojë ose të çaktivizojë Wi-Fi, të skanojë dhe të lidhet me rrjetet Wi-Fi, të shtojë ose të heqë rrjetet ose të nisë një zonë të qasje për internetin vetëm në nivel lokal"</string>
    <string name="media_output_title" msgid="115223550977351699">"Luaj median te"</string>
    <string name="media_output_default_summary" msgid="8115153381240348279">"Kjo pajisje"</string>
    <string name="media_output_summary" product="default" msgid="6839458453831567167">"Telefoni"</string>
    <string name="media_output_summary" product="tablet" msgid="7217221078578554515">"Tablet"</string>
    <string name="media_output_summary" product="device" msgid="5677420090811068649">"Pajisja"</string>
    <string name="media_out_summary_ongoing_call_state" msgid="3533731701018680693">"Nuk ofrohet gjatë telefonatave"</string>
    <string name="media_output_summary_unavailable" msgid="7970304720507697019">"Nuk ofrohet"</string>
    <string name="take_call_on_title" msgid="6066362463436122655">"Prano telefonatën te"</string>
    <string name="cannot_change_apn_toast" msgid="4652498125702594916">"Ky emër APN nuk mund të ndryshohet."</string>
    <string name="battery_suggestion_title" product="tablet" msgid="752439050748267917">"Përmirëso kohëzgjatjen e baterisë së tabletit"</string>
    <string name="battery_suggestion_title" product="device" msgid="1507272328369733005">"Përmirëso kohëzgjatjen e baterisë së pajisjes"</string>
    <string name="battery_suggestion_title" product="default" msgid="4038053023336285165">"Përmirëso kohëzgjatjen e baterisë së telefonit"</string>
    <string name="battery_suggestion_summary" msgid="4585677159811722359"></string>
    <string name="gesture_prevent_ringing_screen_title" msgid="7840226017975251549">"Parandalo zilen"</string>
    <string name="gesture_prevent_ringing_title" msgid="5961391929839748111">"Shtyp së bashku butonin e energjisë dhe atë të ngritjes së volumit për"</string>
    <string name="gesture_prevent_ringing_sound_title" msgid="5724512060316688779">"Shkurtore për të parandaluar zilen"</string>
    <string name="prevent_ringing_option_vibrate" msgid="7286821846542822661">"Dridhje"</string>
    <string name="prevent_ringing_option_mute" msgid="7551545579059879853">"Pa zë"</string>
    <string name="prevent_ringing_option_none" msgid="4656046650769569175">"Mos bëj asgjë"</string>
    <string name="prevent_ringing_option_vibrate_summary" msgid="1157524435626890116">"Aktiv (me dridhje)"</string>
    <string name="prevent_ringing_option_mute_summary" msgid="4472465110708640980">"Aktiv (i heshtur)"</string>
    <string name="prevent_ringing_option_none_summary" msgid="5013718946609276137">"Joaktiv"</string>
    <string name="pref_title_network_details" msgid="7186418845727358964">"Detajet e rrjetit"</string>
    <string name="about_phone_device_name_warning" msgid="8885670415541365348">"Emri i pajisjes sate është i dukshëm për aplikacionet në telefonin tënd. Ai mund të shikohet po ashtu nga persona të tjerë kur lidhesh me pajisje me Bluetooth ose kur konfiguron një zonë të qasjes për internet me Wi-Fi."</string>
    <string name="devices_title" msgid="7701726109334110391">"Pajisjet"</string>
    <string name="homepage_all_settings" msgid="1245540304900512919">"Të gjitha cilësimet"</string>
    <string name="homepage_personal_settings" msgid="1570415428680432319">"Sugjerime"</string>
    <string name="choose_network_title" msgid="5702586742615861037">"Zgjidh rrjetin"</string>
    <string name="network_disconnected" msgid="2933191767567503504">"I shkëputur"</string>
    <string name="network_connected" msgid="4943925032253989621">"Lidhur"</string>
    <string name="network_connecting" msgid="76404590784733557">"Po lidhet…"</string>
    <string name="network_could_not_connect" msgid="1113813392274155369">"Nuk mund të lidhej"</string>
    <string name="empty_networks_list" msgid="2578752112731781190">"Nuk u gjetën rrjete."</string>
    <string name="network_query_error" msgid="7487714485362598410">"Rrjetet nuk mund të gjendeshin. Provo përsëri."</string>
    <string name="forbidden_network" msgid="4626592887509826545">"(ndalohet)"</string>
    <string name="no_sim_card" msgid="1360669528113557381">"Nuk ka kartë SIM"</string>
    <string name="preferred_network_mode_wcdma_perf_summary" msgid="3956515670308744433">"Modaliteti i rrjetit të preferuar: preferohet WCDMA"</string>
    <string name="preferred_network_mode_gsm_only_summary" msgid="5225727680228194864">"Modaliteti i rrjetit të preferuar: vetëm GSM"</string>
    <string name="preferred_network_mode_wcdma_only_summary" msgid="8956197584659205699">"Modaliteti i rrjetit të preferuar: vetëm WCDMA"</string>
    <string name="preferred_network_mode_gsm_wcdma_summary" msgid="4290654515569144276">"Modaliteti i rrjetit të preferuar: GSM / WCDMA"</string>
    <string name="preferred_network_mode_cdma_summary" msgid="854981096234906594">"Modaliteti i rrjetit të preferuar: CDMA"</string>
    <string name="preferred_network_mode_cdma_evdo_summary" msgid="2578065433446506616">"Modaliteti i rrjetit të preferuar: CDMA / EvDo"</string>
    <string name="preferred_network_mode_cdma_only_summary" msgid="6604102246309629962">"Modaliteti i rrjetit të preferuar: vetëm CDMA"</string>
    <string name="preferred_network_mode_evdo_only_summary" msgid="7558385602277592784">"Modaliteti i rrjetit të preferuar: vetëm EvDo"</string>
    <string name="preferred_network_mode_cdma_evdo_gsm_wcdma_summary" msgid="1742638677806401815">"Modaliteti i rrjetit të preferuar: CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_lte_summary" msgid="8528755811985330696">"Modaliteti i rrjetit të preferuar: LTE"</string>
    <string name="preferred_network_mode_lte_gsm_wcdma_summary" msgid="6632007438739933645">"Modaliteti i rrjetit të preferuar: GSM/WCDMA/LTE"</string>
    <string name="preferred_network_mode_lte_cdma_evdo_summary" msgid="5464960267483576515">"Modaliteti i rrjetit të preferuar: CDMA+LTE/EVDO"</string>
    <string name="preferred_network_mode_global_summary" msgid="8552400100470153638">"Modaliteti i rrjetit të preferuar: Global"</string>
    <string name="preferred_network_mode_lte_wcdma_summary" msgid="8037915274486919940">"Modaliteti i rrjetit të preferuar: LTE / WCDMA"</string>
    <string name="preferred_network_mode_lte_gsm_umts_summary" msgid="104110625441127919">"Modaliteti i rrjetit të preferuar: LTE / GSM / UMTS"</string>
    <string name="preferred_network_mode_lte_cdma_summary" msgid="2561159741461407053">"Modaliteti i rrjetit të preferuar: LTE / CDMA"</string>
    <string name="preferred_network_mode_tdscdma_summary" msgid="1111689194136766011">"Modaliteti i rrjetit të preferuar: TDSCDMA"</string>
    <string name="preferred_network_mode_tdscdma_wcdma_summary" msgid="4272515966019344433">"Modaliteti i rrjetit të preferuar: TDSCDMA / WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_summary" msgid="3138210224248737600">"Modaliteti i rrjetit të preferuar: LTE / TDSCDMA"</string>
    <string name="preferred_network_mode_tdscdma_gsm_summary" msgid="7575595856957063853">"Modaliteti i rrjetit të preferuar: TDSCDMA / GSM"</string>
    <string name="preferred_network_mode_lte_tdscdma_gsm_summary" msgid="1512046749970721629">"Modaliteti i rrjetit të preferuar: LTE/GSM/TDSCDMA"</string>
    <string name="preferred_network_mode_tdscdma_gsm_wcdma_summary" msgid="1038314909945393905">"Modaliteti i rrjetit të preferuar: TDSCDMA/GSM/WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_wcdma_summary" msgid="3277980364222159279">"Modaliteti i rrjetit të preferuar: LTE/TDSCDMA/WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_gsm_wcdma_summary" msgid="1572937828071126891">"Modaliteti i rrjetit të preferuar: LTE/TDSCDMA/GSM/WCDMA"</string>
    <string name="preferred_network_mode_tdscdma_cdma_evdo_gsm_wcdma_summary" msgid="8393145171649288912">"Modaliteti i rrjetit të preferuar: TDSCDMA/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_cdma_evdo_gsm_wcdma_summary" msgid="5544016990994809932">"Modaliteti i rrjetit të preferuar: LTE/TDSCDMA/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="network_lte" msgid="1287709529829131860">"LTE (rekomandohet)"</string>
    <string name="network_4G" msgid="8611758013994499559">"4G (rekomandohet)"</string>
    <string name="network_global" msgid="959947774831178632">"Globale"</string>
    <string name="label_available" msgid="1731547832803057893">"Rrjete të arritshme"</string>
    <string name="load_networks_progress" msgid="7709402068413190831">"Po kërkon…"</string>
    <string name="register_on_network" msgid="766516026652295941">"Po regjistron në <xliff:g id="NETWORK">%s</xliff:g>…"</string>
    <string name="not_allowed" msgid="1667079919821581706">"Karta SIM nuk lejon lidhje me këtë rrjet."</string>
    <string name="connect_later" msgid="978991102125216741">"Nuk mund të lidhet me këtë rrjet tani. Provo sërish më vonë."</string>
    <string name="registration_done" msgid="4573820010512184521">"Regjistruar në rrjet."</string>
    <string name="select_automatically" msgid="7318032984017853975">"Zgjidh automatikisht rrjetin"</string>
    <string name="carrier_settings_title" msgid="3503012527671299886">"Cilësimet e operatorit"</string>
    <string name="cdma_lte_data_service" msgid="8507044148856536098">"Konfiguro shërbimin e të dhënave"</string>
    <string name="mobile_data_settings_title" msgid="7674604042461065482">"Të dhënat celulare"</string>
    <string name="mobile_data_settings_summary" msgid="2708261377199805404">"Qasu te të dhënat duke përdorur rrjetin celular"</string>
    <string name="mobile_data_settings_summary_auto_switch" msgid="2914985502279794000">"Telefoni do të kalojë automatikisht te ky operator celular kur të jetë brenda rrezes"</string>
    <string name="calls_preference" msgid="4628557570999372758">"Preferencat e telefonatave"</string>
    <string name="sms_preference" msgid="3479810211828513772">"Preferenca për SMS"</string>
    <string name="calls_and_sms_ask_every_time" msgid="2127802836576375306">"Pyet çdo herë"</string>
    <string name="mobile_network_summary_add_a_network" msgid="9148476748420654283">"Shto një rrjet"</string>
    <plurals name="mobile_network_summary_count" formatted="false" msgid="4505694491027023039">
      <item quantity="other"><xliff:g id="COUNT_1">%1$d</xliff:g> karta SIM</item>
      <item quantity="one"><xliff:g id="COUNT_0">%1$d</xliff:g> kartë SIM</item>
    </plurals>
    <string name="default_for_calls" msgid="6732520879241581841">"E parazgjedhur për telefonatat"</string>
    <string name="default_for_sms" msgid="294276190503132313">"E parazgjedhur për SMS"</string>
    <string name="default_for_calls_and_sms" msgid="3862322027700754792">"E parazgjedhur për telefonatat dhe SMS"</string>
    <string name="default_for_mobile_data" msgid="955987144209828344">"E parazgjedhur për të dhënat celulare"</string>
    <string name="mobile_data_active" msgid="5108294051762397700">"Të dhënat celulare janë aktive"</string>
    <string name="mobile_data_off" msgid="5831854766113105657">"Të dhënat celulare janë joaktive"</string>
    <string name="subscription_available" msgid="6502502298446954785">"Në shitje"</string>
    <string name="mobile_network_in_range" msgid="8212440637838603215">"Brenda rrezes"</string>
    <string name="mobile_network_not_in_range" msgid="5287596455212313284">"Nuk është brenda rrezes"</string>
    <string name="mobile_network_list_add_more" msgid="4000806369124701679">"Shto më shumë"</string>
    <string name="mobile_network_active_sim" msgid="2375956837678169169">"Aktiv / SIM"</string>
    <string name="mobile_network_inactive_sim" msgid="291768076436646044">"Joaktiv / SIM"</string>
    <string name="mobile_network_active_esim" msgid="4914509039134228659">"Aktiv / karta SIM e shkarkuar"</string>
    <string name="mobile_network_inactive_esim" msgid="7653631389686307842">"Joaktiv / karta SIM e shkarkuar"</string>
    <string name="mobile_network_sim_name" msgid="6026120971523242277">"Emri i kartës SIM dhe ngjyra"</string>
    <string name="mobile_network_sim_name_label" msgid="281403463781467324">"Emri"</string>
    <string name="mobile_network_sim_color_label" msgid="3662112943353180621">"Ngjyra (e përdorur nga aplikacionet e përputhshme)"</string>
    <string name="mobile_network_sim_name_rename" msgid="3082357234342116252">"Ruaj"</string>
    <string name="mobile_network_use_sim_on" msgid="8035448244261570189">"Përdor kartën SIM"</string>
    <string name="mobile_network_use_sim_off" msgid="889073420068380943">"Joaktive"</string>
    <string name="mobile_network_disable_sim_explanation" msgid="1515981880164339357">"Për ta çaktivizuar këtë kartë SIM, hiqe kartën SIM"</string>
    <string name="mobile_network_tap_to_activate" msgid="4573431375941175566">"Trokit për të aktivizuar <xliff:g id="CARRIER">%1$s</xliff:g>"</string>
    <string name="mobile_network_esim_swap_confirm_title" msgid="6546784593612512953">"Do të kalosh te <xliff:g id="CARRIER">%1$s</xliff:g>?"</string>
    <string name="mobile_network_esim_swap_confirm_body" msgid="1621021150667547211">"Vetëm një kartë SIM e shkarkuar mund të jetë aktive në të njëjtën kohë.\n\nKalimi te <xliff:g id="CARRIER1">%1$s</xliff:g> nuk do ta anulojë shërbimin e <xliff:g id="CARRIER2">%2$s</xliff:g>."</string>
    <string name="mobile_network_esim_swap_confirm_ok" msgid="8025086398614992834">"Kalo te <xliff:g id="CARRIER">%1$s</xliff:g>"</string>
    <string name="mobile_network_erase_sim" msgid="896275511321635947">"Spastro kartën SIM"</string>
    <string name="mobile_network_erase_sim_dialog_title" msgid="8211945787729023193">"Dëshiron ta pastrosh këtë kartë SIM të shkarkuar?"</string>
    <string name="mobile_network_erase_sim_dialog_body" msgid="3363079846287650684">"Spastrimi i kësaj karte SIM e heq shërbimin e <xliff:g id="CARRIER_0">%1$s</xliff:g> nga kjo pajisje.\n\nShërbimi për <xliff:g id="CARRIER_1">%2$s</xliff:g> nuk do të anulohet."</string>
    <string name="mobile_network_erase_sim_dialog_ok" msgid="5130805470041783437">"Spastro"</string>
    <string name="mobile_network_erase_sim_dialog_progress" msgid="6541813899575453878">"Karta SIM po spastrohet…"</string>
    <string name="mobile_network_erase_sim_error_dialog_title" msgid="730767308428197756">"Karta SIM nuk mund të spastrohet"</string>
    <string name="mobile_network_erase_sim_error_dialog_body" msgid="6835262809290075813">"Kjo kartë SIM nuk mund të spastrohet për shkak të një gabimi.\n\nRinise pajisjen dhe provo përsëri."</string>
    <string name="preferred_network_mode_title" msgid="6505630109389684100">"Lloji i rrjetit të preferuar"</string>
    <string name="preferred_network_mode_summary" msgid="1216219115667163264">"Ndrysho modalitetin e operimit të rrjetit"</string>
    <string name="preferred_network_mode_dialogtitle" msgid="849254040214447984">"Lloji i rrjetit të preferuar"</string>
    <string name="carrier_settings_euicc" msgid="8658562169133242581">"Operatori celular"</string>
    <string name="carrier_settings_version" msgid="3469507893844448432">"Versioni i cilësimeve"</string>
    <string name="call_category" msgid="8108654745239563833">"Po telefonon"</string>
    <string name="video_calling_settings_title" msgid="8153216918491498505">"Telefonata me video e operatorit celular"</string>
    <string name="cdma_system_select_title" msgid="7210256688912895790">"Përzgjedhja e sistemit"</string>
    <string name="cdma_system_select_summary" msgid="3413863051181111941">"Ndrysho modalitetin CDMA të roaming-ut"</string>
    <string name="cdma_system_select_dialogtitle" msgid="1198883288864916563">"Përzgjedhja e sistemit"</string>
    <string name="network_operator_category" msgid="8451238364605724918">"Rrjeti"</string>
    <string name="network_select_title" msgid="8394621216255081026">"Rrjeti"</string>
    <string name="cdma_subscription_title" msgid="1473189596933979467">"Abonimi CDMA"</string>
    <string name="cdma_subscription_summary" msgid="7191590908367194209">"Ndrysho mes RUIM/SIM dhe NV"</string>
    <string name="cdma_subscription_dialogtitle" msgid="9153005469617575361">"abonimi"</string>
    <string name="register_automatically" msgid="518185886971595020">"Regjistrim automatik…"</string>
    <string name="roaming_alert_title" msgid="7458177294163751484">"Të lejohet shfrytëzimi i roaming-ut?"</string>
    <string name="roaming_check_price_warning" msgid="4979418631753681300">"Kontakto me operatorin celular të rrjetit për çmimin."</string>
    <string name="mobile_data_usage_title" msgid="7862429216994894656">"Përdorimi i të dhënave të aplikacioneve"</string>
    <string name="mobile_network_mode_error" msgid="4784347953600013818">"Regjim i pavlefshëm i rrjetit <xliff:g id="NETWORKMODEID">%1$d</xliff:g>. Shpërfille."</string>
    <string name="mobile_network_apn_title" msgid="7610812642954395440">"Emrat e pikës së qasjes"</string>
    <string name="manual_mode_disallowed_summary" msgid="2085670341790561153">"Nuk ofrohet kur është e lidhur me <xliff:g id="CARRIER">%1$s</xliff:g>"</string>
    <string name="emergency_info_contextual_card_summary" msgid="7993926837251874514">"Informacioni mjekësor, kontaktet e urgjencës"</string>
    <string name="see_more" msgid="5953815986207345223">"Shiko më shumë"</string>
    <string name="see_less" msgid="1250265310929558370">"Shiko më pak"</string>
    <string name="network_connection_request_dialog_title" msgid="3502355504717957803">"Pajisja që do të përdoret me <xliff:g id="APPNAME">%1$s</xliff:g>"</string>
    <string name="network_connection_timeout_dialog_message" msgid="3711556077945728716">"Nuk u gjet asnjë pajisje. Sigurohu që pajisjet të jenë të ndezura dhe të gatshme për t\'u lidhur."</string>
    <string name="network_connection_timeout_dialog_ok" msgid="8924405960181020156">"Provo sërish"</string>
    <string name="network_connection_errorstate_dialog_message" msgid="6953778550775646710">"Ndodhi diçka. Aplikacioni ka anuluar kërkesën për të zgjedhur një pajisje."</string>
    <string name="network_connection_connect_successful" msgid="5935510954474494928">"Lidhja ishte e suksesshme"</string>
    <string name="network_connection_request_dialog_showall" msgid="6938922880244567521">"Shfaq të gjitha"</string>
    <plurals name="show_bluetooth_devices" formatted="false" msgid="1715020480026568408">
      <item quantity="other"><xliff:g id="NUMBER_DEVICE_COUNT_1">%1$d</xliff:g> pajisje të lidhura</item>
      <item quantity="one"><xliff:g id="NUMBER_DEVICE_COUNT_0">%1$d</xliff:g> pajisje e lidhur</item>
    </plurals>
    <string name="no_bluetooth_devices" msgid="861861879657732058">"Nuk ka asnjë pajisje me Bluetooth"</string>
    <string name="bluetooth_left_name" msgid="2133431890020995442">"Majtas"</string>
    <string name="bluetooth_right_name" msgid="525578831502355410">"Djathtas"</string>
    <string name="bluetooth_middle_name" msgid="3272836932362043957">"Kasa"</string>
    <string name="settings_panel_title" msgid="4688575606213055744">"Paneli i \"Cilësimeve\""</string>
    <string name="internet_connectivity_panel_title" msgid="721392242301676444">"Lidhshmëria e internetit"</string>
    <string name="volume_connectivity_panel_title" msgid="9192664643867101356">"Volumi"</string>
    <string name="mobile_data_ap_mode_disabled" msgid="1127588179830051811">"Nuk ofrohen në modalitetin e aeroplanit"</string>
    <string name="force_desktop_mode" msgid="4303240595324847998">"Detyro \"modalitetin e desktopit\""</string>
    <string name="force_desktop_mode_summary" msgid="6259798246015387202">"Detyro \"modalitetin e desktopit\" eksperimental në ekrane dytësore"</string>
    <string name="hwui_force_dark_title" msgid="2466919877609396257">"Anulo detyrimin e errësimit"</string>
    <string name="hwui_force_dark_summary" msgid="8705328793382981780">"Anulon funksionin e detyrimit të errësimit që të jetë gjithmonë aktiv"</string>
    <string name="privacy_dashboard_title" msgid="2458407399263943923">"Privatësia"</string>
    <string name="privacy_dashboard_summary" msgid="4570241983077984329">"Autorizimet, aktiviteti i llogarisë, të dhënat personale"</string>
    <string name="contextual_card_dismiss_remove" msgid="2813670241047194713">"Hiq"</string>
    <string name="contextual_card_dismiss_keep" msgid="2230740610451447340">"Mbaj"</string>
    <string name="contextual_card_dismiss_confirm_message" msgid="5507487987591500742">"Të hiqet ky sugjerim?"</string>
    <string name="contextual_card_removed_message" msgid="6744732110721136227">"Sugjerimi u hoq"</string>
    <string name="contextual_card_undo_dismissal_text" msgid="3564089284222177020">"Zhbëj"</string>
    <string name="low_storage_summary" msgid="2077564126033530">"Hapësira ruajtëse është e ulët. <xliff:g id="PERCENTAGE">%1$s</xliff:g> të përdorura - <xliff:g id="FREE_SPACE">%2$s</xliff:g> të lira"</string>
    <string name="contextual_card_feedback_send" msgid="2996691837358030021">"Dërgo komente"</string>
    <string name="contextual_card_feedback_confirm_message" msgid="8115454795160804779">"Dëshiron të na japësh komentet e tua për këtë sugjerim?"</string>
    <string name="copyable_slice_toast" msgid="2924110841440836023">"<xliff:g id="COPY_CONTENT">%1$s</xliff:g> u kopjua në kujtesën e fragmenteve."</string>
    <string name="search_bar_account_avatar_content_description" msgid="4718261366290530792"></string>
    <string name="permission_bar_chart_empty_text" msgid="4380731551728553852">"0 aplikacione përdorën autorizimet"</string>
    <string name="permission_bar_chart_title" msgid="2745425703472199837">"Përdorimi i autorizimeve në 24 orët e fundit"</string>
    <string name="permission_bar_chart_details" msgid="2977943114535855210">"Shikoji të gjitha te \"Paneli\""</string>
    <plurals name="permission_bar_chart_label" formatted="false" msgid="5346938677887948252">
      <item quantity="other"><xliff:g id="NUMBER">%s</xliff:g> aplikacione</item>
      <item quantity="one">1 aplikacion</item>
    </plurals>
    <string name="accessibility_usage_title" msgid="5136753034714150614">"Përdorimi i qasshmërisë"</string>
    <plurals name="accessibility_usage_summary" formatted="false" msgid="5790789101231115740">
      <item quantity="other"><xliff:g id="SERVICE_COUNT">%1$d</xliff:g> aplikacione kanë qasje të plotë te pajisja jote</item>
      <item quantity="one">1 aplikacion ka qasje të plotë te pajisja jote</item>
    </plurals>
    <string name="manage_app_notification" msgid="4575452737886198216">"Menaxho njoftimet e <xliff:g id="APP_NAME">%1$s</xliff:g>"</string>
    <string name="no_suggested_app" msgid="5722034393216359231">"Asnjë aplikacion i sugjeruar"</string>
    <plurals name="notification_few_channel_count_summary" formatted="false" msgid="1090888820158822106">
      <item quantity="other"><xliff:g id="NOTIFICATION_CHANNEL_COUNT_1">%1$d</xliff:g> kanale njoftimi.</item>
      <item quantity="one"><xliff:g id="NOTIFICATION_CHANNEL_COUNT_0">%1$d</xliff:g> kanal njoftimi.</item>
    </plurals>
    <string name="notification_many_channel_count_summary" msgid="8647409434789898073">"<xliff:g id="NOTIFICATION_CHANNEL_COUNT">%1$d</xliff:g> kanale njoftimi. Trokit për t\'i menaxhuar të gjitha."</string>
    <string name="recently_installed_app" msgid="2877671740090335492">"Ke instaluar së fundi këtë aplikacion."</string>
    <string name="media_output_panel_title" msgid="6197092814295528184">"Ndrysho daljen"</string>
    <string name="media_output_panel_summary_of_playing_device" msgid="629529380940058789">"Aktualisht po luhet në <xliff:g id="DEVICE_NAME">%1$s</xliff:g>"</string>
    <string name="wfc_disclaimer_title_text" msgid="6164569741719679613">"Informacione të rëndësishme"</string>
    <string name="wfc_disclaimer_agree_button_text" msgid="1405773141236165542">"VAZHDO"</string>
    <string name="wfc_disclaimer_disagree_text" msgid="2700358281438736674">"JO, FALEMINDERIT"</string>
    <string name="wfc_disclaimer_location_title_text" msgid="6658735446562619865">"Vendndodhja"</string>
    <string name="wfc_disclaimer_location_desc_text" msgid="3096546236221656018">"Ofruesi yt i shërbimit mund të marrë vendndodhjen tënde për të ofruar këtë shërbim.\n\nRishiko politikën e privatësisë së ofruesit të shërbimit."</string>
    <string name="forget_passpoint_dialog_message" msgid="7331876195857622224">"Mund të humbasësh qasjen për çdo kohë ose të dhënë të mbetur. Kontakto me ofruesin tënd para se ta heqësh."</string>
    <string name="keywords_content_capture" msgid="8252675452668954083">"regjistrimi i përmbajtjes, përmbajtja e aplikacionit"</string>
    <string name="content_capture" msgid="3210232615756364639">"Përmbajtja e aplikacionit"</string>
    <string name="content_capture_summary" msgid="659506647507221852">"Lejo që aplikacionet të dërgojnë përmbajtje te sistemi Android"</string>
    <string name="capture_system_heap_dump_title" msgid="8043655498113164693">"Regjistro stivën e skedarëve fiktivë të sistemit"</string>
    <string name="capturing_system_heap_dump_message" msgid="8680086369500395131">"Stiva e skedarëve fiktivë të sistemit po regjistrohet"</string>
    <string name="error_capturing_system_heap_dump_message" msgid="6346229989760615103">"Stiva e skedarëve fiktivë të sistemit nuk mund të regjistrohej"</string>
    <string name="automatic_system_heap_dump_title" msgid="442496436397957988">"Regjistro automatikisht stivat e skedarëve fiktivë të sistemit"</string>
    <string name="automatic_system_heap_dump_summary" msgid="8253838659009241350">"Regjistro automatikisht një stivë të skedarëve fiktivë për sistemin Android kur përdor shumë memorie"</string>
    <string name="wifi_disconnect_button_text" msgid="2032651902928903819">"Shkëput"</string>
    <string name="wfc_disclaimer_emergency_limitation_title_text" msgid="3354031536141983602">"Telefonata urgjence"</string>
    <string name="wfc_disclaimer_emergency_limitation_desc_text" msgid="6068582272230311464">"Telefonatat e urgjencës me \"Telefonata me Wi‑Fi\" nuk mbështeten nga operatori yt celular.\nPajisja kalon automatikisht në një rrjet celular për të kryer një telefonatë urgjence.\nTelefonatat e urgjencës janë të mundshme vetëm në zonat me mbulim celular."</string>
    <string name="wifi_calling_summary" msgid="513599567573172420">"Përdor Wi‑Fi për telefonatat për të përmirësuar cilësinë"</string>
    <string name="enable_receiving_mms_notification_title" msgid="8809328429865242752">"Mesazh MMS në ardhje"</string>
    <string name="enable_sending_mms_notification_title" msgid="3852773093703966351">"Mesazhi MMS nuk mund të dërgohet"</string>
    <string name="enable_mms_notification_summary" msgid="7643379825980866408">"Trokit për të lejuar mesazhet MMS në <xliff:g id="OPERATOR_NAME">%1$s</xliff:g> kur të dhënat celulare janë të çaktivizuara"</string>
    <string name="enable_mms_notification_channel_title" msgid="4402474709766126987">"Mesazh MMS"</string>
    <string name="sim_combination_warning_notification_title" msgid="3717178238465948430">"Lësho me kombinimin e kartës SIM"</string>
    <string name="dual_cdma_sim_warning_notification_summary" msgid="2602011424635850202">"Përdorimi i <xliff:g id="OPERATOR_NAMES">%1$s</xliff:g> mund të kufizojë funksionimin. Trokit për të mësuar më shumë."</string>
    <string name="dual_cdma_sim_warning_notification_channel_title" msgid="4144088600737896010">"Kombinimi i kartës SIM"</string>
    <string name="work_policy_privacy_settings" msgid="2348992644755730215">"Informacioni i politikës sate të punës"</string>
    <string name="work_policy_privacy_settings_summary" msgid="2236899807429121767">"Cilësimet menaxhohen nga administratori yt i TI-së"</string>
</resources>
