<?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="1999566976857398962">"Po"</string>
    <string name="no" msgid="5541738710521607130">"Jo"</string>
    <string name="create" msgid="986997212165228751">"Krijo"</string>
    <string name="allow" msgid="3763244945363657722">"Lejo"</string>
    <string name="deny" msgid="7326117222944479942">"Refuzo"</string>
    <string name="confirmation_turn_on" msgid="2979094011928347665">"Aktivizo"</string>
    <string name="device_info_default" msgid="1406619232867343310">"I panjohur"</string>
    <plurals name="show_dev_countdown" formatted="false" msgid="1646187747875476269">
      <item quantity="other">Tani të duhen edhe <xliff:g id="STEP_COUNT_1">%1$d</xliff:g> hapa për t\'u bërë zhvillues.</item>
      <item quantity="one">Tani të duhet edhe <xliff:g id="STEP_COUNT_0">%1$d</xliff:g> hap për t\'u bërë zhvillues.</item>
    </plurals>
    <string name="show_dev_on" msgid="2840850085134853754">"Tani je zhvillues!"</string>
    <string name="show_dev_already" msgid="7041756429707644630">"Nuk ka nevojë, ti je programues tashmë!"</string>
    <string name="dev_settings_disabled_warning" msgid="6971867026249671244">"Aktivizo opsionet e zhvilluesit në fillim."</string>
    <string name="header_category_wireless_networks" msgid="303445626075235229">"Rrjetet me valë"</string>
    <string name="header_category_system" msgid="1665516346845259058">"Sistemi"</string>
    <string name="radioInfo_service_in" msgid="9088637745836646271">"Në shërbim"</string>
    <string name="radioInfo_service_out" msgid="1868347333892403287">"Jashtë shërbimit"</string>
    <string name="radioInfo_service_emergency" msgid="6838935881091760942">"Vetëm telefonata urgjence"</string>
    <string name="radioInfo_service_off" msgid="6184928420860868571">"Radioja joaktive"</string>
    <string name="radioInfo_roaming_in" msgid="8892550453644088692">"Roaming"</string>
    <string name="radioInfo_roaming_not" msgid="3137594549464975054">"Jo në roaming"</string>
    <string name="radioInfo_data_disconnected" msgid="362604130117666924">"I shkëputur"</string>
    <string name="radioInfo_data_connecting" msgid="7280819598028917888">"Po lidhet"</string>
    <string name="radioInfo_data_connected" msgid="8816467971633020141">"Lidhur"</string>
    <string name="radioInfo_data_suspended" msgid="2001254415431299603">"I pezulluar"</string>
    <string name="radioInfo_unknown" msgid="2892562356748600367">"E panjohur"</string>
    <string name="sdcard_unmount" product="nosdcard" msgid="1816306320988638382">"Shkëput hapësirën për ruajtje të USB-së"</string>
    <string name="sdcard_unmount" product="default" msgid="8078570285871053815">"Shkëput kartën SD"</string>
    <string name="sdcard_format" product="nosdcard" msgid="3248760426252305366">"Spastro hapësirën për ruajtje të USB-së"</string>
    <string name="sdcard_format" product="default" msgid="3676635435136326182">"Spastroje kartën SD"</string>
    <string name="preview_pager_content_description" msgid="3762247188224576303">"Pamja paraprake"</string>
    <string name="preview_page_indicator_content_description" msgid="2790254666634885865">"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="1296835853522566260">"Bëje tekstin në ekran më të vogël ose më të madh."</string>
    <string name="font_size_make_smaller_desc" msgid="4978038055549590140">"Zvogëlo"</string>
    <string name="font_size_make_larger_desc" msgid="5583046033381722247">"Zmadho"</string>
    <string name="auto_rotate_settings_primary_switch_title" msgid="3440951924928594520">"Përdor rrotullimin automatik"</string>
    <string name="smart_rotate_text_headline" msgid="5878008933992951904">"\"Zbulimi i fytyrës\" përdor kamerën e përparme për të përmirësuar saktësinë e rrotullimit automatik. Imazhet nuk ruhen apo dërgohen asnjëherë te Google."</string>
    <string name="font_size_preview_text_headline" msgid="1173103737980511652">"Teksti shembull"</string>
    <string name="font_size_preview_text_title" msgid="6363561029914452382">"Magjistari i mrekullueshëm i Ozit"</string>
    <string name="font_size_preview_text_subtitle" msgid="5806349524325544614">"Kapitulli 11: Qyteti i mrekullueshëm i smeraldtë i Ozit"</string>
    <string name="font_size_preview_text_body" msgid="3323732544011097199">"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="206892409190870726">"Në rregull"</string>
    <string name="sdcard_setting" product="nosdcard" msgid="6071836464978826249">"Hapësira ruajtëse e USB-së"</string>
    <string name="sdcard_setting" product="default" msgid="3713462184783824923">"Karta SD"</string>
    <string name="bluetooth" msgid="8898478620943459654">"Bluetooth-i"</string>
    <string name="bluetooth_is_discoverable" msgid="4798961627677790935">"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="8122823110652921674">"E dukshme për të gjitha pajisjet me \"Bluetooth\" në afërsi"</string>
    <string name="bluetooth_not_visible_to_other_devices" msgid="6181960579190879601">"Nuk është e dukshme te pajisjet e tjera me \"Bluetooth\""</string>
    <string name="bluetooth_only_visible_to_paired_devices" msgid="3574936359739213455">"E dukshme vetëm për pajisjet e çiftuara"</string>
    <string name="bluetooth_visibility_timeout" msgid="7611781967900196353">"Koha e veprimit mbi dukshmërinë skadoi pa sukses"</string>
    <string name="bluetooth_lock_voice_dialing" msgid="7405038248936935186">"Kyç formimin e numrit me zë"</string>
    <string name="bluetooth_lock_voice_dialing_summary" msgid="4959591522483403402">"Parandalo përdorimin e formuesit të numrit me Bluetooth kur ekrani është i kyçur."</string>
    <string name="bluetooth_devices" msgid="1063177983261608277">"Pajisjet me Bluetooth"</string>
    <string name="bluetooth_device_name" msgid="1294669733490268384">"Emri i pajisjes"</string>
    <string name="bluetooth_device_details" msgid="630702184344217832">"Cilësimet e pajisjes"</string>
    <string name="bluetooth_profile_details" msgid="1269419918127093325">"Cilësimet e profilit"</string>
    <string name="bluetooth_name_not_set" msgid="4654357917928126208">"Nuk është caktuar emër, po përdoret emri i llogarisë"</string>
    <string name="bluetooth_scan_for_devices" msgid="8143654526358934069">"Skano për pajisje"</string>
    <string name="bluetooth_rename_device" msgid="4219655243836021443">"Riemërto këtë pajisje"</string>
    <string name="bluetooth_rename_button" msgid="9162500408570289545">"Riemërto"</string>
    <string name="bluetooth_disconnect_title" msgid="4581951246357823044">"Të shkëputet pajisja?"</string>
    <string name="bluetooth_disconnect_all_profiles" product="default" msgid="1934297101665686854">"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="336622948210457991">"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="6944790936166852428">"Pajisja jote do të shkëputet nga <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="bluetooth_disconnect_dialog_ok" msgid="4173740094381092185">"Shkëput"</string>
    <string name="bluetooth_empty_list_user_restricted" msgid="909734990821975673">"Nuk ke leje për të ndryshuar cilësimet e \"Bluetooth-it\"."</string>
    <string name="bluetooth_pairing_pref_title" msgid="3497193027590444598">"Çifto pajisjen e re"</string>
    <string name="keywords_add_bt_device" msgid="4533191164203174011">"bluetooth"</string>
    <string name="bluetooth_pair_other_ear_dialog_title" msgid="3814943511999984012">"Çifto anën tjetër"</string>
    <string name="bluetooth_pair_other_ear_dialog_left_ear_message" msgid="7936892941892347102">"Aparati i dëgjimit në anën e majtë është lidhur.\n\nPër të çiftuar atë në anën e djathtë, sigurohu që ai të jetë i ndezur dhe gati për t\'u çiftuar."</string>
    <string name="bluetooth_pair_other_ear_dialog_right_ear_message" msgid="8242208936062915941">"Aparati i dëgjimit në anën e djathtë është lidhur.\n\nPër të çiftuar atë në anën e majtë, sigurohu që ai të jetë i ndezur dhe gati për t\'u çiftuar."</string>
    <string name="bluetooth_pair_other_ear_dialog_right_ear_positive_button" msgid="533612082529204078">"Çifto anën e djathtë"</string>
    <string name="bluetooth_pair_other_ear_dialog_left_ear_positive_button" msgid="6500192653171220257">"Çifto anën e majtë"</string>
    <string name="bluetooth_screen_related" msgid="7976543255501825536">"Të ngjashme"</string>
    <string name="bluetooth_is_visible_message" msgid="3811631869768157387">"<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="4782330594323261630">"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="1257226691967432025">"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="2863536947810007600">"Adresa e Bluetooth-it e pajisjes: <xliff:g id="BLUETOOTH_MAC_ADDRESS">%1$s</xliff:g>"</string>
    <string name="bluetooth_is_disconnect_question" msgid="777406775955421784">"Të shkëputet <xliff:g id="DEVICE_NAME">%1$s</xliff:g>?"</string>
    <string name="bluetooth_broadcasting" msgid="6379176741690311973">"Transmetimi"</string>
    <string name="bluetooth_device" msgid="2217973503732544291">"Pajisje me \"Bluetooth\" e paemërtuar"</string>
    <string name="progress_scanning" msgid="2564746192843011826">"Po kërkon"</string>
    <string name="bluetooth_no_devices_found" msgid="7704539337219953182">"Nuk u gjet asnjë pajisje me Bluetooth në afërsi."</string>
    <string name="bluetooth_notif_ticker" msgid="209515545257862858">"Kërkesë çiftimi me Bluetooth"</string>
    <string name="bluetooth_notif_title" msgid="1196532269131348647">"Kërkesa e çiftimit"</string>
    <string name="bluetooth_notif_message" msgid="5584717784198086653">"Trokit për ta çiftuar me <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="bluetooth_show_received_files" msgid="685424727760622632">"Skedarët e marrë"</string>
    <string name="bluetooth_devices_card_off_title" msgid="1320149821945129127">"Bluetooth-i është joaktiv"</string>
    <string name="bluetooth_devices_card_off_summary" msgid="2276527382891105858">"Trokit për ta aktivizuar"</string>
    <string name="device_picker" msgid="2427027896389445414">"Zgjidh pajisjen me Bluetooth"</string>
    <string name="bluetooth_ask_enablement" msgid="1529030199895339199">"<xliff:g id="APP_NAME">%1$s</xliff:g> kërkon të aktivizojë Bluetooth-in"</string>
    <string name="bluetooth_ask_disablement" msgid="1879788777942714761">"<xliff:g id="APP_NAME">%1$s</xliff:g> kërkon të çaktivizojë Bluetooth-in"</string>
    <string name="bluetooth_ask_enablement_no_name" msgid="5091401961637405417">"Një aplikacion kërkon të aktivizojë Bluetooth-in"</string>
    <string name="bluetooth_ask_disablement_no_name" msgid="382299750909188822">"Një aplikacion kërkon të çaktivizojë Bluetooth-in"</string>
    <string name="bluetooth_ask_discovery" product="tablet" msgid="1273405567801929487">"<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="7013223328571883275">"<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="3266007454914144057">"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="7989444746980501116">"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="6482084870735107773">"<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="2352494279465502950">"<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="2732992604509910896">"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="356982103612920264">"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="6103655179509599427">"<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="934276632311449337">"<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="1284048348024444485">"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="2661614145022629454">"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="8588317955400593623">"<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="4047444317445386579">"<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="4922952478824372605">"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="1381582950049639439">"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="3842613808709024730">"Po aktivizon Bluetooth-in…"</string>
    <string name="bluetooth_turning_off" msgid="7406309124247701148">"Po çaktivizon \"Bluetooth-in\"…"</string>
    <string name="bluetooth_connection_permission_request" msgid="8793131019383198861">"Kërkesa e lidhjes së Bluetooth-it"</string>
    <string name="bluetooth_connection_notif_message" msgid="6087344980352898209">"Trokit për t\'u lidhur me \"<xliff:g id="DEVICE_NAME">%1$s</xliff:g>\"."</string>
    <string name="bluetooth_connection_dialog_text" msgid="2537152772549874391">"Dëshiron që të lidhesh me \"<xliff:g id="DEVICE_NAME">%1$s</xliff:g>\"?"</string>
    <string name="bluetooth_phonebook_request" msgid="1085102844577089889">"Kërkesë për qasje në numërator"</string>
    <string name="bluetooth_pb_acceptance_dialog_text" msgid="7153531868579789993">"<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="173821849670438110">"Mos pyet përsëri"</string>
    <string name="bluetooth_pb_remember_choice" msgid="2080511174185036562">"Mos pyet më"</string>
    <string name="bluetooth_map_request" msgid="8664081227240707479">"Kërkesë për qasje në mesazhe"</string>
    <string name="bluetooth_map_acceptance_dialog_text" msgid="2647611490952377156">"%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="473439406287008397">"Kërkesa për qasje në kartën SIM"</string>
    <string name="bluetooth_sap_acceptance_dialog_text" msgid="2849083276356078655">"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="8678342689845439583">"E dukshme si \"<xliff:g id="DEVICE_NAME">^1</xliff:g>\" për pajisjet e tjera"</string>
    <string name="bluetooth_off_footer" msgid="76578735660216295">"Aktivizo Bluetooth-in për t\'u lidhur me pajisje të tjera."</string>
    <string name="bluetooth_paired_device_title" msgid="3240639218362342026">"Pajisjet e tua"</string>
    <string name="bluetooth_pairing_page_title" msgid="3403981358823707692">"Çifto pajisjen e re"</string>
    <string name="bluetooth_pref_summary" product="tablet" msgid="3506962706611366830">"Lejo që tableti yt të komunikojë me pajisjet me Bluetooth në afërsi"</string>
    <string name="bluetooth_pref_summary" product="device" msgid="2192027516577675587">"Lejo që pajisja jote të komunikojë me pajisjet me Bluetooth në afërsi"</string>
    <string name="bluetooth_pref_summary" product="default" msgid="768958961865499804">"Lejo që telefoni yt të komunikojë me pajisjet me Bluetooth në afërsi"</string>
    <string name="bluetooth_disable_a2dp_hw_offload" msgid="5942913792817797541">"Çaktivizo shkarkimin e harduerit të Bluetooth A2DP"</string>
    <string name="bluetooth_disable_le_audio_hw_offload" msgid="3966022676505972908">"Çaktivizo shkarkimin e harduerit të Bluetooth LE AUDIO"</string>
    <string name="bluetooth_disable_hw_offload_dialog_title" msgid="6001142380445276918">"Të riniset pajisja?"</string>
    <string name="bluetooth_disable_hw_offload_dialog_message" msgid="1524373895333698779">"Duhet të rinisësh pajisjen tënde për të ndryshuar këtë cilësim."</string>
    <string name="bluetooth_disable_hw_offload_dialog_confirm" msgid="5594859658551707592">"Rinis"</string>
    <string name="bluetooth_disable_hw_offload_dialog_cancel" msgid="3663690305043973720">"Anulo"</string>
    <string name="connected_device_media_device_title" msgid="3783388247594566734">"Pajisjet për median"</string>
    <string name="connected_device_call_device_title" msgid="88732390601723608">"Pajisjet për telefonata"</string>
    <string name="connected_device_other_device_title" msgid="4652120430615729193">"Pajisjet e tjera"</string>
    <string name="connected_device_saved_title" msgid="5607274378851905959">"Pajisjet e ruajtura"</string>
    <string name="connected_device_add_device_summary" msgid="8671009879957120802">"Bluetooth-i do të aktivizohet për çiftimin"</string>
    <string name="connected_device_connections_title" msgid="4164120115341579170">"Preferencat e lidhjes"</string>
    <string name="connected_device_previously_connected_title" msgid="605808252622814415">"Pajisjet e lidhura më parë"</string>
    <string name="connected_device_previously_connected_screen_title" msgid="8823331744788100605">"Të lidhura më parë"</string>
    <string name="connected_device_bluetooth_turned_on_toast" msgid="144664089794199928">"Bluetooth-i është i aktivizuar"</string>
    <string name="previous_connected_see_all" msgid="7759413145713251328">"Shiko të gjitha"</string>
    <string name="date_and_time" msgid="1788358029823431692">"Data dhe ora"</string>
    <string name="choose_timezone" msgid="1450780665958642147">"Zgjidh brezin orar"</string>
    <!-- no translation found for intent_sender_data_label (1733806423295725392) -->
    <skip />
    <string name="intent_sender_sendbroadcast_text" msgid="3202857258557610646">"Dërgo <xliff:g id="BROADCAST">broadcast</xliff:g>"</string>
    <string name="intent_sender_action_label" msgid="257853357827275530">"<xliff:g id="ACTION">Action</xliff:g>:"</string>
    <string name="intent_sender_startactivity_text" msgid="519934560779343541">"Fillo <xliff:g id="ACTIVITY">activity</xliff:g>"</string>
    <string name="intent_sender_resource_label" msgid="5087385727740280207">"<xliff:g id="RESOURCE">Resource</xliff:g>:"</string>
    <string name="intent_sender_account_label" msgid="36614006839665458">"Llogaria:"</string>
    <string name="proxy_settings_title" msgid="4201866858226087066">"Proxy"</string>
    <string name="proxy_clear_text" msgid="6529658759984031149">"Pastro"</string>
    <string name="proxy_port_label" msgid="4647357286461712574">"Porta e proxy-it"</string>
    <string name="proxy_exclusionlist_label" msgid="2598613986784917542">"Anashkalo proxy-in për"</string>
    <string name="proxy_defaultView_text" msgid="6795150505379688451">"Restauro parazgjedhjet"</string>
    <string name="proxy_action_text" msgid="1103328484441449542">"U krye"</string>
    <string name="proxy_hostname_label" msgid="5504327742505848063">"Emri pritës i proxy-it"</string>
    <string name="proxy_error" msgid="3615905975598084126">"Kujdes!"</string>
    <string name="proxy_error_dismiss" msgid="4207430265140873078">"Në rregull"</string>
    <string name="proxy_error_invalid_host" msgid="3814412792702059247">"Emri i pritësit që shkrove nuk është i vlefshëm."</string>
    <string name="proxy_error_invalid_exclusion_list" msgid="6096353559936226599">"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="4250295137005082992">"Duhet të plotësosh fushën e portës."</string>
    <string name="proxy_error_empty_host_set_port" msgid="8886572276450900049">"Fusha e portës duhet të jetë boshe nëse fusha e pritësit është boshe."</string>
    <string name="proxy_error_invalid_port" msgid="2830054691770209166">"Porta që shkrove nuk është e vlefshme."</string>
    <string name="proxy_warning_limited_support" msgid="3277104160797351942">"Proxy i HTTP-së përdoret zakonisht nga shfletuesi. Ai mund të mos përdoret nga aplikacionet e tjera."</string>
    <string name="proxy_url_title" msgid="3502625766036404073">"URL-ja për PAC: "</string>
    <string name="radio_info_ping_hostname_v4" msgid="4790577760885127088">"Verifiko emrin e pritësit (www.google.com) IPv4:"</string>
    <string name="radio_info_ping_hostname_v6" msgid="8327436534663560713">"Verifiko emrin e pritësit (www.google.com) IPv6:"</string>
    <string name="radio_info_http_client_test" msgid="5673975677271544085">"Testi i klientit HTTP:"</string>
    <string name="ping_test_label" msgid="265427033290391845">"Ekzekuto testin e verifikimit \"ping\""</string>
    <string name="sdcard_changes_instructions" msgid="2331969501845866957">"Ndryshimet do të zbatohen kur të rilidhet kablloja e USB-së."</string>
    <string name="sdcard_settings_screen_mass_storage_text" msgid="129059989000252994">"Aktivizo hapësirën ruajtëse masive të USB-së"</string>
    <string name="sdcard_settings_total_bytes_label" msgid="5298511430610207103">"Bajte në total:"</string>
    <string name="sdcard_settings_not_present_status" product="nosdcard" msgid="6189761476582690998">"Hapësira ruajtëse e USB-së nuk është lidhur."</string>
    <string name="sdcard_settings_not_present_status" product="default" msgid="6601962586941623203">"Nuk ka një kartë SD."</string>
    <string name="sdcard_settings_available_bytes_label" msgid="7721283102767669004">"Bajtet e lira:"</string>
    <string name="sdcard_settings_mass_storage_status" product="nosdcard" msgid="4878190674458263222">"USB-ja po përdoret si masive."</string>
    <string name="sdcard_settings_mass_storage_status" product="default" msgid="8850227049504860012">"Karta SD po përdoret si pajisje e ruajtjes masive."</string>
    <string name="sdcard_settings_unmounted_status" product="nosdcard" msgid="1053258530368541571">"Hapësira USB mund të hiqet."</string>
    <string name="sdcard_settings_unmounted_status" product="default" msgid="5813940671700138561">"Tani nuk ka rrezik të heqësh kartën SD."</string>
    <string name="sdcard_settings_bad_removal_status" product="nosdcard" msgid="209564009449909311">"USB-ja u hoq gjatë përdorimit!"</string>
    <string name="sdcard_settings_bad_removal_status" product="default" msgid="6817342973919819392">"Karta SD u hoq kur ishte ende në përdorim!"</string>
    <string name="sdcard_settings_used_bytes_label" msgid="5646588579332741943">"Bajtet e përdorura:"</string>
    <string name="sdcard_settings_scanning_status" product="nosdcard" msgid="8037280964384235345">"Po skanon hapësirën ruajtëse të USB-së për media…"</string>
    <string name="sdcard_settings_scanning_status" product="default" msgid="3297316465982471437">"Po skanon kartën SD për media…"</string>
    <string name="sdcard_settings_read_only_status" product="nosdcard" msgid="3444648373391629840">"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="4338796260718910164">"Karta SD e lidhur vetëm për lexim."</string>
    <string name="skip_label" msgid="6380034601349015895">"Kapërce"</string>
    <string name="next_label" msgid="1248293387735652187">"Para"</string>
    <string name="language_picker_title" msgid="4271307478263345133">"Gjuhët"</string>
    <string name="locale_remove_menu" msgid="3521546263421387474">"Hiqe"</string>
    <string name="add_a_language" msgid="2126220398077503271">"Shto gjuhë"</string>
    <string name="app_locale_preference_title" msgid="5513627099300360232">"Gjuha"</string>
    <string name="locale_picker_category_title" msgid="6212064706962721255">"Gjuha e preferuar"</string>
    <string name="app_locales_picker_menu_title" msgid="3412278173933199721">"Gjuhët e aplikacionit"</string>
    <string name="app_locale_picker_summary" msgid="6742557329924446252">"Cakto gjuhën për secilin aplikacion"</string>
    <string name="app_locale_picker_title" msgid="8423365003726200684">"Gjuha e aplikacionit"</string>
    <string name="suggested_app_locales_title" msgid="8898358282377369405">"Gjuhët e sugjeruara"</string>
    <string name="all_supported_app_locales_title" msgid="5479289964316009026">"Të gjitha gjuhët"</string>
    <string name="preference_of_system_locale_title" msgid="8067226276038751504">"Gjuha e sistemit"</string>
    <string name="preference_of_system_locale_summary" msgid="5612241394431188535">"Parazgjedhja e sistemit"</string>
    <string name="desc_no_available_supported_locale" msgid="7883271726226947273">"Zgjedhja e gjuhës për këtë aplikacion nuk ofrohet nga \"Cilësimet\"."</string>
    <string name="desc_app_locale_disclaimer" msgid="5295933110644789052">"Gjuha mund të ndryshojë nga gjuhët që ofrohen në aplikacion. Disa aplikacione mund të mos e mbështetin këtë cilësim."</string>
    <string name="desc_app_locale_selection_supported" msgid="6149467826636295127">"Vetëm aplikacionet që mbështetin zgjedhjen e gjuhës shfaqen këtu."</string>
    <plurals name="dlg_remove_locales_title" formatted="false" msgid="2845515796732609837">
      <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="8110560091134252067">"Teksti do të shfaqet në një gjuhë tjetër."</string>
    <string name="dlg_remove_locales_error_title" msgid="5875503658221562572">"Nuk mund të hiqen të gjitha gjuhët"</string>
    <string name="dlg_remove_locales_error_message" msgid="6504279959974675302">"Mbaj të paktën një gjuhë të preferuar"</string>
    <string name="locale_not_translated" msgid="5079729745235316146">"Munsd të mos jetë i disponueshëm në disa aplikacione"</string>
    <string name="action_drag_label_move_up" msgid="3392196942330705015">"Lëvize lart"</string>
    <string name="action_drag_label_move_down" msgid="9069518740553953426">"Lëvize poshtë"</string>
    <string name="action_drag_label_move_top" msgid="2430471023612171619">"Lëvize në krye"</string>
    <string name="action_drag_label_move_bottom" msgid="6266165197792827003">"Lëvize në fund"</string>
    <string name="action_drag_label_remove" msgid="1034900377796780568">"Hiq gjuhën"</string>
    <string name="activity_picker_label" msgid="351250401590691126">"Zgjidh aktivitetin"</string>
    <string name="display_label" msgid="3056320781191343221">"Ekrani"</string>
    <string name="sd_card_settings_label" product="nosdcard" msgid="1850505156136467106">"Hapësira për ruajtje e USB-së"</string>
    <string name="sd_card_settings_label" product="default" msgid="8715502912796241588">"Karta SD"</string>
    <string name="proxy_settings_label" msgid="6300573815025557843">"Cilësimet e proxy-it"</string>
    <string name="cancel" msgid="5780102414089664898">"Anulo"</string>
    <string name="okay" msgid="4827099303045669054">"Në rregull"</string>
    <string name="forget" msgid="3754013654135912783">"Harro"</string>
    <string name="save" msgid="3125033126936493822">"Ruaj"</string>
    <string name="done" msgid="7497982645646431310">"U krye"</string>
    <string name="apply" msgid="7834684883190163536">"Zbato"</string>
    <string name="share" msgid="8502235338607613795">"Ndaj"</string>
    <string name="add" msgid="8335206931421683426">"Shto"</string>
    <string name="settings_label" msgid="943294133671632976">"Cilësimet"</string>
    <string name="settings_label_launcher" msgid="820982375501978609">"Cilësimet"</string>
    <string name="settings_shortcut" msgid="8548239727871847171">"Shkurtorja e cilësimeve"</string>
    <string name="airplane_mode" msgid="3196085857882526817">"Modaliteti i aeroplanit"</string>
    <string name="wireless_networks_settings_title" msgid="8557542379234105369">"Wi-Fi dhe rrjetet"</string>
    <string name="radio_controls_summary" msgid="9028430178697624501">"Menaxho Wi‑Fi, Bluetooth, modalitetin \"në aeroplan\", rrjetet celulare dhe rrjetet VPN"</string>
    <string name="cellular_data_summary" msgid="6551434804367912367">"Lejo përdorimin e të dhënave nëpërmjet rrjetit celular"</string>
    <string name="allow_data_usage_title" msgid="2645963379925196671">"Lejo përdorimin e të dhënave kur je në roaming"</string>
    <string name="roaming" msgid="3055365654530847985">"Roaming"</string>
    <string name="roaming_enable" msgid="7845716016861535340">"Lidhu me shërbimet e të dhënave kur je në roaming"</string>
    <string name="roaming_disable" msgid="729512894708689604">"Lidhu me shërbimet e të dhënave kur je në roaming"</string>
    <string name="roaming_reenable_message" msgid="5150423860521673540">"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="6999283810847157816">"Aktivizoje"</string>
    <string name="roaming_warning" msgid="7703647889040229013">"Mund të zbatohen tarifat e roaming-ut."</string>
    <string name="roaming_warning_multiuser" product="tablet" msgid="5629953315019604726">"Kur lejon roaming-un e të dhënave, mund të zbatohen tarifat e roaming-ut.\n\nKy cilësim ndikon te të gjithë përdoruesit në këtë tablet."</string>
    <string name="roaming_warning_multiuser" product="default" msgid="3693719745119874126">"Kur lejon roaming-un e të dhënave, mund të zbatohen tarifat e roaming-ut.\n\nKy cilësim ndikon te të gjithë përdoruesit në këtë telefon."</string>
    <string name="roaming_reenable_title" msgid="770824950144026180">"Të lejohet shfrytëzimi i roaming-ut?"</string>
    <string name="networks" msgid="5184501333492775095">"Zgjedhja e operatorit"</string>
    <string name="sum_carrier_select" msgid="1669911795517995916">"Zgjidh një operator rrjeti"</string>
    <string name="date_and_time_settings_title" msgid="2305454529709812364">"Data dhe ora"</string>
    <string name="date_and_time_settings_title_setup_wizard" msgid="1841717199409629742">"Vendos datën dhe orën"</string>
    <string name="date_and_time_settings_summary" msgid="334967758944498010">"Vendos datën, orën, brezin orar dhe formatet"</string>
    <string name="date_time_auto" msgid="4239202185055225869">"Cakto automatikisht orën"</string>
    <string name="zone_auto_title" msgid="3993580453604839924">"Cakto automatikisht brezin orar"</string>
    <string name="date_time_24hour_auto" msgid="6583078135067804252">"Përdor parazgjedhjen e lokalitetit"</string>
    <string name="date_time_24hour_title" msgid="1445056824481243600">"Formati \"24 orë\""</string>
    <string name="date_time_24hour" msgid="286679379105653406">"Përdor formatin 24 orë"</string>
    <string name="date_time_set_time_title" msgid="2870083415922991906">"Ora"</string>
    <string name="time_format_category_title" msgid="7108616745509689991">"Formati i orës"</string>
    <string name="date_time_set_timezone_title" msgid="790404320569600222">"Brezi orar"</string>
    <string name="date_time_set_timezone" msgid="2915125337941495746">"Brezi orar"</string>
    <string name="date_time_set_date_title" msgid="7624166157167528407">"Data"</string>
    <string name="date_time_search_region" msgid="1364133854952610919">"Kërko rajonin"</string>
    <string name="date_time_select_region" msgid="5449345333305056072">"Rajoni"</string>
    <string name="date_time_select_fixed_offset_time_zones" msgid="594848300882055361">"Zgjidh ndryshimin në UTC"</string>
    <string name="zone_change_to_from_dst" msgid="686451769985774294">"<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="2186042522225153092">"<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="3960192548990990152">"<xliff:g id="TIME_TYPE">%2$s</xliff:g> (<xliff:g id="OFFSET">%1$s</xliff:g>)"</string>
    <string name="zone_info_footer" msgid="7004693956837388129">"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="8399585343328811158">"Përdor <xliff:g id="OFFSET_AND_NAME">%1$s</xliff:g>. Nuk ka orë verore."</string>
    <string name="zone_time_type_dst" msgid="9189689342265305808">"Ora verore"</string>
    <string name="zone_time_type_standard" msgid="6865420715430680352">"Ora standarde"</string>
    <string name="zone_menu_by_region" msgid="2963565278710225652">"Zgjidh sipas rajonit"</string>
    <string name="zone_menu_by_offset" msgid="1257702747474426745">"Zgjidh sipas ndryshimit në UTC"</string>
    <string name="date_picker_title" msgid="646573308567782578">"Data"</string>
    <string name="time_picker_title" msgid="1784236407401743393">"Ora"</string>
    <string name="lock_after_timeout" msgid="8682769000437403444">"Kyçe pas kohës së pritjes së ekranit"</string>
    <string name="lock_after_timeout_summary" msgid="4869265514658147304">"<xliff:g id="TIMEOUT_STRING">%1$s</xliff:g> pas kohës së pritjes"</string>
    <string name="lock_immediately_summary_with_exception" msgid="40819611828339044">"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="3441806647509073124">"<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="197365342192696406">"Shfaq informacionin e zotëruesit në ekranin e kyçjes"</string>
    <string name="owner_info_settings_title" msgid="3555626140700093017">"Shto tekst në ekranin e kyçjes"</string>
    <string name="security_enable_widgets_title" msgid="676199714313423099">"Aktivizo miniapl."</string>
    <string name="security_enable_widgets_disabled_summary" msgid="5191637768484254146">"Çaktivizuar nga administratori"</string>
    <string name="trust_lost_locks_screen_title" msgid="4231232144565291276">"Kyçe ekranin kur të humbasë besimi"</string>
    <string name="trust_lost_locks_screen_summary" msgid="718374221849537361">"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="347238313388083297">"Asnjë"</string>
    <string name="owner_info_settings_status" msgid="7488764871758677862">"<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="841926875876050274">"P.sh., pajisja Android e Admirit."</string>
    <string name="show_profile_info_on_lockscreen_label" msgid="5734739022887933365">"Shfaq informacionin e profilit në ekranin e kyçjes"</string>
    <string name="Accounts_settings_title" msgid="8434263183710375412">"Llogaritë"</string>
    <string name="location_settings_title" msgid="8375074508036087178">"Vendndodhja"</string>
    <string name="location_settings_primary_switch_title" msgid="8849081766644685127">"Përdor vendndodhjen"</string>
    <string name="location_settings_summary_location_off" msgid="4797932754681162262">"Joaktiv"</string>
    <plurals name="location_settings_summary_location_on" formatted="false" msgid="1019959038518185676">
      <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="6054103701535557342">"Po ngarkohet…"</string>
    <string name="location_settings_footer_general" msgid="1040507068701188821">"Aplikacionet me lejen \"Pajisjet në afërsi\" mund të përcaktojnë pozicionin e përafërt të pajisjeve të lidhura."</string>
    <string name="location_settings_footer_location_off" msgid="8568995909147566720">"Qasja te vendndodhja është joaktive për aplikacionet dhe shërbimet. Vendndodhja e pajisjes sate mund t\'u dërgohet përsëri personave që përgjigjen në rast urgjence kur telefonon ose dërgon mesazh te një numër urgjence."</string>
    <string name="location_settings_footer_learn_more_content_description" msgid="5329024810729665156">"Mëso më shumë për \"Cilësimet e vendndodhjes\"."</string>
    <string name="account_settings_title" msgid="9138880127246241885">"Llogaritë"</string>
    <string name="security_settings_title" msgid="6710768415432791970">"Siguria"</string>
    <string name="encryption_and_credential_settings_title" msgid="5856216318961482983">"Enkriptimi dhe kredencialet"</string>
    <string name="encryption_and_credential_settings_summary" product="default" msgid="5298195959570992363">"Telefoni është i enkriptuar"</string>
    <string name="not_encrypted_summary" product="default" msgid="2251945842585788254">"Telefoni nuk është i enkriptuar"</string>
    <string name="encryption_and_credential_settings_summary" product="tablet" msgid="3776741531205406800">"Pajisja është e enkriptuar"</string>
    <string name="not_encrypted_summary" product="tablet" msgid="2374263654698719382">"Pajisja nuk është e enkriptuar"</string>
    <string name="lockscreen_settings_title" msgid="4086121748092341549">"Ekrani i kyçjes"</string>
    <string name="lockscreen_settings_what_to_show_category" msgid="9205490627927741254">"Çfarë të shfaqet"</string>
    <string name="security_settings_summary" msgid="1627059516127354233">"Cakto \"Vendndodhjen time\", shkyçjen e ekranit, kyçjen e kartës SIM, kyçjen e hapësirës ruajtëse të kredencialeve"</string>
    <string name="cdma_security_settings_summary" msgid="2455517905101186330">"Cakto \"Vendndodhja ime\", shkyçjen e ekranit, kyçjen e hapësirës ruajtëse të kredencialeve"</string>
    <string name="security_passwords_title" msgid="4154420930973818581">"Privatësia"</string>
    <string name="disabled_by_administrator_summary" msgid="5424846182313851124">"Nuk ofrohet"</string>
    <string name="security_status_title" msgid="6958004275337618656">"Statusi i sigurisë"</string>
    <string name="security_dashboard_summary" msgid="7571035662779425918">"Kyçja e ekranit, \"Gjej pajisjen time\", siguria e aplikacioneve"</string>
    <string name="safety_center_title" msgid="7732397372178774777">"Siguria dhe privatësia"</string>
    <string name="safety_center_summary" msgid="3554867379951053869">"Siguria e aplikacionit, kyçja e pajisjes, lejet"</string>
    <string name="security_settings_face_preference_summary" msgid="6675126437396914838">"Fytyra u shtua"</string>
    <string name="security_settings_face_preference_summary_none" msgid="5952752252122581846">"Trokit për të konfiguruar fytyrën"</string>
    <string name="security_settings_face_preference_title" msgid="2126625155005348417">"Shkyçja me fytyrë"</string>
    <string name="security_settings_face_profile_preference_title" msgid="7519527436266375005">"\"Shkyçja me fytyrë\" për profilin e punës"</string>
    <string name="security_settings_face_enroll_education_title" msgid="6448806884597691208">"Si të konfigurosh \"Shkyçjen me fytyrë\""</string>
    <string name="security_settings_face_enroll_education_title_accessibility" msgid="3701874093226957891">"Konfiguro \"Shkyçjen me fytyrë\""</string>
    <string name="security_settings_face_enroll_education_title_unlock_disabled" msgid="8810954233979716906">"Përdor fytyrën për të vërtetuar"</string>
    <string name="security_settings_face_enroll_education_message" msgid="4308030157487176799"></string>
    <string name="security_settings_face_enroll_education_message_accessibility" msgid="1986648712195281391"></string>
    <string name="security_settings_face_enroll_education_start" msgid="8830924400907195590">"Nis"</string>
    <string name="security_settings_face_enroll_education_accessibility_dialog_message" msgid="2965952386172202665">"Nëse \"Shkyçja me fytyrë\" për qasshmëri është e çaktivizuar, disa hapa konfigurimi mund të mos funksionojnë mirë me TalkBack."</string>
    <string name="security_settings_face_enroll_education_accessibility_dialog_negative" msgid="7872647360361245461">"Kthehu pas"</string>
    <string name="security_settings_face_enroll_education_accessibility_dialog_positive" msgid="3148077647572203458">"Vazhdo konfigurimin"</string>
    <string name="security_settings_face_enroll_introduction_accessibility" msgid="5748221179069430975">"Përdor konfigurimin e qasshmërisë"</string>
    <string name="security_settings_face_enroll_introduction_accessibility_expanded" msgid="6763509014732769185"></string>
    <string name="security_settings_face_enroll_introduction_accessibility_diversity" msgid="2774962371839179206"></string>
    <string name="security_settings_face_enroll_introduction_accessibility_vision" msgid="7700394302162170363"></string>
    <string name="security_settings_face_enroll_introduction_cancel" msgid="7551159644361639436">"Anulo"</string>
    <string name="security_settings_face_enroll_introduction_no_thanks" msgid="1820618982738898717">"Jo, faleminderit"</string>
    <string name="security_settings_face_enroll_introduction_agree" msgid="6319476573697497750">"Pranoj"</string>
    <string name="security_settings_face_enroll_introduction_more" msgid="1970820298889710532">"Më shumë"</string>
    <string name="security_settings_face_enroll_introduction_title" msgid="7061610077237098046">"Shkyç me fytyrë"</string>
    <string name="security_settings_face_enroll_consent_introduction_title" msgid="3942331854413767814">"Lejo shkyçjen me fytyrë"</string>
    <string name="security_settings_face_enroll_introduction_title_unlock_disabled" msgid="5903924766168353113">"Përdor fytyrën për të vërtetuar"</string>
    <string name="security_settings_face_enroll_introduction_message" msgid="3015751486939484934">"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_consent_message" msgid="866117500419055444">"Lejoje fëmijën tënd të përdorë fytyrën për të shkyçur telefonin ose për t\'u verifikuar si vetvetja. Kjo ndodh kur identifikohet në aplikacione, miraton një blerje etj."</string>
    <string name="security_settings_face_enroll_introduction_message_unlock_disabled" msgid="5841976283789481311">"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="765965418187421753">"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_info_title" msgid="7120796118179406944"></string>
    <string name="security_settings_face_enroll_introduction_info_glasses" msgid="2733870453868907471"></string>
    <string name="security_settings_face_enroll_introduction_info_consent_glasses" msgid="6303917184145586880"></string>
    <string name="security_settings_face_enroll_introduction_info_looking" msgid="6502109133251718131"></string>
    <string name="security_settings_face_enroll_introduction_info_consent_looking" msgid="1911530177804950718"></string>
    <string name="security_settings_face_enroll_introduction_info_less_secure" msgid="6496505354480525745"></string>
    <string name="security_settings_face_enroll_introduction_info_gaze" msgid="143556725395884850"></string>
    <string name="security_settings_face_enroll_introduction_info_consent_gaze" msgid="6301647369911879888"></string>
    <string name="security_settings_face_enroll_introduction_how_title" msgid="3680193263037835600"></string>
    <string name="security_settings_face_enroll_introduction_how_message" msgid="4192656589626667797"></string>
    <string name="security_settings_face_enroll_introduction_how_consent_message" msgid="9028182363896853946"></string>
    <string name="security_settings_face_enroll_introduction_control_title" msgid="4536951089583821051"></string>
    <string name="security_settings_face_enroll_introduction_control_consent_title" msgid="5892729331412694759"></string>
    <string name="security_settings_face_enroll_introduction_control_message" msgid="4818463420573540379"></string>
    <string name="security_settings_face_enroll_introduction_control_consent_message" msgid="4658082872829249850"></string>
    <string name="security_settings_face_enroll_repeat_title" msgid="4446229670377418717">"Mbaje fytyrën në mes të rrethit"</string>
    <string name="security_settings_face_enroll_enrolling_skip" msgid="5568617401632528567">"Kapërce"</string>
    <string name="face_add_max" msgid="4578405795494514876">"Mund të shtosh deri në <xliff:g id="COUNT">%d</xliff:g> fytyra"</string>
    <string name="face_intro_error_max" msgid="2474735057709291626">"Ke shtuar numrin maksimal të fytyrave"</string>
    <string name="face_intro_error_unknown" msgid="1626057493054989995">"Nuk mund të shtohen më shumë fytyra"</string>
    <string name="security_settings_face_enroll_error_dialog_title" msgid="2460820099922775936">"Regjistrimi nuk përfundoi"</string>
    <string name="security_settings_face_enroll_dialog_ok" msgid="1674650455786434426">"OK"</string>
    <string name="security_settings_face_enroll_error_timeout_dialog_message" msgid="7768349698547951750">"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="3186810411630091490">"Regjistrimi i fytyrës nuk funksionoi"</string>
    <string name="security_settings_face_enroll_finish_title" msgid="5882322568359775393">"Gjithçka gati. Duket mirë."</string>
    <string name="security_settings_face_enroll_done" msgid="3048687969498187442">"U krye"</string>
    <string name="security_settings_face_enroll_should_re_enroll_title" msgid="6835778900387289683">"Përmirëso cilësinë e funksionimit të \"Shkyçjes me fytyrë\""</string>
    <string name="security_settings_face_enroll_should_re_enroll_subtitle" msgid="7055780282999744813">"Konfiguro \"Shkyçjen me fytyrë\" përsëri"</string>
    <string name="security_settings_face_enroll_must_re_enroll_title" msgid="4421818770682557621">"Konfiguro \"Shkyçjen me fytyrë\" përsëri"</string>
    <string name="security_settings_face_enroll_must_re_enroll_subtitle" msgid="3584740139535177961">"Përmirëso sigurinë dhe cilësinë e funksionimit"</string>
    <string name="security_settings_face_enroll_improve_face_alert_title" msgid="6194184776580066012">"Konfiguro \"Shkyçjen me fytyrë\""</string>
    <string name="security_settings_face_enroll_improve_face_alert_body" msgid="2670118180411127323">"Fshi modelin tënd aktual të fytyrës për të konfiguruar përsëri \"Shkyçjen me fytyrë\".\n\nModeli yt i fytyrës do të fshihet përfundimisht dhe në mënyrë të sigurt.\n\nPas fshirjes do të të duhet kodi yt PIN, motivi ose fjalëkalimi për të shkyçur telefonin ose për vërtetim në aplikacione."</string>
    <string name="security_settings_face_enroll_improve_face_alert_body_fingerprint" msgid="2469599074650327489">"Fshi modelin tënd aktual të fytyrës për të konfiguruar përsëri \"Shkyçjen me fytyrë\".\n\nModeli yt i fytyrës do të fshihet përfundimisht dhe në mënyrë të sigurt.\n\nPas fshirjes do të të duhet gjurma jote e gishtit, kodi PIN, motivi ose fjalëkalimi për të shkyçur telefonin ose për vërtetim në aplikacione."</string>
    <string name="security_settings_face_settings_use_face_category" msgid="1638314154119800188">"Përdor \"Shkyçjen me fytyrë\" për"</string>
    <string name="security_settings_face_settings_preferences_category" msgid="7628929873407280453">"Kur përdoret \"Shkyçja me fytyrë\""</string>
    <string name="security_settings_face_settings_require_attention" msgid="4395309855914391104">"Kërkon që sytë të jenë të hapur"</string>
    <string name="security_settings_face_settings_require_attention_details" msgid="2546230511769544074">"Për ta shkyçur telefonin, sytë e tu duhet të jenë të hapur"</string>
    <string name="security_settings_face_settings_require_confirmation" msgid="6603039421004198334">"Kërko gjithmonë konfirmimin"</string>
    <string name="security_settings_face_settings_require_confirmation_details" msgid="3498729789625461914">"Kërko gjithmonë hapin e konfirmimit kur përdor \"Shkyçjen me fytyrë\" në aplikacione"</string>
    <string name="security_settings_face_settings_remove_face_model" msgid="812920481303980846">"Fshi modelin e fytyrës"</string>
    <string name="security_settings_face_settings_enroll" msgid="3726313826693825029">"Konfiguro \"Shkyçjen me fytyrë\""</string>
    <string name="security_settings_face_settings_footer" msgid="625696606490947189">"Përdor fytyrën tënde për të shkyçur telefonin ose për vërtetim në aplikacione, si p.sh. kur identifikohesh apo miraton një blerje.\n\nKi parasysh:\nMund të konfigurosh vetëm një fytyrë për rast. Për të shtuar një fytyrë tjetër, fshi fytyrën aktuale.\n\nNëse shikon nga telefoni, mund ta shkyçësh pa dashje.\n\nTelefoni yt mund të shkyçet nga dikush tjetër nëse mbahet në nivelin e fytyrës.\n\nTelefoni mund të shkyçet nga dikush që të ngjan shumë, si p.sh. një binjak identik."</string>
    <string name="security_settings_face_settings_footer_attention_not_supported" msgid="2071065435536235622">"Përdor fytyrën tënde për të shkyçur telefonin ose për vërtetim në aplikacione, si p.sh. kur identifikohesh apo miraton një blerje.\n\nKi parasysh:\nMund të konfigurosh vetëm një fytyrë për rast. Për të shtuar një fytyrë tjetër, fshi fytyrën aktuale.\n\nNëse shikon nga telefoni, mund ta shkyçësh pa dashje.\n\nTelefoni yt mund të shkyçet nga dikush tjetër nëse mbahet në nivelin e fytyrës edhe sikur t\'i kesh mbyllur sytë.\n\nTelefoni mund të shkyçet nga dikush që të ngjan shumë, si p.sh. një binjak identik."</string>
    <string name="security_settings_face_settings_remove_dialog_title" msgid="2899669764446232715">"Të fshihet modeli i fytyrës?"</string>
    <string name="security_settings_face_settings_remove_dialog_details" msgid="916131485988121592">"Modeli yt i fytyrës do të fshihet përgjithmonë dhe në mënyrë të sigurt.\n\nPas fshirjes, do të të duhet kodi yt PIN, motivi ose fjalëkalimi për të shkyçur telefonin ose për vërtetimin në aplikacione."</string>
    <string name="security_settings_face_settings_remove_dialog_details_convenience" msgid="475568135197468990">"Modeli yt i fytyrës do të fshihet përgjithmonë dhe në mënyrë të sigurt.\n\nPas fshirjes, do të të duhet kodi yt PIN, motivi ose fjalëkalimi për të shkyçur telefonin."</string>
    <string name="security_settings_face_settings_context_subtitle" msgid="8284262560781442403">"Përdor \"Shkyçjen me fytyrë\" për të shkyçur telefonin tënd"</string>
    <string name="security_settings_fingerprint_preference_title" msgid="2484965173528415458">"Gjurma e gishtit"</string>
    <string name="security_settings_work_fingerprint_preference_title" msgid="2076006873519745979">"Gjurmë gishti për punë"</string>
    <string name="fingerprint_manage_category_title" msgid="1249349505688268850">"Menaxho gjurm. gishtit"</string>
    <string name="fingerprint_usage_category_title" msgid="8757959085075024856">"Përdor gjurmën për"</string>
    <string name="fingerprint_add_title" msgid="1837610443487902050">"Shto gjurmë gishti"</string>
    <string name="fingerprint_enable_keyguard_toggle_title" msgid="5451094461919440992">"kyçja e ekranit"</string>
    <plurals name="security_settings_fingerprint_preference_summary" formatted="false" msgid="6897454766137108776">
      <item quantity="other"><xliff:g id="COUNT">%1$d</xliff:g> gjurmë gishtash u shtuan</item>
      <item quantity="one">Gjurma e gishtit u shtua</item>
    </plurals>
    <string name="security_settings_fingerprint_preference_summary_none" msgid="1044059475710838504"></string>
    <string name="security_settings_fingerprint_enroll_introduction_title" msgid="7931650601996313070">"Konfiguro gjurmën e gishtit"</string>
    <string name="security_settings_fingerprint_enroll_consent_introduction_title" msgid="2278592030102282364">"Lejo shkyçjen me gjurmën e gishtit"</string>
    <string name="security_settings_fingerprint_enroll_introduction_title_unlock_disabled" msgid="1911710308293783998">"Përdor gjurmën e gishtit"</string>
    <string name="security_settings_fingerprint_enroll_introduction_v2_message" product="tablet" msgid="1533352560544756928">"Përdor gjurmën e gishtit për të shkyçur tabletin tënd ose për të verifikuar që je ti, si p.sh. kur identifikohesh në aplikacione ose kur miraton një blerje."</string>
    <string name="security_settings_fingerprint_enroll_introduction_v2_message" product="device" msgid="3570866595300511932">"Përdor gjurmën e gishtit për të shkyçur pajisjen ose për të verifikuar që je ti, si p.sh. kur identifikohesh në aplikacione ose kur miraton një blerje."</string>
    <string name="security_settings_fingerprint_enroll_introduction_v2_message" product="default" msgid="8539442240212670385">"Përdor gjurmën e gishtit për të shkyçur telefonin tënd ose për të verifikuar që je ti, si p.sh. kur identifikohesh në aplikacione ose kur miraton një blerje."</string>
    <string name="security_settings_fingerprint_enroll_introduction_consent_message" msgid="1833139688278350628">"Lejoje fëmijën tënd të përdorë gjurmën e gishtit për të shkyçur telefonin ose për t\'u verifikuar si vetvetja. Kjo ndodh kur identifikohet në aplikacione, miraton një blerje etj."</string>
    <string name="security_settings_fingerprint_enroll_introduction_footer_title_1" msgid="6808124116419325722">"Kontrolli është në duart e tua"</string>
    <string name="security_settings_fingerprint_enroll_introduction_footer_title_consent_1" msgid="1122676690472680734">"Kontrollin e ke ti dhe fëmija yt"</string>
    <string name="security_settings_fingerprint_enroll_introduction_footer_title_2" msgid="5663733424583416266">"Ki parasysh"</string>
    <string name="security_settings_fingerprint_enroll_introduction_footer_message_1" msgid="7817635368506064516">"Të dhënat e regjistruara nga \"Gjurma e gishtit\" ruhen në mënyrë të sigurt dhe nuk largohen asnjëherë nga telefoni yt. Të dhënat e tua mund t\'i fshish në çdo moment te \"Cilësimet\"."</string>
    <string name="security_settings_fingerprint_enroll_introduction_footer_message_2" msgid="3507618608004123384">"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_footer_message_3" product="default" msgid="4757472591076060066">"Telefoni yt do të përdorë herë pas here imazhet e fundit të gjurmës së gishtit për të krijuar modele të përmirësuara të gjurmës së gishtit."</string>
    <string name="security_settings_fingerprint_enroll_introduction_message_unlock_disabled" msgid="8957789840251747092">"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 ta 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_cancel" msgid="6086532316718920562">"Anulo"</string>
    <string name="security_settings_fingerprint_enroll_introduction_no_thanks" msgid="6104718999323591180">"Jo, faleminderit"</string>
    <string name="security_settings_fingerprint_enroll_introduction_agree" msgid="4068276083536421828">"Pranoj"</string>
    <string name="setup_fingerprint_enroll_skip_title" msgid="2473807887676247264">"Të kapërcehet gjurma e gishtit?"</string>
    <string name="setup_fingerprint_enroll_skip_after_adding_lock_text" msgid="2412645723804450304">"Konfigurimi i gjurmës së gishtit zgjat vetëm një ose dy minuta. Nëse e kapërcen këtë, mund ta shtosh gjurmën tënde të gishtit më vonë te cilësimet."</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_message_setup" msgid="6255210343107484206">"Kur të shikosh këtë ikonë, përdor gjurmën tënde të gishtit për vërtetim, p.sh. kur të identifikohesh në aplikacione ose për të miratuar një blerje"</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_title_1" msgid="4360262371633254407">"Ki parasysh"</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_message_1" msgid="5824014348182478279">"Përdorimi i gjurmës sate të gishtit për të shkyçur telefonin mund të jetë më pak i sigurt se një motiv apo PIN i fortë."</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_title_2" msgid="2580899232734177771">"Si funksionon"</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_message_2" msgid="5909924864816776516">"\"Shkyçja me gjurmën e gishtit\" krijon një model unik të gjurmës sate të gishtit për të verifikuar që je ti. Për ta krijuar këtë model të gjurmës së gishtit gjatë konfigurimit, duhet t\'i regjistrosh nga pozicione të ndryshme imazhet e gjurmës sate të gishtit."</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_message_consent_2" msgid="3493356605815124807">"\"Shkyçja me gjurmën e gishtit\" krijon një model unik të gjurmës së gishtit të fëmijës tënd për të verifikuar që është ai. Për ta krijuar këtë model të gjurmës së gishtit gjatë konfigurimit, ajo duhet t\'i regjistrojë nga pozicione të ndryshme imazhet e gjurmës sate të gishtit."</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_message_3" msgid="4729142136478078228">"Kur të përdorësh Pixel Imprint, imazhet përdoren për të përditësuar modelin tënd të gjurmës së gishtit. Imazhet e përdorura për të krijuar modelin e gjurmës sate të gishtit nuk ruhen asnjëherë, por modeli i gjurmës sate të gishtit ruhet në mënyrë të sigurt në telefonin tënd dhe nuk largohet kurrë nga telefoni. I gjithë përpunimi ndodh në mënyrë të sigurt në telefonin tënd."</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_message_consent_3" msgid="5908959250804145997">"Kur të përdorë Pixel Imprint, imazhet përdoren për të përditësuar modelin e tij të gjurmës së gishtit. Imazhet e përdorura për të krijuar modelin e gjurmës së gishtit të fëmijës tënd nuk ruhen asnjëherë, por modeli i gjurmës së gishtit ruhet në mënyrë të sigurt në telefon dhe nuk largohet kurrë nga telefoni. I gjithë përpunimi ndodh në mënyrë të sigurt në telefon."</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_message_4" msgid="3948305045484131665">"Mund t\'i fshish imazhet dhe modelin e gjurmës sate të gishtit ose çaktivizoje \"Shkyçjen me gjurmën e gishtit\" në çdo kohë te \"Cilësimet\". Imazhet dhe modelet e gjurmës së gishtit ruhen në telefon deri kur t\'i fshish."</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_message_consent_4" msgid="4983770600405797515">"Ti dhe fëmija yt mund t\'i fshini imazhet dhe modelin e gjurmës së tij të gishtit ose ta çaktivizoni \"Shkyçjen me gjurmën e gishtit\" në çfarëdo kohe te \"Cilësimet\". Imazhet dhe modelet e gjurmës së gishtit ruhen në telefon derisa të fshihen."</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_message_5" msgid="2018885671994058605">"Telefoni yt mund të shkyçet edhe nëse nuk ke për qëllim një gjë të tillë, p.sh. nëse dikush ta mban te gishti."</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_message_consent_5" msgid="8356551505082794682">"Telefoni i fëmijës tënd mund të shkyçet pa dashje, si p.sh. nëse dikush ia mban te gishti."</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_message_6" msgid="5314031490467481499">"Për rezultate më të mira, përdor një mbrojtës ekrani që është i certifikuar nga \"Prodhuar për Google\". Me mbrojtës të tjerë ekrani, gjurma jote e gishtit mund të mos funksionojë."</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_message_consent_6" msgid="3563942520716110478">"Për rezultate më të mira, përdor një mbrojtës ekrani që është i certifikuar nga \"Prodhuar për Google\". Me mbrojtës të tjerë ekrani, gjurma e gishtit e fëmijës tënd mund të mos funksionojë."</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_message_learn_more" msgid="5856010507790137793"></string>
    <string name="security_settings_fingerprint_v2_enroll_acquire_try_adjusting" msgid="3855444121278320304">"Ndrysho pak pozicionin e gishtit çdo herë"</string>
    <string name="security_settings_fingerprint_v2_enroll_acquire_partially_detected" msgid="8330287007361798356">"Mbuloje ikonën me qendrën e gjurmës sate të gishtit"</string>
    <string name="security_settings_fingerprint_v2_enroll_acquire_already_enrolled" msgid="8616678833080422946">"Kjo gjurmë gishti është shtuar tashmë"</string>
    <string name="security_settings_fingerprint_v2_enroll_acquire_clean_sensor" msgid="3501453094314993113">"Pastro ekranin tënd pranë sensorit dhe provo përsëri"</string>
    <string name="security_settings_fingerprint_v2_enroll_acquire_too_fast" msgid="5891227328100822018">"Ngri gishtin pasi të ndjesh një dridhje"</string>
    <string name="security_settings_fingerprint_v2_enroll_acquire_too_bright" msgid="769646735950329315">"Lëviz diku me ndriçim më të butë dhe provo përsëri"</string>
    <string name="security_settings_fingerprint_v2_enroll_error_max_attempts" msgid="1464972470750764128">"Ke arritur numrin maksimal të përpjekjeve"</string>
    <string name="security_settings_fingerprint_v2_home_screen_text" product="tablet" msgid="179325591887291180">"Përdor gjurmën e gishtit për të shkyçur tabletin ose për të verifikuar që je ti, si p.sh. kur identifikohesh në aplikacione"</string>
    <string name="security_settings_fingerprint_v2_home_screen_text" product="device" msgid="2503218139575057099">"Përdor gjurmën e gishtit për të shkyçur pajisjen ose për të verifikuar që je ti, si p.sh. kur identifikohesh në aplikacione"</string>
    <string name="security_settings_fingerprint_v2_home_screen_text" product="default" msgid="481286891358925579">"Përdor gjurmën e gishtit për të shkyçur telefonin ose për të verifikuar që je ti, si p.sh. kur identifikohesh në aplikacione"</string>
    <string name="security_settings_biometric_preference_title" msgid="298146483579539448">"Shkyçja me fytyrë dhe me gjurmën e gishtit"</string>
    <string name="security_settings_biometric_preference_summary_none_enrolled" msgid="6941188982863819389">"Trokit për të konfiguruar"</string>
    <string name="security_settings_biometric_preference_summary_both_fp_multiple" msgid="4821859306609955966">"Fytyra dhe gjurmët e gishtave u shtuan"</string>
    <string name="security_settings_biometric_preference_summary_both_fp_single" msgid="684409535278676426">"Fytyra dhe gjurma e gishtit u shtuan"</string>
    <string name="biometric_settings_intro" msgid="4263069383955676756">"Kur të konfigurosh \"Shkyçjen me fytyrë\" dhe \"Shkyçjen me gjurmën e gishtit\", telefoni yt do të kërkojë gjurmën tënde të gishtit kur të mbash maskë apo kur të jesh në një zonë të errët"</string>
    <string name="biometric_settings_category_ways_to_unlock" msgid="3384767901580915266">"Mënyrat për ta shkyçur"</string>
    <string name="biometric_settings_use_biometric_unlock_phone" msgid="8180914579885804358">"Shkyç telefonin"</string>
    <string name="biometric_settings_use_biometric_for_apps" msgid="6201168728906364189">"Verifiko që je ti në aplikacione"</string>
    <string name="biometric_settings_use_face_preference_summary" msgid="1821648836899408477">"Me anë të fytyrës"</string>
    <string name="biometric_settings_use_fingerprint_preference_summary" msgid="6077762097826050165">"Me anë të gjurmës së gishtit"</string>
    <string name="biometric_settings_use_face_or_fingerprint_preference_summary" msgid="3029102492674234728">"Me anë të fytyrës ose gjurmës së gishtit"</string>
    <string name="biometric_settings_hand_back_to_guardian" msgid="3747619291972376153">"Jepja telefonin përsëri prindit"</string>
    <string name="biometric_settings_hand_back_to_guardian_ok" msgid="1763788801883247426">"Në rregull"</string>
    <string name="lock_screen_intro_skip_title" msgid="342553937472568925">"Të kapërcehet kyçja e ekranit?"</string>
    <string name="lock_screen_intro_skip_dialog_text_frp" product="tablet" msgid="1570832293693405757">"Veçoritë 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="4618501606519351904">"Veçoritë 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="2412426429887900241">"Veçoritë 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="7119039592587429936">"Veçoritë 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="3365990364131398523">"Veçoritë 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="4908278819257287536">"Veçoritë 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="3442274117023270068">"Kapërceje gjithsesi"</string>
    <string name="go_back_button_label" msgid="6139455414099035594">"Kthehu prapa"</string>
    <string name="skip_lock_screen_dialog_button_label" msgid="641984698150020591">"Kapërce"</string>
    <string name="cancel_lock_screen_dialog_button_label" msgid="1801132985957491690">"Anulo"</string>
    <string name="security_settings_fingerprint_enroll_find_sensor_title" msgid="886085239313346000">"Prek sensorin"</string>
    <string name="security_settings_udfps_enroll_find_sensor_title" msgid="8077484429913330179">"Si të konfigurosh gjurmën e gishtit"</string>
    <string name="security_settings_fingerprint_enroll_find_sensor_message" msgid="6160543980992596286">"Ndodhet në pjesën e pasme të telefonit. Përdor gishtin tregues."</string>
    <string name="security_settings_udfps_enroll_find_sensor_message" msgid="8383106460819519961">"Sensori i gjurmës së gishtit është në ekranin tënd. Do ta regjistrosh gjurmën e gishtit në ekranin tjetër."</string>
    <string name="security_settings_udfps_enroll_find_sensor_start_button" msgid="3172268783620336357">"Nis"</string>
    <string name="security_settings_udfps_enroll_a11y" msgid="1899453114050362235">"Lëvize gishtin nëpër ekran për të gjetur sensorin. Prek dhe mbaj të shtypur sensorin e gjurmës së gishtit"</string>
    <string name="security_settings_fingerprint_enroll_find_sensor_content_description" msgid="3065850549419750523">"Ilustrim me pajisjen dhe vendndodhjen e sensorit të gjurmës së gjishtit"</string>
    <string name="security_settings_fingerprint_enroll_dialog_name_label" msgid="7298812463228440333">"Emri"</string>
    <string name="security_settings_fingerprint_enroll_dialog_ok" msgid="4074335979239208021">"Në rregull"</string>
    <string name="security_settings_fingerprint_enroll_dialog_delete" msgid="6027141901007342389">"Fshi"</string>
    <string name="security_settings_fingerprint_enroll_start_title" msgid="7391368057800077604">"Prek sensorin"</string>
    <string name="security_settings_fingerprint_enroll_start_message" msgid="5010227772754175346">"Vendose gishtin mbi sensor dhe ngrije pasi të ndjesh një dridhje"</string>
    <string name="security_settings_udfps_enroll_start_message" msgid="5032954588171487566">"Mbaje gjurmën e gishtit mbi sensor derisa të ndjesh një dridhje"</string>
    <string name="security_settings_fingerprint_enroll_udfps_title" msgid="6665610134560896895">"Prek dhe mbaj të shtypur sensorin e gjurmës së gishtit"</string>
    <string name="security_settings_fingerprint_enroll_repeat_title" msgid="9172202128243545021">"Ngrije dhe më pas prek përsëri"</string>
    <string name="security_settings_udfps_enroll_title_one_more_time" msgid="424937043843482410">"Edhe një herë"</string>
    <string name="security_settings_udfps_enroll_repeat_title_touch_icon" msgid="4096344864386190335">"Ndiq ikonën e gjurmës së gishtit"</string>
    <string name="security_settings_fingerprint_enroll_repeat_message" msgid="5382958363770893577">"Vazhdo ta ngresh gishtin për të shtuar pjesë të ndryshme të gjurmës së gishtit"</string>
    <string name="security_settings_udfps_enroll_repeat_message" msgid="2213106975297867798">"Prek dhe mbaj të shtypur sa herë që lëviz ikona e gjurmës së gishtit. Kjo ndihmon për të regjistruar një pjesë më të madhe të gjurmës së gishtit tënd."</string>
    <string name="security_settings_udfps_enroll_fingertip_title" msgid="4123142574168831116">"Vendos majën e gishtit në sensor"</string>
    <string name="security_settings_udfps_enroll_left_edge_title" msgid="1944076382202470458">"Vendos skajin e majtë të gishtit"</string>
    <string name="security_settings_udfps_enroll_right_edge_title" msgid="9036744264606447490">"Vendos skajin e djathtë të gishtit"</string>
    <string name="security_settings_udfps_enroll_edge_message" msgid="4455253923746607702">"Vendos anën e gjurmës së gishtit në sensor dhe mbaje, më pas kalo në anën tjetër"</string>
    <string name="security_settings_udfps_enroll_repeat_a11y_message" msgid="2785464357615568197">"Kjo ndihmon për të regjistruar një pjesë më të madhe të gjurmës së gishtit tënd"</string>
    <string name="security_settings_udfps_enroll_progress_a11y_message" msgid="6183535114682369699">"Regjistrimi i gjurmës së gishtit: <xliff:g id="PERCENTAGE">%d</xliff:g> për qind"</string>
    <string name="security_settings_fingerprint_enroll_finish_title" msgid="3606325177406951457">"Gjurma e gishtit u shtua"</string>
    <string name="security_settings_fingerprint_enroll_finish_v2_message" product="tablet" msgid="5918110416185820480">"\"Shkyçja me gjurmën e gishtit\" përmirësohet sa më shumë që e përdor atë për të shkyçur tabletin tënd ose për të verifikuar që je ti në aplikacione"</string>
    <string name="security_settings_fingerprint_enroll_finish_v2_message" product="device" msgid="2989276789236025675">"\"Shkyçja me gjurmën e gishtit\" përmirësohet sa më shumë që e përdor atë për të shkyçur pajisjen tënde ose për të verifikuar që je ti në aplikacione"</string>
    <string name="security_settings_fingerprint_enroll_finish_v2_message" product="default" msgid="6506437402392739879">"\"Shkyçja me gjurmën e gishtit\" përmirësohet sa më shumë që e përdorur atë për të shkyçur telefonin tënd ose për të verifikuar që je ti në aplikacione"</string>
    <string name="security_settings_fingerprint_enroll_enrolling_skip" msgid="3004786457919122854">"Bëje më vonë"</string>
    <string name="security_settings_udfps_tip_fingerprint_help" msgid="7580784640741217494">"Ngrije dhe më pas prek përsëri"</string>
    <string name="security_settings_udfps_side_fingerprint_help" msgid="2567232481013195191">"Vendos anën e gjurmës së gishtit në sensor dhe mbaje, më pas kalo në anën tjetër"</string>
    <string name="setup_fingerprint_enroll_enrolling_skip_title" msgid="352947044008973812">"Kapërce konfigurimin e gjurmës së gishtit?"</string>
    <string name="setup_fingerprint_enroll_enrolling_skip_message" msgid="4876965433600560365">"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="lock_screen_pin_skip_message" product="tablet" msgid="4938798234214623521">"Kodi PIN e mbron tabletin nëse të humbet apo ta vjedhin."</string>
    <string name="lock_screen_pattern_skip_message" product="tablet" msgid="4359575348578515037">"Motivi e mbron tabletin nëse të humbet apo ta vjedhin."</string>
    <string name="lock_screen_password_skip_message" product="tablet" msgid="5420451292764062637">"Fjalëkalimi e mbron tabletin nëse të humbet apo ta vjedhin."</string>
    <string name="lock_screen_pin_skip_message" product="device" msgid="8841426051550671169">"Kodi PIN e mbron pajisjen nëse të humbet apo ta vjedhin."</string>
    <string name="lock_screen_pattern_skip_message" product="device" msgid="6296702954920045923">"Motivi e mbron pajisjen nëse të humbet apo ta vjedhin."</string>
    <string name="lock_screen_password_skip_message" product="device" msgid="9186075211441188900">"Fjalëkalimi e mbron pajisjen nëse të humbet apo ta vjedhin."</string>
    <string name="lock_screen_pin_skip_message" product="default" msgid="4301690296689572747">"Kodi PIN e mbron telefonin nëse të humbet apo ta vjedhin."</string>
    <string name="lock_screen_pattern_skip_message" product="default" msgid="7387967847446084260">"Motivi e mbron telefonin nëse të humbet apo ta vjedhin."</string>
    <string name="lock_screen_password_skip_message" product="default" msgid="6415788841227543063">"Fjalëkalimi e mbron telefonin nëse të humbet apo ta vjedhin."</string>
    <string name="lock_screen_pin_skip_fingerprint_message" product="tablet" msgid="2350062798056164403">"Kërkohet një kod PIN për të konfiguruar \"Shkyçjen me gjurmën e gishtit\".\n\nKodi PIN e mbron tabletin nëse të humbet apo ta vjedhin."</string>
    <string name="lock_screen_pattern_skip_fingerprint_message" product="tablet" msgid="222574071926747300">"Kërkohet një motiv për të konfiguruar \"Shkyçjen me gjurmën e gishtit\".\n\nMotivi e mbron tabletin nëse të humbet apo ta vjedhin."</string>
    <string name="lock_screen_password_skip_fingerprint_message" product="tablet" msgid="7780323831330724644">"Kërkohet një fjalëkalim për të konfiguruar \"Shkyçjen me gjurmën e gishtit\".\n\nFjalëkalimi e mbron tabletin nëse të humbet apo ta vjedhin."</string>
    <string name="lock_screen_pin_skip_fingerprint_message" product="device" msgid="7421096089691939451">"Kërkohet një kod PIN për të konfiguruar \"Shkyçjen me gjurmën e gishtit\".\n\nKodi PIN e mbron pajisjen nëse të humbet apo ta vjedhin."</string>
    <string name="lock_screen_pattern_skip_fingerprint_message" product="device" msgid="6458468083711413617">"Kërkohet një motiv për të konfiguruar \"Shkyçjen me gjurmën e gishtit\".\n\nMotivi e mbron pajisjen nëse të humbet apo ta vjedhin."</string>
    <string name="lock_screen_password_skip_fingerprint_message" product="device" msgid="1632249532665518954">"Kërkohet një fjalëkalim për të konfiguruar \"Shkyçjen me gjurmën e gishtit\".\n\nFjalëkalimi e mbron pajisjen nëse të humbet apo ta vjedhin."</string>
    <string name="lock_screen_pin_skip_fingerprint_message" product="default" msgid="3101384462491132314">"Kërkohet një kod PIN për të konfiguruar \"Shkyçjen me gjurmën e gishtit\".\n\nKodi PIN e mbron telefonin nëse të humbet apo ta vjedhin."</string>
    <string name="lock_screen_pattern_skip_fingerprint_message" product="default" msgid="382422778886929469">"Kërkohet një motiv për të konfiguruar \"Shkyçjen me gjurmën e gishtit\".\n\nMotivi e mbron telefonin nëse të humbet apo ta vjedhin."</string>
    <string name="lock_screen_password_skip_fingerprint_message" product="default" msgid="5515199168425229243">"Kërkohet një fjalëkalim për të konfiguruar \"Shkyçjen me gjurmën e gishtit\".\n\nFjalëkalimi e mbron telefonin nëse të humbet apo ta vjedhin."</string>
    <string name="lock_screen_pin_skip_face_message" product="tablet" msgid="2454239555320628731">"Kërkohet një kod PIN për të konfiguruar \"Shkyçjen me fytyrë\".\n\nKodi PIN e mbron tabletin nëse të humbet apo ta vjedhin."</string>
    <string name="lock_screen_pattern_skip_face_message" product="tablet" msgid="4354138725903415816">"Kërkohet një motiv për të konfiguruar \"Shkyçjen me fytyrë\".\n\nMotivi e mbron tabletin nëse të humbet apo ta vjedhin."</string>
    <string name="lock_screen_password_skip_face_message" product="tablet" msgid="719339718267952196">"Kërkohet një fjalëkalim për të konfiguruar \"Shkyçjen me fytyrë\".\n\nFjalëkalimi e mbron tabletin nëse të humbet apo ta vjedhin."</string>
    <string name="lock_screen_pin_skip_face_message" product="device" msgid="3729243407606881750">"Kërkohet një kod PIN për të konfiguruar \"Shkyçjen me fytyrë\".\n\nKodi PIN e mbron pajisjen nëse të humbet apo ta vjedhin."</string>
    <string name="lock_screen_pattern_skip_face_message" product="device" msgid="6966329744346503807">"Kërkohet një motiv për të konfiguruar \"Shkyçjen me fytyrë\".\n\nMotivi e mbron pajisjen nëse të humbet apo ta vjedhin."</string>
    <string name="lock_screen_password_skip_face_message" product="device" msgid="3020827854443297996">"Kërkohet një fjalëkalim për të konfiguruar \"Shkyçjen me fytyrë\".\n\nFjalëkalimi e mbron pajisjen nëse të humbet apo ta vjedhin."</string>
    <string name="lock_screen_pin_skip_face_message" product="default" msgid="2155678903559865476">"Kërkohet një kod PIN për të konfiguruar \"Shkyçjen me fytyrë\".\n\nKodi PIN e mbron telefonin nëse të humbet apo ta vjedhin."</string>
    <string name="lock_screen_pattern_skip_face_message" product="default" msgid="473271568005748452">"Kërkohet një motiv për të konfiguruar \"Shkyçjen me fytyrë\".\n\nMotivi e mbron telefonin nëse të humbet apo ta vjedhin."</string>
    <string name="lock_screen_password_skip_face_message" product="default" msgid="4319934862372116788">"Kërkohet një fjalëkalim për të konfiguruar \"Shkyçjen me fytyrë\".\n\nFjalëkalimi e mbron telefonin nëse të humbet apo ta vjedhin."</string>
    <string name="lock_screen_pin_skip_biometrics_message" product="tablet" msgid="647987565338402155">"Kërkohet një kod PIN për të konfiguruar \"Shkyçjen me fytyrë\" dhe \"Shkyçjen me gjurmën e gishtit\".\n\nKodi PIN e mbron tabletin nëse të humbet apo ta vjedhin."</string>
    <string name="lock_screen_pattern_skip_biometrics_message" product="tablet" msgid="5293609077890072841">"Kërkohet një motiv për të konfiguruar \"Shkyçjen me fytyrë\" dhe \"Shkyçjen me gjurmën e gishtit\".\n\nMotivi e mbron tabletin nëse të humbet apo ta vjedhin."</string>
    <string name="lock_screen_password_skip_biometrics_message" product="tablet" msgid="2660359318928684172">"Kërkohet një fjalëkalim për të konfiguruar \"Shkyçjen me fytyrë\" dhe \"Shkyçjen me gjurmën e gishtit\".\n\nFjalëkalimi e mbron tabletin nëse të humbet apo ta vjedhin."</string>
    <string name="lock_screen_pin_skip_biometrics_message" product="device" msgid="1278795063897397815">"Kërkohet një kod PIN për të konfiguruar \"Shkyçjen me fytyrë\" dhe \"Shkyçjen me gjurmën e gishtit\".\n\nKodi PIN e mbron pajisjen nëse të humbet apo ta vjedhin."</string>
    <string name="lock_screen_pattern_skip_biometrics_message" product="device" msgid="8766169819759371801">"Kërkohet një motiv për të konfiguruar \"Shkyçjen me fytyrë\" dhe \"Shkyçjen me gjurmën e gishtit\".\n\nMotivi e mbron pajisjen nëse të humbet apo ta vjedhin."</string>
    <string name="lock_screen_password_skip_biometrics_message" product="device" msgid="8611216039321306045">"Kërkohet një fjalëkalim për të konfiguruar \"Shkyçjen me fytyrë\" dhe \"Shkyçjen me gjurmën e gishtit\".\n\nFjalëkalimi e mbron pajisjen nëse të humbet apo ta vjedhin."</string>
    <string name="lock_screen_pin_skip_biometrics_message" product="default" msgid="8796878521409329051">"Kërkohet një kod PIN për të konfiguruar \"Shkyçjen me fytyrë\" dhe \"Shkyçjen me gjurmën e gishtit\".\n\nKodi PIN e mbron telefonin nëse të humbet apo ta vjedhin."</string>
    <string name="lock_screen_pattern_skip_biometrics_message" product="default" msgid="8423700958936341596">"Kërkohet një motiv për të konfiguruar \"Shkyçjen me fytyrë\" dhe \"Shkyçjen me gjurmën e gishtit\".\n\nMotivi e mbron telefonin nëse të humbet apo ta vjedhin."</string>
    <string name="lock_screen_password_skip_biometrics_message" product="default" msgid="5411689248299854172">"Kërkohet një fjalëkalim për të konfiguruar \"Shkyçjen me fytyrë\" dhe \"Shkyçjen me gjurmën e gishtit\".\n\nFjalëkalimi e mbron telefonin nëse të humbet apo ta vjedhin."</string>
    <string name="lock_screen_pin_skip_title" msgid="6853866579893458111">"Do ta kapërcesh konfigurimin e kodit PIN?"</string>
    <string name="lock_screen_pin_skip_face_title" msgid="8810770395309512358">"Të kapërcehet konfigurimi për kodin PIN dhe fytyrën?"</string>
    <string name="lock_screen_pin_skip_fingerprint_title" msgid="371214283158750976">"Të kapërcehet konfigurimi për kodin PIN dhe gjurmën e gishtit?"</string>
    <string name="lock_screen_pin_skip_biometrics_title" msgid="1082066572914073311">"Të kapërcehet konfigurimi për kodin PIN, fytyrën dhe gjurmën e gishtit?"</string>
    <string name="lock_screen_password_skip_title" msgid="8891463713793185768">"Do ta kapërcesh konfigurimin e fjalëkalimit?"</string>
    <string name="lock_screen_password_skip_face_title" msgid="8166210519462164998">"Të kapërcehet konfigurimi për fjalëkalimin dhe fytyrën?"</string>
    <string name="lock_screen_password_skip_fingerprint_title" msgid="2506392546016772170">"Të kapërcehet konfigurimi për fjalëkalimin dhe gjurmën e gishtit?"</string>
    <string name="lock_screen_password_skip_biometrics_title" msgid="900281322095862009">"Të kapërcehet konfigurimi për fjalëkalimin, fytyrën dhe gjurmën e gishtit?"</string>
    <string name="lock_screen_pattern_skip_title" msgid="7214938393640060932">"Do ta kapërcesh konfigurimin e motivit?"</string>
    <string name="lock_screen_pattern_skip_face_title" msgid="145100333454316334">"Të kapërcehet konfigurimi për motivin dhe fytyrën?"</string>
    <string name="lock_screen_pattern_skip_fingerprint_title" msgid="2513110208722100495">"Të kapërcehet konfigurimi për motivin dhe gjurmën e gishtit?"</string>
    <string name="lock_screen_pattern_skip_biometrics_title" msgid="2434258106825380187">"Të kapërcehet konfigurimi për motivin, fytyrën dhe gjurmën e gishtit?"</string>
    <string name="security_settings_fingerprint_enroll_setup_screen_lock" msgid="3538784524778508018">"Konfiguro kyçjen e ekranit"</string>
    <string name="security_settings_fingerprint_enroll_done" msgid="9198775984215057337">"U krye"</string>
    <string name="security_settings_fingerprint_enroll_touch_dialog_title" msgid="5742429501012827526">"Jo, sensori nuk është ai"</string>
    <string name="security_settings_fingerprint_enroll_touch_dialog_message" msgid="7172969336386036998">"Prek sensorin në pjesën e pasme të telefonit. Përdor gishtin tregues."</string>
    <string name="security_settings_fingerprint_enroll_error_dialog_title" msgid="132085362209418770">"Regjistrimi nuk përfundoi"</string>
    <string name="security_settings_fingerprint_enroll_error_timeout_dialog_message" msgid="5479647886550695766">"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="6068935528640241271">"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="6652490687672815760">"Shto një tjetër"</string>
    <string name="fingerprint_enroll_button_next" msgid="1034110123277869532">"Para"</string>
    <string name="security_settings_fingerprint_enroll_disclaimer" msgid="7875826823637114097">"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_fingerprint_disclaimer_lockscreen_disabled_1" msgid="294529888220959309">"Opsioni i kyçjes së ekranit është çaktivizuar. Për të mësuar më shumë, kontakto me administratorin e organizatës sate."</string>
    <string name="security_fingerprint_disclaimer_lockscreen_disabled_2" msgid="8070829069640846543">"Mund të vazhdosh ta përdorësh gjurmën tënde të gishtit për të autorizuar blerjet dhe qasjen në aplikacione."</string>
    <string name="security_settings_fingerprint_enroll_lift_touch_again" msgid="2590665137265458789">"Ngrije gishtin dhe më pas preke përsëri sensorin"</string>
    <string name="security_settings_fingerprint_bad_calibration" msgid="598502302101068608">"Sensori i gjurmës së gishtit nuk mund të përdoret. Vizito një ofrues të shërbimit të riparimit"</string>
    <string name="security_advanced_settings" msgid="6260756619837834042">"Cilësime të tjera të sigurisë"</string>
    <string name="security_advanced_settings_work_profile_settings_summary" msgid="7295451997961973175">"Kyçja e profilit të punës, enkriptimi dhe të tjera"</string>
    <string name="security_advanced_settings_no_work_profile_settings_summary" msgid="345336447137417638">"Enkriptimi, kredencialet dhe të tjera"</string>
    <string name="security_advanced_settings_keywords" msgid="5294945170370974974">"siguria, cilësime të tjera të sigurisë, cilësime të tjera, cilësime të përparuara të sigurisë"</string>
    <string name="privacy_advanced_settings" msgid="8828215456566937719">"Cilësime të tjera të privatësisë"</string>
    <string name="privacy_advanced_settings_summary" msgid="2927281894237561935">"Plotësimi automatik, kontrollet e aktivitetit dhe të tjera"</string>
    <string name="fingerprint_add_max" msgid="8639321019299347447">"Mund të shtosh deri në <xliff:g id="COUNT">%d</xliff:g> gjurma të gishtave"</string>
    <string name="fingerprint_intro_error_max" msgid="4431784409732135610">"Ke shtuar numrin maksimal të gjurmëve të gishtave"</string>
    <string name="fingerprint_intro_error_unknown" msgid="877005321503793963">"Nuk mund të shtohen gjurmë të tjera të gishtave"</string>
    <string name="fingerprint_last_delete_title" msgid="4081475675646514726">"Të hiqen të gjitha gjurmët e gishtave?"</string>
    <string name="fingerprint_delete_title" msgid="1469865327307917858">"Hiq \"<xliff:g id="FINGERPRINT_ID">%1$s</xliff:g>\""</string>
    <string name="fingerprint_delete_message" msgid="1454995433333496541">"Dëshiron ta fshish këtë gjurmë gishti?"</string>
    <string name="fingerprint_v2_delete_message" msgid="4136720729608391131">"Kjo fshin imazhet e gjurmës së gishtit dhe modelin e lidhur me \"<xliff:g id="FINGERPRINT_ID">%1$s</xliff:g>\" që ruhen në pajisjen tënde"</string>
    <string name="fingerprint_last_delete_message" msgid="7860374760549404410">"Nuk do të jesh në gjendje të përdorësh gjurmën e gishtit për të shkyçur telefonin tënd ose për të verifikuar që je ti në aplikacione."</string>
    <string name="fingerprint_last_delete_message_profile_challenge" msgid="4104208067277655068">"Nuk do të jesh në gjendje të përdorësh gjurmën e gishtit për të shkyçur profilin tënd të punës, për të autorizuar blerje ose për t\'u identifikuar në aplikacionet e punës."</string>
    <string name="fingerprint_last_delete_confirm" msgid="3294910995598819259">"Po, hiqi"</string>
    <string name="encryption_settings_title" msgid="2848716008695618360">"Enkriptimi"</string>
    <string name="encrypt_title" product="tablet" msgid="6518642273119816435">"Enkripto tabletin"</string>
    <string name="encrypt_title" product="default" msgid="7337365190988321100">"Enkripto telefonin"</string>
    <string name="encrypted_summary" msgid="545623487587251207">"Enkriptuar"</string>
    <string name="no_screen_lock_issue_title" msgid="1814109590692792891">"Cakto një kyçje ekrani"</string>
    <string name="no_screen_lock_issue_summary" msgid="2383217853510608406">"Për siguri shtesë, cakto një kod PIN, një motiv ose një fjalëkalim për këtë pajisje."</string>
    <string name="no_screen_lock_issue_action_label" msgid="2691229130486382863">"Cakto kyçjen e ekranit"</string>
    <string name="suggested_lock_settings_title" msgid="7836065447159730217">"Siguro telefonin tënd"</string>
    <string name="suggested_lock_settings_summary" product="tablet" msgid="3213718550422761562">"Cakto kyçjen e ekranit për të mbrojtur tabletin"</string>
    <string name="suggested_lock_settings_summary" product="device" msgid="8479766049078378225">"Cakto kyçjen e ekranit për të mbrojtur pajisjen"</string>
    <string name="suggested_lock_settings_summary" product="default" msgid="2443273582716671033">"Cakto kyçjen e ekranit për të mbrojtur telefonin"</string>
    <string name="suggested_fingerprint_lock_settings_title" msgid="3140266181874137984">"Shto gjurmën e gishtit për ta shkyçur"</string>
    <string name="suggested_fingerprint_lock_settings_summary" product="tablet" msgid="1040265358906410746"></string>
    <string name="suggested_fingerprint_lock_settings_summary" product="device" msgid="1040265358906410746"></string>
    <string name="suggested_fingerprint_lock_settings_summary" product="default" msgid="1040265358906410746"></string>
    <string name="lock_settings_picker_title" msgid="9219376327364915334">"Zgjidh kyçjen e ekranit"</string>
    <string name="lock_settings_picker_new_lock_title" msgid="3113042086804290919">"Zgjidh një kyçje ekrani"</string>
    <string name="lock_settings_picker_update_lock_title" msgid="536853138943415927">"Zgjidh një kyçje të re të ekranit"</string>
    <string name="lock_settings_picker_new_profile_lock_title" msgid="2270462215256413800">"Zgjidh një kyçje për aplikacionet e punës"</string>
    <string name="lock_settings_picker_update_profile_lock_title" msgid="5929068163516308927">"Zgjidh një kyçje të re për punën"</string>
    <string name="setup_lock_settings_picker_title" product="tablet" msgid="1276283007274778191">"Mbroje tabletin tënd"</string>
    <string name="setup_lock_settings_picker_title" product="device" msgid="3585905639045649905">"Mbroje pajisjen tënde"</string>
    <string name="setup_lock_settings_picker_title" product="default" msgid="2758197863515864300">"Mbroje telefonin tënd"</string>
    <string name="lock_settings_picker_biometrics_added_security_message" msgid="1105247657304421299">"Për më shumë siguri, cakto një kyçje rezervë për ekranin"</string>
    <string name="setup_lock_settings_picker_message" product="tablet" msgid="4870877800737248926">"Parandalo që të tjerët ta përdorin këtë tablet pa lejen tënde duke aktivizuar veçoritë 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="8961855222808442301">"Parandalo që të tjerët ta përdorin këtë pajisje pa lejen tënde duke aktivizuar veçoritë 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="8867435145945818970">"Parandalo që të tjerët ta përdorin këtë telefon pa lejen tënde duke aktivizuar veçoritë e mbrojtjes së pajisjes. Zgjidh kyçjen e ekranit që dëshiron të përdorësh."</string>
    <string name="lock_settings_picker_biometric_message" msgid="2609666443527262781">"Zgjidh mënyrën rezervë të kyçjes së ekranit"</string>
    <string name="lock_settings_picker_admin_restricted_personal_message" msgid="3532653662159888328">"Nëse harron kyçjen e ekranit, administratori i teknologjisë së informacionit nuk mund ta rivendosë."</string>
    <string name="lock_settings_picker_admin_restricted_personal_message_action" msgid="5956615234246626264">"Cakto një kyçje të veçantë për punën"</string>
    <string name="lock_settings_picker_profile_message" msgid="9142379549980873478">"Nëse e harron këtë kyçje, kërkoji administratorit të teknologjisë së informacionit që ta rivendosë atë"</string>
    <string name="setup_lock_settings_options_button_label" msgid="6098297461618298505">"Opsionet e kyçjes së ekranit"</string>
    <string name="setup_lock_settings_options_dialog_title" msgid="7985107300517468569">"Opsionet e kyçjes së ekranit"</string>
    <string name="unlock_set_unlock_launch_picker_title" msgid="4981063601772605609">"Kyçja e ekranit"</string>
    <string name="unlock_set_unlock_launch_picker_summary_lock_immediately" msgid="5799070517574360310">"<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="4572132216801894216">"<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="7631371082326055429">"Kyçja e profilit të punës"</string>
    <string name="unlock_set_unlock_launch_picker_change_title" msgid="4746783679112447948">"Ndrysho ekranin e kyçjes"</string>
    <string name="unlock_set_unlock_launch_picker_change_summary" msgid="6023813780512501969">"Ndrysho ose çaktivizo sigurinë e motivit, kodit PIN ose fjalëkalimit"</string>
    <string name="unlock_set_unlock_launch_picker_enable_summary" msgid="1699993191343299179">"Zgjidh një metodë për të kyçur ekranin"</string>
    <string name="unlock_set_unlock_off_title" msgid="2831957685685921667">"Asnjë"</string>
    <string name="unlock_set_unlock_off_summary" msgid="4578319976164001322"></string>
    <string name="unlock_set_unlock_none_title" msgid="2844029875174409728">"Me rrëshqitje"</string>
    <string name="unlock_set_unlock_none_summary" msgid="641298008390890152">"Pa siguri"</string>
    <string name="unlock_set_unlock_pattern_title" msgid="8224895208452995332">"Me motiv"</string>
    <string name="unlock_set_unlock_pattern_summary" msgid="4482018884090552709">"Siguria mesatare"</string>
    <string name="unlock_set_unlock_pin_title" msgid="5283636759362880407">"Me kod PIN"</string>
    <string name="unlock_set_unlock_pin_summary" msgid="1961863114590024945">"Siguri mesatare deri në të lartë"</string>
    <string name="unlock_set_unlock_password_title" msgid="2559842616268607041">"Me fjalëkalim"</string>
    <string name="unlock_set_unlock_password_summary" msgid="7647435233968707432">"Siguri e lartë"</string>
    <string name="unlock_set_do_later_title" msgid="6565575303676064364">"Jo tani"</string>
    <string name="current_screen_lock" msgid="1367883977261098017">"Kyçja aktuale e ekranit"</string>
    <string name="fingerprint_unlock_set_unlock_pattern" msgid="4492334416059646032">"Gjurma e gishtit + Motivi"</string>
    <string name="fingerprint_unlock_set_unlock_pin" msgid="4724451168139460493">"Gjurma e gishtit + Kodi PIN"</string>
    <string name="fingerprint_unlock_set_unlock_password" msgid="5614333047430835971">"Gjurma e gishtit + Fjalëkalimi"</string>
    <string name="fingerprint_unlock_skip_fingerprint" msgid="7631242444064287891">"Vazhdo pa gjurmën e gishtit"</string>
    <string name="fingerprint_unlock_title" msgid="4978686534505944042">"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="3117316407679805330">"Shkyçja me fytyrë + Motivi"</string>
    <string name="face_unlock_set_unlock_pin" msgid="5300188327595503657">"Shkyçja me fytyrë + Kodi PIN"</string>
    <string name="face_unlock_set_unlock_password" msgid="8395722611524617956">"Shkyçja me fytyrë + Fjalëkalimi"</string>
    <string name="face_unlock_skip_face" msgid="189695556498300008">"Vazhdo pa \"Shkyçjen me fytyrë\""</string>
    <string name="face_unlock_title" msgid="7344830351598247267">"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="biometrics_unlock_set_unlock_pattern" msgid="8084495264354847044">"Motivi • Fytyra • Gjurma e gishtit"</string>
    <string name="biometrics_unlock_set_unlock_pin" msgid="5912980580857825894">"PIN • Fytyra • Gjurma e gishtit"</string>
    <string name="biometrics_unlock_set_unlock_password" msgid="4612217647465743624">"Fjalëkalimet • Fytyra • Gjurma e gishtit"</string>
    <string name="biometrics_unlock_skip_biometrics" msgid="7785643433551409223">"Vazhdo pa fytyrë apo gjurmë gishti"</string>
    <string name="biometrics_unlock_title" msgid="616524056055233041">"Mund ta shkyçësh telefonin duke përdorur fytyrën ose gjurmën e gishtit. Për siguri, ky opsion kërkon një kyçje rezervë të ekranit."</string>
    <string name="unlock_set_unlock_disabled_summary" msgid="4022867760387966129">"Çaktivizuar nga administratori, politika e enkriptimit ose hapësira ruajtëse e kredencialeve"</string>
    <string name="unlock_set_unlock_mode_off" msgid="4632139864722236359">"Asnjë"</string>
    <string name="unlock_set_unlock_mode_none" msgid="5596049938457028214">"Me rrëshqitje"</string>
    <string name="unlock_set_unlock_mode_pattern" msgid="1926480143883094896">"Motivi"</string>
    <string name="unlock_set_unlock_mode_pin" msgid="9028659554829888373">"Kodi PIN"</string>
    <string name="unlock_set_unlock_mode_password" msgid="8810609692771987513">"Fjalëkalimi"</string>
    <string name="unlock_setup_wizard_fingerprint_details" msgid="5974580769186206478">"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="2564279819907932759">"Çakt. kyçjen e ekranit"</string>
    <string name="unlock_disable_frp_warning_title" msgid="3606280046362811229">"Të fshihet kyçja e ekranit?"</string>
    <string name="unlock_disable_frp_warning_title_profile" msgid="1005284289723910461">"Të hiqet mbrojtja e profilit?"</string>
    <string name="unlock_disable_frp_warning_content_pattern" msgid="6246242612158828147">"Telefoni yt mbrohet nga një motiv në rast se humb ose vidhet."</string>
    <string name="unlock_disable_frp_warning_content_pattern_fingerprint" msgid="2259825377085781801">"Telefoni yt mbrohet nga një motiv në rast se humb ose vidhet.<xliff:g id="EMPTY_LINE">

</xliff:g>Kjo fshin po ashtu modelin e gjurmës së gishtit të ruajtur në pajisjen tënde. Nuk do të mund të përdorësh gjurmën e gishtit për vërtetimin në aplikacione."</string>
    <string name="unlock_disable_frp_warning_content_pattern_face" msgid="4699508435412336378">"Telefoni yt mbrohet nga një motiv në rast se humb ose vidhet.<xliff:g id="EMPTY_LINE">

</xliff:g>Modeli yt i fytyrës do të fshihet gjithashtu përgjithmonë dhe në mënyrë të sigurt. Nuk do të mund ta përdorësh fytyrën për vërtetimin në aplikacione."</string>
    <string name="unlock_disable_frp_warning_content_pattern_face_fingerprint" msgid="7049706229344804972">"Telefoni yt mbrohet nga një motiv në rast se humb ose vidhet.<xliff:g id="EMPTY_LINE">

</xliff:g>Kjo fshin po ashtu modelin e gjurmës së gishtit të ruajtur në pajisjen tënde. Modeli yt i fytyrës do të fshihet gjithashtu përgjithmonë dhe në mënyrë të sigurt. Nuk do të mund të përdorësh fytyrën ose gjurmën e gishtit për vërtetimin në aplikacione."</string>
    <string name="unlock_disable_frp_warning_content_pin" msgid="122154942944422284">"Telefoni yt mbrohet nga një kod PIN në rast se humb ose vidhet."</string>
    <string name="unlock_disable_frp_warning_content_pin_fingerprint" msgid="983373874470746066">"Telefoni yt mbrohet nga një kod PIN në rast se humb ose vidhet.<xliff:g id="EMPTY_LINE">

</xliff:g>Kjo fshin po ashtu modelin e gjurmës së gishtit të ruajtur në pajisjen tënde. Nuk do të mund të përdorësh gjurmën e gishtit për vërtetimin në aplikacione."</string>
    <string name="unlock_disable_frp_warning_content_pin_face" msgid="5607150515413131761">"Telefoni yt mbrohet nga një kod PIN në rast se humb ose vidhet.<xliff:g id="EMPTY_LINE">

</xliff:g>Modeli yt i fytyrës do të fshihet gjithashtu përgjithmonë dhe në mënyrë të sigurt. Nuk do të mund ta përdorësh fytyrën për vërtetimin në aplikacione."</string>
    <string name="unlock_disable_frp_warning_content_pin_face_fingerprint" msgid="1821792325159866312">"Telefoni yt mbrohet nga një kod PIN në rast se humb ose vidhet.<xliff:g id="EMPTY_LINE">

</xliff:g>Kjo fshin modelin e gjurmës së gishtit të ruajtur në pajisjen tënde. Modeli yt i fytyrës do të fshihet gjithashtu përgjithmonë dhe në mënyrë të sigurt. Nuk do të mund të përdorësh fytyrën ose gjurmën e gishtit për vërtetimin në aplikacione."</string>
    <string name="unlock_disable_frp_warning_content_password" msgid="6422723907917376210">"Telefoni yt mbrohet nga një fjalëkalim në rast se humb ose vidhet."</string>
    <string name="unlock_disable_frp_warning_content_password_fingerprint" msgid="8899452884016354856">"Telefoni yt mbrohet nga një fjalëkalim në rast se humb ose vidhet.<xliff:g id="EMPTY_LINE">

</xliff:g>Kjo fshin po ashtu modelin e gjurmës së gishtit të ruajtur në pajisjen tënde. Nuk do të mund të përdorësh gjurmën e gishtit për vërtetimin në aplikacione."</string>
    <string name="unlock_disable_frp_warning_content_password_face" msgid="1811067332335964495">"Telefoni yt mbrohet nga një fjalëkalim në rast se humb ose vidhet.<xliff:g id="EMPTY_LINE">

</xliff:g>Modeli yt i fytyrës do të fshihet gjithashtu përgjithmonë dhe në mënyrë të sigurt. Nuk do të mund ta përdorësh fytyrën për vërtetimin në aplikacione."</string>
    <string name="unlock_disable_frp_warning_content_password_face_fingerprint" msgid="7063649456205159491">"Telefoni yt mbrohet nga një fjalëkalim në rast se humb ose vidhet.<xliff:g id="EMPTY_LINE">

</xliff:g>Kjo fshin modelin e gjurmës së gishtit të ruajtur në pajisjen tënde. Modeli yt i fytyrës do të fshihet gjithashtu përgjithmonë dhe në mënyrë të sigurt. Nuk do të mund të përdorësh fytyrën ose gjurmën e gishtit për vërtetimin në aplikacione."</string>
    <string name="unlock_disable_frp_warning_content_unknown" msgid="8903568674104115231">"Veçoritë 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="6542744110902941189">"Veçoritë e mbrojtjes së pajisjes nuk do të funksionojnë pa kyçjen tënde të ekranit.<xliff:g id="EMPTY_LINE">

</xliff:g>Kjo fshin po ashtu modelin e gjurmës së gishtit të ruajtur në pajisjen tënde. Nuk do të mund të përdorësh gjurmën e gishtit për vërtetimin në aplikacione."</string>
    <string name="unlock_disable_frp_warning_content_unknown_face" msgid="4559917661432267841">"Veçoritë e mbrojtjes së pajisjes nuk do të funksionojnë pa kyçjen tënde të ekranit.<xliff:g id="EMPTY_LINE">

</xliff:g>Modeli yt i fytyrës do të fshihet gjithashtu përgjithmonë dhe në mënyrë të sigurt. Nuk do të mund ta përdorësh fytyrën për vërtetimin në aplikacione."</string>
    <string name="unlock_disable_frp_warning_content_unknown_face_fingerprint" msgid="3779582301453677644">"Veçoritë e mbrojtjes së pajisjes nuk do të funksionojnë pa kyçjen tënde të ekranit.<xliff:g id="EMPTY_LINE">

</xliff:g>Kjo fshin modelin e gjurmës së gishtit të ruajtur në pajisjen tënde. Modeli yt i fytyrës do të fshihet gjithashtu përgjithmonë dhe në mënyrë të sigurt. Nuk do të mund të përdorësh fytyrën ose gjurmën e gishtit për vërtetimin në aplikacione."</string>
    <string name="unlock_disable_frp_warning_ok" msgid="6173427638951230842">"Fshi"</string>
    <string name="unlock_change_lock_pattern_title" msgid="8234523589333929193">"Ndrysho motivin e shkyçjes"</string>
    <string name="unlock_change_lock_pin_title" msgid="2324077520816477479">"Ndrysho kodin PIN"</string>
    <string name="unlock_change_lock_password_title" msgid="873517913969091074">"Ndrysho fjalk. shkyçjes"</string>
    <string name="unlock_footer_high_complexity_requested" msgid="4471274783909915352">"<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="5515870066751600640">"<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="2517656037576567971">"<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="8534900170428140529">"<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="6874652886647631418">"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="7450322567217745999">"Të dhënat e tua do të fshihen"</string>
    <string name="lock_last_pattern_attempt_before_wipe_device" msgid="5816668400104558952">"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="2815681042623708775">"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="985126164175708507">"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="8283944727199433440">"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="972834567684477451">"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="3797239847079686727">"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="2479195488386373253">"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="7086428013814722436">"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="253673907244112643">"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>
    <plurals name="lockpassword_password_too_short" formatted="false" msgid="2192234965414232157">
      <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>
    <string name="lockpassword_password_too_short_all_numeric" msgid="4301294924022401502">"{count,plural, =1{Nëse përdor vetëm numra, ai duhet të përmbajë të paktën 1 shifër}other{Nëse përdor vetëm numra, ai duhet të përmbajë të paktën # shifra}}"</string>
    <plurals name="lockpassword_pin_too_short" formatted="false" msgid="6817086810898414162">
      <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="2507983991979547816">"Vazhdo"</string>
    <plurals name="lockpassword_password_too_long" formatted="false" msgid="8118091957172967677">
      <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="8706992338720310765">
      <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_recently_used" msgid="6650277060998923465">"Administratori i pajisjes nuk e lejon përdorimin e një kodi PIN të përdorur së fundi"</string>
    <string name="lockpassword_illegal_character" msgid="3434031212215886433">"Kjo nuk mund të përfshijë një karakter të pavlefshëm"</string>
    <string name="lockpassword_password_requires_alpha" msgid="721084100957669018">"Duhet të përmbajë të paktën një germë"</string>
    <string name="lockpassword_password_requires_digit" msgid="312518567592683795">"Duhet të përmbajë të paktën një shifër"</string>
    <string name="lockpassword_password_requires_symbol" msgid="6178512486154701321">"Duhet të përmbajë të paktën një simbol"</string>
    <plurals name="lockpassword_password_requires_letters" formatted="false" msgid="2385916409676839024">
      <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="2057467885488612701">
      <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="4541266279643052025">
      <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="70617964591376248">
      <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="7981236881269921943">
      <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="1567877061888948467">
      <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>
    <plurals name="lockpassword_password_requires_nonnumerical" formatted="false" msgid="5056743974888384475">
      <item quantity="other">Duhet të përmbajë të paktën <xliff:g id="COUNT">%d</xliff:g> karaktere jonumerike</item>
      <item quantity="one">Duhet të përmbajë të paktën 1 karakter jonumerik</item>
    </plurals>
    <string name="lockpassword_password_recently_used" msgid="5341218079730167191">"Administratori i pajisjes nuk e lejon përdorimin e një fjalëkalimi të përdorur së fundi"</string>
    <string name="lockpassword_pin_no_sequential_digits" msgid="5843639256988031272">"Nuk lejohet një sekuencë shifrash në rritje, në zbritje ose me përsëritje"</string>
    <string name="lockpassword_confirm_label" msgid="560897521093566777">"Konfirmo"</string>
    <string name="lockpassword_cancel_label" msgid="6711112212489992112">"Anulo"</string>
    <string name="lockpassword_clear_label" msgid="311359833434539894">"Pastro"</string>
    <string name="lockpassword_credential_changed" msgid="5934778179732392028">"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="775215267818384016">"Anulo"</string>
    <string name="lockpattern_tutorial_continue_label" msgid="1329049481210689408">"Para"</string>
    <string name="lock_setup" msgid="4622999020926280737">"Konfigurimi përfundoi."</string>
    <string name="manage_device_admin" msgid="1044620606203916275">"Apl. e admin. të pajisjes"</string>
    <string name="number_of_device_admins_none" msgid="152926922020437312">"Asnjë aplikacion aktiv"</string>
    <plurals name="number_of_device_admins" formatted="false" msgid="2528735319390151989">
      <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="6410149930029992356">"Agjentët e besuar"</string>
    <string name="disabled_because_no_backup_security" msgid="4998095356607488854">"Për ta përdorur, në fillim cakto një kyçje ekrani"</string>
    <string name="manage_trust_agents_summary" msgid="6423843123607674286">"Asnjë"</string>
    <plurals name="manage_trust_agents_summary_on" formatted="false" msgid="5438047398376802735">
      <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="5955341060378240781">"Bluetooth-i"</string>
    <string name="bluetooth_quick_toggle_summary" msgid="5257744297562880017">"Aktivizo \"Bluetooth-in\""</string>
    <string name="bluetooth_settings" msgid="2967239493428695171">"Bluetooth-i"</string>
    <string name="bluetooth_settings_title" msgid="2642029095769509647">"Bluetooth-i"</string>
    <string name="bluetooth_settings_summary" msgid="6805458703566046784">"Menaxho lidhjet, cakto emrin e pajisjes dhe zbulueshmërinë"</string>
    <string name="bluetooth_pairing_request" msgid="7762990650683525640">"Të çiftohet me <xliff:g id="DEVICE_NAME">%1$s</xliff:g>?"</string>
    <string name="bluetooth_pairing_key_msg" msgid="1329835708475701761">"Kodi i çiftimit të Bluetooth-it"</string>
    <string name="bluetooth_enter_passkey_msg" msgid="5806420933599368592">"Shkruaj kodin e çiftimit, pastaj shtyp \"Kthehu\" ose \"Hyr\""</string>
    <string name="bluetooth_enable_alphanumeric_pin" msgid="7256286571636950635">"Kodi PIN përmban shkronja ose simbole"</string>
    <string name="bluetooth_pin_values_hint" msgid="2753202519050044670">"Zakonisht 0000 ose 1234"</string>
    <string name="bluetooth_pin_values_hint_16_digits" msgid="5603928271430883558">"Duhet të ketë 16 shifra"</string>
    <string name="bluetooth_enter_pin_other_device" msgid="6737778699899780717">"Mund të duhet gjithashtu ta shkruash këtë kod PIN në pajisjen tjetër."</string>
    <string name="bluetooth_enter_passkey_other_device" msgid="8270426446247344709">"Mund të duhet gjithashtu ta shkruash këtë çelës kalimi në pajisjen tjetër."</string>
    <string name="bluetooth_confirm_passkey_msg" msgid="327192310468680072">"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ë çelës kalimi:&lt;br&gt;&lt;b&gt;<xliff:g id="PASSKEY">%2$s</xliff:g>&lt;/b&gt;"</string>
    <string name="bluetooth_paring_group_msg" msgid="4609515924670823316">"Konfirmo për të çiftuar me grupin e koordinuar"</string>
    <string name="bluetooth_incoming_pairing_msg" msgid="1068123527866596779">"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="8672803845151786521">"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="4329325125260724843">"Lejo qasjen te kontaktet dhe historiku i telefonatave"</string>
    <string name="bluetooth_error_title" msgid="2284738188253690278"></string>
    <string name="bluetooth_connecting_error_message" msgid="3941893154784152112">"Nuk mundi të lidhej me <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="bluetooth_preference_scan_title" msgid="3460316252463771851">"Skano për pajisje"</string>
    <string name="bluetooth_search_for_devices" msgid="6516902340975407648">"Rifresko"</string>
    <string name="bluetooth_searching_for_devices" msgid="6541984133657573124">"Po kërkon..."</string>
    <string name="bluetooth_preference_device_settings" msgid="1688662188157019998">"Cilësimet e pajisjes"</string>
    <string name="bluetooth_preference_paired_dialog_title" msgid="1090131276572055841">"Pajisja e çiftuar"</string>
    <string name="bluetooth_preference_paired_dialog_internet_option" msgid="4337953030661626289">"Lidhje me internet"</string>
    <string name="bluetooth_preference_paired_dialog_keyboard_option" msgid="8247634441638919886">"Tastiera"</string>
    <string name="bluetooth_preference_paired_dialog_contacts_option" msgid="8194423860397844579">"Kontaktet dhe historiku i telefonatave"</string>
    <string name="bluetooth_pairing_dialog_title" msgid="6106058683134173178">"Të çiftohet me këtë pajisje?"</string>
    <string name="bluetooth_pairing_dialog_sharing_phonebook_title" msgid="5472835166206721325">"Të ndahet numëratori telefonik?"</string>
    <string name="bluetooth_pairing_dialog_contants_request" msgid="7516277926581535299">"<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="1545098121090892788">"<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="830061195998352840">"Pajisjet që ofrohen"</string>
    <string name="bluetooth_preference_no_found_devices" msgid="1331122763066030155">"Nuk ofrohet asnjë pajisje"</string>
    <string name="bluetooth_device_context_connect" msgid="4913860372216815855">"Lidh"</string>
    <string name="bluetooth_device_context_disconnect" msgid="4464167389972513232">"Shkëput"</string>
    <string name="bluetooth_device_context_pair_connect" msgid="2406032703622371826">"Ҫifto dhe lidh"</string>
    <string name="bluetooth_device_context_unpair" msgid="7525735305244087162">"Anulo çiftimin"</string>
    <string name="bluetooth_device_context_disconnect_unpair" msgid="2001359431289794561">"Shkëput dhe anulo çiftimin"</string>
    <string name="bluetooth_device_context_connect_advanced" msgid="934657460643490773">"Opsionet..."</string>
    <string name="bluetooth_menu_advanced" msgid="7633682234855216066">"Të përparuara"</string>
    <string name="bluetooth_advanced_titlebar" msgid="5369701494951467257">"Cilësimet e përparuara të Bluetooth-it"</string>
    <string name="bluetooth_empty_list_bluetooth_off" msgid="316627049372961941">"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="6667723887545056976">"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 me Bluetooth"</annotation>"."</string>
    <string name="ble_scan_notify_text" msgid="1358879010396045164">"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="7892663424429584925">"Nuk mund të lidhej. Provo përsëri."</string>
    <string name="device_details_title" msgid="1155622417516195481">"Detajet e pajisjes"</string>
    <string name="bluetooth_device_mac_address" msgid="4873325074786732703">"Adresa e Bluetooth-it e pajisjes: <xliff:g id="ADDRESS">%1$s</xliff:g>"</string>
    <string name="bluetooth_multuple_devices_mac_address" msgid="4974301550897923376">"Adresa e Bluetooth-it e pajisjes:\n<xliff:g id="ADDRESS">%1$s</xliff:g>"</string>
    <string name="bluetooth_unpair_dialog_title" msgid="6943633443716052995">"Të harrohet pajisja?"</string>
    <string name="remove_association_button" msgid="5004208145998061135">"Hiq lidhjen"</string>
    <string name="bluetooth_companion_app_remove_association_dialog_title" msgid="1344518601377991897">"Të shkëputet aplikacioni?"</string>
    <string name="bluetooth_unpair_dialog_body" product="default" msgid="4730377171981539265">"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="3428463407231980054">"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="5117397433721336918">"Pajisja jote nuk do të jetë më e çiftuar me <xliff:g id="DEVICE_NAME">%1$s</xliff:g>"</string>
    <string name="bluetooth_companion_app_body" msgid="8442643629075687761">"Aplikacioni <xliff:g id="APP_NAME">%1$s</xliff:g> nuk do të lidhet më me pajisjen tënde <xliff:g id="DEVICE_NAME">%2$s</xliff:g>"</string>
    <string name="bluetooth_unpair_dialog_forget_confirm_button" msgid="9184489424930549015">"Harroje pajisjen"</string>
    <string name="bluetooth_companion_app_remove_association_confirm_button" msgid="76323555527926915">"Shkëput aplikacionin"</string>
    <string name="bluetooth_connect_specific_profiles_title" msgid="1323072239637864488">"Lidhu me…"</string>
    <string name="bluetooth_disconnect_a2dp_profile" msgid="339103864166293612">"<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="7857706184371154920">"<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="4794752406024916925">"<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="283176886159444413">"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="733193449967330892">"<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="7852265676243153982">"<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="1181664272013729515">"Pajisja me Bluetooth e çiftuar"</string>
    <string name="bluetooth_device_advanced_online_mode_title" msgid="8302236592496988747">"Lidh"</string>
    <string name="bluetooth_device_advanced_online_mode_summary" msgid="271856759516576615">"Lidhu me pajisjen me Bluetooth"</string>
    <string name="bluetooth_device_advanced_profile_header_title" msgid="7892879890208207223">"Përdore për"</string>
    <string name="bluetooth_device_advanced_rename_device" msgid="4798081898389041132">"Riemërto"</string>
    <string name="bluetooth_device_advanced_enable_opp_title" msgid="7604726126703453984">"Lejo transferimet e skedarëve hyrës"</string>
    <string name="bluetooth_pan_user_profile_summary_connected" msgid="7851033200857999275">"Lidhur me pajisjen për qasje në internet"</string>
    <string name="bluetooth_pan_nap_profile_summary_connected" msgid="5563892893331988809">"Po ndan lidhjen lokale të internetit me pajisjen"</string>
    <string name="bluetooth_dock_settings" msgid="1709536202189755022">"Cilësimet e stacionit"</string>
    <string name="bluetooth_dock_settings_title" msgid="4872789068019972847">"Përdor stacionin për audion"</string>
    <string name="bluetooth_dock_settings_headset" msgid="5756482379574272554">"Si altoparlant"</string>
    <string name="bluetooth_dock_settings_a2dp" msgid="434520221656010141">"Për muzikë dhe media"</string>
    <string name="bluetooth_dock_settings_remember" msgid="6993526033095292609">"Kujto cilësimet"</string>
    <string name="bluetooth_max_connected_audio_devices_string" msgid="3114156958598821615">"Numri maksimal i pajisjeve të lidhura audio me Bluetooth"</string>
    <string name="bluetooth_max_connected_audio_devices_dialog_title" msgid="4056811727247312473">"Zgjidh numrin maksimal të pajisjeve të lidhura audio me Bluetooth"</string>
    <string name="nfc_stack_debuglog_title" msgid="2926748386805740609">"Evidenca e korrigjimit të grumbullit të NFC-së"</string>
    <string name="nfc_stack_debuglog_summary" msgid="7333205107551132121">"Rrit nivelin e regjistrimit të grumbullit të NFC-së"</string>
    <string name="wifi_display_settings_title" msgid="6451625615274960175">"Transmetimi"</string>
    <string name="keywords_wifi_display_settings" msgid="5753883229564422679">"pasqyro"</string>
    <string name="wifi_display_enable_menu_item" msgid="7391841780777318134">"Aktivizo ekranin pa tel"</string>
    <string name="wifi_display_no_devices_found" msgid="7904877793677102805">"Nuk u gjet asnjë pajisje në afërsi."</string>
    <string name="wifi_display_status_connecting" msgid="530880182560077334">"Po lidhet"</string>
    <string name="wifi_display_status_connected" msgid="2189925211258519539">"Të lidhura"</string>
    <string name="wifi_display_status_in_use" msgid="5904009697167947449">"Në përdorim"</string>
    <string name="wifi_display_status_not_available" msgid="8463750208946968594">"Nuk ofrohet"</string>
    <string name="wifi_display_details" msgid="2351632307998142920">"Shfaq cilësimet"</string>
    <string name="wifi_display_options_title" msgid="7584326966240865043">"Opsionet e ekranit pa tel"</string>
    <string name="wifi_display_options_forget" msgid="3140558691112356024">"Harro"</string>
    <string name="wifi_display_options_done" msgid="7608851767701954020">"U krye"</string>
    <string name="wifi_display_options_name" msgid="8181334945680312228">"Emri"</string>
    <string name="wifi_band_24ghz" msgid="7322286660245127384">"2,4 GHz"</string>
    <string name="wifi_band_5ghz" msgid="7995204987245404797">"5 GHz"</string>
    <string name="wifi_band_6ghz" msgid="8166833829829455339">"6 GHz"</string>
    <string name="wifi_sign_in_button_text" msgid="8483892122845654850">"Identifikohu"</string>
    <string name="wifi_venue_website_button_text" msgid="7749360432667175030">"Hap sajtin"</string>
    <string name="wifi_time_remaining" msgid="8503606272869846170">"<xliff:g id="REMAINING_TIME">%1$s</xliff:g> të mbetura"</string>
    <string name="wifi_expiry_time" msgid="5419758551129267624">"Skadon më <xliff:g id="EXPIRY_TIME">%1$s</xliff:g>"</string>
    <string name="wifi_tap_to_sign_in" msgid="8658506618807549483">"Trokit këtu për t\'u identifikuar në rrjet"</string>
    <string name="tx_link_speed" msgid="3071955184703668113">"<xliff:g id="TRANSMIT_LINK_SPEED">%1$d</xliff:g> Mbps"</string>
    <string name="rx_link_speed" msgid="6292229178855567783">"<xliff:g id="RECEIVE_LINK_SPEED">%1$d</xliff:g> Mbps"</string>
    <string name="link_speed" msgid="931786745741016446">"<xliff:g id="LINK_SPEED">%1$d</xliff:g> Mbps"</string>
    <string name="wifi_ask_enable" msgid="6860056048266810769">"<xliff:g id="REQUESTER">%s</xliff:g> kërkon të aktivizojë Wi-Fi"</string>
    <string name="wifi_ask_disable" msgid="1663208096020309639">"<xliff:g id="REQUESTER">%s</xliff:g> kërkon të çaktivizojë Wi-Fi"</string>
    <string name="art_verifier_for_debuggable_title" msgid="1926445785190030479">"Verifiko kodin me bajte për apl. e korrigjueshme"</string>
    <string name="art_verifier_for_debuggable_summary" msgid="4802875841862652879">"Lejo që ART të verifikojë kodin me bajte për aplikacionet e korrigjueshme"</string>
    <string name="show_refresh_rate" msgid="5742688821872354973">"Shfaq shpejtësinë e rifreskimit"</string>
    <string name="show_refresh_rate_summary" msgid="3558118122374609663">"Shfaq shpejtësinë aktuale të rifreskimit të ekranit"</string>
    <string name="nfc_quick_toggle_title" msgid="3607620705230351666">"NFC"</string>
    <string name="nfc_quick_toggle_summary" product="tablet" msgid="3622326550467939809">"Lejo shkëmbimin e të dhënave kur tableti prek një pajisje me NFC"</string>
    <string name="nfc_quick_toggle_summary" product="default" msgid="1460871052409162980">"Lejo shkëmbimin e të dhënave kur telefoni prek një pajisje me NFC"</string>
    <string name="nfc_disclaimer_title" msgid="3696580694485048039">"Aktivizo NFC-në"</string>
    <string name="nfc_disclaimer_content" msgid="8256675597551036207">"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="4906958426927741485">"Kërkohet shkyçja e pajisjes për NFC"</string>
    <string name="nfc_secure_toggle_summary" product="default" msgid="407654335737959071">"Lejo përdorimin e NFC-së vetëm kur ekrani është i shkyçur"</string>
    <string name="android_beam_settings_title" msgid="2797963824490671295">"Dërgimi me rreze i Androidit"</string>
    <string name="android_beam_on_summary" msgid="6067720758437490896">"Gati për të transmetuar përmbajtjen e aplikacionit përmes NFC-së"</string>
    <string name="android_beam_off_summary" msgid="5693961375631325042">"Çaktivizuar"</string>
    <string name="nfc_disabled_summary" msgid="8737797364522502351">"Nuk ofrohet sepse NFC-ja është e çaktivizuar"</string>
    <string name="android_beam_label" msgid="7168565080321110094">"Dërgimi me rreze i Androidit"</string>
    <string name="android_beam_explained" msgid="5684416131846701256">"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="2737097538432862807">"Wi-Fi"</string>
    <string name="wifi_quick_toggle_summary" msgid="4957267477820468553">"Aktivizo Wi-Fi"</string>
    <string name="wifi_settings" msgid="8313301946393559700">"Wi‑Fi"</string>
    <string name="wifi_settings_primary_switch_title" msgid="628360786662947258">"Përdor Wi-Fi"</string>
    <string name="wifi_settings_category" msgid="3523464780563778321">"Cilësimet e Wi-Fi"</string>
    <string name="wifi_settings_title" msgid="3879649725059512799">"Wi‑Fi"</string>
    <string name="wifi_settings_summary" msgid="784074686763572811">"Cakto dhe menaxho zonat e qasjes të rrjetit me valë"</string>
    <string name="wifi_select_network" msgid="6692897876718813259">"Zgjidh Wi‑Fi"</string>
    <string name="wifi_starting" msgid="6147022683967506341">"Po aktivizon Wi‑Fi…"</string>
    <string name="wifi_stopping" msgid="4471699665741299711">"Po çaktivizon Wi‑Fi…"</string>
    <string name="wifi_error" msgid="4903954145386086899">"Gabim"</string>
    <string name="wifi_sap_no_channel_error" msgid="2126487622024749402">"Brezi 5 GHz nuk ofrohet në këtë vend"</string>
    <string name="wifi_in_airplane_mode" msgid="1235412508135267981">"Në modalitetin e aeroplanit"</string>
    <string name="wifi_notify_open_networks" msgid="2610323626246818961">"Njofto për rrjetet publike"</string>
    <string name="wifi_notify_open_networks_summary" msgid="191058832201741013">"Njofto kur ofrohet një rrjet publik me cilësi të lartë"</string>
    <string name="wifi_wakeup" msgid="3834327315861781611">"Aktivizo automatikisht Wi‑Fi"</string>
    <string name="wifi_wakeup_summary" msgid="5778059083790221465">"Wi-Fi do të aktivizohet përsëri në afërsi të rrjeteve të ruajtura me cilësi të lartë, si p.sh. rrjeti i shtëpisë"</string>
    <string name="wifi_wakeup_summary_no_location" msgid="681323616606485096">"Nuk ofrohet sepse vendndodhja është e çaktivizuar. Aktivizo "<annotation id="link">"vendndodhjen"</annotation>"."</string>
    <string name="wifi_wakeup_summary_scanning_disabled" msgid="1771489741850119751">"Nuk ofrohet sepse skanimi i Wi-Fi është çaktivizuar"</string>
    <string name="wifi_wakeup_summary_scoring_disabled" msgid="3615120120960539780">"Për ta përdorur, zgjidh një ofrues të vlerësimit të rrjetit"</string>
    <string name="wifi_poor_network_detection" msgid="8210035875160288422">"Shmang lidhjet e dobëta"</string>
    <string name="wifi_poor_network_detection_summary" msgid="383834617032605347">"Mos përdor rrjet Wi‑Fi nëse nuk ka lidhje të mirë interneti"</string>
    <string name="wifi_avoid_poor_network_detection_summary" msgid="4993203473116721772">"Përdor vetëm rrjete që kanë lidhje të mirë interneti"</string>
    <string name="use_open_wifi_automatically_title" msgid="7193846454986712009">"Lidhu me rrjetet publike"</string>
    <string name="use_open_wifi_automatically_summary" msgid="6663890845558591023">"Lidhu automatikisht me rrjete publike me cilësi të lartë"</string>
    <string name="use_open_wifi_automatically_summary_scoring_disabled" msgid="2299284032301667622">"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="1780306481499369913">"Për ta përdorur, zgjidh një ofrues të përputhshëm të vlerësimit të rrjetit"</string>
    <string name="wifi_install_credentials" msgid="5192903644606839972">"Instalo certifikatat"</string>
    <string name="wifi_scan_notify_text" msgid="7163137260385995873">"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 me Wi-Fi<xliff:g id="LINK_END_1">LINK_END</xliff:g>."</string>
    <string name="wifi_scan_notify_text_scanning_off" msgid="7439201783168213149">"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 të Wi-Fi<xliff:g id="LINK_END_1">LINK_END</xliff:g>."</string>
    <string name="wifi_scan_notify_remember_choice" msgid="8436897497968907701">"Mos e shfaq përsëri"</string>
    <string name="wifi_setting_sleep_policy_title" msgid="6285374200292675649">"Wi-Fi aktiv kur fiket ekrani"</string>
    <string name="wifi_setting_on_during_sleep_title" msgid="8753852404141070878">"Wi-Fi gjatë qendrimit në gjendje gjumi"</string>
    <string name="wifi_setting_sleep_policy_error" msgid="4512566787805720422">"Kishte një problem me ndryshimin e cilësimit"</string>
    <string name="wifi_suspend_efficiency_title" msgid="3589291227092825754">"Përmirëso efikasitetin"</string>
    <string name="wifi_suspend_optimizations" msgid="5840680940416640209">"Optimizimi i Wi-Fi"</string>
    <string name="wifi_suspend_optimizations_summary" msgid="8204170804523356781">"Minimizo përdorimin e baterisë kur Wi‑Fi është aktiv"</string>
    <string name="wifi_limit_optimizations_summary" msgid="8461087338100462302">"Kufizo baterinë në Wi-Fi"</string>
    <string name="wifi_switch_away_when_unvalidated" msgid="681353878530696197">"Kalo te të dhënat celulare nëse Wi‑Fi humbet qasjen në internet."</string>
    <string name="wifi_cellular_data_fallback_title" msgid="2844653839490977040">"Kalo automatikisht te të dhënat celulare"</string>
    <string name="wifi_cellular_data_fallback_summary" msgid="7039944853033554386">"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="4178564862173751181">"Shto një rrjet"</string>
    <string name="wifi_configure_settings_preference_title" msgid="2536725796700696566">"Preferencat e Wi‑Fi"</string>
    <string name="wifi_configure_settings_preference_summary_wakeup_on" msgid="7822368955551467382">"Wi‑Fi aktivizohet përsëri automatikisht"</string>
    <string name="wifi_configure_settings_preference_summary_wakeup_off" msgid="5710203586018223864">"Wi‑Fi nuk aktivizohet përsëri automatikisht"</string>
    <string name="wifi_access_points" msgid="5846755709207101844">"Rrjetet Wi‑Fi"</string>
    <string name="wifi_menu_more_options" msgid="1236651929987819716">"Opsione të tjera"</string>
    <string name="wifi_menu_p2p" msgid="5234165837732940385">"Wi‑Fi Direct"</string>
    <string name="wifi_menu_scan" msgid="3498653582115656526">"Skano"</string>
    <string name="wifi_menu_advanced" msgid="1940919392030994019">"Të përparuara"</string>
    <string name="wifi_menu_configure" msgid="352423980467311427">"Konfiguro"</string>
    <string name="wifi_menu_connect" msgid="7824796427932811078">"Lidhu me rrjetin"</string>
    <string name="wifi_menu_remember" msgid="8639523871321603112">"Kujto rrjetin"</string>
    <string name="wifi_menu_forget" msgid="6557142984528657361">"Harro rrjetin"</string>
    <string name="wifi_menu_modify" msgid="7246143391161038875">"Modifiko rrjetin"</string>
    <string name="wifi_empty_list_wifi_off" msgid="7697422506708419298">"Për të parë rrjetet që ofrohen, aktivizo Wi-Fi."</string>
    <string name="wifi_empty_list_wifi_on" msgid="2448010040478321376">"Po kërkon për rrjete…"</string>
    <string name="wifi_empty_list_user_restricted" msgid="454861411536708709">"Nuk ke leje të ndryshosh rrjetin Wi-Fi."</string>
    <string name="wifi_more" msgid="8742256421693351035">"Më shumë"</string>
    <string name="wifi_setup_wps" msgid="4303694722593999931">"Konfigurimi automatik (WPS)"</string>
    <string name="wifi_settings_scanning_required_title" msgid="1088663325396007484">"Të aktivizohet skanimi i Wi‑Fi?"</string>
    <string name="wifi_settings_scanning_required_summary" msgid="4770243653675416569">"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="1473411566072565789">"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 veçoritë dhe shërbimet e bazuara te vendndodhja."</string>
    <string name="wifi_settings_scanning_required_turn_on" msgid="1112223196123955447">"Aktivizo"</string>
    <string name="wifi_settings_scanning_required_enabled" msgid="4721729158927146365">"Skanimi i Wi‑Fi është aktivizuar"</string>
    <string name="wifi_show_advanced" msgid="2969378109942071741">"Opsionet e përparuara"</string>
    <string name="wifi_advanced_toggle_description" msgid="7299179796727934885">"Opsionet e përparuara të listës me lëshim poshtë"</string>
    <string name="wifi_advanced_toggle_description_collapsed" msgid="3615140699129928913">"zgjero"</string>
    <string name="wifi_ssid" msgid="2713062130735103151">"Emri i rrjetit"</string>
    <string name="wifi_ssid_hint" msgid="1940577553241083524">"Fut SSID-në"</string>
    <string name="wifi_security" msgid="9095934643631406913">"Siguria"</string>
    <string name="wifi_hidden_network" msgid="6466834025375485596">"Rrjet i fshehur"</string>
    <string name="wifi_hidden_network_warning" msgid="3937433813754746158">"Nëse router-i 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="4442182285304271424">"Fuqia e sinjalit"</string>
    <string name="wifi_status" msgid="5349199188871002778">"Statusi"</string>
    <string name="tx_wifi_speed" msgid="2368986629172050673">"Shpejtësia e lidhjes së transmetimit"</string>
    <string name="rx_wifi_speed" msgid="5167966079215111232">"Shpejtësia e lidhjes së marrjes"</string>
    <string name="wifi_speed" msgid="6562147734565434513">"Shpejtësia e lidhjes"</string>
    <string name="wifi_frequency" msgid="3120998420184702834">"Frekuenca"</string>
    <string name="wifi_ip_address" msgid="8903577251845268209">"Adresa e IP-së"</string>
    <string name="passpoint_label" msgid="6513669696739302866">"U ruajt me"</string>
    <string name="passpoint_content" msgid="5219226173518418335">"Kredencialet e <xliff:g id="NAME">%1$s</xliff:g>"</string>
    <string name="wifi_eap_method" msgid="3776009521349381742">"Metoda EAP"</string>
    <string name="please_select_phase2" msgid="577633852089847142">"Vërtetimi i Fazës 2"</string>
    <string name="wifi_eap_ca_cert" msgid="8033404008276298886">"Certifikata CA"</string>
    <string name="wifi_eap_ocsp" msgid="8713933962516871238">"Statusi i certifikatës në linjë"</string>
    <string name="wifi_eap_domain" msgid="8304301470752333203">"Domeni"</string>
    <string name="wifi_eap_user_cert" msgid="3569182430929173220">"Certifikata e përdoruesit"</string>
    <string name="wifi_eap_identity" msgid="3629406902174137028">"Identiteti"</string>
    <string name="wifi_eap_anonymous" msgid="8630332141751267000">"Identitet anonim"</string>
    <string name="wifi_password" msgid="1458802324849513755">"Fjalëkalimi"</string>
    <string name="wifi_show_password" msgid="6865993988238157923">"Shfaq fjalëkalimin"</string>
    <string name="wifi_ap_band_config" msgid="1589020070150933055">"Zgjidh bandën AP"</string>
    <string name="wifi_ap_choose_auto" msgid="8944442003151215691">"Automatik"</string>
    <string name="wifi_ap_choose_2G" msgid="1436802195991542016">"Bandë 2,4 GHz"</string>
    <string name="wifi_ap_choose_5G" msgid="8413248472288180075">"Banda 5,0 GHz"</string>
    <string name="wifi_ap_prefer_5G" msgid="2520628479818369902">"Preferohet banda 5,0 GHz"</string>
    <string name="wifi_ap_2G" msgid="4099628221864343015">"2,4 GHz"</string>
    <string name="wifi_ap_5G" msgid="3493942667238551207">"5,0 GHz"</string>
    <string name="wifi_ap_band_select_one" msgid="5221193733812493435">"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="6420498748726599133">"Cilësimet e IP-së"</string>
    <string name="wifi_privacy_settings" msgid="3283946009000725698">"Privatësia"</string>
    <string name="wifi_subscription" msgid="4432423938285430113">"Abonim"</string>
    <string name="wifi_subscription_summary" msgid="18802471063384598">"Shiko ose ndrysho abonimin"</string>
    <string name="wifi_privacy_settings_ephemeral_summary" msgid="8502084692297249372">"Adresa MAC e rastësishme"</string>
    <string name="wifi_dpp_add_device_to_network" msgid="6141246783457722976">"Shto një pajisje"</string>
    <string name="wifi_dpp_center_qr_code" msgid="5270782275746178104">"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="3543923817779444434">"Skano kodin QR"</string>
    <string name="wifi_dpp_scan_qr_code_join_network" msgid="969985020363459133">"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="3180020429793614145">"Bashkoju rrjetit Wi-Fi duke skanuar një kod QR"</string>
    <string name="wifi_dpp_share_wifi" msgid="2431744447544057866">"Ndaj Wi‑Fi"</string>
    <string name="wifi_dpp_scan_qr_code_with_another_device" msgid="6967364080214325016">"Skano këtë kod QR me një pajisje tjetër për t\'u bashkuar me “<xliff:g id="SSID">%1$s</xliff:g>”"</string>
    <string name="wifi_dpp_scan_open_network_qr_code_with_another_device" msgid="5398619697898444311">"Skano këtë kod QR për t\'u lidhur me “<xliff:g id="SSID">%1$s</xliff:g>”"</string>
    <string name="wifi_dpp_failure_authentication_or_configuration" msgid="847551626830740204">"Provo sërish. Nëse problemi vazhdon, kontakto me prodhuesin e pajisjes"</string>
    <string name="wifi_dpp_failure_not_compatible" msgid="4453775826337805825">"Ndodhi një gabim"</string>
    <string name="wifi_dpp_failure_timeout" msgid="7902971341771145564">"Sigurohu që pajisja është në prizë, e karikuar dhe e ndezur"</string>
    <string name="wifi_dpp_failure_generic" msgid="6559442892600448442">"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="2908961523550486480">"Shtimi i “<xliff:g id="SSID">%1$s</xliff:g>” nuk mbështetet nga kjo pajisje"</string>
    <string name="wifi_dpp_failure_cannot_find_network" msgid="8519567801353014036">"Provo ta lëvizësh pajisjen më pranë pikës së qasjes Wi‑Fi/router-it"</string>
    <string name="wifi_dpp_failure_enrollee_authentication" msgid="7008840843663520852">"Kontrollo fjalëkalimin dhe provo përsëri"</string>
    <string name="wifi_dpp_failure_enrollee_rejected_configuration" msgid="982310033782652478">"Kontakto me prodhuesin e pajisjes"</string>
    <string name="wifi_dpp_check_connection_try_again" msgid="6118892932595974823">"Kontrollo lidhjen dhe provo përsëri"</string>
    <string name="wifi_dpp_choose_network" msgid="3987007684129341427">"Zgjidh rrjetin"</string>
    <string name="wifi_dpp_choose_network_to_connect_device" msgid="4321618376432197593">"Për të lidhur pajisjen, zgjidh një rrjet"</string>
    <string name="wifi_dpp_add_device_to_wifi" msgid="5170095438763569255">"Të shtohet kjo pajisje te “<xliff:g id="SSID">%1$s</xliff:g>”?"</string>
    <string name="wifi_dpp_wifi_shared_with_device" msgid="4484366631307204949">"Wi‑Fi është ndarë me këtë pajisje"</string>
    <string name="wifi_dpp_add_another_device" msgid="3307575293580739604">"Shto pajisje tjetër"</string>
    <string name="wifi_dpp_choose_different_network" msgid="8963625819804792157">"Zgjidh një rrjet tjetër"</string>
    <string name="wifi_dpp_could_not_add_device" msgid="6865710911186601933">"Pajisja nuk mund të shtohej"</string>
    <string name="wifi_dpp_device_found" msgid="633646744759830603">"U gjet pajisje"</string>
    <string name="wifi_dpp_sharing_wifi_with_this_device" msgid="7250369936882080107">"Po ndan Wi‑Fi me këtë pajisje…"</string>
    <string name="wifi_dpp_connecting" msgid="2312769193202897589">"Po lidhet…"</string>
    <string name="wifi_dpp_share_hotspot" msgid="6186452780604755316">"Ndaj zonën e qasjes për internet"</string>
    <string name="wifi_dpp_lockscreen_title" msgid="4231438175617953652">"Verifiko që je ti"</string>
    <string name="wifi_dpp_wifi_password" msgid="4992986319806934381">"Fjalëkalimi i Wi‑Fi: <xliff:g id="PASSWORD">%1$s</xliff:g>"</string>
    <string name="wifi_dpp_hotspot_password" msgid="688464342650820420">"Fjalëkalimi i zonës së qasjes për internet: <xliff:g id="PASSWORD">%1$s</xliff:g>"</string>
    <string name="wifi_auto_connect_title" msgid="1890342051674657892">"Lidh automatikisht"</string>
    <string name="wifi_auto_connect_summary" msgid="1707702705345670370">"Lejo lidhjen me këtë rrjet kur të jetë brenda rrezes"</string>
    <string name="wifi_dpp_add_device" msgid="8695656122114721335">"Shto pajisje"</string>
    <string name="wifi_dpp_connect_network_using_qr_code" msgid="6975258007798254937">"Përdor një kod QR për të shtuar një pajisje në këtë rrjet"</string>
    <string name="wifi_dpp_qr_code_is_not_valid_format" msgid="5190689503019328279">"Kodi QR nuk është në format të vlefshëm"</string>
    <string name="retry" msgid="7542103800274026915">"Riprovo"</string>
    <string name="wifi_shared" msgid="8850748923537589782">"Ndaje me përdoruesit e tjerë të pajisjes"</string>
    <string name="wifi_unchanged" msgid="8026045290856150191">"(i pandryshuar)"</string>
    <string name="wifi_unspecified" msgid="4561964943472312208">"Zgjidh"</string>
    <string name="wifi_multiple_cert_added" msgid="2151019652853383776">"(U shtuan shumë certifikata)"</string>
    <string name="wifi_use_system_certs" msgid="5587866698144996931">"Përdor certifikatat e sistemit"</string>
    <string name="wifi_do_not_provide_eap_user_cert" msgid="6336636553673065145">"Mos e ofro"</string>
    <string name="wifi_do_not_validate_eap_server" msgid="4673867078988209732">"Mos e mirato"</string>
    <string name="wifi_trust_on_first_use" msgid="7488431582505858774">"Beso që në përdorimin e parë"</string>
    <string name="wifi_ssid_too_long" msgid="5961719058705013875">"Emri i rrjetit është shumë i gjatë."</string>
    <string name="wifi_no_domain_warning" msgid="1452133316532366772">"Duhet të specifikohet një domen."</string>
    <string name="wifi_no_user_cert_warning" msgid="8466376918835248956">"Kërkohet certifikimi."</string>
    <string name="wifi_wps_available_first_item" msgid="5780501151792036589">"Ofrohet WPS"</string>
    <string name="wifi_wps_available_second_item" msgid="1717024103303480804">" (Ofrohet WPS)"</string>
    <string name="wifi_carrier_connect" msgid="4511538300946413213">"Rrjeti Wi-Fi i operatorit celular"</string>
    <string name="wifi_carrier_content" msgid="2876499905644083615">"E lidhur përmes <xliff:g id="NAME">%1$s</xliff:g>"</string>
    <string name="wifi_scan_always_turnon_message" msgid="2165909441512029921">"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="4903345360745717385">"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="93691286302680448">"Për ta çaktivizuar këtë, shko te \"Të përparuara\" në menynë e tejkalimit."</string>
    <string name="wifi_scan_always_confirm_allow" msgid="4154200627800959777">"Lejo"</string>
    <string name="wifi_scan_always_confirm_deny" msgid="6997087934558839256">"Refuzo"</string>
    <string name="wifi_hotspot_title" msgid="1918712370697971229">"Dëshiron të identifikohesh për t\'u lidhur?"</string>
    <string name="wifi_hotspot_message" msgid="5245614124614833169">"<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="1916314048788438331">"LIDHE"</string>
    <string name="no_internet_access_text" msgid="3611993143350310936">"Ky rrjet nuk ka qasje në internet. Dëshiron të qëndrosh i lidhur?"</string>
    <string name="partial_connectivity_text" msgid="8874614799723694554">"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="5113610157731269258">"Mos pyet përsëri për këtë rrjet"</string>
    <string name="lost_internet_access_title" msgid="9032463989950384698">"Wi-Fi nuk është i lidhur me internetin"</string>
    <string name="lost_internet_access_text" msgid="1535911323549496789">"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="7935665847081706202">"Kalo te rrjeti celular"</string>
    <string name="lost_internet_access_cancel" msgid="1981171269794585284">"Qëndro në Wi‑Fi"</string>
    <string name="lost_internet_access_persist" msgid="6813604557672782197">"Kurrë mos e trego përsëri"</string>
    <string name="wifi_connect" msgid="2481467560349907397">"Lidh"</string>
    <string name="wifi_turned_on_message" msgid="8069855406962662881">"Wi-Fi është i aktivizuar"</string>
    <string name="wifi_connected_to_message" msgid="8976048616505112896">"Lidhur me <xliff:g id="NETWORK_NAME">%1$s</xliff:g>"</string>
    <string name="wifi_connecting_to_message" msgid="3153205024060064551">"Po lidhet me <xliff:g id="NETWORK_NAME">%1$s</xliff:g>"</string>
    <string name="wifi_connecting" msgid="7450277833386859724">"Po lidhet…"</string>
    <string name="wifi_failed_connect_message" msgid="8538000546604347894">"Lidhja me rrjetin dështoi"</string>
    <string name="wifi_not_in_range_message" msgid="3885327464037574739">"Rrjeti nuk është brenda rrezes"</string>
    <string name="wifi_forget" msgid="3485573280364015620">"Harro"</string>
    <string name="wifi_modify" msgid="5127926476383659412">"Modifiko"</string>
    <string name="wifi_failed_forget_message" msgid="8272732599235525880">"Dështoi në harrimin e rrjetit"</string>
    <string name="wifi_save" msgid="2312643132472226807">"Ruaj"</string>
    <string name="wifi_failed_save_message" msgid="1830279872341387120">"Dështoi në ruajtjen e rrjetit"</string>
    <string name="wifi_cancel" msgid="6698897376888935410">"Anulo"</string>
    <string name="wifi_forget_dialog_title" msgid="4363829200968563164">"Dëshiron ta harrosh rrjetin?"</string>
    <string name="wifi_forget_dialog_message" msgid="8419499588321940243">"Të gjitha fjalëkalimet për këtë rrjet do të fshihen"</string>
    <plurals name="wifi_saved_access_points_summary" formatted="false" msgid="2802436466732147888">
      <item quantity="other">%d rrjete</item>
      <item quantity="one">1 rrjet</item>
    </plurals>
    <plurals name="wifi_saved_passpoint_access_points_summary" formatted="false" msgid="5802057518058840450">
      <item quantity="other">%d abonime</item>
      <item quantity="one">1 abonim</item>
    </plurals>
    <plurals name="wifi_saved_all_access_points_summary" formatted="false" msgid="5125849180309374451">
      <item quantity="other">%d rrjete dhe abonime</item>
      <item quantity="one">1 rrjet dhe abonim</item>
    </plurals>
    <string name="wifi_advanced_titlebar" msgid="1234150304285575798">"Cilësimet e Wi‑Fi"</string>
    <string name="wifi_advanced_ssid_title" msgid="1561437650193980185">"SSID"</string>
    <string name="wifi_advanced_device_mac_address_title" msgid="6155800851233164411">"Adresa MAC e pajisjes"</string>
    <string name="wifi_advanced_randomized_mac_address_title" msgid="3930671320234553088">"Adresa MAC e rastësishme"</string>
    <string name="wifi_advanced_randomized_mac_address_disconnected_title" msgid="2755843130417523727">"Adresa e rastësishme MAC (përdorur së fundi)"</string>
    <string name="wifi_advanced_ip_address_title" msgid="4265355419782184514">"Adresa e IP-së"</string>
    <string name="wifi_details_title" msgid="222735438574597493">"Detajet e rrjetit"</string>
    <string name="wifi_details_subnet_mask" msgid="1619151769276260512">"Maska e nënrrjetit"</string>
    <string name="wifi_type_title" msgid="2174893488722015838">"Lloji"</string>
    <string name="wifi_details_dns" msgid="273231528073312579">"DNS"</string>
    <string name="wifi_details_ipv6_address_header" msgid="1913151339341722443">"Adresat IPv6"</string>
    <string name="wifi_saved_access_points_label" msgid="5691340724310548151">"Rrjetet e ruajtura"</string>
    <string name="wifi_subscribed_access_points_tab" msgid="7224061396195667208">"Abonimet"</string>
    <string name="wifi_saved_other_networks_tab" msgid="7942647415716557293">"Rrjetet e tjera"</string>
    <string name="wifi_advanced_settings_label" msgid="5880605751602184383">"Cilësimet e IP-së"</string>
    <string name="wifi_advanced_not_available" msgid="8701003884367299092">"Cilësimet e Wi-Fi nuk disponohen për këtë përdorues"</string>
    <string name="wifi_ip_settings_menu_save" msgid="5190481040428567106">"Ruaj"</string>
    <string name="wifi_ip_settings_menu_cancel" msgid="1757817733064004598">"Anulo"</string>
    <string name="wifi_ip_settings_invalid_ip_address" msgid="3622891107865052307">"Shkruaj një adresë të vlefshme IP-je."</string>
    <string name="wifi_ip_settings_invalid_gateway" msgid="1174931247370931239">"Shkruaj një adresë të vlefshme porte kalimi."</string>
    <string name="wifi_ip_settings_invalid_dns" msgid="1757402215999845975">"Shkruaj një adresë të vlefshme DNS-je."</string>
    <string name="wifi_ip_settings_invalid_network_prefix_length" msgid="5980808986926987299">"Shkruaj një gjatësi prefiksi rrjeti mes 0 dhe 32."</string>
    <string name="wifi_dns1" msgid="6764769531843748514">"DNS 1 (përveçse nëse është anuluar nga DNS-ja private)"</string>
    <string name="wifi_dns2" msgid="7273133202625326148">"DNS 2 (përveçse nëse është anuluar nga DNS-ja private)"</string>
    <string name="wifi_gateway" msgid="3699227808616416759">"Porta e kalimit"</string>
    <string name="wifi_network_prefix_length" msgid="1003365439352276622">"Gjatësia e prefiksit të rrjetit"</string>
    <string name="wifi_p2p_settings_title" msgid="1689918226469221870">"Wi-Fi Direct"</string>
    <string name="wifi_p2p_device_info" msgid="4304362679971797283">"Informacioni i pajisjes"</string>
    <string name="wifi_p2p_persist_network" msgid="7942929491568227945">"Kujtoje këtë lidhje"</string>
    <string name="wifi_p2p_menu_search" msgid="8383306178784876840">"Kërko pajisje"</string>
    <string name="wifi_p2p_menu_searching" msgid="3428767661028761100">"Po kërkon..."</string>
    <string name="wifi_p2p_menu_rename" msgid="7059994112737743336">"Riemërto pajisjen"</string>
    <string name="wifi_p2p_peer_devices" msgid="5158559154640283546">"Pajisjet homologe"</string>
    <string name="wifi_p2p_remembered_groups" msgid="5497007770930525695">"Grupet r ruajtura në memorie"</string>
    <string name="wifi_p2p_failed_connect_message" msgid="6767831720507440027">"Nuk mund të lidhej."</string>
    <string name="wifi_p2p_failed_rename_message" msgid="1317434386267376606">"Riemërtimi i pajisjes dështoi."</string>
    <string name="wifi_p2p_disconnect_title" msgid="96361896458072463">"Të shkëputet?"</string>
    <string name="wifi_p2p_disconnect_message" msgid="1208761239498807208">"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="4490648217799144078">"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="8476985132989357041">"Të anulohet ftesa?"</string>
    <string name="wifi_p2p_cancel_connect_message" msgid="2409074184473879809">"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="4880242270742385699">"Të harrohet ky grup?"</string>
    <string name="wifi_hotspot_checkbox_text" msgid="1549663436920597006">"Zonë qasjeje për Wi-Fi"</string>
    <string name="wifi_hotspot_off_subtext" msgid="2751383134504362078">"Nuk po ndan internetin ose përmbajtje me pajisjet e tjera"</string>
    <string name="wifi_hotspot_tethering_on_subtext" product="tablet" msgid="5832429443898690152">"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="5451921191609178326">"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="965051079784031636">"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="3685689196772398783">"Nuk është caktuar fjalëkalim"</string>
    <string name="wifi_hotspot_name_title" msgid="6633480190014369846">"Emri i zonës së qasjes për internet"</string>
    <string name="wifi_hotspot_name_summary_connecting" msgid="2094754115215428892">"<xliff:g id="WIFI_HOTSPOT_NAME">%1$s</xliff:g> po aktivizohet…"</string>
    <string name="wifi_hotspot_name_summary_connected" msgid="6935457127884928249">"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="9096340919454296786">"Fjalëkalimi i zonës së qasjes për internet"</string>
    <string name="wifi_hotspot_ap_band_title" msgid="560262446129195042">"Banda AP"</string>
    <string name="wifi_hotspot_footer_info_regular" msgid="6620216295510397461">"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="3813311942370920903">"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="8855711787485504882">"Çaktivizo automatikisht zonën e qasjes për internet"</string>
    <string name="wifi_hotspot_auto_off_summary" msgid="8283656069997871354">"Kur nuk është lidhur asnjë pajisje"</string>
    <string name="wifi_hotspot_maximize_compatibility" msgid="6494125684420024058">"Zgjero përputhshmërinë"</string>
    <string name="wifi_hotspot_maximize_compatibility_single_ap_summary" msgid="383355687431591441">"I ndihmon pajisjet e tjera të gjejnë këtë zonë të qasjes për internet. Zvogëlon shpejtësinë e lidhjes të zonës së qasjes për internet"</string>
    <string name="wifi_hotspot_maximize_compatibility_dual_ap_summary" msgid="3579549223159056533">"I ndihmon pajisjet e tjera të gjejnë këtë zonë të qasjes për internet. Rrit përdorimin e baterisë."</string>
    <string name="wifi_tether_starting" msgid="8879874184033857814">"Po aktivizon zonën e qasjes..."</string>
    <string name="wifi_tether_stopping" msgid="4416492968019409188">"Po çaktivizon zonën e qasjes..."</string>
    <string name="wifi_tether_carrier_unsupport_dialog_title" msgid="3089432578433978073">"Ndarja e internetit nuk ofrohet"</string>
    <string name="wifi_tether_carrier_unsupport_dialog_content" msgid="5920421547607921112">"Kontakto me operatorin celular për detaje"</string>
    <string name="wifi_tether_enabled_subtext" msgid="5085002421099821056">"<xliff:g id="NETWORK_SSID">%1$s</xliff:g> është aktiv"</string>
    <string name="wifi_tether_failed_subtext" msgid="437190628041885500">"Gabim në zonën e lirë të qasjes Wi-Fi"</string>
    <string name="wifi_tether_configure_ap_text" msgid="7072559431286459122">"Konfiguro zonën e qasjes Wi‑Fi"</string>
    <string name="wifi_hotspot_configure_ap_text" msgid="9027072969831022321">"Konfigurimi i zonës së qasjes Wi‑Fi"</string>
    <string name="wifi_hotspot_configure_ap_text_summary" msgid="1445157424926935178">"Zona e qasjes e AndroidAP WPA2 PSK"</string>
    <string name="wifi_tether_configure_ssid_default" msgid="1709397571393179300">"Zona Android e qasjes së lirë për internet"</string>
    <string name="wifi_add_app_single_network_title" msgid="8911612806204065225">"Të ruhet ky rrjet?"</string>
    <string name="wifi_add_app_single_network_summary" product="default" msgid="6881712878537666626">"<xliff:g id="APPNAME">%1$s</xliff:g> dëshiron të ruajë një rrjet në telefonin tënd"</string>
    <string name="wifi_add_app_single_network_summary" product="tablet" msgid="8455616967601552440">"<xliff:g id="APPNAME">%1$s</xliff:g> dëshiron të ruajë një rrjet në tabletin tënd"</string>
    <string name="wifi_add_app_single_network_saving_summary" msgid="7366337245410388895">"Po ruan…"</string>
    <string name="wifi_add_app_single_network_saved_summary" msgid="7135016314713158289">"U ruajt"</string>
    <string name="wifi_add_app_network_save_failed_summary" msgid="7223817782309294652">"Nuk mund të ruhet. Provo sërish."</string>
    <string name="wifi_add_app_networks_title" msgid="4384594865433042851">"Do t\'i ruash rrjetet?"</string>
    <string name="wifi_add_app_networks_summary" product="default" msgid="2670215712788515167">"<xliff:g id="APPNAME">%1$s</xliff:g> dëshiron t\'i ruajë këto rrjete në telefonin tënd"</string>
    <string name="wifi_add_app_networks_summary" product="tablet" msgid="2088967184512169910">"<xliff:g id="APPNAME">%1$s</xliff:g> dëshiron t\'i ruajë këto rrjete në tabletin tënd"</string>
    <string name="wifi_add_app_networks_saving_summary" msgid="577680250954742033">"Po ruhen <xliff:g id="NUMBER">%d</xliff:g> rrjete…"</string>
    <string name="wifi_add_app_networks_saved_summary" msgid="1648417628665152905">"Rrjetet e ruajtura"</string>
    <string name="wifi_calling_settings_title" msgid="264665264535884440">"Telefonata me Wi-Fi"</string>
    <string name="wifi_calling_suggestion_title" msgid="4791435106729906727">"Zgjero telefonatat me Wi‑Fi"</string>
    <string name="wifi_calling_suggestion_summary" msgid="5413024679599742858">"Aktivizo telefonatat me Wi‑Fi për të zgjeruar mbulimin"</string>
    <string name="wifi_calling_mode_title" msgid="5145896168360825619">"Preferenca e telefonatës"</string>
    <string name="wifi_calling_mode_dialog_title" msgid="944146521898592440">"Preferenca për telefonatën"</string>
    <string name="wifi_calling_roaming_mode_title" msgid="7703305991991520773">"Preferenca e roaming-ut"</string>
    <!-- no translation found for wifi_calling_roaming_mode_summary (6061631305384464179) -->
    <skip />
    <string name="wifi_calling_roaming_mode_dialog_title" msgid="5382466713784067077">"Preferenca e roaming-ut"</string>
  <string-array name="wifi_calling_mode_choices_v2">
    <item msgid="6052353275413974742">"Wi-Fi"</item>
    <item msgid="8622872038388687383">"Celular"</item>
    <item msgid="3027927219952052398">"Vetëm Wi-Fi"</item>
  </string-array>
  <string-array name="wifi_calling_mode_choices_v2_without_wifi_only">
    <item msgid="588620799769664461">"Wi-Fi"</item>
    <item msgid="7566603075659706590">"Celular"</item>
  </string-array>
    <string name="wifi_calling_mode_wifi_preferred_summary" msgid="3240387177966098351">"Nëse Wi‑Fi nuk ofrohet, përdor rrjetin celular"</string>
    <string name="wifi_calling_mode_cellular_preferred_summary" msgid="3746914244902314059">"Nëse rrjeti celular nuk ofrohet, përdor Wi‑Fi"</string>
    <string name="wifi_calling_mode_wifi_only_summary" msgid="3155660680014892641">"Telefono nëpërmjet Wi-Fi. Nëse humb Wi‑Fi, telefonata do të mbyllet."</string>
    <string name="wifi_calling_off_explanation" msgid="6295526820826322895">"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="3487475808574416183"></string>
    <string name="emergency_address_title" msgid="8102786488994263815">"Adresa e urgjencës"</string>
    <string name="emergency_address_summary" msgid="3022628750270626473">"Përdoret si vendndodhja jote kur kryen një telefonatë urgjence me Wi‑Fi"</string>
    <string name="private_dns_help_message" msgid="851221502063782306"><annotation id="url">"Mëso më shumë"</annotation>" rreth funksioneve të \"DNS-së private\""</string>
    <string name="private_dns_mode_on" msgid="8878679071975375696">"Aktive"</string>
    <string name="wifi_calling_pref_managed_by_carrier" msgid="129524064888622179">"Cilësimi menaxhohet nga operatori celular"</string>
    <string name="wifi_calling_settings_activation_instructions" msgid="3936067355828542266">"Aktivizo \"Telefonatën me Wi-Fi\""</string>
    <string name="wifi_calling_turn_on" msgid="7687886259199428823">"Aktivizo \"Telefonatën me Wi-Fi\""</string>
    <string name="wifi_calling_not_supported" msgid="3303917737849393175">"\"Telefonata me Wi‑Fi\" nuk mbështetet për %1$s"</string>
    <string name="wifi_disconnected_from" msgid="5249576734324159708">"U shkëput nga <xliff:g id="SSID">%1$s</xliff:g>"</string>
    <string name="carrier" msgid="1755020806290963951">"Operatori celular"</string>
    <string name="display_settings_title" msgid="626835071804834218">"Paraqitja"</string>
    <string name="sound_settings" msgid="7622986039384531304">"Tingulli dhe dridhjet"</string>
    <string name="all_volume_title" msgid="6196367642878437513">"Volumet"</string>
    <string name="musicfx_title" msgid="5458574743312283473">"Efektet e muzikës"</string>
    <string name="ring_volume_title" msgid="4869034595079914541">"Volumi i ziles dhe njoftimeve"</string>
    <string name="vibrate_in_silent_title" msgid="5076579100685867363">"Dridhje kur është \"në heshtje\""</string>
    <string name="notification_sound_title" msgid="8747567935870133157">"Tingulli i parazgjedhur i njoftimit"</string>
    <string name="incoming_call_volume_title" msgid="8445408274513654261">"Toni i ziles"</string>
    <string name="notification_volume_title" msgid="328053763590888609">"Njoftimi"</string>
    <string name="checkbox_notification_same_as_incoming_call" msgid="1798481722572489141">"Përdor volumin e telefonatës hyrëse për njoftime"</string>
    <string name="home_work_profile_not_supported" msgid="2605589489324241338">"Profilet e punës nuk mbështeten"</string>
    <string name="notification_sound_dialog_title" msgid="7431891669251806266">"Tingulli i parazgjedhur i njoftimit"</string>
    <string name="media_volume_title" msgid="5209147840160985178">"Media"</string>
    <string name="media_volume_summary" msgid="4671324482655564873">"Cakto volumin për muzikë dhe video"</string>
    <string name="alarm_volume_title" msgid="706302621191735343">"Alarmi"</string>
    <string name="dock_settings_summary" msgid="8548721822219932359">"Cilësimet e audios për stacionin e bashkëngjitur"</string>
    <string name="dtmf_tone_enable_title" msgid="2241337296249130217">"Tonet e bllokut të tasteve"</string>
    <string name="sound_effects_enable_title" msgid="328569690466233866">"Tingujt e trokitjes"</string>
    <string name="lock_sounds_enable_title" msgid="804365014499259673">"Tingulli i kyçjes së ekranit"</string>
    <string name="audio_record_proc_title" msgid="486071779724181619">"Anulimi i zhurmës"</string>
    <string name="volume_media_description" msgid="2736061076584067204">"Muzikë, video, lojëra dhe media të tjera"</string>
    <string name="volume_ring_description" msgid="5423168446359881864">"Toni i ziles dhe njoftimet"</string>
    <string name="volume_notification_description" msgid="3241009629930030492">"Njoftimet"</string>
    <string name="volume_alarm_description" msgid="156563371961039376">"Alarmet"</string>
    <string name="volume_ring_mute" msgid="1445718401945149622">"Hiq tingullin e ziles dhe njoftimeve"</string>
    <string name="volume_media_mute" msgid="1881020121757820746">"Çaktivizo zërin për muzikën dhe \"mediat\" e tjera"</string>
    <string name="volume_notification_mute" msgid="2612197659377126312">"Vendosi në heshtje njoftimet"</string>
    <string name="volume_alarm_mute" msgid="3730895630530980760">"Çaktivizo zërin e alarmeve"</string>
    <string name="dock_settings" msgid="4654404127402812514">"lidh me stacionin"</string>
    <string name="dock_settings_title" msgid="1276956575555480214">"Cilësimet e stacionit"</string>
    <string name="dock_audio_settings_title" msgid="8294821925086965934">"Audio"</string>
    <string name="dock_audio_summary_desk" msgid="4158593887711452737">"Cilësimet për stacionin e lidhur të desktopit"</string>
    <string name="dock_audio_summary_car" msgid="292911654994476080">"Cilësimet për stacionin e lidhur të makinës"</string>
    <string name="dock_audio_summary_none" product="tablet" msgid="7758416095500202500">"Tableti nuk u stacionua"</string>
    <string name="dock_audio_summary_none" product="default" msgid="9056359991181743485">"Telefoni nuk u stacionua"</string>
    <string name="dock_audio_summary_unknown" msgid="5486086330763810318">"Cilësimet për stacionin e lidhur"</string>
    <string name="dock_not_found_title" msgid="4721157149003423417">"Stacioni nuk u gjet"</string>
    <string name="dock_not_found_text" product="tablet" msgid="9192097687086523411">"Duhet të futësh tabletin në stacion para se të konfigurosh audion e stacionit."</string>
    <string name="dock_not_found_text" product="default" msgid="2247163115146852069">"Duhet të vendosësh telefonin te stacioni para se të konfigurosh audion e stacionit."</string>
    <string name="dock_sounds_enable_title" msgid="2974614136344237932">"Tingulli i vendosjes në stacion"</string>
    <string name="dock_sounds_enable_summary_on" product="tablet" msgid="468592489565539336">"Lësho një tingull kur futet ose hiqet tableti nga stacioni"</string>
    <string name="dock_sounds_enable_summary_on" product="default" msgid="8121670617316301768">"Lësho një tingull kur futet ose hiqet telefoni nga stacioni"</string>
    <string name="dock_sounds_enable_summary_off" product="tablet" msgid="7833926726878567889">"Mos lësho asnjë tingull kur futet ose hiqet tableti nga stacioni"</string>
    <string name="dock_sounds_enable_summary_off" product="default" msgid="5560601997128422001">"Mos lësho asnjë tingull kur futet ose hiqet telefoni nga stacioni"</string>
    <string name="account_settings" msgid="255404935489127404">"Llogaritë"</string>
    <string name="accessibility_category_work" msgid="5133894487353964944">"Llogaritë e profilit të punës - <xliff:g id="MANAGED_BY">%s</xliff:g>"</string>
    <string name="accessibility_category_personal" msgid="2228088849803484780">"Llogaritë e profilit personal"</string>
    <string name="accessibility_work_account_title" msgid="7622485151217943839">"Llogari pune - <xliff:g id="MANAGED_BY">%s</xliff:g>"</string>
    <string name="accessibility_personal_account_title" msgid="8535265881509557013">"Llogari personale - <xliff:g id="MANAGED_BY">%s</xliff:g>"</string>
    <string name="search_settings" msgid="7573686516434589771">"Kërko"</string>
    <string name="display_settings" msgid="7197750639709493852">"Ekrani"</string>
    <string name="accelerometer_title" msgid="7745991950833748909">"Rrotullimi automatik i ekranit"</string>
    <string name="auto_rotate_option_off" msgid="2788096269396290731">"Joaktiv"</string>
    <string name="auto_rotate_option_on" msgid="5776678230808498171">"Aktiv"</string>
    <string name="auto_rotate_option_face_based" msgid="3438645484087953174">"Aktiv - Në bazë të fytyrave"</string>
    <string name="auto_rotate_switch_face_based" msgid="9116123744601564320">"Zbulimi i fytyrës"</string>
    <string name="auto_rotate_screen_summary" msgid="4547268203621754096">"Rregullo automatikisht orientimin e ekranit kur lëviz telefonin mes modalitetit të portretit dhe atij horizontal"</string>
    <string name="auto_rotate_link_a11y" msgid="5146188567212233286">"Mëso më shumë për rrotullimin automatik"</string>
    <string name="auto_rotate_summary_a11y" msgid="1505094100328581685">"Kur lëviz telefonin mes modalitetit \"portret\" e \"horizontal\""</string>
    <string name="screen_resolution_title" msgid="2690518693139811486">"Rezolucioni i ekranit"</string>
    <string name="screen_resolution_option_high" msgid="2617496842852992853">"Rezolucion i lartë"</string>
    <string name="screen_resolution_option_highest" msgid="7892101083236381555">"Rezolucioni më i lartë"</string>
    <string name="screen_resolution_summary_high" msgid="5611896959631297437">"1080p FHD+"</string>
    <string name="screen_resolution_summary_highest" msgid="2609112310453953756">"1440p QHD+"</string>
    <string name="screen_resolution_footer" msgid="2563830074752340045">"Ndërrimi i rezolucionit mund të shkaktojë mbylljen e disa aplikacioneve që po ekzekutohen aktualisht."</string>
    <string name="color_mode_title" msgid="8666690832113906028">"Ngjyrat"</string>
    <string name="color_mode_option_natural" msgid="6192875655101283303">"Natyrale"</string>
    <string name="color_mode_option_boosted" msgid="4698797857766774289">"Të theksuara"</string>
    <string name="color_mode_option_saturated" msgid="3413853820158447300">"E gjallë"</string>
    <string name="color_mode_option_automatic" msgid="2281217686509980870">"Me përshtatje"</string>
    <string name="color_mode_summary_natural" msgid="8298840714001791628">"Përdor vetëm ngjyrat e sakta"</string>
    <string name="color_mode_summary_automatic" msgid="8157885594041700275">"Rregullo mes ngjyrave të gjalla dhe të sakta"</string>
    <string name="accelerometer_summary_on" product="tablet" msgid="6413384391658481700">"Ndërro orientimin automatikisht kur rrotullon tabletin"</string>
    <string name="accelerometer_summary_on" product="default" msgid="7117139542131700779">"Ndrysho automatikisht orientimin kur rrotullon telefonin"</string>
    <string name="accelerometer_summary_off" product="tablet" msgid="3747370091309939684">"Ndërro orientimin automatikisht kur rrotullon tabletin"</string>
    <string name="accelerometer_summary_off" product="default" msgid="4451125241783158763">"Ndrysho orientimin automatik kur rrotullon telefonin"</string>
    <string name="brightness" msgid="6216871641021779698">"Niveli i ndriçimit"</string>
    <string name="brightness_title" msgid="5457874893085305155">"Ndriçimi"</string>
    <string name="brightness_summary" msgid="6309641759293018049">"Rregullo ndriçimin e ekranit"</string>
    <string name="auto_brightness_title" msgid="4239324728760986697">"Ndriçimi i përshtatshëm"</string>
    <string name="auto_brightness_summary" msgid="1737148869232725883">"Ndriçimi i ekranit përshtatet me ambientin"</string>
    <string name="auto_brightness_summary_on" msgid="2748088951224387004">"Aktiv"</string>
    <string name="auto_brightness_summary_off" msgid="8077066192887677956">"Joaktiv"</string>
    <string name="auto_brightness_summary_very_low" msgid="2705445901659224330">"Ndriçimi i preferuar është shumë i ulët"</string>
    <string name="auto_brightness_summary_low" msgid="1606100911112851291">"Ndriçimi i preferuar është i ulët"</string>
    <string name="auto_brightness_summary_default" msgid="9038441148247815684">"Ndriçimi i preferuar është i parazgjedhur"</string>
    <string name="auto_brightness_summary_high" msgid="2886260311484349010">"Ndriçimi i preferuar është i lartë"</string>
    <string name="auto_brightness_summary_very_high" msgid="8294814315426024005">"Ndriçimi i preferuar është shumë i lartë"</string>
    <string name="auto_brightness_off_title" msgid="5156056957376839677">"Joaktiv"</string>
    <string name="auto_brightness_very_low_title" msgid="618973599332847430">"Shumë i ulët"</string>
    <string name="auto_brightness_low_title" msgid="4243763334776382492">"I ulët"</string>
    <string name="auto_brightness_default_title" msgid="1776584786251120907">"I parazgjedhur"</string>
    <string name="auto_brightness_high_title" msgid="6472704542949390468">"I lartë"</string>
    <string name="auto_brightness_very_high_title" msgid="4935132626750630713">"Shumë i lartë"</string>
    <string name="auto_brightness_subtitle" msgid="6839449395639517870">"Niveli yt i preferuar i ndriçimit"</string>
    <string name="auto_brightness_off_summary" msgid="4993150980274474226">"Mos e rregullo sipas dritës së ambientit"</string>
    <string name="auto_brightness_very_high_summary" msgid="2784981315548144255">"Përdorimi i rritur i baterisë"</string>
    <string name="auto_brightness_disclaimer" msgid="1868395832774087351">"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="6807117118142381193">"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 e përshtatshëm që të mësojë preferencat e tua."</string>
    <string name="display_white_balance_title" msgid="2624544323029364713">"Shfaq balancimin e të bardhës"</string>
    <string name="display_white_balance_summary" msgid="7625456704950209050"></string>
    <string name="peak_refresh_rate_title" msgid="1878771412897140903">"Smooth Display"</string>
    <string name="peak_refresh_rate_summary" msgid="1527087897198455042">"Rrit automatikisht shpejtësinë e rifreskimit nga 60 në 90 Hz për disa përmbajtje. Rrit përdorimin e baterisë."</string>
    <string name="force_high_refresh_rate_toggle" msgid="3325789621928312050">"Detyro shpejtësinë maksimale të rifreskimit"</string>
    <string name="force_high_refresh_rate_desc" msgid="7794566420873814875">"Shpejtësia më e lartë e rifreskimit për përmirësimin e reagueshmërisë së prekjes dhe cilësisë së animacioneve. Rrit përdorimin e baterisë."</string>
    <string name="adaptive_sleep_title" msgid="2987961991423539233">"Vëmendja ndaj ekranit"</string>
    <string name="adaptive_sleep_summary_on" msgid="313187971631243800">"Aktiv / Ekrani nuk do të fiket nëse shikon tek ai"</string>
    <string name="adaptive_sleep_summary_off" msgid="5272156339202897523">"Joaktiv"</string>
    <string name="adaptive_sleep_title_no_permission" msgid="1719759921214237016">"Nevojitet qasja te kamera"</string>
    <string name="adaptive_sleep_summary_no_permission" msgid="5822591289468803691">"Kërkohet qasja në kamerë për vëmendjen e ekranit. Trokit për të menaxhuar autorizimet për \"Shërbimet e personalizimit të pajisjes\""</string>
    <string name="adaptive_sleep_manage_permission_button" msgid="1404510197847664846">"Menaxho autorizimet"</string>
    <string name="adaptive_sleep_description" msgid="1835321775327187860">"Parandalon fikjen e ekranit nëse shikon tek ai"</string>
    <string name="adaptive_sleep_privacy" msgid="7664570136417980556">"\"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 ruhen apo dërgohen asnjëherë te Google."</string>
    <string name="adaptive_sleep_contextual_slice_title" msgid="7467588613212629758">"Aktivizo vëmendjen ndaj ekranit"</string>
    <string name="adaptive_sleep_contextual_slice_summary" msgid="2993867044745446094">"Mbaje ekranin aktiv kur e shikon"</string>
    <string name="auto_rotate_camera_lock_title" msgid="5369003176695105872">"Kamera është e kyçur"</string>
    <string name="auto_rotate_camera_lock_summary" msgid="5699491516271544672">"Kamera duhet të jetë e shkyçur për \"Zbulimin e fytyrës\""</string>
    <string name="adaptive_sleep_camera_lock_summary" msgid="8417541183603618098">"Kamera duhet të jetë e shkyçur për \"Vëmendjen ndaj ekranit\""</string>
    <string name="auto_rotate_summary_no_permission" msgid="1025061139746254554">"Kërkohet qasja te \"Kamera\" për \"Zbulimin e fytyrës\". Trokit për të menaxhuar lejet për \"Shërbimet e personalizimit të pajisjes\""</string>
    <string name="auto_rotate_manage_permission_button" msgid="2591146085906382385">"Menaxho lejet"</string>
    <string name="night_display_title" msgid="8532432776487216581">"Drita e natës"</string>
    <string name="night_display_text" msgid="4789324042428095383">"\"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="5869128421470824381">"Planifikimi"</string>
    <string name="night_display_auto_mode_never" msgid="2721729920187175239">"Asnjë"</string>
    <string name="night_display_auto_mode_custom" msgid="3938791496034086916">"Aktivizohet në kohë të personalizuar"</string>
    <string name="night_display_auto_mode_twilight" msgid="4291855156158833997">"Aktivizohet nga perëndimi deri në agim"</string>
    <string name="night_display_start_time_title" msgid="2611541851596977786">"Koha e nisjes"</string>
    <string name="night_display_end_time_title" msgid="5243112480391192111">"Koha e përfundimit"</string>
    <string name="night_display_status_title" msgid="9006282950657941820">"Statusi"</string>
    <string name="night_display_temperature_title" msgid="857248782470764263">"Intensiteti"</string>
    <string name="night_display_summary_off_auto_mode_never" msgid="7406899634169354142">"Nuk do të aktivizohet asnjëherë automatikisht"</string>
    <string name="night_display_summary_off_auto_mode_custom" msgid="6667008039080687931">"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="3669132200611324994">"Do të aktivizohet automatikisht kur të perëndojë dielli"</string>
    <string name="night_display_summary_on_auto_mode_never" msgid="832333009202889350">"Nuk do të çaktivizohet asnjëherë automatikisht"</string>
    <string name="night_display_summary_on_auto_mode_custom" msgid="2096677025343425755">"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="8070517472000680361">"Do të çaktivizohet automatikisht në agim"</string>
    <string name="night_display_activation_on_manual" msgid="7999294858026069365">"Aktivizo tani"</string>
    <string name="night_display_activation_off_manual" msgid="4842907786868153218">"Çaktivizo tani"</string>
    <string name="night_display_activation_on_twilight" msgid="3440889451767582067">"Aktivizo deri në lindjen e diellit"</string>
    <string name="night_display_activation_off_twilight" msgid="2853594955401726956">"Çaktivizo deri në perëndim të diellit"</string>
    <string name="night_display_activation_on_custom" msgid="4951143503599226846">"Çaktivizo deri në <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="night_display_activation_off_custom" msgid="79965738861100371">"Çaktivizo deri në <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="night_display_not_currently_on" msgid="6600205753103093827">"\"Drita e natës\" aktualisht nuk është aktive"</string>
    <string name="twilight_mode_location_off_dialog_message" msgid="4559150893687124801">"Vendndodhja e pajisjes nevojitet për të përcaktuar kohën e perëndimit dhe agimit të diellit."</string>
    <string name="twilight_mode_launch_location" msgid="7799112373591153956">"Cilësimet e vendndodhjes"</string>
    <string name="dark_ui_activation_on_manual" msgid="1541006734577325234">"Aktivizo tani"</string>
    <string name="dark_ui_activation_off_manual" msgid="2395333709291250065">"Çaktivizo tani"</string>
    <string name="dark_ui_activation_on_auto" msgid="4824339634784765049">"Aktivizo deri në lindjen e diellit"</string>
    <string name="dark_ui_activation_off_auto" msgid="9136717444658505208">"Çaktivizo deri në perëndim të diellit"</string>
    <string name="dark_ui_title" msgid="3373976268671557416">"Modaliteti i errët"</string>
    <string name="dark_ui_auto_mode_title" msgid="9027528859262295099">"Orari"</string>
    <string name="dark_ui_auto_mode_never" msgid="3980412582267787662">"Asnjë"</string>
    <string name="dark_ui_auto_mode_auto" msgid="6658909029498623375">"Aktivizohet nga perëndimi deri në agim"</string>
    <string name="dark_ui_auto_mode_custom" msgid="3800138185265182170">"Aktivizohet në kohë të personalizuar"</string>
    <string name="dark_ui_auto_mode_custom_bedtime" msgid="8465023741946439266">"Aktivizohet në orarin e gjumit"</string>
    <string name="dark_ui_status_title" msgid="3505119141437774329">"Statusi"</string>
    <string name="dark_ui_summary_off_auto_mode_never" msgid="5828281549475697398">"Nuk do të aktivizohet asnjëherë automatikisht"</string>
    <string name="dark_ui_summary_off_auto_mode_auto" msgid="6766831395970887213">"Do të aktivizohet automatikisht kur të perëndojë dielli"</string>
    <string name="dark_ui_summary_off_auto_mode_custom" msgid="1345906088326708376">"Do të aktivizohet automatikisht në <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="dark_ui_summary_off_auto_mode_custom_bedtime" msgid="7759826673214624622">"Do të aktivizohet automatikisht në orarin e gjumit"</string>
    <string name="dark_ui_summary_on_auto_mode_never" msgid="2468597062391435521">"Nuk do të çaktivizohet asnjëherë automatikisht"</string>
    <string name="dark_ui_summary_on_auto_mode_auto" msgid="5553376115092648636">"Do të çaktivizohet automatikisht në agim"</string>
    <string name="dark_ui_summary_on_auto_mode_custom" msgid="2526935680241734784">"Do të çaktivizohet automatikisht në <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="dark_ui_summary_on_auto_mode_custom_bedtime" msgid="1976993025762551246">"Do të çaktivizohet automatikisht pas orarit të gjumit"</string>
    <string name="dark_ui_activation_on_custom" msgid="1889379402860316125">"Çaktivizo deri në <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="dark_ui_activation_off_custom" msgid="2192932161592759607">"Çaktivizo deri në <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="dark_ui_text" msgid="4392646155331126666">"\"Tema e errët\" përdor një sfond të zi për të ndihmuar në mbajtjen e baterisë të karikuar për një kohë më të gjatë në disa ekrane. Oraret e \"Temës së errët\" nuk aktivizohen përpara se ekrani të jetë fikur."</string>
    <string name="dark_ui_bedtime_footer_summary" msgid="5576501833145170581">"Aktualisht, tema e errët po ndjek orarin e modalitetit të \"Orarit të gjumit\""</string>
    <string name="dark_ui_bedtime_footer_action" msgid="1493095487994054339">"Cilësimet e modalitetit të \"Orarit të gjumit\""</string>
    <string name="screen_timeout" msgid="7709947617767439410">"Koha e pritjes së ekranit"</string>
    <string name="screen_timeout_title" msgid="785134393520893049">"Ekrani çaktivizohet"</string>
    <string name="screen_timeout_summary" msgid="5558778019594643427">"Pas <xliff:g id="TIMEOUT_DESCRIPTION">%1$s</xliff:g> pa aktivitet"</string>
    <string name="wallpaper_settings_title" msgid="5635129851136006383">"Imazhi i sfondit"</string>
    <string name="style_and_wallpaper_settings_title" msgid="2232042809407308946">"Imazhi i sfondit dhe stili"</string>
    <string name="wallpaper_dashboard_summary" msgid="2324472863981057118">"Baza, ekrani i kyçjes"</string>
    <string name="wallpaper_settings_summary_default" msgid="7569803705735001813">"I parazgjedhur"</string>
    <string name="wallpaper_settings_summary_custom" msgid="3174561317688848729">"I personalizuar"</string>
    <string name="wallpaper_suggestion_title" msgid="3812842717939877330">"Ndrysho imazhin e sfondit"</string>
    <string name="wallpaper_suggestion_summary" msgid="9077061486716754784">"Personalizo ekranin"</string>
    <string name="wallpaper_settings_fragment_title" msgid="8445963841717633149">"Zgjidh imazhin e sfondit nga"</string>
    <string name="style_suggestion_title" msgid="1213747484782364775">"Personalizo telefonin"</string>
    <string name="style_suggestion_summary" msgid="4271131877800968159">"Provo stile, imazhe sfondi të ndryshme etj."</string>
    <string name="screensaver_settings_title" msgid="3588535639672365395">"Mbrojtësi i ekranit"</string>
    <string name="screensaver_settings_toggle_title" msgid="6194634226897244374">"Përdor mbrojtësin e ekranit"</string>
    <string name="screensaver_settings_summary_either_long" msgid="371949139331896271">"Gjatë karikimit ose lidhjes me stacionin"</string>
    <string name="screensaver_settings_summary_either_short" msgid="2126139984738506920">"Në të dyja rastet"</string>
    <string name="screensaver_settings_summary_sleep" msgid="6555922932643037432">"Gjatë karikimit"</string>
    <string name="screensaver_settings_summary_dock" msgid="6997766385189369733">"Kur vendoset në stacion"</string>
    <string name="screensaver_settings_summary_never" msgid="4988141393040918450">"Asnjëherë"</string>
    <string name="screensaver_settings_summary_off" msgid="8720357504939106923">"Çaktivizuar"</string>
    <string name="screensaver_settings_disabled_prompt" msgid="1166343194760238835">"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="8145025742428940520">"Kur të fillojë"</string>
    <string name="screensaver_settings_current" msgid="390472865895976891">"Mbrojtësi aktual i ekranit"</string>
    <string name="screensaver_settings_button" msgid="6159236558934930238">"Cilësimet"</string>
    <string name="automatic_brightness" msgid="4599827881929079513">"Ndriçimi automatik"</string>
    <string name="lift_to_wake_title" msgid="8994218158737714046">"Ngrije për ta zgjuar"</string>
    <string name="ambient_display_screen_title" msgid="8615947016991429325">"Shfaqja e ambientit"</string>
    <string name="ambient_display_category_triggers" msgid="1216640141609270011">"Kur të shfaqet"</string>
    <string name="doze_title" msgid="1523090408230862316">"Zgjo ekranin për njoftimet"</string>
    <string name="doze_summary" msgid="8252867381522942804">"Kur ekrani është i errët, ai aktivizohet për njoftimet e reja"</string>
    <string name="doze_always_on_title" msgid="7326245192352868477">"Shfaq gjithmonë orën dhe info."</string>
    <string name="doze_always_on_summary" msgid="509097829739647852">"Përdorimi i rritur i baterisë"</string>
    <string name="force_bold_text" msgid="4620929631102086716">"Tekst i trashë"</string>
    <string name="title_font_size" msgid="570613010306330622">"Madhësia e shkrimit"</string>
    <string name="short_summary_font_size" msgid="8444689613442419978">"Zmadho ose zvogëlo tekstin"</string>
    <string name="sim_lock_settings" msgid="4493069398250139205">"Kyçja e kartës SIM"</string>
    <string name="sim_lock_settings_category" msgid="4280307997492851625">"Kyçja e kartës SIM"</string>
    <string name="sim_lock_settings_summary_off" msgid="4570941250786847095">"Joaktive"</string>
    <string name="sim_lock_settings_summary_on" msgid="1562184566830887925">"Kyçur"</string>
    <string name="sim_lock_settings_title" msgid="1401619059761012696">"Kyçja e kartës SIM"</string>
    <string name="sim_pin_toggle" msgid="98754920202404425">"Kyçe kartën SIM"</string>
    <string name="sim_lock_on" product="tablet" msgid="5857965768682972363">"Kërko kodin PIN për të përdorur tabletin"</string>
    <string name="sim_lock_on" product="default" msgid="3303147192981388923">"Kërko kod PIN për të përdorur telefonin"</string>
    <string name="sim_lock_off" product="tablet" msgid="7188936582548721225">"Kërko kodin PIN për të përdorur tabletin"</string>
    <string name="sim_lock_off" product="default" msgid="4634118006847137785">"Kërko kod PIN për të përdorur telefonin"</string>
    <string name="sim_pin_change" msgid="5978881209990507379">"Ndrysho PIN-in e kartës SIM"</string>
    <string name="sim_enter_pin" msgid="8235202785516053253">"PIN-i i kartës SIM"</string>
    <string name="sim_enable_sim_lock" msgid="8993991669975548653">"Kyçe kartën SIM"</string>
    <string name="sim_disable_sim_lock" msgid="7656447857474746157">"Shkyçe kartën SIM"</string>
    <string name="sim_enter_old" msgid="6882545610939674813">"Kodi i vjetër PIN i kartës SIM"</string>
    <string name="sim_enter_new" msgid="9010947802784561582">"PIN-i i ri i kartës SIM"</string>
    <string name="sim_reenter_new" msgid="6131418271490374263">"Shkruaj përsëri kodin e ri PIN"</string>
    <string name="sim_change_pin" msgid="1104103818545005448">"Kodi PIN i kartës SIM"</string>
    <string name="sim_bad_pin" msgid="5416328363761048221">"Kodi PIN është i pasaktë"</string>
    <string name="sim_pins_dont_match" msgid="1540348773896609260">"Kodet PIN nuk përputhen"</string>
    <string name="sim_change_failed" msgid="316723087029061740">"Kodi PIN nuk ndryshoi.\nKod PIN i gabuar."</string>
    <string name="sim_change_succeeded" msgid="3516905528149069739">"PIN-i i kartës SIM u ndryshua me sukses."</string>
    <string name="sim_lock_failed" msgid="16360418201678317">"Karta SIM ende e kyçur.\nKod PIN i gabuar."</string>
    <string name="sim_pin_disable_failed" msgid="8719890393181032837">"Kodi PIN nuk mund të çaktivizohet."</string>
    <string name="sim_pin_enable_failed" msgid="5156513975085380284">"Kodi PIN nuk mund të aktivizohet."</string>
    <string name="sim_enter_ok" msgid="3401715290135787531">"Në rregull"</string>
    <string name="sim_enter_cancel" msgid="2001859323724961490">"Anulo"</string>
    <string name="sim_multi_sims_title" msgid="4875083890014013296">"U gjetën shumë karta SIM"</string>
    <string name="sim_multi_sims_summary" msgid="1711012455679332238">"Zgjidh kartën SIM që preferon për të dhënat celulare."</string>
    <string name="sim_change_data_title" msgid="4663239438584588847">"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="3046178883369645132">"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="4922114750417276560">"Përdor <xliff:g id="CARRIER">%1$s</xliff:g>"</string>
    <string name="sim_preferred_title" msgid="7182406911552216373">"Të përditësohet karta e preferuar SIM?"</string>
    <string name="sim_preferred_message" msgid="6004009449266648351">"<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="3414172752791445033">"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="4054088588731305475">
      <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="wrong_pin_code_one" msgid="6924852214263071441">"Kodi PIN i kartës SIM është i pasaktë. Të ka mbetur edhe 1 tentativë para se të të duhet të kontaktosh me operatorin tënd celular për ta shkyçur pajisjen."</string>
    <string name="pin_failed" msgid="3726505565797352255">"Operac. kodit PIN të kartës SIM dështoi!"</string>
    <string name="system_update_settings_list_item_title" msgid="3398346836439366350">"Përditësimet e sistemit"</string>
    <string name="system_update_settings_list_item_summary" msgid="6703752298349642101"></string>
    <string name="firmware_version" msgid="1606901586501447275">"Versioni i Android"</string>
    <string name="security_patch" msgid="4071756145347865382">"Përditësim sigurie për Android"</string>
    <string name="model_info" msgid="8997566254717810904">"Modeli"</string>
    <string name="hardware_revision" msgid="3454709180861965025">"Versioni i harduerit"</string>
    <string name="fcc_equipment_id" msgid="6596668314025646129">"ID-ja e pajsjes"</string>
    <string name="baseband_version" msgid="2600182227599835857">"Versioni i brezit të bazës"</string>
    <string name="kernel_version" msgid="3513538109381366881">"Versioni i bërthamës"</string>
    <string name="build_number" msgid="9009733242117579826">"Numri i ndërtimit"</string>
    <string name="module_version" msgid="1787518340082046658">"Përditësimi i sistemit të Google Play"</string>
    <string name="device_info_not_available" msgid="4804474466616712326">"Nuk ofrohet"</string>
    <string name="device_status_activity_title" msgid="1812666241137263882">"Statusi"</string>
    <string name="device_status" msgid="7988547478034984649">"Statusi"</string>
    <string name="device_status_summary" product="tablet" msgid="8826216824111648900">"Statusi i baterisë, rrjeti dhe informacione të tjera"</string>
    <string name="device_status_summary" product="default" msgid="8132661857066128832">"Numri i telefonit, sinjali etj."</string>
    <string name="storage_settings" msgid="7472188817781592677">"Hapësira ruajtëse"</string>
    <string name="storage_settings_for_app" msgid="229425418984637483">"Hapësira ruajtëse dhe memoria specifike"</string>
    <string name="storage_usb_settings" msgid="7058142934214211583">"Hapësira ruajtëse"</string>
    <string name="storage_settings_title" msgid="486118156723194815">"Cilësimet e hapësirës ruajtëse"</string>
    <string name="storage_settings_summary" product="nosdcard" msgid="3858049818577638926">"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="267557695753980969">"Shkëput kartën SD. Shiko hapësirën e lirë për ruajtje."</string>
    <string name="imei_multi_sim" msgid="71477088017585479">"IMEI (foleja %1$d e kartës SIM)"</string>
    <string name="view_saved_network" msgid="1232387673095080910">"Për ta shfaqur, zgjidh rrjetin e ruajtur"</string>
    <string name="status_number" product="tablet" msgid="3597945414666253183">"MDN"</string>
    <string name="status_number" product="default" msgid="8407999629121682207">"Numri i telefonit"</string>
    <string name="status_number_sim_slot" product="tablet" msgid="6582203988975619529">"MDN (foleja %1$d e kartës SIM)"</string>
    <string name="status_number_sim_slot" product="default" msgid="5724823197745786398">"Numri i telefonit (foleja %1$d e SIM)"</string>
    <string name="status_number_sim_status" product="tablet" msgid="4239876366511743428">"MDN në kartën SIM"</string>
    <string name="status_number_sim_status" product="default" msgid="2772745542921910086">"Numri i telefonit në kartën SIM"</string>
    <string name="status_min_number" msgid="4492899165438225714">"MINUTA"</string>
    <string name="status_msid_number" msgid="3871958248824595774">"MSID"</string>
    <string name="status_prl_version" msgid="9002131357502714281">"Versioni PRL"</string>
    <string name="meid_multi_sim" msgid="7645394486193991388">"MEID (foleja %1$d e kartës SIM)"</string>
    <string name="scanning_status_text_on" msgid="3846571210578042940">"Aktiv"</string>
    <string name="scanning_status_text_off" msgid="4002352668313705132">"Joaktiv"</string>
    <string name="scanning_status_text_wifi_on_ble_on" msgid="7644609329607744714">"Skanimi i Wi‑Fi dhe Bluetooth-it janë të dy aktivë"</string>
    <string name="scanning_status_text_wifi_on_ble_off" msgid="7215007787287418186">"Skanimi i Wi‑Fi është aktiv, skanimi i Bluetooth-it është joaktiv"</string>
    <string name="scanning_status_text_wifi_off_ble_on" msgid="1396882599556304165">"Skanimi i Bluetooth-it është aktiv, skanimi i Wi-Fi është joaktiv"</string>
    <string name="scanning_status_text_wifi_off_ble_off" msgid="7670694707427030537">"Skanimi i Wi‑Fi dhe Bluetooth-it janë të dy joaktivë"</string>
    <string name="status_meid_number" msgid="6040380838489162650">"MEID"</string>
    <string name="status_icc_id" msgid="7995690631650006970">"ICCID"</string>
    <string name="status_data_network_type" msgid="3689772955330665876">"Lloji i rrjetit të të dhënave celulare"</string>
    <string name="status_voice_network_type" msgid="8700356693062562884">"Lloji i rrjetit zanor celular"</string>
    <string name="status_latest_area_info" msgid="8288488664620741734">"Informacioni i operatorit"</string>
    <string name="status_data_state" msgid="525196229491743487">"Gjendja e rrjetit celular"</string>
    <string name="status_esim_id" msgid="5158916796362809133">"EID"</string>
    <string name="status_service_state" msgid="1693424422121058791">"Gjendja e shërbimit"</string>
    <string name="status_signal_strength" msgid="7644525712554444359">"Fuqia e sinjalit"</string>
    <string name="status_roaming" msgid="1253597174715663778">"Roaming"</string>
    <string name="status_operator" msgid="4335640583552058491">"Rrjeti"</string>
    <string name="status_wifi_mac_address" msgid="4447611754614388914">"Adresa MAC e Wi‑Fi"</string>
    <string name="status_device_wifi_mac_address" msgid="1896121694334176494">"Adresa MAC e Wi‑Fi të pajisjes"</string>
    <string name="status_bt_address" msgid="6919660304578476547">"Adresa e Bluetooth-it"</string>
    <string name="status_serial_number" msgid="9060064164331466789">"Numri i serisë"</string>
    <string name="status_up_time" msgid="1274778533719495438">"Koha aktive"</string>
    <string name="status_awake_time" msgid="2573925324168081586">"Koha e zgjimit"</string>
    <string name="internal_memory" msgid="1869518160077033848">"Hapësira e brendshme për ruajtje"</string>
    <string name="sd_memory" product="nosdcard" msgid="5456718463397723781">"Hapësira për ruajtje e USB-së"</string>
    <string name="sd_memory" product="default" msgid="3098344183202722455">"Karta SD"</string>
    <string name="memory_available" msgid="712528795743654737">"E lirë"</string>
    <string name="memory_available_read_only" msgid="3201969221573511590">"E gatshme (vetëm për lexim)"</string>
    <string name="memory_size" msgid="2710897518522931469">"Hapësira totale"</string>
    <string name="memory_calculating_size" msgid="3898240439798661242">"Po llogarit…"</string>
    <string name="memory_apps_usage" msgid="8818570780540532952">"Apl. dhe të dhënat e tyre"</string>
    <string name="memory_media_usage" msgid="5161308657995646963">"Media"</string>
    <string name="memory_downloads_usage" msgid="8252462247720191179">"Shkarkimet"</string>
    <string name="memory_dcim_usage" msgid="3568913845973164352">"Fotografitë, videot"</string>
    <string name="memory_music_usage" msgid="8100634000114206429">"Audio (muzikë, zile etj.)"</string>
    <string name="memory_media_misc_usage" msgid="7066851245178533269">"Skedarë të tjerë"</string>
    <string name="memory_media_cache_usage" msgid="780808666853685824">"Të dhënat e memories specifike"</string>
    <string name="sd_eject" product="nosdcard" msgid="6136102589751843304">"Shkëput hapësirën ruajtëse të ndarë"</string>
    <string name="sd_eject" product="default" msgid="8062832622096296251">"Shkëput kartën SD"</string>
    <string name="sd_eject_summary" product="nosdcard" msgid="6859940774161708871">"Çmonto hapësirën ruajtëse të brendshme të USB-së"</string>
    <string name="sd_eject_summary" product="default" msgid="5151243312587186226">"Çmontoje kartën SD që ta heqësh në mënyrë të sigurt"</string>
    <string name="sd_insert_summary" product="nosdcard" msgid="9164545135649775664">"Fut USB-në për lidhje"</string>
    <string name="sd_insert_summary" product="default" msgid="5949168259622002192">"Vendos një kartë SD për lidhje"</string>
    <string name="sd_mount" product="nosdcard" msgid="8305985249945415150">"Lidh hapësirën për ruajtje të USB-së"</string>
    <string name="sd_mount" product="default" msgid="5279813999455776169">"Lidh kartën SD"</string>
    <string name="sd_mount_summary" product="nosdcard" msgid="2190410240845521205"></string>
    <string name="sd_mount_summary" product="default" msgid="2190410240845521205"></string>
    <string name="sd_format" product="nosdcard" msgid="8657427883364711513">"Spastro hapësirën USB"</string>
    <string name="sd_format" product="default" msgid="9085302892248732329">"Spastro kartën SD"</string>
    <string name="sd_format_summary" product="nosdcard" msgid="6179784504937189658">"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="60583152211068164">"Spastro të gjitha të dhënat në kartën SD, si muzikën dhe fotografitë"</string>
    <string name="mtp_ptp_mode_summary" msgid="7969656567437639239">"Funksioni MTP ose PTP është aktiv"</string>
    <string name="dlg_confirm_unmount_title" product="nosdcard" msgid="7694112411895701320">"Të shkëputet USB-ja?"</string>
    <string name="dlg_confirm_unmount_title" product="default" msgid="8251329019960361646">"Të çmontohet karta SD?"</string>
    <string name="dlg_confirm_unmount_text" product="nosdcard" msgid="1212025106709645023">"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="3887768438615563697">"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="2205587942165199845"></string>
    <string name="dlg_error_unmount_title" product="default" msgid="2205587942165199845"></string>
    <string name="dlg_error_unmount_text" product="nosdcard" msgid="7876201891724279436">"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="2185659901137961711">"Karta SD nuk mund të shkëputej. Provo përsëri më vonë."</string>
    <string name="unmount_inform_text" product="nosdcard" msgid="5932607205977999175">"Hapësira ruajtëse e USB-së do të shkëputet."</string>
    <string name="unmount_inform_text" product="default" msgid="716578785262713312">"Karta SD do të shkëputet."</string>
    <string name="sd_ejecting_title" msgid="1641122369013595273">"Po çmontohet"</string>
    <string name="sd_ejecting_summary" msgid="861928572729341132">"Çmontimi në vazhdim"</string>
    <string name="storage_low_title" msgid="8002650511493419567">"Hapësira e ruajtjes po mbaron"</string>
    <string name="storage_low_summary" msgid="7341022293583384506">"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="8549835371429159336">"Riemërto"</string>
    <string name="storage_menu_mount" msgid="4760531872302820569">"Monto"</string>
    <string name="storage_menu_unmount" msgid="8171552487742912282">"Nxirr"</string>
    <string name="storage_menu_format" msgid="5454870642788909443">"Formato"</string>
    <string name="storage_menu_format_public" msgid="5567214442727034630">"Formato si të lëvizshme"</string>
    <string name="storage_menu_format_private" msgid="3208326980027382079">"Formato si të brendshme"</string>
    <string name="storage_menu_migrate" msgid="2196088149560070193">"Migro të dhënat"</string>
    <string name="storage_menu_forget" msgid="5154017890033638936">"Harroje"</string>
    <string name="storage_menu_set_up" msgid="4401074025612064744">"Konfiguro"</string>
    <string name="storage_menu_free" msgid="616100170298501673">"Liro hapësirën"</string>
    <string name="storage_menu_manage" msgid="7465522758801346408">"Menaxho hapësirën e ruajtjes"</string>
    <string name="keywords_storage_menu_free" msgid="2275406357317597106">"pastro, hapësira ruajtëse"</string>
    <string name="storage_free_up_space_title" msgid="281047807372131975">"Liro hapësirën"</string>
    <string name="storage_free_up_space_summary" msgid="6650027929735481350">"Shko tek aplikacioni Files për të menaxhuar dhe për të liruar hapësirë"</string>
    <string name="storage_title_usb" msgid="1332488715547400452">"Lidhja e kompjuterit me USB-në"</string>
    <string name="usb_connection_category" msgid="2288543238378907242">"Lidh si"</string>
    <string name="usb_mtp_title" msgid="9068009584556422314">"Pajisje e jashtme \"media\" (MTP)"</string>
    <string name="usb_mtp_summary" msgid="6293240861011560842">"Lejon që të transferosh skedarët \"media\" në Windows ose duke përdorur \"Transferimin e skedarëve të Android\" në Mac (shiko www.android.com/filetransfer)"</string>
    <string name="usb_ptp_title" msgid="4496529268189091846">"Kamera (PTP)"</string>
    <string name="usb_ptp_summary" msgid="8382539472311655671">"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="1139558846427981761">"MIDI"</string>
    <string name="usb_midi_summary" msgid="1842457325845863840">"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="7017206190449510992">"Përdorues të tjerë"</string>
    <string name="storage_internal_title" msgid="3265098802217660829">"Hapësira për ruajtje e pajisjes"</string>
    <string name="storage_external_title" msgid="8984075540312137135">"Hapësira ruajtëse e lëvizshme"</string>
    <string name="storage_size_large" msgid="1155308277890194878">"<xliff:g id="NUMBER">^1</xliff:g>"<small><small>" <xliff:g id="UNIT">^2</xliff:g>"</small></small>""</string>
    <string name="storage_mount_success" msgid="393972242641313135">"<xliff:g id="NAME">%1$s</xliff:g> u montua"</string>
    <string name="storage_mount_failure" msgid="3667915814876418011">"Nuk mundi të lidhte <xliff:g id="NAME">%1$s</xliff:g>"</string>
    <string name="storage_unmount_success" msgid="6406298575402936148">"<xliff:g id="NAME">%1$s</xliff:g> u nxorr në mënyrë të sigurt"</string>
    <string name="storage_unmount_failure" msgid="3796912279003790607">"<xliff:g id="NAME">%1$s</xliff:g> nuk mund të nxirrej në mënyrë të sigurt"</string>
    <string name="storage_format_success" msgid="3028114521294256851">"<xliff:g id="NAME">%1$s</xliff:g> është i formatuar"</string>
    <string name="storage_format_failure" msgid="2042691589726261987">"<xliff:g id="NAME">%1$s</xliff:g> nuk mund të formatohej"</string>
    <string name="storage_rename_title" msgid="5911285992205282312">"Riemërto hapësirën ruajtëse"</string>
    <string name="storage_dialog_unmounted" msgid="1187960789775910051">"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="1761107904296941687">"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_internal_format_details" msgid="8922023528848861812">"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="487689543322907311"><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="5606507270046186691">"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="379238668153099015">"Harroje <xliff:g id="NAME">^1</xliff:g>?"</string>
    <string name="storage_internal_forget_confirm" msgid="5752634604952674123">"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_dialog_system" msgid="7461009051858709479">"Sistemi përfshin skedarët që përdoren për ekzekutimin e versionit <xliff:g id="VERSION">%s</xliff:g> të Android"</string>
    <string name="storage_wizard_init_title" msgid="9036374223934708619">"Konfiguro <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_init_external_title" msgid="6540132491909241713">"Përdore si hapësirë portative ruajtjeje"</string>
    <string name="storage_wizard_init_external_summary" msgid="5807552934494462984">"Për të zhvendosur fotografi dhe artikuj të tjerë \"media\" mes pajisjeve."</string>
    <string name="storage_wizard_init_internal_title" msgid="3256355049992147270">"Përdore si hapësirë të brendshme ruajtjeje"</string>
    <string name="storage_wizard_init_internal_summary" msgid="2283798331883929674">"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="4898014527956178762">"Formato si hapësirë të brendshme ruajtjeje"</string>
    <string name="storage_wizard_format_confirm_body" msgid="5514665245241830772">"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="649252654496577680">"Formatoje si hapësirë ruajtëse të lëvizshme"</string>
    <string name="storage_wizard_format_confirm_public_body" msgid="6219883780307218266">"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="4412063054982084056">"Fshi dhe formato"</string>
    <string name="storage_wizard_format_progress_title" msgid="9170393018855949774">"<xliff:g id="NAME">^1</xliff:g> po formatohet..."</string>
    <string name="storage_wizard_format_progress_body" msgid="1044024044955390417">"Mos e hiq <xliff:g id="NAME">^1</xliff:g> gjatë formatimit."</string>
    <string name="storage_wizard_migrate_title" msgid="3013711737005104623">"Zhvendos të dhënat në hapësirën e re të ruajtjes"</string>
    <string name="storage_wizard_migrate_body" msgid="1630853797296198275">"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="175023718337037181">"Zhvendos tani"</string>
    <string name="storage_wizard_migrate_later" msgid="6573789572520980112">"Zhvendos më vonë"</string>
    <string name="storage_wizard_migrate_confirm_title" msgid="255346780598924540">"Zhvendos të dhënat"</string>
    <string name="storage_wizard_migrate_confirm_body" msgid="5039938578355576124"><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="217478540562501692">"Zhvendos"</string>
    <string name="storage_wizard_migrate_progress_title" msgid="462238335086734131">"Po zhvendos të dhënat..."</string>
    <string name="storage_wizard_migrate_details" msgid="7474061662976940407">"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="3093468548660255543">"<xliff:g id="NAME">^1</xliff:g> është gati për përdorim"</string>
    <string name="storage_wizard_ready_external_body" msgid="45040717412844114">"<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="7734817996475607447">"<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="6812469630804101590">"Zhvendos <xliff:g id="APP">^1</xliff:g>"</string>
    <string name="storage_wizard_move_confirm_body" msgid="1713022828842263574">"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="14651384927767749">"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="3912406225614672391">"Po zhvendos <xliff:g id="APP">^1</xliff:g> ..."</string>
    <string name="storage_wizard_move_progress_body" msgid="2396714553394935094">"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="3494022998599718937">"Anulo zhvendosjen"</string>
    <string name="storage_wizard_slow_body" msgid="8293565076885232029">"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="2538630338392381113">"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="1884468440013151482">"Përdore si hapësirë ruajtëse shtesë të tabletit"</string>
    <string name="storage_wizard_init_v2_internal_summary" product="tablet" msgid="2907833056467441047">"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="3278694259614995649">"Hapësira ruajtëse e tabletit"</string>
    <string name="storage_wizard_init_v2_internal_title" product="default" msgid="5941952998075252284">"Përdore si hapësirë ruajtëse shtesë të telefonit"</string>
    <string name="storage_wizard_init_v2_internal_summary" product="default" msgid="3022584310096954875">"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="5645732875040797464">"Hapësira ruajtëse e telefonit"</string>
    <string name="storage_wizard_init_v2_or" msgid="5558706089661158026">"Ose"</string>
    <string name="storage_wizard_init_v2_external_title" msgid="8129096036551264207">"Përdore si hapësirë të lëvizshme"</string>
    <string name="storage_wizard_init_v2_external_summary" msgid="6436419488235871823">"Për transferimin e skedarëve dhe medias mes pajisjeve"</string>
    <string name="storage_wizard_init_v2_external_action" msgid="781928899530539860">"Hapësira ruajtëse e lëvizshme"</string>
    <string name="storage_wizard_init_v2_later" msgid="5366815913892609285">"Konfiguro më vonë"</string>
    <string name="storage_wizard_format_confirm_v2_title" msgid="6294104100437326067">"Të formatohet kjo <xliff:g id="NAME">^1</xliff:g>?"</string>
    <string name="storage_wizard_format_confirm_v2_body" msgid="635958708974709506">"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="5718254101386377126">"Formato <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_migrate_v2_title" msgid="3471564531564756698">"Të zhvendoset përmbajtja te <xliff:g id="NAME">^1</xliff:g>?"</string>
    <string name="storage_wizard_migrate_v2_body" product="tablet" msgid="4541523202790415721">"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="809730501314645325">"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="2618258869444553060">"Gjatë zhvendosjes:"</string>
    <string name="storage_wizard_migrate_v2_checklist_media" msgid="5867134681730723744">"Mos e hiq <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_migrate_v2_checklist_apps" msgid="1882077445750580783">"Disa aplikacione nuk do të funksionojnë"</string>
    <string name="storage_wizard_migrate_v2_checklist_battery" product="tablet" msgid="6111770421449869539">"Mbaje këtë tablet të karikuar"</string>
    <string name="storage_wizard_migrate_v2_checklist_battery" product="default" msgid="8826915870192535008">"Mbaje këtë telefon të karikuar"</string>
    <string name="storage_wizard_migrate_v2_now" msgid="3341460117088026966">"Zhvendos përmbajtjen"</string>
    <string name="storage_wizard_migrate_v2_later" msgid="6067756122853315642">"Zhvendose përmbajtjen më vonë"</string>
    <string name="storage_wizard_migrate_progress_v2_title" msgid="8791318509516968103">"Përmbajtja po zhvendoset…"</string>
    <string name="storage_wizard_slow_v2_title" msgid="3760766921170980221">"<xliff:g id="NAME">^1</xliff:g> e ngadaltë"</string>
    <string name="storage_wizard_slow_v2_body" msgid="7604252106419016929">"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="1806852287668077536">"Fillo nga e para"</string>
    <string name="storage_wizard_slow_v2_continue" msgid="7469713755893007901">"Vazhdo"</string>
    <string name="storage_wizard_ready_v2_external_body" msgid="3896836008684280905">"Mund ta zhvendosësh përmbajtjen te <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_ready_v2_internal_body" msgid="5710665992219332454">"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="1269878056598666852">"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="4661768220545945771">"Statusi i baterisë"</string>
    <string name="battery_level_title" msgid="1371765298786083448">"Niveli i baterisë"</string>
    <string name="apn_settings" msgid="4295467389400441299">"APN-të"</string>
    <string name="apn_edit" msgid="2003683641840248741">"Redakto pikën e qasjes"</string>
    <string name="apn_not_set" msgid="8246646433109750293">"Nuk është caktuar"</string>
    <string name="apn_not_set_for_mvno" msgid="1141490067313964640">"Nuk është caktuar"</string>
    <string name="apn_name" msgid="6677695784108157953">"Emri"</string>
    <string name="apn_apn" msgid="5812828833797458602">"APN-ja"</string>
    <string name="apn_http_proxy" msgid="1052464912365838007">"Proxy"</string>
    <string name="apn_http_port" msgid="9138610639873966046">"Porta"</string>
    <string name="apn_user" msgid="5831763936428279228">"Emri i përdoruesit"</string>
    <string name="apn_password" msgid="7435086635953953029">"Fjalëkalimi"</string>
    <string name="apn_server" msgid="6997704279138388384">"Serveri"</string>
    <string name="apn_mmsc" msgid="4985570919581927224">"MMSC-ja"</string>
    <string name="apn_mms_proxy" msgid="6592247653258283592">"Proxy i MMS-ve"</string>
    <string name="apn_mms_port" msgid="6500563737462966663">"Porta e MMS-ve"</string>
    <string name="apn_mcc" msgid="4971414138516074809">"MCC-ja"</string>
    <string name="apn_mnc" msgid="1926382406843447854">"MNC-ja"</string>
    <string name="apn_auth_type" msgid="4234397513494356932">"Lloji i vërtetimit"</string>
    <string name="apn_auth_type_none" msgid="6845031410929644238">"Asnjë"</string>
    <string name="apn_auth_type_pap" msgid="9003475621032514182">"PAP"</string>
    <string name="apn_auth_type_chap" msgid="3587713509473187621">"CHAP"</string>
    <string name="apn_auth_type_pap_chap" msgid="6852124741245095775">"PAP ose CHAP"</string>
    <string name="apn_type" msgid="1835573305077788773">"Lloji i APN-së"</string>
    <string name="apn_protocol" msgid="181529867160380010">"Protokolli i APN-së"</string>
    <string name="apn_roaming_protocol" msgid="1645131094105362513">"Protokolli i APN-së në roaming"</string>
    <string name="carrier_enabled" msgid="664074151573150130">"Aktivizo/çaktivizo APN-në"</string>
    <string name="carrier_enabled_summaryOn" msgid="5212067975273903381">"Rrjeti APN u aktivizua"</string>
    <string name="carrier_enabled_summaryOff" msgid="8541959867953738521">"Rrjeti APN u çaktivizua"</string>
    <string name="bearer" msgid="3231443241639159358">"Bartësi"</string>
    <string name="mvno_type" msgid="4734654257494971247">"Lloji i MVNO-së"</string>
    <string name="mvno_match_data" msgid="5213193073684321156">"Vlera e MVNO-së"</string>
    <string name="menu_delete" msgid="9199740901584348273">"Fshi APN-në"</string>
    <string name="menu_new" msgid="6571230342655509006">"APN e re"</string>
    <string name="menu_save" msgid="6611465355127483100">"Ruaj"</string>
    <string name="menu_cancel" msgid="1197826697950745335">"Anulo"</string>
    <string name="error_title" msgid="7158648377702417716"></string>
    <string name="error_name_empty" msgid="1258275899283079142">"Fusha Emri nuk mund të jetë bosh."</string>
    <string name="error_apn_empty" msgid="7657491065443746915">"Rrjeti APN nuk mund të jetë bosh."</string>
    <string name="error_mcc_not3" msgid="883659545640179094">"Fusha e MCC-së duhet të ketë 3 shifra."</string>
    <string name="error_mnc_not23" msgid="7642478711158474918">"Fusha e MNC-së duhet të ketë 2 ose 3 shifra."</string>
    <string name="error_adding_apn_type" msgid="1324263534991467943">"Operatori nuk lejon shtimin e APN-ve të llojit %s."</string>
    <string name="restore_default_apn" msgid="6596048535642130689">"Po restauron cilësimet e APN-së me parazgjedhje."</string>
    <string name="menu_restore" msgid="4310539620115151551">"Rivendos të parazgjedhurën"</string>
    <string name="restore_default_apn_completed" msgid="5167505087078340256">"Rivendosja e cilësimeve të APN-së me parazgjedhje përfundoi."</string>
    <string name="reset_dashboard_title" msgid="7423200250697886918">"Opsionet e rivendosjes"</string>
    <string name="reset_dashboard_summary" msgid="4390780188264852956">"Rrjeti, aplikacionet ose pajisja mund të rivendosen"</string>
    <string name="reset_dashboard_summary_onlyApps" msgid="3304252260039419584">"Aplikacionet mund të rivendosen"</string>
    <string name="reset_network_title" msgid="1395494440355807616">"Rivendos Wi-Fi, lidhjen celulare dhe Bluetooth"</string>
    <string name="reset_network_desc" msgid="1112523764899788246">"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="erase_euicc_data_button" msgid="728078969563311737">"Spastro"</string>
    <string name="reset_esim_title" msgid="6152167073280852849">"Spastro kartat SIM të shkarkuara"</string>
    <string name="reset_esim_desc" msgid="3662444090563399131">"Kjo nuk do të anulojë planet e shërbimit celular. Për të shkarkuar karta zëvendësuese SIM, kontakto me operatorin celular."</string>
    <string name="reset_network_button_text" msgid="2281476496459610071">"Rivendos cilësimet"</string>
    <string name="reset_network_final_desc" msgid="5304365082065278425">"Të rivendosen të gjitha cilësimet e rrjetit? Ky veprim nuk mund të zhbëhet."</string>
    <string name="reset_network_final_desc_esim" msgid="8342882682282693844">"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="2433867118414000462">"Rivendos cilësimet"</string>
    <string name="reset_network_confirm_title" msgid="913014422184481270">"Të rivendosen?"</string>
    <string name="network_reset_not_available" msgid="1966334631394607829">"Rivendosja e rrjetit nuk është e disponueshme për këtë përdorues"</string>
    <string name="reset_network_complete_toast" msgid="1367872474130621115">"Cilësimet e rrjetit janë rivendosur"</string>
    <string name="reset_esim_error_title" msgid="4670073610967959597">"Kartat SIM nuk mund të spastrohen"</string>
    <string name="reset_esim_error_msg" msgid="4441504470684307370">"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="main_clear_title" msgid="277664302144837723">"Spastro të gjitha të dhënat (rivendosja e fabrikës)"</string>
    <string name="main_clear_short_title" msgid="4752094765533020696">"Spastro të gjitha të dhënat (rivendosja e fabrikës)"</string>
    <string name="main_clear_desc" product="tablet" msgid="1651178880680056849">"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="main_clear_desc" product="default" msgid="6984348811887162647">"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="main_clear_accounts" product="default" msgid="7675859115108318537">\n\n"Je i identifikuar aktualisht në llogaritë e mëposhtme:\n"</string>
    <string name="main_clear_other_users_present" product="default" msgid="2672976674798019077">\n\n"Ka përdorues të tjerë të pranishëm në këtë pajisje.\n"</string>
    <string name="main_clear_desc_also_erases_external" msgid="3687911419628956693"><li>"Muzika"</li>\n<li>"Fotografitë"</li>\n<li>"Të dhëna të tjera të përdoruesit"</li></string>
    <string name="main_clear_desc_also_erases_esim" msgid="4553469876411831729"><li>"Kartat eSIM"</li></string>
    <string name="main_clear_desc_no_cancel_mobile_plan" msgid="369883568059127035">\n\n"Kjo nuk do ta anulojë planin tënd të shërbimit celular."</string>
    <string name="main_clear_desc_erase_external_storage" product="nosdcard" msgid="4441604184663452046">\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="main_clear_desc_erase_external_storage" product="default" msgid="1498514970618215728">\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="2182181846128639635">"Fshi hapësirën ruajtëse të USB-së"</string>
    <string name="erase_external_storage" product="default" msgid="2610056855012660451">"Spastroje kartën SD"</string>
    <string name="erase_external_storage_description" product="nosdcard" msgid="6358699244894944843">"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="3367779850546310380">"Spastro të gjitha të dhënat në kartën SD, si muzikën ose fotografitë"</string>
    <string name="main_clear_button_text" product="tablet" msgid="6246087475569640671">"Spastro të gjitha të dhënat"</string>
    <string name="main_clear_button_text" product="default" msgid="6246087475569640671">"Spastro të gjitha të dhënat"</string>
    <string name="main_clear_final_desc" msgid="5800877928569039580">"Të gjitha informacionet e tua personale dhe aplikacionet e shkarkuara do të fshihen. Nuk mund ta zhbësh këtë veprim."</string>
    <string name="main_clear_final_desc_esim" msgid="440406836793824969">"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="main_clear_confirm_title" msgid="6577071819657853713">"Të spastrohen të gjitha të dhënat?"</string>
    <string name="main_clear_not_available" msgid="3433795327146684827">"Rivendosja në gjendjen e fabrikës nuk ofrohet për këtë përdorues"</string>
    <string name="main_clear_progress_title" msgid="7239741132015617719">"Po spastron"</string>
    <string name="main_clear_progress_text" msgid="4636695115176327972">"Qëndro në pritje…"</string>
    <string name="call_settings_title" msgid="2531072044177194164">"Cilësimet e telefonatave"</string>
    <string name="call_settings_summary" msgid="8244293779053318053">"Konfiguro postën zanore, transferimin e telefonatave, telefonatat në pritje dhe ID-në e telefonuesit"</string>
    <string name="tether_settings_title_usb" msgid="5926474044238409099">"Ndarje përmes USB-së"</string>
    <string name="tether_settings_title_wifi" msgid="4327056146425282159">"Zona e qasjes e lëvizshme"</string>
    <string name="tether_settings_title_bluetooth" msgid="8878813702520141084">"Ndarje interneti përmes Bluetooth-it"</string>
    <string name="tether_settings_title_usb_bluetooth" msgid="4437274151658505496">"Ndarja e internetit"</string>
    <string name="tether_settings_title_all" msgid="6807525590937697228">"Zona e qasjes dhe ndarja e internetit"</string>
    <string name="tether_settings_summary_hotspot_on_tether_on" msgid="6110241048260139633">"Zona e qasjes së internetit aktive, interneti po ndahet"</string>
    <string name="tether_settings_summary_hotspot_on_tether_off" msgid="5057598961245943644">"Zona e qasjes së internetit aktive"</string>
    <string name="tether_settings_summary_hotspot_off_tether_on" msgid="7181518138494995888">"Ndarja e internetit"</string>
    <string name="tether_settings_disabled_on_data_saver" msgid="9054069463426952689">"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="tether_settings_summary_hotspot_only" msgid="8529008147731140279">"Vetëm zona e qasjes për internet"</string>
    <string name="tether_settings_summary_usb_tethering_only" msgid="6351624505239356221">"Vetëm USB"</string>
    <string name="tether_settings_summary_bluetooth_tethering_only" msgid="1451008625343274930">"Vetëm Bluetooth"</string>
    <string name="tether_settings_summary_ethernet_tethering_only" msgid="3582266687537419309">"Vetëm eternet"</string>
    <string name="tether_settings_summary_hotspot_and_usb" msgid="5999349643653265016">"Zona e qasjes për internet, USB"</string>
    <string name="tether_settings_summary_hotspot_and_bluetooth" msgid="810514646401708557">"Zona e qasjes për internet, Bluetooth"</string>
    <string name="tether_settings_summary_hotspot_and_ethernet" msgid="5489192670354277152">"Zona e qasjes së internetit, eternet"</string>
    <string name="tether_settings_summary_usb_and_bluetooth" msgid="1355680331767261967">"USB, Bluetooth"</string>
    <string name="tether_settings_summary_usb_and_ethernet" msgid="2195017679820919905">"USB, Ethernet"</string>
    <string name="tether_settings_summary_bluetooth_and_ethernet" msgid="1015253926959211012">"Bluetooth, eternet"</string>
    <string name="tether_settings_summary_hotspot_and_usb_and_bluetooth" msgid="2949043525073791732">"Zona e qasjes për internet, USB, Bluetooth"</string>
    <string name="tether_settings_summary_hotspot_and_usb_and_ethernet" msgid="5178946567323581144">"Zona e qasjes për internet, USB, Ethernet"</string>
    <string name="tether_settings_summary_hotspot_and_bluetooth_and_ethernet" msgid="4104425838594994441">"Zona e qasjes së internetit, Bluetooth, eternet"</string>
    <string name="tether_settings_summary_usb_and_bluetooth_and_ethernet" msgid="5880591133984166550">"USB, Bluetooth, eternet"</string>
    <string name="tether_settings_summary_all" msgid="7565193614882005775">"Zona e qasjes së internetit, USB, Bluetooth, eternet"</string>
    <string name="tether_settings_summary_off" msgid="2526164899130351968">"Interneti nuk ndahet me pajisje të tjera"</string>
    <string name="tethering_interface_options" msgid="7575535888135143650">"Ndarja e internetit"</string>
    <string name="disable_wifi_hotspot_title" msgid="2167985468585290478">"Mos përdor zonën e qasjes për Wi-Fi"</string>
    <string name="disable_wifi_hotspot_when_usb_on" msgid="220439059794714583">"Ndaje internetin vetëm me USB"</string>
    <string name="disable_wifi_hotspot_when_bluetooth_on" msgid="4711723299880116345">"Ndaje internetin vetëm me Bluetooth"</string>
    <string name="disable_wifi_hotspot_when_ethernet_on" msgid="4123242400542103599">"Ndaje internetin vetëm me eternet"</string>
    <string name="disable_wifi_hotspot_when_usb_and_bluetooth_on" msgid="5258774769658150180">"Ndaje internetin vetëm me USB dhe Bluetooth"</string>
    <string name="disable_wifi_hotspot_when_usb_and_ethernet_on" msgid="7126313562907225612">"Ndaje internetin vetëm me USB dhe eternet"</string>
    <string name="disable_wifi_hotspot_when_bluetooth_and_ethernet_on" msgid="2943464651349235967">"Ndaje internetin vetëm me Bluetooth dhe eternet"</string>
    <string name="disable_wifi_hotspot_when_usb_and_bluetooth_and_ethernet_on" msgid="3934609816834760008">"Ndaje internetin vetëm me USB, Bluetooth dhe eternet"</string>
    <string name="usb_title" msgid="1157283449840612901">"USB"</string>
    <string name="usb_tethering_button_text" msgid="7364633823180913777">"Ndarje interneti përmes USB-së"</string>
    <string name="usb_tethering_subtext" product="default" msgid="3168636595109044213">"Ndaj lidhjen e internetit të telefonit përmes USB-së"</string>
    <string name="usb_tethering_subtext" product="tablet" msgid="1749659335004856576">"Ndaj lidhjen e internetit të tabletit përmes USB-së"</string>
    <string name="bluetooth_tether_checkbox_text" msgid="6108398414967813545">"Ndarje interneti përmes Bluetooth-it"</string>
    <string name="bluetooth_tethering_subtext" product="tablet" msgid="2023654677593885805">"Ndaj lidhjen e internetit të tabletit përmes Bluetooth-it"</string>
    <string name="bluetooth_tethering_subtext" product="default" msgid="4322810060538179348">"Ndaj lidhjen e internetit të telefonit përmes Bluetooth-it"</string>
    <string name="bluetooth_tethering_off_subtext_config" msgid="6941934844527406581">"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="5292358672240161566">"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="5087548945727762308">"Ndarja e internetit do të çaktivizohet për <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="ethernet_tether_checkbox_text" msgid="959743110824197356">"Ndarja e Ethernet-it"</string>
    <string name="ethernet_tethering_subtext" product="default" msgid="5998100693350351694">"Ndaj lidhjen e internetit të telefonit përmes Ethernet"</string>
    <string name="tethering_footer_info" msgid="6782375845587483281">"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_footer_info_sta_ap_concurrency" msgid="2079039077487477676">"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 Wi-Fi ose 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="2823655011510912001">"Ndihma"</string>
    <string name="network_settings_title" msgid="4663717899931613176">"Rrjeti celular"</string>
    <string name="manage_mobile_plan_title" msgid="5616930513733409064">"Plani celular"</string>
    <string name="sms_application_title" msgid="4791107002724108809">"Aplikacioni për SMS"</string>
    <string name="sms_change_default_dialog_title" msgid="2343439998715457307">"Të ndryshohet aplikacioni i SMS-ve?"</string>
    <string name="sms_change_default_dialog_text" msgid="8777606240342982531">"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="6215622785087181275">"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="2022922801936206195">"Ofruesi i vlerësimit të rrjetit"</string>
    <string name="network_scorer_picker_none_preference" msgid="8894034333043177807">"Asnjë"</string>
    <string name="network_scorer_change_active_dialog_title" msgid="7005220310238618141">"Të ndryshohet ndihmësi i Wi‑Fi?"</string>
    <string name="network_scorer_change_active_dialog_text" msgid="7006057749370850706">"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="680685773455072321">"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="6650422533065760963">"Operatori i kartës SIM është i panjohur"</string>
    <string name="mobile_no_provisioning_url" msgid="609462719893503773">"<xliff:g id="OPERATOR">%1$s</xliff:g> nuk ka faqe të sigurt e të njohur"</string>
    <string name="mobile_insert_sim_card" msgid="3639245241283948038">"Vendos kartën SIM dhe rinise"</string>
    <string name="mobile_connect_to_internet" msgid="8162654404357069060">"Lidhu me internetin"</string>
    <string name="location_category_recent_location_requests" msgid="2205900488782832082">"Kërkesat e vendndodhjeve të fundit"</string>
    <string name="location_recent_location_requests_see_all" msgid="7918405176741692524">"Shfaq çdo gjë"</string>
    <string name="location_category_location_services" msgid="8163798686832434284">"Shërbimet e vendndodhjes"</string>
    <string name="location_title" msgid="5819154746934945021">"Vendndodhja ime"</string>
    <string name="managed_profile_location_switch_title" msgid="1265007506385460066">"Vend. për profilin e punës"</string>
    <string name="location_app_level_permissions" msgid="907206607664629759">"Lejet e vendndodhjes për aplikacionet"</string>
    <string name="location_app_permission_summary_location_off" msgid="2711822936853500335">"Vendndodhja është joaktive"</string>
    <plurals name="location_app_permission_summary_location_on" formatted="false" msgid="8286873148858526214">
      <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="2558063524482178146">"Qasja së fundi"</string>
    <string name="location_recent_location_access_see_all" msgid="4203102419355323325">"Shiko të gjitha"</string>
    <string name="location_recent_location_access_view_details" msgid="5803264082558504544">"Shiko detajet"</string>
    <string name="location_no_recent_apps" msgid="6814206631456177033">"Asnjë aplikacion nuk ka kërkuar vendndodhje kohët e fundit"</string>
    <string name="location_no_recent_accesses" msgid="6031735777805464247">"Asnjë aplikacion nuk ka pasur qasje te vendndodhja së fundi"</string>
    <string name="location_high_battery_use" msgid="4277318891200626524">"Përdorimi i lartë i baterisë"</string>
    <string name="location_low_battery_use" msgid="5218950289737996431">"Përdorim i ulët baterie"</string>
    <string name="location_scanning_wifi_always_scanning_title" msgid="5004781272733434794">"Skanimi i Wi-Fi"</string>
    <string name="location_scanning_wifi_always_scanning_description" msgid="6236055656376931306">"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="1809309545730215891">"Skanimi i Bluetooth-it"</string>
    <string name="location_scanning_bluetooth_always_scanning_description" msgid="5362988856388462841">"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="location_services_preference_title" msgid="604317859531782159">"Shërbimet e vendndodhjes"</string>
    <string name="location_services_screen_title" msgid="5640002489976602476">"Shërbimet e vendndodhjes"</string>
    <string name="managed_profile_location_services" msgid="8172092734138341880">"Shërbimet e vendndodhjes për punë"</string>
    <string name="location_time_zone_detection_toggle_title" msgid="6518338597250564260">"Përdor vendndodhjen për të caktuar brezin orar"</string>
    <string name="location_time_zone_detection_location_is_off_dialog_title" msgid="231698690198001146">"Nevojitet vendndodhja e pajisjes"</string>
    <string name="location_time_zone_detection_location_is_off_dialog_message" msgid="5846316326139169523">"Për të caktuar brezin orar duke përdorur vendndodhjen tënde, aktivizo vendndodhjen, pastaj përditëso cilësimet e brezit orar"</string>
    <string name="location_time_zone_detection_location_is_off_dialog_ok_button" msgid="2685647335717750297">"Cilësimet e vendndodhjes"</string>
    <string name="location_time_zone_detection_location_is_off_dialog_cancel_button" msgid="3968729678789071154">"Anulo"</string>
    <string name="location_time_zone_detection_auto_is_off" msgid="6264253990141650280">"Brezi orar automatik është joaktiv"</string>
    <string name="location_time_zone_detection_not_applicable" msgid="6757964612836952714">"Zbulimi i brezit orar të vendndodhjes është çaktivizuar"</string>
    <string name="location_time_zone_detection_not_supported" msgid="3251181656388306501">"Zbulimi i brezit orar të vendndodhjes nuk mbështetet"</string>
    <string name="location_time_zone_detection_not_allowed" msgid="8264525161514617051">"Nuk lejohen ndryshimet në zbulimin e brezit orar të vendndodhjes"</string>
    <string name="location_network_based" msgid="5247042890080021887">"Vend. rrjetit Wi‑Fi e celular"</string>
    <string name="location_neighborhood_level" msgid="3668890550358558267">"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="6227393490651891977">"Vendndodhja u përcaktua nga Wi‑Fi"</string>
    <string name="location_gps" msgid="8783616672454701134">"Satelitët GPS"</string>
    <string name="location_street_level" product="tablet" msgid="865953107414742784">"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="3813836654645896185">"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="1714546606018821498">"Përdor GPS-në e ndihmuar"</string>
    <string name="assisted_gps_enabled" msgid="6220188450779319248">"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="1062496503892849">"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="1345594777162897654">"Vendndodhja dhe kërkimi në Google"</string>
    <string name="use_location_summary" msgid="377322574549729921">"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="4052667453826272040">"Qasja në vendndodhjen time"</string>
    <string name="location_access_summary" msgid="8634100005481578143">"Lejoji aplikacionet që kanë kërkuar lejen tënde të përdorin informacionin e vendndodhjes"</string>
    <string name="location_sources_heading" msgid="6126965815860570524">"Burimet e vendndodhjes"</string>
    <string name="about_settings" product="tablet" msgid="2888705054709289693">"Rreth tabletit"</string>
    <string name="about_settings" product="default" msgid="4038626127378127613">"Informacion mbi telefonin"</string>
    <string name="about_settings" product="device" msgid="9012888717090302815">"Informacione rreth pajisjes"</string>
    <string name="about_settings" product="emulator" msgid="2516560858771320366">"Rreth emulatorit"</string>
    <string name="about_settings_summary" msgid="4831942939227432513">"Shiko informacionin ligjor, statusin dhe versionin e softuerit"</string>
    <string name="legal_information" msgid="7509900979811934843">"Informacioni ligjor"</string>
    <string name="contributors_title" msgid="7965640251547037965">"Kontribuuesit"</string>
    <string name="manual" msgid="3651593989906084868">"Manuale"</string>
    <string name="regulatory_labels" msgid="5960251403367154270">"Etiketat rregullatore"</string>
    <string name="safety_and_regulatory_info" msgid="8285048080439298528">"Manuali rregullator dhe i sigurisë"</string>
    <string name="copyright_title" msgid="83245306827757857">"Të drejtat e autorit"</string>
    <string name="license_title" msgid="8745742085916617540">"Licenca"</string>
    <string name="module_license_title" msgid="8705484239826702828">"Licencat e përditësimit të sistemit të Google Play"</string>
    <string name="terms_title" msgid="2071742973672326073">"Kushtet e përgjithshme"</string>
    <string name="webview_license_title" msgid="5832692241345780517">"Licenca e WebView në sistem"</string>
    <string name="wallpaper_attributions" msgid="4323659759250650736">"Bashkëpunëtorët e imazheve të sfondit"</string>
    <string name="wallpaper_attributions_values" msgid="987277439026021925">"Ofruesit e imazheve satelitore:\n©2014 CNES / Astrium, DigitalGlobe, Bluesky"</string>
    <string name="settings_manual_activity_title" msgid="1682978148920788484">"Manuale"</string>
    <string name="settings_manual_activity_unavailable" msgid="2514549851682321576">"Ka një problem me ngarkimin e manualit."</string>
    <string name="settings_license_activity_title" msgid="7832071619364734914">"Licencat e palëve të treta"</string>
    <string name="settings_license_activity_unavailable" msgid="9014803774391134570">"Ka një problem me ngarkimin e licencave."</string>
    <string name="settings_license_activity_loading" msgid="1653151990366578827">"Po ngarkon..."</string>
    <string name="settings_safetylegal_title" msgid="1334501164265709288">"Informacioni i sigurisë"</string>
    <string name="settings_safetylegal_activity_title" msgid="2218587051061093358">"Informacioni i sigurisë"</string>
    <string name="settings_safetylegal_activity_unreachable" msgid="6571695168138207587">"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="1757860124583063395">"Po ngarkon..."</string>
    <string name="lockpassword_choose_your_password_header" msgid="2407205113298094824">"Cakto një fjalëkalim"</string>
    <string name="lockpassword_choose_your_profile_password_header" msgid="7038997227611893312">"Cakto një fjalëkalim për punën"</string>
    <string name="lockpassword_choose_your_pin_header" msgid="7754265746504679473">"Cakto një kod PIN"</string>
    <string name="lockpassword_choose_your_profile_pin_header" msgid="4581749963670819048">"Cakto një kod PIN për punën"</string>
    <string name="lockpassword_choose_your_pattern_header" msgid="5674909390779586252">"Cakto një motiv"</string>
    <string name="lockpassword_choose_your_profile_pattern_header" msgid="3101811498330756641">"Cakto një motiv për punën"</string>
    <string name="lockpassword_choose_your_password_header_for_fingerprint" msgid="3167261267229254090">"Për të përdorur gjurmën e gishtit, vendos fjalëkalimin"</string>
    <string name="lockpassword_choose_your_pattern_header_for_fingerprint" msgid="4707788269512303400">"Për të përdorur gjurmën e gishtit, vendos motivin"</string>
    <string name="lockpassword_choose_your_pin_message" msgid="7230665212172041837">"Për siguri, cakto një kod PIN"</string>
    <string name="lockpassword_choose_your_pin_header_for_fingerprint" msgid="2783879743691792556">"Për të përdorur gjurmën e gishtit, vendos kodin PIN"</string>
    <string name="lockpassword_confirm_your_password_header" msgid="6132312814563023990">"Fut përsëri fjalëkalimin"</string>
    <string name="lockpassword_reenter_your_profile_password_header" msgid="3812040127714827685">"Fut përsëri fjalëkalimin tënd për punën"</string>
    <string name="lockpassword_confirm_your_work_password_header" msgid="4647071231702288305">"Fut fjalëkalimin e punës"</string>
    <string name="lockpassword_confirm_your_pattern_header" msgid="4037701363240138651">"Konfirmo motivin"</string>
    <string name="lockpassword_confirm_your_work_pattern_header" msgid="2668883108969165844">"Fut motivin e punës"</string>
    <string name="lockpassword_confirm_your_pin_header" msgid="2241722970567131308">"Fut përsëri kodin PIN"</string>
    <string name="lockpassword_reenter_your_profile_pin_header" msgid="2890233614560435538">"Fut përsëri kodin tënd PIN për punën"</string>
    <string name="lockpassword_confirm_your_work_pin_header" msgid="4229765521391960255">"Fut kodin PIN të punës"</string>
    <string name="lockpassword_confirm_passwords_dont_match" msgid="2100071354970605232">"Fjalëkalimet nuk përputhen"</string>
    <string name="lockpassword_confirm_pins_dont_match" msgid="1103699575489401030">"Kodet PIN nuk përputhen"</string>
    <string name="lockpassword_draw_your_pattern_again_header" msgid="1045638030120803622">"Vizato sërish motivin tënd"</string>
    <string name="lockpassword_choose_lock_generic_header" msgid="5669348379247148696">"Përzgjedhja e shkyçjes"</string>
    <string name="lockpassword_password_set_toast" msgid="6615759749393973795">"Fjalëkalimi është caktuar"</string>
    <string name="lockpassword_pin_set_toast" msgid="5415783847198570890">"Kodi PIN është caktuar"</string>
    <string name="lockpassword_pattern_set_toast" msgid="3090582314362416762">"Motivi është caktuar"</string>
    <string name="lockpassword_choose_your_password_header_for_face" msgid="622276003801157839">"Për të përdorur \"Shkyçjen me fytyrë\", cakto fjalëkalimin"</string>
    <string name="lockpassword_choose_your_pattern_header_for_face" msgid="7333603579958317102">"Për të përdorur \"Shkyçjen me fytyrë\", cakto motivin"</string>
    <string name="lockpassword_choose_your_pin_header_for_face" msgid="704061826984851309">"Për të përdorur \"Shkyçjen me fytyrë\", cakto kodin PIN"</string>
    <string name="lockpassword_choose_your_password_header_for_biometrics" msgid="2053366309272487015">"Cakto një fjalëkalim për të përdorur fytyrën ose gjurmën e gishtit"</string>
    <string name="lockpassword_choose_your_pattern_header_for_biometrics" msgid="4038476475293734905">"Cakto një motiv për të përdorur fytyrën ose gjurmën e gishtit"</string>
    <string name="lockpassword_choose_your_pin_header_for_biometrics" msgid="9086039918921009380">"Cakto një kod PIN për të përdorur fytyrën ose gjurmën e gishtit"</string>
    <string name="lockpassword_forgot_password" msgid="5730587692489737223">"Harrove fjalëkalimin?"</string>
    <string name="lockpassword_forgot_pattern" msgid="1196116549051927516">"Harrove motivin?"</string>
    <string name="lockpassword_forgot_pin" msgid="7164232234705747672">"Harrove kodin PIN?"</string>
    <string name="lockpassword_confirm_your_pattern_generic" msgid="7692794426682501482">"Përdor motivin e pajisjes për të vazhduar"</string>
    <string name="lockpassword_confirm_your_pin_generic" msgid="9206928587904701094">"Fut kodin PIN të pajisjes për të vazhduar"</string>
    <string name="lockpassword_confirm_your_password_generic" msgid="2616127423884477152">"Fut fjalëkalimin e pajisjes për të vazhduar"</string>
    <string name="lockpassword_confirm_your_pattern_generic_profile" msgid="9110305410672321714">"Përdor motivin tënd të punës për të vazhduar"</string>
    <string name="lockpassword_confirm_your_pin_generic_profile" msgid="6524208128570235127">"Fut kodin tënd PIN të punës për të vazhduar"</string>
    <string name="lockpassword_confirm_your_password_generic_profile" msgid="5918738487760814147">"Fut fjalëkalimin tënd të punës për të vazhduar"</string>
    <string name="lockpassword_strong_auth_required_device_pattern" msgid="113817518413715557">"Për më shumë siguri, përdor motivin e pajisjes"</string>
    <string name="lockpassword_strong_auth_required_device_pin" msgid="9163822166411129815">"Për më shumë siguri, fut kodin PIN të pajisjes"</string>
    <string name="lockpassword_strong_auth_required_device_password" msgid="8310047427464299337">"Për më shumë siguri, fut fjalëkalimin e pajisjes"</string>
    <string name="lockpassword_strong_auth_required_work_pattern" msgid="6803652050512161140">"Për më shumë siguri, përdor motivin e punës"</string>
    <string name="lockpassword_strong_auth_required_work_pin" msgid="4208510396448713500">"Për më shumë siguri, fut kodin PIN të punës"</string>
    <string name="lockpassword_strong_auth_required_work_password" msgid="6119482061429323090">"Për më shumë siguri, fut fjalëkalimin e punës"</string>
    <string name="lockpassword_confirm_your_pattern_details_frp" msgid="6351784282865851482">"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="2128795640346033349">"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="4031863562975125016">"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="5641858015891896427">"Verifiko motivin"</string>
    <string name="lockpassword_confirm_your_pin_header_frp" msgid="8285647793164729982">"Verifiko kodin PIN"</string>
    <string name="lockpassword_confirm_your_password_header_frp" msgid="7932240547542564033">"Verifiko fjalëkalimin"</string>
    <string name="lockpassword_invalid_pin" msgid="7530854476819820600">"Kod PIN i gabuar"</string>
    <string name="lockpassword_invalid_password" msgid="1588184930542221687">"Fjalëkalim i gabuar"</string>
    <string name="lockpattern_need_to_unlock_wrong" msgid="8109305107409924083">"Motiv i gabuar"</string>
    <string name="lock_settings_title" msgid="665707559508132349">"Siguria e pajisjes"</string>
    <string name="lockpattern_change_lock_pattern_label" msgid="5853706275279878879">"Ndrysho motivin e shkyçjes"</string>
    <string name="lockpattern_change_lock_pin_label" msgid="7327409886587802756">"Ndrysho kodin PIN të shkyçjes"</string>
    <string name="lockpattern_recording_intro_header" msgid="8325736706877916560">"Vizato një motiv shkyçjeje"</string>
    <string name="lockpattern_recording_intro_footer" msgid="2656868858594487197">"Shtyp Menynë për ndihmë."</string>
    <string name="lockpattern_recording_inprogress" msgid="7268008332694009191">"Hiqe gishtin kur të mbarosh"</string>
    <string name="lockpattern_recording_incorrect_too_short" msgid="3351522018450593723">"Lidh të paktën <xliff:g id="NUMBER">%d</xliff:g> pika. Provo përsëri."</string>
    <string name="lockpattern_pattern_entered_header" msgid="7709618312713127249">"Motivi u regjistrua"</string>
    <string name="lockpattern_need_to_confirm" msgid="6489499109451714360">"Vizato sërish motivin për ta konfirmuar"</string>
    <string name="lockpattern_pattern_confirmed_header" msgid="2969990617475456153">"Motivi i ri i shkyçjes"</string>
    <string name="lockpattern_confirm_button_text" msgid="6122815520373044089">"Konfirmo"</string>
    <string name="lockpattern_restart_button_text" msgid="255339375151895998">"Tërhiq sërish"</string>
    <string name="lockpattern_retry_button_text" msgid="4229668933251849760">"Pastro"</string>
    <string name="lockpattern_continue_button_text" msgid="5253269556259503537">"Vazhdo"</string>
    <string name="lockpattern_settings_title" msgid="9223165804553269083">"Motivi i shkyçjes"</string>
    <string name="lockpattern_settings_enable_title" msgid="7401197111303283723">"Kërko motivin"</string>
    <string name="lockpattern_settings_enable_summary" msgid="1116467204475387886">"Duhet të vizatosh motivin për të shkyçur ekranin"</string>
    <string name="lockpattern_settings_enable_visible_pattern_title" msgid="3340969054395584754">"Bëje motivin të dukshëm"</string>
    <string name="lockpattern_settings_enable_visible_pattern_title_profile" msgid="5138189101808127489">"Bëje të dukshëm motivin e profilit"</string>
    <string name="lockpattern_settings_enable_tactile_feedback_title" msgid="2273374883831956787">"Dridhje pas trokitjes"</string>
    <string name="lockpattern_settings_enable_power_button_instantly_locks" msgid="1638619728773344099">"Butoni i fikjes e kyç menjëherë"</string>
    <string name="lockpattern_settings_power_button_instantly_locks_summary" msgid="2202430156268094229">"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="2193588309557281466">"Cakto motivin e shkyçjes"</string>
    <string name="lockpattern_settings_change_lock_pattern" msgid="7614155083815661347">"Ndrysho motivin e shkyçjes"</string>
    <string name="lockpattern_settings_help_how_to_record" msgid="2093801939046625774">"Si të vizatosh një motiv shkyçjeje"</string>
    <string name="lockpattern_too_many_failed_confirmation_attempts" msgid="7891484005551794824">"Shumë tentativa të pasakta. Provo sërish brenda <xliff:g id="NUMBER">%d</xliff:g> sekondash."</string>
    <string name="activity_not_found" msgid="5464331414465894254">"Aplikacioni nuk është i instaluar në telefonin tënd."</string>
    <string name="lock_settings_profile_title" msgid="103605580492566086">"Siguria e profilit të punës"</string>
    <string name="lock_settings_profile_screen_lock_title" msgid="3776275029218681815">"Kyçja e ekranit të profilit të punës"</string>
    <string name="lock_settings_profile_unification_title" msgid="5777961097706546513">"Përdor një kyçje të vetme"</string>
    <string name="lock_settings_profile_unification_summary" msgid="1317553536289481654">"Përdor 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="5163178097464820825">"Të përdoret një kyçje e vetme?"</string>
    <string name="lock_settings_profile_unification_dialog_body" msgid="1222905637428672355">"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="8844682343443755895">"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="6276915393736137843">"Përdor një kyçje të vetme"</string>
    <string name="lock_settings_profile_unification_dialog_uncompliant_confirm" msgid="8509287115116369677">"Përdor një kyçje të vetme"</string>
    <string name="lock_settings_profile_unified_summary" msgid="777095092175037385">"Njësoj si kyçja e ekranit të pajisjes"</string>
    <string name="manageapplications_settings_title" msgid="9198876415524237657">"Menaxho aplikacionet"</string>
    <string name="manageapplications_settings_summary" msgid="848586372489062357">"Menaxho dhe hiq aplikacionet e instaluara"</string>
    <string name="applications_settings" msgid="1941993743933425622">"Informacioni mbi aplikacionin"</string>
    <string name="applications_settings_summary" msgid="8206066893744768531">"Menaxho aplikacionet, konfiguro shkurtoret e hapjes së shpejtë"</string>
    <string name="applications_settings_header" msgid="3154670675856048015">"Cilësimet e apl."</string>
    <string name="install_applications" msgid="3921609656584369901">"Burime të panjohura"</string>
    <string name="install_applications_title" msgid="7890233747559108106">"Lejo të gjitha burimet e apl."</string>
    <string name="recent_app_category_title" msgid="189758417804427533">"Aplikacionet e hapura së fundi"</string>
    <plurals name="see_all_apps_title" formatted="false" msgid="6864581406735745400">
      <item quantity="other">Shiko të %1$d aplikacionet</item>
      <item quantity="one">Shiko të gjitha aplikacionet</item>
    </plurals>
    <string name="forgot_password_title" msgid="3967873480875239885">"Kontakto me administratorin e teknologjisë së informacionit"</string>
    <string name="forgot_password_text" msgid="2583194470767613163">"Ata mund të të ndihmojnë të rivendosësh kodin PIN, motivin ose fjalëkalimin"</string>
    <string name="install_all_warning" product="tablet" msgid="7010749217925069520">"Tableti dhe të dhënat e tua personale janë më të cenueshme nga sulmet nga aplikacione të panjohura. Duke instaluar aplikacionet nga ky burim, ti pranon se je përgjegjës për çdo dëm ndaj tabletit ose çdo humbje të të dhënave që mund të rezultojë nga përdorimi i tyre."</string>
    <string name="install_all_warning" product="default" msgid="652516435709047343">"Telefoni dhe të dhënat e tua personale janë më të cenueshme nga sulmet nga aplikacione të panjohura. Duke instaluar aplikacionet nga ky burim, ti pranon se je përgjegjës për çdo dëm ndaj telefonit ose çdo humbje të të dhënave që mund të rezultojë nga përdorimi i tyre."</string>
    <string name="install_all_warning" product="device" msgid="2348262609815354500">"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="2368905204839169094">"Cilësimet e përparuara"</string>
    <string name="advanced_settings_summary" msgid="1823765348195530035">"Aktivizo më shumë opsione të cilësimeve"</string>
    <string name="application_info_label" msgid="1015706497694165866">"Informacioni i apl."</string>
    <string name="storage_label" msgid="2522307545547515733">"Hapësira ruajtëse"</string>
    <string name="auto_launch_label" msgid="4069860409309364872">"Hap me parazgjedhje"</string>
    <string name="auto_launch_label_generic" msgid="5033137408273064599">"Parazgjedhjet"</string>
    <string name="screen_compatibility_label" msgid="7549658546078613431">"Përputhshmëria e ekranit"</string>
    <string name="permissions_label" msgid="1708927634370314404">"Lejet"</string>
    <string name="cache_header_label" msgid="2441967971921741047">"Memoria specifike"</string>
    <string name="clear_cache_btn_text" msgid="8597272828928143723">"Pastro memorien specifike"</string>
    <string name="cache_size_label" msgid="313456088966822757">"Memoria specifike"</string>
    <plurals name="uri_permissions_text" formatted="false" msgid="8212425823423508096">
      <item quantity="other">%d artikuj</item>
      <item quantity="one">1 artikull</item>
    </plurals>
    <string name="clear_uri_btn_text" msgid="4828117421162495134">"Qasje e pastër"</string>
    <string name="controls_label" msgid="8671492254263626383">"Kontrollet"</string>
    <string name="force_stop" msgid="2681771622136916280">"Ndalo me forcë"</string>
    <string name="total_size_label" msgid="2052185048749658866">"Totali"</string>
    <string name="application_size_label" msgid="6407051020651716729">"Madhësia e aplikacionit"</string>
    <string name="external_code_size_label" msgid="7375146402660973743">"Aplikacioni i hapësirës ruajtëse të USB-së"</string>
    <string name="data_size_label" msgid="7814478940141255234">"Të dhënat e përdoruesit"</string>
    <string name="external_data_size_label" product="nosdcard" msgid="1054860423004751290">"Të dhënat e hapësirës ruajtëse të USB-së"</string>
    <string name="external_data_size_label" product="default" msgid="3370825186202856353">"Karta SD"</string>
    <string name="uninstall_text" msgid="315764653029060126">"Çinstalo"</string>
    <string name="uninstall_all_users_text" msgid="5924715251087176474">"Çinstaloje për të gjithë përdoruesit"</string>
    <string name="install_text" msgid="4558333621516996473">"Instalo"</string>
    <string name="disable_text" msgid="5146002260857428005">"Çaktivizo"</string>
    <string name="enable_text" msgid="8570798764647110430">"Aktivizo"</string>
    <string name="clear_user_data_text" msgid="6773186434260397947">"Pastro hapësirën ruajtëse"</string>
    <string name="app_factory_reset" msgid="8974044931667015201">"Çinstalo përditësimet"</string>
    <string name="app_restricted_settings_lockscreen_title" msgid="5993061278264872648">"Lejo cilësimet e kufizuara"</string>
    <string name="auto_launch_enable_text" msgid="8912714475823807798">"Disa aktivitete që ke zgjedhur hapen në këtë aplikacion si parazgjedhje."</string>
    <string name="always_allow_bind_appwidgets_text" msgid="2069415023986858324">"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="502648841250936209">"Nuk ka parazgjedhje të caktuara."</string>
    <string name="clear_activities" msgid="488089228657585700">"Pastro preferencat e parazgjedhura"</string>
    <string name="screen_compatibility_text" msgid="5915767835411020274">"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="8388397595148476565">"Pyet kur të hapet"</string>
    <string name="enable_compatibility" msgid="1163387233622859712">"Shkallëzo aplikacionin"</string>
    <string name="unknown" msgid="8192160131923461175">"I panjohur"</string>
    <string name="sort_order_alpha" msgid="3400680865280266582">"Rendit sipas emrit"</string>
    <string name="sort_order_size" msgid="7731928486199737223">"Rendit sipas madhësisë"</string>
    <string name="sort_order_recent_notification" msgid="1496198895330443073">"Më të fundit"</string>
    <string name="sort_order_frequent_notification" msgid="4063700985742284794">"Më të shpeshta"</string>
    <string name="show_running_services" msgid="8666008279959853318">"Shfaq shërbimet që po ekzekutohen"</string>
    <string name="show_background_processes" msgid="5682856012453562151">"Shfaq proceset specifike"</string>
    <string name="default_emergency_app" msgid="1929974800666613803">"Aplikacioni i emergjencave"</string>
    <string name="reset_app_preferences" msgid="8861758340732716573">"Rivendos preferencat e apl."</string>
    <string name="reset_app_preferences_title" msgid="8935136792316050759">"Të rivendosen preferencat e aplikacionit?"</string>
    <string name="reset_app_preferences_desc" msgid="6509978724602405805">"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ë autorizimeve"</li>\n\n" Nuk do të humbësh asnjë të dhënë aplikacioni."</string>
    <string name="reset_app_preferences_button" msgid="2591318711372850058">"Rivendos aplikacionet"</string>
    <string name="manage_space_text" msgid="9013414693633572277">"Menaxho hapësirën"</string>
    <string name="filter" msgid="9039576690686251462">"Filtro"</string>
    <string name="filter_dlg_title" msgid="3086282431958601338">"Zgjidh opsionet e filtrit"</string>
    <string name="filter_apps_all" msgid="5705421199299914620">"Të gjitha aplikacionet"</string>
    <string name="filter_apps_disabled" msgid="5068011814871004105">"Aplikacionet e çaktivizuara"</string>
    <string name="filter_apps_third_party" msgid="9049447784849114843">"Të shkarkuara"</string>
    <string name="filter_apps_running" msgid="535465683273284141">"Vrapim"</string>
    <string name="filter_apps_onsdcard" product="nosdcard" msgid="5140211657134608469">"Hapësira ruajtëse e USB-së"</string>
    <string name="filter_apps_onsdcard" product="default" msgid="1774499644768369891">"Në kartën SD"</string>
    <string name="not_installed" msgid="5074606858798519449">"Nuk është i instaluar për këtë përdorues"</string>
    <string name="installed" msgid="2837449358488825884">"I instaluar"</string>
    <string name="no_applications" msgid="985069304755391640">"Asnjë aplikacion."</string>
    <string name="internal_storage" msgid="999496851424448809">"Hapësira e brendshme ruajtëse"</string>
    <string name="recompute_size" msgid="1098091228370999128">"Po llogarit përsëri madhësinë…"</string>
    <string name="clear_data_dlg_title" msgid="180446967743732410">"Të fshihen të dhënat e aplikacionit?"</string>
    <string name="clear_data_dlg_text" msgid="3440011276559762619">"Të dhënat e këtij aplikacioni, duke përfshirë skedarët dhe cilësimet, do të fshihen përgjithmonë nga kjo pajisje"</string>
    <string name="dlg_ok" msgid="1421350367857960997">"Në rregull"</string>
    <string name="dlg_cancel" msgid="5164705061530774899">"Anulo"</string>
    <string name="dlg_delete" msgid="1790919205039397659">"Fshi"</string>
    <string name="app_not_found_dlg_title" msgid="7122106240981109930"></string>
    <string name="app_not_found_dlg_text" msgid="8634675268730513704">"Aplikacioni nuk u gjet në listën e aplikacioneve të instaluara."</string>
    <string name="clear_failed_dlg_text" msgid="6866741916836125732">"Nuk mund të pastrohet hapësira për aplikacionin."</string>
    <string name="join_two_items" msgid="7893073836681382429">"<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="5301233410730513655">"<xliff:g id="FIRST_ITEM">%1$s</xliff:g>, <xliff:g id="SECOND_ITEM">%2$s</xliff:g>"</string>
    <string name="computing_size" msgid="4915310659841174866">"Po llogarit…"</string>
    <string name="invalid_size_value" msgid="7017371543563259201">"Madhësia e paketës nuk mund të llogaritej."</string>
    <string name="version_text" msgid="7628938665256107608">"versioni <xliff:g id="VERSION_NUM">%1$s</xliff:g>"</string>
    <string name="move_app" msgid="5421158479447276791">"Zhvendos"</string>
    <string name="move_app_to_internal" product="tablet" msgid="5799782476959541144">"Zhvendos te tableti"</string>
    <string name="move_app_to_internal" product="default" msgid="7395498801589544372">"Zhvendos te telefoni"</string>
    <string name="move_app_to_sdcard" product="nosdcard" msgid="1145367822171576972">"Zhvendose në USB"</string>
    <string name="move_app_to_sdcard" product="default" msgid="7161667212614143767">"Zhvendos te karta SD"</string>
    <string name="another_migration_already_in_progress" msgid="6550546307856052261">"Një migrim tjetër është tashmë në vazhdim."</string>
    <string name="insufficient_storage" msgid="8115088042669030558">"Nuk ka hapësirë ruajtëse të mjaftueshme."</string>
    <string name="does_not_exist" msgid="6499163879348776120">"Aplikacioni nuk ekziston."</string>
    <string name="invalid_location" msgid="8013853455355520557">"Vendndodhja e instalimit nuk është e vlefshme."</string>
    <string name="system_package" msgid="7559476279008519360">"Përditësimet e sistemit nuk mund të instalohen në median e jashtme."</string>
    <string name="move_error_device_admin" msgid="1561502976834303626">"Aplikacioni i administrimit të pajisjes nuk mund të instalohet në media të jashtme"</string>
    <string name="force_stop_dlg_title" msgid="86745852555490146">"Të ndalohet me forcë?"</string>
    <string name="force_stop_dlg_text" msgid="1527286468544457368">"Nëse e ndalon me forcë një aplikacion, ai mund të përjetojë çrregullime në funksionim."</string>
    <string name="app_install_location_title" msgid="8932938164156303191">"Vendndodhja e preferuar e instalimit"</string>
    <string name="app_install_location_summary" msgid="4948270795544357021">"Ndrysho vendndodhjen e preferuar të instalimit për aplikacione të reja"</string>
    <string name="app_disable_dlg_positive" msgid="1414218905322009505">"Çaktivizo aplikacionin"</string>
    <string name="app_disable_dlg_text" msgid="2449382902751908916">"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="6686569904059411780">"Të çaktivizohen njoftimet?"</string>
    <string name="app_install_details_group_title" msgid="1172114479073704677">"Dyqani"</string>
    <string name="app_install_details_title" msgid="7783556181897142187">"Detajet e aplikacioneve"</string>
    <string name="app_install_details_summary" msgid="2013043219249992373">"Aplikacioni i instaluar nga <xliff:g id="APP_STORE">%1$s</xliff:g>"</string>
    <string name="instant_app_details_summary" msgid="417197491598208216">"Më shumë informacion rreth <xliff:g id="APP_STORE">%1$s</xliff:g>"</string>
    <string name="app_ops_running" msgid="6127474473137428721">"Në funksionim"</string>
    <string name="app_ops_never_used" msgid="9038133162371204506">"(Nuk përdoret asnjëherë)"</string>
    <string name="no_default_apps" msgid="8966319676910104570">"Asnjë apl. i parazgjedhur"</string>
    <string name="storageuse_settings_title" msgid="3125650750657988194">"Përdorimi i hapësirës ruajtëse"</string>
    <string name="storageuse_settings_summary" msgid="5001621552305431831">"Shiko hapësirën për ruajtje të përdorur nga aplikacionet"</string>
    <string name="service_restarting" msgid="5104563288155809226">"Po rinis..."</string>
    <string name="cached" msgid="5379485147573438201">"Procesi në sfond i ruajtur në memorien specifike"</string>
    <string name="no_running_services" msgid="9079738069349859373">"Nuk po ekzekutohet asgjë."</string>
    <string name="service_started_by_app" msgid="6845028506417670179">"U nis nga aplikacioni."</string>
    <!-- no translation found for service_client_name (2210898622981598861) -->
    <skip />
    <string name="service_background_processes" msgid="2800539421534521948">"<xliff:g id="MEMORY">%1$s</xliff:g> të lira"</string>
    <string name="service_foreground_processes" msgid="6380905887193621704">"<xliff:g id="MEMORY">%1$s</xliff:g> përdorur"</string>
    <string name="memory" msgid="5253757199926592074">"RAM"</string>
    <!-- no translation found for service_process_name (7827318358399776412) -->
    <skip />
    <string name="running_process_item_user_label" msgid="1444898861984132133">"Përdoruesi: <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="running_process_item_removed_user_label" msgid="4812732296696662613">"Përdorues i hequr"</string>
    <string name="running_processes_item_description_s_s" msgid="6835918861352501671">"<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="1209371773353932361">"<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="8957061449107822282">"<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="3292999232897469679">"<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="558961782589967366">"Memoria e pajisjes"</string>
    <string name="running_processes_header_footer" msgid="2726092156680487584">"Përdorimi i RAM-it nga aplikacionet"</string>
    <string name="running_processes_header_system_prefix" msgid="8819527769608555124">"Sistemi"</string>
    <string name="running_processes_header_apps_prefix" msgid="4151874328324238133">"Aplikacionet"</string>
    <string name="running_processes_header_free_prefix" msgid="4271100378295864738">"E lirë"</string>
    <string name="running_processes_header_used_prefix" msgid="5205762402234243007">"Në përdorim"</string>
    <string name="running_processes_header_cached_prefix" msgid="839132595831993521">"Në memorien specifike"</string>
    <string name="running_processes_header_ram" msgid="3014991380467004685">"<xliff:g id="RAM_0">%1$s</xliff:g> nga RAM-i"</string>
    <string name="runningservicedetails_settings_title" msgid="1057845389092757121">"Aplikacioni në ekzekutim"</string>
    <string name="no_services" msgid="3898812785511572899">"Jo aktiv"</string>
    <string name="runningservicedetails_services_title" msgid="11853795112787355">"Shërbimet"</string>
    <string name="runningservicedetails_processes_title" msgid="5292271587797234038">"Proceset"</string>
    <string name="service_stop" msgid="5712522600201308795">"Ndalo"</string>
    <string name="service_manage" msgid="3896322986828332075">"Cilësimet"</string>
    <string name="service_stop_description" msgid="6327742632400026677">"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="3086419998820881290">"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="4792038933517438037">"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="6615788996428486121">"<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="6685973937935027773">"Procesi kryesor është në përdorim."</string>
    <string name="process_service_in_use_description" msgid="4210957264507014878">"Shërbimi <xliff:g id="COMP_NAME">%1$s</xliff:g> është në përdorim."</string>
    <string name="process_provider_in_use_description" msgid="6730020083976048028">"Ofruesi <xliff:g id="COMP_NAME">%1$s</xliff:g> është në përdorim."</string>
    <string name="runningservicedetails_stop_dlg_title" msgid="6201041461740445113">"Të ndalohet shërbimi i sistemit?"</string>
    <string name="runningservicedetails_stop_dlg_text" product="tablet" msgid="2076922609580490122">"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="2625863973434309085">"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="3292455685728572960">"Gjuhët, hyrja dhe gjestet"</string>
    <string name="language_input_gesture_summary_on_with_assist" msgid="8670153838520237089"></string>
    <string name="language_input_gesture_summary_on_non_assist" msgid="2738661322747920463"></string>
    <string name="language_input_gesture_summary_off" msgid="1604575860215661606"></string>
    <string name="language_settings" msgid="8700174277543875046">"Gjuhët dhe metodat e hyrjes"</string>
    <string name="language_empty_list_user_restricted" msgid="8050367405839231863">"Nuk ke leje të ndryshosh gjuhën e pajisjes."</string>
    <string name="language_keyboard_settings_title" msgid="7934844313233544557">"Gjuhët dhe metodat e hyrjes"</string>
    <string name="input_assistance" msgid="3437568284144952104">"Veglat"</string>
    <string name="keyboard_settings_category" msgid="5392847229300117064">"Tastiera dhe metodat e hyrjes"</string>
    <string name="phone_language" msgid="5986939176239963826">"Gjuhët"</string>
    <string name="phone_language_summary" msgid="863041222809685325"></string>
    <string name="auto_replace" msgid="4830732960264447043">"Zëvendëso automatikisht"</string>
    <string name="auto_replace_summary" msgid="1285443414597153423">"Korrigjo fjalët e shkruara gabim"</string>
    <string name="auto_caps" msgid="5573583581288305355">"Kapitalizim automatik"</string>
    <string name="auto_caps_summary" msgid="3144141933426846665">"Filloji fjalitë me shkronjë të madhe"</string>
    <string name="auto_punctuate" msgid="2838809477621809507">"Vendos automatikisht pikësimin"</string>
    <string name="hardkeyboard_category" msgid="8729780593378161071">"Cilësimet e tastierës fizike"</string>
    <string name="auto_punctuate_summary" msgid="3549190848611386748">"Shtyp dy herë tastin Hapësirë për të futur \".\""</string>
    <string name="show_password" msgid="7101900779571040117">"Shfaq fjalëkalimet"</string>
    <string name="show_password_summary" msgid="9025960283785111619">"Shfaq karakteret shkurtimisht kur shkruan"</string>
    <string name="spellchecker_security_warning" msgid="2016059050608271820">"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="6449414356743946577">"Cilësimet"</string>
    <string name="spellchecker_language" msgid="8905487366580285282">"Gjuha"</string>
    <string name="keyboard_and_input_methods_category" msgid="5296847777802891649">"Tastierat"</string>
    <string name="virtual_keyboard_category" msgid="2339505603075527212">"Tastiera në ekran"</string>
    <string name="keywords_virtual_keyboard" msgid="1494726424879503434">"Gboard"</string>
    <string name="available_virtual_keyboard_category" msgid="6930012948152749337">"Ofrohet tastiera në ekran"</string>
    <string name="add_virtual_keyboard" msgid="2515850206289352606">"Menaxho tastierat në ekran"</string>
    <string name="keyboard_assistance_category" msgid="7320599809770932032">"Asistenca e tastierës"</string>
    <string name="physical_keyboard_title" msgid="3328134097512350958">"Tastiera fizike"</string>
    <string name="show_ime" msgid="4334255501724746849">"Përdor tastierën në ekran"</string>
    <string name="show_ime_summary" msgid="7293345791727205975">"Mbaje në ekran ndërsa tastiera fizike është aktive"</string>
    <string name="keyboard_shortcuts_helper" msgid="2553221039203165344">"Shkurtoret e tastierës"</string>
    <string name="keyboard_shortcuts_helper_summary" msgid="8649760728213630156">"Shfaq shkurtoret e disponueshme"</string>
    <string name="language_and_input_for_work_category_title" msgid="2546950919124199743">"Tastierat dhe veglat e profilit të punës"</string>
    <string name="virtual_keyboards_for_work_title" msgid="786459157034008675">"Tastiera në ekran për punën"</string>
    <string name="default_keyboard_layout" msgid="8690689331289452201">"E parazgjedhur"</string>
    <string name="speech_category_title" msgid="5995161659186229742">"Ligjërimi"</string>
    <string name="pointer_speed" msgid="7398649279282675718">"Shpejtësia e treguesit"</string>
    <string name="game_controller_settings_category" msgid="8557472715034961918">"Kontrolluesi i lojës"</string>
    <string name="vibrate_input_devices" msgid="5192591087864449142">"Ridrejto dridhjen"</string>
    <string name="vibrate_input_devices_summary" msgid="8791680891376689823">"Dërgoji dridhjet te kontrolluesi i lojës kur të lidhet"</string>
    <string name="keyboard_layout_dialog_title" msgid="8770130364048089954">"Zgjidh planin e tastierës"</string>
    <string name="keyboard_layout_dialog_setup_button" msgid="6546245862744626706">"Konfiguro planet e tastierës"</string>
    <string name="keyboard_layout_dialog_switch_hint" msgid="3303564123674979354">"Për kalimin, shtyp \"Kontroll\" dhe \"Hapësirë\""</string>
    <string name="keyboard_layout_default_label" msgid="6078569989261528039">"E parazgjedhur"</string>
    <string name="keyboard_layout_picker_title" msgid="240504762718562906">"Planet e tastierës"</string>
    <string name="user_dict_settings_title" msgid="680410651924276991">"Fjalori personal"</string>
    <string name="user_dict_settings_for_work_title" msgid="1245315720684961770">"Fjalori personal për punë"</string>
    <string name="user_dict_settings_summary" msgid="4939694372338975081">"Shto fjalë për t\'u përdorur në aplikacione si \"Drejtshkrimori\""</string>
    <string name="user_dict_settings_add_menu_title" msgid="8046882347281382968">"Shto"</string>
    <string name="user_dict_settings_add_dialog_title" msgid="3485845465134083084">"Shto në fjalor"</string>
    <string name="user_dict_settings_add_screen_title" msgid="1866408024073475379">"Fraza"</string>
    <string name="user_dict_settings_add_dialog_more_options" msgid="2642928746425808108">"Opsione të tjera"</string>
    <string name="user_dict_settings_add_dialog_less_options" msgid="100432503633458156">"Më pak opsione"</string>
    <string name="user_dict_settings_add_dialog_confirm" msgid="1866751313790655088">"Në rregull"</string>
    <string name="user_dict_settings_add_word_option_name" msgid="2686051785623698231">"Fjala:"</string>
    <string name="user_dict_settings_add_shortcut_option_name" msgid="5722204336242646866">"Shkurtorja:"</string>
    <string name="user_dict_settings_add_locale_option_name" msgid="2117468247460253346">"Gjuha:"</string>
    <string name="user_dict_settings_add_word_hint" msgid="4560494723256242785">"Shkruaj një fjalë"</string>
    <string name="user_dict_settings_add_shortcut_hint" msgid="6209624157217434640">"Shkurtore opsionale"</string>
    <string name="user_dict_settings_edit_dialog_title" msgid="316493656442362284">"Redakto fjalën"</string>
    <string name="user_dict_settings_context_menu_edit_title" msgid="4909198741914531509">"Redakto"</string>
    <string name="user_dict_settings_context_menu_delete_title" msgid="651550824433043545">"Fshi"</string>
    <string name="user_dict_settings_empty_text" msgid="86562873609647919">"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="8563387437755363526">"Për të gjitha gjuhët"</string>
    <string name="user_dict_settings_more_languages" msgid="5378870726809672319">"Gjuhë të tjera…"</string>
    <string name="testing" msgid="6294172343766732037">"Testimi"</string>
    <string name="testing_phone_info" product="tablet" msgid="1910768200608214456">"Informacion për tabletin"</string>
    <string name="testing_phone_info" product="default" msgid="1150527695827743906">"Informacioni i telefonit"</string>
    <string name="input_methods_settings_title" msgid="7796027458321225550">"Hyrjet e tekstit"</string>
    <string name="input_method" msgid="2982805181425436775">"Metoda e hyrjes"</string>
    <string name="current_input_method" msgid="3471068842881330883">"Tastiera aktuale"</string>
    <string name="input_method_selector" msgid="8463209725824763600">"Fut përzgjedhësin e metodës"</string>
    <string name="input_method_selector_show_automatically_title" msgid="6483428482089875034">"Automatik"</string>
    <string name="input_method_selector_always_show_title" msgid="2479533500357556146">"Shfaq gjithmonë"</string>
    <string name="input_method_selector_always_hide_title" msgid="807424180027384849">"Fshih gjithmonë"</string>
    <string name="configure_input_method" msgid="8831343065130376880">"Konfiguro metodat e hyrjes"</string>
    <string name="input_method_settings" msgid="4177883733022569830">"Cilësimet"</string>
    <string name="input_method_settings_button" msgid="5145039044301426311">"Cilësimet"</string>
    <string name="input_methods_settings_label_format" msgid="5809693308957109022">"Cilësimet e <xliff:g id="IME_NAME">%1$s</xliff:g>"</string>
    <string name="input_methods_and_subtype_enabler_title" msgid="8940326108334307057">"Zgjidh metodat aktive të hyrjes"</string>
    <string name="onscreen_keyboard_settings_summary" msgid="3975358507879701606">"Cilësimet e tastierës në ekran"</string>
    <string name="builtin_keyboard_settings_title" msgid="5096171620714179661">"Tastiera fizike"</string>
    <string name="builtin_keyboard_settings_summary" msgid="4332792334499933856">"Cilësimet e tastierës fizike"</string>
    <string name="gadget_picker_title" msgid="7615902510050731400">"Zgjidh veglën"</string>
    <string name="widget_picker_title" msgid="7641298325488989676">"Zgjidh miniprogramin"</string>
    <string name="allow_bind_app_widget_activity_allow_bind_title" msgid="3537968409832846255">"Të krijohet miniaplikacion dhe të lejohet qasja në të?"</string>
    <string name="allow_bind_app_widget_activity_allow_bind" msgid="5825298768068148804">"Pasi të krijosh miniaplikacionin, aplikacioni mund të ketë qasje në gjithçka që shfaqet.\n\nAplikacioni: <xliff:g id="WIDGET_HOST_NAME">%1$s</xliff:g>\nMiniaplikacioni: <xliff:g id="WIDGET_LABEL">%2$s</xliff:g>\n"</string>
    <string name="allow_bind_app_widget_activity_always_allow_bind" msgid="7268758525344468364">"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="6523644917803320085">"Statistikat e përdorimit"</string>
    <string name="testing_usage_stats" msgid="4660643799010906365">"Statistikat e përdorimit"</string>
    <string name="display_order_text" msgid="7120394778684605892">"Rendit sipas:"</string>
    <string name="app_name_label" msgid="3809910527680143673">"Aplikacioni"</string>
    <string name="last_time_used_label" msgid="2639712813493534074">"Përdorur për herë të fundit"</string>
    <string name="usage_time_label" msgid="9105343335151559883">"Koha e përdorimit"</string>
    <string name="accessibility_settings" msgid="4713215774904704682">"Qasshmëria"</string>
    <string name="accessibility_settings_title" msgid="6739115703615065716">"Cilësimet e qasjes"</string>
    <string name="accessibility_settings_summary" msgid="2366627644570558503">"Ekrani, ndërveprimi, audioja"</string>
    <string name="vision_settings_title" msgid="8919983801864103069">"Cilësimet e shikimit"</string>
    <string name="vision_settings_description" msgid="7614894785054441991">"Mund ta personalizosh këtë pajisje për t\'iu përshtatur nevojave të tua. Këto veçori të qasshmërisë mund të ndryshohen më vonë te \"Cilësimet\"."</string>
    <string name="vision_settings_suggestion_title" msgid="4689275412658803919">"Ndrysho madhësinë e shkrimit"</string>
    <string name="screen_reader_category_title" msgid="5825700839731107803">"Lexuesi i ekranit"</string>
    <string name="captions_category_title" msgid="574490148949400274">"Titrat"</string>
    <string name="audio_category_title" msgid="5283853679967605826">"Audio"</string>
    <string name="general_category_title" msgid="6298579528716834157">"Të përgjithshme"</string>
    <string name="display_category_title" msgid="6638191682294461408">"Ekrani"</string>
    <string name="accessibility_color_and_motion_title" msgid="2323301706545305874">"Ngjyra dhe lëvizja"</string>
    <string name="accessibility_turn_screen_darker_title" msgid="5986223133285858349">"Bëj ekranin më të errët"</string>
    <string name="interaction_control_category_title" msgid="2696474616743882372">"Kontrollet e ndërveprimeve"</string>
    <string name="accessibility_tap_assistance_title" msgid="1058913033421048284">"Kontrollet në lidhje me kohën"</string>
    <string name="accessibility_system_controls_title" msgid="6403287349518987624">"Kontrollet e sistemit"</string>
    <string name="user_installed_services_category_title" msgid="2639470729311439731">"Aplikacionet e shkarkuara"</string>
    <string name="experimental_category_title" msgid="898904396646344152">"Eksperimentale"</string>
    <string name="feature_flags_dashboard_title" msgid="348990373716658289">"Raportimet e veçorive"</string>
    <string name="talkback_title" msgid="8756080454514251327">"Talkback"</string>
    <string name="talkback_summary" msgid="5820927220378864281">"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="1995285446766920925">"Trokit artikujt në ekran për t\'i dëgjuar të lexuar me zë të lartë"</string>
    <string name="accessibility_captioning_title" msgid="4561871958958925225">"Preferencat e titrave"</string>
    <string name="accessibility_captioning_about_title" msgid="3542171637334191563">"Rreth preferencave për titrat"</string>
    <string name="accessibility_captioning_footer_learn_more_content_description" msgid="5730040700677017706">"Mëso më shumë rreth preferencave për titrat"</string>
    <string name="accessibility_screen_magnification_title" msgid="1211169976144629087">"Zmadhimi"</string>
    <string name="accessibility_screen_magnification_shortcut_title" msgid="2387963646377987780">"Shkurtorja e zmadhimit"</string>
    <string name="accessibility_screen_magnification_follow_typing_title" msgid="6379517513916651560">"Zmadho shkrimin"</string>
    <string name="accessibility_screen_magnification_follow_typing_summary" msgid="2882250257391761678">"Zmadhuesi ndjek tekstin ndërsa shkruan"</string>
    <string name="accessibility_screen_magnification_about_title" msgid="8857919020223505415">"Rreth zmadhimit"</string>
    <string name="accessibility_screen_magnification_footer_learn_more_content_description" msgid="924848332575978463">"Mëso më shumë rreth zmadhimit"</string>
    <string name="accessibility_magnification_mode_title" msgid="8446475127807168063">"Lloji i zmadhimit"</string>
    <string name="accessibility_magnification_area_settings_message" msgid="8498648925928109462">"Zmadho ekranin tënd të plotë, një zonë specifike ose kalo mes dy opsioneve."</string>
    <string name="accessibility_magnification_area_settings_full_screen_summary" msgid="2728962784113713010">"Ekrani i plotë"</string>
    <string name="accessibility_magnification_area_settings_window_screen_summary" msgid="9191632962955877019">"Ekrani i pjesshëm"</string>
    <string name="accessibility_magnification_area_settings_all_summary" msgid="8107511976748799455">"Kalo mes ekranit të plotë dhe të pjesshëm"</string>
    <string name="accessibility_magnification_mode_dialog_title" msgid="9151027667059878578">"Zgjidh se si do të zmadhosh"</string>
    <string name="accessibility_magnification_mode_dialog_option_full_screen" msgid="4892487869954032029">"Zmadho në ekranin e plotë"</string>
    <string name="accessibility_magnification_mode_dialog_option_window" msgid="4492443201099153362">"Zmadho një pjesë të ekranit"</string>
    <string name="accessibility_magnification_mode_dialog_option_switch" msgid="561043521011229424">"Kalo mes ekranit të plotë dhe të pjesshëm"</string>
    <string name="accessibility_magnification_area_settings_mode_switch_summary" msgid="2885238806099080966">"Trokit te butoni i ndërrimit për të kaluar nga njëri opsion te tjetri"</string>
    <string name="accessibility_magnification_switch_shortcut_title" msgid="3671432048806533079">"Të kalohet te butoni i qasshmërisë?"</string>
    <string name="accessibility_magnification_switch_shortcut_message" msgid="7718653917415163833">"Përdorimi i trokitjes së trefishtë për të zmadhuar një pjesë të ekranit shkakton vonesa gjatë shkrimit dhe të tjera.\n\nButoni i qasshmërisë pluskon në ekranin tënd mbi aplikacionet e tjera. Trokite për ta zmadhuar."</string>
    <string name="accessibility_magnification_switch_shortcut_positive_button" msgid="2446942190957296957">"Kalo te butoni i qasshmërisë"</string>
    <string name="accessibility_magnification_switch_shortcut_negative_button" msgid="7115794462123071594">"Përdor trokitjen e trefishtë"</string>
    <string name="accessibility_magnification_triple_tap_warning_title" msgid="8484669851397296597">"Kjo mund ta ngadalësojë tastierën"</string>
    <string name="accessibility_magnification_triple_tap_warning_message" msgid="2008671502848936410">"Kur troket tri herë për të zmadhuar një pjesë të ekranit, mund të vësh re probleme me tastierën.\n\nPër ta shmangur këtë, mund ta ndryshosh shkurtoren e zmadhimit nga tri trokitje në një opsion tjetër.\n"<annotation id="link">"Ndrysho cilësimin"</annotation></string>
    <string name="accessibility_magnification_triple_tap_warning_positive_button" msgid="8712304035901450010">"Vazhdo gjithsesi"</string>
    <string name="accessibility_magnification_triple_tap_warning_negative_button" msgid="2028849736366584733">"Anulo"</string>
    <string name="accessibility_magnification_service_settings_title" msgid="3531350704632316017">"Cilësimet e zmadhimit"</string>
    <string name="accessibility_screen_magnification_gestures_title" msgid="3121714118381882167">"Zmadho me tre trokitje"</string>
    <string name="accessibility_screen_magnification_navbar_title" msgid="480853328665484528">"Zmadho me shkurtore"</string>
    <string name="accessibility_screen_magnification_state_navbar_gesture" msgid="8067042663897802231">"Zmadho me shkurtore dhe tri trokitje"</string>
    <string name="accessibility_introduction_title" msgid="8834950581512452348">"Rreth \"<xliff:g id="SERVICE">%1$s</xliff:g>\""</string>
    <string name="accessibility_text_reading_options_title" msgid="3224648909213325563">"Madhësia e ekranit dhe teksti"</string>
    <string name="accessibility_text_reading_options_suggestion_title" msgid="2492155642665312733">"Ndrysho mënyrën se si shfaqet teksti"</string>
    <string name="accessibility_text_reading_preview_mail_subject" msgid="4597374768612733616">"Subjekti: Dizajnet e balonave"</string>
    <string name="accessibility_text_reading_preview_mail_from" msgid="1797499780365288020">"Nga: Bill"</string>
    <string name="accessibility_text_reading_preview_mail_content" msgid="8078152365771951802">"Mirëmëngjesi!\n\nDoja vetëm të kontrolloja se si po shkon puna me dizajnet. A do të jenë gati përpara se të fillojmë të ndërtojmë balonat e reja?"</string>
    <string name="accessibility_text_reading_reset_button_title" msgid="5960753279788187669">"Rivendos cilësimet"</string>
    <string name="accessibility_text_reading_reset_message" msgid="824644303661026712">"Cilësimet e madhësisë së ekranit dhe tekstit janë rivendosur"</string>
    <string name="accessibility_text_reading_confirm_dialog_title" msgid="2865331351355690389">"Të rivendosen madhësia e ekranit dhe teksti?"</string>
    <string name="accessibility_text_reading_confirm_dialog_message" msgid="517090197003540264">"Preferencat e tua për madhësinë e ekranit dhe tekstin do të rivendosen në cilësimet origjinale të telefonit"</string>
    <string name="accessibility_text_reading_confirm_dialog_reset_button" msgid="8215800137850243736">"Rivendos"</string>
    <string name="accessibility_text_reading_conversation_message_1" msgid="7883952203831957831">"Ke plane për fundjavën?"</string>
    <string name="accessibility_text_reading_conversation_message_2" msgid="8112160435318635856">"Mendoj të shkoj në plazh. Dëshiron të më bashkohesh?"</string>
    <string name="accessibility_screen_option" msgid="8465307075278878145">"Opsionet"</string>
    <string name="accessibility_preference_magnification_summary" msgid="2875518904115896888">"Zmadho ekranin"</string>
    <string name="accessibility_screen_magnification_short_summary" msgid="2207048420669939150">"Trokit 3 herë për ta zmadhuar"</string>
    <string name="accessibility_screen_magnification_navbar_short_summary" msgid="4885018322430052037">"Trokit te një buton për të zmadhuar"</string>
    <string name="accessibility_screen_magnification_intro_text" msgid="3856180549393526339">"Zmadho me shpejtësi në ekran për ta bërë përmbajtjen më të madhe"</string>
    <string name="accessibility_screen_magnification_summary" msgid="8267672508057326959">"&lt;b&gt;Për të zmadhuar:&lt;/b&gt;&lt;br/&gt; {0,number,integer}. Përdor shkurtoren për të filluar zmadhimin&lt;br/&gt; {1,number,integer}. Trokit në ekran&lt;br/&gt; {2,number,integer}. Zvarrit 2 gishta për të lëvizur nëpër ekran&lt;br/&gt; {3,number,integer}. Bashko 2 gishta për të rregulluar zmadhimin&lt;br/&gt; {4,number,integer}. Përdor shkurtoren për të ndaluar zmadhimin&lt;br/&gt;&lt;br/&gt;&lt;b&gt;Për ta zmadhuar përkohësisht:&lt;/b&gt;&lt;br/&gt; {0,number,integer}. Sigurohu që lloji i zmadhimit të jetë caktuar në ekran të plotë&lt;br/&gt; {1,number,integer}. Përdor shkurtoren për të filluar zmadhimin&lt;br/&gt; {2,number,integer}. Prek dhe mbaj shtypur diku në ekran&lt;br/&gt; {3,number,integer}. Zvarrit gishtin për të lëvizur nëpër ekran&lt;br/&gt; {4,number,integer}. Ngrije gishtin për të ndaluar zmadhimin"</string>
    <string name="accessibility_screen_magnification_navbar_summary" msgid="807985499898802296">"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>"Afro 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 dhe më pas prek dhe mbaj të shtypur diku në ekran.\n"<ul><li>"Zvarrit për të lëvizur nëpër ekran"</li>\n<li>"Ngri gishtin për të zvogëluar"</li></ul>\n\n"Nuk mund të zmadhosh te tastiera ose shiriti i navigimit."</string>
    <string name="accessibility_tutorial_pager" msgid="8461939455728454061">"Faqja <xliff:g id="CURRENT_PAGE">%1$d</xliff:g> nga <xliff:g id="NUM_PAGES">%2$d</xliff:g>"</string>
    <string name="accessibility_tutorial_dialog_title_button" msgid="4681164949716215131">"Përdor butonin e qasshmërisë për të hapur"</string>
    <string name="accessibility_tutorial_dialog_title_volume" msgid="494810949830845234">"Mbaj shtypur tastet e volumit për ta hapur"</string>
    <string name="accessibility_tutorial_dialog_title_triple" msgid="7089562919284464400">"Trokit tri herë në ekran për ta hapur"</string>
    <string name="accessibility_tutorial_dialog_title_gesture" msgid="4965810097646659332">"Përdor gjestin për të hapur"</string>
    <string name="accessibility_tutorial_dialog_title_gesture_settings" msgid="6800684770875867559">"Përdor gjestin e qasshmërisë"</string>
    <string name="accessibility_tutorial_dialog_message_button" msgid="7002398857479782303">"Për ta përdorur këtë veçori, trokit te butoni i qasshmërisë <xliff:g id="ACCESSIBILITY_ICON">%s</xliff:g> në fund të ekranit.\n\nPër të ndërruar mes veçorive, mbaj të shtypur butonin e qasshmërisë."</string>
    <string name="accessibility_tutorial_dialog_message_floating_button" msgid="2551777208185138391">"Për të përdorur këtë veçori, trokit te butoni i qasshmërisë në ekranin tënd."</string>
    <string name="accessibility_tutorial_dialog_message_volume" msgid="5033080515460519183">"Për ta përdorur këtë veçori, mbaj shtypur të dyja tastet e volumit."</string>
    <string name="accessibility_tutorial_dialog_message_triple" msgid="5219991116201165146">"Për të filluar dhe ndaluar zmadhimin, trokit tri herë diku në ekran."</string>
    <string name="accessibility_tutorial_dialog_message_gesture" msgid="4148062210755434854">"Për ta përdorur këtë veçori, rrëshqit shpejt lart nga fundi i ekranit me 2 gishta.\n\nPër të ndërruar mes veçorive, rrëshqit shpejt lart me 2 gishta dhe mbaje të shtypur."</string>
    <string name="accessibility_tutorial_dialog_message_gesture_talkback" msgid="8142847782708562793">"Për ta përdorur këtë veçori, rrëshqit shpejt lart nga fundi i ekranit me 3 gishta.\n\nPër të ndërruar mes veçorive, rrëshqit shpejt lart me 3 gishta dhe mbaje të shtypur."</string>
    <string name="accessibility_tutorial_dialog_message_gesture_settings" msgid="40769674586981429">"Për të përdorur një veçori të qasshmërisë, rrëshqit shpejt lart nga fundi i ekranit me 2 gishta.\n\nPër të ndërruar mes veçorive, rrëshqit shpejt lart me 2 gishta dhe mbaje të shtypur."</string>
    <string name="accessibility_tutorial_dialog_message_gesture_settings_talkback" msgid="7292969929578621958">"Për të përdorur një veçori të qasshmërisë, rrëshqit shpejt lart nga fundi i ekranit me 3 gishta.\n\nPër të ndërruar mes veçorive, rrëshqit shpejt lart me 3 gishta dhe mbaje të shtypur."</string>
    <string name="accessibility_tutorial_dialog_button" msgid="2031773187678948436">"E kuptova"</string>
    <string name="accessibility_shortcut_title" msgid="8125867833704517463">"Shkurtorja për \"<xliff:g id="SERVICE">%1$s</xliff:g>\""</string>
    <string name="accessibility_shortcut_edit_summary_software" msgid="6405629977940618205">"Butoni i qasshmërisë"</string>
    <string name="accessibility_shortcut_edit_summary_software_gesture" msgid="5489284264414421286">"Gjesti i qasshmërisë"</string>
    <string name="accessibility_shortcut_edit_dialog_title_software_gesture" msgid="8078659880723370597">"Rrëshqit lart me 2 gishta"</string>
    <string name="accessibility_shortcut_edit_dialog_title_software_gesture_talkback" msgid="7422753388389160524">"Rrëshqit lart me 3 gishta"</string>
    <string name="accessibility_shortcut_edit_dialog_title_software" msgid="4796192466943479849">"Trokit mbi butonin e qasshmërisë"</string>
    <string name="accessibility_shortcut_edit_dialog_title_software_by_gesture" msgid="3981188764050497346">"Përdor gjestin e qasshmërisë"</string>
    <string name="accessibility_shortcut_edit_dialog_summary_software" msgid="5606196352833449600">"Trokit mbi butonin e qasshmërisë <xliff:g id="ACCESSIBILITY_ICON">%s</xliff:g> në fund të ekranit.\n\nPër të kaluar mes veçorive, prek dhe mbaj prekur butonin e qasshmërisë."</string>
    <string name="accessibility_shortcut_edit_dialog_summary_software_gesture" msgid="8292555254353761635">"Rrëshqit shpejt lart nga fundi i ekranit me 2 gishta.\n\nPër të kaluar mes veçorive, rrëshqit shpejt lart me 2 gishta dhe mbaje të shtypur."</string>
    <string name="accessibility_shortcut_edit_dialog_summary_software_gesture_talkback" msgid="84483464524360845">"Rrëshqit shpejt lart nga fundi i ekranit me 3 gishta.\n\nPër të kaluar mes veçorive, rrëshqit shpejt lart me 3 gishta dhe mbaje të shtypur."</string>
    <string name="accessibility_shortcut_edit_dialog_summary_software_floating" msgid="4459254227203203324"><annotation id="link">"Opsione të tjera"</annotation></string>
    <string name="footer_learn_more_content_description" msgid="8843798273152131341">"Mëso më shumë për <xliff:g id="SERVICE">%1$s</xliff:g>"</string>
    <string name="accessibility_shortcut_edit_dialog_title_hardware" msgid="2356853121810443026">"Mbaj butonat e volumit"</string>
    <string name="accessibility_shortcut_hardware_keyword" msgid="3921915304537166064">"mbaj butonat e volumit"</string>
    <string name="accessibility_shortcut_edit_dialog_summary_hardware" msgid="2503134386397991634">"Shtyp dhe mbaj shtypur të dy butonat e volumit"</string>
    <string name="accessibility_shortcut_edit_dialog_title_triple_tap" msgid="6672798007229795841">"Trokit tri herë mbi ekran"</string>
    <string name="accessibility_shortcut_triple_tap_keyword" msgid="6863958573135995927">"trokit tri herë mbi ekran"</string>
    <string name="accessibility_shortcut_edit_dialog_summary_triple_tap" msgid="2102327956423320536">"Trokit me shpejtësi {0,number,integer} herë në ekran. Kjo shkurtore mund të ngadalësojë pajisjen tënde"</string>
    <string name="accessibility_shortcut_edit_dialog_title_advance" msgid="4567868630655591506">"Të përparuara"</string>
    <string name="accessibility_screen_magnification_navbar_configuration_warning" msgid="266736851606791552">"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="991017769735632046">"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="3713636732641882959">"Shkurtorja e tastit të volumit"</string>
    <string name="accessibility_shortcut_service_title" msgid="6842883700702723355">"Shërbimi i shkurtores"</string>
    <string name="accessibility_shortcut_settings" msgid="836783442658447995">"Cilësimet e shkurtores"</string>
    <string name="accessibility_shortcut_service_on_lock_screen_title" msgid="3923122834058574478">"Shkurtorja nga ekrani i kyçjes"</string>
    <string name="accessibility_shortcut_description" msgid="2184693606202133549">"Lejo që shkurtorja e veçorisë të aktivizohet nga ekrani i kyçjes. Mbaji të dy çelësat e volumit për disa sekonda."</string>
    <string name="accessibility_button_title" msgid="5251235485581552614">"Butoni i qasshmërisë"</string>
    <string name="accessibility_button_gesture_title" msgid="3573456209050374139">"Butoni dhe gjesti i qasshmërisë"</string>
    <string name="accessibility_button_intro_text" msgid="80993874471745687">"Qasu me shpejtësi në veçoritë e qasshmërisë nga çdo ekran"</string>
    <string name="accessibility_button_about_title" msgid="3581116105084067926">"Rreth butonit të qasshmërisë"</string>
    <string name="accessibility_button_gesture_about_title" msgid="8468987303602865536">"Rreth butonin dhe gjestit të qasshmërisë"</string>
    <string name="accessibility_button_gesture_footer_learn_more_content_description" msgid="4144803517680297869">"Mëso më shumë rreth butonit dhe gjestit të qasshmërisë"</string>
    <string name="accessibility_button_intro" msgid="2601976470525277903">"Përdorimi i butonit të qasshmërisë. Gjesti nuk ofrohet me navigimin me 3 butona."</string>
    <string name="accessibility_button_summary" msgid="8510939012631455831">"Qasu me shpejtësi te veçoritë e qasshmërisë"</string>
    <string name="accessibility_button_gesture_description" msgid="7507097717493960397"><b>"Për të filluar"</b>\n"1. Shko te cilësimet e qasshmërisë\n2. Zgjidh një veçori dhe trokit shkurtoren\n3. Zgjidh nëse dëshiron të përdorësh një buton ose gjest për të marrë qasje te kjo veçori"</string>
    <string name="accessibility_button_description" msgid="1261273371298608222"><b>"Për të filluar"</b>\n"1. Shko te cilësimet e qasshmërisë\n2. Zgjidh një veçori dhe trokit shkurtoren\n3. Zgjidh butonin për të pasur qasje te veçoria"</string>
    <string name="accessibility_button_or_gesture_title" msgid="3510075963401163529">"Përdor butonin ose gjestin"</string>
    <string name="accessibility_button_location_title" msgid="7182107846092304942">"Vendndodhja"</string>
    <string name="accessibility_button_size_title" msgid="5785110470538960881">"Madhësia"</string>
    <string name="accessibility_button_fade_title" msgid="8081993897680588829">"Zbehe kur nuk është në përdorim"</string>
    <string name="accessibility_button_fade_summary" msgid="7865950833524973709">"Zbehet pas pak sekondash për ta bërë më të lehtë shikimin e ekranit"</string>
    <string name="accessibility_button_opacity_title" msgid="4727355657530362289">"Transparenca kur nuk është në përdorim"</string>
    <string name="accessibility_button_low_label" msgid="4193015407828927741">"Transparente"</string>
    <string name="accessibility_button_high_label" msgid="9138077512008190896">"Jotransparente"</string>
    <string name="accessibility_toggle_high_text_contrast_preference_title" msgid="1830189632458752698">"Tekst me kontrast të lartë"</string>
    <string name="accessibility_toggle_high_text_contrast_preference_summary" msgid="5286411556836346180">"Ndrysho ngjyrën e tekstit në të zezë ose të bardhë. Maksimizon kontrastin me sfondin."</string>
    <string name="accessibility_toggle_screen_magnification_auto_update_preference_title" msgid="4987009529235165664">"Përditëso auto. zmadhimin e ekranit"</string>
    <string name="accessibility_toggle_screen_magnification_auto_update_preference_summary" msgid="9034532513972547720">"Përditëso zmadhimin e ekranit në kalimet e apl."</string>
    <string name="accessibility_power_button_ends_call_prerefence_title" msgid="8187306131979612144">"Butoni i energjisë mbyll telefonatën"</string>
    <string name="accessibility_toggle_large_pointer_icon_title" msgid="5508351959249876801">"Kursor mausi i madh"</string>
    <string name="accessibility_toggle_large_pointer_icon_summary" msgid="1480527946039237705">"Bëje treguesin e miut më të dukshëm"</string>
    <string name="accessibility_disable_animations" msgid="2993529829457179058">"Hiq animacionet"</string>
    <string name="accessibility_disable_animations_summary" msgid="5828228669556554565">"Redukto lëvizjen në ekran"</string>
    <string name="accessibility_toggle_primary_mono_title" msgid="7587152099472946571">"Audioja mono"</string>
    <string name="accessibility_toggle_primary_mono_summary" msgid="1935283927319407303">"Ndërthur kanalet kur luan audion"</string>
    <string name="accessibility_toggle_primary_balance_title" msgid="7332275200153366714">"Balanca e audios"</string>
    <string name="accessibility_toggle_primary_balance_left_label" msgid="6415750010517682014">"Majtas"</string>
    <string name="accessibility_toggle_primary_balance_right_label" msgid="2987443495390104935">"Djathtas"</string>
    <string name="accessibility_timeout_default" msgid="1033702739376842824">"E parazgjedhur"</string>
    <string name="accessibility_timeout_10secs" msgid="5072577454521239794">"10 sekonda"</string>
    <string name="accessibility_timeout_30secs" msgid="7814673496724760684">"30 sekonda"</string>
    <string name="accessibility_timeout_1min" msgid="4804644263166961262">"1 minutë"</string>
    <string name="accessibility_timeout_2mins" msgid="7901692984522708679">"2 minuta"</string>
    <string name="accessibility_setting_item_control_timeout_title" msgid="1600516937989217899">"Veprimi (koha e pritjes së \"Qasshmërisë\")"</string>
    <string name="accessibility_control_timeout_about_title" msgid="813588002683460837">"Rreth kohës për të kryer veprim (koha e pritjes e \"Qasshmërisë\")"</string>
    <string name="accessibility_control_timeout_footer_learn_more_content_description" msgid="8118584413220542193">"Mëso më shumë rreth kohës për të kryer veprim (koha e pritjes e \"Qasshmërisë\")"</string>
    <string name="accessibility_control_timeout_preference_title" msgid="1443940538597464758">"Koha për të kryer veprime"</string>
    <string name="accessibility_control_timeout_preference_summary" msgid="4037051091059316310">"Kjo preferencë e kohës nuk mbështetet nga të gjitha aplikacionet"</string>
    <string name="accessibility_control_timeout_preference_intro_text" msgid="1398116710556762245">"Zgjidh se për sa kohë të shfaqen mesazhet e përkohshme që të kërkojnë të kryesh veprim"</string>
    <string name="accessibility_long_press_timeout_preference_title" msgid="5237764682976688855">"Vonesa e prekjes dhe e mbajtjes shtypur"</string>
    <string name="accessibility_display_inversion_preference_title" msgid="5476133104746207952">"Anasjellja e ngjyrës"</string>
    <string name="accessibility_display_inversion_switch_title" msgid="7458595722552743503">"Përdor anasjelljen e ngjyrës"</string>
    <string name="accessibility_display_inversion_shortcut_title" msgid="6889624526691513462">"Shkurtorja e anasjelljes së ngjyrës"</string>
    <string name="accessibility_display_inversion_preference_intro_text" msgid="1159663288481145318">"Anasjellja e ngjyrave i bën të errëta ekranet e ndriçuara. Gjithashtu, ajo i bën të ndriçuara ekranet e errëta."</string>
    <string name="accessibility_display_inversion_preference_subtitle" msgid="4494767676482389509">"&lt;b&gt;Ki parasysh&lt;/b&gt;&lt;br/&gt; &lt;ol&gt; &lt;li&gt; Ngjyrat do të ndryshojnë te media dhe imazhet&lt;/li&gt; &lt;li&gt; Anasjellja e ngjyrave funksionon në të gjitha aplikacionet&lt;/li&gt; &lt;li&gt; Për të shfaqur një ekran të errët, mund të përdoret më mirë \"Tema e errët\"&lt;/li&gt; &lt;/ol&gt;"</string>
    <string name="accessibility_autoclick_preference_title" msgid="2703143361605555752">"Klikimi automatik (koha e qëndrimit pa lëvizur)"</string>
    <string name="accessibility_autoclick_about_title" msgid="152923024405552594">"Rreth klikimit automatik (koha e qëndrimit pa lëvizur)"</string>
    <string name="accessibility_autoclick_footer_learn_more_content_description" msgid="7056189627042350691">"Mëso më shumë rreth klikimit automatik (koha qëndrimit pa lëvizur)"</string>
    <string name="accessibility_autoclick_intro_text" msgid="8959680635470639347">"Mund të caktosh që mausi i lidhur të klikojë automatikisht kur kursori ndalon së lëvizuri për një kohë të caktuar"</string>
    <string name="accessibility_autoclick_description" msgid="6695732131412361101">"Klikimi automatik mund të jetë i dobishëm nëse ke vështirësi me klikimin e mausit"</string>
    <string name="accessibility_autoclick_default_title" msgid="2024730028293793490">"Klikimi automatik joaktiv"</string>
    <string name="accessibility_autoclick_short_title" msgid="7938302504358912984">"I shkurtër"</string>
    <string name="accessibility_autoclick_short_summary" msgid="4106953930081213514">"0,2 sekonda"</string>
    <string name="accessibility_autoclick_medium_title" msgid="3134175117576834320">"Mesatar"</string>
    <string name="accessibility_autoclick_medium_summary" msgid="1343390686514222871">"0,6 sekonda"</string>
    <string name="accessibility_autoclick_long_title" msgid="6799311820641687735">"I gjatë"</string>
    <string name="accessibility_autoclick_long_summary" msgid="3747153151313563637">"1 sekondë"</string>
    <string name="accessibility_autoclick_custom_title" msgid="4597792235546232038">"Personalizo"</string>
    <string name="accessibility_autoclick_shorter_desc" msgid="7631013255724544348">"Më e shkurtër"</string>
    <string name="accessibility_autoclick_longer_desc" msgid="2566025502981487443">"Më e gjatë"</string>
    <string name="accessibility_autoclick_seekbar_desc" msgid="8363959277814621118">"Koha e klikimit automatik"</string>
    <string name="accessibility_vibration_settings_title" msgid="936301142478631993">"Dridhja dhe prekja"</string>
    <string name="accessibility_vibration_settings_summary" msgid="3690308537483465527">"Kontrollo fuqinë e dridhjes për përdorime të ndryshme"</string>
    <string name="accessibility_vibration_settings_state_on" msgid="5566026932372832502">"Aktive"</string>
    <string name="accessibility_vibration_settings_state_off" msgid="7946588741954981703">"Joaktive"</string>
    <string name="accessibility_vibration_setting_disabled_for_silent_mode_summary" msgid="3982701772953323190">"Cilësimet u çaktivizuan sepse pajisja është vendosur në heshtje"</string>
    <string name="accessibility_call_vibration_category_title" msgid="2545607568768192318">"Telefonatat"</string>
    <string name="accessibility_notification_alarm_vibration_category_title" msgid="2683635252414849417">"Njoftimet dhe alarmet"</string>
    <string name="accessibility_interactive_haptics_category_title" msgid="3162855291184592021">"Reagimi ndërveprues"</string>
    <string name="accessibility_vibration_primary_switch_title" msgid="6162579254864450592">"Përdor dridhjen dhe prekjen"</string>
    <string name="accessibility_alarm_vibration_title" msgid="4661294337828522745">"Dridhja e alarmit"</string>
    <string name="accessibility_media_vibration_title" msgid="1372073715403945428">"Dridhja e medias"</string>
    <string name="accessibility_ring_vibration_title" msgid="4689811297654320885">"Dridhjet e ziles"</string>
    <string name="accessibility_notification_vibration_title" msgid="6205679908785776478">"Dridhjet e njoftimeve"</string>
    <string name="accessibility_touch_vibration_title" msgid="533931451319110741">"Reagimi me prekje"</string>
    <string name="accessibility_service_primary_switch_title" msgid="437610853412159406">"Përdor <xliff:g id="ACCESSIBILITY_APP_NAME">%1$s</xliff:g>"</string>
    <string name="accessibility_service_primary_open_title" msgid="8655108684769091154">"Hap <xliff:g id="ACCESSIBILITY_APP_NAME">%1$s</xliff:g>"</string>
    <string name="accessibility_service_auto_added_qs_tooltip_content" msgid="2941824314912928072">"<xliff:g id="ACCESSIBILITY_APP_NAME">%1$s</xliff:g> u shtua te \"Cilësimet e shpejta\". Rrëshqit shpejt poshtë për ta aktivizuar ose çaktivizuar në çdo kohë."</string>
    <string name="accessibility_service_qs_tooltip_content" msgid="6002493441414967868">"Gjithashtu, <xliff:g id="ACCESSIBILITY_APP_NAME">%1$s</xliff:g> mund ta shtosh te \"Cilësimet e shpejta\" nga kreu i ekranit"</string>
    <string name="accessibility_color_correction_auto_added_qs_tooltip_content" msgid="9092661358437404374">"Korrigjimi i ngjyrës u shtua te \"Cilësimet e shpejta\". Rrëshqit shpejt poshtë për ta aktivizuar ose çaktivizuar në çdo kohë."</string>
    <string name="accessibility_color_correction_qs_tooltip_content" msgid="3258628434235475205">"Gjithashtu, korrigjimin e ngjyrës mund ta shtosh te \"Cilësimet e shpejta\" nga kreu i ekranit"</string>
    <string name="accessibility_color_inversion_auto_added_qs_tooltip_content" msgid="7267618234972101725">"Anasjellja e ngjyrës u shtua te \"Cilësimet e shpejta\". Rrëshqit shpejt poshtë për ta aktivizuar ose çaktivizuar në çdo kohë."</string>
    <string name="accessibility_color_inversion_qs_tooltip_content" msgid="5046332142185711869">"Gjithashtu, anasjelljen e ngjyrës mund ta shtosh te \"Cilësimet e shpejta\" nga kreu i ekranit"</string>
    <string name="accessibility_reduce_bright_colors_auto_added_qs_tooltip_content" msgid="1906588335786328512">"Zbehja e shtuar u shtua te \"Cilësimet e shpejta\". Rrëshqit shpejt poshtë për ta aktivizuar ose çaktivizuar në çdo kohë."</string>
    <string name="accessibility_reduce_bright_colors_qs_tooltip_content" msgid="7522121299176176785">"Gjithashtu, zbehjen e shtuar mund ta shtosh te \"Cilësimet e shpejta\" nga kreu i ekranit"</string>
    <string name="accessibility_one_handed_mode_auto_added_qs_tooltip_content" msgid="7914554254280416532">"Modaliteti i përdorimit me një dorë u shtua te \"Cilësimet e shpejta\". Rrëshqit shpejt poshtë për ta aktivizuar ose çaktivizuar në çdo kohë."</string>
    <string name="accessibility_one_handed_mode_qs_tooltip_content" msgid="2754332083184384603">"Gjithashtu, modalitetin e përdorimit me një dorë mund ta shtosh te \"Cilësimet e shpejta\" nga kreu i ekranit"</string>
    <string name="accessibility_quick_settings_tooltip_dismiss" msgid="3269120277643884190">"Hiq"</string>
    <string name="accessibility_daltonizer_about_intro_text" product="default" msgid="3636710237139542212">"Rregullo mënyrën se si shfaqen ngjyrat në telefon"</string>
    <string name="accessibility_daltonizer_about_intro_text" product="tablet" msgid="3702653229533336133">"Rregullo mënyrën se si shfaqen ngjyrat në tabletin tënd"</string>
    <string name="accessibility_daltonizer_primary_switch_title" msgid="32064721588910540">"Përdor korrigjimin e ngjyrave"</string>
    <string name="accessibility_daltonizer_shortcut_title" msgid="7480360363995502369">"Shkurtorja e korrigjimit të ngjyrës"</string>
    <string name="accessibility_daltonizer_about_title" msgid="6063650804116981287">"Rreth korrigjimit të ngjyrës"</string>
    <string name="accessibility_daltonizer_footer_learn_more_content_description" msgid="2091679253892040910">"Mëso më shumë rreth korrigjimit të ngjyrës"</string>
    <string name="accessibility_color_inversion_about_title" msgid="8275754480247040136">"Rreth anasjelljes së ngjyrës"</string>
    <string name="accessibility_color_inversion_footer_learn_more_content_description" msgid="5382579548498952445">"Mëso më shumë rreth anasjelljes së ngjyrës"</string>
    <string name="accessibility_caption_primary_switch_title" msgid="8901149325574757370">"Shfaq titrat"</string>
    <string name="accessibility_caption_primary_switch_summary" msgid="2754071646412717674">"Vetëm për aplikacionet e mbështetura"</string>
    <string name="captioning_caption_appearance_title" msgid="4501313548541670063">"Madhësia dhe stili i titrave"</string>
    <string name="captioning_caption_appearance_summary" msgid="7340741178479381312">"Madhësia e tekstit <xliff:g id="ACCESSIBILITY_FONT_SIZE">%1$s</xliff:g>"</string>
    <string name="captioning_more_options_title" msgid="3484496882942539652">"Opsione të tjera"</string>
    <string name="accessibility_caption_preference_intro" msgid="6662649135457507767">"Personalizo madhësinë dhe stilin e titrave për t\'i bërë më të lehta për t\'u lexuar"</string>
    <string name="accessibility_caption_preference_summary" msgid="632875702223135121">"Këto preferenca të titrave nuk mbështeten nga të gjitha aplikacionet e medias"</string>
    <string name="accessibility_shortcut_type_software" msgid="2552732582767687515">"Butoni i qasshmërisë"</string>
    <string name="accessibility_shortcut_type_software_gesture" msgid="5608959693931019059">"Rrëshqitja shpejt lart me 2 gishta nga poshtë"</string>
    <string name="accessibility_shortcut_type_hardware" msgid="4834144210432451916">"Mbaj butonat e volumit"</string>
    <string name="accessibility_shortcut_type_triple_tap" msgid="7717524216825494543">"Trokit tri herë tek ekrani"</string>
    <string name="accessibility_hearingaid_instruction_continue_button" msgid="3367260988024430722">"Vazhdo"</string>
    <string name="accessibility_hearingaid_title" msgid="427173678199203191">"Aparatet e dëgjimit"</string>
    <string name="accessibility_hearingaid_not_connected_summary" msgid="3371427366765435743">"Nuk ka asnjë aparat dëgjimi të lidhur"</string>
    <string name="accessibility_hearingaid_adding_summary" msgid="999051610528600783">"Shto aparate dëgjimi"</string>
    <string name="accessibility_hearingaid_pair_instructions_title" msgid="2357706801112207624">"Çifto aparatin e dëgjimit"</string>
    <string name="accessibility_hearingaid_pair_instructions_message" msgid="581652489109350119">"Në ekranin tjetër, trokit tek aparati yt i dëgjimit. Mund të të duhet të çiftosh veshin e majtë dhe të djathtë veçmas.\n\nSigurohu që aparati i dëgjimit të jetë i ndezur dhe gati për t\'u çiftuar."</string>
    <string name="accessibility_hearingaid_active_device_summary" msgid="509703438222873967">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g> është aktive"</string>
    <string name="accessibility_hearingaid_left_side_device_summary" msgid="1907302799168261001">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g>, vetëm në anën e majtë"</string>
    <string name="accessibility_hearingaid_right_side_device_summary" msgid="148257064855054376">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g>, vetëm në anën e djathtë"</string>
    <string name="accessibility_hearingaid_left_and_right_side_device_summary" msgid="4268221140368164452">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g>, në anën e majtë dhe të djathtë"</string>
    <string name="accessibility_hearingaid_more_device_summary" msgid="8092641784056942546">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g> dhe 1 tjetër"</string>
    <plurals name="show_number_hearingaid_count" formatted="false" msgid="776000580683647556">
      <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_audio_adjustment_title" msgid="1332113739136802997">"Rregullimi i audios"</string>
    <string name="accessibility_toggle_audio_description_preference_title" msgid="8916473886256061220">"Përshkrimi i audios"</string>
    <string name="accessibility_audio_description_summary" msgid="2554789094873781056">"Dëgjo një përshkrim të asaj që ndodh në ekran te filmat dhe shfaqjet e mbështetura"</string>
    <string name="keywords_audio_description" msgid="6202816411593281252">"përshkrimi i audios, audio, përshkrimi, shikim i dobët"</string>
    <string name="accessibility_summary_shortcut_enabled" msgid="4030427268146752644">"Shkurtorja aktive"</string>
    <string name="accessibility_summary_shortcut_disabled" msgid="564005462092499068">"Joaktiv"</string>
    <string name="accessibility_summary_state_enabled" msgid="1065431632216039369">"Aktiv"</string>
    <string name="accessibility_summary_state_disabled" msgid="9173234532752799694">"Joaktiv"</string>
    <string name="accessibility_summary_state_stopped" msgid="2343602489802623424">"Nuk funksionon. Trokit për informacione."</string>
    <string name="accessibility_description_state_stopped" msgid="5364752492861199133">"Ky shërbim nuk po funksionon mirë."</string>
    <string name="accessibility_shortcuts_settings_title" msgid="974740249671825145">"Shkurtoret e qasshmërisë"</string>
    <string name="enable_quick_setting" msgid="6648073323202243604">"Shfaq në Cilësimet e shpejta"</string>
    <string name="daltonizer_mode_deuteranomaly_title" msgid="4210949400493358650">"E kuqe - e gjelbër"</string>
    <string name="daltonizer_mode_protanomaly_title" msgid="6392456967103014723">"E kuqe - e gjelbër"</string>
    <string name="daltonizer_mode_tritanomaly_title" msgid="2278786218762602022">"E kaltër - e verdhë"</string>
    <string name="daltonizer_mode_grayscale_title" msgid="152005391387952588">"Nuancat e grisë"</string>
    <string name="daltonizer_mode_deuteranomaly_summary" msgid="2117727423019598455">"E gjelbër e dobët, deuteranomali"</string>
    <string name="daltonizer_mode_protanomaly_summary" msgid="4617032854982040748">"E kuqe e dobët, protanomali"</string>
    <string name="daltonizer_mode_tritanomaly_summary" msgid="2428218320118180070">"Tritanomali"</string>
    <string name="reduce_bright_colors_preference_title" msgid="2249314004651574997">"Shumë më i zbehtë"</string>
    <string name="reduce_bright_colors_switch_title" msgid="1751678397884065312">"Bëje ekranin shumë më të zbehtë"</string>
    <string name="reduce_bright_colors_shortcut_title" msgid="495648157059202745">"Shkurtorja për veçorinë \"shumë më i zbehtë\""</string>
    <string name="reduce_bright_colors_about_title" msgid="503655452544934393">"Rreth shumë më të zbehtës"</string>
    <string name="reduce_bright_colors_preference_summary" product="default" msgid="7878756844769221647">"Errësoje ekranin përtej ndriçimit minimal të telefonit tënd"</string>
    <string name="reduce_bright_colors_preference_summary" product="tablet" msgid="8959794720356934888">"Errësoje ekranin përtej ndriçimit minimal të tabletës sate"</string>
    <string name="reduce_bright_colors_preference_intro_text" msgid="3502290826747650566">"Bëje ekranin më të zbehtë për ta bërë leximin më komod"</string>
    <string name="reduce_bright_colors_preference_subtitle" product="default" msgid="8573408446901659333">"Zbehja e shtuar mund të jetë e dobishme kur: &lt;ol&gt; &lt;li&gt; Ndriçimi minimal i parazgjedhur i telefonit tënd është përsëri tepër i ndritshëm&lt;/li&gt; &lt;li&gt; Po e përdor telefonin në situata të errëta, si natën ose në një dhomë të errët përpara gjumit&lt;/li&gt; &lt;/ol&gt;"</string>
    <string name="reduce_bright_colors_preference_subtitle" product="tablet" msgid="5158211121482010799">"Zbehja e shtuar mund të jetë e dobishme kur: &lt;ol&gt; &lt;li&gt; Ndriçimi minimal i parazgjedhur i tabletit tënd është përsëri tepër i ndritshëm&lt;/li&gt; &lt;li&gt; Po e përdor tabletin në situata të errëta, si natën ose në një dhomë të errët përpara gjumit&lt;/li&gt; &lt;/ol&gt;"</string>
    <string name="reduce_bright_colors_intensity_preference_title" msgid="7455443033955118267">"Intensiteti"</string>
    <string name="reduce_bright_colors_intensity_start_label" msgid="930387498396426039">"Më i errët"</string>
    <string name="reduce_bright_colors_intensity_end_label" msgid="1422600205484299860">"Më i ndritshëm"</string>
    <string name="reduce_bright_colors_persist_preference_title" msgid="4368829654993343354">"Mbaje të aktivizuar pasi pajisja të riniset"</string>
    <plurals name="accessibilty_autoclick_preference_subtitle_short_delay" formatted="false" msgid="5354221071353645263">
      <item quantity="other">E shkurtër (<xliff:g id="CLICK_DELAY_LABEL_1">%1$s</xliff:g> sekonda)</item>
      <item quantity="one">E shkurtër (<xliff:g id="CLICK_DELAY_LABEL_0">%1$s</xliff:g> sekondë)</item>
    </plurals>
    <plurals name="accessibilty_autoclick_preference_subtitle_medium_delay" formatted="false" msgid="1550891909800510628">
      <item quantity="other">Mesatare (<xliff:g id="CLICK_DELAY_LABEL_1">%1$s</xliff:g> sekonda)</item>
      <item quantity="one">Mesatare (<xliff:g id="CLICK_DELAY_LABEL_0">%1$s</xliff:g> sekondë)</item>
    </plurals>
    <plurals name="accessibilty_autoclick_preference_subtitle_long_delay" formatted="false" msgid="2230755548820485984">
      <item quantity="other">E gjatë (<xliff:g id="CLICK_DELAY_LABEL_1">%1$s</xliff:g> sekonda)</item>
      <item quantity="one">E gjatë (<xliff:g id="CLICK_DELAY_LABEL_0">%1$s</xliff:g> sekondë)</item>
    </plurals>
    <plurals name="accessibilty_autoclick_delay_unit_second" formatted="false" msgid="4537791441118261556">
      <item quantity="other"><xliff:g id="CLICK_DELAY_LABEL_2">%1$s</xliff:g> sekonda</item>
      <item quantity="one"><xliff:g id="CLICK_DELAY_LABEL_0">%1$s</xliff:g> sekondë</item>
    </plurals>
    <string name="accessibility_menu_item_settings" msgid="2652637954865389271">"Cilësimet"</string>
    <string name="accessibility_feature_state_on" msgid="1777344331063467511">"Aktivizuar"</string>
    <string name="accessibility_feature_state_off" msgid="169119895905460512">"Çaktivizuar"</string>
    <string name="captioning_preview_title" msgid="2888561631323180535">"Shikim paraprak"</string>
    <string name="captioning_standard_options_title" msgid="5360264497750980205">"Opsionet standarde"</string>
    <string name="captioning_locale" msgid="5533303294290661590">"Gjuha"</string>
    <string name="captioning_text_size" msgid="8039448543171463017">"Madhësia e tekstit"</string>
    <string name="captioning_preset" msgid="4174276086501638524">"Stili i titrave"</string>
    <string name="captioning_custom_options_title" msgid="3858866498893566351">"Personalizo opsionet"</string>
    <string name="captioning_background_color" msgid="5231412761368883107">"Ngjyra e sfondit"</string>
    <string name="captioning_background_opacity" msgid="6453738649182382614">"Niveli i transparencës së sfondit"</string>
    <string name="captioning_window_color" msgid="1406167274530183119">"Ngjyra e dritares së titrave"</string>
    <string name="captioning_window_opacity" msgid="4031752812991199525">"Transparenca e dritares së titrave"</string>
    <string name="captioning_foreground_color" msgid="9057327228286129232">"Ngjyra e tekstit"</string>
    <string name="captioning_foreground_opacity" msgid="1395843080697567189">"Niveli i transparencës së tekstit"</string>
    <string name="captioning_edge_color" msgid="6035818279902597518">"Ngjyra e skajit"</string>
    <string name="captioning_edge_type" msgid="5281259280060811506">"Lloji i skajeve"</string>
    <string name="captioning_typeface" msgid="285325623518361407">"Familja e shkrimit"</string>
    <string name="captioning_preview_text" msgid="4973475065545995704">"Titrat do të duken kështu"</string>
    <string name="captioning_preview_characters" msgid="7854812443613580460">"Aa"</string>
    <string name="locale_default" msgid="8948077172250925164">"E parazgjedhur"</string>
    <string name="color_title" msgid="2511586788643787427">"Ngjyra"</string>
    <string name="color_unspecified" msgid="4102176222255378320">"E parazgjedhur"</string>
    <string name="color_none" msgid="3703632796520710651">"Asnjë"</string>
    <string name="color_white" msgid="1896703263492828323">"E bardhë"</string>
    <string name="color_gray" msgid="8554077329905747877">"Gri"</string>
    <string name="color_black" msgid="9006830401670410387">"E zezë"</string>
    <string name="color_red" msgid="5210756997426500693">"E kuqe"</string>
    <string name="color_green" msgid="4400462091250882271">"E gjelbër"</string>
    <string name="color_blue" msgid="4997784644979140261">"E kaltër"</string>
    <string name="color_cyan" msgid="4341758639597035927">"Gurkali"</string>
    <string name="color_yellow" msgid="5957551912912679058">"E verdhë"</string>
    <string name="color_magenta" msgid="8943538189219528423">"E purpurt"</string>
    <string name="enable_service_title" msgid="7231533866953706788">"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="1225853611983394386">"\"<xliff:g id="SERVICE">%1$s</xliff:g>\" ka nevojë të:"</string>
    <string name="touch_filtered_warning" msgid="4225815157460318241">"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="accessibility_service_warning" msgid="6779187188736432618">"<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="6573203795976134751">"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="324795030658109870">"Shiko dhe kontrollo ekranin"</string>
    <string name="accessibility_service_screen_control_description" msgid="8431940515157990426">"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="1449360056585337833">"Shiko dhe kryej veprimet"</string>
    <string name="accessibility_service_action_perform_description" msgid="7807832069800034738">"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="8274918676473216697">"Lejo"</string>
    <string name="accessibility_dialog_button_deny" msgid="2037249860078259284">"Refuzo"</string>
    <string name="accessibility_dialog_button_stop" msgid="7295448112784528196">"Ndalo"</string>
    <string name="accessibility_dialog_button_cancel" msgid="4813234247237851121">"Anulo"</string>
    <string name="disable_service_title" msgid="2909108731776956167">"Të ndalohet shërbimi \"<xliff:g id="SERVICE">%1$s</xliff:g>\"?"</string>
    <string name="disable_service_message" msgid="4814173941688548016">"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="3725569493860028593">"Nuk është instaluar asnjë shërbim"</string>
    <string name="accessibility_no_service_selected" msgid="1310596127128379897">"Nuk është zgjedhur asnjë shërbim"</string>
    <string name="accessibility_service_default_description" msgid="7801435825448138526">"Nuk është dhënë asnjë përshkrim."</string>
    <string name="settings_button" msgid="2195468788019730377">"Cilësimet"</string>
    <string name="keywords_reduce_bright_colors" msgid="1683190961013139183">"ndjeshmëria ndaj dritës, fotofobia, tema e errët, migrena, dhimbje koke, modaliteti i leximit, modaliteti i natës, ul ndriçimin, pika e bardhë"</string>
    <string name="keywords_accessibility" msgid="4263443239404659143">"Lehtësia e përdorimit, lehtësia e qasjes, ndihma, ndihmëse"</string>
    <string name="keywords_magnification" msgid="3908145308269840862">"Zmadhuesi i dritareve, zmadho, zmadhimi, shikim i dobët, zmadho, bëje më të madh"</string>
    <string name="keywords_talkback" msgid="2816435437095102527"></string>
    <string name="keywords_live_caption" msgid="1667203998080567556">"Titrat, CC, Transkriptimi në çast, vështirësi në dëgjim, humbje e dëgjimit, CART, ligjërimi në tekst, nëntitull"</string>
    <string name="keywords_live_transcribe" msgid="3226990195174890997"></string>
    <string name="keywords_sound_notifications" msgid="8183107485754075413"></string>
    <string name="keywords_sound_amplifier" msgid="939404835256246663"></string>
    <string name="keywords_display_size" msgid="5286419615221231518">"madhësia e ekranit, ekrani i madh"</string>
    <string name="keywords_bold_text" msgid="6257418169207099589">"Kontrasti i lartë, shikim i dobët, font i trashësuar, shkrim i trashësuar"</string>
    <string name="keywords_select_to_speak" msgid="2872704811610888719"></string>
    <string name="keywords_color_correction" msgid="8540442886990423681">"rregullo ngjyrën"</string>
    <string name="keywords_color_inversion" msgid="4291058365873221962">"bëje ekranin të errët, bëje ekranin të ndriçuar"</string>
    <string name="keywords_accessibility_menu" msgid="4300579436464706608"></string>
    <string name="keywords_switch_access" msgid="5813094504384313402"></string>
    <string name="keywords_auto_click" msgid="7151756353013736931">"aftësitë motorike, miu"</string>
    <string name="keywords_hearing_aids" msgid="524979615168196199">"vështirësi në dëgjim, humbje e dëgjimit"</string>
    <string name="keywords_rtt" msgid="2429130928152514402">"vështirësi në dëgjim, humbje e dëgjimit, titrat, teletajp, TTY"</string>
    <string name="keywords_voice_access" msgid="7807335263195876454"></string>
    <string name="print_settings" msgid="8519810615863882491">"Printimi"</string>
    <string name="print_settings_summary_no_service" msgid="6721731154917653862">"Joaktive"</string>
    <plurals name="print_settings_summary" formatted="false" msgid="1034273609054146099">
      <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="3933688846338306536">
      <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="7680498284751129935">"Shërbimet e printimit"</string>
    <string name="print_no_services_installed" msgid="7554057966540602692">"Nuk është instaluar asnjë shërbim"</string>
    <string name="print_no_printers_found" msgid="4833082484646109486">"Nuk u gjet asnjë printer"</string>
    <string name="print_menu_item_settings" msgid="8202755044784599740">"Cilësimet"</string>
    <string name="print_menu_item_add_printers" msgid="7958192149202584039">"Shto printerë"</string>
    <string name="print_feature_state_on" msgid="7132063461008624685">"Aktivizuar"</string>
    <string name="print_feature_state_off" msgid="1466195699995209446">"Çaktivizuar"</string>
    <string name="print_menu_item_add_service" msgid="1549091062463044676">"Shto shërbim"</string>
    <string name="print_menu_item_add_printer" msgid="8711630848324870892">"Shto printer"</string>
    <string name="print_menu_item_search" msgid="5989979785203603169">"Kërko"</string>
    <string name="print_searching_for_printers" msgid="5401413178028348800">"Po kërkon për printerë"</string>
    <string name="print_service_disabled" msgid="9185935228930987786">"Shërbimi është çaktivizuar"</string>
    <string name="print_print_jobs" msgid="2605944855933091183">"Punët e printimit"</string>
    <string name="print_print_job" msgid="8477859161886726608">"Punë printimi"</string>
    <string name="print_restart" msgid="4424096106141083945">"Rifillo"</string>
    <string name="print_cancel" msgid="7611266511967568501">"Anulo"</string>
    <string name="print_job_summary" msgid="277210060872032969">"<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="2887013172492183045">"Po konfiguron <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_printing_state_title_template" msgid="7367513245156603431">"Po printon <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_cancelling_state_title_template" msgid="9094795458159980190">"Po anulon <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_failed_state_title_template" msgid="4751695809935404505">"Gabim i printerit për <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_blocked_state_title_template" msgid="3134100215188411074">"Printeri bllokoi <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_search_box_shown_utterance" msgid="6215002365360341961">"Kutia e kërkimit është e shfaqur"</string>
    <string name="print_search_box_hidden_utterance" msgid="5355387966141712567">"Kutia e kërkimit është e fshehur"</string>
    <string name="printer_info_desc" msgid="1206872325746154206">"Më shumë informacione mbi këtë printer"</string>
    <string name="power_usage_summary_title" msgid="4198312848584882113">"Bateria"</string>
    <string name="power_usage_summary" msgid="6857382582534984531">"Kush e ka harxhuar baterinë"</string>
    <string name="power_usage_not_available" msgid="3425302437465106036">"Të dhënat nuk ofrohen."</string>
    <string name="power_usage_level_and_status" msgid="821521456989429593">"<xliff:g id="LEVEL">%1$s</xliff:g> - <xliff:g id="STATUS">%2$s</xliff:g>"</string>
    <string name="power_discharge_remaining" msgid="6997529817917076536">"<xliff:g id="REMAIN">%1$s</xliff:g> të mbetura"</string>
    <string name="power_charge_remaining" msgid="7046064326172265116">"<xliff:g id="UNTIL_CHARGED">%1$s</xliff:g> për të karikuar"</string>
    <string name="low_battery_summary" msgid="4458925347316501953">"Bateria në nivel të ulët"</string>
    <string name="background_activity_title" msgid="8214332017349791380">"Kufizimi i përdorimit në sfond"</string>
    <string name="background_activity_summary" msgid="3817376868497046016">"Lejo që aplikacioni të ekzekutohet në sfond"</string>
    <string name="background_activity_summary_disabled" msgid="32459916080651444">"Nuk lejohet që aplikacioni të ekzekutohet në sfond"</string>
    <string name="background_activity_summary_allowlisted" msgid="6240154358657454651">"Përdorimi në sfond nuk mund të kufizohet"</string>
    <string name="background_activity_warning_dialog_title" msgid="3449566823290744823">"Të kufizohet aktiviteti në sfond?"</string>
    <string name="background_activity_warning_dialog_text" msgid="8202776985767701095">"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="4053170297325882494">"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="manager_battery_usage_unrestricted_title" msgid="2426486290463258032">"Pa kufizim"</string>
    <string name="manager_battery_usage_optimized_title" msgid="8080765739761921817">"I optimizuar"</string>
    <string name="manager_battery_usage_restricted_title" msgid="7702863764130323118">"I kufizuar"</string>
    <string name="manager_battery_usage_unrestricted_summary" msgid="6819279865465667692">"Lejo përdorimin e baterisë në sfond pa kufizime. Mund të përdoret më shumë bateri."</string>
    <string name="manager_battery_usage_optimized_summary" msgid="1332545476428039900">"Optimizoje bazuar në përdorimin tënd. Rekomandohet për shumicën e aplikacioneve."</string>
    <string name="manager_battery_usage_restricted_summary" msgid="8324695640704416905">"Kufizo përdorimin e baterisë në sfond. Aplikacioni mund të mos funksionojë siç pritet. Njoftimet mund të vonohen."</string>
    <string name="manager_battery_usage_footer" msgid="2635906573922553766">"Ndryshimi i mënyrës se si e përdor baterinë një aplikacion mund të ketë ndikim te rendimenti i saj."</string>
    <string name="manager_battery_usage_footer_limited" msgid="5180776148877306780">"Ky aplikacion kërkon përdorimin e baterisë: <xliff:g id="STATE">%1$s</xliff:g>."</string>
    <string name="manager_battery_usage_unrestricted_only" msgid="3646162131339418216">"pa kufizim"</string>
    <string name="manager_battery_usage_optimized_only" msgid="7121785281913056432">"i optimizuar"</string>
    <string name="manager_battery_usage_link_a11y" msgid="374918091821438564">"Mëso më shumë për opsionet e përdorimit të baterisë"</string>
    <string name="device_screen_usage" msgid="1011630249648289909">"Përdorimi i ekranit që nga karikimi i plotë"</string>
    <string name="power_usage_list_summary" msgid="3237540201918492925">"Përdorimi i baterisë që prej karikimit të plotë"</string>
    <string name="screen_usage_summary" msgid="1393184943010909471">"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="242243537371697285">"Përdorimi i pajisjes që nga karikimi i plotë"</string>
    <string name="battery_since_unplugged" msgid="6991509383429936921">"Përdorimi i baterisë që nga heqja nga ngarkimi"</string>
    <string name="battery_since_reset" msgid="2930376112877476562">"Përdorimi i baterisë që nga rivendosja"</string>
    <string name="battery_stats_on_battery" msgid="1553011980384645514">"<xliff:g id="TIME">%1$s</xliff:g> me bateri"</string>
    <string name="battery_stats_duration" msgid="6918768703070999743">"<xliff:g id="TIME">%1$s</xliff:g> që nga heqja nga priza"</string>
    <string name="battery_stats_charging_label" msgid="6204814386861342145">"Ngarkimi"</string>
    <string name="battery_stats_screen_on_label" msgid="8989312180491200138">"Qëndrimi aktiv i ekranit"</string>
    <string name="battery_stats_gps_on_label" msgid="5626424078405382686">"GPS-ja aktive"</string>
    <string name="battery_stats_camera_on_label" msgid="555635201416769359">"Kamera aktive"</string>
    <string name="battery_stats_flashlight_on_label" msgid="1621027969559427783">"Blici aktiv"</string>
    <string name="battery_stats_wifi_running_label" msgid="6461551370010379049">"Wi-Fi"</string>
    <string name="battery_stats_wake_lock_label" msgid="8115041205778441548">"Qëndrimi zgjuar"</string>
    <string name="battery_stats_phone_signal_label" msgid="679649411998679555">"Sinjali i rrjetit celular"</string>
    <!-- no translation found for battery_stats_last_duration (3088100394725340600) -->
    <skip />
    <string name="awake" msgid="5405871714019268978">"Koha e zgjimit të pajisjes"</string>
    <string name="wifi_on_time" msgid="3880778525760926066">"Koha e aktivizimit të Wi‑Fi"</string>
    <string name="bluetooth_on_time" msgid="8424625554628450028">"Koha e aktivizimit të Wi‑Fi"</string>
    <string name="advanced_battery_title" msgid="3005993394776555079">"Përdorimi i baterisë"</string>
    <string name="history_details_title" msgid="8628584613889559355">"Detajet e historikut"</string>
    <string name="advanced_battery_preference_title" msgid="3790901207877260883">"Përdorimi i baterisë"</string>
    <string name="advanced_battery_preference_summary_with_hours" msgid="954091349133320955">"Shiko përdorimin për 24 orët e fundit"</string>
    <string name="advanced_battery_preference_summary" msgid="6088389774708000305">"Shiko përdorimin nga karikimi i fundit i plotë"</string>
    <string name="battery_details_title" msgid="4531369291819754178">"Përdorimi i baterisë"</string>
    <string name="details_subtitle" msgid="2550872569652785527">"Përdor detajet"</string>
    <string name="controls_subtitle" msgid="3759606830916441564">"Rregullo përdorimin e energjisë"</string>
    <string name="packages_subtitle" msgid="8687690644931499428">"Paketat e përfshira"</string>
    <string name="battery_tip_summary_title" msgid="321127485145626939">"Aplikacionet po funksionojnë normalisht"</string>
    <string name="battery_tip_summary_summary" product="default" msgid="6077959765904507849">"Telefoni ka një përdorim normal të baterisë në sfond"</string>
    <string name="battery_tip_summary_summary" product="tablet" msgid="5063158368808711973">"Tableti ka një përdorim normal të baterisë në sfond"</string>
    <string name="battery_tip_summary_summary" product="device" msgid="4242899844618910548">"Pajisja ka një përdorim normal të baterisë në sfond"</string>
    <string name="battery_tip_low_battery_title" msgid="4155239078744100997">"Niveli i baterisë është i ulët"</string>
    <string name="battery_tip_low_battery_summary" msgid="2629633757244297436">"Aktivizo \"Kursyesin e baterisë\" për të rritur kohëzgjatjen e baterisë"</string>
    <string name="battery_tip_smart_battery_title" msgid="8925025450214912325">"Përmirëso kohëzgjatjen e baterisë"</string>
    <string name="battery_tip_smart_battery_summary" msgid="3592965553502362965">"Aktivizo \"Menaxherin e baterisë\""</string>
    <string name="battery_tip_early_heads_up_title" msgid="4411387863476629452">"Aktivizo \"Kursyesin e baterisë\""</string>
    <string name="battery_tip_early_heads_up_summary" msgid="578523794827443977">"Bateria mund të mbarojë më herët se zakonisht"</string>
    <string name="battery_tip_early_heads_up_done_title" msgid="7705597228709143337">"\"Kursyesi i baterisë\", aktiv"</string>
    <string name="battery_saver_link_a11y" msgid="740558184830458845">"Mëso më shumë rreth \"Kursyesit të baterisë\""</string>
    <string name="battery_tip_early_heads_up_done_summary" msgid="7858923105760361208">"Disa veçori mund të jenë të kufizuara"</string>
    <string name="battery_tip_high_usage_title" msgid="9110720762506146697">"Përdorim më i lartë i baterisë"</string>
    <string name="battery_tip_high_usage_summary" msgid="3938999581403084551">"Shiko aplikacionet me përdorimin më të lartë"</string>
    <string name="battery_tip_limited_temporarily_title" msgid="5231061779363606924">"Karikimi përkohësisht i kufizuar"</string>
    <string name="battery_tip_limited_temporarily_summary" msgid="8504402301403419444">"Për të kursyer baterinë. Mëso më shumë."</string>
    <string name="battery_tip_limited_temporarily_dialog_resume_charge" msgid="2302295458913832342">"Vazhdo karikimin"</string>
    <string name="battery_tip_limited_temporarily_dialog_msg" product="default" msgid="8125639486214812735">"Karikimi mund të kufizohet në <xliff:g id="PERCENT">%1$s</xliff:g> për të ndihmuar në ruajtjen e gjendjes së baterisë në kushte të caktuara, si p.sh. në temperatura të larta dhe periudha të gjata karikimi.\n\nKur këto kushte përfundojnë, telefoni yt do të karikohet automatikisht si zakonisht."</string>
    <string name="battery_tip_limited_temporarily_dialog_msg" product="tablet" msgid="3890877885222574553">"Karikimi mund të kufizohet në <xliff:g id="PERCENT">%1$s</xliff:g> për të ndihmuar në ruajtjen e gjendjes së baterisë në kushte të caktuara, si p.sh. në temperatura të larta dhe periudha të gjata karikimi.\n\nKur këto kushte përfundojnë, tableta jote do të karikohet automatikisht si zakonisht."</string>
    <string name="battery_tip_dialog_message" product="default" msgid="4592387206991500075">"Bateria mund të mbarojë më shpejt se normalisht pasi e ke përdorur telefonin më shumë se zakonisht.\n\nAplikacionet që përdorin më shumë baterinë:"</string>
    <string name="battery_tip_dialog_message" product="tablet" msgid="111303605119856034">"Bateria mund të mbarojë më shpejt se normalisht pasi e ke përdorur tabletin më shumë se zakonisht.\n\nAplikacionet që përdorin më shumë baterinë:"</string>
    <string name="battery_tip_dialog_message" product="device" msgid="3896805213768863874">"Bateria mund të mbarojë më shpejt se normalisht pasi e ke përdorur pajisjen më shumë se zakonisht.\n\nAplikacionet që përdorin më shumë baterinë:"</string>
    <string name="battery_tip_dialog_message_footer" msgid="986542164372177504">"Përfshin aktivitetin me nivel të lartë të energjisë në sfond"</string>
    <plurals name="battery_tip_restrict_title" formatted="false" msgid="3108195491484891588">
      <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="5862649927574803958">
      <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="3328499737453686910">
      <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="3036853535034350991">
      <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="7897944678619251740">
      <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="137856003724730751">"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="5894648804112181324">"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="4546838397423565138">"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="7025027696689301916">"Kufizo"</string>
    <string name="battery_tip_unrestrict_app_dialog_title" msgid="5501997201160532301">"Të hiqet kufizimi?"</string>
    <string name="battery_tip_unrestrict_app_dialog_message" msgid="215449637818582819">"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="7940183167721998470">"Hiq"</string>
    <string name="battery_tip_unrestrict_app_dialog_cancel" msgid="4968135709160207507">"Anulo"</string>
    <string name="battery_tip_dialog_summary_message" product="default" msgid="6097167058237891756">"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="573297655597451123">"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="8222461068860745749">"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="3677620516657920364">"Menaxheri i baterisë"</string>
    <string name="smart_battery_title" msgid="9095903608520254254">"Menaxho automatikisht aplikacionet"</string>
    <string name="smart_battery_summary" product="default" msgid="1492277404000064998">"Kufizo baterinë për aplikacionet që nuk i përdor shpesh"</string>
    <string name="smart_battery_footer" msgid="8407121907452993645">"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="6585080822121007436">"Aplikacionet e kufizuara"</string>
    <plurals name="restricted_app_summary" formatted="false" msgid="6059772951505411003">
      <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="3097721884155913252">"Kufizuar <xliff:g id="TIME">%1$s</xliff:g>"</string>
    <string name="restricted_app_detail_footer" msgid="3495725286882138803">"Këto aplikacione nuk mund ta përdorin baterinë kur janë në sfond. Ato mund të mos funksionojnë siç pritet dhe njoftimet mund të vonohen."</string>
    <string name="battery_auto_restriction_title" msgid="827206218118093357">"Përdor \"Menaxherin e baterisë\""</string>
    <string name="battery_auto_restriction_summary" msgid="2140896101984815711">"Zbulo kur aplikacionet shkarkojnë baterinë"</string>
    <string name="battery_manager_summary" msgid="255708681438809287">"Po zbulon kur aplikacionet shkarkojnë baterinë"</string>
    <string name="battery_manager_summary_unsupported" msgid="7334173707292807964">"Po zbulon kur aplikacionet shkarkojnë baterinë"</string>
    <string name="battery_manager_off" msgid="673547668722420924">"Joaktiv"</string>
    <plurals name="battery_manager_app_restricted" formatted="false" msgid="6714534362166394848">
      <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="8371821625994616659">"<xliff:g id="NUMBER">^1</xliff:g>"<small>" "<font size="20">"<xliff:g id="UNIT">%</xliff:g>"</font></small>""</string>
    <string name="battery_missing_message" msgid="400958471814422770">"Problem me leximin e matësit të baterisë."</string>
    <string name="battery_missing_link_message" msgid="6021565067124898074"></string>
    <string name="battery_missing_link_a11y_message" msgid="3310971406602316323">"Trokit për të mësuar më shumë rreth këtij gabimi"</string>
    <string name="dialog_stop_title" msgid="5972757101865665655">"Të ndalohet aplikacioni?"</string>
    <string name="dialog_stop_message" product="default" msgid="2063536418875183799">"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="426862716783569739">"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="4252335402634772603">"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="604462000476810125">"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="7737426241260791605">"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="1820679795932901383">"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="1171516542217183180">"Ndalo aplikacionin"</string>
    <string name="dialog_background_check_title" msgid="8571605969100408762">"Të çaktivizohet përdorimi në sfond dhe të ndalohet aplikacioni?"</string>
    <string name="dialog_background_check_message" product="default" msgid="6203374578970183277">"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="1282389215667916176">"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="8005524265739819577">"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="5792934035264144797">"Çaktivizo"</string>
    <string name="dialog_location_title" msgid="1323400468370901875">"Të çaktivizohet vendndodhja?"</string>
    <string name="dialog_location_message" product="default" msgid="5597959072209122057">"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="7165269165194599595">"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="4606829479989940464">"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="6338680851382069716">"Çaktivizo"</string>
    <string name="power_screen" msgid="4596900105850963806">"Ekrani"</string>
    <string name="power_flashlight" msgid="8993388636332573202">"Blici"</string>
    <string name="power_camera" msgid="4778315081581293923">"Kamera"</string>
    <string name="power_wifi" msgid="4614007837288250325">"Wi‑Fi"</string>
    <string name="power_bluetooth" msgid="5085900180846238196">"Bluetooth-i"</string>
    <string name="power_cell" msgid="7793805106954398186">"Rrjeti celular"</string>
    <string name="power_phone" msgid="2768396619208561670">"Telefonatat zanore"</string>
    <string name="power_idle" product="tablet" msgid="4689321599298911021">"Tableti në gjendje joaktive"</string>
    <string name="power_idle" product="default" msgid="9132502722499465252">"Telefoni në gjendje joaktive"</string>
    <string name="power_unaccounted" msgid="2160811497426475703">"Të ndryshme"</string>
    <string name="power_overcounted" msgid="3681101460287472876">"Numëruar më shumë sa duhet"</string>
    <string name="usage_type_cpu" msgid="8544148642836549011">"CPU-ja në total"</string>
    <string name="usage_type_cpu_foreground" msgid="6120871498122604239">"CPU-ja në plan të parë"</string>
    <string name="usage_type_wake_lock" msgid="3442487584173668904">"Mbaje të zgjuar"</string>
    <string name="usage_type_gps" msgid="4118035982288964651">"GPS"</string>
    <string name="usage_type_wifi_running" msgid="5573404832197356206">"Wi‑Fi në ekzekutim"</string>
    <string name="usage_type_phone" product="tablet" msgid="4527092861928972130">"Tableti"</string>
    <string name="usage_type_phone" product="default" msgid="4149330237181984782">"Telefoni"</string>
    <string name="usage_type_data_send" msgid="4375755152437282184">"Paketat celulare të dërguara"</string>
    <string name="usage_type_data_recv" msgid="7821924049621005218">"Paketat celulare u morën"</string>
    <string name="usage_type_radio_active" msgid="1876069445855950097">"Radioja celulare është aktive"</string>
    <string name="usage_type_data_wifi_send" msgid="6154038607322769558">"Paketat e Wi‑Fi u dërguan"</string>
    <string name="usage_type_data_wifi_recv" msgid="4821128213012023100">"Paketat e Wi‑Fi u morën"</string>
    <string name="usage_type_audio" msgid="1100651355357912864">"Audio"</string>
    <string name="usage_type_video" msgid="1068481638906679035">"Video"</string>
    <string name="usage_type_camera" msgid="3999579307204257822">"Kamera"</string>
    <string name="usage_type_flashlight" msgid="5629235220169383309">"Blici"</string>
    <string name="usage_type_on_time" msgid="104642441471272535">"Koha e lënies ndezur"</string>
    <string name="usage_type_no_coverage" msgid="1385712176630900103">"Koha pa sinjal"</string>
    <string name="usage_type_total_battery_capacity" msgid="3878234027503885998">"Kapaciteti total i baterisë"</string>
    <string name="usage_type_computed_power" msgid="5191902025833668752">"Përdorimi i llogaritur i energjisë"</string>
    <string name="usage_type_actual_power" msgid="1221358930299037926">"Përdorimi i vërejtur i energjisë"</string>
    <string name="battery_action_stop" msgid="6998228610098034316">"Ndalo me forcë"</string>
    <string name="battery_action_app_details" msgid="7201369216798227707">"Informacioni i apl."</string>
    <string name="battery_action_app_settings" msgid="2437124469335488464">"Cilësimet e apl."</string>
    <string name="battery_action_display" msgid="6515712081248863749">"Cilësimet e ekranit"</string>
    <string name="battery_action_wifi" msgid="1829212604573932607">"Cilësimet e Wi-Fi"</string>
    <string name="battery_action_bluetooth" msgid="4723692623358386789">"Cilësimet e Bluetooth-it"</string>
    <string name="battery_desc_voice" msgid="6900799826084022585">"Bateria e përdorur nga telefonatat zanore"</string>
    <string name="battery_desc_standby" product="tablet" msgid="5818742458684767043">"Bateria e përdorur kur tableti nuk është në punë"</string>
    <string name="battery_desc_standby" product="default" msgid="2543075041964578103">"Bateria e përdorur kur telefoni nuk është në punë"</string>
    <string name="battery_desc_radio" msgid="454677140485133914">"Bateria e përdorur nga radioja celulare"</string>
    <string name="battery_sugg_radio" msgid="5476234634503535270">"Kalo te modaliteti \'në aeroplan\" për të kursyer energjinë në zonat pa mbulim të rrjetit celular"</string>
    <string name="battery_desc_flashlight" msgid="6694895513133361404">"Bateria e përdorur nga blici"</string>
    <string name="battery_desc_camera" msgid="6152712271731518018">"Bateria e përdorur nga kamera"</string>
    <string name="battery_desc_display" msgid="7175017688954602685">"Bateria e përdorur nga ekrani dhe drita e sfondit"</string>
    <string name="battery_sugg_display" msgid="3102137296547788111">"Ul ndriçimin e ekranit dhe/ose kohën e pritjes së ekranit"</string>
    <string name="battery_desc_wifi" msgid="5276669172548928768">"Bateria e përdorur nga Wi-Fi"</string>
    <string name="battery_sugg_wifi" msgid="359757575108350109">"Çaktivizo Wi‑Fi kur nuk e përdor ose kur nuk ofrohet"</string>
    <string name="battery_desc_bluetooth" msgid="2237947137783306282">"Bateria e përdorur nga Bluetooth-i"</string>
    <string name="battery_sugg_bluetooth_basic" msgid="8943564578546832037">"Çaktivizo \"Bluetooth-in\" kur nuk e përdor."</string>
    <string name="battery_sugg_bluetooth_headset" msgid="6495519793211758353">"Provo të lidhesh me një pajisje tjetër me \"Bluetooth\""</string>
    <string name="battery_desc_apps" msgid="4187483940383266017">"Bateria e përdorur nga aplikacioni"</string>
    <string name="battery_sugg_apps_info" msgid="4796917242296658454">"Ndalo ose çinstalo aplikacionin"</string>
    <string name="battery_sugg_apps_gps" msgid="7221335088647925110">"Përzgjidh modalitetin e kursimit të baterisë"</string>
    <string name="battery_sugg_apps_settings" msgid="6527223370162382166">"Aplikacioni mund të ofrojë cilësimet për të zvogëluar përdorimin e baterisë"</string>
    <string name="battery_desc_users" msgid="1959428568888686847">"Bateria e përdorur nga përdoruesi"</string>
    <string name="battery_desc_unaccounted" msgid="1649497860893660763">"Përdorime të ndryshme të energjisë"</string>
    <string name="battery_msg_unaccounted" msgid="5647345548624995064">"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="5982079150027267539">"Përdorimi i energjisë i numëruar më shumë sa duhet"</string>
    <string name="mah" msgid="3604527474433227780">"<xliff:g id="NUMBER">%d</xliff:g> mAh"</string>
    <string name="battery_used_for" msgid="6401552215008504483">"Përdorur për <xliff:g id="TIME">^1</xliff:g>"</string>
    <string name="battery_active_for" msgid="4416277218863232476">"Aktiv për <xliff:g id="TIME">^1</xliff:g>"</string>
    <string name="battery_screen_usage" msgid="90008745183187461">"Përdorimi i ekranit <xliff:g id="TIME">^1</xliff:g>"</string>
    <string name="battery_used_by" msgid="6457305178016189330">"<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="8940140259734182014">"<xliff:g id="PERCENT">%1$s</xliff:g> nga e gjithë bateria"</string>
    <string name="battery_detail_since_full_charge" msgid="5650946565524184582">"Analiza që nga karikimi i fundit i plotë"</string>
    <string name="battery_last_full_charge" msgid="8308424441475063956">"Karikimi i fundit i plotë"</string>
    <string name="battery_full_charge_last" msgid="465146408601016923">"Ngarkimi i plotë zgjat rreth"</string>
    <string name="battery_footer_summary" msgid="8221691063048377342">"Të dhënat e përdorimit të baterisë janë të përafërta dhe mund të ndryshojnë bazuar te përdorimi."</string>
    <string name="battery_detail_foreground" msgid="3312280147931093967">"Kur është në përdorim aktiv"</string>
    <string name="battery_detail_background" msgid="3333915023706228000">"Kur është në sfond"</string>
    <string name="battery_detail_power_usage" msgid="1492926471397355477">"Përdorimi i baterisë"</string>
    <string name="battery_detail_info_title" msgid="5896661833554333683">"Që nga karikimi i plotë"</string>
    <string name="battery_detail_manage_title" msgid="7910805419446927887">"Menaxho përdorimin e baterisë"</string>
    <string name="battery_total_and_bg_usage" msgid="8266478675516886819">"<xliff:g id="TIME_0">^1</xliff:g> në total • <xliff:g id="TIME_1">^2</xliff:g> në sfond\nnga karikimi i fundit i plotë"</string>
    <string name="battery_total_and_bg_usage_24hr" msgid="2393832614028187281">"<xliff:g id="TIME_0">^1</xliff:g> në total • <xliff:g id="TIME_1">^2</xliff:g> në sfond\npër 24 orët e fundit"</string>
    <string name="battery_total_and_bg_usage_with_period" msgid="2809037516933951047">"<xliff:g id="TIME_0">^1</xliff:g> në total • <xliff:g id="TIME_1">^2</xliff:g> në sfond\npër <xliff:g id="TIME_PERIOD">^3</xliff:g>"</string>
    <string name="battery_total_usage_less_minute" msgid="7614894994853812076">"Në total më pak se një minutë nga karikimi i fundit i plotë"</string>
    <string name="battery_total_usage_less_minute_24hr" msgid="699268449496083696">"Përdorimi në total: më pak se një minutë për 24 orët e fundit"</string>
    <string name="battery_total_usage_less_minute_with_period" msgid="571923652373556609">"Përdorimi në total: më pak se një minutë për periudhën <xliff:g id="TIME_PERIOD">^1</xliff:g>"</string>
    <string name="battery_bg_usage_less_minute" msgid="3919299699317615641">"Në sfond më pak se një minutë nga karikimi i fundit i plotë"</string>
    <string name="battery_bg_usage_less_minute_24hr" msgid="5016983623297552985">"Në sfond për më pak se një minutë për 24 orët e fundit"</string>
    <string name="battery_bg_usage_less_minute_with_period" msgid="7624741677867017430">"Në sfond për më pak se një minutë për periudhën <xliff:g id="TIME_PERIOD">^1</xliff:g>"</string>
    <string name="battery_total_usage" msgid="4685408616230899847">"<xliff:g id="TIME">^1</xliff:g> në total nga karikimi i fundit i plotë"</string>
    <string name="battery_total_usage_24hr" msgid="3907495067623665787">"<xliff:g id="TIME">^1</xliff:g> në total për 24 orët e fundit"</string>
    <string name="battery_total_usage_with_period" msgid="2849061229625950626">"<xliff:g id="TIME_0">^1</xliff:g> në total për periudhën <xliff:g id="TIME_PERIOD">^2</xliff:g>"</string>
    <string name="battery_bg_usage" msgid="548670902301883980">"<xliff:g id="TIME">^1</xliff:g> në sfond nga karikimi i fundit i plotë"</string>
    <string name="battery_bg_usage_24hr" msgid="1999734910656674710">"<xliff:g id="TIME">^1</xliff:g> në sfond për 24 orët e fundit"</string>
    <string name="battery_bg_usage_with_period" msgid="992952174445045711">"<xliff:g id="TIME_0">^1</xliff:g> në sfond për periudhën <xliff:g id="TIME_PERIOD">^2</xliff:g>"</string>
    <string name="battery_total_usage_and_bg_less_minute_usage" msgid="1460882261983325026">"<xliff:g id="TIME">^1</xliff:g> në total • në sfond më pak se një minutë\nnga karikimi i fundit i plotë"</string>
    <string name="battery_total_usage_and_bg_less_minute_usage_24hr" msgid="1721830675789709748">"<xliff:g id="TIME">^1</xliff:g> në total • në sfond më pak se një minutë\npër 24 orët e fundit"</string>
    <string name="battery_total_usage_and_bg_less_minute_usage_with_period" msgid="5943281928474598517">"<xliff:g id="TIME_0">^1</xliff:g> në total • në sfond për më pak se një minutë\npër <xliff:g id="TIME_PERIOD">^2</xliff:g>"</string>
    <string name="battery_not_usage" msgid="1472275761547230196">"Pa përdorim nga karikimi i fundit i plotë"</string>
    <string name="battery_not_usage_24hr" msgid="8397519536160741248">"Nuk është përdorur për 24 orët e fundit"</string>
    <string name="battery_usage_without_time" msgid="1346894834339420538"></string>
    <string name="advanced_battery_graph_subtext" msgid="6816737986172678550">"Përllogaritja për baterinë e mbetur bazohet në përdorimin e pajisjes tënde"</string>
    <string name="estimated_time_left" msgid="948717045180211777">"Koha e vlerësuar e mbetur"</string>
    <string name="estimated_charging_time_left" msgid="2287135413363961246">"Deri në ngarkimin e plotë"</string>
    <string name="estimated_time_description" msgid="211058785418596009">"Vlerësimi mund të ndryshojë sipas përdorimit"</string>
    <string name="menu_stats_unplugged" msgid="7125297366200634285">"<xliff:g id="UNPLUGGED">%1$s</xliff:g> që kur ka qenë në prizë"</string>
    <string name="menu_stats_last_unplugged" msgid="230678127178268655">"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="2713445396954503670">"Totalet e përdorimit"</string>
    <string name="menu_stats_refresh" msgid="6727628139586938835">"Rifresko"</string>
    <string name="process_mediaserver_label" msgid="6135260215912215092">"Serveri i medias"</string>
    <string name="process_dex2oat_label" msgid="1190208677726583153">"Optimizimi i aplikacionit"</string>
    <string name="process_network_tethering" msgid="6822671758152900766">"Ndarja e internetit"</string>
    <string name="process_removed_apps" msgid="6544406592678476902">"Aplikacionet e hequra"</string>
    <string name="battery_saver" msgid="7737147344510595864">"Kursyesi i baterisë"</string>
    <string name="battery_saver_auto_title" msgid="6789753787070176144">"Aktivizo automatikisht"</string>
    <string name="battery_saver_auto_no_schedule" msgid="5123639867350138893">"Nuk ka asnjë orar"</string>
    <string name="battery_saver_auto_routine" msgid="4656495097900848608">"Bazuar në rutinën tënde"</string>
    <string name="battery_saver_pref_auto_routine_summary" msgid="4739240095966241508">"Do të aktivizohet bazuar në rutinën tënde"</string>
    <string name="battery_saver_auto_percentage" msgid="558533724806281980">"Bazuar në përqindjen"</string>
    <string name="battery_saver_auto_routine_summary" msgid="3913145448299472628">"\"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="6190884450723824287">"Do të aktivizohet në <xliff:g id="PERCENT">%1$s</xliff:g>"</string>
    <string name="battery_saver_schedule_settings_title" msgid="3688019979950082237">"Cakto një orar"</string>
    <string name="battery_saver_turn_on_summary" msgid="1433919417587171160">"Rrit kohëzgjatjen e baterisë"</string>
    <string name="battery_saver_sticky_title_new" msgid="5942813274115684599">"Çaktivizo kur të karikohet"</string>
    <string name="battery_saver_sticky_description_new" product="default" msgid="492221102651829607">"\"Kursyesi i baterisë\" çaktivizohet kur telefoni yt karikohet mbi <xliff:g id="NUMBER">^1</xliff:g><xliff:g id="UNIT">%</xliff:g>"</string>
    <string name="battery_saver_sticky_description_new" product="tablet" msgid="4566426833434375284">"\"Kursyesi i baterisë\" çaktivizohet kur tableti yt karikohet mbi <xliff:g id="NUMBER">^1</xliff:g><xliff:g id="UNIT">%</xliff:g>"</string>
    <string name="battery_saver_sticky_description_new" product="device" msgid="4128841327359445726">"\"Kursyesi i baterisë\" çaktivizohet kur pajisja jote karikohet mbi <xliff:g id="NUMBER">^1</xliff:g><xliff:g id="UNIT">%</xliff:g>"</string>
    <!-- no translation found for battery_saver_seekbar_title (3712266470054006641) -->
    <skip />
    <string name="battery_saver_seekbar_title_placeholder" msgid="7141264642540687540">"Aktivizo"</string>
    <string name="battery_saver_master_switch_title" msgid="3474312070095834915">"Përdor \"Kursyesin e baterisë\""</string>
    <string name="battery_saver_turn_on_automatically_title" msgid="7857393318205740864">"Aktivizim automatikisht"</string>
    <string name="battery_saver_turn_on_automatically_never" msgid="6194649389871448663">"Asnjëherë"</string>
    <string name="battery_saver_turn_on_automatically_pct" msgid="4294335680892392449">"me <xliff:g id="PERCENT">%1$s</xliff:g> bateri"</string>
    <string name="battery_percentage" msgid="1779934245963043490">"Përqindja e baterisë"</string>
    <string name="battery_percentage_description" msgid="2321465139126125541">"Shfaq përqindjen e baterisë në shiritin e statusit"</string>
    <string name="battery_usage_chart_graph_hint" msgid="9182079098173323005">"Niveli i baterisë për 24 orët e fundit"</string>
    <string name="battery_app_usage_for_past_24" msgid="1234770810563940656">"Përdorimi i aplikacionit për 24 orët e fundit"</string>
    <string name="battery_system_usage_for_past_24" msgid="3341520273114616263">"Përdorimi i sistemit për 24 orët e fundit"</string>
    <string name="battery_system_usage_for" msgid="3248552137819897140">"Përdorimi i sistemit për: <xliff:g id="SLOT">%s</xliff:g>"</string>
    <string name="battery_app_usage_for" msgid="7309909074935858949">"Përdorimi i aplikacionit për: <xliff:g id="SLOT">%s</xliff:g>"</string>
    <string name="battery_usage_total_less_than_one_minute" msgid="1035425863251685509">"Në total: më pak se një minutë"</string>
    <string name="battery_usage_background_less_than_one_minute" msgid="3957971442554437909">"Në sfond: më pak se një minutë"</string>
    <string name="battery_usage_for_total_time" msgid="8402254046930910905">"Në total: <xliff:g id="TIME">%s</xliff:g>"</string>
    <string name="battery_usage_for_background_time" msgid="9109637210617095188">"Në sfond: <xliff:g id="TIME">%s</xliff:g>"</string>
    <string name="battery_usage_screen_footer" msgid="7899907241146636817">"Të dhënat e përdorimit të baterisë janë të përafërta dhe nuk masin përdorimin gjatë karikimit të telefonit"</string>
    <string name="battery_usage_screen_footer_empty" msgid="115806339713068930">"Të dhënat e përdorimit të baterisë do të ofrohen pasi të përdorësh telefonin për disa orë"</string>
    <string name="battery_usage_chart" msgid="4114747521432440017">"Grafiku i përdorimit të baterisë"</string>
    <string name="process_stats_summary_title" msgid="502683176231281732">"Statistikat e procesit"</string>
    <string name="process_stats_summary" msgid="522842188571764699">"Statistikat teknike për proceset në ekzekutim"</string>
    <string name="app_memory_use" msgid="7559666138324410666">"Përdorimi i memories"</string>
    <string name="process_stats_total_duration" msgid="3898635541254636618">"<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="4391502694312709148">"<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="4094034441562453522">"Sfondi"</string>
    <string name="process_stats_type_foreground" msgid="5043049335546793803">"Plani i parë"</string>
    <string name="process_stats_type_cached" msgid="129788969589599563">"Në memorien specifike"</string>
    <string name="process_stats_os_label" msgid="2096501347732184886">"Sistemi operativ Android"</string>
    <string name="process_stats_os_native" msgid="794547105037548539">"Vendas"</string>
    <string name="process_stats_os_kernel" msgid="5626269994512354996">"Bërthamë"</string>
    <string name="process_stats_os_zram" msgid="3067278664868354143">"Z-Ram"</string>
    <string name="process_stats_os_cache" msgid="4753163023524305711">"Memoriet specifike"</string>
    <string name="process_stats_ram_use" msgid="5966645638783509937">"Përdorimi i RAM-it"</string>
    <string name="process_stats_bg_ram_use" msgid="3572439697306771461">"Përdorimi i RAM-it (sfond)"</string>
    <string name="process_stats_run_time" msgid="8631920944819076418">"Koha në funksionim"</string>
    <string name="processes_subtitle" msgid="5791138718719605724">"Përpunime"</string>
    <string name="services_subtitle" msgid="9136741140730524046">"Shërbimet"</string>
    <string name="menu_proc_stats_duration" msgid="1249684566371309908">"Kohëzgjatja"</string>
    <string name="mem_details_title" msgid="8064756349669711949">"Detajet e memories"</string>
    <string name="menu_duration_3h" msgid="9202635114831885878">"3 orë"</string>
    <string name="menu_duration_6h" msgid="2843895006519153126">"6 orë"</string>
    <string name="menu_duration_12h" msgid="9206922888181602565">"12 orë"</string>
    <string name="menu_duration_1d" msgid="8538390358158862330">"1 ditë"</string>
    <string name="menu_show_system" msgid="3780310384799907818">"Shfaq sistemin"</string>
    <string name="menu_hide_system" msgid="5197937451381420622">"Fshih sistemin"</string>
    <string name="menu_show_percentage" msgid="6143205879027928330">"Tregoji në përqindje"</string>
    <string name="menu_use_uss" msgid="1663914348353623749">"Përdor Uss-në"</string>
    <string name="menu_proc_stats_type" msgid="5048575824389855689">"Lloji i statistikave"</string>
    <string name="menu_proc_stats_type_background" msgid="6796434633192284607">"Sfondi"</string>
    <string name="menu_proc_stats_type_foreground" msgid="9011432748521890803">"Në plan të parë"</string>
    <string name="menu_proc_stats_type_cached" msgid="1351321959600144622">"Në memorien specifike"</string>
    <string name="voice_input_output_settings" msgid="1055497319048272051">"Hyrjet dhe daljet e zërit"</string>
    <string name="voice_input_output_settings_title" msgid="6449454483955543064">"Cilësimet e hyrjes dhe daljes së zërit"</string>
    <string name="voice_search_settings_title" msgid="228743187532160069">"Kërkimi me zë"</string>
    <string name="keyboard_settings_title" msgid="2199286020368890114">"Tastierë për \"Android\""</string>
    <string name="voice_input_settings" msgid="105821652985768064">"Cilësimet e hyrjes zanore"</string>
    <string name="voice_input_settings_title" msgid="3708147270767296322">"Hyrja zanore"</string>
    <string name="voice_service_preference_section_title" msgid="4807795449147187497">"Shërbime të hyrjes zanore"</string>
    <string name="voice_interactor_preference_summary" msgid="3942881638813452880">"Ndërveprimi dhe fjalëkyçi i aktivizimit (hotword), i plotë"</string>
    <string name="voice_recognizer_preference_summary" msgid="9195427725367463336">"Shërbim i thjeshtë \"ligjërim-në-tekst\""</string>
    <string name="voice_interaction_security_warning" msgid="7962884055885987671">"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="7808775764174571132">"Motori i preferuar"</string>
    <string name="tts_engine_settings_title" msgid="1298093555056321577">"Cilësimet e motorit"</string>
    <string name="tts_sliders_title" msgid="6901146958648426181">"Shpejtësia e të folurës dhe intonacioni"</string>
    <string name="tts_engine_section_title" msgid="5115035218089228451">"Motori"</string>
    <string name="tts_install_voice_title" msgid="5133545696447933812">"Zërat"</string>
    <string name="tts_spoken_language" msgid="4652894245474520872">"Gjuha e folur"</string>
    <string name="tts_install_voices_title" msgid="6505257816336165782">"Instalo zërat"</string>
    <string name="tts_install_voices_text" msgid="902408506519246362">"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="919034855418197668">"Hap aplikacionin"</string>
    <string name="tts_install_voices_cancel" msgid="5179154684379560628">"Anulo"</string>
    <string name="tts_reset" msgid="9047681050813970031">"Rivendos"</string>
    <string name="tts_play" msgid="2945513377250757221">"Luaj"</string>
    <string name="vpn_settings_title" msgid="9131315656202257272">"VPN"</string>
    <string name="vpn_settings_insecure_single" msgid="9012504179995045195">"Jo i sigurt"</string>
    <string name="vpn_settings_single_insecure_multiple_total" msgid="6107225844641301139">"<xliff:g id="VPN_COUNT">%d</xliff:g> jo i sigurt"</string>
    <string name="vpn_settings_multiple_insecure_multiple_total" msgid="1706236062478680488">"<xliff:g id="VPN_COUNT">%d</xliff:g> jo i sigurt"</string>
    <string name="adaptive_connectivity_title" msgid="7464959640138428192">"Lidhshmëria me përshtatje"</string>
    <string name="adaptive_connectivity_summary" msgid="3648731530666326885">"Rrit kohëzgjatjen e baterisë dhe përmirëson cilësinë e funksionimit të pajisjes duke menaxhuar automatikisht lidhjet e rrjetit"</string>
    <string name="adaptive_connectivity_switch_on" msgid="3653067561620745493">"Aktive"</string>
    <string name="adaptive_connectivity_switch_off" msgid="5076172560836115265">"Joaktive"</string>
    <string name="credentials_title" msgid="7535942196886123656">"Ruajtja e kredencialeve"</string>
    <string name="credentials_install" msgid="3933218407598415827">"Instalo një certifikatë"</string>
    <string name="credentials_install_summary" product="nosdcard" msgid="6644116499934553975">"Instalo certifikatat nga hapësira ruajtëse"</string>
    <string name="credentials_install_summary" product="default" msgid="8161351950524166012">"Instalo certifikatat nga karta SD"</string>
    <string name="credentials_reset" msgid="4246628389366452655">"Pastro kredencialet"</string>
    <string name="credentials_reset_summary" msgid="5400585520572874255">"Hiqi të gjitha certifikatat"</string>
    <string name="trusted_credentials" msgid="2522784976058244683">"Kredencialet e besuara"</string>
    <string name="trusted_credentials_summary" msgid="345822338358409468">"Shfaq certifikatat CA të besuara"</string>
    <string name="user_credentials" msgid="4044405430790970775">"Kredencialet e përdoruesit"</string>
    <string name="user_credentials_summary" msgid="686471637627271856">"Shiko dhe modifiko kredencialet e ruajtura"</string>
    <string name="advanced_security_title" msgid="7117581975877192652">"Të përparuara"</string>
    <string name="credentials_settings_not_available" msgid="7433088409177429600">"Kredencialet nuk ofrohen për këtë përdorues"</string>
    <string name="credential_for_vpn_and_apps" msgid="2208229692860871136">"Instaluar për VPN dhe aplikacione"</string>
    <string name="credential_for_wifi" msgid="1963335263280604998">"Instaluar për Wi-Fi"</string>
    <string name="credentials_reset_hint" msgid="4054601857203464867">"Të hiqen të gjitha përmbajtjet?"</string>
    <string name="credentials_erased" msgid="9121052044566053345">"Hapësira ruajtëse e kredencialeve është spastruar."</string>
    <string name="credentials_not_erased" msgid="3611058412683184031">"Ruajtja e kred. s\'mund të fshihej."</string>
    <string name="usage_access_title" msgid="1580006124578134850">"Aplikacione me qasje te përdorimi"</string>
    <string name="ca_certificate" msgid="3076484307693855611">"Certifikata CA"</string>
    <string name="user_certificate" msgid="6897024598058566466">"Cert. e përdoruesit të VPN-së dhe apl."</string>
    <string name="wifi_certificate" msgid="8461905432409380387">"Certifikata e Wi‑Fi"</string>
    <string name="ca_certificate_warning_title" msgid="7951148441028692619">"Të dhënat e tua nuk do të jenë private"</string>
    <string name="ca_certificate_warning_description" msgid="8409850109551028774">"Certifikatat CA përdoren nga sajtet e uebit, aplikacionet dhe VPN-të për enkriptim. Instalo vetëm certifikata CA nga organizatat që u beson. \n\nNëse instalon një certifikatë CA, zotëruesi i certifikatës mund të qaset te të dhënat e tua, si p.sh. fjalëkalimet ose detajet e kartave të kreditit, nga sajtet e uebit që viziton ose aplikacionet që përdor, edhe nëse të dhënat e tua janë të enkriptuara."</string>
    <string name="certificate_warning_dont_install" msgid="3794366420884560605">"Mos e instalo"</string>
    <string name="certificate_warning_install_anyway" msgid="4633118283407228740">"Instalo gjithsesi"</string>
    <string name="cert_not_installed" msgid="6725137773549974522">"Certifikata nuk u instalua"</string>
    <string name="request_manage_credentials_title" msgid="596805634568013413">"Të lejohet që "<b>"<xliff:g id="APP_NAME">^1</xliff:g>"</b>" t\'i instalojë certifikatat në këtë pajisje?"</string>
    <string name="request_manage_credentials_description" msgid="8044839857171509619">"Këto certifikat do të të verifikojnë duke shpërndarë ID-në unike të pajisjes me aplikacionet dhe URL-të e mëposhtme"</string>
    <string name="request_manage_credentials_dont_allow" msgid="3630610197644877809">"Mos lejo"</string>
    <string name="request_manage_credentials_allow" msgid="4910940118408348245">"Lejo"</string>
    <string name="request_manage_credentials_more" msgid="6101210283534101582">"Shfaq më shumë"</string>
    <string name="certificate_management_app" msgid="8086699498358080826">"Aplikacioni i menaxhimit të certifikatave"</string>
    <string name="no_certificate_management_app" msgid="3025739370424406717">"Asnjë"</string>
    <string name="certificate_management_app_description" msgid="8507306554200869005">"Certifikatat do të të verifikojnë kur të përdorësh aplikacionet dhe URL-të e mëposhtme"</string>
    <string name="uninstall_certs_credential_management_app" msgid="4945883254446077354">"Çinstalo certifikatat"</string>
    <string name="remove_credential_management_app" msgid="6089291496976812786">"Hiqe aplikacionin"</string>
    <string name="remove_credential_management_app_dialog_title" msgid="5713525435104706772">"Të hiqet ky aplikacion?"</string>
    <string name="remove_credential_management_app_dialog_message" msgid="7739474298063646935">"Ky aplikacion nuk do t\'i menaxhojë certifikatat, por do të qëndrojë në pajisjen tënde. Çdo certifikatë e instaluar nga aplikacioni do të çinstalohet."</string>
    <plurals name="number_of_urls" formatted="false" msgid="403979258551655023">
      <item quantity="other"><xliff:g id="NUMBER_1">%d</xliff:g> URL</item>
      <item quantity="one"><xliff:g id="NUMBER_0">%d</xliff:g> URL</item>
    </plurals>
    <string name="emergency_tone_title" msgid="6673118505206685168">"Sinjali i telefonimit të urgjencës"</string>
    <string name="emergency_tone_summary" msgid="2519776254708767388">"Cakto sjelljen kur kryhet një telefonatë urgjence"</string>
    <string name="privacy_settings_title" msgid="6437057228255974577">"Rezervimi"</string>
    <string name="backup_summary_state_on" msgid="9018954639693085240">"Aktiv"</string>
    <string name="backup_summary_state_off" msgid="5341339397224835909">"Joaktiv"</string>
    <string name="backup_section_title" msgid="6539706829848457794">"Rezervo dhe restauro"</string>
    <string name="personal_data_section_title" msgid="6368610168625722682">"Të dhënat personale"</string>
    <string name="backup_data_title" msgid="507663517227498525">"Rezervo të dhënat e mia"</string>
    <string name="backup_data_summary" msgid="8054551085241427531">"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="8574055186903658842">"Llogaria rezervë"</string>
    <string name="backup_data_management_title" msgid="6596830198441939702">"Menaxho llogarinë e rezervimit"</string>
    <string name="include_app_data_title" msgid="2969603876620594523">"Përfshi të dhënat e aplikacionit"</string>
    <string name="auto_restore_title" msgid="4124345897936637561">"Restaurimi automatik"</string>
    <string name="auto_restore_summary" msgid="6830198851045584001">"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="6753265378043349277">"Shërbimi i rezervimit nuk është aktiv"</string>
    <string name="backup_configure_account_default_summary" msgid="5323225330966306690">"Asnjë llogari nuk po ruan aktualisht të dhënat e kopjes rezervë"</string>
    <string name="backup_erase_dialog_title" msgid="5892431263348766484"></string>
    <string name="backup_erase_dialog_message" msgid="2250872501409574331">"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="2379053988557486162">"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="971587401251601473">"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="31392408594557070">"Cilësimet e administratorit të pajisjes"</string>
    <string name="active_device_admin_msg" msgid="7744106305636543184">"Apl. i administrimit të pajisjes"</string>
    <string name="remove_device_admin" msgid="3143059558744287259">"Çaktivizo këtë aplikacion të administrimit të pajisjes"</string>
    <string name="uninstall_device_admin" msgid="4481095209503956916">"Çinstalo aplikacionin"</string>
    <string name="remove_and_uninstall_device_admin" msgid="707912012681691559">"Çaktivizo dhe çinstalo"</string>
    <string name="select_device_admin_msg" msgid="5501360309040114486">"Apl. e admin. të pajisjes"</string>
    <string name="no_device_admins" msgid="8888779888103079854">"Nuk ka asnjë aplikacion të administrimit të pajisjes në dispozicion"</string>
    <string name="no_trust_agents" msgid="8659098725864191600">"Nuk mundësohet asnjë agjent i besuar"</string>
    <string name="add_device_admin_msg" msgid="7730006568970042119">"Të aktivizohet apl. i admin. të pajisjes?"</string>
    <string name="add_device_admin" msgid="6252128813507932519">"Aktivizo këtë aplikacion të administrimit të pajisjes"</string>
    <string name="device_admin_add_title" msgid="6087481040932322289">"Administratori i pajisjes"</string>
    <string name="device_admin_warning" msgid="1889160106787280321">"Aktivizimi i këtij aplikacioni të administrimit 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="2715756519899116115">"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="6332571781623084064">"Ky aplikacion administrimi ë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="2774489881662331549">"Të aktivizohet menaxheri i profilit?"</string>
    <string name="profile_owner_add_title_simplified" msgid="2320828996993774182">"Të lejohet mbikëqyrja?"</string>
    <string name="adding_profile_owner_warning" msgid="6868275476058020513">"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="8122039047419172139">"Opsionet e tjera janë çaktivizuar nga administratori yt"</string>
    <string name="admin_more_details" msgid="4928985331640193758">"Mëso më shumë"</string>
    <string name="notification_log_title" msgid="2812594935014664891">"Regjistri i njoftimeve"</string>
    <string name="notification_history_title" msgid="8821060912502593309">"Historiku i njoftimeve"</string>
    <string name="notification_history_today" msgid="5828496957208237230">"24 orët e fundit"</string>
    <string name="notification_history_snooze" msgid="3980568893290512257">"Shtyrë"</string>
    <string name="notification_history_dismiss" msgid="6180321217375722918">"Hequr së fundi"</string>
    <plurals name="notification_history_count" formatted="false" msgid="1859304685071321991">
      <item quantity="other"><xliff:g id="NUMBER_1">%d</xliff:g> njoftime</item>
      <item quantity="one"><xliff:g id="NUMBER_0">%d</xliff:g> njoftim</item>
    </plurals>
    <string name="sound_category_call_ringtone_vibrate_title" msgid="9090693401915654528">"Zilja dhe dridhja e telefonit."</string>
    <string name="wifi_setup_detail" msgid="2012898800571616422">"Detajet e rrjetit"</string>
    <string name="accessibility_sync_enabled" msgid="5308864640407050209">"Sinkronizimi u aktivizua"</string>
    <string name="accessibility_sync_disabled" msgid="5507600126380593611">"Sinkronizimi u çaktivizua"</string>
    <string name="accessibility_sync_in_progress" msgid="3229428197779196660">"Po sinkronizon tani"</string>
    <string name="accessibility_sync_error" msgid="7248490045013170437">"Gabim në sinkronizim."</string>
    <string name="sync_failed" msgid="3806495232114684984">"Sinkronizimi dështoi"</string>
    <string name="sync_active" msgid="5787407579281739975">"Sinkronizimi është aktiv"</string>
    <string name="account_sync_settings_title" msgid="2684888109902800966">"Sinkronizo"</string>
    <string name="sync_is_failing" msgid="6738004111400633331">"Sinkronizimi ka aktualisht probleme. Do të ofrohet sërish së shpejti."</string>
    <string name="add_account_label" msgid="7134707140831385869">"Shto një llogari"</string>
    <string name="managed_profile_not_available_label" msgid="7500578232182547365">"Profili i punës nuk ofrohet ende"</string>
    <string name="work_mode_label" msgid="1001415270126064436">"Profili i punës"</string>
    <string name="work_mode_on_summary" msgid="2042885311126239961">"Menaxhohet nga organizata jote"</string>
    <string name="work_mode_off_summary" msgid="4044568753909036134">"Aplikacionet dhe njoftimet janë joaktive"</string>
    <string name="remove_managed_profile_label" msgid="1294933737673830431">"Hiq profilin e punës"</string>
    <string name="background_data" msgid="321903213000101158">"Të dhënat në sfond"</string>
    <string name="background_data_summary" msgid="6572245922513522466">"Aplikacionet mund të sinkronizojnë, dërgojnë dhe marrin të dhëna në çdo kohë"</string>
    <string name="background_data_dialog_title" msgid="1692005302993229867">"Të çaktivizohen të dhënat në sfond?"</string>
    <string name="background_data_dialog_message" msgid="7760280837612824670">"Ҫ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="4874122892765430304">"Auto-sinkronizo të dhënat e apl."</string>
    <string name="sync_enabled" msgid="5794103781356455043">"Sinkronizimi është aktiv"</string>
    <string name="sync_disabled" msgid="1636223106968593391">"Sinkronizimi është JOAKTIV"</string>
    <string name="sync_error" msgid="846923369794727644">"Gabim gjatë sinkronizimit"</string>
    <string name="last_synced" msgid="1527008461298110443">"Sinkronizimi i fundit më <xliff:g id="LAST_SYNC_TIME">%1$s</xliff:g>"</string>
    <string name="sync_in_progress" msgid="6200093151211458977">"Po sinkronizon tani…"</string>
    <string name="settings_backup" msgid="5357973563989458049">"Cilësimet e rezervimit"</string>
    <string name="settings_backup_summary" msgid="6803046376335724034">"Rezervo cilësimet e mia"</string>
    <string name="sync_menu_sync_now" msgid="3948443642329221882">"Sinkronizo tani"</string>
    <string name="sync_menu_sync_cancel" msgid="2422994461106269813">"Anulo sinkronizimin"</string>
    <string name="sync_one_time_sync" msgid="8114337154112057462">"Trokit për ta sinkronizuar tani<xliff:g id="LAST_SYNC_TIME">
%1$s</xliff:g>"</string>
    <string name="sync_gmail" msgid="228561698646018808">"Gmail"</string>
    <string name="sync_calendar" msgid="4603704438090387251">"Kalendari"</string>
    <string name="sync_contacts" msgid="2376465611511325472">"Kontaktet"</string>
    <string name="sync_plug" msgid="7956982719077985381"><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="7427706834875419243">"Cilësimet e sinkronizimit të apl."</string>
    <string name="header_data_and_synchronization" msgid="453920312552838939">"Të dhënat dhe sinkronizimi"</string>
    <string name="preference_change_password_title" msgid="5465821666939825972">"Ndërro fjalëkalimin"</string>
    <string name="header_account_settings" msgid="1189339410278750008">"Cilësimet e llogarisë"</string>
    <string name="remove_account_label" msgid="4169490568375358010">"Hiq llogarinë"</string>
    <string name="header_add_an_account" msgid="3919151542338822661">"Shto një llogari"</string>
    <string name="really_remove_account_title" msgid="253097435885652310">"Të hiqet llogaria?"</string>
    <string name="really_remove_account_message" product="tablet" msgid="8893801622174947887">"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="1217810840427479274">"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="5241756807386611084">"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="3709502163548900644">"Ky ndryshim nuk lejohet nga administratori yt"</string>
    <string name="cant_sync_dialog_title" msgid="2613000568881139517">"Nuk mund të sinkronizojë manualisht"</string>
    <string name="cant_sync_dialog_message" msgid="7612557105054568581">"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="delete" msgid="8330605554706263775">"Fshi"</string>
    <string name="misc_files" msgid="6598066985800749585">"Skedarë të ndryshëm"</string>
    <string name="misc_files_selected_count" msgid="5597802791672749532">"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="7622766714974500289">"<xliff:g id="NUMBER">%1$s</xliff:g> nga <xliff:g id="TOTAL">%2$s</xliff:g>"</string>
    <string name="select_all" msgid="7898929601615536401">"Përzgjidhi të gjtiha"</string>
    <string name="data_usage_summary_title" msgid="394067070764360142">"Përdorimi i të dhënave"</string>
    <string name="data_usage_app_summary_title" msgid="4933742247928064178">"Të dhënat celulare dhe Wi‑Fi"</string>
    <string name="data_usage_accounting" msgid="6832015632699116754">"Llogaritja e të dhënave nga operatori mund të ndryshojë nga ajo e pajisjes tënde."</string>
    <string name="data_usage_app" msgid="6367974637783240699">"Përdorimi i aplikacionit"</string>
    <string name="data_usage_app_info_label" msgid="3542220416056122841">"INFORMACIONI I APL."</string>
    <string name="data_usage_cellular_data" msgid="1917226172511825849">"Të dhënat celulare"</string>
    <string name="data_usage_data_limit" msgid="1120291692444009289">"Cakto kufirin e të dhënave"</string>
    <string name="data_usage_cycle" msgid="6875568429140150029">"Cikli i përdorimit të të dhënave"</string>
    <string name="data_usage_app_items_header_text" msgid="7513812163443595033">"Përdorimi i aplikacionit"</string>
    <string name="data_usage_menu_roaming" msgid="6864561338842056939">"Të dhënat në roaming"</string>
    <string name="data_usage_menu_restrict_background" msgid="1414574366645086133">"Kufizo të dhënat në sfond"</string>
    <string name="data_usage_menu_allow_background" msgid="6242931073390680432">"Lejo të dhënat në sfond"</string>
    <string name="data_usage_menu_split_4g" msgid="3391899816926640583">"Përdorimi i 4G i ndarë"</string>
    <string name="data_usage_menu_show_wifi" msgid="6380926350184939975">"Shfaq Wi-Fi"</string>
    <string name="data_usage_menu_hide_wifi" msgid="4694889089278302691">"Fshih Wi-Fi"</string>
    <string name="data_usage_menu_show_ethernet" msgid="4401026240876938859">"Shfaq përdorimin e Eternetit"</string>
    <string name="data_usage_menu_hide_ethernet" msgid="7792365022467586772">"Fshih përdorimin e eternetit"</string>
    <string name="data_usage_menu_metered" msgid="4279260736172851951">"Kufizimet e rrjetit"</string>
    <string name="data_usage_menu_auto_sync" msgid="2632694000068175025">"Të dhënat e autosinkronizimit"</string>
    <string name="data_usage_menu_sim_cards" msgid="8966135605336735887">"Kartat SIM"</string>
    <string name="data_usage_cellular_data_summary" msgid="8139993171126153316">"U ndërpre në kufi"</string>
    <string name="account_settings_menu_auto_sync" msgid="1660484779001900562">"Auto-sinkronizo të dhënat"</string>
    <string name="account_settings_menu_auto_sync_personal" msgid="2905595464540145671">"Sinkronizo automatikisht të dhënat personale"</string>
    <string name="account_settings_menu_auto_sync_work" msgid="8561102487795657789">"Sinkronizo automatikisht të dhënat e punës"</string>
    <string name="data_usage_change_cycle" msgid="4501026427365283899">"Ndrysho ciklin…"</string>
    <string name="data_usage_pick_cycle_day" msgid="3548922497494790123">"Dita për rivendosjen e ciklit të përdorimit të të dhënave:"</string>
    <string name="data_usage_empty" msgid="5619908658853726866">"Nuk janë përdorur të dhëna gjatë kësaj periudhe."</string>
    <string name="data_usage_label_foreground" msgid="8782117644558473624">"Plani i parë"</string>
    <string name="data_usage_label_background" msgid="8862781660427421859">"Sfondi"</string>
    <string name="data_usage_app_restricted" msgid="312065316274378518">"i kufizuar"</string>
    <string name="data_usage_disable_mobile" msgid="6183809500102606801">"Të çaktivizohen të dhënat celulare?"</string>
    <string name="data_usage_disable_mobile_limit" msgid="1370147078938479538">"Cakto kufirin e të dhënave"</string>
    <string name="data_usage_disable_4g_limit" msgid="3084868504051520840">"Cakto kufirin e të dhënave 4G"</string>
    <string name="data_usage_disable_3g_limit" msgid="8867555130268898044">"Cakto kufirin për 2G-3G"</string>
    <string name="data_usage_disable_wifi_limit" msgid="7222459951785404241">"Cakto kufirin e të dhënave të Wi-Fi"</string>
    <string name="data_usage_tab_wifi" msgid="801667863336456787">"Wi‑Fi"</string>
    <string name="data_usage_tab_ethernet" msgid="2951873059375493878">"Eternet"</string>
    <string name="data_usage_tab_mobile" msgid="952231704205870928">"Celulare"</string>
    <string name="data_usage_tab_4g" msgid="3265237821331861756">"4G"</string>
    <string name="data_usage_tab_3g" msgid="6111070409752123049">"2G-3G"</string>
    <string name="data_usage_list_mobile" msgid="3738130489722964291">"Celulare"</string>
    <string name="data_usage_list_none" msgid="2091924522549134855">"Asnjë"</string>
    <string name="data_usage_enable_mobile" msgid="1996943748103310201">"Të dhënat celulare"</string>
    <string name="data_usage_enable_3g" msgid="2818189799905446932">"Të dhënat 2G-3G"</string>
    <string name="data_usage_enable_4g" msgid="1526584080251993023">"Të dhënat 4G"</string>
    <string name="data_roaming_enable_mobile" msgid="5745287603577995977">"Roaming"</string>
    <string name="data_usage_forground_label" msgid="5762048187044975428">"Plani i parë:"</string>
    <string name="data_usage_background_label" msgid="5363718469293175279">"Sfondi:"</string>
    <string name="data_usage_app_settings" msgid="5693524672522122485">"Cilësimet e apl."</string>
    <string name="data_usage_app_restrict_background" msgid="5728840276368097276">"Të dhënat në sfond"</string>
    <string name="data_usage_app_restrict_background_summary" msgid="2997942775999602794">"Aktivizo përdorimin e të dhënave celulare në sfond"</string>
    <string name="data_usage_app_restrict_background_summary_disabled" msgid="8213268097024597864">"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="5383874438677899255">"Të kufizohen të dhënat në sfond?"</string>
    <string name="data_usage_app_restrict_dialog" msgid="5534272311979978297">"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="8599940395497268584">"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="2048411447974361181">"Të aktivizohen të dhënat e sinkronizimit automatik?"</string>
    <string name="data_usage_auto_sync_on_dialog" product="tablet" msgid="6387714350903085918">"Ç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="6457107552266187107">"Ç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="1783917145440587470">"Të çaktivizohen të dhënat e sinkronizimit automatik?"</string>
    <string name="data_usage_auto_sync_off_dialog" msgid="6523112583569674837">"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="2019035830921480941">"Data e rivendosjes së ciklit të përdorimit"</string>
    <string name="data_usage_cycle_editor_subtitle" msgid="1026234456777365545">"Data e secilit muaj:"</string>
    <string name="data_usage_cycle_editor_positive" msgid="6110165528024717527">"Cakto"</string>
    <string name="data_usage_warning_editor_title" msgid="5252748452973120016">"Cakto paralajmërimin për përdorimin e të dhënave"</string>
    <string name="data_usage_limit_editor_title" msgid="8826855902435008518">"Cakto kufirin e përdorimit të të dhënave"</string>
    <string name="data_usage_limit_dialog_title" msgid="2053134451707801439">"Kufizimi i përdorimit të të dhënave"</string>
    <string name="data_usage_limit_dialog_mobile" product="tablet" msgid="6000062970083379466">"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="4942895670789168024">"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="2745551538820692821">"Të kufizohen të dhënat në sfond?"</string>
    <string name="data_usage_restrict_background" msgid="1893102079135282794">"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="5588623586867665419">"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="6402714504088590463">"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="2072854703184614828"><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="6947019190890086284">"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="9065885396147675694">"Aplikacionet e hequra"</string>
    <string name="data_usage_uninstalled_apps_users" msgid="1262228664057122983">"Aplikacionet dhe përdoruesit e hequr"</string>
    <string name="data_usage_received_sent" msgid="1486740779864806124">"<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="2695893609573024612">"<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="45300375132284265">"<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="3183594094081558193">"<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="6421347352444253058">"Kufizimet e rrjetit"</string>
    <string name="data_usage_metered_body" msgid="1206840367501998582">"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="3514227339274396401">"Rrjetet celulare"</string>
    <string name="data_usage_metered_wifi" msgid="4807465959110473407">"Rrjetet Wi‑Fi me konsum të kufizuar"</string>
    <string name="data_usage_metered_wifi_disabled" msgid="4664158157415362613">"Për të zgjedhur rrjetet me konsum të kufizuar, aktivizo Wi‑Fi."</string>
    <string name="data_usage_metered_auto" msgid="1560514082131687116">"Automatike"</string>
    <string name="wifi_metered_title" msgid="6623732965268033931">"Përdorimi i rrjetit"</string>
    <string name="data_usage_metered_yes" msgid="4262598072030135223">"Me matje"</string>
    <string name="data_usage_metered_no" msgid="1685828958417926268">"Pa matje"</string>
    <string name="data_usage_disclaimer" msgid="3271450299386176770">"Llogaritja e të dhënave nga operatori mund të ndryshojë nga ajo e pajisjes tënde."</string>
    <string name="vpn_name" msgid="3806456074909253262">"Emri"</string>
    <string name="vpn_type" msgid="5533202873260826663">"Lloji"</string>
    <string name="vpn_server" msgid="2908816134941973935">"Adresa e serverit"</string>
    <string name="vpn_mppe" msgid="7366657055055114239">"Enkriptimi PPP (MPPE)"</string>
    <string name="vpn_l2tp_secret" msgid="2356744369959140121">"Sekreti L2TP"</string>
    <string name="vpn_ipsec_identifier" msgid="8511842694369254801">"Identifikuesi IPSec"</string>
    <string name="vpn_ipsec_secret" msgid="532007567355505963">"Çelësi IPSec i parashkëmbyer"</string>
    <string name="vpn_ipsec_user_cert" msgid="2714372103705048405">"Certifikata e përdoruesit IPSec"</string>
    <string name="vpn_ipsec_ca_cert" msgid="5558498943577474987">"Certifikata CA e protokollit IPSec"</string>
    <string name="vpn_ipsec_server_cert" msgid="1411390470454731396">"Certifikata e serverit IPSec"</string>
    <string name="vpn_show_options" msgid="6105437733943318667">"Shfaq opsionet e përparuara"</string>
    <string name="vpn_search_domains" msgid="1973799969613962440">"Domenet e kërkimit të DNS-së"</string>
    <string name="vpn_dns_servers" msgid="6505263074417737107">"Serverët DNS (p.sh. 8.8.8.8)"</string>
    <string name="vpn_routes" msgid="1218707725375594862">"Rrugët e transferimit (p.sh. 10.0.0.0/8)"</string>
    <string name="vpn_username" msgid="8671768183475960068">"Emri i përdoruesit"</string>
    <string name="vpn_password" msgid="1183746907642628127">"Fjalëkalimi"</string>
    <string name="vpn_save_login" msgid="5986762519977472618">"Ruaj informacionet e llogarisë"</string>
    <string name="vpn_not_used" msgid="7229312881336083354">"(nuk përdoret)"</string>
    <string name="vpn_no_ca_cert" msgid="3687379414088677735">"(mos e verifiko serverin)"</string>
    <string name="vpn_no_server_cert" msgid="8106540968643125407">"(marrë nga serveri)"</string>
    <string name="vpn_always_on_invalid_reason_type" msgid="4699113710248872972">"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="2635347740046212693">"Rrjeti VPN gjithmonë aktiv mbështet adresat numerike të serverit"</string>
    <string name="vpn_always_on_invalid_reason_no_dns" msgid="3980357762395272467">"Duhet të specifikohet një server DNS për rrjetin VPN gjthmonë aktiv"</string>
    <string name="vpn_always_on_invalid_reason_dns" msgid="3934369594591801587">"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="4571905303713233321">"Informacionet e futura nuk e mbështesin rrjetin VPN gjithmonë aktiv"</string>
    <string name="vpn_cancel" msgid="5929410618112404383">"Anulo"</string>
    <string name="vpn_done" msgid="5137858784289564985">"Injoro"</string>
    <string name="vpn_save" msgid="683868204634860888">"Ruaj"</string>
    <string name="vpn_connect" msgid="7102335248484045354">"Lidh"</string>
    <string name="vpn_replace" msgid="1533147558671640341">"Zëvendëso"</string>
    <string name="vpn_edit" msgid="5862301148429324911">"Redakto profilin e VPN-së"</string>
    <string name="vpn_forget" msgid="2913950864877236737">"Harroje"</string>
    <string name="vpn_connect_to" msgid="216709261691085594">"Lidhu me <xliff:g id="PROFILE">%s</xliff:g>"</string>
    <string name="vpn_disconnect_confirm" msgid="6356789348816854539">"Shkëpute këtë rrjet VPN"</string>
    <string name="vpn_disconnect" msgid="7753808961085867345">"Shkëpute"</string>
    <string name="vpn_version" msgid="6344167191984400976">"Versioni"</string>
    <string name="vpn_forget_long" msgid="729132269203870205">"Harroje rrjetin VPN"</string>
    <string name="vpn_replace_vpn_title" msgid="3994226561866340280">"Të zëvendësohet rrjeti ekzistues VPN?"</string>
    <string name="vpn_set_vpn_title" msgid="1667539483005810682">"Të caktohet rrjeti VPN gjithmonë aktiv?"</string>
    <string name="vpn_first_always_on_vpn_message" msgid="2769478310633047870">"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="9154843462740876652">"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="4299175336198481106">"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="1094297700371463386">"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="3568307071295211187">"Aktivizo"</string>
    <string name="vpn_cant_connect_title" msgid="5670787575925519386">"<xliff:g id="VPN_NAME">%1$s</xliff:g> nuk mund të lidhet"</string>
    <string name="vpn_cant_connect_message" msgid="2139148820719163694">"Ky aplikacion nuk e mbështet rrjetin VPN gjithmonë aktiv"</string>
    <string name="vpn_title" msgid="3068868814145870274">"VPN"</string>
    <string name="vpn_create" msgid="7546073242936894638">"Shto profil VPN-je"</string>
    <string name="vpn_menu_edit" msgid="5100387853773792379">"Modifiko profilin"</string>
    <string name="vpn_menu_delete" msgid="4455966182219039928">"Fshi profilin"</string>
    <string name="vpn_menu_lockdown" msgid="5284041663859541007">"Rrjeti VPN gjithmonë aktiv"</string>
    <string name="vpn_no_vpns_added" msgid="7387080769821533728">"Nuk është shtuar asnjë rrjet VPN"</string>
    <string name="vpn_always_on_summary" msgid="2171252372476858166">"Qëndro i lidhur me rrjetin VPN gjatë të gjithë kohës"</string>
    <string name="vpn_always_on_summary_not_supported" msgid="9084872130449368437">"Nuk mbështetet nga ky aplikacion"</string>
    <string name="vpn_always_on_summary_active" msgid="175877594406330387">"Gjithmonë aktiv"</string>
    <string name="vpn_insecure_summary" msgid="4450920215186742859">"Jo i sigurt"</string>
    <string name="vpn_require_connection" msgid="1027347404470060998">"Blloko lidhjet pa rrjetin VPN"</string>
    <string name="vpn_require_connection_title" msgid="4186758487822779039">"Të kërkohet lidhja e VPN-së?"</string>
    <string name="vpn_insecure_dialog_subtitle" msgid="1857621742868835300">"Jo e sigurt. Përditësoje me një VPN IKEv2"</string>
    <string name="vpn_lockdown_summary" msgid="4700625960550559029">"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="455915403560910517">"Asnjë"</string>
    <string name="vpn_lockdown_config_error" msgid="1992071316416371316">"VPN-ja gjithnjë e aktivizuar kërkon një adresë IP-je për serverin dhe DNS-në."</string>
    <string name="vpn_no_network" msgid="7187593680049843763">"Nuk ka lidhje rrjeti. Provo sërish më vonë."</string>
    <string name="vpn_disconnected" msgid="7694522069957717501">"Shkëputur nga VPN"</string>
    <string name="vpn_disconnected_summary" msgid="721699709491697712">"Asnjë"</string>
    <string name="vpn_missing_cert" msgid="5397309964971068272">"Mungon një certifikatë. Provo të redaktosh profilin."</string>
    <string name="trusted_credentials_system_tab" msgid="675362923690364722">"Sistemi"</string>
    <string name="trusted_credentials_user_tab" msgid="4978365619630094339">"Përdoruesi"</string>
    <string name="trusted_credentials_disable_label" msgid="6649583220519447947">"Çaktivizo"</string>
    <string name="trusted_credentials_enable_label" msgid="5551204878588237991">"Aktivizo"</string>
    <string name="trusted_credentials_remove_label" msgid="8296330919329489422">"Çinstalo"</string>
    <string name="trusted_credentials_trust_label" msgid="4841047312274452474">"Beso"</string>
    <string name="trusted_credentials_enable_confirmation" msgid="6686528499458144754">"Të aktivizohet certifikata CA e sistemit?"</string>
    <string name="trusted_credentials_disable_confirmation" msgid="5131642563381656676">"Të çaktivizohet certifikata CA e sistemit?"</string>
    <string name="trusted_credentials_remove_confirmation" msgid="3420345440353248381">"Të hiqet përgjithmonë certifikata CA e përdoruesit?"</string>
    <string name="credential_contains" msgid="407972262032275476">"Ky regjistrim përmban:"</string>
    <string name="one_userkey" msgid="4417212932385103517">"çelës për një përdorues"</string>
    <string name="one_usercrt" msgid="1865069301105101370">"certifikatë për një përdorues"</string>
    <string name="one_cacrt" msgid="7467796501404158399">"një certifikatë CA"</string>
    <string name="n_cacrts" msgid="5886462550192731627">"%d certifikata CA"</string>
    <string name="user_credential_title" msgid="4686178602575567298">"Detajet e kredencialeve"</string>
    <string name="user_credential_removed" msgid="4087675887725394743">"Kredenciali i hequr: <xliff:g id="CREDENTIAL_NAME">%s</xliff:g>"</string>
    <string name="user_credential_none_installed" msgid="918620912366836994">"Nuk ka kredenciale të përdoruesit të instaluara"</string>
    <string name="spellcheckers_settings_title" msgid="2799021700580591443">"Kontrolluesi drejtshkrimor"</string>
    <string name="spellcheckers_settings_for_work_title" msgid="6471603934176062893">"Kontrolluesi drejtshkrimor për punë"</string>
    <string name="current_backup_pw_prompt" msgid="4962276598546381140">"Shkruaj fjalëkalimin aktual për rezervimin e plotë"</string>
    <string name="new_backup_pw_prompt" msgid="4884439230209419503">"Shkruaj fjalëkalimin e ri për rezervimin e plotë"</string>
    <string name="confirm_new_backup_pw_prompt" msgid="5753796799743881356">"Rishkruaj fjalëkalimin e ri për rezervimin e plotë"</string>
    <string name="backup_pw_set_button_text" msgid="8892357974661340070">"Vendos fjalëkalimin"</string>
    <string name="backup_pw_cancel_button_text" msgid="2244399819018756323">"Anulo"</string>
    <string name="additional_system_update_settings_list_item_title" msgid="7230385345152138051">"Përditësime të sistemit"</string>
    <string name="ssl_ca_cert_warning" msgid="3898387588657346106">"Rrjeti mund të jetë i monitoruar"</string>
    <string name="done_button" msgid="6269449526248267">"U krye"</string>
    <plurals name="ssl_ca_cert_dialog_title" formatted="false" msgid="5491460811755938449">
      <item quantity="other">Besoji ose hiqi certifikatat</item>
      <item quantity="one">Besoje ose hiqe certifikatën</item>
    </plurals>
    <string name="ssl_ca_cert_info_message_device_owner" msgid="7528581447864707873">"{numberOfCertificates,plural, =1{{orgName} ka instaluar një autoritet certifikimi në pajisjen tënde, çka mund ta lejojë atë të monitorojë aktivitetin tënd të rrjetit të pajisjes, duke përfshirë email-et, aplikacionet dhe sajtet e sigurta të uebit.\n\nPër më shumë informacione rreth kësaj certifikate, kontakto me administratorin.}other{{orgName} ka instaluar autoritete certifikimi në pajisjen tënde, çka mund ta lejojë atë të monitorojë aktivitetin tënd të rrjetit të pajisjes, duke përfshirë email-et, aplikacionet dhe sajtet e sigurta të uebit.\n\nPër më shumë informacione rreth këtyre certifikatave, kontakto me administratorin.}}"</string>
    <string name="ssl_ca_cert_info_message" msgid="3111724430981667845">"{numberOfCertificates,plural, =1{{orgName} ka instaluar një autoritet certifikimi për profilin tënd të punës, çka mund ta lejojë atë të monitorojë aktivitetin tënd të rrjetit të punës, duke përfshirë email-et, aplikacionet dhe sajtet e sigurta të uebit.\n\nPër më shumë informacione rreth kësaj certifikate, kontakto me administratorin.}other{{orgName} ka instaluar autoritete certifikimi për profilin tënd të punës, çka mund ta lejojë atë të monitorojë aktivitetin tënd të rrjetit të punës, duke përfshirë email-et, aplikacionet dhe sajtet e sigurta të uebit.\n\nPër më shumë informacione rreth këtyre certifikatave, kontakto me administratorin.}}"</string>
    <string name="ssl_ca_cert_warning_message" msgid="4374052724815563051">"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="125941406175485894">
      <item quantity="other">Kontrollo certifikatat</item>
      <item quantity="one">Kontrollo certifikatën</item>
    </plurals>
    <string name="user_settings_title" msgid="6550866465409807877">"Disa përdorues"</string>
    <string name="user_settings_footer_text" product="device" msgid="7523914344521302179">"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="3730074318510244552">"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="4420915712050349125">"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="1387379079186123404">"Përdoruesit dhe profilet"</string>
    <string name="user_add_user_or_profile_menu" msgid="305851380425838287">"Shto një përdorues ose një profil"</string>
    <string name="user_summary_restricted_profile" msgid="451650609582185813">"Profil i kufizuar"</string>
    <string name="user_summary_not_set_up" msgid="4602868481732886115">"Nuk është konfiguruar"</string>
    <string name="user_summary_restricted_not_set_up" msgid="1658946988920104613">"E pakonfiguruar - Profil i kufizuar"</string>
    <string name="user_summary_managed_profile_not_set_up" msgid="5739207307082458746">"Nuk është konfiguruar - profili i punës"</string>
    <string name="user_admin" msgid="4024553191395768119">"Administrator"</string>
    <string name="user_you" msgid="3070562015202859996">"Ti (<xliff:g id="NAME">%s</xliff:g>)"</string>
    <string name="user_add_max_count" msgid="3328539978480663740">"Nuk mund të shtosh përdorues të tjerë. Hiq një përdorues për të shtuar një të ri."</string>
    <string name="user_cannot_manage_message" product="tablet" msgid="3405022988077682357">"Vetëm zotëruesi i tabletit mund t\'i menaxhojë përdoruesit."</string>
    <string name="user_cannot_manage_message" product="default" msgid="6434662649769855494">"Vetëm zotëruesi i telefonit mund t\'i menaxhojë përdoruesit."</string>
    <string name="user_cannot_add_accounts_message" msgid="2351326078338805337">"Profilet e kufizuar nuk mund të shtojnë llogari"</string>
    <string name="user_remove_user_menu" msgid="2183714948094429367">"Fshije <xliff:g id="USER_NAME">%1$s</xliff:g> nga pajisja"</string>
    <string name="user_lockscreen_settings" msgid="4596612658981942092">"Cilësimet e ekranit të kyçjes"</string>
    <string name="user_add_on_lockscreen_menu" msgid="2539059062034644966">"Shto përdoruesit nga ekrani i kyçjes"</string>
    <string name="switch_to_user_zero_when_docked" msgid="2554028721803481458">"Kalo te përdoruesi administrator kur stacionohet"</string>
    <string name="user_confirm_remove_self_title" msgid="926265330805361832">"Do e fshish veten?"</string>
    <string name="user_confirm_remove_title" msgid="3626559103278006002">"Të fshihet ky përdorues?"</string>
    <string name="user_profile_confirm_remove_title" msgid="3131574314149375354">"Të hiqet ky profil?"</string>
    <string name="work_profile_confirm_remove_title" msgid="6229618888167176036">"Të hiqet profili i punës?"</string>
    <string name="user_confirm_remove_self_message" product="tablet" msgid="439222554798995592">"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="5991495192044543230">"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="362545924965977597">"Të gjitha aplikacionet dhe të dhënat do të fshihen."</string>
    <string name="work_profile_confirm_remove_message" msgid="1037294114103024478">"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="3641289528179850718">"Të gjitha aplikacionet dhe të dhënat do të fshihen."</string>
    <string name="user_adding_new_user" msgid="7439602720177181412">"Po shton përdorues të ri..."</string>
    <string name="user_delete_user_description" msgid="7764153465503821011">"Fshi përdoruesin"</string>
    <string name="user_delete_button" msgid="3833498650182594653">"Fshi"</string>
    <string name="user_exit_guest_confirm_message" msgid="8995296853928816554">"Të gjitha aplikacionet dhe të dhënat në këtë sesion do të fshihen."</string>
    <string name="user_exit_guest_dialog_remove" msgid="7067727314172605181">"Hiq!"</string>
    <string name="user_enable_calling" msgid="264875360626905535">"Aktivizo telefonatat"</string>
    <string name="user_enable_calling_sms" msgid="8546430559552381324">"Aktivizo telefonatat dhe SMS-të"</string>
    <string name="user_remove_user" msgid="8468203789739693845">"Fshi përdoruesin"</string>
    <string name="user_enable_calling_confirm_title" msgid="7868894792723368364">"Të aktivizohen telefonatat?"</string>
    <string name="user_enable_calling_confirm_message" msgid="4924965198409050155">"Historiku i telefonatave do të ndahet me këtë përdorues."</string>
    <string name="user_enable_calling_and_sms_confirm_title" msgid="4041510268838725520">"Të aktivizohen telefonatat dhe SMS-të?"</string>
    <string name="user_enable_calling_and_sms_confirm_message" msgid="367792286597449922">"Historiku i telefonatave dhe SMS-ve do të ndahet me këtë përdorues."</string>
    <string name="emergency_info_title" msgid="8233682750953695582">"Informacioni i urgjencës"</string>
    <string name="emergency_info_summary" msgid="8463622253016757697">"Informacionet dhe kontaktet për <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="open_app_button" msgid="5025229765547191710">"Hap <xliff:g id="APP_NAME">%1$s</xliff:g>"</string>
    <string name="more_settings_button" msgid="8988612279031242411">"Cilësime të tjera"</string>
    <string name="application_restrictions" msgid="276179173572729205">"Lejo aplikacionet dhe përmbajtjen"</string>
    <string name="apps_with_restrictions_header" msgid="5277698582872267931">"Aplikacionet me kufizime"</string>
    <string name="apps_with_restrictions_settings_button" msgid="2648355133416902221">"Zgjeroji cilësimet për aplikacionin"</string>
    <string name="user_choose_copy_apps_to_another_user" msgid="5914037067347012870">"Zgjidh aplikacionet për të instaluar"</string>
    <string name="user_copy_apps_menu_title" msgid="5354300105759670300">"Instalo aplikacionet e disponueshme"</string>
    <string name="nfc_payment_settings_title" msgid="2043139180030485500">"Pagesat pa kontakt"</string>
    <string name="nfc_default_payment_settings_title" msgid="2150504446774382261">"Aplikacioni i parazgjedhur për pagesa"</string>
    <string name="nfc_default_payment_footer" msgid="978535088340021360">"Për të paguar me aplikacionin për pagesa, mbaje pjesën e pasme të pajisjes te një pikë pagese"</string>
    <string name="nfc_more_details" msgid="1700713533074275233">"Mëso më shumë"</string>
    <string name="nfc_default_payment_workapp_confirmation_title" msgid="746921251872504687">"Të parazgjidhet apl. i punës për pagesat?"</string>
    <string name="nfc_default_payment_workapp_confirmation_message_title" msgid="1533022606333010329">"Për të paguar me aplikacionin e punës:"</string>
    <string name="nfc_default_payment_workapp_confirmation_message_1" msgid="2917430119080702912">"duhet të aktivizohet profili i punës."</string>
    <string name="nfc_default_payment_workapp_confirmation_message_2" msgid="8161184137833245628">"duhet të futësh kodin PIN të punës, motivin ose fjalëkalimin, nëse ke."</string>
    <string name="nfc_payment_how_it_works" msgid="3658253265242662010">"Si funksionon"</string>
    <string name="nfc_payment_no_apps" msgid="6840001883471438798">"Paguaj me telefonin tënd në dyqane"</string>
    <string name="nfc_payment_default" msgid="3769788268378614608">"Aplikacioni i parazgjedhur për pagesat"</string>
    <string name="nfc_payment_default_not_set" msgid="6471905683119084622">"Nuk është caktuar"</string>
    <string name="nfc_payment_app_and_desc" msgid="2607417639227030398">"<xliff:g id="APP">%1$s</xliff:g> - <xliff:g id="DESCRIPTION">%2$s</xliff:g>"</string>
    <string name="nfc_payment_use_default" msgid="6127665705799658860">"Përdor aplikacionin e parazgjedhur për pagesa"</string>
    <string name="nfc_payment_use_default_dialog" msgid="8556328090777785383">"Përdor aplikacionin e parazgjedhur për pagesa"</string>
    <string name="nfc_payment_favor_default" msgid="4508491832174644772">"Gjithmonë"</string>
    <string name="nfc_payment_favor_open" msgid="8554643344050373346">"Përveçse kur është i hapur një apl. tjetër për pagesa"</string>
    <string name="nfc_payment_pay_with" msgid="3001320460566523453">"Te një terminal për pagesa pa kontakt, paguaj me:"</string>
    <string name="nfc_how_it_works_title" msgid="1363791241625771084">"Pagesa në terminal"</string>
    <string name="nfc_how_it_works_content" msgid="1141382684788210772">"Konfiguro një aplikacion për pagesa. Më pas thjesht mbaje pjesën e pasme të telefonit te një terminal me simbolin e pagesave pa kontakt."</string>
    <string name="nfc_how_it_works_got_it" msgid="4717868843368296630">"E kuptova"</string>
    <string name="nfc_more_title" msgid="1041094244767216498">"Më shumë…"</string>
    <string name="nfc_payment_set_default_label" msgid="7395939287766230293">"Cakto aplikacionin e parazgjedhur për pagesat"</string>
    <string name="nfc_payment_update_default_label" msgid="8201975914337221246">"Përditëso aplikacionin e parazgjedhur për pagesat"</string>
    <string name="nfc_payment_set_default" msgid="4101484767872365195">"Te një terminal për pagesa pa kontakt, paguaj me <xliff:g id="APP">%1$s</xliff:g>"</string>
    <string name="nfc_payment_set_default_instead_of" msgid="565237441045013280">"Te një terminal për pagesa pa kontakt, paguaj me <xliff:g id="APP_0">%1$s</xliff:g>.\n\nKjo zëvendëson <xliff:g id="APP_1">%2$s</xliff:g> si aplikacionin tënd të parazgjedhur për pagesa."</string>
    <string name="nfc_payment_btn_text_set_deault" msgid="1821065137209590196">"Vendos të parazgjedhurën"</string>
    <string name="nfc_payment_btn_text_update" msgid="5159700960497443832">"Përditëso"</string>
    <string name="nfc_work_text" msgid="2496515165821504077">"Puna"</string>
    <string name="restriction_settings_title" msgid="4293731103465972557">"Kufizimet"</string>
    <string name="restriction_menu_reset" msgid="92859464456364092">"Hiq kufizimet"</string>
    <string name="restriction_menu_change_pin" msgid="2505923323199003718">"Ndrysho kodin PIN"</string>
    <string name="help_label" msgid="2896538416436125883">"Ndihmë dhe komente"</string>
    <string name="support_summary" product="default" msgid="6137136608018134563">"Artikujt e ndihmës, telefoni dhe biseda"</string>
    <string name="support_summary" product="tablet" msgid="6681247727996378252">"Artikujt e ndihmës, tableti dhe biseda"</string>
    <string name="support_summary" product="device" msgid="1690554254039752541">"Artikujt e ndihmës, pajisja dhe biseda"</string>
    <string name="user_account_title" msgid="6389636876210834864">"Llogaria për përmbajtjen"</string>
    <string name="user_picture_title" msgid="7176437495107563321">"ID-ja e fotos"</string>
    <string name="extreme_threats_title" msgid="1098958631519213856">"Kërcënimet ekstreme"</string>
    <string name="extreme_threats_summary" msgid="3560742429496902008">"Merr sinjalizime për kërcënime ekstreme mbi jetën dhe pronën"</string>
    <string name="severe_threats_title" msgid="8962959394373974324">"Kërcënime serioze"</string>
    <string name="severe_threats_summary" msgid="4982256198071601484">"Merr alarme për kërcënime serioze kundër jetës dhe pronës"</string>
    <string name="amber_alerts_title" msgid="5238275758191804575">"Sinjalizimet AMBER"</string>
    <string name="amber_alerts_summary" msgid="5755221775246075883">"Merr buletine rreth rrëmbimeve të fëmijëve"</string>
    <string name="repeat_title" msgid="8676570486899483606">"Përsërit"</string>
    <string name="call_manager_enable_title" msgid="1214301265395158720">"Aktivizo \"Menaxherin e telefonatave\""</string>
    <string name="call_manager_enable_summary" msgid="7362506369604163030">"Lejo këtë shërbim të menaxhojë si kryhen telefonatat."</string>
    <string name="call_manager_title" msgid="3397433159509629466">"Menaxheri i telefonatave"</string>
    <!-- no translation found for call_manager_summary (2558839230880919191) -->
    <skip />
    <string name="cell_broadcast_settings" msgid="2416980110093867199">"Sinjalizimet me valë të urgjencës"</string>
    <string name="network_operators_settings" msgid="5105453353329748954">"Operatorët e rrjetit"</string>
    <string name="access_point_names" msgid="5768430498022188057">"Emrat e pikës së qasjes"</string>
    <string name="enhanced_4g_lte_mode_title" msgid="6624700245232361149">"VoLTE"</string>
    <string name="enhanced_4g_lte_mode_title_advanced_calling" msgid="7066009898031465265">"Telefonatë e përparuar"</string>
    <string name="enhanced_4g_lte_mode_title_4g_calling" msgid="7445853566718786195">"Telefonatat me 4G"</string>
    <string name="enhanced_4g_lte_mode_summary" msgid="1067066329756036427">"Përdor shërbimet LTE për të përmirësuar telefonatat zanore (rekomandohet)"</string>
    <string name="enhanced_4g_lte_mode_summary_4g_calling" msgid="2575004054914178405">"Përdor shërbimet 4G për të përmirësuar telefonatat zanore (rekomandohet)"</string>
    <string name="nr_advanced_calling_title" msgid="6106286679535355939">"Vo5G"</string>
    <string name="nr_advanced_calling_summary" msgid="6926192539172030330">"Përdor 5G për telefonatat zanore"</string>
    <string name="contact_discovery_opt_in_title" msgid="8708034790649773814">"Dërgo kontaktet te operatori celular"</string>
    <string name="contact_discovery_opt_in_summary" msgid="6539010458256667300">"Dërgo numrat e telefonit të kontakteve të tua për të ofruar veçori të përmirësuara"</string>
    <string name="contact_discovery_opt_in_dialog_title" msgid="2230536282911854114">"Të dërgohen kontaktet te <xliff:g id="CARRIER">%1$s</xliff:g>?"</string>
    <string name="contact_discovery_opt_in_dialog_title_no_carrier_defined" msgid="2028983133745990320">"Të dërgohen kontaktet te operatori yt celular?"</string>
    <string name="contact_discovery_opt_in_dialog_message" msgid="8818310894782757538">"Numrat e telefonit të kontakteve të tua do të dërgohen periodikisht te <xliff:g id="CARRIER">%1$s</xliff:g>.<xliff:g id="EMPTY_LINE">

</xliff:g>Ky informacion identifikon nëse kontaktet e tua mund të përdorin veçori të caktuara, si telefonatat me video ose disa veçori të mesazheve."</string>
    <string name="contact_discovery_opt_in_dialog_message_no_carrier_defined" msgid="1914894516552445911">"Numrat e telefonit të kontakteve të tua do të dërgohen periodikisht tek operatori yt.<xliff:g id="EMPTY_LINE">

</xliff:g>Ky informacion identifikon nëse kontaktet e tua mund të përdorin veçori të caktuara, si telefonatat me video ose disa veçori të mesazheve."</string>
    <string name="preferred_network_type_title" msgid="812509938714590857">"Lloji i preferuar i rrjetit"</string>
    <string name="preferred_network_type_summary" msgid="8786291927331323061">"LTE (rekomandohet)"</string>
    <string name="mms_message_title" msgid="6624505196063391964">"Mesazhet MMS"</string>
    <string name="mms_message_summary" msgid="2855847140141698341">"Dërgo dhe merr kur të dhënat celulare janë joaktive"</string>
    <string name="data_during_calls_title" msgid="3940276893360429144">"Të dhënat gjatë telefonatave"</string>
    <string name="data_during_calls_summary" msgid="2289050189544214759">"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="8999872928646924429">"Karta SIM e punës"</string>
    <string name="user_restrictions_title" msgid="4068914244980335993">"Qasja tek aplikacioni e përmbajtja"</string>
    <string name="user_rename" msgid="8735940847878484249">"Riemërto"</string>
    <string name="app_restrictions_custom_label" msgid="6949268049087435132">"Cakto kufizimet e aplikacionit"</string>
    <string name="user_restrictions_controlled_by" msgid="2821526006742851624">"Kontrollohet nga <xliff:g id="APP">%1$s</xliff:g>"</string>
    <string name="app_sees_restricted_accounts" msgid="3526008344222566318">"Ky aplikacion mund të ketë qasje në llogaritë e tua"</string>
    <string name="app_sees_restricted_accounts_and_controlled_by" msgid="8338520379923447143">"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="2630656989926554685">"Wi‑Fi dhe rrjeti celular"</string>
    <string name="restriction_wifi_config_summary" msgid="920419010472168694">"Lejo modifikimin e cilësimeve Wi-Fi dhe atyre celulare"</string>
    <string name="restriction_bluetooth_config_title" msgid="220586273589093821">"Bluetooth-i"</string>
    <string name="restriction_bluetooth_config_summary" msgid="7558879931011271603">"Lejo modifikimin e çiftimeve të \"Bluetooth-it\" dhe cilësimet"</string>
    <string name="restriction_nfc_enable_title" msgid="525512312298242911">"NFC"</string>
    <string name="restriction_nfc_enable_summary_config" msgid="8065688740509581028">"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="6397567147629410131">"Lejo shkëmbimin e të dhënave kur tableti prek një tjetër pajisje"</string>
    <string name="restriction_nfc_enable_summary" product="default" msgid="3331800894734678808">"Lejo shkëmbimin e të dhënave kur telefoni prek një tjetër pajisje"</string>
    <string name="restriction_location_enable_title" msgid="4872281754836538066">"Vendndodhja"</string>
    <string name="restriction_location_enable_summary" msgid="7139292323897390221">"Lejo aplikacionet të përdorin informacionin e vendndodhjes tënde"</string>
    <string name="wizard_back" msgid="8257697435061870191">"Prapa"</string>
    <string name="wizard_next" msgid="3884832431439072471">"Para"</string>
    <string name="wizard_finish" msgid="4220258401946825946">"Përfundo"</string>
    <string name="regulatory_info_text" msgid="1154461023369976667"></string>
    <string name="sim_setup_wizard_title" msgid="3945520353564138219">"Kartat SIM"</string>
    <string name="sim_settings_title" msgid="8392862852842113531">"Kartat SIM"</string>
    <string name="sim_settings_summary" msgid="5777472623476930332">"<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="7726897488921853655">"Kartat SIM kanë ndryshuar"</string>
    <string name="sim_cards_changed_message_summary" msgid="7338082681445213621">"Trokit për të caktuar aktivitetet"</string>
    <string name="sim_cellular_data_unavailable" msgid="4653591727755387534">"Të dhënat celulare nuk ofrohen"</string>
    <string name="sim_cellular_data_unavailable_summary" msgid="6505871722911347881">"Trokit për të zgjedhur një kartë SIM për të dhëna"</string>
    <string name="sim_calls_always_use" msgid="967857230039768111">"Përdor gjithmonë këtë për telefonatat"</string>
    <string name="select_sim_for_data" msgid="2642305487659432499">"Zgjidh kartën SIM për të dhënat celulare"</string>
    <string name="select_sim_for_sms" msgid="5335510076282673497">"Zgjidh një kartë SIM për mesazhet SMS"</string>
    <string name="data_switch_started" msgid="6292759843974720112">"Po ndërron kartën SIM të të dhënave. Kjo mund të zgjasë deri në një minutë…"</string>
    <string name="select_specific_sim_for_data_title" msgid="5851980301321577985">"Të përdoret <xliff:g id="NEW_SIM">%1$s</xliff:g> për të dhënat celulare?"</string>
    <string name="select_specific_sim_for_data_msg" msgid="7401698123430573637">"Nëse kalon te <xliff:g id="NEW_SIM">%1$s</xliff:g>, <xliff:g id="OLD_SIM">%2$s</xliff:g> nuk do të përdoret më për të dhënat celulare."</string>
    <string name="select_specific_sim_for_data_button" msgid="6571935548920603512">"Përdor <xliff:g id="NEW_SIM">%1$s</xliff:g>"</string>
    <string name="select_sim_for_calls" msgid="7843107015635189868">"Telefono me"</string>
    <string name="sim_select_card" msgid="1226182454109919045">"Zgjidh një kartë SIM"</string>
    <string name="sim_card_number_title" msgid="4728780444646439845">"SIM <xliff:g id="CARD_NUMBER">%1$d</xliff:g>"</string>
    <string name="sim_editor_name" msgid="5900178038499314621">"Emri i kartës SIM"</string>
    <string name="sim_name_hint" msgid="8231524869124193119">"Fut emrin e kartës SIM"</string>
    <string name="sim_editor_title" msgid="918655391915256859">"Foleja e kartës SIM %1$d"</string>
    <string name="sim_editor_carrier" msgid="2424593350691002557">"Operatori celular"</string>
    <string name="sim_editor_number" msgid="3209002966895156006">"Numri"</string>
    <string name="sim_editor_color" msgid="9067029630083892961">"Ngjyra e kartës SIM"</string>
    <string name="sim_card_select_title" msgid="8146523005929848793">"Zgjidh kartën SIM"</string>
    <string name="color_orange" msgid="216547825489739010">"Portokalli"</string>
    <string name="color_purple" msgid="6603701972079904843">"Vjollcë"</string>
    <string name="sim_no_inserted_msg" msgid="7272710974813741735">"Nuk janë futur karta SIM"</string>
    <string name="sim_status_title" msgid="6188770698037109774">"Statusi i kartës SIM"</string>
    <string name="sim_status_title_sim_slot" msgid="4932996839194493313">"Statusi i kartës SIM (foleja %1$d e SIM)"</string>
    <string name="sim_call_back_title" msgid="4274099761123657464">"Telefono mbrapsht nga karta SIM e parazgjedhur"</string>
    <string name="sim_outgoing_call_title" msgid="7759080345748128897">"Karta SIM për telefonatat dalëse"</string>
    <string name="sim_other_call_settings" msgid="5956308869284958883">"Cilësime të tjera të telefonatës"</string>
    <string name="preferred_network_offload_title" msgid="6453199586512609557">"Shkarkimi në rrjetin e preferuar"</string>
    <string name="preferred_network_offload_header" msgid="4842188794016376899">"Çaktivizo transmetimin e emrit të rrjetit"</string>
    <string name="preferred_network_offload_footer" msgid="374984523082849648">"Ç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="3949937898807213370">"Çaktivizimi i transmetimit të emrit të rrjetit do të parandalojë lidhjen automatike me rrjetet e fshehura."</string>
    <string name="sim_signal_strength" msgid="6351052821700294501">"<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="584752983048661108">"Kartat SIM kanë ndryshuar."</string>
    <string name="sim_notification_summary" msgid="5593339846307029991">"Trokit për ta konfiguruar"</string>
    <string name="sim_calls_ask_first_prefs_title" msgid="3077694594349657933">"Pyet çdo herë"</string>
    <string name="sim_selection_required_pref" msgid="231437651041498359">"Kërkohet përzgjedhja"</string>
    <string name="sim_selection_channel_title" msgid="3193666315607572484">"Zgjedhja e kartës SIM"</string>
    <string name="dashboard_title" msgid="5660733037244683387">"Cilësimet"</string>
    <plurals name="settings_suggestion_header_summary_hidden_items" formatted="false" msgid="6585075562837786847">
      <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="788543070557731240">"Rrjeti dhe interneti"</string>
    <string name="network_dashboard_summary_mobile" msgid="7750924671970583670">"Rrjeti celular, Wi‑Fi, zona e qasjes për internet"</string>
    <string name="network_dashboard_summary_no_mobile" msgid="4022575916334910790">"Wi‑Fi, zona e qasjes për internet"</string>
    <string name="connected_devices_dashboard_title" msgid="19868275519754895">"Pajisje të lidhura"</string>
    <string name="connected_devices_dashboard_default_summary" msgid="7211769956193710397">"Bluetooth, çiftimi"</string>
    <string name="connected_devices_dashboard_summary" msgid="6927727617078296491">"Bluetooth, modaliteti \"me makinë\", NFC"</string>
    <string name="connected_devices_dashboard_no_nfc_summary" msgid="8424794257586524040">"Bluetooth, modaliteti \"me makinë\""</string>
    <string name="connected_devices_dashboard_no_driving_mode_summary" msgid="7155882619333726331">"Bluetooth, NFC"</string>
    <string name="connected_devices_dashboard_no_driving_mode_no_nfc_summary" msgid="1175254057213044560">"Bluetooth-i"</string>
    <string name="connected_devices_dashboard_android_auto_summary" msgid="8179090809275818804">"Bluetooth, Android Auto, modaliteti \"me makinë\", NFC"</string>
    <string name="connected_devices_dashboard_android_auto_no_nfc_summary" msgid="2532811870469405527">"Bluetooth, Android Auto, modaliteti \"me makinë\""</string>
    <string name="connected_devices_dashboard_android_auto_no_driving_mode_summary" msgid="6426996842202276640">"Bluetooth, Android Auto, NFC"</string>
    <string name="connected_devices_dashboard_android_auto_no_nfc_no_driving_mode" msgid="1672426693308438634">"Bluetooth, Android Auto"</string>
    <string name="nfc_and_payment_settings_payment_off_nfc_off_summary" msgid="7132040463607801625">"Nuk ofrohet sepse NFC është joaktive"</string>
    <string name="nfc_and_payment_settings_no_payment_installed_summary" msgid="4879818114908207465">"Për ta përdorur, në fillim instalo një aplikacion për pagesa"</string>
    <string name="app_and_notification_dashboard_title" msgid="2861781687031832943">"Apl. dhe njoftimet"</string>
    <string name="app_and_notification_dashboard_summary" msgid="8047683010984186106">"Aplikacionet së fundi, aplikacionet e parazgjedhura"</string>
    <string name="notification_settings_work_profile" msgid="6076211850526353975">"Qasja te njoftimet nuk ofrohet për aplikacionet në profilin e punës."</string>
    <string name="account_dashboard_title" msgid="8228773251948253914">"Fjalëkalimet dhe llogaritë"</string>
    <string name="account_dashboard_default_summary" msgid="1730719656099599488">"Fjalëkalimet e ruajtura, plotësimi automatik, llogaritë e sinkronizuara"</string>
    <string name="app_default_dashboard_title" msgid="4071015747629103216">"Apl. e parazgjedhura"</string>
    <string name="system_dashboard_summary" msgid="7400745270362833832">"Gjuhët, gjestet, koha, rezervimi"</string>
    <string name="search_results_title" msgid="3360639917793022533">"Cilësimet"</string>
    <string name="keywords_wifi" msgid="8156528242318351490">"wifi, wi-fi, lidhja e rrjetit, internet, pa tel, të dhëna, wi fi"</string>
    <string name="keywords_wifi_notify_open_networks" msgid="6580896556389306636">"Njoftimi i Wi‑Fi, njoftimi i wifi"</string>
    <string name="keywords_wifi_data_usage" msgid="4718555409695862085">"përdorimi i të dhënave"</string>
    <string name="keywords_time_format" msgid="5384803098766166820">"Përdor formatin 24-orësh"</string>
    <string name="keywords_storage_files" msgid="4509695858659705198">"Shkarko"</string>
    <string name="keywords_app_default" msgid="8977706259156428770">"Hap me"</string>
    <string name="keywords_applications_settings" msgid="999926810912037792">"Aplikacionet"</string>
    <string name="keywords_time_zone" msgid="6402919157244589055">"brezi orar"</string>
    <string name="keywords_draw_overlay" msgid="3170036145197260392">"Koka e bisedës, sistem, sinjalizim, dritare, dialog, shfaq, mbi aplikacionet e tjera, vizato"</string>
    <string name="keywords_flashlight" msgid="2133079265697578183">"Elektriku, drita, feneri"</string>
    <string name="keywords_change_wifi_state" msgid="7573039644328488165">"wifi, wi-fi, ndrysho, kontrolli"</string>
    <string name="keywords_more_mobile_networks" msgid="5041272719326831744">"celular, celular, operator celular, pa tel, të dhëna, 4g, 3g, 2g, lte"</string>
    <string name="keywords_wifi_calling" msgid="4319184318421027136">"wifi, wi-fi, telefonatë, telefono"</string>
    <string name="keywords_display" msgid="874738809280751745">"ekran, ekran me prekje"</string>
    <string name="keywords_display_brightness_level" msgid="850742707616318056">"zbeh ekranin, ekran me prekje, bateri, e ndritshme"</string>
    <string name="keywords_display_night_display" msgid="4711054330804250058">"zbeh ekranin, natë, nuancë, orari i natës, ndriçimi, ngjyra e ekranit, ngjyrë, ngjyra"</string>
    <string name="keywords_display_wallpaper" msgid="8478137541939526564">"sfondi, personalizo, personalizo ekranin"</string>
    <string name="keywords_display_font_size" msgid="3593317215149813183">"madhësia e tekstit"</string>
    <string name="keywords_display_cast_screen" msgid="2572331770299149370">"projektoj, transmetoj, Pasqyrimi i ekranit, Ndarja e ekranit, pasqyrimi, ndaj ekranin, transmetimi i ekranit"</string>
    <string name="keywords_storage" msgid="3004667910133021783">"hapësirë, disk, njësi disku e ngurtë, përdorimi i pajisjes"</string>
    <string name="keywords_battery" msgid="7040323668283600530">"përdorimi i energjisë, karikim"</string>
    <string name="keywords_battery_usage" msgid="1763573071014260220">"shiko përdorimin e baterisë, përdorimi i baterisë, përdorimi i energjisë"</string>
    <string name="keywords_battery_saver" msgid="6289682844453234359">"kursyesi i baterisë, kursyesi i energjisë, kursyesi"</string>
    <string name="keywords_battery_adaptive_preferences" msgid="1774870663426502938">"preferencat me përshtatje, bateria me përshtatje"</string>
    <string name="keywords_spell_checker" msgid="5148906820603481657">"gërmëzim, fjalor, kontroll ortografik, korrigjim automatik"</string>
    <string name="keywords_voice_input" msgid="7534900094659358971">"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="6728080502619011668">"vlerëso, gjuhë e parazgjedhur, fol, duke folur, tts, qasje, lexues ekrani, i verbër"</string>
    <string name="keywords_date_and_time" msgid="4402136313104901312">"ora, ushtarake"</string>
    <string name="keywords_network_reset" msgid="4075670452112218042">"rivendos, restauro, gjendje fabrike"</string>
    <string name="keywords_factory_data_reset" msgid="4979623326958976773">"pastro, fshi, restauro, spastro, hiq, rivendosja e gjendjes së fabrikës"</string>
    <string name="keywords_printing" msgid="3528250034669909466">"printeri"</string>
    <string name="keywords_sounds" msgid="187191900698371911">"sinjali bip i altoparlantit, altoparlanti, volumi, hiq zërin, vendos në heshtje, audio, muzikë, me prekje, me dridhje, dridhje"</string>
    <string name="keywords_sounds_and_notifications_interruptions" msgid="1500312884808362467">"mos, mos shqetëso, ndërprit, ndërprerje, pushim"</string>
    <string name="keywords_app" msgid="7983814237980258061">"RAM"</string>
    <string name="keywords_location" msgid="8016374808099706213">"në afërsi, vendndodhje, historik, raportim, GPS"</string>
    <string name="keywords_accounts" msgid="3013897982630845506">"llogaria, shto një llogari, profili i punës, shto një llogari, hiq, fshi"</string>
    <string name="keywords_users" msgid="3497517660077620843">"kufizimi, kufizo, të kufizuara"</string>
    <string name="keywords_keyboard_and_ime" msgid="4741098648730042570">"korrigjim teksti, saktë, zë, dridhje, automatike, gjuhë, gjest, sugjero, sugjerim, temë, ofenduese, fjalë, emoji. ndërkombëtare"</string>
    <string name="keywords_reset_apps" msgid="8254315757754930862">"rivendos, preferencat, e parazgjedhur"</string>
    <string name="keywords_all_apps" msgid="9016323378609007166">"apl, shkarkim, aplikacione, sistem"</string>
    <string name="keywords_app_permissions" msgid="2061773665663541610">"aplikacione, leje, siguria"</string>
    <string name="keywords_default_apps" msgid="4601664230800605416">"aplikacionet, e parazgjedhura"</string>
    <string name="keywords_ignore_optimizations" msgid="8967142288569785145">"shpërfill optimizimet, sasia, aplikacioni në modalitet gatishmërie"</string>
    <string name="keywords_color_mode" msgid="1193896024705705826">"ngjyrë e gjallë, RGB, sRGB, ngjyrë, natyrale, standarde"</string>
    <string name="keywords_screen_resolution" msgid="6652125115386722875">"FHD, QHD, rezolucion, 1080p, 1440p"</string>
    <string name="keywords_color_temperature" msgid="8159539138837118453">"ngjyrë, temperaturë, D65, D73, e bardhë, e verdhë, blu, e ngrohtë, e ftohtë"</string>
    <string name="keywords_lockscreen" msgid="3656926961043485797">"rrëshqit për ta shkyçur, fjalëkalim, motiv, PIN"</string>
    <string name="keywords_app_pinning" msgid="1564144561464945019">"gozhdimi i ekranit"</string>
    <string name="keywords_profile_challenge" msgid="5135555521652143612">"sfidë në punë, punë, profil"</string>
    <string name="keywords_unification" msgid="2677472004971453468">"profili i punës, profili i menaxhuar, unifiko, unifikim, punë, profil"</string>
    <string name="keywords_gesture" msgid="3456930847450080520">"gjestet"</string>
    <string name="keywords_wallet" msgid="3757421969956996972">"portofoli"</string>
    <string name="keywords_payment_settings" msgid="6268791289277000043">"paguaj, trokit, pagesa"</string>
    <string name="keywords_backup" msgid="707735920706667685">"rezervim, rezervo"</string>
    <string name="keywords_assist_gesture_launch" msgid="7710762655355161924">"gjesti"</string>
    <string name="keywords_face_unlock" msgid="545338452730885392">"fytyrë, shkyçje, autorizim, identifikim"</string>
    <string name="keywords_biometric_unlock" msgid="8569545388717753692">"fytyrë, shkyç, vërtetim, identifikim, gjurmë gishti, biometrik"</string>
    <string name="keywords_imei_info" msgid="8848791606402333514">"imei, meid, min, versioni prl, imei sv"</string>
    <string name="keywords_sim_status" msgid="8784456547742075508">"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="4723665865709965044">"numri i serisë, versioni i harduerit"</string>
    <string name="keywords_android_version" msgid="1629882125290323070">"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="6373999418195344014">"tema, e çelët, e errët, modaliteti, ndjeshmëria ndaj dritës, fotofobia, bëje më të errët, errëso, modaliteti i errët, migrenë"</string>
    <string name="keywords_systemui_theme" msgid="6341194275296707801">"tema e errët"</string>
    <string name="keywords_device_feedback" msgid="5489930491636300027">"defekt në kod"</string>
    <string name="keywords_ambient_display_screen" msgid="661492302323274647">"Shfaqja e ambientit, shfaqja e ekranit të kyçjes"</string>
    <string name="keywords_lock_screen_notif" msgid="6363144436467429932">"njoftimi i ekranit të kyçjes, njoftimet"</string>
    <string name="keywords_face_settings" msgid="1360447094486865058">"fytyrë"</string>
    <string name="keywords_fingerprint_settings" msgid="7345121109302813358">"gjurmë gishti, shto një gjurmë gishti"</string>
    <string name="keywords_biometric_settings" msgid="2173605297939326549">"fytyrë, gjurmë gishti, shto një gjurmë gishti"</string>
    <string name="keywords_display_auto_brightness" msgid="7162942396941827998">"errëso ekranin, ekrani me prekje, bateria, ndriçimi inteligjent, ndriçimi dinamik, ndriçimi automatik"</string>
    <string name="keywords_display_adaptive_sleep" msgid="4905300860114643966">"inteligjente, errëso ekranin, në gjumë, bateria, koha e pritjes, vëmendja, ekrani, mungesa e aktivitetit"</string>
    <string name="keywords_auto_rotate" msgid="7288697525101837071">"kamera, inteligjente, rrotullo automatikisht, rrotullo, përmbys, rrotullim, portret, peizazh, orientimi, vertikal, horizontal"</string>
    <string name="keywords_system_update_settings" msgid="5769003488814164931">"përmirëso, android"</string>
    <string name="keywords_zen_mode_settings" msgid="7810203406522669584">"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="8921857020437540572">"ekrani, koha e kyçjes, koha e pritjes, ekrani i kyçjes"</string>
    <string name="keywords_storage_settings" msgid="6018856193950281898">"memorie, memorie specifike, të dhëna, fshi, pastro, e lirë, hapësirë"</string>
    <string name="keywords_bluetooth_settings" msgid="2588159530959868188">"e lidhur, pajisje, kufje, kufje me mikrofon, altoparlant, pa tela, çift, kufje të vogla, muzikë, media"</string>
    <string name="keywords_wallpaper" msgid="7332890404629446192">"sfondi, tema, rrjeta, përshtat, personalizo"</string>
    <string name="keywords_styles" msgid="5291614313348476068">"ikona, theksi, ngjyra"</string>
    <string name="keywords_assist_input" msgid="3086289530227075593">"i parazgjedhur, asistenti"</string>
    <string name="keywords_default_payment_app" msgid="5162298193637362104">"pagesë, e parazgjedhur"</string>
    <string name="keywords_ambient_display" msgid="3149287105145443697">"njoftim hyrës"</string>
    <string name="keywords_hotspot_tethering" msgid="3688439689671232627">"ndaj internetin me usb, ndaj internetin me bluetooth, zona e qasjes për internet me wifi"</string>
    <string name="keywords_accessibility_vibration_primary_switch" msgid="730692154347231253">"prekje, dridhje, vibracion"</string>
    <string name="keywords_touch_vibration" msgid="1125291201902251273">"prekje, dridhje, ekran, ndjeshmëri"</string>
    <string name="keywords_ring_vibration" msgid="1736301626537417541">"prekje, dridhje, telefon, telefonatë, ndjeshmëri, zile"</string>
    <string name="keywords_ramping_ringer_vibration" msgid="3678966746742257366">"prekje, dridhje, telefon, telefonatë, zile, gradualisht"</string>
    <string name="keywords_notification_vibration" msgid="2620799301276142183">"prekje, dridhje, ndjeshmëri, njoftim"</string>
    <string name="keywords_alarm_vibration" msgid="4833220371621521817">"prekje, dridhje, ndjeshmëri, alarm"</string>
    <string name="keywords_media_vibration" msgid="723896490102792327">"prekje, dridhje, ndjeshmëri, media"</string>
    <string name="keywords_vibration" msgid="670455132028025952">"prekje, dridhje, vibracion"</string>
    <string name="keywords_battery_saver_sticky" msgid="1646191718840975110">"kursyesi i baterisë, i ngjitur, vazhdoj, kursyesi i energjisë, bateria"</string>
    <string name="keywords_battery_saver_schedule" msgid="8240483934368455930">"rutina, planifikimi, kursyesi i baterisë, kursyesi i energjisë, bateria, automatike, përqind"</string>
    <string name="keywords_enhance_4g_lte" msgid="658889360486800978">"volte, telefonatë e përparuar, telefonatë me 4g"</string>
    <string name="keywords_nr_advanced_calling" msgid="4157823099610141014">"vo5g, vonr, telefonatat e përparuara, telefonatat 5g"</string>
    <string name="keywords_add_language" msgid="1882751300359939436">"shto gjuhën, shto një gjuhë"</string>
    <string name="keywords_font_size" msgid="1643198841815006447">"madhësia e tekstit, shkronja të mëdha, fonti i madh, teksti i madh, shikim i dobët, bëje tekstin më të madh, zmadhuesi i fontit, zmadhimi i fontit"</string>
    <string name="keywords_always_show_time_info" msgid="9120590185763264666">"ekrani gjithmonë aktiv"</string>
    <string name="default_sound" msgid="6604374495015245195">"Tingulli i parazgjedhur"</string>
    <string name="sound_settings_summary" msgid="944761906531715109">"Volumi i ziles dhe njoftimeve në <xliff:g id="PERCENTAGE">%1$s</xliff:g>"</string>
    <string name="sound_dashboard_summary" msgid="6574444810552643312">"Volum, dridhje, \"Mos shqetëso\""</string>
    <string name="sound_settings_summary_vibrate" msgid="7192223433295988890">"Zilja u caktua me dridhje"</string>
    <string name="sound_settings_summary_silent" msgid="746662794579344761">"Zilja u vendos në heshtje"</string>
    <string name="sound_settings_example_summary" msgid="8125110691864707925">"Volumi i ziles dhe njoftimeve në 80%"</string>
    <string name="media_volume_option_title" msgid="5966569685119475630">"Volumi i medias"</string>
    <string name="remote_media_volume_option_title" msgid="8760846743943305764">"Volumi i transmetimit"</string>
    <string name="call_volume_option_title" msgid="1461105986437268924">"Volumi i telefonatës"</string>
    <string name="alarm_volume_option_title" msgid="6398641749273697140">"Volumi i alarmit"</string>
    <string name="ring_volume_option_title" msgid="1520802026403038560">"Volumi i ziles dhe njoftimeve"</string>
    <string name="notification_volume_option_title" msgid="4838818791683615978">"Volumi i njoftimit"</string>
    <string name="ringtone_title" msgid="3271453110387368088">"Zilja e telefonit"</string>
    <string name="notification_ringtone_title" msgid="6924501621312095512">"Tingulli i parazgjedhur i njoftimit"</string>
    <string name="notification_unknown_sound_title" msgid="1319708450698738980">"Tingulli i dhënë nga aplikacioni"</string>
    <string name="notification_sound_default" msgid="8630353701915294299">"Tingulli i parazgjedhur i njoftimit"</string>
    <string name="alarm_ringtone_title" msgid="6680761007731764726">"Tingulli i parazgjedhur i alarmit"</string>
    <string name="vibrate_when_ringing_title" msgid="3436203665622843196">"Lësho dridhje për telefonatat"</string>
    <string name="keywords_vibrate_for_calls" msgid="1019870409730074899">"Dridhje"</string>
    <string name="vibrate_when_ringing_option_never_vibrate" msgid="6518980907289156517">"Mos lësho asnjëherë dridhje"</string>
    <string name="vibrate_when_ringing_option_always_vibrate" msgid="968652667232075466">"Gjithmonë me dridhje"</string>
    <string name="vibrate_when_ringing_option_ramping_ringer" msgid="2798848945803840348">"Me dridhje në fillim e më pas zilja gradualisht"</string>
    <string name="other_sound_settings" msgid="5468360269346162072">"Tinguj të tjerë"</string>
    <string name="spatial_audio_title" msgid="6591051622375191603">"Audio hapësinore"</string>
    <string name="dial_pad_tones_title" msgid="3536945335367914892">"Tonet e bllokut të tasteve"</string>
    <string name="screen_locking_sounds_title" msgid="5695030983872787321">"Tingulli i kyçjes së ekranit"</string>
    <string name="charging_sounds_title" msgid="5261683808537783668">"Tingujt dhe dridhja e karikimit"</string>
    <string name="docking_sounds_title" msgid="5341616179210436159">"Tingujt e stacionimit"</string>
    <string name="touch_sounds_title" msgid="2200734041857425078">"Tingujt e prekjes"</string>
    <string name="vibrate_icon_title" msgid="1281100105045362530">"Shfaq gjithmonë ikonën në modalitetin me dridhje"</string>
    <string name="dock_audio_media_title" msgid="6474579339356398330">"Luhet nga altoparlanti i stacionit"</string>
    <string name="dock_audio_media_disabled" msgid="8499927008999532341">"Të gjitha audiot"</string>
    <string name="dock_audio_media_enabled" msgid="4039126523653131281">"Vetëm klipe \"media\" audio"</string>
    <string name="emergency_tone_silent" msgid="5048069815418450902">"Heshtje"</string>
    <string name="emergency_tone_alert" msgid="1977698889522966589">"Tonet"</string>
    <string name="emergency_tone_vibrate" msgid="6282296789406984698">"Dridhjet"</string>
    <string name="boot_sounds_title" msgid="5033062848948884111">"Aktivizo tingujt"</string>
    <string name="live_caption_title" msgid="8617086825712756983">"Titra në çast"</string>
    <string name="live_caption_summary" msgid="2898451867595161809">"Media me titra automatike"</string>
    <string name="spatial_audio_speaker" msgid="9145233652433523302">"Altoparlanti i telefonit"</string>
    <string name="spatial_audio_wired_headphones" msgid="2237355789145828648">"Kufje me tel"</string>
    <string name="spatial_audio_text" msgid="8201387855375146000">"Audioja nga media e përputhshme bëhet më përfshirëse"</string>
    <string name="spatial_summary_off" msgid="8272678804629774378">"Joaktiv"</string>
    <string name="spatial_summary_on_one" msgid="6239933399496282994">"Aktiv / <xliff:g id="OUTPUT_DEVICE">%1$s</xliff:g>"</string>
    <string name="spatial_summary_on_two" msgid="4526919818832483883">"Aktiv / <xliff:g id="OUTPUT_DEVICE_0">%1$s</xliff:g> dhe <xliff:g id="OUTPUT_DEVICE_1">%2$s</xliff:g>"</string>
    <string name="spatial_audio_footer_title" msgid="8775010547623606088">"Mund të aktivizosh po ashtu \"Audion hapësinore\" për pajisjet me Bluetooth."</string>
    <string name="spatial_audio_footer_learn_more_text" msgid="3826811708094366301">"Cilësimet e pajisjeve të lidhura"</string>
    <string name="zen_mode_settings_schedules_summary" msgid="2047688589286811617">"{count,plural, =0{Asnjë}=1{1 orar i caktuar}other{# orare të caktuara}}"</string>
    <string name="zen_mode_settings_title" msgid="682676757791334259">"Mos shqetëso"</string>
    <string name="zen_mode_settings_summary" msgid="6040862775514495191">"Merr njoftime vetëm nga aplikacionet dhe personat e rëndësishëm"</string>
    <string name="zen_mode_slice_subtitle" msgid="6849372107272604160">"Kufizo ndërprerjet"</string>
    <string name="zen_mode_settings_turn_on_dialog_title" msgid="7500702838426404527">"Aktivizo \"Mos shqetëso\""</string>
    <string name="zen_mode_behavior_alarms_only" msgid="2956938533859578315">"Alarmet dhe tingujt e medias mund ta ndërpresin"</string>
    <string name="zen_mode_automation_settings_title" msgid="3709324184191870926">"Oraret"</string>
    <string name="zen_mode_delete_automatic_rules" msgid="5020468289267191765">"Fshi oraret"</string>
    <string name="zen_mode_schedule_delete" msgid="5383420576833765114">"Fshi"</string>
    <string name="zen_mode_rule_name_edit" msgid="1053237022416700481">"Redakto"</string>
    <string name="zen_mode_automation_settings_page_title" msgid="6217433860514433311">"Oraret"</string>
    <string name="zen_mode_automatic_rule_settings_page_title" msgid="5264835276518295033">"Orari"</string>
    <string name="zen_mode_schedule_category_title" msgid="1381879916197350988">"Orari"</string>
    <string name="zen_mode_automation_suggestion_title" msgid="7776129050500707960">"Vendose telefonin në heshtje në kohë të caktuara"</string>
    <string name="zen_mode_automation_suggestion_summary" msgid="1946750790084170826">"Cakto rregullat për \"Mos shqetëso\""</string>
    <string name="zen_mode_schedule_title" msgid="7064866561892906613">"Orari"</string>
    <string name="zen_mode_use_automatic_rule" msgid="733850322530002484">"Përdor orar"</string>
    <string name="zen_mode_summary_combination" msgid="5944689309915947828">"<xliff:g id="MODE">%1$s</xliff:g>: <xliff:g id="EXIT_CONDITION">%2$s</xliff:g>"</string>
    <string name="zen_mode_settings_category" msgid="3794956668816783447">"Lejo ndërprerjet që lëshojnë tinguj"</string>
    <string name="zen_mode_visual_interruptions_settings_title" msgid="7806181124566937214">"Blloko shqetësimet vizuale"</string>
    <string name="zen_mode_visual_signals_settings_subtitle" msgid="7433077540895876672">"Lejo sinjalet vizuale"</string>
    <string name="zen_mode_restrict_notifications_title" msgid="4169952466106040297">"Opsionet e ekranit për njoftimet e fshehura"</string>
    <string name="zen_mode_restrict_notifications_category" msgid="5870944770935394566">"Kur modaliteti \"Mos shqetëso\" është aktiv"</string>
    <string name="zen_mode_restrict_notifications_mute" msgid="6692072837485018287">"Asnjë tingull nga njoftimet"</string>
    <string name="zen_mode_restrict_notifications_mute_summary" msgid="966597459849580949">"Do të shikosh njoftime në ekranin tënd"</string>
    <string name="zen_mode_restrict_notifications_mute_footer" msgid="2152115038156049608">"Kur mbërrijnë njoftime, telefoni nuk do të lëshojë tinguj apo dridhje."</string>
    <string name="zen_mode_restrict_notifications_hide" msgid="5997930361607752541">"Asnjë pamje apo tingull nga njoftimet"</string>
    <string name="zen_mode_restrict_notifications_hide_summary" msgid="6005445725686969583">"Nuk do të shohësh apo dëgjosh njoftime"</string>
    <string name="zen_mode_restrict_notifications_hide_footer" msgid="4314772315731485747">"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="5469078057954463796">"Personalizo"</string>
    <string name="zen_mode_restrict_notifications_enable_custom" msgid="4303255634151330401">"Aktivizo cilësimin e personalizuar"</string>
    <string name="zen_mode_restrict_notifications_disable_custom" msgid="5062332754972217218">"Hiq cilësimin e personalizuar"</string>
    <string name="zen_mode_restrict_notifications_summary_muted" msgid="4750213316794189968">"Asnjë tingull nga njoftimet"</string>
    <string name="zen_mode_restrict_notifications_summary_custom" msgid="3918461289557316364">"Pjesërisht i fshehur"</string>
    <string name="zen_mode_restrict_notifications_summary_hidden" msgid="636494600775773296">"Asnjë pamje apo tingull nga njoftimet"</string>
    <string name="zen_mode_what_to_block_title" msgid="5692710098205334164">"Personalizo kufizimet"</string>
    <string name="zen_mode_block_effects_screen_on" msgid="8780668375194500987">"Kur ekrani është aktiv"</string>
    <string name="zen_mode_block_effects_screen_off" msgid="2291988790355612826">"Kur ekrani është joaktiv"</string>
    <string name="zen_mode_block_effect_sound" msgid="7929909410442858327">"Vendos tingullin dhe dridhjen në heshtje"</string>
    <string name="zen_mode_block_effect_intent" msgid="7621578645742903531">"Mos e aktivizo ekranin"</string>
    <string name="zen_mode_block_effect_light" msgid="1997222991427784993">"Mos pulso dritën"</string>
    <string name="zen_mode_block_effect_peek" msgid="2525844009475266022">"Mos shfaq njoftime në ekran"</string>
    <string name="zen_mode_block_effect_status" msgid="5765965061064691918">"Fshih ikonat e shiritit të statusit në krye të ekranit"</string>
    <string name="zen_mode_block_effect_badge" msgid="332151258515152429">"Fshih pikat e njoftimeve në ikonat e aplikacioneve"</string>
    <string name="zen_mode_block_effect_ambient" msgid="1247740599476031543">"Mos zgjo për njoftimet"</string>
    <string name="zen_mode_block_effect_list" msgid="7549367848660137118">"Fshihe nga streha me tërheqje poshtë"</string>
    <string name="zen_mode_block_effect_summary_none" msgid="6688519142395714659">"Asnjëherë"</string>
    <string name="zen_mode_block_effect_summary_screen_off" msgid="6989818116297061488">"Kur ekrani është joaktiv"</string>
    <string name="zen_mode_block_effect_summary_screen_on" msgid="4876016548834916087">"Kur ekrani është aktiv"</string>
    <string name="zen_mode_block_effect_summary_sound" msgid="1559968890497946901">"Tingull dhe dridhje"</string>
    <string name="zen_mode_block_effect_summary_some" msgid="2730383453754229650">"Tingull, dridhje dhe disa shenja vizuale të njoftimeve"</string>
    <string name="zen_mode_block_effect_summary_all" msgid="3131918059492425222">"Tingull, dridhje dhe shenja vizuale të njoftimeve"</string>
    <string name="zen_mode_blocked_effects_footer" msgid="1115914818435434668">"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="1580136061336585873">"Asnjë"</string>
    <string name="zen_mode_other_options" msgid="3399967231522580421">"opsione të tjera"</string>
    <string name="zen_mode_add" msgid="8789024026733232566">"Shto"</string>
    <string name="zen_mode_enable_dialog_turn_on" msgid="1971034397501675078">"Aktivizo"</string>
    <string name="zen_mode_button_turn_on" msgid="6583862599681052347">"Aktivizo tani"</string>
    <string name="zen_mode_button_turn_off" msgid="2060862413234857296">"Çaktivizo tani"</string>
    <string name="zen_mode_settings_dnd_manual_end_time" msgid="8251503918238985549">"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="1436568478062106132">"Modaliteti \"Mos shqetëso\" do të qëndrojë aktiv deri sa ta çaktivizosh"</string>
    <string name="zen_mode_settings_dnd_automatic_rule" msgid="1958092329238152236">"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="3401685760954156067">"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="6566115866660865385">"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="8255159194653341835">" "<annotation id="link">"Shiko cilësimet e personalizuara"</annotation></string>
    <string name="zen_interruption_level_priority" msgid="4854123502362861192">"Vetëm me prioritet"</string>
    <string name="zen_mode_and_condition" msgid="8580896862841920031">"<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="4803606180235742003">"Aktiv / <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="zen_mode_sound_summary_on" msgid="9077659040104989899">"Aktiv"</string>
    <string name="zen_mode_duration_summary_always_prompt" msgid="7658172853423383037">"Pyet çdo herë"</string>
    <string name="zen_mode_duration_summary_forever" msgid="5551992961329998606">"Derisa ta çaktivizosh"</string>
    <string name="zen_mode_duration_summary_time_hours" msgid="2602655749780428308">"{count,plural, =1{1 orë}other{# orë}}"</string>
    <string name="zen_mode_duration_summary_time_minutes" msgid="5755536844016835693">"{count,plural, =1{1 minutë}other{# minuta}}"</string>
    <string name="zen_mode_sound_summary_off" msgid="7350437977839985836">"{count,plural, =0{Joaktiv}=1{Joaktiv / 1 orar mund të aktivizohet automatikisht}other{Joaktiv / # orare mund të aktivizohen automatikisht}}"</string>
    <string name="zen_category_behavior" msgid="3214056473947178507">"Çfarë mund ta ndërpresë \"Mos shqetëso\""</string>
    <string name="zen_category_people" msgid="8252926021894933047">"Personat"</string>
    <string name="zen_category_apps" msgid="1167374545618451925">"Aplikacionet"</string>
    <string name="zen_category_exceptions" msgid="1316097981052752811">"Alarmet dhe ndërprerjet e tjera"</string>
    <string name="zen_category_schedule" msgid="2003707171924226212">"Oraret"</string>
    <string name="zen_category_duration" msgid="7515850842082631460">"Kohëzgjatja për \"Cilësimet e shpejta\""</string>
    <string name="zen_settings_general" msgid="2704932194620124153">"Të përgjithshme"</string>
    <string name="zen_sound_footer" msgid="4090291351903631977">"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_custom_settings_dialog_title" msgid="4613603772432720380">"Cilësimet e personalizuara"</string>
    <string name="zen_custom_settings_dialog_review_schedule" msgid="4674671820584759928">"Rishiko orarin"</string>
    <string name="zen_custom_settings_dialog_ok" msgid="8842373418878278246">"E kuptova"</string>
    <string name="zen_custom_settings_notifications_header" msgid="7635280645171095398">"Njoftimet"</string>
    <string name="zen_custom_settings_duration_header" msgid="5065987827522064943">"Kohëzgjatja"</string>
    <string name="zen_msg_event_reminder_title" msgid="5362025129007417554">"Mesazhet, ngjarjet dhe alarmet rikujtuese"</string>
    <string name="zen_msg_event_reminder_footer" msgid="2700459146293750387">"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="8764248406533833392">"U krye"</string>
    <string name="zen_onboarding_settings" msgid="2815839576245114342">"Cilësimet"</string>
    <string name="zen_onboarding_new_setting_title" msgid="8813308612916316657">"Asnjë pamje apo tingull nga njoftimet"</string>
    <string name="zen_onboarding_current_setting_title" msgid="5024603685220407195">"Asnjë tingull nga njoftimet"</string>
    <string name="zen_onboarding_new_setting_summary" msgid="7695808354942143707">"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="8864567406905990095">"(Cilësimet aktuale)"</string>
    <string name="zen_onboarding_dnd_visual_disturbances_header" msgid="8639698336231314609">"Të ndryshohen cilësimet e njoftimeve të modalitetit \"Mos shqetëso\"?"</string>
    <string name="sound_work_settings" msgid="752627453846309092">"Tingujt e profilit të punës"</string>
    <string name="work_use_personal_sounds_title" msgid="7729428677919173609">"Përdor tingujt e profilit personal"</string>
    <string name="work_use_personal_sounds_summary" msgid="608061627969077231">"Përdor tinguj të njëjtë si të profilit tënd personal"</string>
    <string name="work_ringtone_title" msgid="4810802758746102589">"Toni telefonik i telefonit të punës"</string>
    <string name="work_notification_ringtone_title" msgid="2955312017013255515">"Tingulli i parazgjedhur i njoftimit të punës"</string>
    <string name="work_alarm_ringtone_title" msgid="3369293796769537392">"Tingulli i parazgjedhur i alarmit të punës"</string>
    <string name="work_sound_same_as_personal" msgid="1836913235401642334">"Njësoj si profili personal"</string>
    <string name="work_sync_dialog_title" msgid="7810248132303515469">"Të përdoren tingujt e profilit personal?"</string>
    <string name="work_sync_dialog_yes" msgid="5785488304957707534">"Konfirmo"</string>
    <string name="work_sync_dialog_message" msgid="5066178064994040223">"Profili yt i punës do të përdorë tinguj të njëjtë si të profilit tënd personal"</string>
    <string name="ringtones_install_custom_sound_title" msgid="3885712267015760638">"Të shtohet një tingull i personalizuar?"</string>
    <string name="ringtones_install_custom_sound_content" msgid="5844996763705884979">"Ky skedar do të kopjohet te dosja <xliff:g id="FOLDER_NAME">%s</xliff:g>"</string>
    <string name="ringtones_category_preference_title" msgid="26680768777533727">"Zilet"</string>
    <string name="other_sound_category_preference_title" msgid="8182757473602586634">"Tinguj dhe dridhje të tjera"</string>
    <string name="configure_notification_settings" msgid="1492820231694314376">"Njoftimet"</string>
    <string name="notification_dashboard_summary" msgid="7530169251902320652">"Historiku i njoftimeve, bisedat"</string>
    <string name="conversation_notifs_category" msgid="2549844862379963273">"Biseda"</string>
    <string name="recent_notifications" msgid="1105631022180160436">"Dërguar së fundi"</string>
    <string name="recent_notifications_see_all_title" msgid="3087299996651692987">"Shih të gjithë apl. në 7 ditët e fundit"</string>
    <string name="general_notification_header" msgid="3669031068980713359">"Menaxho"</string>
    <string name="app_notification_field" msgid="3858667320444612716">"Cilësimet e aplikacionit"</string>
    <string name="app_notification_field_summary" msgid="5981393613897713471">"Kontrollo njoftimet nga aplikacione individuale"</string>
    <string name="advanced_section_header" msgid="6478709678084326738">"Të përgjithshme"</string>
    <string name="profile_section_header" msgid="4970209372372610799">"Njoftimet e punës"</string>
    <string name="profile_section_header_for_advanced_privacy" msgid="8385775428904838579">"Profili i punës"</string>
    <string name="smart_notifications_title" msgid="8995288376897952015">"Njoftimet me përshtatje"</string>
    <string name="asst_capability_prioritizer_title" msgid="1181272430009156556">"Përparësia e njoftimeve me përshtatje"</string>
    <string name="asst_capability_prioritizer_summary" msgid="954988212366568737">"Caktoji automatikisht njoftimet me prioritet më të ulët te \"Me rëndësi të ulët\""</string>
    <string name="asst_capability_ranking_title" msgid="312998580233257581">"Renditja e njoftimeve me përshtatje"</string>
    <string name="asst_capability_ranking_summary" msgid="2293524677144599450">"Rendit automatikisht njoftimet sipas përshtatshmërisë"</string>
    <string name="asst_feedback_indicator_title" msgid="5169801869752395354">"Komentet e njoftimeve me përshtatje"</string>
    <string name="asst_feedback_indicator_summary" msgid="5862082842073307900">"Trego rregullimet që u bëhen njoftimeve dhe shfaq opsionin për t\'i dhënë komente sistemit"</string>
    <string name="asst_importance_reset_title" msgid="6191265591976440115">"Rivendos rëndësinë e njoftimeve"</string>
    <string name="asst_importance_reset_summary" msgid="684794589254282667">"Rivendos cilësimet e rëndësisë që janë ndryshuar nga përdoruesi dhe lejo që asistenti i njoftimeve të caktojë përparësinë"</string>
    <string name="asst_capabilities_actions_replies_title" msgid="4392470465646394289">"Veprimet dhe përgjigjet e sugjeruara"</string>
    <string name="asst_capabilities_actions_replies_summary" msgid="416234323365645871">"Shfaq automatikisht veprimet dhe përgjigjet e sugjeruara"</string>
    <string name="notification_history_summary" msgid="5434741516307706892">"Shfaq njoftimet e fundit dhe ato të shtyra"</string>
    <string name="notification_history" msgid="8663811361243456201">"Historiku i njoftimeve"</string>
    <string name="notification_history_toggle" msgid="9093762294928569030">"Përdor historikun e njoftimeve"</string>
    <string name="notification_history_off_title_extended" msgid="853807652537281601">"Historiku i njoftimeve është çaktivizuar"</string>
    <string name="notification_history_off_summary" msgid="671359587084797617">"Aktivizo historikun e njoftimeve për të parë njoftimet e fundit dhe njoftimet e shtyra"</string>
    <string name="history_toggled_on_title" msgid="4518001110492652830">"Nuk ka njoftime të fundit"</string>
    <string name="history_toggled_on_summary" msgid="9034278971358282728">"Njoftimet e tua të fundit dhe të shtyra do të shfaqen këtu"</string>
    <string name="notification_history_view_settings" msgid="5269317798670449002">"shiko cilësimet e njoftimeve"</string>
    <string name="notification_history_open_notification" msgid="2655071846911258371">"hap njoftimin"</string>
    <string name="snooze_options_title" msgid="2109795569568344617">"Lejo shtyrjen e njoftimeve"</string>
    <string name="hide_silent_icons_title" msgid="5951392023601167577">"Fshih ikonat nga njoftimet me rëndësi të ulët"</string>
    <string name="hide_silent_icons_summary" msgid="623763437631637232">"Ikonat nga njoftimet me rëndësi të ulët nuk shfaqen në shiritin e statusit"</string>
    <string name="notification_badging_title" msgid="5469616894819568917">"Pika e njoftimit në ikonën e aplikacionit"</string>
    <string name="notification_people_strip_title" msgid="1185857822541001139">"Shfaq shiritin e bisedave të fundit"</string>
    <string name="notification_bubbles_title" msgid="5681506665322329301">"Flluskat"</string>
    <string name="bubbles_feature_education" msgid="4088275802688887634">"Disa njoftime dhe përmbajtje të tjera mund të shfaqen si flluska në ekran. Për të hapur një flluskë, trokit tek ajo. Për ta hequr, zvarrite poshtë në ekran."</string>
    <string name="bubbles_app_toggle_title" msgid="5319021259954576150">"Flluskat"</string>
    <string name="bubbles_conversation_app_link" msgid="5468779786387915337">"Të gjitha cilësimet e flluskave"</string>
    <string name="bubbles_conversation_toggle_title" msgid="5225039214083311316">"Vendos bisedën në flluskë"</string>
    <string name="bubbles_conversation_toggle_summary" msgid="720229032254323578">"Shfaq ikona pluskuese mbi aplikacione"</string>
    <string name="bubbles_app_toggle_summary" msgid="1574515698567947948">"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="1794193899792284007">"Të aktivizohen flluskat për pajisjen?"</string>
    <string name="bubbles_feature_disabled_dialog_text" msgid="5275666953364031055">"Aktivizimi i flluskave për këtë aplikacion do të aktivizojë edhe flluskat për pajisjen tënde.\n\nKjo ndikon tek aplikacionet ose bisedat e tjera që lejohen të shfaqen si flluskë."</string>
    <string name="bubbles_feature_disabled_button_approve" msgid="2042628067101419871">"Aktivizo"</string>
    <string name="bubbles_feature_disabled_button_cancel" msgid="8963409459448350600">"Anulo"</string>
    <string name="notifications_bubble_setting_on_summary" msgid="4641572377430901196">"Aktive / Bisedat mund të shfaqen si ikona pluskuese"</string>
    <string name="notifications_bubble_setting_title" msgid="8287649393774855268">"Lejo aplikacionet që të shfaqin flluska"</string>
    <string name="notifications_bubble_setting_description" msgid="7336770088735025981">"Disa biseda do të shfaqen si ikona pluskuese mbi aplikacionet e tjera"</string>
    <string name="bubble_app_setting_all" msgid="312524752846978277">"Të gjitha bisedat mund të vendosen në flluska."</string>
    <string name="bubble_app_setting_selected" msgid="4324386074198040675">"Bisedat e zgjedhura mund të vendosen në flluska"</string>
    <string name="bubble_app_setting_none" msgid="8643594711863996418">"Asgjë nuk mund të vendoset në flluska"</string>
    <string name="bubble_app_setting_selected_conversation_title" msgid="3060958976857529933">"Bisedat"</string>
    <string name="bubble_app_setting_excluded_conversation_title" msgid="324818960338773945">"Të gjitha bisedat mund të shfaqen si flluskë përveç"</string>
    <string name="bubble_app_setting_unbubble_conversation" msgid="1769789500566080427">"Çaktivizo flluskat për këtë bisedë"</string>
    <string name="bubble_app_setting_bubble_conversation" msgid="1461981680982964285">"Aktivizo flluskat për këtë bisedë"</string>
    <string name="swipe_direction_title" msgid="4260320464727178413">"Veprimet me rrëshqitje"</string>
    <string name="swipe_direction_ltr" msgid="5137180130142633085">"Rrëshqit shpejt djathtas për ta hequr, ose majtas për të shfaqur menynë"</string>
    <string name="swipe_direction_rtl" msgid="1707391213940663992">"Rrëshqit shpejt majtas për ta hequr, ose djathtas për të shfaqur menynë"</string>
    <string name="gentle_notifications_title" msgid="2793492905132530991">"Njoftimet me rëndësi të ulët"</string>
    <string name="gentle_notifications_also_display" msgid="8617545395880297691">"Shfaq po ashtu në"</string>
    <string name="gentle_notifications_display_status" msgid="7410244447768694856">"Shiriti i statusit"</string>
    <string name="gentle_notifications_display_lock" msgid="1914245082527924144">"Ekrani i kyçjes"</string>
    <string name="gentle_notifications_education" msgid="5957509621826384362">"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="7616926954719310445">"Shfaq vetëm në strehën me tërheqje poshtë"</string>
    <string name="gentle_notifications_display_summary_shade_lock" msgid="3936088046873705625">"Shfaq në strehën me tërheqje poshtë dhe në ekranin e kyçjes"</string>
    <string name="gentle_notifications_display_summary_shade_status" msgid="3363137853729359907">"Shfaq në strehën me tërheqje poshtë dhe shiritin e statusit"</string>
    <string name="gentle_notifications_display_summary_shade_status_lock" msgid="2068738866725616212">"Shfaq në strehën me tërheqje poshtë, shiritin e statusit dhe në ekranin e kyçjes"</string>
    <string name="silent_notifications_status_bar" msgid="6113307620588767516">"Fshih njoftimet në heshtje në shiritin e statusit"</string>
    <string name="notification_pulse_title" msgid="8013178454646671529">"Drita me pulsim"</string>
    <string name="lock_screen_notifications_title" msgid="2876323153692406203">"Privatësia"</string>
    <string name="lockscreen_bypass_title" msgid="6519964196744088573">"Kapërce ekranin e kyçjes"</string>
    <string name="lockscreen_bypass_summary" msgid="464277506200346748">"Pas shkyçjes shko drejtpërdrejt tek ekrani i fundit i përdorur"</string>
    <string name="keywords_lockscreen_bypass" msgid="41035425468915498">"Ekrani i kyçjes, ekrani i bllokimit, kapërce, anashkalo"</string>
    <string name="locked_work_profile_notification_title" msgid="279367321791301499">"Kur profili i punës është i kyçur"</string>
    <string name="lock_screen_notifs_title" msgid="3412042692317304449">"Njoftimet në ekranin e kyçjes"</string>
    <string name="lock_screen_notifs_show_all_summary" msgid="4226586018375762117">"Shfaq bisedat, të parazgjedhura dhe të heshtura"</string>
    <string name="lock_screen_notifs_show_all" msgid="1300418674456749664">"Shfaq bisedat, të parazgjedhura dhe të heshtura"</string>
    <string name="lock_screen_notifs_show_alerting" msgid="6584682657382684566">"Fshih bisedat dhe njoftimet e heshtura"</string>
    <string name="lock_screen_notifs_show_none" msgid="1941044980403067101">"Mos shfaq asnjë njoftim"</string>
    <string name="lock_screen_notifs_redact" msgid="9024158855454642296">"Njoftimet delikate"</string>
    <string name="lock_screen_notifs_redact_summary" msgid="1395483766035470612">"Shfaq përmbajtje delikate kur është i kyçur"</string>
    <string name="lock_screen_notifs_redact_work" msgid="3833920196569208430">"Njoftimet delikate të profilit të punës"</string>
    <string name="lock_screen_notifs_redact_work_summary" msgid="3238238380405430156">"Shfaq përmbajtje delikate të profilit të punës kur është i kyçur"</string>
    <string name="lock_screen_notifications_summary_show" msgid="6540443483088311328">"Shfaq të gjithë përmbajtjen e njoftimit"</string>
    <string name="lock_screen_notifications_summary_hide" msgid="7837303171531166789">"Shfaq përmbajtje delikate vetëm kur të shkyçet"</string>
    <string name="lock_screen_notifications_summary_disable" msgid="3388290397947365744">"Mos shfaq asnjë njoftim"</string>
    <string name="lock_screen_notifications_interstitial_message" msgid="4688399629301178487">"Si dëshiron të shfaqet ekrani i kyçjes?"</string>
    <string name="lock_screen_notifications_interstitial_title" msgid="1360388192096354315">"Ekrani i kyçjes"</string>
    <string name="lock_screen_notifications_summary_show_profile" msgid="8373401288962523946">"Shfaq të gjitha përmbajtjet e njoftimeve të punës"</string>
    <string name="lock_screen_notifications_summary_hide_profile" msgid="2183455323048921579">"Fshihe përmbajtjen delikate të punës"</string>
    <string name="lock_screen_notifications_interstitial_message_profile" msgid="1456262034599029028">"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="6950124772255324448">"Njoftimet e profilit"</string>
    <string name="notifications_title" msgid="4221655533193721131">"Njoftimet"</string>
    <string name="app_notifications_title" msgid="248374669037385148">"Njoftimet e apl."</string>
    <string name="notification_channel_title" msgid="8859880871692797611">"Kategoria e njoftimeve"</string>
    <string name="notification_group_title" msgid="7525666535695631538">"Grupi i kategorisë së njoftimeve"</string>
    <string name="notification_importance_title" msgid="1545158655988342703">"Sjellja"</string>
    <string name="notification_importance_unspecified" msgid="1543165530748339700">"Lejo tingullin"</string>
    <string name="notification_importance_blocked" msgid="4933285639639899394">"Mos i shfaq asnjëherë njoftimet"</string>
    <string name="conversations_category_title" msgid="5586541340846847798">"Bisedat"</string>
    <string name="conversation_category_title" msgid="6777135786004214149">"Bashkëbisedim"</string>
    <string name="conversation_section_switch_title" msgid="3332885377659473775">"Seksioni i bisedave"</string>
    <string name="conversation_section_switch_summary" msgid="6123587625929439674">"Lejo aplikacionin të përdorë seksionin e bisedave"</string>
    <string name="demote_conversation_title" msgid="6355383023376508485">"Nuk është bisedë"</string>
    <string name="demote_conversation_summary" msgid="4319929331165604112">"Hiq nga seksioni i bisedës"</string>
    <string name="promote_conversation_title" msgid="4731148769888238722">"Ky është bashkëbisedim"</string>
    <string name="promote_conversation_summary" msgid="3890724115743515035">"Shto te seksioni i bisedës"</string>
    <string name="manage_conversations" msgid="4440289604887824337">"Menaxho bisedat"</string>
    <string name="priority_conversation_count_zero" msgid="3862289535537564713">"Nuk ka biseda me përparësi"</string>
    <plurals name="priority_conversation_count" formatted="false" msgid="4229447176780862649">
      <item quantity="other"><xliff:g id="COUNT_1">%d</xliff:g> biseda me përparësi</item>
      <item quantity="one"><xliff:g id="COUNT_0">%d</xliff:g> bisedë me përparësi</item>
    </plurals>
    <string name="important_conversations" msgid="1233893707189659401">"Bisedat me përparësi"</string>
    <string name="important_conversations_summary_bubbles" msgid="614327166808117644">"Shfaqen në krye të seksionit të bisedës dhe shfaqen si flluska pluskuese"</string>
    <string name="important_conversations_summary" msgid="3184022761562676418">"Shfaqen në krye të seksionit të bisedës"</string>
    <string name="other_conversations" msgid="551178916855139870">"Bisedat pa përparësi"</string>
    <string name="other_conversations_summary" msgid="3487426787901236273">"Bisedat ku ke bërë ndryshime"</string>
    <string name="recent_conversations" msgid="471678228756995274">"Bisedat e fundit"</string>
    <string name="conversation_settings_clear_recents" msgid="8940398397663307054">"Pastro bisedat e fundit"</string>
    <string name="recent_convos_removed" msgid="2122932798895714203">"Bisedat e fundit u hoqën"</string>
    <string name="recent_convo_removed" msgid="8686414146325958281">"Biseda u hoq"</string>
    <string name="clear" msgid="5092178335409471100">"Pastro"</string>
    <string name="important_bubble" msgid="7911698275408390846">"Shfaq flluskën për bisedat me përparësi"</string>
    <string name="important_conversation_behavior_summary" msgid="1845064084071107732">"Bisedat me përparësi shfaqen në krye të strehës me tërheqje poshtë. Mund t\'i caktosh po ashtu që të shfaqen si flluskë dhe të ndërpresin \"Mos shqetëso\"."</string>
    <string name="conversation_onboarding_title" msgid="5194559958353468484">"Bisedat me përparësi dhe të modifikuara do të shfaqen këtu"</string>
    <string name="conversation_onboarding_summary" msgid="2484845363368486941">"Kur e shënon një bisedë si me përparësi, ose kur bën ndonjë ndryshim tjetër te bisedat, ato do të shfaqen këtu. \n\nPër të ndryshuar cilësimet e bisedës: \nRrëshqit shpejt poshtë nga kreu i ekranit për të hapur strehën me tërheqje poshtë dhe më pas prek dhe mbaj të shtypur një bisedë."</string>
    <string name="notification_importance_min" msgid="4609688642942787774">"Shfaq në heshtje dhe minimizo"</string>
    <string name="notification_importance_low" msgid="7562535765919565273">"Shfaq në heshtje"</string>
    <string name="notification_importance_default" msgid="7483906490369073043">"Bëj tingull"</string>
    <string name="notification_importance_high" msgid="8453789143477210550">"Bëj një tingull dhe shfaq në ekran"</string>
    <string name="notification_importance_high_silent" msgid="8977232884004607985">"Shfaq në ekran"</string>
    <string name="notification_importance_min_title" msgid="7676541266705442501">"Minimizo"</string>
    <string name="notification_importance_low_title" msgid="658158049378796947">"Mesatare"</string>
    <string name="notification_importance_default_title" msgid="8875198696330289686">"E lartë"</string>
    <string name="notification_importance_high_title" msgid="394129291760607808">"Shfaq në ekran"</string>
    <string name="notification_block_title" msgid="7392909527700971673">"Blloko"</string>
    <string name="notification_silence_title" msgid="4085829874452944989">"Në heshtje"</string>
    <string name="notification_alert_title" msgid="1632401211722199217">"E parazgjedhur"</string>
    <string name="allow_interruption" msgid="5237201780159482716">"Lejo ndërprerjet"</string>
    <string name="allow_interruption_summary" msgid="9044131663518112543">"Lejo që aplikacioni të lëshojë tingull, të dridhet dhe/ose të shfaqë njoftime në ekran"</string>
    <string name="notification_priority_title" msgid="5554834239080425229">"Me përparësi"</string>
    <string name="notification_channel_summary_priority" msgid="7225362351439076913">"Shfaqet në krye të seksionit të bisedës dhe shfaqet si flluskë pluskuese, shfaq fotografinë e profilit në ekranin e kyçjes"</string>
    <string name="convo_not_supported_summary" msgid="4285471045268268048">"<xliff:g id="APP_NAME">%1$s</xliff:g> nuk mbështet shumicën e veçorive të bisedave. Nuk mund ta caktosh një bisedë si me përparësi dhe bisedat nuk do të shfaqen si flluska pluskuese."</string>
    <string name="notification_channel_summary_min" msgid="8823399508450176842">"Në strehën me tërheqje poshtë, palosi njoftimet në një rresht"</string>
    <string name="notification_channel_summary_low" msgid="5549662596677692000">"Asnjë tingull ose dridhje"</string>
    <string name="notification_conversation_summary_low" msgid="6352818857388412326">"Asnjë tingull ose dridhje dhe shfaqet më poshtë në seksionin e bisedave"</string>
    <string name="notification_channel_summary_default" msgid="3674057458265438896">"Mund të bjerë zilja ose të dridhet në bazë të cilësimeve të telefonit"</string>
    <string name="notification_channel_summary_high" msgid="3411637309360617621">"Kur pajisja është e shkyçur, shfaq njoftimet si një banderolë përgjatë kreut të ekranit"</string>
    <string name="notification_switch_label" msgid="8029371325967501557">"Të gjitha njoftimet e \"<xliff:g id="APP_NAME">%1$s</xliff:g>\""</string>
    <string name="notification_app_switch_label" msgid="4422902423925084193">"Të gjitha njoftimet e <xliff:g id="APP_NAME">%1$s</xliff:g>"</string>
    <string name="default_notification_assistant" msgid="243718059890346442">"Njoftimet me përshtatje"</string>
    <plurals name="notifications_sent_daily" formatted="false" msgid="1479283620504341566">
      <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="4913443431857170519">
      <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="9081278709126812062">"Asnjëherë"</string>
    <string name="manage_notification_access_title" msgid="6481256069087219982">"Njoftimet e pajisjes dhe aplikacioneve"</string>
    <string name="manage_notification_access_summary" msgid="2907135226478903997">"Kontrollo se cilat aplikacione dhe pajisje mund të lexojnë njoftime"</string>
    <string name="work_profile_notification_access_blocked_summary" msgid="8643809206612366067">"Qasja në njoftimet e profilit të punës është bllokuar"</string>
    <string name="manage_notification_access_summary_zero" msgid="7528633634628627431">"Aplikacionet nuk mund t\'i lexojnë njoftimet"</string>
    <plurals name="manage_notification_access_summary_nonzero" formatted="false" msgid="3703008881487586312">
      <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="5889201903272393099">"Njoftimet e përmirësuara"</string>
    <string name="notification_assistant_summary" msgid="1957783114840908887">"Merr sugjerime për veprimet, përgjigjet etj."</string>
    <string name="no_notification_assistant" msgid="2533323397091834096">"Asnjë"</string>
    <string name="no_notification_listeners" msgid="2839354157349636000">"Asnjë apl. i instaluar nuk ka kërkuar qasje te njoftimet."</string>
    <string name="notification_access_detail_switch" msgid="46386786409608330">"Lejo qasjen te njoftimet"</string>
    <string name="notification_assistant_security_warning_title" msgid="2972346436050925276">"Të lejohet qasja te njoftimet për \"<xliff:g id="SERVICE">%1$s</xliff:g>\"?"</string>
    <string name="notification_assistant_security_warning_summary" msgid="4846559755787348129">"Njoftimet e përmirësuara kanë zëvendësuar \"Njoftimet me përshtatje të Android\" në Android 12. Kjo veçori shfaq veprimet dhe përgjigjet e sugjeruara dhe organizon njoftimet e tua. \n\nNjoftimet e përmirësuara mund të kenë qasje te përmbajtja e njoftimeve, duke përfshirë informacionet personale si emrat e kontakteve dhe mesazhet. Kjo veçori mund t\'i heqë ose të përgjigjet po ashtu për njoftimet, si p.sh. t\'u përgjigjet telefonatave, dhe të kontrollojë modalitetin \"Mos shqetëso\"."</string>
    <string name="notification_listener_security_warning_title" msgid="5791700876622858363">"Të lejohet qasja te njoftimet për \"<xliff:g id="SERVICE">%1$s</xliff:g>\"?"</string>
    <string name="notification_listener_security_warning_summary" msgid="4317764112725749020">"<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, fotografitë dhe tekstin e mesazheve që merr. Ky aplikacion do të jetë gjithashtu në gjendje të shtyjë alarmin, të heqë njoftimet ose të veprojë mbi butonat te njoftimet, duke përfshirë përgjigjen ndaj telefonatave. \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="nls_warning_prompt" msgid="9143226910825830619">"<xliff:g id="NOTIFICATION_LISTENER_NAME">%1$s</xliff:g> do të jetë në gjendje:"</string>
    <string name="nls_feature_read_title" msgid="7629713268744220437">"Të lexojë njoftimet e tua"</string>
    <string name="nls_feature_read_summary" msgid="1064698238110273593">"Mund të lexojë njoftimet e tua, duke përfshirë informacionet personale, si p.sh. kontaktet, mesazhet dhe fotografitë."</string>
    <string name="nls_feature_reply_title" msgid="7925455553821362039">"T\'u përgjigjet mesazheve"</string>
    <string name="nls_feature_reply_summary" msgid="4492543411395565556">"Mund t\'u përgjigjet mesazheve dhe të kryejë veprime te butonat në njoftime, duke përfshirë shtyrjen ose heqjen e njoftimeve dhe përgjigjen ndaj telefonatave."</string>
    <string name="nls_feature_settings_title" msgid="8208164329853194414">"Të ndryshojë cilësimet"</string>
    <string name="nls_feature_settings_summary" msgid="3770028705648985689">"Mund të aktivizojë ose çaktivizojë modalitetin \"Mos shqetëso\" dhe të ndryshojë cilësimet që lidhen me të."</string>
    <string name="notification_listener_disable_warning_summary" msgid="8373396293802088961">"Nëse çaktivizon qasjen te njoftimet për \"<xliff:g id="NOTIFICATION_LISTENER_NAME">%1$s</xliff:g>\", mund të çaktivizohet edhe qasja te \"Mos shqetëso\"."</string>
    <string name="notification_listener_disable_warning_confirm" msgid="841492108402184976">"Çaktivizo"</string>
    <string name="notification_listener_disable_warning_cancel" msgid="8802784105045594324">"Anulo"</string>
    <string name="notification_listener_type_title" msgid="2791552789364336733">"Llojet e njoftimeve të lejuara"</string>
    <string name="notif_type_ongoing" msgid="135675014223627555">"Kohë reale"</string>
    <string name="notif_type_ongoing_summary" msgid="2348867528527573574">"Komunikim i vazhduar nga aplikacionet në përdorim, navigimi, telefonatat etj."</string>
    <string name="notif_type_conversation" msgid="4383931408641374979">"Biseda"</string>
    <string name="notif_type_conversation_summary" msgid="179142405410217101">"SMS, mesazhe me tekst dhe komunikime të tjera"</string>
    <string name="notif_type_alerting" msgid="4713073696855718576">"Njoftimet"</string>
    <string name="notif_type_alerting_summary" msgid="4681068287836313604">"Mund të bjerë zilja ose të dridhet në bazë të cilësimeve"</string>
    <string name="notif_type_silent" msgid="6273951794420331010">"Në heshtje"</string>
    <string name="notif_type_silent_summary" msgid="7820923063105060844">"Njoftimet që asnjëherë nuk nxjerrin tinguj ose dridhje"</string>
    <string name="notification_listener_allowed" msgid="5536962633536318551">"Lejohet"</string>
    <string name="notification_listener_not_allowed" msgid="3352962779597846538">"Nuk lejohet"</string>
    <string name="notif_listener_excluded_app_title" msgid="6679316209330349730">"Shiko të gjitha aplikacionet"</string>
    <string name="notif_listener_excluded_app_summary" msgid="2914567678047195396">"Ndrysho cilësimet për secilin aplikacion që dërgon njoftime"</string>
    <string name="notif_listener_excluded_app_screen_title" msgid="8636196723227432994">"Aplikacionet që shfaqen në pajisje"</string>
    <string name="notif_listener_not_migrated" msgid="6265206376374278226">"Ky aplikacion nuk i mbështet cilësimet e përmirësuara"</string>
    <string name="vr_listeners_title" msgid="4960357292472540964">"Shërbimet e ndihmësit VR"</string>
    <string name="no_vr_listeners" msgid="8442646085375949755">"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="7026351795627615177">"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="1888843557687017791">"<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="4850474436291113569">"Kur pajisja është në modalitetin VR"</string>
    <string name="display_vr_pref_low_persistence" msgid="7039841277157739871">"Zvogëlo turbullimin (rekomandohet)"</string>
    <string name="display_vr_pref_off" msgid="4008841566387432721">"Zvogëlo luhatjet e dritës"</string>
    <string name="picture_in_picture_title" msgid="9001594281840542493">"Figurë brenda figurës"</string>
    <string name="picture_in_picture_empty_text" msgid="9123600661268731579">"Asnjë aplikacion i instaluar nuk e mbështet figurën brenda figurës"</string>
    <string name="picture_in_picture_keywords" msgid="3605379820551656253">"fbf figurë brenda"</string>
    <string name="picture_in_picture_app_detail_title" msgid="4442235098255164650">"Figurë brenda figurës"</string>
    <string name="picture_in_picture_app_detail_switch" msgid="8544190716075624017">"Lejo figurë brenda figurës"</string>
    <string name="picture_in_picture_app_detail_summary" msgid="2503211101305358849">"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="interact_across_profiles_title" msgid="7285906999927669971">"Aplikacione pune dhe personale të lidhura"</string>
    <string name="interact_across_profiles_summary_allowed" msgid="1365881452153799092">"Lidhur"</string>
    <string name="interact_across_profiles_summary_not_allowed" msgid="5802674212788171790">"Nuk është lidhur"</string>
    <string name="interact_across_profiles_empty_text" msgid="419061031064397168">"Nuk ka aplikacione të lidhura"</string>
    <string name="interact_across_profiles_keywords" msgid="5996472773111665049">"kryqëzim, profil, i lidhur, aplikacion, aplikacione, punë dhe personal"</string>
    <string name="interact_across_profiles_app_detail_title" msgid="7776184211173575648">"Aplikacione pune dhe personale të lidhura"</string>
    <string name="interact_across_profiles_switch_enabled" msgid="7294719120282287495">"Lidhur"</string>
    <string name="interact_across_profiles_switch_disabled" msgid="4312196170211463988">"Lidh këto aplikacione"</string>
    <string name="interact_across_profiles_summary_1" msgid="6093976896137600231">"Aplikacionet e lidhura ndajnë leje dhe mund të kenë qasje te të dhënat e njëri-tjetrit."</string>
    <string name="interact_across_profiles_summary_2" msgid="505748305453633885">"Lidhi aplikacionet vetëm nëse u beson se nuk do t\'i ndajnë të dhënat personale me administratorin tënd të teknologjisë së informacionit."</string>
    <string name="interact_across_profiles_summary_3" msgid="444428694843299854">"Mund t\'i shkëputësh aplikacionet në çdo kohë te cilësimet e privatësisë së pajisjes."</string>
    <string name="interact_across_profiles_consent_dialog_title" msgid="8530621211216508681">"Të besohet aplikacioni <xliff:g id="NAME">%1$s</xliff:g> i punës me të dhënat e tua personale?"</string>
    <string name="interact_across_profiles_consent_dialog_summary" msgid="3949870271562055048">"Lidhi aplikacionet vetëm nëse u beson se nuk do t\'i ndajnë të dhënat personale me administratorin tënd të teknologjisë së informacionit."</string>
    <string name="interact_across_profiles_consent_dialog_app_data_title" msgid="8436318876213958940">"Të dhënat e aplikacioneve"</string>
    <string name="interact_across_profiles_consent_dialog_app_data_summary" msgid="6057019384328088311">"Ky aplikacion mund të ketë qasje tek aplikacioni yt personal <xliff:g id="NAME">%1$s</xliff:g>."</string>
    <string name="interact_across_profiles_consent_dialog_permissions_title" msgid="2316852600280487055">"Lejet"</string>
    <string name="interact_across_profiles_consent_dialog_permissions_summary" msgid="995051542847604039">"Ky aplikacion mund të përdorë lejet e tua personale të aplikacionit <xliff:g id="NAME">%1$s</xliff:g>, si: qasja te vendndodhja, hapësira ruajtëse ose kontaktet."</string>
    <string name="interact_across_profiles_number_of_connected_apps_none" msgid="8573289199942092964">"Nuk ka aplikacione të lidhura"</string>
    <plurals name="interact_across_profiles_number_of_connected_apps" formatted="false" msgid="6991750455661974772">
      <item quantity="other"><xliff:g id="COUNT_1">%d</xliff:g> aplikacione të lidhura</item>
      <item quantity="one"><xliff:g id="COUNT_0">%d</xliff:g> aplikacion i lidhur</item>
    </plurals>
    <string name="interact_across_profiles_install_work_app_title" msgid="2821669067014436056">"Për të lidhur këto aplikacione, instalo <xliff:g id="NAME">%1$s</xliff:g> në profilin tënd të punës"</string>
    <string name="interact_across_profiles_install_personal_app_title" msgid="4790651223324866344">"Për të lidhur këto aplikacione, instalo <xliff:g id="NAME">%1$s</xliff:g> në profilin tënd personal"</string>
    <string name="interact_across_profiles_install_app_summary" msgid="7715324358034968657">"Trokit për të marrë aplikacionin"</string>
    <string name="manage_zen_access_title" msgid="1562322900340107269">"Qasja te \"Mos shqetëso\""</string>
    <string name="zen_access_detail_switch" msgid="4183681772666138993">"Lejo modalitetin \"Mos shqetëso\""</string>
    <string name="zen_access_empty_text" msgid="3779921853282293080">"Asnjë aplikacion i instaluar nuk ka kërkuar qasje te \"Mos shqetëso\""</string>
    <string name="loading_notification_apps" msgid="5139471829295287945">"Po ngarkon aplikacionet…"</string>
    <string name="app_notifications_off_desc" msgid="6691342160980435901">"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="6202042207121633488">"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="9096417708500595424">"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="1502969522886493799">"Kategoritë"</string>
    <string name="notification_channels_other" msgid="18159805343647908">"Të tjera"</string>
    <plurals name="notification_group_summary" formatted="false" msgid="483490958130993160">
      <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="4716199078612071915">"Ky aplikacion nuk ka postuar asnjë njoftim"</string>
    <string name="app_settings_link" msgid="6725453466705333311">"Cilësime shtesë në aplikacion"</string>
    <string name="notification_screen_summary" msgid="5984915275134654822">"Historiku i njoftimeve, flluskat, dërguar së fundi"</string>
    <string name="app_notification_listing_summary_zero" msgid="2988400013221120744">"Aktiv për të gjitha aplikacionet"</string>
    <plurals name="app_notification_listing_summary_others" formatted="false" msgid="1506127395400503717">
      <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="5963473421547029532">
      <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="1624283327379059003">"Aktive"</string>
    <string name="notification_toggle_off" msgid="3295373308338024844">"Joaktive"</string>
    <string name="app_notification_block_title" msgid="3880322745749900296">"Bllokoji të gjitha"</string>
    <string name="app_notification_block_summary" msgid="1804611676339341551">"Mos i shfaq asnjëherë këto njoftime"</string>
    <string name="notification_content_block_title" msgid="6689085826061361351">"Shfaq njoftimet"</string>
    <string name="notification_content_block_summary" msgid="329171999992248925">"Mos shfaq asnjëherë njoftime në hije ose në pajisje periferike"</string>
    <string name="notification_badge_title" msgid="6854537463548411313">"Lejo pikën e njoftimeve"</string>
    <string name="notification_channel_badge_title" msgid="6505542437385640049">"Shfaq pikën e njoftimeve"</string>
    <string name="app_notification_override_dnd_title" msgid="3769539356442226691">"Anulo \"Mos shqetëso\""</string>
    <string name="app_notification_override_dnd_summary" msgid="4894641191397562920">"Lejo shfaqjen e njoftimeve edhe kur modaliteti \"Mos shqetëso\" është aktiv"</string>
    <string name="app_notification_visibility_override_title" msgid="7778628150022065920">"Ekrani i kyçjes"</string>
    <string name="app_notification_row_banned" msgid="4513523107019706924">"I bllokuar"</string>
    <string name="app_notification_row_priority" msgid="8100777138078316446">"Me përparësi"</string>
    <string name="app_notification_row_sensitive" msgid="7374688948587174964">"Delikate"</string>
    <string name="app_notifications_dialog_done" msgid="573716608705273004">"U krye"</string>
    <string name="app_notification_importance_title" msgid="8293193440040799998">"Rëndësia"</string>
    <string name="notification_show_lights_title" msgid="5564315979007438583">"Drita me pulsim"</string>
    <string name="notification_vibrate_title" msgid="1422330728336623351">"Dridhje"</string>
    <string name="notification_channel_sound_title" msgid="9018031231387273476">"Tingulli"</string>
    <string name="notification_conversation_important" msgid="4365437037763608045">"Me përparësi"</string>
    <string name="notification_conversation_add_to_home" msgid="8136269431130231389">"Shto te shtëpia"</string>
    <string name="zen_mode_rule_delete_button" msgid="7642063606919058862">"Fshi"</string>
    <string name="zen_mode_rule_rename_button" msgid="4158377587795511144">"Riemërto"</string>
    <string name="zen_mode_rule_name" msgid="7303080427006917702">"Emri i orarit"</string>
    <string name="zen_mode_rule_name_hint" msgid="7029432803855827697">"Vendos emrin e orarit"</string>
    <string name="zen_mode_rule_name_warning" msgid="1244435780807634954">"Emri i orarit është tashmë në përdorim"</string>
    <string name="zen_mode_add_rule" msgid="4217731747959400770">"Shto më shumë"</string>
    <string name="zen_mode_add_event_rule" msgid="9179404395950854471">"Shto orar ngjarjeje"</string>
    <string name="zen_mode_add_time_rule" msgid="2621320450155364432">"Shto orar"</string>
    <string name="zen_mode_delete_rule" msgid="5419296431989891130">"Fshi orarin"</string>
    <string name="zen_mode_choose_rule_type" msgid="7656308563653982975">"Zgjidh llojin e orarit"</string>
    <string name="zen_mode_delete_rule_confirmation" msgid="6195069346439736688">"Të fshihet rregulli \"<xliff:g id="RULE">%1$s</xliff:g>\"?"</string>
    <string name="zen_mode_delete_rule_button" msgid="8328729110756882244">"Fshi"</string>
    <string name="zen_mode_rule_type_unknown" msgid="7819162569994282316">"I panjohur"</string>
    <string name="zen_mode_app_set_behavior" msgid="4319517270279704677">"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="8544413884273894104">"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="3805244555649172848">"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="8071428540221112090">"Koha"</string>
    <string name="zen_schedule_rule_enabled_toast" msgid="6534402316741678208">"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="1921166617081971754">"Ngjarje"</string>
    <string name="zen_event_rule_enabled_toast" msgid="4943723266121388395">"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="6279460374929508907">"Gjatë ngjarjeve për"</string>
    <string name="zen_mode_event_rule_summary_calendar_template" msgid="3065013489987409864">"Gjatë ngjarjeve për <xliff:g id="CALENDAR">%1$s</xliff:g>"</string>
    <string name="zen_mode_event_rule_summary_any_calendar" msgid="8395450413356855311">"çdo kalendar"</string>
    <string name="zen_mode_event_rule_summary_reply_template" msgid="7786137431469077008">"Kur përgjigjja është <xliff:g id="REPLY">%1$s</xliff:g>"</string>
    <string name="zen_mode_event_rule_calendar_any" msgid="5152139705998281205">"Çdo kalendar"</string>
    <string name="zen_mode_event_rule_reply" msgid="6099405414361340225">"Kur përgjigjja është"</string>
    <string name="zen_mode_event_rule_reply_any_except_no" msgid="4672746760505346596">"\"Po\", \"Ndoshta\" ose \"Jo\""</string>
    <string name="zen_mode_event_rule_reply_yes_or_maybe" msgid="6584448788100186574">"\"Po\" ose \"Ndoshta\""</string>
    <string name="zen_mode_event_rule_reply_yes" msgid="7812120982734551236">"Po"</string>
    <string name="zen_mode_rule_not_found_text" msgid="5303667326973891036">"Rregulli nuk u gjet."</string>
    <string name="zen_mode_rule_summary_enabled_combination" msgid="1183604368083885789">"Aktive / <xliff:g id="MODE">%1$s</xliff:g>"</string>
    <string name="zen_mode_rule_summary_provider_combination" msgid="785343032708491365">"<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="8633770815307716351">"Ditët"</string>
    <string name="zen_mode_schedule_rule_days_none" msgid="5636604196262227070">"Asnjë"</string>
    <string name="zen_mode_schedule_rule_days_all" msgid="1583884351893245169">"Çdo ditë"</string>
    <string name="zen_mode_schedule_alarm_title" msgid="305237266064819345">"Alarmi mund të anulojë kohën e përfundimit"</string>
    <string name="zen_mode_schedule_alarm_summary" msgid="9162760856136645133">"Orari çaktivizohet kur bie një alarm"</string>
    <string name="zen_mode_custom_behavior_title" msgid="92525364576358085">"Sjellja e modalitetit \"Mos shqetëso\""</string>
    <string name="zen_mode_custom_behavior_summary_default" msgid="3259312823717839148">"Përdor cilësimet e parazgjedhura"</string>
    <string name="zen_mode_custom_behavior_summary" msgid="5390522750884328843">"Krijo cilësime të personalizuara për këtë orar"</string>
    <string name="zen_mode_custom_behavior_category_title" msgid="7815612569425733764">"Për \"<xliff:g id="SCHEDULE_NAME">%1$s</xliff:g>\""</string>
    <string name="summary_divider_text" msgid="8836285171484563986">", "</string>
    <string name="summary_range_symbol_combination" msgid="8447490077794415525">"<xliff:g id="START">%1$s</xliff:g> - <xliff:g id="END">%2$s</xliff:g>"</string>
    <string name="summary_range_verbal_combination" msgid="6022314482293187463">"<xliff:g id="START">%1$s</xliff:g> deri ditën <xliff:g id="END">%2$s</xliff:g>"</string>
    <string name="zen_mode_conversations_title" msgid="5491912973456026379">"Bisedat"</string>
    <string name="zen_mode_conversations_section_title" msgid="666809483050936026">"Bisedat që mund ta ndërpresin"</string>
    <string name="zen_mode_from_all_conversations" msgid="3447000451361857061">"Të gjitha bisedat"</string>
    <string name="zen_mode_from_important_conversations" msgid="528050873364229253">"Bisedat me përparësi"</string>
    <string name="zen_mode_from_important_conversations_second" msgid="7588299891972136599">"biseda me përparësi"</string>
    <string name="zen_mode_from_no_conversations" msgid="3924593219855567165">"Asnjë"</string>
    <string name="zen_mode_conversations_count" msgid="3199310723073707153">"{count,plural, =0{Asnjë}=1{1 bisedë}other{# biseda}}"</string>
    <string name="zen_mode_people_calls_messages_section_title" msgid="6815202112413762206">"Kush mund ta ndërpresë"</string>
    <string name="zen_mode_people_footer" msgid="7710707353004137431">"Edhe nëse aplikacionet e mesazheve apo të telefonatave nuk mund të të njoftojnë, personat që ti zgjedh këtu mund të të kontaktojnë nëpërmjet këtyre aplikacioneve"</string>
    <string name="zen_mode_calls_title" msgid="2078578043677037740">"Telefonata"</string>
    <string name="zen_mode_calls" msgid="7653245854493631095">"Telefonatat"</string>
    <string name="zen_mode_calls_list" msgid="5044730950895749093">"telefonatat"</string>
    <string name="zen_mode_calls_header" msgid="8379225445095856726">"Telefonatat që mund ta ndërpresin"</string>
    <string name="zen_mode_calls_footer" msgid="2008079711083701243">"Për t\'u siguruar që telefonatat e lejuara lëshojnë tingull, kontrollo nëse pajisja jote është caktuar me zile"</string>
    <string name="zen_mode_custom_calls_footer" msgid="6521283204577441053">"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="630299631659575589">"Kontaktet me yll"</string>
    <string name="zen_mode_starred_contacts_summary_contacts" msgid="1629467178444895094">"{count,plural,offset:2 =0{Asnjë}=1{{contact_1}}=2{{contact_1} dhe {contact_2}}=3{{contact_1}, {contact_2} dhe {contact_3}}other{{contact_1}, {contact_2} dhe # kontakte të tjera}}"</string>
    <string name="zen_mode_starred_contacts_empty_name" msgid="2906404745550293688">"(Pa emër)"</string>
    <string name="zen_mode_messages" msgid="7315084748885170585">"Mesazhet"</string>
    <string name="zen_mode_messages_list" msgid="5431014101342361882">"mesazhet"</string>
    <string name="zen_mode_messages_title" msgid="1777598523485334405">"Mesazhet"</string>
    <string name="zen_mode_messages_header" msgid="253721635061451577">"Mesazhet që mund ta ndërpresin"</string>
    <string name="zen_mode_messages_footer" msgid="6002468050854126331">"Për t\'u siguruar që mesazhet e lejuara lëshojnë tingull, kontrollo nëse pajisja jote është caktuar me zile"</string>
    <string name="zen_mode_custom_messages_footer" msgid="7545180036949550830">"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_all_messages_summary" msgid="3756267858343104554">"Të gjithë mesazhet mund të vijnë te ti"</string>
    <string name="zen_mode_all_calls_summary" msgid="7337907849083824698">"Të gjitha telefonatat mund të lidhen me ty"</string>
    <string name="zen_mode_contacts_count" msgid="6568631261119795799">"{count,plural, =0{Asnjë}=1{1 kontakt}other{# kontakte}}"</string>
    <string name="zen_mode_from_anyone" msgid="6027004263046694174">"Çdo person"</string>
    <string name="zen_mode_from_contacts" msgid="2989933306317064818">"Kontaktet"</string>
    <string name="zen_mode_from_starred" msgid="8616516644241652287">"Kontaktet me yll"</string>
    <string name="zen_mode_from_some" msgid="3708450042225044524">"Disa njerëz ose biseda"</string>
    <string name="zen_calls_summary_starred_repeat" msgid="8078759939219244001">"Nga kontaktet me yll dhe telefonuesit e përsëritur"</string>
    <string name="zen_calls_summary_contacts_repeat" msgid="2276432091940405376">"Nga kontaktet ose telefonuesit e përsëritur"</string>
    <string name="zen_calls_summary_repeat_only" msgid="7748352153193832632">"Vetëm nga telefonuesit e përsëritur"</string>
    <string name="zen_mode_none_calls" msgid="2047166006414016327">"Asnjë"</string>
    <string name="zen_mode_none_messages" msgid="1386626352943268342">"Asnjë"</string>
    <string name="zen_mode_alarms" msgid="5989343060100771099">"Alarmet"</string>
    <string name="zen_mode_alarms_summary" msgid="3388679177457223967">"Nga kohëmatësit, alarmet, sistemet e sigurisë dhe aplikacione të tjera"</string>
    <string name="zen_mode_alarms_list" msgid="334782233067365405">"alarmet"</string>
    <string name="zen_mode_alarms_list_first" msgid="2780418316613576610">"Alarmet"</string>
    <string name="zen_mode_media" msgid="885017672250984735">"Tingujt e medias"</string>
    <string name="zen_mode_media_summary" msgid="7174081803853351461">"Tingujt nga videot, lojërat dhe media të tjera"</string>
    <string name="zen_mode_media_list" msgid="2006413476596092020">"media"</string>
    <string name="zen_mode_media_list_first" msgid="7824427062528618442">"Media"</string>
    <string name="zen_mode_system" msgid="7301665021634204942">"Tingujt e prekjes"</string>
    <string name="zen_mode_system_summary" msgid="7225581762792177522">"Tingujt nga tastiera dhe butonat e tjerë"</string>
    <string name="zen_mode_system_list" msgid="2256218792042306434">"tingujt e prekjes"</string>
    <string name="zen_mode_system_list_first" msgid="8590078626001067855">"Tingujt e prekjes"</string>
    <string name="zen_mode_reminders" msgid="1970224691551417906">"Alarmet rikujtuese"</string>
    <string name="zen_mode_reminders_summary" msgid="3961627037429412382">"Nga detyrat dhe alarmet rikujtuese"</string>
    <string name="zen_mode_reminders_list" msgid="3133513621980999858">"alarmet rikujtuese"</string>
    <string name="zen_mode_reminders_list_first" msgid="1130470396012190814">"Alarmet rikujtuese"</string>
    <string name="zen_mode_events" msgid="7425795679353531794">"Ngjarjet e kalendarit"</string>
    <string name="zen_mode_events_summary" msgid="3241903481309766428">"Nga ngjarjet e ardhshme të kalendarit"</string>
    <string name="zen_mode_events_list" msgid="7191316245742097229">"ngjarjet"</string>
    <string name="zen_mode_events_list_first" msgid="7425369082835214361">"Ngjarjet"</string>
    <string name="zen_mode_bypassing_apps" msgid="625309443389126481">"Lejo aplikacionet ta anulojnë"</string>
    <string name="zen_mode_bypassing_apps_header" msgid="60083006963906906">"Aplikacionet që mund ta ndërpresin"</string>
    <string name="zen_mode_bypassing_apps_add_header" msgid="3201829605075172536">"Zgjidh më shumë aplikacione"</string>
    <string name="zen_mode_bypassing_apps_none" msgid="7944221631721778096">"Nuk u përzgjodh asnjë aplikacion"</string>
    <string name="zen_mode_bypassing_apps_subtext_none" msgid="5128770411598722200">"Asnjë aplikacion nuk mund ta ndërpresë"</string>
    <string name="zen_mode_bypassing_apps_add" msgid="5031919618521327102">"Shto aplikacione"</string>
    <string name="zen_mode_bypassing_apps_summary_all" msgid="4684544706511555744">"Të gjitha njoftimet"</string>
    <string name="zen_mode_bypassing_apps_summary_some" msgid="5315750826830358230">"Disa njoftime"</string>
    <string name="zen_mode_bypassing_apps_footer" msgid="1454862989340760124">"Persona të zgjedhur mund të të kontaktojnë ende, edhe nëse nuk i lejon aplikacionet ta ndërpresin modalitetin"</string>
    <string name="zen_mode_bypassing_apps_subtext" msgid="5258652366929842710">"{count,plural,offset:2 =0{Asnjë aplikacion nuk mund ta ndërpresë}=1{{app_1} mund ta ndërpresë}=2{{app_1} dhe {app_2} mund ta ndërpresin}=3{{app_1}, {app_2} dhe {app_3} mund ta ndërpresin}other{{app_1}, {app_2} dhe # aplikacione të tjera mund ta ndërpresin}}"</string>
    <string name="zen_mode_bypassing_apps_title" msgid="371050263563164059">"Aplikacionet"</string>
    <string name="zen_mode_bypassing_apps_all_summary" msgid="5197566190120503132">"Të gjitha njoftimet"</string>
    <string name="zen_mode_bypassing_apps_some_summary" msgid="1514572070650411509">"Disa njoftime"</string>
    <string name="zen_mode_bypassing_app_channels_header" msgid="4011017798712587373">"Njoftimet që mund ta ndërpresin"</string>
    <string name="zen_mode_bypassing_app_channels_toggle_all" msgid="1449462656358219116">"Lejo të gjitha njoftimet"</string>
    <string name="zen_mode_other_sounds_summary" msgid="8784400697494837032">"{count,plural,offset:2 =0{Asgjë nuk mund ta ndërpresë}=1{{sound_category_1} mund ta ndërpresë}=2{{sound_category_1} dhe {sound_category_2} mund ta ndërpresin}=3{{sound_category_1}, {sound_category_2} dhe {sound_category_3} mund ta ndërpresin}other{{sound_category_1}, {sound_category_2} dhe # tinguj të tjerë mund ta ndërpresin}}"</string>
    <string name="zen_mode_sounds_none" msgid="6557474361948269420">"Asgjë nuk mund ta ndërpresë"</string>
    <string name="zen_mode_people_none" msgid="4613147461974255046">"Askush nuk mund ta ndërpresë"</string>
    <string name="zen_mode_people_some" msgid="9101872681298810281">"Disa persona mund ta ndërpresin"</string>
    <string name="zen_mode_people_all" msgid="311036110283015205">"Të gjithë kontaktet mund ta ndërpresin"</string>
    <string name="zen_mode_repeat_callers" msgid="2270356100287792138">"Telefonuesit e përsëritur"</string>
    <string name="zen_mode_repeat_callers_title" msgid="8016699240338264781">"Lejo telefonuesit e përsëritur"</string>
    <string name="zen_mode_all_callers" msgid="8104755389401941875">"çdo person"</string>
    <string name="zen_mode_contacts_callers" msgid="5429267704011896833">"kontaktet"</string>
    <string name="zen_mode_starred_callers" msgid="1002370699564211178">"kontaktet me yll"</string>
    <string name="zen_mode_repeat_callers_list" msgid="181819778783743847">"telefonuesit e përsëritur"</string>
    <!-- no translation found for zen_mode_calls_summary_one (1928015516061784276) -->
    <skip />
    <string name="zen_mode_calls_summary_two" msgid="6351563496898410742">"<xliff:g id="CALLER_TYPE_0">%1$s</xliff:g> dhe <xliff:g id="CALLER_TYPE_1">%2$s</xliff:g>"</string>
    <string name="zen_mode_repeat_callers_summary" msgid="4121054819936083025">"Nëse telefonon i njëjti person për herë të dytë në një periudhë prej <xliff:g id="MINUTES">%d</xliff:g> minutash"</string>
    <string name="zen_mode_behavior_summary_custom" msgid="3126805555852783860">"Personalizo"</string>
    <string name="zen_mode_when" msgid="5710214762051824755">"Aktivizo automatikisht"</string>
    <string name="zen_mode_when_never" msgid="2537537280091840672">"Asnjëherë!"</string>
    <string name="zen_mode_when_every_night" msgid="9018738747936038166">"Çdo natë"</string>
    <string name="zen_mode_when_weeknights" msgid="531342225633264368">"Natën gjatë javës"</string>
    <string name="zen_mode_start_time" msgid="1252665038977523332">"Koha e nisjes"</string>
    <string name="zen_mode_end_time" msgid="223502560367331706">"Koha e përfundimit"</string>
    <string name="zen_mode_end_time_next_day_summary_format" msgid="419683704068360804">"<xliff:g id="FORMATTED_TIME">%s</xliff:g> ditën tjetër"</string>
    <string name="zen_mode_summary_alarms_only_indefinite" msgid="910047326128154945">"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="1900512966361163390">
      <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="955991428001659124">
      <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="8140619669703968810">"Ndrysho në gjendjen \"vetëm alarmet\" deri në <xliff:g id="FORMATTEDTIME">%1$s</xliff:g>"</string>
    <string name="zen_mode_summary_always" msgid="722093064250082317">"Ndrysho te \"ndërprit gjithmonë\""</string>
    <string name="zen_mode_screen_on" msgid="7312758100468915319">"Kur ekrani është aktiv"</string>
    <string name="zen_mode_screen_on_summary" msgid="510055058460316698">"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="7069798697669366075">"Kur ekrani është joaktiv"</string>
    <string name="zen_mode_screen_off_summary" msgid="4698018253505406152">"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="1958271859408992636">"Lejo që njoftimet e vendosura në heshtje nga \"Mos shqetëso\" të aktivizojnë ekranin"</string>
    <string name="notification_app_settings_button" msgid="4692549882609342128">"Cilësimet e njoftimeve"</string>
    <string name="warning_button_text" msgid="1274234338874005639">"Paralajmërim"</string>
    <string name="suggestion_button_text" msgid="4370673818678692873">"Në rregull"</string>
    <string name="suggestion_button_close" msgid="6865170855573283759">"Mbyll"</string>
    <string name="device_feedback" msgid="5351614458411688608">"Dërgo përshtypjet për këtë pajisje"</string>
    <string name="restr_pin_enter_admin_pin" msgid="4435410646541671918">"Fut kodin PIN të administratorit"</string>
    <string name="switch_on_text" msgid="5664542327776075105">"Aktivizuar"</string>
    <string name="switch_off_text" msgid="1315547447393646667">"Joaktiv"</string>
    <string name="nfc_setting_on" msgid="7701896496026725772">"Aktive"</string>
    <string name="nfc_setting_off" msgid="7142103438532732309">"Joaktive"</string>
    <string name="screen_pinning_switch_on_text" msgid="6971386830247542552">"Aktiv"</string>
    <string name="screen_pinning_switch_off_text" msgid="5032105155623003875">"Joaktiv"</string>
    <string name="screen_pinning_title" msgid="6927227272780208966">"Gozhdimi i aplikacionit"</string>
    <string name="app_pinning_intro" msgid="6409063008733004245">"Gozhdimi i aplikacionit të lejon ta mbash aplikacionin aktual në pamje derisa ta zhgozhdosh. Kjo veçori mund të përdoret, për shembull, për të lejuar një shok të besuar që të luajë një lojë specifike."</string>
    <string name="screen_pinning_description" msgid="4305370471370474846">"Kur një aplikacion është i gozhduar, ai mund të hapë aplikacione të tjera dhe mund të ketë qasje tek të dhënat personale. \n\nPër të përdorur gozhdimin e aplikacionit: 	\n1. Aktivizo gozhdimin e aplikacionit 	\n2. Hap \"Përmbledhja\" 	\n3. Trokit ikonën e aplikacionit në krye të ekranit dhe më pas trokit \"Gozhdo\""</string>
    <string name="screen_pinning_guest_user_description" msgid="2465729370037556955">"Kur një aplikacion është i gozhduar, ai mund të hapë aplikacione të tjera dhe mund të ketë qasje tek të dhënat personale. \n\nNëse do që ta ndash në mënyrë të sigurt pajisjen tënde me dikë, provo të përdorësh më mirë një përdorues vizitor. \n\nPër të përdorur gozhdimin e aplikacionit: 	\n1. Aktivizo gozhdimin e aplikacionit 	\n2. Hap \"Përmbledhja\" 	\n3. Trokit ikonën e aplikacionit në krye të ekranit dhe më pas trokit \"Gozhdo\""</string>
    <string name="screen_pinning_dialog_message" msgid="8144925258679476654">"Kur aplikacioni është i gozhduar: \n\n•		Të dhënat personale mund të jenë të qasshme \n		(si kontaktet dhe përmbajtja e email-eve) \n•		Aplikacioni i gozhduar mund të hapë aplikacione të tjera \n\nPërdore gozhdimin e aplikacionit vetëm me personat te të cilët ke besim."</string>
    <string name="screen_pinning_unlock_pattern" msgid="1345877794180829153">"Kërko motivin e shkyçjes para heqjes së gozhdimit"</string>
    <string name="screen_pinning_unlock_pin" msgid="8716638956097417023">"Zhgozhdimi kërkon PIN-in"</string>
    <string name="screen_pinning_unlock_password" msgid="4957969621904790573">"Kërko fjalëkalim para heqjes nga gozhdimi"</string>
    <string name="screen_pinning_unlock_none" msgid="2474959642431856316">"Kyçe pajisjen kur heq gozhdimin"</string>
    <string name="confirm_sim_deletion_title" msgid="9199369003530237871">"Konfirmo fshirjen e kartës SIM"</string>
    <string name="confirm_sim_deletion_description" msgid="8937609409607338516">"Verifiko që je ti përpara se të fshish një kartë SIM të shkarkuar"</string>
    <string name="opening_paragraph_delete_profile_unknown_company" msgid="2951348192319498135">"Ky profil pune menaxhohet nga:"</string>
    <string name="managing_admin" msgid="2633920317425356619">"I menaxhuar nga <xliff:g id="ADMIN_APP_LABEL">%s</xliff:g>"</string>
    <string name="experimental_preference" msgid="869354050717870055">"(Eksperimentale)"</string>
    <string name="encryption_interstitial_header" msgid="4418014339568737685">"Nisje e sigurt"</string>
    <string name="encryption_continue_button" msgid="3591796237625134622">"Vazhdo"</string>
    <string name="encryption_interstitial_message_pin" msgid="1413575143234269985">"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="726550613252236854">"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="6051054565294909975">"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="7152770518093102916">"Përveç përdorimit të gjurmës së gishtit për ta 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 në 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="6257856552043740490">"Përveç përdorimit të gjurmës së gishtit për ta 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 në 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="7710804822643612867">"Përveç përdorimit të gjurmës së gishtit për ta 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 në 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="8577135499926738241">"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 të 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="5851725964283239644">"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 të 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="3553329272456428461">"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 të 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_biometrics" msgid="4590004045791674901">"Përveç përdorimit të sistemeve biometrike për ta shkyçur pajisjen tënde, mund ta mbrosh edhe më shumë këtë pajisje duke kërkuar kodin tënd PIN 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 kodi PIN për të nisur pajisjen?"</string>
    <string name="encryption_interstitial_message_pattern_for_biometrics" msgid="2697768285995352576">"Përveç përdorimit të sistemeve biometrike për ta shkyçur pajisjen tënde, mund ta mbrosh edhe më shumë 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_for_biometrics" msgid="1895561539964730123">"Përveç përdorimit të sistemeve biometrike për ta 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, 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="1948016725089728181">"Po"</string>
    <string name="encryption_interstitial_no" msgid="3352331535473118487">"Jo"</string>
    <string name="restricted_true_label" msgid="612852292488747564">"I kufizuar"</string>
    <string name="restricted_false_label" msgid="2837053797913490628">"Aplikacioni mund të përdorë baterinë në sfond"</string>
    <string name="encrypt_talkback_dialog_require_pin" msgid="8974156384205924887">"Të kërkohet kodi PIN?"</string>
    <string name="encrypt_talkback_dialog_require_pattern" msgid="1587587568721873184">"Të kërkohet motivi?"</string>
    <string name="encrypt_talkback_dialog_require_password" msgid="2701793623210531836">"Të kërkohet fjalëkalim?"</string>
    <string name="encrypt_talkback_dialog_message_pin" msgid="4482887117824444481">"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="5156321541636018756">"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="1917287751192953034">"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="5766006106305996844">"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="8703564992893669514">"Informacioni i IMEI-t"</string>
    <string name="imei_information_summary" msgid="4763358372990258786">"Informacioni përkatës i IMEI-t"</string>
    <string name="slot_number" msgid="2663789411468530397">"(Foleja <xliff:g id="SLOT_NUM">%1$d</xliff:g>)"</string>
    <string name="launch_by_default" msgid="892824422067985734">"Hap me parazgjedhje"</string>
    <string name="app_launch_domain_links_title" msgid="6702041169676128550">"Hapja e lidhjeve"</string>
    <string name="app_launch_open_domain_urls_title" msgid="4805388403977096285">"Hap lidhjet e mbështetura"</string>
    <string name="app_launch_top_intro_message" msgid="137370923637482459">"Lejo që lidhjet e uebit të hapen në këtë aplikacion"</string>
    <string name="app_launch_links_category" msgid="2380467163878760037">"Lidhje që hapen në këtë aplikacion"</string>
    <string name="app_launch_open_domain_urls_summary" msgid="3609156836041234957">"Hape pa pyetur"</string>
    <string name="app_launch_supported_domain_urls_title" msgid="5088779668667217369">"Lidhjet e mbështetura"</string>
    <string name="app_launch_other_defaults_title" msgid="5674385877838735586">"Preferenca të tjera të parazgjedhura"</string>
    <string name="app_launch_add_link" msgid="8622558044530305811">"Shto lidhje"</string>
    <string name="app_launch_footer" msgid="4521865035105622557">"Një aplikacion mund t\'i verifikojë lidhjet që të hapen automatikisht në aplikacion."</string>
    <plurals name="app_launch_verified_links_title" formatted="false" msgid="3945301449178587783">
      <item quantity="other"><xliff:g id="COUNT_1">%d</xliff:g> lidhje të verifikuara</item>
      <item quantity="one"><xliff:g id="COUNT_0">%d</xliff:g> lidhje e verifikuar</item>
    </plurals>
    <plurals name="app_launch_verified_links_message" formatted="false" msgid="1209292155940482111">
      <item quantity="other">Këto lidhje verifikohen dhe hapen automatikisht në këtë aplikacion.</item>
      <item quantity="one">Kjo lidhje është verifikuar dhe hapet automatikisht në këtë aplikacion.</item>
    </plurals>
    <string name="app_launch_dialog_ok" msgid="1446157681861409861">"Në rregull"</string>
    <string name="app_launch_verified_links_info_description" msgid="7514750232467132117">"Shfaq listën e lidhjeve të verifikuara"</string>
    <string name="app_launch_checking_links_title" msgid="6119228853554114201">"Po kontrollon për lidhje të tjera të mbështetura…"</string>
    <string name="app_launch_dialog_cancel" msgid="6961071841814898663">"Anulo"</string>
    <plurals name="app_launch_supported_links_title" formatted="false" msgid="8579323750839397568">
      <item quantity="other"><xliff:g id="COUNT_1">%d</xliff:g> lidhje të mbështetura</item>
      <item quantity="one"><xliff:g id="COUNT_0">%d</xliff:g> lidhje e mbështetur</item>
    </plurals>
    <string name="app_launch_supported_links_add" msgid="3271247750388016131">"Shto"</string>
    <string name="app_launch_supported_links_subtext" msgid="4268004019469184113">"Hapet në <xliff:g id="APP_LABEL">%s</xliff:g>"</string>
    <string name="storage_summary_format" msgid="5721782272185284276">"<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="979243131665635278">"hap. ruajtëse e brendshme"</string>
    <string name="storage_type_external" msgid="125078274000280821">"hap. ruajtëse e jashtme"</string>
    <string name="data_summary_format" msgid="8802057788950096650">"<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="2591194906751432725">"Hapësirë ruajtëse e përdorur"</string>
    <string name="change" msgid="273206077375322595">"Ndrysho"</string>
    <string name="change_storage" msgid="8773820275624113401">"Ndrysho hapësirën ruajtëse"</string>
    <string name="notifications_label" msgid="8471624476040164538">"Njoftimet"</string>
    <string name="notifications_enabled" msgid="7743168481579361019">"Aktive"</string>
    <string name="notifications_enabled_with_info" msgid="1808946629277684308">"<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="5603160425378437143">"Joaktiv"</string>
    <string name="notifications_partly_blocked" msgid="5738239705473445725">"<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="2673798575466545098">"Në heshtje"</string>
    <string name="notifications_redacted" msgid="8820993927920208612">"Përmbajtja delikate jo në ekranin e kyçjes"</string>
    <string name="notifications_hidden" msgid="2415415452913806859">"Jo në ekranin e kyçjes"</string>
    <string name="notifications_priority" msgid="9068574646650663837">"\"Mos shqetëso\" u anulua"</string>
    <string name="notifications_summary_divider" msgid="6877149909390030983">" / "</string>
    <string name="notification_summary_level" msgid="4074326972839105652">"Niveli %d"</string>
    <string name="notification_summary_channel" msgid="8459033623057872803">"<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="1385401442703692986">
      <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="5015472550875144481">
      <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="2091022049141391855">
      <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="5888624648943937645">
      <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="7456745929035665029">"Nuk është dhënë leje"</string>
    <string name="runtime_permissions_summary_no_permissions_requested" msgid="7174876170116073356">"Nuk është kërkuar leje"</string>
    <string name="runtime_permissions_summary_control_app_access" msgid="3744591396348990500">"Kontrollo qasjen e apl. te të dhënat e tua"</string>
    <string name="permissions_usage_title" msgid="2942741460679049132">"Paneli i privatësisë"</string>
    <string name="permissions_usage_summary" msgid="6784310472062516454">"Shfaq se cilat aplikacione i kanë përdorur së fundi lejet"</string>
    <string name="unused_apps" msgid="4566272194756830656">"Aplikacionet e papërdorura"</string>
    <plurals name="unused_apps_summary" formatted="false" msgid="3827583582750975783">
      <item quantity="other"><xliff:g id="COUNT_1">%d</xliff:g> aplikacione të papërdorura</item>
      <item quantity="one"><xliff:g id="COUNT_0">%d</xliff:g> aplikacion i papërdorur</item>
    </plurals>
    <string name="unused_apps_category" msgid="8954930958175500851">"Cilësimet e aplikacioneve të papërdorura"</string>
    <string name="unused_apps_switch" msgid="7595419855882245772">"Ndërprit aktivitetin nëse nuk përdoret"</string>
    <string name="unused_apps_switch_summary" msgid="2171098908014596802">"Hiq lejet, fshi skedarët e përkohshëm dhe ndalo njoftimet"</string>
    <string name="filter_all_apps" msgid="6645539744080251371">"Të gjitha apl."</string>
    <string name="filter_enabled_apps" msgid="8868356616126759124">"Aplikacionet e instaluara"</string>
    <string name="filter_instant_apps" msgid="2292108467020380068">"Aplikacionet e çastit"</string>
    <string name="filter_notif_all_apps" msgid="2764590815789208306">"Aplikacionet: Të gjitha"</string>
    <string name="filter_notif_blocked_apps" msgid="1065653868850012325">"Çaktivizuar"</string>
    <string name="filter_notif_urgent_channels" msgid="875381675739324318">"Kategoritë: Rëndësia urgjente"</string>
    <string name="filter_notif_low_channels" msgid="2163005243095264537">"Kategoritë: Përparësia e ulët"</string>
    <string name="filter_notif_blocked_channels" msgid="1131444963543380495">"Kategoritë: Të çaktivizuara"</string>
    <string name="filter_notif_dnd_channels" msgid="13445325087914932">"Kategoritë: Anulon \"Mos shqetëso\""</string>
    <string name="advanced_apps" msgid="7643010673326578815">"Të përparuara"</string>
    <string name="configure_apps" msgid="5468359087126598115">"Konfiguro aplikacionet"</string>
    <string name="unknown_app" msgid="2027248925719898714">"Aplikacion i panjohur"</string>
    <string name="app_permissions" msgid="8666537659217653626">"Menaxheri i lejeve"</string>
    <string name="app_permissions_summary" msgid="2709819220672938860">"Apl. që marrin të dhëna nga <xliff:g id="APPS">%1$s</xliff:g>"</string>
    <string name="app_permissions_summary_more" msgid="6247952473615352350">"Aplikacionet që përdorin <xliff:g id="APPS">%1$s</xliff:g> dhe më shumë"</string>
    <string name="tap_to_wake" msgid="3313433536261440068">"Trokit për ta zgjuar"</string>
    <string name="tap_to_wake_summary" msgid="6641039858241611072">"Trokit dy herë diku në ekran për ta zgjuar pajisjen."</string>
    <string name="domain_urls_title" msgid="7012209752049678876">"Hapja e lidhjeve"</string>
    <string name="domain_urls_summary_none" msgid="1132578967643384733">"Mos i hap lidhjet e mbështetura"</string>
    <string name="domain_urls_summary_one" msgid="3312008753802762892">"Hap <xliff:g id="DOMAIN">%s</xliff:g>"</string>
    <string name="domain_urls_summary_some" msgid="1197692164421314523">"Hap <xliff:g id="DOMAIN">%s</xliff:g> dhe URL të tjera"</string>
    <string name="domain_urls_apps_summary_off" msgid="2534980824850890416">"Nuk ka asnjë aplikacion që hap lidhjet e mbështetura"</string>
    <plurals name="domain_urls_apps_summary_on" formatted="false" msgid="7864816862441985323">
      <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="9167065494930657503">"Lejo që aplikacioni të hapë lidhjet e mbështetura"</string>
    <string name="app_link_open_ask" msgid="2422450109908936371">"Pyet çdo herë"</string>
    <string name="app_link_open_never" msgid="5299808605386052350">"Mos lejo që aplikacioni të hapë lidhjet"</string>
    <plurals name="app_link_open_always_summary" formatted="false" msgid="1816161439007251694">
      <item quantity="other">Aplikacioni kërkon të administrojë <xliff:g id="COUNT_1">%d</xliff:g> lidhje</item>
      <item quantity="one">Aplikacioni kërkon të administrojë <xliff:g id="COUNT_0">%d</xliff:g> lidhje</item>
    </plurals>
    <string name="open_supported_links_footer" msgid="3188808142432787933">"Aplikacioni kërkon të administrojë lidhjet e mëposhtme:"</string>
    <string name="default_apps_title" msgid="6943471331817718664">"Të parazgjedhura"</string>
    <string name="default_for_work" msgid="537558180548617528">"Të parazgjedhura për punën"</string>
    <string name="assist_and_voice_input_title" msgid="6317935163145135914">"Asistenti dhe hyrja zanore"</string>
    <string name="default_assist_title" msgid="1182435129627493758">"Aplikacioni i asistentit dixhital"</string>
    <string name="default_digital_assistant_title" msgid="5654663086385490838">"Apl. i parazgjedhur i asistentit dixhital"</string>
    <string name="assistant_security_warning_title" msgid="6444187332360938730">"Bëje <xliff:g id="ASSISTANT_APP_NAME">%s</xliff:g> asistentin tënd?"</string>
    <string name="assistant_security_warning" msgid="5623237187748811070">"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="9013334158753473359">"Pranoj"</string>
    <string name="assistant_security_warning_disagree" msgid="1539182108068356410">"Nuk pranoj"</string>
    <string name="choose_voice_input_title" msgid="4855506199101586943">"Zgjidh hyrjen zanore"</string>
    <string name="default_browser_title" msgid="8342074390782390458">"Aplikacioni për shfletim"</string>
    <string name="default_browser_title_none" msgid="4691907418284764833">"Nuk ka asnjë shfletues të parazgjedhur"</string>
    <string name="default_phone_title" msgid="7616730756650803827">"Aplikacioni \"Telefoni\""</string>
    <string name="default_app" msgid="445053777504688596">"(I parazgjedhur)"</string>
    <string name="system_app" msgid="1863291702508355041">"(Sistemi)"</string>
    <string name="system_default_app" msgid="2647834628622214931">"(Parazgjedhja e sistemit)"</string>
    <string name="apps_storage" msgid="643866814746927111">"Hapësira ruajtëse e apl."</string>
    <string name="usage_access" msgid="5487993885373893282">"Qasja te përdorimi"</string>
    <string name="permit_usage_access" msgid="179630895262172674">"Lejo qasjen te përdorimi"</string>
    <string name="app_usage_preference" msgid="7062447555623339120">"Preferencat e përdorimit të aplikacioneve"</string>
    <string name="time_spent_in_app_pref_title" msgid="25327097913383330">"Koha para ekranit"</string>
    <string name="usage_access_description" msgid="8547716253713890707">"Qasja te përdorimi 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="6582588646363308430">"Memoria"</string>
    <string name="memory_details_title" msgid="3048107441540417799">"Detajet e memories"</string>
    <string name="always_running" msgid="9012705720688200252">"Gjithmonë në funksionim (<xliff:g id="PERCENTAGE">%s</xliff:g>)"</string>
    <string name="sometimes_running" msgid="7954947311082655448">"Përdoret ndonjëherë (<xliff:g id="PERCENTAGE">%s</xliff:g>)"</string>
    <string name="rarely_running" msgid="2704869567353196798">"Përdoret rrallë (<xliff:g id="PERCENTAGE">%s</xliff:g>)"</string>
    <string name="memory_max_use" msgid="8721866158069974846">"Maksimale"</string>
    <string name="memory_avg_use" msgid="4620476409349875703">"Mesatare"</string>
    <string name="memory_max_desc" msgid="6966923521720393526">"Maksimale <xliff:g id="MEMORY">%1$s</xliff:g>"</string>
    <string name="memory_avg_desc" msgid="2632995851138152303">"Mesatarisht <xliff:g id="MEMORY">%1$s</xliff:g>"</string>
    <string name="memory_use_running_format" msgid="4376086847362492613">"<xliff:g id="MEMORY">%1$s</xliff:g> / <xliff:g id="RUNNING">%2$s</xliff:g>"</string>
    <string name="process_format" msgid="4239069158701023623">"<xliff:g id="APP_NAME">%1$s</xliff:g> (<xliff:g id="COUNT">%2$d</xliff:g>)"</string>
    <string name="high_power_apps" msgid="5623152700992102510">"Optimizimi i baterisë"</string>
    <string name="additional_battery_info" msgid="3104208543623068714">"Sinjalizimet për përdorimin"</string>
    <string name="show_all_apps" msgid="4490719452453223082">"Shfaq përdorimin e plotë të pajisjes"</string>
    <string name="hide_extra_apps" msgid="7313907836289865123">"Shfaq përdorimin e aplikacionit"</string>
    <plurals name="power_high_usage_summary" formatted="false" msgid="573433136005336970">
      <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="8013115866788425817">
      <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="447849271630431531">"Nuk është optimizuar"</string>
    <string name="high_power_on" msgid="8778058701270819268">"Nuk është optimizuar"</string>
    <string name="high_power_off" msgid="317000444619279018">"Optimizimi i përdorimit të baterisë"</string>
    <string name="high_power_system" msgid="3966701453644915787">"Optimizimi i baterisë nuk ofrohet"</string>
    <string name="high_power_desc" msgid="2753076899835765338">"Mos zbato optimizimin e baterisë. Kjo mund ta shkarkojë baterinë më shpejt."</string>
    <string name="high_power_prompt_title" msgid="2574478825228409124">"Të lejohet që aplikacioni të ekzekutohet gjithmonë në sfond?"</string>
    <string name="high_power_prompt_body" msgid="6029266540782139941">"Nëse lejon që \"<xliff:g id="APP_NAME">%1$s</xliff:g>\" të ekzekutohet gjithmonë në sfond, kjo mund të zvogëlojë kohëzgjatjen e baterisë. \n\nKëtë mund ta ndryshosh më vonë nga Cilësimet &gt; Aplikacionet."</string>
    <string name="battery_summary" msgid="2491764359695671207">"<xliff:g id="PERCENTAGE">%1$s</xliff:g> përdorim që prej karikimit të fundit të plotë"</string>
    <string name="battery_summary_24hr" msgid="7656033283282656551">"<xliff:g id="PERCENTAGE">%1$s</xliff:g> e përdorimit për 24 orët e fundit"</string>
    <string name="no_battery_summary" msgid="5769159953384122003">"Asnjë përdorim i baterisë që prej karikimit të fundit të plotë"</string>
    <string name="no_battery_summary_24hr" msgid="6280079526797873842">"Nuk është përdorur bateria për 24 orët e fundit"</string>
    <string name="app_notification_preferences" msgid="2004680717999108725">"Cilësimet e aplikacionit"</string>
    <string name="system_ui_settings" msgid="936169564323330967">"Shfaq sintonizuesin SystemUI"</string>
    <string name="additional_permissions" msgid="4656871347558988462">"Lejet shtesë"</string>
    <string name="additional_permissions_more" msgid="8188145515437525307">"<xliff:g id="COUNT">%1$d</xliff:g> të tjera"</string>
    <string name="share_remote_bugreport_dialog_title" msgid="1575283098565582433">"Të ndahet raporti i defektit në kod?"</string>
    <string name="share_remote_bugreport_dialog_message_finished" msgid="4869053468609007680">"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="8714439220818865391">"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="3523877008096439251">"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="7173093464692893276">"Shpërndaj"</string>
    <string name="decline_remote_bugreport_action" msgid="1276509879613158895">"Refuzo"</string>
    <string name="usb_use_charging_only" msgid="1743303747327057947">"Nuk ka transferim të të dhënave"</string>
    <string name="usb_use_charging_only_desc" msgid="1234421230461847336">"Vetëm karikoje këtë pajisje"</string>
    <string name="usb_use_power_only" msgid="3408055485802114621">"Kariko pajisjen e lidhur"</string>
    <string name="usb_use_file_transfers" msgid="483915710802018503">"Transferimi i skedarëve"</string>
    <string name="usb_use_file_transfers_desc" msgid="1020257823387107336">"Transfero skedarët te një pajisje tjetër"</string>
    <string name="usb_use_photo_transfers" msgid="4641181628966036093">"PTP"</string>
    <string name="usb_transcode_files" msgid="2441954752105119109">"Konvertoji videot në AVC"</string>
    <string name="usb_transcode_files_summary" msgid="307102635711961513">"Videot do të luhen në më shumë luajtës të medias, por cilësia mund të jetë më e ulët"</string>
    <string name="usb_use_photo_transfers_desc" msgid="7490250033610745765">"Transfero foto ose dosje, nëse MTP-ja nuk mbështetet (PTP)"</string>
    <string name="usb_use_tethering" msgid="2897063414491670531">"Ndarje interneti përmes USB-së"</string>
    <string name="usb_use_MIDI" msgid="8621338227628859789">"MIDI"</string>
    <string name="usb_use_MIDI_desc" msgid="6464135515868405143">"Përdore këtë pajisje si MIDI"</string>
    <string name="usb_use" msgid="6783183432648438528">"Opsionet e përdorimit të USB-së:"</string>
    <string name="usb_default_label" msgid="3372838450371060750">"Konfigurimi i parazgjedhur i USB-së"</string>
    <string name="usb_default_info" msgid="167172599497085266">"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_power_title" msgid="5602112548385798646">"Opsionet e energjisë"</string>
    <string name="usb_file_transfer_title" msgid="2261577861371481478">"Opsionet e transferimit të skedarëve"</string>
    <string name="usb_pref" msgid="8521832005703261700">"USB"</string>
    <string name="usb_preference" msgid="5084550082591493765">"Preferencat e USB-së"</string>
    <string name="usb_control_title" msgid="1946791559052157693">"USB-ja kontrollohet nga"</string>
    <string name="usb_control_host" msgid="7404215921555021871">"Pajisja e lidhur"</string>
    <string name="usb_control_device" msgid="527916783743021577">"Kjo pajisje"</string>
    <string name="usb_switching" msgid="3654709188596609354">"Po ndërrohet…"</string>
    <string name="usb_switching_failed" msgid="5721262697715454137">"Nuk mund të ndërrohej"</string>
    <string name="usb_summary_charging_only" msgid="678095599403565146">"Karikon këtë pajisje"</string>
    <string name="usb_summary_power_only" msgid="4901734938857822887">"Pajisja e lidhur po karikohet"</string>
    <string name="usb_summary_file_transfers" msgid="5498487271972556431">"Transferimi i skedarëve"</string>
    <string name="usb_summary_tether" msgid="2554569836525075702">"Ndarje interneti përmes USB-së"</string>
    <string name="usb_summary_photo_transfers" msgid="7331503733435780492">"PTP"</string>
    <string name="usb_summary_MIDI" msgid="2372443732675899571">"MIDI"</string>
    <string name="usb_summary_file_transfers_power" msgid="2788374660532868630">"Transferimi i skedarëve dhe furnizimi me energji"</string>
    <string name="usb_summary_tether_power" msgid="4853034392919904792">"Ndarje interneti dhe furnizim me energji përmes USB-së"</string>
    <string name="usb_summary_photo_transfers_power" msgid="9077173567697482239">"PTP dhe furnizimi me energji"</string>
    <string name="usb_summary_MIDI_power" msgid="1184681982025435815">"MIDI dhe furnizimi me energji"</string>
    <string name="background_check_pref" msgid="5304564658578987535">"Kontrolli i sfondit"</string>
    <string name="background_check_title" msgid="225170874283229686">"Qasje e plotë në sfond"</string>
    <string name="assist_access_context_title" msgid="5201495523514096201">"Përdor tekstin nga ekrani"</string>
    <string name="assist_access_context_summary" msgid="6951814413185646275">"Lejo që aplikacioni i asistentit të qaset te përmbajtjet e ekranit si tekst"</string>
    <string name="assist_access_screenshot_title" msgid="4395902231753643633">"Përdor pamjen e ekranit"</string>
    <string name="assist_access_screenshot_summary" msgid="5276593070956201863">"Lejo që aplikacioni i asistentit të qaset te një imazh i ekranit"</string>
    <string name="assist_flash_title" msgid="5449512572885550108">"Pulso ekranin"</string>
    <string name="assist_flash_summary" msgid="3032289860177784594">"Pulso këndet e ekranit kur aplikacioni ndihmës qaset në tekstin nga ekrani apo pamja e ekranit"</string>
    <string name="assist_footer" msgid="8248015363806299068">"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="717313706368825388">"Memoria mesatare në përdorim"</string>
    <string name="maximum_memory_use" msgid="2171779724001152933">"Përdorimi maksimal i memories"</string>
    <string name="memory_usage" msgid="5594133403819880617">"Përdorimi i memories"</string>
    <string name="app_list_memory_use" msgid="3178720339027577869">"Përdorimi i aplikacionit"</string>
    <string name="memory_details" msgid="6133226869214421347">"Detajet"</string>
    <string name="memory_use_summary" msgid="3915964794146424142">"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="6708111974923274436">"Nuk u përdor memoria në 3 orët e fundit"</string>
    <string name="sort_avg_use" msgid="4416841047669186903">"Rendit sipas përdorimit mesatar"</string>
    <string name="sort_max_use" msgid="3370552820889448484">"Rendit sipas përdorimit maksimal"</string>
    <string name="memory_performance" msgid="5448274293336927570">"Performanca"</string>
    <string name="total_memory" msgid="5244174393008910567">"Memoria totale"</string>
    <string name="average_used" msgid="690235917394070169">"Mesatarja e përdorur (%)"</string>
    <string name="free_memory" msgid="439783742246854785">"E lirë"</string>
    <string name="memory_usage_apps" msgid="5776108502569850579">"Memoria e përdorur nga aplikacionet"</string>
    <plurals name="memory_usage_apps_summary" formatted="false" msgid="1355637088533572208">
      <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="7260225121706316639">"Frekuenca"</string>
    <string name="memory_maximum_usage" msgid="2047013391595835607">"Përdorimi maksimal"</string>
    <string name="no_data_usage" msgid="4665617440434654132">"Nuk janë përdorur të dhëna"</string>
    <string name="zen_access_warning_dialog_title" msgid="6323325813123130154">"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="8468714854067428987">"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="6565908224294537889">"Duhet të qëndrojë e aktivizuar sepse qasja te njoftimet është e aktivizuar"</string>
    <string name="zen_access_revoke_warning_dialog_title" msgid="7377261509261811449">"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="8689801842914183595">"Të gjitha rregullat e \"Mos shqetëso\" të krijuara nga ky aplikacion, do të hiqen."</string>
    <string name="ignore_optimizations_on" msgid="6865583039303804932">"Mos optimizo"</string>
    <string name="ignore_optimizations_off" msgid="9186557038453586295">"Optimizo"</string>
    <string name="ignore_optimizations_on_desc" msgid="1280043916460939932">"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="3324571675983286177">"Rekomandohet për një jetëgjatësi më të mirë të baterisë"</string>
    <string name="ignore_optimizations_title" msgid="3464172726254542889">"Lejo që <xliff:g id="APP">%s</xliff:g> t\'i injorojë optimizimet e baterisë?"</string>
    <string name="app_list_preference_none" msgid="1635406344616653756">"Asnjë"</string>
    <string name="work_profile_usage_access_warning" msgid="3477719910927319122">"Çaktivizimi i qasjes te përdorimi 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="4597298121698665401">"<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="7902083260500573027">"Shfaq mbi aplikacionet e tjera"</string>
    <string name="system_alert_window_settings" msgid="6458633954424862521">"Shfaq mbi aplikacionet e tjera"</string>
    <string name="system_alert_window_apps_title" msgid="1537949185175079866">"Aplikacionet"</string>
    <string name="system_alert_window_access_title" msgid="3074573819155116817">"Shfaq mbi aplikacionet e tjera"</string>
    <string name="permit_draw_overlay" msgid="4468994037192804075">"Lejo shfaqjen mbi aplikacionet e tjera"</string>
    <string name="allow_overlay_description" msgid="1607235723669496298">"Lejoje këtë aplikacion të shfaqet në krye të aplikacioneve të tjera që po përdor. Ky aplikacion do të jetë në gjendje të shikojë se ku troket ose të ndryshojë se çfarë shfaqet në ekran."</string>
    <string name="manage_external_storage_title" msgid="8024521099838816100">"Qasje te të gjithë skedarët"</string>
    <string name="permit_manage_external_storage" msgid="6928847280689401761">"Lejo qasjen për të menaxhuar të gjithë skedarët"</string>
    <string name="allow_manage_external_storage_description" msgid="5707948153603253225">"Lejo që ky aplikacion të lexojë, modifikojë dhe fshijë të gjithë skedarët në këtë pajisje ose në çdo volum hapësire ruajtjeje të lidhur. Nëse lejohet, aplikacioni mund të ketë qasje te skedarët pa dijeninë tënde të qartë."</string>
    <string name="filter_manage_external_storage" msgid="6751640571715343804">"Mund të ketë qasje te të gjithë skedarët"</string>
    <string name="media_management_apps_title" msgid="8222942355578724582">"Aplikacionet e menaxhimit të medias"</string>
    <string name="media_management_apps_toggle_label" msgid="166724270857067456">"Lejo që aplikacioni të menaxhojë median"</string>
    <string name="media_management_apps_description" msgid="8000565658455268524">"Nëse lejohet, ky aplikacion mund të modifikojë ose të fshijë skedarët e medias të krijuar me aplikacione të tjera pa të pyetur. Aplikacionet duhet të kenë leje për t\'u qasur te skedarët edhe media."</string>
    <string name="keywords_media_management_apps" msgid="7499959607583088690">"Media, skedar, menaxhim, menaxher, menaxho, modifiko, modifikues, aplikacion, program"</string>
    <string name="keywords_vr_listener" msgid="902737490270081131">"vr realitet virtual dëgjues stereo ndihmues shërbim"</string>
    <string name="overlay_settings" msgid="2030836934139139469">"Shfaq mbi aplikacionet e tjera"</string>
    <string name="system_alert_window_summary" msgid="1435856750594492891">"<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="2483998217116789206">"Aplikacionet me leje"</string>
    <string name="app_permission_summary_allowed" msgid="1155115629167757278">"Lejohet"</string>
    <string name="app_permission_summary_not_allowed" msgid="2673793662439097900">"Nuk lejohet"</string>
    <string name="keywords_install_other_apps" msgid="563895867658775580">"instalo aplikacione nga burime të panjohura"</string>
    <string name="write_settings" msgid="6864794401614425894">"Modifiko cilësimet e sistemit"</string>
    <string name="keywords_write_settings" msgid="6908708078855507813">"shkruaj modifiko sistem cilësime"</string>
    <string name="write_settings_summary" msgid="2085800775513476479">"<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="6930762738519588431">"Mund të instalojë aplikacione të tjera"</string>
    <string name="filter_write_settings_apps" msgid="4754994984909024093">"Mund të modifikojë cilësimet e sistemit"</string>
    <string name="write_settings_title" msgid="3011034187823288557">"Mund të modifikojë cilësimet e sistemit"</string>
    <string name="write_system_settings" msgid="5555707701419757421">"Modifiko cilësimet e sistemit"</string>
    <string name="permit_write_settings" msgid="3113056800709924871">"Lejo modifikimin e cilësimeve të sistemit"</string>
    <string name="write_settings_description" msgid="1474881759793261146">"Kjo leje e lejon një aplikacion të modifikojë cilësimet e sistemit."</string>
    <string name="write_settings_on" msgid="8533286548451191112">"Po"</string>
    <string name="write_settings_off" msgid="1781103034490679144">"Jo"</string>
    <string name="external_source_switch_title" msgid="101571983954849473">"Lejo nga ky burim"</string>
    <string name="camera_gesture_title" msgid="5559439253128696180">"Rrotullo dy herë për kamerën"</string>
    <string name="camera_gesture_desc" msgid="7557645057320805328">"Hap aplikacionin e kamerës duke rrotulluar kyçin e dorës dy herë"</string>
    <string name="camera_double_tap_power_gesture_title" msgid="8264757967127716261">"Shtyp butonin e energjisë dy herë për kamerën"</string>
    <string name="camera_double_tap_power_gesture_desc" msgid="1539147023700755155">"Hap me shpejtësi kamerën pa e shkyçur ekranin"</string>
    <string name="screen_zoom_title" msgid="6928045302654960559">"Madhësia e paraqitjes"</string>
    <string name="screen_zoom_short_summary" msgid="756254364808639194">"Zmadho ose zvogëlo gjithçka"</string>
    <string name="screen_zoom_keywords" msgid="5964023524422386592">"dendësia e pamjes, zmadhimi i ekranit, shkalla, shkallëzimi"</string>
    <string name="screen_zoom_summary" msgid="1362984939045594989">"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="5288355628444562735">"Pamja paraprake"</string>
    <string name="screen_zoom_make_smaller_desc" msgid="2628662648068995971">"Zvogëlo"</string>
    <string name="screen_zoom_make_larger_desc" msgid="7268794713428853139">"Zmadho"</string>
    <string name="screen_zoom_conversation_icon_alex" msgid="2896036059049355968">"A"</string>
    <string name="screen_zoom_conversation_icon_pete" msgid="4873109337506890558">"P"</string>
    <string name="screen_zoom_conversation_message_1" msgid="2641317981482545659">"Përshëndetje Ani!"</string>
    <string name="screen_zoom_conversation_message_2" msgid="6528272610590915790">"Ej, do që të takohemi sot për një kafe?"</string>
    <string name="screen_zoom_conversation_message_3" msgid="6930848361702066106">"Patjetër. Di unë një vend jo larg që këtu."</string>
    <string name="screen_zoom_conversation_message_4" msgid="2501043894465807210">"Mrekulli!"</string>
    <string name="screen_zoom_conversation_timestamp_1" msgid="512353741016062507">"E martë 18:00"</string>
    <string name="screen_zoom_conversation_timestamp_2" msgid="472183807915497199">"E martë 18:01"</string>
    <string name="screen_zoom_conversation_timestamp_3" msgid="1659313906250856104">"E martë 18:02"</string>
    <string name="screen_zoom_conversation_timestamp_4" msgid="2046797647382623313">"E martë 18:03"</string>
    <string name="disconnected" msgid="3469373726996129247">"Nuk është i lidhur"</string>
    <string name="keyboard_disconnected" msgid="796053864561894531">"Nuk është e lidhur"</string>
    <string name="data_usage_summary_format" msgid="6844301859713164522">"<xliff:g id="AMOUNT">%1$s</xliff:g> nga të dhënat janë përdorur"</string>
    <string name="data_usage_wifi_format" msgid="7644390582649568117">"<xliff:g id="AMOUNT">^1</xliff:g> të përdorura në Wi‑Fi"</string>
    <plurals name="notification_summary" formatted="false" msgid="7638388920823212470">
      <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="9179312319023988089">"Aktive për të gjitha aplikacionet"</string>
    <string name="apps_summary" msgid="4007416751775414252">"<xliff:g id="COUNT">%1$d</xliff:g> aplikacione të instaluara"</string>
    <string name="apps_summary_example" msgid="6034002063446955592">"24 aplikacione të instaluara"</string>
    <string name="storage_summary" msgid="5903562203143572768">"<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="2063780050580228868">"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="5526061030874717172">"Në gjumë pas <xliff:g id="TIMEOUT_DESCRIPTION">%1$s</xliff:g> pa aktivitet"</string>
    <string name="display_dashboard_summary" msgid="1599453894989339454">"Tema e errët, madhësia e fontit, ndriçimi"</string>
    <string name="display_summary_example" msgid="4275121979039344438">"Në gjumë pas 10 minutash pa aktivitet"</string>
    <string name="memory_summary" msgid="8221954450951651735">"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="8473589474976307510">"Identifikuar si <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="payment_summary" msgid="5513009140568552693">"<xliff:g id="APP_NAME">%1$s</xliff:g> është i parazgjedhur"</string>
    <string name="backup_disabled" msgid="4503062265560959320">"Rezervimi u çaktivizua"</string>
    <string name="android_version_summary" msgid="7818952662015042768">"Përditësuar në Android <xliff:g id="VERSION">%1$s</xliff:g>"</string>
    <string name="android_version_pending_update_summary" msgid="5404532347171027730">"Ofrohet përditësim"</string>
    <string name="disabled_by_policy_title" msgid="3635622338687810583">"Bllokuar nga administratori yt"</string>
    <string name="disabled_by_policy_title_adjust_volume" msgid="1669689058213728099">"Volumi nuk mund të ndryshohet"</string>
    <string name="disabled_by_policy_title_outgoing_calls" msgid="400089720689494562">"Telefonatat nuk mund të kryhen"</string>
    <string name="disabled_by_policy_title_sms" msgid="8951840850778406831">"Mesazhet SMS nuk mund të dërgohen"</string>
    <string name="disabled_by_policy_title_camera" msgid="6616508876399613773">"Kamera nuk mund të përdoret"</string>
    <string name="disabled_by_policy_title_screen_capture" msgid="6085100101044105811">"Pamjet e ekranit nuk mund të nxirren"</string>
    <string name="disabled_by_policy_title_suspend_packages" msgid="4223983156635729793">"Ky aplikacion nuk mund të hapet"</string>
    <string name="disabled_by_policy_title_financed_device" msgid="2328740314082888228">"Bllokuar nga ofruesi i kreditit"</string>
    <string name="disabled_by_policy_title_biometric_parental_consent" msgid="2463673997797134678">"Nevojitet prindi"</string>
    <string name="disabled_by_policy_content_biometric_parental_consent" msgid="7124116806784305206">"Jepja telefonin prindit për të filluar konfigurimin e kësaj"</string>
    <string name="default_admin_support_msg" msgid="8338570262037182531">"Nëse ke pyetje, kontakto me administratorin e TI-së"</string>
    <string name="admin_support_more_info" msgid="8407433155725898290">"Më shumë detaje"</string>
    <string name="admin_profile_owner_message" msgid="8860709969532649195">"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="4929926887231544950">"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="5503131744126520590">"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="admin_financed_message" msgid="1156197630834947884">"Administratori i pajisjes sate mund të arrijë të qaset te të dhënat e lidhura me këtë pajisje, të menaxhojë aplikacionet dhe të ndryshojë cilësimet e kësaj pajisjeje."</string>
    <string name="condition_turn_off" msgid="402707350778441939">"Çaktivizo"</string>
    <string name="condition_turn_on" msgid="3911077299444314791">"Aktivizo"</string>
    <string name="condition_expand_show" msgid="1501084007540953213">"Shfaq"</string>
    <string name="condition_expand_hide" msgid="8347564076209121058">"Fshih"</string>
    <string name="condition_hotspot_title" msgid="7903918338790641071">"Zona e qasjes është aktive"</string>
    <string name="condition_airplane_title" msgid="5847967403687381705">"Modaliteti i aeroplanit është aktiv"</string>
    <string name="condition_airplane_summary" msgid="1964500689287879888">"Rrjetet nuk ofrohen"</string>
    <string name="condition_zen_title" msgid="7674761111934567490">"\"Mos shqetëso\" është aktiv"</string>
    <string name="condition_zen_summary_phone_muted" msgid="6516753722927681820">"Telefonit i është hequr zëri"</string>
    <string name="condition_zen_summary_with_exceptions" msgid="9019937492602199663">"Me përjashtime"</string>
    <string name="condition_battery_title" msgid="6395113995454385248">"Kursyesi i baterisë është i aktivizuar"</string>
    <string name="condition_battery_summary" msgid="8436806157833107886">"Funksionet e kufizuara"</string>
    <string name="condition_cellular_title" msgid="155474690792125747">"Të dhënat celulare janë joaktive"</string>
    <string name="condition_cellular_summary" msgid="1678098728303268851">"Interneti ofrohet vetëm nëpërmjet Wi‑Fi"</string>
    <string name="condition_bg_data_title" msgid="2719263664589753094">"Kursyesi i të dhënave"</string>
    <string name="condition_bg_data_summary" msgid="1736255283216193834">"Funksionet e kufizuara"</string>
    <string name="condition_work_title" msgid="174326145616998813">"Profili i punës është i çaktivizuar"</string>
    <string name="condition_work_summary" msgid="7113473121312772398">"Për aplikacionet dhe njoftimet"</string>
    <string name="condition_device_muted_action_turn_on_sound" msgid="4078406807327674934">"Aktivizo tingullin"</string>
    <string name="condition_device_muted_title" msgid="2446306263428466378">"Ziles i është hequr zëri"</string>
    <string name="condition_device_muted_summary" msgid="3772178424510397327">"Për telefonatat dhe njoftimet"</string>
    <string name="condition_device_vibrate_title" msgid="9058943409545158583">"Vetëm me dridhje"</string>
    <string name="condition_device_vibrate_summary" msgid="7537724181691903202">"Për telefonatat dhe njoftimet"</string>
    <string name="night_display_suggestion_title" msgid="5418911386429667704">"Vendos planifikimin e \"Dritës së natës\""</string>
    <string name="night_display_suggestion_summary" msgid="4218017907425509769">"Cakto automatikisht një nuancë të ekranit çdo natë"</string>
    <string name="condition_night_display_title" msgid="1072880897812554421">"\"Drita e natës\" është aktive"</string>
    <string name="condition_night_display_summary" msgid="3278349775875166984">"Ekrani me nuancë të verdhë në portokalli"</string>
    <string name="condition_grayscale_title" msgid="9029271080007984542">"Nuancat e grisë"</string>
    <string name="condition_grayscale_summary" msgid="1306034149271251292">"Shfaq vetëm në ngjyrën gri"</string>
    <string name="homepage_condition_footer_content_description" msgid="1568313430995646108">"Palos"</string>
    <string name="suggestions_title_v2" msgid="421003737901460147">"Të sugjeruara për ty"</string>
    <string name="suggestions_title" msgid="61841299295602686">"Sugjerime"</string>
    <string name="suggestions_summary" msgid="1709710458908440469">"+<xliff:g id="ID_1">%1$d</xliff:g>"</string>
    <string name="suggestions_more_title" msgid="240124526378997009">"+<xliff:g id="ID_1">%1$d</xliff:g> të tjera"</string>
    <plurals name="suggestions_collapsed_title" formatted="false" msgid="5023679825210836444">
      <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="3789011332018516832">
      <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="6753986344585367776">"Hiqe"</string>
    <string name="color_temperature" msgid="8256912135746305176">"Temperatura e ftohtë e ngjyrës"</string>
    <string name="color_temperature_desc" msgid="6713259535885669622">"Përdor ngjyra të ftohta të ekranit"</string>
    <string name="color_temperature_toast" msgid="7611532183532407342">"Për të zbatuar ndryshimin e ngjyrës, çaktivizoje ekranin"</string>
    <string name="camera_laser_sensor_switch" msgid="7097842750947187671">"Sensori me laser i kamerës"</string>
    <string name="ota_disable_automatic_update" msgid="1953894421412420231">"Përditësimet automatike të sistemit"</string>
    <string name="ota_disable_automatic_update_summary" msgid="7803279951533276841">"Zbato përditësimet kur të riniset pajisja"</string>
    <string name="usage" msgid="287782903846013936">"Përdorimi"</string>
    <string name="cellular_data_usage" msgid="5874156338825285334">"Përdorimi i të dhënave celulare"</string>
    <string name="app_cellular_data_usage" msgid="7603292978956033926">"Përdorimi i të dhënave të aplikacionit"</string>
    <string name="wifi_data_usage" msgid="6868503699134605707">"Përdorimi i të dhënave me Wi-Fi"</string>
    <string name="non_carrier_data_usage" msgid="6494603202578414755">"Përdorimi i të dhënave jo të operatorit celular"</string>
    <string name="ethernet_data_usage" msgid="4552227880905679761">"Përdorimi i të dhënave me eternet"</string>
    <string name="wifi" msgid="2932584495223243842">"Wi-Fi"</string>
    <string name="ethernet" msgid="4665162609974492983">"Eterneti"</string>
    <string name="cell_data_template" msgid="6077963976103260821">"<xliff:g id="AMOUNT">^1</xliff:g> të dhëna celulare"</string>
    <string name="wifi_data_template" msgid="935934798340307438">"<xliff:g id="AMOUNT">^1</xliff:g> të dhëna Wi-Fi"</string>
    <string name="ethernet_data_template" msgid="1429173767445201145">"<xliff:g id="AMOUNT">^1</xliff:g> të dhëna eterneti"</string>
    <string name="billing_cycle" msgid="6618424022653876279">"Paralajmërimi dhe kufiri i të dhënave"</string>
    <string name="app_usage_cycle" msgid="341009528778520583">"Cikli i përdorimit të të dhënave të celularit"</string>
    <string name="cell_data_warning" msgid="5664921950473359634">"Paralajmërimi i të dhënave <xliff:g id="ID_1">^1</xliff:g>"</string>
    <string name="cell_data_limit" msgid="256855024790622112">"Kufiri i të dhënave <xliff:g id="ID_1">^1</xliff:g>"</string>
    <string name="cell_data_warning_and_limit" msgid="8393200831986035724">"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="6346655500491631357">"Çdo muaj në ditën <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="network_restrictions" msgid="8385824604048229846">"Kufizimet e rrjetit"</string>
    <plurals name="network_restrictions_summary" formatted="false" msgid="3875128958788008975">
      <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="5672761970087591211">"Llogaritja e të dhënave nga operatori mund të ndryshojë nga llogaritja e pajisjes"</string>
    <string name="non_carrier_data_usage_warning" msgid="4707184871368847697">"Përjashton të dhënat që përdoren nga rrjetet e operatorëve celularë"</string>
    <string name="data_used_template" msgid="8229342096562327646">"<xliff:g id="ID_1">%1$s</xliff:g> të përdorura"</string>
    <string name="set_data_warning" msgid="1685771882794205462">"Cakto paralajm. për të dhënat"</string>
    <string name="data_warning" msgid="2925054658166062884">"Paralajmërimi i të dhënave"</string>
    <string name="data_warning_footnote" msgid="5991901765915710592">"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="9010326815874642680">"Cakto kufirin e të dhënave"</string>
    <string name="data_limit" msgid="8731731657513652363">"Kufiri i të dhënave"</string>
    <string name="data_usage_template" msgid="3822452362629968010">"<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="1499586749829665889">"Konfiguro"</string>
    <string name="data_usage_other_apps" msgid="5649047093607329537">"Aplikacionet e tjera të përfshira në përdorim"</string>
    <plurals name="data_saver_unrestricted_summary" formatted="false" msgid="3316296488378947221">
      <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="4039024073687469094">"Të dhënat kryesore"</string>
    <string name="data_usage_wifi_title" msgid="1060495519280456926">"Të dhënat e Wi‑Fi"</string>
    <string name="data_used" msgid="7770571947591789895">"<xliff:g id="ID_1">^1</xliff:g> të përdorura"</string>
    <string name="data_used_formatted" msgid="7913920278059077938">"<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="3680477320458707259">"<xliff:g id="ID_1">^1</xliff:g> mbi kufi"</string>
    <string name="data_remaining" msgid="6316251496381922837">"<xliff:g id="ID_1">^1</xliff:g> të mbetura"</string>
    <string name="data_usage_chart_brief_content_description" msgid="5548074070258881530">"Grafiku shfaq të përdorimin e të dhënave mes <xliff:g id="START_DATE">%1$s</xliff:g> dhe <xliff:g id="END_DATE">%2$s</xliff:g>."</string>
    <string name="data_usage_chart_no_data_content_description" msgid="5481968839079467231">"Nuk ka të dhëna në këtë diapazon datash"</string>
    <plurals name="billing_cycle_days_left" formatted="false" msgid="661792524671718753">
      <item quantity="other">%d ditë të mbetura</item>
      <item quantity="one">%d ditë e mbetur</item>
    </plurals>
    <string name="billing_cycle_none_left" msgid="1694844019159277504">"Nuk ka më kohë të mbetur"</string>
    <string name="billing_cycle_less_than_one_day_left" msgid="1210202399053992163">"Mbetet më pak se 1 ditë"</string>
    <string name="carrier_and_update_text" msgid="5363656651921656280">"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="5432798085593055966">"U përditësua <xliff:g id="ID_1">^2</xliff:g> më parë"</string>
    <string name="carrier_and_update_now_text" msgid="5075861262344398849">"Sapo u përditësua nga <xliff:g id="ID_1">^1</xliff:g>"</string>
    <string name="no_carrier_update_now_text" msgid="7898004907837200752">"U përditësua pikërisht tani"</string>
    <string name="launch_mdp_app_text" msgid="8791816789749304897">"Shiko planin"</string>
    <string name="launch_wifi_text" msgid="976421974332512894">"Shiko detajet"</string>
    <string name="data_saver_title" msgid="2593804270788863815">"Kursyesi i të dhënave"</string>
    <string name="unrestricted_data_saver" msgid="7922563266857367495">"Të dhënat e pakufizuara"</string>
    <string name="restrict_background_blocklisted" msgid="2308345280442438232">"Të dhënat e sfondit janë të çaktivizuara"</string>
    <string name="data_saver_on" msgid="7848893946018448793">"Aktiv"</string>
    <string name="data_saver_off" msgid="5891210864117269045">"Joaktiv"</string>
    <string name="data_saver_switch_title" msgid="7111538580123722959">"Përdor \"Kursyesin e të dhënave\""</string>
    <string name="unrestricted_app_title" msgid="7117585996574329284">"Përdorim i pakufizuar i të dhënave"</string>
    <string name="unrestricted_app_summary" msgid="282698963532000403">"Lejo qasjen e pakufizuar të të dhënave kur \"Kursyesi i të dhënave\" është aktiv"</string>
    <string name="home_app" msgid="6056850504746902747">"Aplikacioni bazë"</string>
    <string name="no_default_home" msgid="3588073707316139318">"Nuk ka faqe bazë të parazgjedhur"</string>
    <string name="lockpattern_settings_require_cred_before_startup" msgid="4098653943835666086">"Nisje e sigurt"</string>
    <string name="lockpattern_settings_require_pattern_before_startup_summary" msgid="311325321794497404">"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="1881271630312222251">"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="8651761245246411947">"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="4726777300101156208">"Shto një gjurmë tjetër gishti"</string>
    <string name="suggestion_additional_fingerprints_summary" msgid="2825364645039666674">"Shkyçe me një gisht tjetër"</string>
    <string name="battery_saver_on_summary" msgid="4605146593966255848">"Aktiv"</string>
    <string name="battery_saver_off_scheduled_summary" msgid="2193875981740829819">"Do të aktivizohet në <xliff:g id="BATTERY_PERCENTAGE">%1$s</xliff:g>"</string>
    <string name="battery_saver_off_summary" msgid="4411561435493109261">"Joaktiv"</string>
    <string name="battery_saver_button_turn_on" msgid="2206239048232352476">"Aktivizo tani"</string>
    <string name="battery_saver_button_turn_off" msgid="6371072408072481484">"Çaktivizo tani"</string>
    <string name="not_battery_optimizing" msgid="8361294470943376258">"Nuk po përdoret optimizimi i baterisë"</string>
    <string name="lockscreen_remote_input" msgid="6030274311185811503">"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="7108373288347014351">"Kontrolluesi drejtshkrimor i parazgjedhur"</string>
    <string name="choose_spell_checker" msgid="7402513404783243675">"Zgjidh kontrolluesin drejtshkrimor"</string>
    <string name="spell_checker_primary_switch_title" msgid="529240542284039243">"Përdor kontrolluesin drejtshkrimor"</string>
    <string name="spell_checker_not_selected" msgid="8818618543474481451">"I pazgjedhur"</string>
    <string name="notification_log_no_title" msgid="2343315128609978203">"(asnjë)"</string>
    <string name="notification_log_details_delimiter" msgid="2475986465985309821">": "</string>
    <string name="notification_log_details_package" msgid="3205243985502010202">"paketa"</string>
    <string name="notification_log_details_key" msgid="2690467272328709046">"çelësi"</string>
    <string name="notification_log_details_group" msgid="1765952974599794393">"grupi"</string>
    <string name="notification_log_details_group_summary" msgid="4364622087007803822">"(përmbledhja)"</string>
    <string name="notification_log_details_visibility" msgid="6811292866832243357">"dukshmëria"</string>
    <string name="notification_log_details_public_version" msgid="3057653571018432759">"versioni publik"</string>
    <string name="notification_log_details_priority" msgid="4772047133062255513">"përparësia"</string>
    <string name="notification_log_details_importance" msgid="8516198274667183446">"rëndësia"</string>
    <string name="notification_log_details_explanation" msgid="6966274549873070059">"shpjegimi"</string>
    <string name="notification_log_details_badge" msgid="648647240928645446">"mund të shfaqë simbol dallues"</string>
    <string name="notification_log_details_content_intent" msgid="2768423554375629089">"synimi"</string>
    <string name="notification_log_details_delete_intent" msgid="8296434571041573503">"fshi synimin"</string>
    <string name="notification_log_details_full_screen_intent" msgid="4151243693072002296">"synimi i ekranit të plotë"</string>
    <string name="notification_log_details_actions" msgid="2269605330470905236">"veprimet"</string>
    <string name="notification_log_details_title" msgid="8365761340979164197">"titulli"</string>
    <string name="notification_log_details_remoteinput" msgid="264204203044885921">"hyrjet në largësi"</string>
    <string name="notification_log_details_content_view" msgid="7193602999512479112">"pamja e personalizuar"</string>
    <string name="notification_log_details_extras" msgid="8602887256103970989">"shtesë"</string>
    <string name="notification_log_details_icon" msgid="6728710746466389675">"ikona"</string>
    <string name="notification_log_details_parcel" msgid="2098454650154230531">"madhësia e pakos"</string>
    <string name="notification_log_details_ashmem" msgid="6163312898302809015">"ashmem"</string>
    <string name="notification_log_details_alerted" msgid="5285078967825048406">"njoftimi u sinjalizua"</string>
    <string name="notification_log_channel" msgid="3406738695621767204">"kanal"</string>
    <string name="notification_log_details_none" msgid="1090852853755089991">"asnjë"</string>
    <string name="notification_log_details_ranking_null" msgid="6607596177723101524">"Objekti i renditjes mungon."</string>
    <string name="notification_log_details_ranking_none" msgid="2484105338466675261">"Objekti i renditjes nuk e përmban këtë çelës."</string>
    <string name="theme_customization_device_default" msgid="7641813022590999286">"Parazgjedhja e pajisjes"</string>
    <string name="display_cutout_emulation" msgid="1421648375408281244">"Prerja e ekranit"</string>
    <string name="display_cutout_emulation_keywords" msgid="4506580703807358127">"prerje ekrani, e prerë"</string>
    <string name="overlay_option_device_default" msgid="7986355499809313848">"Parazgjedhja e pajisjes"</string>
    <string name="overlay_toast_failed_to_apply" msgid="4839587811338164960">"Zbatimi i mbivendosjes dështoi"</string>
    <string name="special_access" msgid="1767980727423395147">"Qasja e veçantë e apl."</string>
    <plurals name="special_access_summary" formatted="false" msgid="4995506406763570815">
      <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="132919514147475846">"Shiko më shumë"</string>
    <string name="reset_shortcut_manager_throttling" msgid="2183940254903144298">"Rivendos kufizimin e normës së ShortcutManager"</string>
    <string name="reset_shortcut_manager_throttling_complete" msgid="8949943009096885470">"Është rivendosur kufizimi i normës së ShortcutManager"</string>
    <string name="notification_suggestion_title" msgid="6309263655965785411">"Kontrollo informacionin në ekranin e kyçjes"</string>
    <string name="notification_suggestion_summary" msgid="7615611244249276113">"Shfaq ose fshih përmbajtjet e njoftimeve"</string>
    <string name="page_tab_title_summary" msgid="7188875610123234454">"Të gjitha"</string>
    <string name="page_tab_title_support" msgid="3235725053332345773">"Këshilla dhe mbështetje"</string>
    <string name="developer_smallest_width" msgid="632354817870920911">"Gjerësia më e vogël"</string>
    <string name="premium_sms_none" msgid="8737045049886416739">"Asnjë aplikacion i instaluar nuk ka kërkuar qasje te mesazhet SMS premium"</string>
    <string name="premium_sms_warning" msgid="2192300872411073324">"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="5605970342699013212">"Qasja te mesazhet SMS premium"</string>
    <string name="bluetooth_disabled" msgid="835838280837359514">"Joaktiv"</string>
    <string name="bluetooth_connected_summary" msgid="8043167194934315712">"Lidhur me <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="bluetooth_connected_multiple_devices_summary" msgid="2294954614327771844">"Lidhur me shumë pajisje"</string>
    <string name="demo_mode" msgid="6566167465451386728">"Modaliteti i demonstrimit i ndërfaqes së përdoruesit të sistemit"</string>
    <string name="dark_ui_mode" msgid="898146394425795281">"Tema e errët"</string>
    <string name="dark_ui_mode_disabled_summary_dark_theme_on" msgid="4554134480159161533">"Çaktivizuar për shkak të \"Kursyesit të baterisë\""</string>
    <string name="ambient_camera_summary_battery_saver_on" msgid="1787784892047029560">"Çaktivizuar për shkak të \"Kursyesit të baterisë\""</string>
    <string name="ambient_camera_battery_saver_off" msgid="689825730569761613">"Çaktivizo kursimin e baterisë"</string>
    <string name="dark_ui_mode_disabled_summary_dark_theme_off" msgid="4154227921313505702">"Aktivizuar përkohësisht për shkak të \"Kursyesit të baterisë\""</string>
    <string name="dark_theme_slice_title" msgid="4684222119481114062">"Provo \"Temën e errët\""</string>
    <string name="dark_theme_slice_subtitle" msgid="5555724345330434268">"Ndihmon për rritjen e kohëzgjatjes së baterisë"</string>
    <string name="quick_settings_developer_tiles" msgid="7336007844525766623">"Pllakëzat e zhvilluesit të cilësimeve të shpejta"</string>
    <string name="adb_authorization_timeout_title" msgid="6996844506783749754">"Çaktivizo kohën e pritjes së autorizimit të ADB-së"</string>
    <string name="adb_authorization_timeout_summary" msgid="409931540424019778">"Çaktivizo revokimin automatik të autorizimeve të ADB-së për sistemet që nuk janë lidhur me sasinë e parazgjedhur të kohës (7 ditë) ose të konfiguruar nga përdoruesi (minimumi 1 ditë)."</string>
    <string name="winscope_trace_quick_settings_title" msgid="4104768565053226689">"Gjurma e Winscope"</string>
    <string name="sensors_off_quick_settings_title" msgid="8472151847125917167">"Sensorët joaktivë"</string>
    <string name="managed_profile_settings_title" msgid="3400923723423564217">"Cilësimet e profilit të punës"</string>
    <string name="managed_profile_contact_search_title" msgid="6562061740814513737">"Kërko për kontakte në direktorinë e punës tek aplikacionet personale"</string>
    <string name="managed_profile_contact_search_summary" msgid="4974727886709219105">"Kërkimet dhe telefonatat e tua hyrëse mund të jenë të dukshme për administratorin e teknologjisë së informacionit"</string>
    <string name="cross_profile_calendar_title" msgid="7570277841490216947">"Kalendari i profileve"</string>
    <string name="cross_profile_calendar_summary" msgid="8856185206722860069">"Shfaq ngjarjet e punës në kalendarin personal"</string>
    <plurals name="hours" formatted="false" msgid="1853396353451635458">
      <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="6244503272924425418">
      <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="4237020272336995370">
      <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="519158151463974656">"Menaxho hapësirën ruajtëse"</string>
    <string name="automatic_storage_manager_text" msgid="6900593059927987273">"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="5077286114860539367">"Hiq fotografitë dhe videot"</string>
    <string name="automatic_storage_manager_preference_title" msgid="3483357910142595444">"Menaxheri i hapësirës ruajtëse"</string>
    <string name="automatic_storage_manager_primary_switch_title" msgid="9131959126462101994">"Përdor \"Menaxherin e hapësirës ruajtëse\""</string>
    <string name="deletion_helper_automatic_title" msgid="597196990024769472">"Automatike"</string>
    <string name="deletion_helper_manual_title" msgid="1068812971600327101">"Manual"</string>
    <string name="deletion_helper_preference_title" msgid="6364023246849161274">"Liro hapësirën tani"</string>
    <string name="gesture_preference_title" msgid="8291899281322647187">"Gjestet"</string>
    <string name="gesture_preference_summary" product="default" msgid="7941981260703379398">"Gjeste të shpejta për të kontrolluar telefonin"</string>
    <string name="gesture_preference_summary" product="tablet" msgid="4031666250963488007">"Gjestet e shpejta për të kontrolluar tabletin"</string>
    <string name="gesture_preference_summary" product="device" msgid="3520072325356373349">"Gjestet e shpejta për të kontrolluar pajisjen"</string>
    <string name="double_tap_power_for_camera_title" msgid="7982364144330923683">"Hap me shpejtësi kamerën"</string>
    <string name="double_tap_power_for_camera_summary" msgid="1100926048598415509">"Për të hapur me shpejtësi kamerën, shtyp dy herë butonin e energjisë. Funksionon nga çdo ekran."</string>
    <string name="double_tap_power_for_camera_suggestion_title" msgid="4299496243418753571">"Hap kamerën me shpejtësi"</string>
    <string name="double_twist_for_camera_mode_title" msgid="472455236910935684">"Përmbys kamerën për selfie"</string>
    <string name="double_twist_for_camera_mode_summary" msgid="592503740044744951"></string>
    <string name="double_twist_for_camera_suggestion_title" msgid="8178844037382604158">"Bëj selfi më shpejt"</string>
    <string name="system_navigation_title" msgid="1698862900901417194">"Navigimi i sistemit"</string>
    <string name="swipe_up_to_switch_apps_title" msgid="6677266952021118342">"Navigimi me 2 butona"</string>
    <string name="swipe_up_to_switch_apps_summary" msgid="1415457307836359560">"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="5754081720589900007">"Provo butonin e ri \"Ekrani bazë\""</string>
    <string name="swipe_up_to_switch_apps_suggestion_summary" msgid="8885866570559435110">"Aktivizo gjestin e ri për të ndryshuar aplikacionet"</string>
    <string name="emergency_settings_preference_title" msgid="6183455153241187148">"Siguria dhe urgjenca"</string>
    <string name="emergency_dashboard_summary" msgid="401033951074039302">"Thirrja e urgjencës, informacioni mjekësor, sinjalizimet"</string>
    <string name="edge_to_edge_navigation_title" msgid="714427081306043819">"Navigimi me gjeste"</string>
    <string name="edge_to_edge_navigation_summary" msgid="8497033810637690561">"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="7877402855994423727">"Navigimi me 3 butona"</string>
    <string name="legacy_navigation_summary" msgid="5905301067778326433">"Kthehu pas te \"Kreu\" dhe ndërro aplikacionet me butonat në fund të ekranit tënd."</string>
    <string name="keywords_system_navigation" msgid="3131782378486554934">"navigimi i sistemit, navigimi me 2 butona, navigimi me 3 butona, navigimi me gjeste, rrëshqit shpejt"</string>
    <string name="gesture_not_supported_dialog_message" msgid="5316512246119347889">"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="7909969459977021893">"Ndërro aplikacionin e parazgjedhur për ekranin bazë"</string>
    <string name="assistant_gesture_category_title" msgid="2478251256585807920">"Asistenti dixhital"</string>
    <string name="assistant_corner_gesture_title" msgid="1895061522687002106">"Rrëshqit shpejt për të aktivizuar asistentin"</string>
    <string name="assistant_corner_gesture_summary" msgid="7279576276455168075">"Rrëshqit shpejt lart nga këndi i poshtëm për të aktivizuar aplikacionin e asistentit dixhital."</string>
    <string name="assistant_long_press_home_gesture_title" msgid="4865972278738178753">"Mbaj shtypur \"Kreun\" për \"Asistentin\""</string>
    <string name="assistant_long_press_home_gesture_summary" msgid="592882226105081447">"Shtyp dhe mbaj shtypur butonin \"Kreu\" për të thirrur aplikacionin e asistentit dixhital."</string>
    <string name="information_label" msgid="6939310810756569298">"Informacione"</string>
    <string name="low_label" msgid="6525629096999711220">"I ulët"</string>
    <string name="high_label" msgid="357503396626018487">"I lartë"</string>
    <string name="left_edge" msgid="1513576842959071849">"Skaji i majtë"</string>
    <string name="right_edge" msgid="1505309103265829121">"Skaji i djathtë"</string>
    <string name="back_sensitivity_dialog_message" msgid="6638367716784103306">"Ndjeshmëria më e lartë mund të jetë në konflikt me gjestet e aplikacionit përgjatë skajeve të ekranit."</string>
    <string name="back_sensitivity_dialog_title" msgid="6153608904168908264">"Ndjeshmëria e kthimit pas"</string>
    <string name="gesture_settings_activity_title" msgid="2025828425762595733">"Ndjeshmëria e navigimit me gjeste"</string>
    <string name="button_navigation_settings_activity_title" msgid="7335636045504461813">"Navigimi me butona"</string>
    <string name="keywords_gesture_navigation_settings" msgid="667561222717238931">"navigimi me gjeste, ndjeshmëria e kthimit prapa, gjesti i kthimit prapa"</string>
    <string name="keywords_button_navigation_settings" msgid="7888812253110553920">"navigimi, butoni \"krehu\""</string>
    <string name="ambient_display_title" product="default" msgid="5885136049497127396">"Trokit dy herë për të kontrolluar telefonin"</string>
    <string name="ambient_display_title" product="tablet" msgid="205744440641466921">"Trokit dy herë për të kontrolluar tabletin"</string>
    <string name="ambient_display_title" product="device" msgid="4164103424628824786">"Trokit dy herë për të kontrolluar pajisjen"</string>
    <string name="one_handed_title" msgid="2584414010282746195">"Modaliteti i përdorimit me një dorë"</string>
    <string name="one_handed_mode_enabled" msgid="3396864848786359651">"Përdor modalitetin e përdorimit me një dorë"</string>
    <string name="one_handed_mode_shortcut_title" msgid="1847871530184067369">"Shkurtorja e modalitetit të përdorimit me një dorë"</string>
    <string name="keywords_one_handed" msgid="969440592493034101">"arritshmëria"</string>
    <string name="one_handed_mode_swipe_down_category" msgid="110178629274462484">"Me rrëshqitjen shpejt poshtë:"</string>
    <string name="one_handed_mode_use_shortcut_category" msgid="1414714099339147711">"Përdor shkurtoren për"</string>
    <string name="one_handed_mode_intro_text" msgid="7921988617828924342">"Tërhiq poshtë gjysmën e sipërme të ekranit në mënyrë që të jetë më e lehtë për t\'u arritur me një dorë"</string>
    <string name="one_handed_mode_footer_text" msgid="6336209800330679840">" "<b>"Si të përdorësh modalitetin e përdorimit me një dorë"</b>\n" • Sigurohu që navigimi me gjeste të jetë zgjedhur te cilësimet e navigimit të sistemit\n • Rrëshqit poshtë pranë skajit të poshtëm të ekranit"</string>
    <string name="one_handed_action_pull_down_screen_title" msgid="9187194533815438150">"Tërhiq ekranin brenda rrezes së kapjes"</string>
    <string name="one_handed_action_pull_down_screen_summary" msgid="7582432473450036628">"Pjesa e sipërme e ekranit do të lëvizë brenda rrezes së kapjes të gishtit të madh të dorës."</string>
    <string name="one_handed_action_show_notification_title" msgid="8789305491485437130">"Shfaq njoftimet"</string>
    <string name="one_handed_action_show_notification_summary" msgid="8281689861222000436">"Njoftimet dhe cilësimet do të shfaqen."</string>
    <string name="ambient_display_summary" msgid="2650326740502690434">"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="4418310591912877548">"Ngrije për ta kontrolluar telefonin"</string>
    <string name="ambient_display_pickup_title" product="tablet" msgid="8055486872070888377">"Ngrije për ta kontrolluar tabletin"</string>
    <string name="ambient_display_pickup_title" product="device" msgid="8980156994848721455">"Ngrije për ta kontrolluar pajisjen"</string>
    <string name="ambient_display_wake_screen_title" msgid="7637678749035378085">"Ekrani i zgjimit"</string>
    <string name="ambient_display_pickup_summary" product="default" msgid="1087355013674109242">"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="2589556997034530529">"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="1916011370011115627">"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="2811332293938467179">"Trokit për ta kontrolluar telefonin"</string>
    <string name="ambient_display_tap_screen_title" product="tablet" msgid="6461531447715370632">"Trokit për të kontrolluar tabletin"</string>
    <string name="ambient_display_tap_screen_title" product="device" msgid="4423803387551153840">"Trokit për të kontrolluar pajisjen"</string>
    <string name="ambient_display_tap_screen_summary" msgid="4480489179996521405">"Për të kontrolluar orën, njoftimet dhe informacione të tjera, trokit tek ekrani."</string>
    <string name="emergency_gesture_screen_title" msgid="3280543310204360902">"Thirrja e urgjencës"</string>
    <string name="emergency_gesture_switchbar_title" msgid="7421353963329899514">"Përdor shërbimin e \"Thirrjes së urgjencës\""</string>
    <string name="emergency_gesture_entrypoint_summary" msgid="4730874229911208834">"Menaxhohet nga <xliff:g id="APP_NAME">%1$s</xliff:g>"</string>
    <string name="emergency_gesture_screen_summary" msgid="6640521030845132507">"Shtyp butonin e energjisë 5 herë ose më shumë me shpejtësi për të nisur veprimet më poshtë"</string>
    <string name="emergency_gesture_sound_setting_title" msgid="7153948164862156536">"Luaj alarmin me numërim mbrapsht"</string>
    <string name="emergency_gesture_sound_setting_summary" msgid="6573377104470235173">"Luaj një tingull të lartë kur fillon \"Thirrja e urgjencës\""</string>
    <string name="emergency_gesture_category_call_for_help_title" msgid="1680040129478289510">"Njofto për ndihmë"</string>
    <string name="emergency_gesture_call_for_help_title" msgid="4969340870836239982">"Telefono për ndihmë"</string>
    <string name="emergency_gesture_call_for_help_dialog_title" msgid="8901271205171421201">"Numri për të telefonuar për ndihmë"</string>
    <string name="emergency_gesture_call_for_help_summary" msgid="6552830427932669221">"<xliff:g id="PHONE_NUMBER">%1$s</xliff:g>. Trokit për ta ndryshuar"</string>
    <string name="emergency_gesture_number_override_notes" msgid="233018570696200402">"Nëse fut një numër jo urgjence:\n • Pajisja jote duhet të jetë e shkyçur për të përdorur \"Thirrjen e urgjencës\"\n • Telefonatës mund të mos i përgjigjen"</string>
    <string name="fingerprint_swipe_for_notifications_title" msgid="2271217256447175017">"Rrëshqit gjurmën e gishtit për njoftimet"</string>
    <string name="fingerprint_gesture_screen_title" msgid="9086261338232806522">"Rrëshqit gjurmën e gishtit"</string>
    <string name="fingerprint_swipe_for_notifications_summary" product="default" msgid="286662791588779673">"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="8642092907817554454">"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="3888927017311372398">"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="2956636269742745449">"Shiko njoftimet me shpejtësi"</string>
    <string name="gesture_setting_on" msgid="3223448394997988591">"Aktiv"</string>
    <string name="gesture_setting_off" msgid="3444029475726294919">"Joaktiv"</string>
    <string name="oem_unlock_enable_disabled_summary_bootloader_unlocked" msgid="65713754674288193">"Ngarkuesi i sistemit është i shkyçur tashmë"</string>
    <string name="oem_unlock_enable_disabled_summary_connectivity" msgid="8045017109714463041">"Lidhu me internetin fillimisht"</string>
    <string name="oem_unlock_enable_disabled_summary_connectivity_or_locked" msgid="7425519481227423860">"Lidhu me internetin ose kontakto me operatorin celular"</string>
    <string name="oem_unlock_enable_disabled_summary_sim_locked_device" msgid="168124660162907358">"Nuk ofrohet në pajisjet e kyçura për një operator celular"</string>
    <string name="oem_lock_info_message" msgid="8843145669619429197">"Rinis pajisjen për të aktivizuar funksionin e mbrojtjes së pajisjes."</string>
    <string name="automatic_storage_manager_freed_bytes" msgid="706230592123831676">"<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="6654581786741216382">"Aplikacionet e çastit"</string>
    <string name="web_action_enable_summary" msgid="2658930257777545990">"Hap lidhjet në aplikacione, edhe nëse nuk janë të instaluara"</string>
    <string name="web_action_section_title" msgid="994717569424234098">"Aplikacionet e çastit"</string>
    <string name="instant_apps_settings" msgid="4280942494969957858">"Preferencat për \"Aplikacionet e çastit\""</string>
    <string name="domain_url_section_title" msgid="9028890472923474958">"Aplikacionet e instaluara"</string>
    <string name="automatic_storage_manager_activation_warning" msgid="170508173207142665">"Hapësira jote ruajtëse tani po menaxhohet nga menaxheri i hapësirës ruajtëse"</string>
    <string name="account_for_section_header" msgid="7466759342105251096">"Llogaritë që ka <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="configure_section_header" msgid="3126887329521705210">"Konfiguro"</string>
    <string name="auto_sync_account_title" msgid="1070908045600374254">"Sinkronizo automatikisht të dhënat e aplikacionit"</string>
    <string name="auto_sync_personal_account_title" msgid="3544275021920818595">"Sinkronizo automatikisht të dhënat personale"</string>
    <string name="auto_sync_work_account_title" msgid="6060310415978781885">"Sinkronizo automatikisht të dhënat e punës"</string>
    <string name="auto_sync_account_summary" msgid="7580352130028957346">"Lejo që aplikacionet t\'i rifreskojnë automatikisht të dhënat"</string>
    <string name="account_sync_title" msgid="7036067017433297574">"Sinkronizimi i llogarisë"</string>
    <string name="account_sync_summary_some_on" msgid="911460286297968724">"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="2953682111836599841">"Sinkronizimi aktiv për të gjithë artikujt"</string>
    <string name="account_sync_summary_all_off" msgid="6378301874540507884">"Sinkronizimi joaktiv për të gjithë artikujt"</string>
    <string name="enterprise_privacy_settings" msgid="786350385374794180">"Informacioni i pajisjes së menaxhuar"</string>
    <string name="enterprise_privacy_settings_summary_generic" msgid="5471858290610344646">"Ndryshimet dhe cilësimet menaxhohen nga organizata jote"</string>
    <string name="enterprise_privacy_settings_summary_with_name" msgid="1315413275836515937">"Ndryshimet dhe cilësimet menaxhohen nga <xliff:g id="ORGANIZATION_NAME">%s</xliff:g>"</string>
    <string name="enterprise_privacy_header" msgid="4626225398848641603">"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="2507761423540037308">"Llojet e informacionit që mund të shikojë organizata jote"</string>
    <string name="enterprise_privacy_exposure_changes_category" msgid="5459989751333816587">"Ndryshimet e kryera nga administratori i organizatës tënde"</string>
    <string name="enterprise_privacy_device_access_category" msgid="140157499478630004">"Qasja jote në këtë pajisje"</string>
    <string name="enterprise_privacy_enterprise_data" msgid="3963070078195245028">"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="6707006112254572820">"Lista e aplikacioneve në pajisjen tënde"</string>
    <string name="enterprise_privacy_usage_stats" msgid="6328506963853465534">"Sasia e kohës dhe të dhënat e harxhuara në çdo aplikacion"</string>
    <string name="enterprise_privacy_network_logs" msgid="3081744541193695887">"Regjistri më i fundit i trafikut të rrjetit"</string>
    <string name="enterprise_privacy_bug_reports" msgid="2635897583413134123">"Raporti më i fundit i defekteve në kod"</string>
    <string name="enterprise_privacy_security_logs" msgid="8494681624247959075">"Regjistri yt më i fundit i sigurisë"</string>
    <string name="enterprise_privacy_none" msgid="6026527690979756431">"Asnjë"</string>
    <string name="enterprise_privacy_enterprise_installed_packages" msgid="9114143640515900082">"Aplikacione të instaluara"</string>
    <string name="enterprise_privacy_apps_count_estimation_info" msgid="7959907857710107792">"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="5403847001419529018">
      <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="8023838718108456971">"Lejet e vendndodhjes"</string>
    <string name="enterprise_privacy_microphone_access" msgid="7242958026470143653">"Lejet e mikrofonit"</string>
    <string name="enterprise_privacy_camera_access" msgid="7685460535880069016">"Lejet e kamerës"</string>
    <string name="enterprise_privacy_enterprise_set_default_apps" msgid="7498546659083996300">"Apl. e parazgjedhura"</string>
    <plurals name="enterprise_privacy_number_packages" formatted="false" msgid="8568544906431825430">
      <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="3278314982700662246">"Tastiera e parazgjedhur"</string>
    <string name="enterprise_privacy_input_method_name" msgid="2974859490559054584">"Caktuar në <xliff:g id="APP_LABEL">%s</xliff:g>"</string>
    <string name="enterprise_privacy_always_on_vpn_device" msgid="1735829327405126695">"Rrjeti VPN gjithmonë aktiv i aktivizuar"</string>
    <string name="enterprise_privacy_always_on_vpn_personal" msgid="8395903360175064841">"Rrjeti VPN gjithmonë aktiv i aktivizuar në profilin tënd personal"</string>
    <string name="enterprise_privacy_always_on_vpn_work" msgid="2496961514592522377">"Rrjeti VPN gjithmonë aktiv i aktivizuar në profilin tënd të punës"</string>
    <string name="enterprise_privacy_global_http_proxy" msgid="4350347418068037051">"Proxy global HTTP i caktuar"</string>
    <string name="enterprise_privacy_ca_certs_device" msgid="1816495877258727663">"Kredencialet e besuara"</string>
    <string name="enterprise_privacy_ca_certs_personal" msgid="1516422660828485795">"Kredencialet e besuara në profilin tënd personal"</string>
    <string name="enterprise_privacy_ca_certs_work" msgid="4318941788592655561">"Kredencialet e besuara në profilin tënd të punës"</string>
    <plurals name="enterprise_privacy_number_ca_certs" formatted="false" msgid="6459725295322004179">
      <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="464054894363899866">"Administratori mund ta kyçë pajisjen dhe rivendosë fjalëkalimin"</string>
    <string name="enterprise_privacy_wipe_device" msgid="869589182352244591">"Administratori mund të fshijë të gjitha të dhënat e pajisjes"</string>
    <string name="enterprise_privacy_failed_password_wipe_device" msgid="7045164901334821226">"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="2537582942554484170">"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="8811973918944217791">
      <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="3067459392402324538">"Kjo pajisje menaxhohet nga organizata jote."</string>
    <string name="do_disclosure_with_name" msgid="867544298924410766">"Kjo pajisje menaxhohet nga <xliff:g id="ORGANIZATION_NAME">%s</xliff:g>."</string>
    <string name="do_disclosure_learn_more_separator" msgid="5714364437437041671">" "</string>
    <string name="learn_more" msgid="3534519107947510952">"Mëso më shumë"</string>
    <string name="blocked_by_restricted_settings_title" msgid="7334715011474037399">"Cilësim i kufizuar"</string>
    <string name="toast_allows_restricted_settings_successfully" msgid="1219116121291466102">"Cilësimet e kufizuara janë lejuar për <xliff:g id="APP_NAME">%s</xliff:g>"</string>
    <string name="blocked_by_restricted_settings_content" msgid="3628660029601161080">"Për sigurinë tënde, ky cilësim nuk ofrohet për momentin."</string>
    <string name="financed_privacy_settings" msgid="2575114436197204145">"Informacionet e pajisjes së financuar"</string>
    <string name="financed_privacy_intro" msgid="5458393846604867947">"Ofruesi yt i blerjes me këste mund të ndryshojë cilësimet dhe të instalojë softuerë në këtë pajisje.\n\nNëse harron një pagesë, pajisja jote do të kyçet.\n\nPër të mësuar më shumë, kontakto ofruesin e blerjes me këste."</string>
    <string name="financed_privacy_restrictions_category" msgid="2472659467919651602">"Nëse pajisja nuk është financuar, nuk mund:"</string>
    <string name="financed_privacy_install_apps" msgid="7381718005710210851">"Të instalosh aplikacione nga jashtë \"Dyqanit të Play\""</string>
    <string name="financed_privacy_safe_mode" msgid="5362149445732602578">"Të rindezësh pajisjen në modalitetin e sigurt"</string>
    <string name="financed_privacy_multi_users" msgid="1727194928477613081">"Të shtosh disa përdorues në pajisje"</string>
    <string name="financed_privacy_config_date_time" msgid="8567370445374984365">"Të ndryshosh datën, orën dhe brezat orarë"</string>
    <string name="financed_privacy_developer_options" msgid="7602001474669831672">"Të përdorësh opsionet e zhvilluesit"</string>
    <string name="financed_privacy_credit_provider_capabilities_category" msgid="8737902277892987998">"Ofruesi yt i blerjes me këste mund:"</string>
    <string name="financed_privacy_IMEI" msgid="1852413860963824799">"Të qaset te numri yt IMEI"</string>
    <string name="financed_privacy_factory_reset" msgid="8915355477801723433">"Të rivendosë pajisjen në gjendje fabrike"</string>
    <string name="financed_privacy_locked_mode_category" msgid="3708288398912647751">"Nëse pajisja jote është e kyçur, mund ta përdorësh atë vetëm për sa më poshtë:"</string>
    <string name="financed_privacy_emergency_calls" msgid="1108183987142736497">"Të kryesh telefonata urgjence"</string>
    <string name="financed_privacy_system_info" msgid="4158031444108708927">"Të shikosh informacionet e sistemit, si p.sh. datën, orën, statusin e rrjetit dhe baterinë"</string>
    <string name="financed_privacy_turn_on_off_device" msgid="3331566753152790571">"Të ndezësh apo fikësh pajisjen"</string>
    <string name="financed_privacy_notifications" msgid="5932303271274089968">"Për të parë njoftimet dhe mesazhet me tekst"</string>
    <string name="financed_privacy_allowlisted_apps" msgid="8333040812194879963">"Të qasesh te aplikacionet që lejohen nga ofruesi i blerjes me këste"</string>
    <string name="financed_privacy_fully_paid_category" msgid="9221763928564246923">"Pasi të paguash shumën e plotë:"</string>
    <string name="financed_privacy_restrictions_removed" msgid="3182636815294595072">"Të gjitha kufizimet do të hiqen nga pajisja"</string>
    <string name="financed_privacy_uninstall_creditor_app" msgid="6339004120497310705">"Mund ta çinstalosh aplikacionin e kreditorit"</string>
    <plurals name="default_camera_app_title" formatted="false" msgid="8112432929729136399">
      <item quantity="other">Aplikacionet e kamerës</item>
      <item quantity="one">Aplikacioni i kamerës</item>
    </plurals>
    <string name="default_calendar_app_title" msgid="1870095225089706093">"Aplikacioni i kalendarit"</string>
    <string name="default_contacts_app_title" msgid="7740028900741944569">"Aplikacioni i kontakteve"</string>
    <plurals name="default_email_app_title" formatted="false" msgid="8338194872609410234">
      <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="7569231732944853320">"Aplikacioni i hartës"</string>
    <plurals name="default_phone_app_title" formatted="false" msgid="4222188821845826493">
      <item quantity="other">Aplikacionet e telefonit</item>
      <item quantity="one">Aplikacioni i telefonit</item>
    </plurals>
    <string name="app_names_concatenation_template_2" msgid="8320181646458855457">"<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="7019703249717854148">"<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_default_internal_storage" msgid="4055660218818688131">"Kjo pajisje"</string>
    <string name="storage_photos_videos" msgid="6926197783745481869">"Fotografitë dhe videot"</string>
    <string name="storage_music_audio" msgid="1185624135490182822">"Muzika dhe audioja"</string>
    <string name="storage_games" msgid="1176568610086802469">"Lojëra"</string>
    <string name="storage_other_apps" msgid="5902520888043081176">"Aplikacionet e tjera"</string>
    <string name="storage_files" msgid="7968460921272772299">"Skedarët"</string>
    <string name="storage_images" msgid="2055893015567979387">"Imazhet"</string>
    <string name="storage_videos" msgid="6117698226447251033">"Videot"</string>
    <string name="storage_audio" msgid="5994664984472140386">"Audio"</string>
    <string name="storage_apps" msgid="3564291603258795216">"Aplikacionet"</string>
    <string name="storage_documents_and_other" msgid="3293689243732236480">"Dokumentet dhe të tjera"</string>
    <string name="storage_system" msgid="8472410119822911844">"Sistemi"</string>
    <string name="storage_trash" msgid="2807138998886084856">"Koshi"</string>
    <string name="storage_trash_dialog_title" msgid="2296169576049935200">"Të boshatiset koshi?"</string>
    <string name="storage_trash_dialog_ask_message" msgid="8982602137242358798">"Ka <xliff:g id="TOTAL">%1$s</xliff:g> skedarë te koshi. Të gjithë artikujt do të fshihen përgjithmonë dhe nuk do të mund t\'i restaurosh."</string>
    <string name="storage_trash_dialog_empty_message" msgid="7334670765528691400">"Koshi është bosh"</string>
    <string name="storage_trash_dialog_confirm" msgid="1707723334982760436">"Boshatis koshin"</string>
    <string name="storage_size_large_alternate" msgid="7555149858858591495">"<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="7102720999351050601">"Përdorur nga <xliff:g id="TOTAL">%1$s</xliff:g> gjithsej"</string>
    <string name="storage_percent_full" msgid="7211888326013020857">"e përdorur"</string>
    <string name="storage_usage_summary" msgid="4591121727356723463">"<xliff:g id="NUMBER">%1$s</xliff:g> <xliff:g id="UNIT">%2$s</xliff:g> të përdorura"</string>
    <string name="storage_total_summary" msgid="7163360249534964272">"<xliff:g id="NUMBER">%1$s</xliff:g> <xliff:g id="UNIT">%2$s</xliff:g> në total"</string>
    <string name="clear_instant_app_data" msgid="5951258323364386357">"Pastro aplikacionin"</string>
    <string name="clear_instant_app_confirmation" msgid="3964731334459209482">"Dëshiron që ta heqësh këtë aplikacion të çastit?"</string>
    <string name="launch_instant_app" msgid="8503927414339606561">"Hap"</string>
    <string name="game_storage_settings" msgid="2521393115726178837">"Lojëra"</string>
    <string name="app_info_storage_title" msgid="4076977173803093808">"Hapësira e përdorur"</string>
    <string name="webview_uninstalled_for_user" msgid="627352948986275488">"(çinstaluar për përdoruesin <xliff:g id="USER">%s</xliff:g>)"</string>
    <string name="webview_disabled_for_user" msgid="5809886172032644498">"(çaktivizuar për përdoruesin <xliff:g id="USER">%s</xliff:g>)"</string>
    <string name="autofill_app" msgid="7595308061826307921">"Shërbimi i plotësimit automatik"</string>
    <string name="autofill_passwords" msgid="6708057251459761083">"Fjalëkalimet"</string>
    <plurals name="autofill_passwords_count" formatted="false" msgid="7715009165029452622">
      <item quantity="other"><xliff:g id="COUNT_1">%1$d</xliff:g> fjalëkalime</item>
      <item quantity="one"><xliff:g id="COUNT_0">%1$d</xliff:g> fjalëkalim</item>
    </plurals>
    <string name="autofill_keywords" msgid="8598763328489346438">"automatikisht, plotëso, plotësimi automatik, fjalëkalim"</string>
    <string name="autofill_confirmation_message" msgid="4888767934273494272">"&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="5998163555428196185">"Plotësim automatik"</string>
    <string name="autofill_logging_level_title" msgid="3733958845861098307">"Niveli i identifikimit"</string>
    <string name="autofill_max_partitions" msgid="7342195529574406366">"Kërkesat maksimale për seancë"</string>
    <string name="autofill_max_visible_datasets" msgid="4970201981694392229">"Setet maksimale të dukshme të të dhënave"</string>
    <string name="autofill_reset_developer_options" msgid="6425613608979498608">"Rivendos në vlerat e parazgjedhura"</string>
    <string name="autofill_reset_developer_options_complete" msgid="1276741935956594965">"Opsionet e plotësimit automatik të zhvilluesit janë rivendosur"</string>
    <string name="location_category" msgid="3496759112306219062">"Vendndodhja"</string>
    <string name="location_indicator_settings_title" msgid="6655916258720093451">"Treguesi i vendndodhjes së shiritit të statusit"</string>
    <string name="location_indicator_settings_description" msgid="2888022085372804021">"Shfaqe për të gjitha vendndodhjet, duke përfshirë rrjetin dhe lidhshmërinë"</string>
    <string name="enable_gnss_raw_meas_full_tracking" msgid="1206679951510243341">"Matjet GNSS me fuqi të plotë"</string>
    <string name="enable_gnss_raw_meas_full_tracking_summary" msgid="3841463141138247167">"Gjurmo të gjitha koleksionet dhe frekuencat e GNSS pa ciklim të detyruar"</string>
    <string name="input_method_category" msgid="2252659253631639005">"Metoda e hyrjes"</string>
    <string name="stylus_handwriting" msgid="2154591374132794563">"Shkrimi i dorës me stilolaps"</string>
    <string name="stylus_handwriting_summary" msgid="6333425895172696950">"Kur aktivizohet, metoda aktuale e hyrjes merr stilolapsin MotionEvent nëse një \"Modifikues\" është i fokusuar."</string>
    <string name="device_theme" msgid="5027604586494772471">"Tema e pajisjes"</string>
    <string name="default_theme" msgid="4815428567082263639">"I parazgjedhur"</string>
    <string name="show_operator_name_title" msgid="3355910331531144028">"Emri i rrjetit"</string>
    <string name="show_operator_name_summary" msgid="5352696579216501773">"Shfaq emrin e rrjetit në shiritin e statusit"</string>
    <string name="storage_manager_indicator" msgid="6187509172735927297">"Menaxheri i hapësirës ruajtëse: <xliff:g id="STATUS">^1</xliff:g>"</string>
    <string name="storage_manager_indicator_off" msgid="2705959642617709265">"Joaktiv"</string>
    <string name="storage_manager_indicator_on" msgid="8380330763647785309">"Aktiv"</string>
    <string name="install_type_instant" msgid="7685381859060486009">"Aplikacioni i çastit"</string>
    <string name="automatic_storage_manager_deactivation_warning" msgid="4905106133215702099">"Të çaktivizohet menaxheri i hapësirës ruajtëse?"</string>
    <string name="storage_movies_tv" msgid="7897612625450668593">"Apl. e filmave dhe shfaqjeve televizive"</string>
    <string name="carrier_provisioning" msgid="7217868336140325816">"Informacionet e përgatitjes së operatorit celular"</string>
    <string name="trigger_carrier_provisioning" msgid="3288805742683538597">"Aktivizo përgatitjen e operatorit celular"</string>
    <string name="zen_suggestion_title" msgid="4555260320474465668">"Përditëso modalitetin \"Mos shqetëso\""</string>
    <string name="zen_suggestion_summary" msgid="1984990920503217">"Vendos njoftimet në pauzë për të qëndruar i fokusuar"</string>
    <string name="disabled_feature" msgid="7151433782819744211">"Veçoria nuk ofrohet"</string>
    <string name="disabled_feature_reason_slow_down_phone" msgid="5743569256308510404">"Kjo veçori është çaktivizuar sepse ngadalëson telefonin tënd"</string>
    <string name="show_first_crash_dialog" msgid="1696584857732637389">"Gjithmonë shfaq dialogun e ndërprerjes aksidentale"</string>
    <string name="show_first_crash_dialog_summary" msgid="4692334286984681111">"Shfaq dialogun sa herë që një aplikacion pëson ndërprerje aksidentale"</string>
    <string name="angle_enabled_app" msgid="6044941043384239076">"Zgjidh aplikacionin e aktivizuar për ANGLE"</string>
    <string name="angle_enabled_app_not_set" msgid="4472572224881726067">"Nuk është caktuar aplikacion i aktivizuar për ANGLE"</string>
    <string name="angle_enabled_app_set" msgid="7811829383833353021">"Aplikacioni i aktivizuar për ANGLE: <xliff:g id="APP_NAME">%1$s</xliff:g>"</string>
    <string name="graphics_driver_dashboard_title" msgid="5661084817492587796">"Preferencat e drejtuesit të grafikës"</string>
    <string name="graphics_driver_dashboard_summary" msgid="6348759885315793654">"Modifiko cilësimet e drejtuesit të grafikës"</string>
    <string name="graphics_driver_footer_text" msgid="5123754522284046790">"Kur ka disa drejtues grafike, 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="graphics_driver_all_apps_preference_title" msgid="1343065382898127360">"Aktivizo për të gjitha aplikacionet"</string>
    <string name="graphics_driver_app_preference_title" msgid="3133255818657706857">"Zgjidh drejtuesin e grafikës"</string>
    <string name="graphics_driver_app_preference_default" msgid="764432460281859855">"E parazgjedhur"</string>
    <string name="graphics_driver_app_preference_production_driver" msgid="1515874802568434915">"Drejtuesi i lojës"</string>
    <string name="graphics_driver_app_preference_prerelease_driver" msgid="7355929161805829480">"Drejtuesi i zhvilluesit"</string>
    <string name="graphics_driver_app_preference_system" msgid="3754748149113184126">"Drejtuesi i grafikës së sistemit"</string>
    <!-- no translation found for graphics_driver_all_apps_preference_values:0 (8039644515855740879) -->
    <!-- no translation found for graphics_driver_all_apps_preference_values:1 (157748136905839375) -->
    <!-- no translation found for graphics_driver_all_apps_preference_values:2 (8104576549429294026) -->
    <!-- no translation found for graphics_driver_app_preference_values:0 (6403705826179314116) -->
    <!-- no translation found for graphics_driver_app_preference_values:1 (485288770206606512) -->
    <!-- no translation found for graphics_driver_app_preference_values:2 (5391218026495225599) -->
    <!-- no translation found for graphics_driver_app_preference_values:3 (2586045835780389650) -->
    <string name="platform_compat_dashboard_title" msgid="1323980546791790236">"Ndryshimet e pajtueshmërisë së aplikacionit"</string>
    <string name="platform_compat_dashboard_summary" msgid="4036546607938791337">"Aktivizo ose çaktivizo ndryshimet e përputhshmërisë së aplikacionit"</string>
    <string name="platform_compat_default_enabled_title" msgid="8973137337738388024">"Ndryshimet të aktivizuara si parazgjedhje"</string>
    <string name="platform_compat_default_disabled_title" msgid="3975847180953793602">"Ndryshimet të çaktivizuara si parazgjedhje"</string>
    <string name="platform_compat_dialog_title_no_apps" msgid="4387656000745989506">"Nuk ofrohet asnjë aplikacion"</string>
    <string name="platform_compat_dialog_text_no_apps" msgid="5715226015751055812">"Ndryshimet e pajtueshmërisë së aplikacionit mund të modifikohen vetëm për aplikacionet e korrigjueshme. Instalo një aplikacion të korrigjueshëm dhe provo përsëri."</string>
    <string name="unsupported_setting_summary" product="default" msgid="1085229417771470172">"Cilësimi nuk mbështetet në këtë telefon"</string>
    <string name="unsupported_setting_summary" product="tablet" msgid="7402414129786489664">"Cilësimi nuk mbështetet në këtë tablet"</string>
    <string name="unsupported_setting_summary" product="device" msgid="3422953459122926833">"Cilësimi nuk mbështetet në këtë pajisje"</string>
    <string name="disabled_for_user_setting_summary" msgid="9096036019081828639">"Cilësimi nuk mund të ndryshohet nga përdoruesi aktual"</string>
    <string name="disabled_dependent_setting_summary" msgid="4508635725315852504">"Varet nga një cilësim tjetër"</string>
    <string name="unknown_unavailability_setting_summary" msgid="9060213910510360231">"Cilësimi nuk ofrohet"</string>
    <string name="my_device_info_account_preference_title" msgid="9197139254007133175">"Llogaria"</string>
    <string name="my_device_info_device_name_preference_title" msgid="8053298498727237971">"Emri i pajisjes"</string>
    <string name="my_device_info_basic_info_category_title" msgid="381963187269356548">"Informacionet bazë"</string>
    <string name="my_device_info_legal_category_title" msgid="7732792841537995127">"Informacione ligjore dhe rregullatore"</string>
    <string name="my_device_info_device_details_category_title" msgid="4848438695638348680">"Detajet e pajisjes"</string>
    <string name="my_device_info_device_identifiers_category_title" msgid="2197063484127704153">"Identifikuesit e pajisjes"</string>
    <string name="change_wifi_state_title" msgid="5629648102837821525">"Kontrolli i lidhjes Wi-Fi"</string>
    <string name="change_wifi_state_app_detail_switch" msgid="1385358508267180745">"Lejo që aplikacioni të kontrollojë lidhjen Wi-Fi"</string>
    <string name="change_wifi_state_app_detail_summary" msgid="8230854855584217111">"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="8283629315159510680">"Luaj median te"</string>
    <string name="media_output_label_title" msgid="4139048973886819148">"Luaj <xliff:g id="LABEL">%s</xliff:g> në"</string>
    <string name="media_output_default_summary" msgid="4200343059396412376">"Kjo pajisje"</string>
    <string name="media_output_summary" product="default" msgid="4760338801715262899">"Telefoni"</string>
    <string name="media_output_summary" product="tablet" msgid="5138101426462250247">"Tablet"</string>
    <string name="media_output_summary" product="device" msgid="3598300438694764381">"Pajisja"</string>
    <string name="media_out_summary_ongoing_call_state" msgid="475188726850090363">"Nuk ofrohet gjatë telefonatave"</string>
    <string name="media_output_summary_unavailable" msgid="2695058965888813093">"Nuk ofrohet"</string>
    <string name="media_output_group_panel_title" msgid="3086245179062913037">"Shto daljet"</string>
    <string name="media_output_group" msgid="7918231774595274396">"Grupi"</string>
    <string name="media_output_group_panel_single_device_summary" msgid="5027884071572180516">"1 pajisje e zgjedhur"</string>
    <string name="media_output_group_panel_multiple_devices_summary" msgid="4838305763151455248">"<xliff:g id="COUNT">%1$d</xliff:g> pajisje të zgjedhura"</string>
    <string name="media_output_switching" msgid="7488216595474868546">"Po ndërrohet…"</string>
    <string name="take_call_on_title" msgid="1159417893879946757">"Prano telefonatën te"</string>
    <string name="cannot_change_apn_toast" msgid="296540724089240405">"Ky emër APN nuk mund të ndryshohet."</string>
    <string name="battery_suggestion_title" product="tablet" msgid="1525940496459255289">"Përmirëso kohëzgjatjen e baterisë së tabletit"</string>
    <string name="battery_suggestion_title" product="device" msgid="2280773774080720377">"Përmirëso kohëzgjatjen e baterisë së pajisjes"</string>
    <string name="battery_suggestion_title" product="default" msgid="4811554469047272537">"Përmirëso kohëzgjatjen e baterisë së telefonit"</string>
    <string name="battery_suggestion_summary" msgid="8186720080540016197"></string>
    <string name="gesture_prevent_ringing_screen_title" msgid="8293094715267769349">"Parandalo zilen"</string>
    <string name="gesture_prevent_ringing_title" msgid="5978577898997523581">"Shtyp së bashku butonin e energjisë dhe atë të ngritjes së volumit për"</string>
    <string name="gesture_prevent_ringing_sound_title" msgid="4529077822282099235">"Shkurtore për të parandaluar zilen"</string>
    <string name="prevent_ringing_option_vibrate" msgid="5456962289649581737">"Dridhje"</string>
    <string name="prevent_ringing_option_mute" msgid="7446121133560945051">"Pa zë"</string>
    <string name="prevent_ringing_option_none" msgid="7776676007180834163">"Mos bëj asgjë"</string>
    <string name="prevent_ringing_option_vibrate_summary" msgid="3435299885425754304">"Lësho dridhje"</string>
    <string name="prevent_ringing_option_mute_summary" msgid="3939350522269337013">"Hiqi zërin"</string>
    <string name="prevent_ringing_option_unavailable_lpp_summary" msgid="3193459102328015340">"Për ta aktivizuar, në fillim ndrysho \"Shtyp dhe mbaj shtypur butonin e energjisë\" te menyja e energjisë."</string>
    <string name="pref_title_network_details" msgid="7329759534269363308">"Detajet e rrjetit"</string>
    <string name="about_phone_device_name_warning" msgid="1938930553285875166">"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, kur lidhesh me një rrjet Wi-Fi ose kur konfiguron një zonë të qasjes për internet me Wi-Fi."</string>
    <string name="devices_title" msgid="649715719278562515">"Pajisjet"</string>
    <string name="homepage_all_settings" msgid="1877827279189801035">"Të gjitha cilësimet"</string>
    <string name="homepage_personal_settings" msgid="8312279476519359656">"Sugjerime"</string>
    <string name="choose_network_title" msgid="5355609223363859430">"Zgjidh rrjetin"</string>
    <string name="network_disconnected" msgid="8281188173486212661">"I shkëputur"</string>
    <string name="network_connected" msgid="7637745547242487795">"Lidhur"</string>
    <string name="network_connecting" msgid="6856124847029124041">"Po lidhet…"</string>
    <string name="network_could_not_connect" msgid="676574629319069922">"Nuk mund të lidhej"</string>
    <string name="empty_networks_list" msgid="6519489879480673428">"Nuk u gjetën rrjete."</string>
    <string name="network_query_error" msgid="6406348372070035274">"Rrjetet nuk mund të gjendeshin. Provo përsëri."</string>
    <string name="forbidden_network" msgid="7404863971282262991">"(ndalohet)"</string>
    <string name="no_sim_card" msgid="1497407489810953863">"Nuk ka kartë SIM"</string>
    <string name="sim_card" msgid="6381158752066377709">"SIM"</string>
    <string name="wifi_no_sim_card" msgid="7144290066491585672">"Nuk ka kartë SIM"</string>
    <string name="wifi_no_related_sim_card" msgid="3568255415415630510">"Asnjë"</string>
    <string name="wifi_require_sim_card_to_connect" msgid="1524984445750423666">"Kërkon kartë SIM për t\'u lidhur"</string>
    <string name="wifi_require_specific_sim_card_to_connect" msgid="8136020469861668506">"Kërkon kartë SIM nga <xliff:g id="WIRELESS_CARRIER">%s</xliff:g> për t\'u lidhur"</string>
    <string name="preferred_network_mode_wcdma_perf_summary" msgid="230527592752934655">"Modaliteti i rrjetit të preferuar: preferohet WCDMA"</string>
    <string name="preferred_network_mode_gsm_only_summary" msgid="2936969642076535162">"Modaliteti i rrjetit të preferuar: vetëm GSM"</string>
    <string name="preferred_network_mode_wcdma_only_summary" msgid="632816273979433076">"Modaliteti i rrjetit të preferuar: vetëm WCDMA"</string>
    <string name="preferred_network_mode_gsm_wcdma_summary" msgid="6419309630040697488">"Modaliteti i rrjetit të preferuar: GSM / WCDMA"</string>
    <string name="preferred_network_mode_cdma_summary" msgid="5735467143380764681">"Modaliteti i rrjetit të preferuar: CDMA"</string>
    <string name="preferred_network_mode_cdma_evdo_summary" msgid="1667358006735235626">"Modaliteti i rrjetit të preferuar: CDMA / EvDo"</string>
    <string name="preferred_network_mode_cdma_only_summary" msgid="6305930965673800101">"Modaliteti i rrjetit të preferuar: vetëm CDMA"</string>
    <string name="preferred_network_mode_evdo_only_summary" msgid="613903666107299289">"Modaliteti i rrjetit të preferuar: vetëm EvDo"</string>
    <string name="preferred_network_mode_cdma_evdo_gsm_wcdma_summary" msgid="5643603478619124717">"Modaliteti i rrjetit të preferuar: CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_lte_summary" msgid="4236015557975544307">"Modaliteti i rrjetit të preferuar: LTE"</string>
    <string name="preferred_network_mode_lte_gsm_wcdma_summary" msgid="1377100995001285751">"Modaliteti i rrjetit të preferuar: GSM/WCDMA/LTE"</string>
    <string name="preferred_network_mode_lte_cdma_evdo_summary" msgid="1221806410911793222">"Modaliteti i rrjetit të preferuar: CDMA+LTE/EVDO"</string>
    <string name="preferred_network_mode_lte_cdma_evdo_gsm_wcdma_summary" msgid="8974263692041299883">"Modaliteti i preferuar i rrjetit: LTE/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_global_summary" msgid="817118763629102239">"Modaliteti i rrjetit të preferuar: Global"</string>
    <string name="preferred_network_mode_lte_wcdma_summary" msgid="7326137039981934928">"Modaliteti i rrjetit të preferuar: LTE / WCDMA"</string>
    <string name="preferred_network_mode_lte_gsm_umts_summary" msgid="5105989927899481131">"Modaliteti i rrjetit të preferuar: LTE / GSM / UMTS"</string>
    <string name="preferred_network_mode_lte_cdma_summary" msgid="2364210682008525703">"Modaliteti i rrjetit të preferuar: LTE / CDMA"</string>
    <string name="preferred_network_mode_tdscdma_summary" msgid="796303916110624922">"Modaliteti i rrjetit të preferuar: TDSCDMA"</string>
    <string name="preferred_network_mode_tdscdma_wcdma_summary" msgid="1465990745594594173">"Modaliteti i rrjetit të preferuar: TDSCDMA / WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_summary" msgid="3771917510642642724">"Modaliteti i rrjetit të preferuar: LTE / TDSCDMA"</string>
    <string name="preferred_network_mode_tdscdma_gsm_summary" msgid="8906951876805688851">"Modaliteti i rrjetit të preferuar: TDSCDMA / GSM"</string>
    <string name="preferred_network_mode_lte_tdscdma_gsm_summary" msgid="2264537129425897267">"Modaliteti i rrjetit të preferuar: LTE/GSM/TDSCDMA"</string>
    <string name="preferred_network_mode_tdscdma_gsm_wcdma_summary" msgid="2469046704847661521">"Modaliteti i rrjetit të preferuar: TDSCDMA/GSM/WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_wcdma_summary" msgid="2276439307637315057">"Modaliteti i rrjetit të preferuar: LTE/TDSCDMA/WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_gsm_wcdma_summary" msgid="1640309016390119366">"Modaliteti i rrjetit të preferuar: LTE/TDSCDMA/GSM/WCDMA"</string>
    <string name="preferred_network_mode_tdscdma_cdma_evdo_gsm_wcdma_summary" msgid="8918066490624875671">"Modaliteti i rrjetit të preferuar: TDSCDMA/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_cdma_evdo_gsm_wcdma_summary" msgid="1059705864131001171">"Modaliteti i rrjetit të preferuar: LTE/TDSCDMA/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_nr_only_summary" msgid="9153575102136218656">"Modaliteti i preferuar i rrjetit: Vetëm NR"</string>
    <string name="preferred_network_mode_nr_lte_summary" msgid="4326679533556458480">"Modaliteti i preferuar i rrjetit: NR / LTE"</string>
    <string name="preferred_network_mode_nr_lte_cdma_evdo_summary" msgid="4030662583832600005">"Modaliteti i preferuar i rrjetit: NR/LTE/CDMA/EvDo"</string>
    <string name="preferred_network_mode_nr_lte_gsm_wcdma_summary" msgid="8327982533965785835">"Modaliteti i preferuar i rrjetit: NR/LTE/GSM/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_cdma_evdo_gsm_wcdma_summary" msgid="7892233480076496041">"Modaliteti i preferuar i rrjetit: NR/LTE/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_wcdma_summary" msgid="5762334298562095421">"Modaliteti i preferuar i rrjetit: NR/LTE/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_summary" msgid="2356681171665091175">"Modaliteti i preferuar i rrjetit: NR/LTE/TDSCDMA"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_gsm_summary" msgid="8889597344872814893">"Modaliteti i preferuar i rrjetit: NR/LTE/TDSCDMA/GSM"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_wcdma_summary" msgid="506057560516483258">"Modaliteti i preferuar i rrjetit: NR/LTE/TDSCDMA/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_gsm_wcdma_summary" msgid="4337061745216872524">"Modaliteti i preferuar i rrjetit: NR/LTE/TDSCDMA/GSM/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_cdma_evdo_gsm_wcdma_summary" msgid="3396717432149544381">"Modaliteti i preferuar i rrjetit: NR/LTE/TDSCDMA/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="network_5G_recommended" msgid="4769018972369031538">"5G (rekomandohet)"</string>
    <string name="network_lte" msgid="2449425437381668780">"LTE (rekomandohet)"</string>
    <string name="network_4G" msgid="9018841362928321047">"4G (rekomandohet)"</string>
    <string name="label_available" msgid="5305726869955838606">"Rrjete të arritshme"</string>
    <string name="load_networks_progress" msgid="4717874401621250401">"Po kërkon…"</string>
    <string name="register_on_network" msgid="2169662800750709709">"Po regjistron në <xliff:g id="NETWORK">%s</xliff:g>…"</string>
    <string name="not_allowed" msgid="5756935665192962915">"Karta SIM nuk lejon lidhje me këtë rrjet."</string>
    <string name="connect_later" msgid="2330538069949281352">"Nuk mund të lidhet me këtë rrjet tani. Provo sërish më vonë."</string>
    <string name="registration_done" msgid="1750434215698850123">"Regjistruar në rrjet."</string>
    <string name="select_automatically" msgid="2419752566747259155">"Zgjidh automatikisht rrjetin"</string>
    <string name="carrier_settings_title" msgid="6959295328730560529">"Cilësimet e operatorit"</string>
    <string name="cdma_lte_data_service" msgid="6937443423651347345">"Konfiguro shërbimin e të dhënave"</string>
    <string name="mobile_data_settings_title" msgid="3927524078598009792">"Të dhënat celulare"</string>
    <string name="mobile_data_settings_summary" msgid="7323978798199919063">"Qasu te të dhënat duke përdorur rrjetin celular"</string>
    <string name="mobile_data_settings_summary_auto_switch" msgid="7851549787645698945">"Telefoni do të kalojë automatikisht te ky operator celular kur të jetë brenda rrezes"</string>
    <string name="mobile_data_settings_summary_unavailable" msgid="3309106501029928951">"Nuk ka kartë SIM"</string>
    <string name="calls_preference" msgid="2166481296066890129">"Preferencat e telefonatave"</string>
    <string name="sms_preference" msgid="7742964962568219351">"Preferenca për SMS"</string>
    <string name="calls_and_sms_ask_every_time" msgid="3178743088737726677">"Pyet çdo herë"</string>
    <string name="mobile_network_summary_add_a_network" msgid="9079866102827526779">"Shto një rrjet"</string>
    <plurals name="mobile_network_summary_count" formatted="false" msgid="5173633860800230925">
      <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="2788950217176988034">"E parazgjedhur për telefonatat"</string>
    <string name="default_for_sms" msgid="1316988329407434771">"E parazgjedhur për SMS"</string>
    <string name="default_for_calls_and_sms" msgid="8223971369339958151">"E parazgjedhur për telefonatat dhe SMS"</string>
    <string name="default_for_mobile_data" msgid="3725773640392315626">"E parazgjedhur për të dhënat celulare"</string>
    <string name="mobile_data_active" msgid="8683694456401350210">"Të dhënat celulare janë aktive"</string>
    <string name="mobile_data_off" msgid="2702029611959308269">"Të dhënat celulare janë joaktive"</string>
    <string name="subscription_available" msgid="2659722770210403365">"Në shitje"</string>
    <string name="mobile_network_in_range" msgid="3528320750936028369">"Brenda rrezes"</string>
    <string name="mobile_network_not_in_range" msgid="5680896182395366584">"Nuk është brenda rrezes"</string>
    <string name="mobile_network_list_add_more" msgid="4478586073355236604">"Shto më shumë"</string>
    <string name="mobile_network_active_sim" msgid="6397581267971410039">"Aktiv / SIM"</string>
    <string name="mobile_network_inactive_sim" msgid="5829757490580409899">"Joaktiv / SIM"</string>
    <string name="mobile_network_active_esim" msgid="4673190244386572318">"Aktiv / karta SIM e shkarkuar"</string>
    <string name="mobile_network_inactive_esim" msgid="2901035056727849007">"Joaktiv / karta SIM e shkarkuar"</string>
    <string name="mobile_network_sim_name" msgid="3187192894150386537">"Emri i kartës SIM dhe ngjyra"</string>
    <string name="mobile_network_sim_name_label" msgid="1452440641628369625">"Emri"</string>
    <string name="mobile_network_sim_color_label" msgid="5293944087609632340">"Ngjyra (e përdorur nga aplikacionet e përputhshme)"</string>
    <string name="mobile_network_sim_name_rename" msgid="5967588549571582924">"Ruaj"</string>
    <string name="mobile_network_use_sim_on" msgid="7298332437547707908">"Përdor kartën SIM"</string>
    <string name="mobile_network_use_sim_off" msgid="6303281166199670639">"Joaktive"</string>
    <string name="mobile_network_disable_sim_explanation" msgid="2851862257846773796">"Për ta çaktivizuar këtë kartë SIM, hiqe kartën SIM"</string>
    <string name="mobile_network_tap_to_activate" msgid="4139979375717958102">"Trokit për të aktivizuar <xliff:g id="CARRIER">%1$s</xliff:g>"</string>
    <string name="mobile_network_esim_swap_confirm_title" msgid="2762744961192218789">"Do të kalosh te <xliff:g id="CARRIER">%1$s</xliff:g>?"</string>
    <string name="mobile_network_esim_swap_confirm_body" msgid="8168680839542031781">"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="8695772737522378095">"Kalo te <xliff:g id="CARRIER">%1$s</xliff:g>"</string>
    <string name="mobile_network_erase_sim" msgid="4629071168032714930">"Spastro kartën SIM"</string>
    <string name="mobile_network_erase_sim_error_dialog_title" msgid="6680959559589234726">"Karta SIM nuk mund të spastrohet"</string>
    <string name="mobile_network_erase_sim_error_dialog_body" msgid="6401922869095572710">"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="3083431168988535628">"Lloji i rrjetit të preferuar"</string>
    <string name="preferred_network_mode_summary" msgid="537577807865497546">"Ndrysho modalitetin e operimit të rrjetit"</string>
    <string name="preferred_network_mode_dialogtitle" msgid="4179420486180351631">"Lloji i rrjetit të preferuar"</string>
    <string name="carrier_settings_euicc" msgid="1541279297111378907">"Operatori celular"</string>
    <string name="carrier_settings_version" msgid="3364919669057317776">"Versioni i cilësimeve të operatorit celular"</string>
    <string name="call_category" msgid="641461844504128789">"Po telefonon"</string>
    <string name="video_calling_settings_title" msgid="5490466306783552190">"Telefonata me video e operatorit celular"</string>
    <string name="cdma_system_select_title" msgid="8261408056382123386">"Përzgjedhja e sistemit"</string>
    <string name="cdma_system_select_summary" msgid="384128007068464145">"Ndrysho modalitetin CDMA të roaming-ut"</string>
    <string name="cdma_system_select_dialogtitle" msgid="6143586810486936984">"Përzgjedhja e sistemit"</string>
    <string name="network_operator_category" msgid="5309383730335681395">"Rrjeti"</string>
    <string name="network_select_title" msgid="4532395144000206685">"Rrjeti"</string>
    <string name="cdma_subscription_title" msgid="3107207913315872336">"Abonimi CDMA"</string>
    <string name="cdma_subscription_summary" msgid="7134032708555561334">"Ndrysho mes RUIM/SIM dhe NV"</string>
    <string name="cdma_subscription_dialogtitle" msgid="555971296756231647">"abonimi"</string>
    <string name="register_automatically" msgid="5208258089316657167">"Regjistrim automatik…"</string>
    <string name="roaming_alert_title" msgid="9052791521868787985">"Të lejohet shfrytëzimi i roaming-ut?"</string>
    <string name="roaming_check_price_warning" msgid="5876977438036791361">"Kontakto me operatorin celular të rrjetit për çmimin."</string>
    <string name="mobile_data_usage_title" msgid="2047864499317759728">"Përdorimi i të dhënave të aplikacionit"</string>
    <string name="mobile_network_mode_error" msgid="9222056129897416074">"Regjim i pavlefshëm i rrjetit <xliff:g id="NETWORKMODEID">%1$d</xliff:g>. Shpërfille."</string>
    <string name="mobile_network_apn_title" msgid="5582995550142073054">"Emrat e pikës së qasjes"</string>
    <string name="manual_mode_disallowed_summary" msgid="4243142645520152175">"Nuk ofrohet kur është e lidhur me <xliff:g id="CARRIER">%1$s</xliff:g>"</string>
    <string name="see_more" msgid="7499355691042812723">"Shiko më shumë"</string>
    <string name="see_less" msgid="2642392725363552793">"Shiko më pak"</string>
    <string name="sim_action_enable_sub_dialog_title" msgid="4003377033815971802">"Të aktivizohet <xliff:g id="CARRIER_NAME">%1$s</xliff:g>?"</string>
    <string name="sim_action_enable_sub_dialog_title_without_carrier_name" msgid="4842051610633654278">"Të aktivizohet SIM?"</string>
    <string name="sim_action_switch_sub_dialog_title" msgid="9180969453358718635">"Do të kalosh te <xliff:g id="CARRIER_NAME">%1$s</xliff:g>?"</string>
    <string name="sim_action_switch_psim_dialog_title" msgid="5613177333235213024">"Dëshiron të kalosh te përdorimi i kartës SIM?"</string>
    <string name="sim_action_switch_sub_dialog_mep_title" msgid="933856847099933004">"Të përdoret <xliff:g id="CARRIER_NAME">%1$s</xliff:g>?"</string>
    <string name="sim_action_switch_sub_dialog_text" msgid="2091834911153293004">"Vetëm një kartë SIM mund të jetë aktive në të njëjtën kohë.\n\nKalimi te <xliff:g id="TO_CARRIER_NAME">%1$s</xliff:g> nuk do ta anulojë shërbimin e <xliff:g id="FROM_CARRIER_NAME">%2$s</xliff:g>."</string>
    <string name="sim_action_switch_sub_dialog_text_downloaded" msgid="1396320209544698027">"Vetëm një kartë SIM e shkarkuar mund të jetë aktive në të njëjtën kohë.\n\nKalimi te <xliff:g id="TO_CARRIER_NAME">%1$s</xliff:g> nuk do ta anulojë shërbimin e <xliff:g id="FROM_CARRIER_NAME">%2$s</xliff:g>."</string>
    <string name="sim_action_switch_sub_dialog_text_single_sim" msgid="6188750682431170845">"Vetëm një kartë SIM mund të jetë aktive në të njëjtën kohë.\n\nKalimi nuk do ta anulojë shërbimin e <xliff:g id="TO_CARRIER_NAME">%1$s</xliff:g>."</string>
    <string name="sim_action_switch_sub_dialog_mep_text" msgid="8348764755143679582">"Mund të përdorësh 2 karta SIM në të njëjtën kohë. Për të përdorur <xliff:g id="CARRIER_NAME">%1$s</xliff:g>, çaktivizo një kartë tjetër SIM."</string>
    <string name="sim_action_switch_sub_dialog_confirm" msgid="1901181581944638961">"Kalo te <xliff:g id="CARRIER_NAME">%1$s</xliff:g>"</string>
    <string name="sim_action_switch_sub_dialog_carrier_list_item_for_turning_off" msgid="5392037608705799522">"Çaktivizo <xliff:g id="CARRIER_NAME">%1$s</xliff:g>"</string>
    <string name="sim_action_switch_sub_dialog_info_outline_for_turning_off" msgid="1617619100229136888">"Çaktivizimi i kartës SIM nuk do ta anulojë shërbimin"</string>
    <string name="sim_action_enabling_sim_without_carrier_name" msgid="2706862823501979981">"Po lidhet me rrjetin…"</string>
    <string name="sim_action_switch_sub_dialog_progress" msgid="4718412054243793310">"Po kalohet te <xliff:g id="CARRIER_NAME">%1$s</xliff:g> për telefonatat dhe mesazhet…"</string>
    <string name="sim_action_enable_sim_fail_title" msgid="1765646238941015899">"Operatori nuk mund të ndërrohet"</string>
    <string name="sim_action_enable_sim_fail_text" msgid="4781863235721417544">"Operatori nuk mund të ndërrohet për shkak të një gabimi."</string>
    <string name="privileged_action_disable_sub_dialog_title" msgid="3298942357601334418">"Të çaktivizohet <xliff:g id="CARRIER_NAME">%1$s</xliff:g>?"</string>
    <string name="privileged_action_disable_sub_dialog_title_without_carrier" msgid="6518373229436331608">"Të çaktivizohet karta SIM?"</string>
    <string name="privileged_action_disable_sub_dialog_progress" msgid="5900243067681478102">"Po çaktivizohet karta SIM<xliff:g id="ELLIPSIS">…</xliff:g>"</string>
    <string name="privileged_action_disable_fail_title" msgid="6689494935697043555">"Operatori celular nuk mund të çaktivizohet"</string>
    <string name="privileged_action_disable_fail_text" msgid="8404023523406091819">"Ndodhi një gabim dhe operatori celular nuk mund të çaktivizohet."</string>
    <string name="sim_action_enable_dsds_title" msgid="226508711751577169">"Dëshiron të përdorësh 2 karta SIM?"</string>
    <string name="sim_action_enable_dsds_text" msgid="970986559326263949">"Kjo pajisje mund të ketë 2 karta SIM aktive në të njëjtën kohë. Që të vazhdosh të përdorësh vetëm 1 kartë SIM, trokit te \"Jo, faleminderit\"."</string>
    <string name="sim_action_restart_title" msgid="7054617569121993825">"Të riniset pajisja?"</string>
    <string name="sim_action_restart_text" msgid="8019300474703571013">"Për të filluar, rinise pajisjen tënde. Më pas mund të shtosh një kartë tjetër SIM."</string>
    <string name="sim_action_continue" msgid="1688813133152389943">"Vazhdo"</string>
    <string name="sim_action_yes" msgid="8076556020131395515">"Po"</string>
    <string name="sim_action_reboot" msgid="3508948833333441538">"Rinis"</string>
    <string name="sim_action_no_thanks" msgid="435717748384544195">"Jo, faleminderit"</string>
    <string name="sim_action_cancel" msgid="2668099867029610910">"Anulo"</string>
    <string name="sim_switch_button" msgid="1405772571706095387">"Ndërro"</string>
    <string name="dsds_activation_failure_title" msgid="4467364110584914794">"Karta SIM nuk mund të aktivizohet"</string>
    <string name="dsds_activation_failure_body_msg1" msgid="6303921196869256391">"Hiq kartën SIM dhe fute përsëri. Nëse problemi vazhdon, rinise pajisjen."</string>
    <string name="dsds_activation_failure_body_msg2" msgid="73044349546544410">"Provo të aktivizosh kartën SIM përsëri. Nëse problemi vazhdon, rinise pajisjen."</string>
    <string name="sim_setup_channel_id" msgid="8797972565087458515">"Aktivizimi i rrjetit"</string>
    <string name="sim_switch_channel_id" msgid="4927038626791837861">"Ndërrimi i operatorit celular"</string>
    <string name="post_dsds_reboot_notification_title_with_carrier" msgid="3308827462185135307">"<xliff:g id="CARRIER_NAME">%1$s</xliff:g> është aktiv"</string>
    <string name="post_dsds_reboot_notification_text" msgid="7533428378211541410">"Trokit për të përditësuar cilësimet e kartës SIM"</string>
    <string name="switch_to_removable_notification" msgid="7640342063449806296">"Kaloi te <xliff:g id="CARRIER_NAME">%1$s</xliff:g>"</string>
    <string name="switch_to_removable_notification_no_carrier_name" msgid="7384856964036215338">"U kalua te një operator tjetër celular"</string>
    <string name="network_changed_notification_text" msgid="2407908598496951243">"Rrjeti yt celular ka ndryshuar"</string>
    <string name="dsds_notification_after_suw_title" msgid="3738898232310273982">"Konfiguro kartën tjetër SIM"</string>
    <string name="dsds_notification_after_suw_text" msgid="1287357774676361084">"Zgjidh kartën tënde aktive SIM ose përdor 2 karta SIM njëkohësisht"</string>
    <string name="choose_sim_title" msgid="4804689675237716286">"Zgjidh një numër për ta përdorur"</string>
    <string name="choose_sim_text" msgid="4356662002583501647">"{count,plural, =1{1 numër ofrohet në këtë pajisje, por vetëm një mund të përdoret në të njëjtën kohë}=2{2 numra ofrohen në këtë pajisje, por vetëm një mund të përdoret në të njëjtën kohë}other{# numra ofrohen në këtë pajisje, por vetëm një mund të përdoret në të njëjtën kohë}}"</string>
    <string name="choose_sim_activating" msgid="9035902671985449448">"Po aktivizohet<xliff:g id="ELLIPSIS">…</xliff:g>"</string>
    <string name="choose_sim_could_not_activate" msgid="2154564459842291617">"Nuk mund të aktivizohej në këtë moment"</string>
    <string name="choose_sim_item_summary_unknown" msgid="7854314795485227568">"Numër i panjohur"</string>
    <string name="switch_sim_dialog_title" msgid="5407316878973237773">"Të përdoret <xliff:g id="CARRIER_NAME">%1$s</xliff:g>?"</string>
    <string name="switch_sim_dialog_text" msgid="7530186862171635464">"<xliff:g id="CARRIER_NAME">%1$s</xliff:g> do të përdoret për të dhënat celulare, telefonatat dhe mesazhet SMS"</string>
    <string name="switch_sim_dialog_no_switch_title" msgid="809763410787744247">"Nuk ka karta SIM aktive"</string>
    <string name="switch_sim_dialog_no_switch_text" msgid="7053939850026876088">"Për të përdorur të dhënat celulare, veçoritë e telefonatave dhe mesazhet SMS më vonë, shko te cilësimet e tua të rrjetit"</string>
    <string name="sim_card_label" msgid="5632157635124050923">"Karta SIM"</string>
    <string name="erase_sim_dialog_title" msgid="881253002169177016">"Të spastrohet kjo kartë SIM e shkarkuar?"</string>
    <string name="erase_sim_dialog_text" msgid="753031064269699885">"Spastrimi i kësaj karte SIM e heq shërbimin e <xliff:g id="CARRIER_NAME_A">%1$s</xliff:g> nga kjo pajisje.\n\nShërbimi për <xliff:g id="CARRIER_NAME_B">%1$s</xliff:g> nuk do të anulohet."</string>
    <string name="erase_sim_confirm_button" msgid="8309115684335320541">"Spastro"</string>
    <string name="erasing_sim" msgid="7877703231075699139">"Karta SIM po spastrohet…"</string>
    <string name="erase_sim_fail_title" msgid="2024446702985862427">"Karta SIM nuk mund të spastrohet"</string>
    <string name="erase_sim_fail_text" msgid="7870804401227483131">"Kjo kartë SIM nuk mund të spastrohet për shkak të një gabimi.\n\nRinise pajisjen dhe provo përsëri."</string>
    <string name="network_connection_request_dialog_title" msgid="1896186380874289434">"Lidhu me pajisjen"</string>
    <string name="network_connection_request_dialog_summary" msgid="7693038309792726170">"Aplikacioni <xliff:g id="APPNAME">%1$s</xliff:g> dëshiron të përdorë një rrjet të përkohshëm Wi-Fi për t\'u lidhur me pajisjen tënde"</string>
    <string name="network_connection_timeout_dialog_message" msgid="598509083077743772">"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="6022675321823723755">"Provo sërish"</string>
    <string name="network_connection_errorstate_dialog_message" msgid="3360714322047603239">"Ndodhi diçka. Aplikacioni ka anuluar kërkesën për të zgjedhur një pajisje."</string>
    <string name="network_connection_connect_successful" msgid="2587314077675642476">"Lidhja ishte e suksesshme"</string>
    <string name="network_connection_connect_failure" msgid="6803313816657494319">"Lidhja dështoi"</string>
    <string name="network_connection_request_dialog_showall" msgid="6392059758456994944">"Shfaq të gjitha"</string>
    <string name="network_connection_searching_message" msgid="8521819623516926482">"Po kërkohet për pajisjen…"</string>
    <string name="network_connection_connecting_message" msgid="433189540877274889">"Po lidhet me pajisjen…"</string>
    <string name="bluetooth_left_name" msgid="7440064067910080502">"Majtas"</string>
    <string name="bluetooth_right_name" msgid="7588088072444124949">"Djathtas"</string>
    <string name="bluetooth_middle_name" msgid="3909371955137442319">"Kasa"</string>
    <string name="settings_panel_title" msgid="346363079938069215">"Paneli i \"Cilësimeve\""</string>
    <string name="internet_connectivity_panel_title" msgid="2044237561024730108">"Lidhshmëria e internetit"</string>
    <string name="volume_connectivity_panel_title" msgid="8772438444782726321">"Volumi"</string>
    <string name="mobile_data_ap_mode_disabled" msgid="6067959496888990983">"Nuk ofrohen në modalitetin e aeroplanit"</string>
    <string name="force_desktop_mode" msgid="1336913605091334238">"Detyro \"modalitetin e desktopit\""</string>
    <string name="force_desktop_mode_summary" msgid="4587416867846930479">"Detyro \"modalitetin e desktopit\" eksperimental në ekrane dytësore"</string>
    <string name="enable_non_resizable_multi_window" msgid="6832903754625404477">"Aktivizo aplikacionet me madhësi jo të ndryshueshme në modalitetin me shumë dritare"</string>
    <string name="enable_non_resizable_multi_window_summary" msgid="3275763753261901999">"Lejon që aplikacionet me madhësi jo të ndryshueshme të shfaqen në modalitetin me shumë dritare"</string>
    <string name="hwui_force_dark_title" msgid="4256904905631994219">"Anulo detyrimin e errësimit"</string>
    <string name="hwui_force_dark_summary" msgid="6515748781487952769">"Anulon funksionin e detyrimit të errësimit që të jetë gjithmonë aktiv"</string>
    <string name="privacy_dashboard_title" msgid="6845403825611829558">"Privatësia"</string>
    <string name="privacy_dashboard_summary" msgid="5775090172422786808">"Lejet, aktiviteti i llogarisë, të dhënat personale"</string>
    <string name="privacy_controls_title" msgid="1383047169455206604">"Kontrollet"</string>
    <string name="contextual_card_dismiss_remove" msgid="8636557343011606722">"Hiq"</string>
    <string name="contextual_card_dismiss_keep" msgid="440516181066490747">"Mbaj"</string>
    <string name="contextual_card_dismiss_confirm_message" msgid="6434344989238055188">"Të hiqet ky sugjerim?"</string>
    <string name="contextual_card_removed_message" msgid="5755438207494260867">"Sugjerimi u hoq"</string>
    <string name="contextual_card_undo_dismissal_text" msgid="5200381837316691406">"Zhbëj"</string>
    <string name="low_storage_summary" msgid="1979492757417779718">"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="7409408664417908922">"Dërgo komente"</string>
    <string name="contextual_card_feedback_confirm_message" msgid="3186334562157665381">"Dëshiron të na japësh komentet e tua për këtë sugjerim?"</string>
    <string name="copyable_slice_toast" msgid="1008251852798990606">"<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="880523277036898350"></string>
    <string name="permission_bar_chart_empty_text" msgid="4856719891991325077">"0 aplikacione përdorën autorizimet"</string>
    <string name="permission_bar_chart_title" msgid="2493212904955611441">"Përdorimi i autorizimeve në 24 orët e fundit"</string>
    <string name="permission_bar_chart_details" msgid="5816698018592357088">"Shikoji të gjitha te \"Paneli\""</string>
    <plurals name="permission_bar_chart_label" formatted="false" msgid="4853396794340896078">
      <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="9190967143518779145">"Përdorimi i qasshmërisë"</string>
    <plurals name="accessibility_usage_summary" formatted="false" msgid="6910643986958263005">
      <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="media_output_panel_title" msgid="5920946795078065159">"Ndrysho daljen"</string>
    <string name="media_output_panel_summary_of_playing_device" msgid="6998758947764222915">"Aktualisht po luhet në <xliff:g id="DEVICE_NAME">%1$s</xliff:g>"</string>
    <string name="media_output_disconnected_status" msgid="5567111639832431865">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g> (e shkëputur)"</string>
    <string name="media_output_switch_error_text" msgid="603563475910236831">"Nuk mund të ndërrohet. Trokit për të provuar përsëri."</string>
    <string name="wfc_disclaimer_title_text" msgid="4617195934203523503">"Informacione të rëndësishme"</string>
    <string name="wfc_disclaimer_agree_button_text" msgid="4082872292910770344">"VAZHDO"</string>
    <string name="wfc_disclaimer_disagree_text" msgid="8424457394700137703">"JO, FALEMINDERIT"</string>
    <string name="wfc_disclaimer_location_title_text" msgid="7913919887475418423">"Vendndodhja"</string>
    <string name="wfc_disclaimer_location_desc_text" msgid="1417004513415772582">"Operatori yt celular mund të mbledhë të dhëna për vendndodhjen tënde kur ti e përdor këtë shërbim për telefonatat e urgjencës.\n\nVizito politikën e privatësisë së operatorit celular për detaje."</string>
    <string name="forget_passpoint_dialog_message" msgid="2433875063907365760">"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="7802155522681936956">"regjistrimi i përmbajtjes, përmbajtja e aplikacionit"</string>
    <string name="content_capture" msgid="868372905432812238">"Përmbajtja e aplikacionit"</string>
    <string name="content_capture_summary" msgid="49720773699715531">"Lejo që aplikacionet të dërgojnë përmbajtje te sistemi Android"</string>
    <string name="capture_system_heap_dump_title" msgid="9210974110606886455">"Regjistro grumbullin e skedarëve fiktivë të sistemit"</string>
    <string name="reboot_with_mte_title" msgid="9167242803901899693">"Rindiz me MTE"</string>
    <string name="reboot_with_mte_message" msgid="7675836625682561153">"Sistemi do të rindizet dhe do të lejojë eksperimentimin me \"Shtesën e etiketimit të memories\" (MTE). MTE mund të ndikojë negativisht në performancën dhe qëndrueshmërinë e sistemit. Do të rivendoset gjatë rindezjes së radhës."</string>
    <string name="capturing_system_heap_dump_message" msgid="8410503247477360622">"Grumbulli i skedarëve fiktivë të sistemit po regjistrohet"</string>
    <string name="error_capturing_system_heap_dump_message" msgid="2352983250048200052">"Grumbulli i skedarëve fiktivë të sistemit nuk mund të regjistrohej"</string>
    <string name="automatic_system_heap_dump_title" msgid="4093306504711109479">"Regjistro automatikisht grumbujt e skedarëve fiktivë të sistemit"</string>
    <string name="automatic_system_heap_dump_summary" msgid="4060846186592886986">"Regjistro automatikisht një grumbull të skedarëve fiktivë për sistemin Android kur përdor shumë memorie"</string>
    <string name="wifi_disconnect_button_text" msgid="5698154296678571998">"Shkëput"</string>
    <string name="wfc_disclaimer_emergency_limitation_title_text" msgid="8276287227589397162">"Telefonata urgjence"</string>
    <string name="wfc_disclaimer_emergency_limitation_desc_text" msgid="5503902001191552196">"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="8566648389959032967">"Përdor Wi‑Fi për telefonatat për të përmirësuar cilësinë"</string>
    <string name="backup_calling_settings_title" msgid="519714752900364326">"Opsioni rezervë i telefonatave"</string>
    <string name="backup_calling_setting_summary" msgid="599493254305348733">"Nëse <xliff:g id="BACKUP_CALLING_OPERATOR_TEXT">%1$s</xliff:g> nuk ofrohet ose është në roaming, përdor kartën SIM të të dhënave celulare për telefonata me <xliff:g id="BACKUP_CALLING_CARRIER_TEXT">%1$s</xliff:g>."</string>
    <string name="keywords_backup_calling" msgid="8592800915478816800">"opsioni rezervë i telefonatave"</string>
    <string name="enable_receiving_mms_notification_title" msgid="6465218559386990248">"Mesazh MMS në ardhje"</string>
    <string name="enable_sending_mms_notification_title" msgid="7120641300854953375">"Mesazhi MMS nuk mund të dërgohet"</string>
    <string name="enable_mms_notification_summary" msgid="6432752438276672500">"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="1798206332620642108">"Mesazh MMS"</string>
    <string name="sim_combination_warning_notification_title" msgid="1365401631492986487">"Lësho me kombinimin e kartës SIM"</string>
    <string name="dual_cdma_sim_warning_notification_summary" msgid="2826474790710586487">"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="1049161096896074364">"Kombinimi i kartës SIM"</string>
    <string name="work_policy_privacy_settings" msgid="2702644843505242596">"Informacioni i politikës sate të punës"</string>
    <string name="work_policy_privacy_settings_summary" msgid="690118670737638405">"Cilësimet menaxhohen nga administratori yt i TI-së"</string>
    <string name="track_frame_time_keywords" msgid="7885340257945922239">"GPU"</string>
    <string name="bug_report_handler_title" msgid="713439959113250125">"Administruesi i raportit të defekteve në kod"</string>
    <string name="bug_report_handler_picker_footer_text" msgid="4935758328366585673">"Përcakton se cili aplikacion administron shkurtoren e \"Raportit të defekteve në kod\" në pajisjen tënde."</string>
    <string name="personal_profile_app_subtext" msgid="5586060806997067676">"Personal"</string>
    <string name="work_profile_app_subtext" msgid="5043419461440127879">"Puna"</string>
    <string name="system_default_app_subtext" msgid="5212055189703164839">"Parazgjedhja e sistemit"</string>
    <string name="select_invalid_bug_report_handler_toast_text" msgid="8857326334015386692">"Kjo zgjedhje nuk është më e vlefshme. Provo përsëri."</string>
    <string name="quick_controls_lower" msgid="6675573610027367819">"kontrollet e pajisjes"</string>
    <string name="cards_passes_sentence" msgid="1866311782387946944">"Kartat dhe lejet e kalimit"</string>
    <string name="cards_passes_lower" msgid="2429722007109957877">"kartat dhe lejet e kalimit"</string>
    <string name="power_menu_setting_name" msgid="7291642927216934159">"Shtyp dhe mbaj shtypur butonin e energjisë"</string>
    <string name="power_menu_summary_long_press_for_assist_enabled" msgid="5322150755041458952">"Shtyp dhe mbaj shtypur për \"Asistetin\""</string>
    <string name="power_menu_summary_long_press_for_assist_disabled_with_power_menu" msgid="5165714995895517816">"Shtyp dhe mbaj shtypur për menynë e energjisë"</string>
    <string name="power_menu_summary_long_press_for_assist_disabled_no_action" msgid="2831598484771657432">"Shtypja dhe mbajta shtypur është e çaktivizuar"</string>
    <string name="lockscreen_privacy_not_secure" msgid="3251276389681975912">"Për ta përdorur, në fillim cakto një kyçje ekrani"</string>
    <string name="power_menu_long_press_for_assist" msgid="2016813721240777737">"Mbaje shtypur për \"Asistentin\""</string>
    <string name="power_menu_long_press_for_assist_summary" msgid="8251928804984560312">"Aktivizo \"Asistentin\" duke mbajtur shtypur butonin e energjisë"</string>
    <string name="power_menu_power_volume_up_hint" msgid="1733051433583045623">"Menyja \"Energjia dhe urgjenca\":\nShtyp njëherësh \"Energjinë\" dhe \"Volumin lart\"."</string>
    <string name="power_menu_power_prevent_ringing_hint" msgid="5786494894009727654">"Parandalo rënien e ziles:\nKa shkurtore në menynë e volumit."</string>
    <string name="power_menu_long_press_for_assist_sensitivity_title" msgid="1626808509158422185">"Kohëzgjatja e mbajtjes shtypur"</string>
    <string name="power_menu_long_press_for_assist_sensitivity_summary" msgid="7550610071666801935">"Rregullo ndjeshmërinë duke zgjedhur kohëzgjatjen e mbajtjes shtypur të butonit të energjisë"</string>
    <string name="power_menu_long_press_for_assist_sensitivity_low_label" msgid="3430099983480845635">"E shkurtër"</string>
    <string name="power_menu_long_press_for_assist_sensitivity_high_label" msgid="2059686170350829156">"E gjatë"</string>
    <string name="lockscreen_privacy_wallet_setting_toggle" msgid="4188327143734192000">"Shfaq portofolin"</string>
    <string name="lockscreen_privacy_wallet_summary" msgid="3984851951621168573">"Lejo qasje te portofoli nga ekrani i kyçjes"</string>
    <string name="lockscreen_privacy_qr_code_scanner_setting_toggle" msgid="4284186474146767523">"Shfaq skanerin e kodeve QR"</string>
    <string name="lockscreen_privacy_qr_code_scanner_summary" msgid="6152471629901191089">"Lejo qasje te \"Skaneri i kodeve QR\" nga ekrani i kyçjes"</string>
    <string name="lockscreen_privacy_controls_setting_toggle" msgid="7445725343949588613">"Shfaq kontrollet e pajisjes"</string>
    <string name="lockscreen_privacy_controls_summary" msgid="2769166101644452893">"Shfaq kontrollet për pajisjet e jashtme nga ekrani i kyçjes"</string>
    <string name="lockscreen_trivial_controls_setting_toggle" msgid="8211063535536295676">"Kontrolli nga pajisja e kyçur"</string>
    <string name="lockscreen_trivial_controls_summary" msgid="680581904143387225">"Kontrollo pajisje të jashtme pa shkyçur telefonin ose tabletin, nëse lejohet nga aplikacioni i kontrolleve të pajisjes"</string>
    <string name="lockscreen_trivial_disabled_controls_summary" msgid="7593626010580689155">"Për ta përdorur, fillimisht aktivizo \"Shfaq kontrollet e pajisjes\""</string>
    <string name="lockscreen_double_line_clock_summary" msgid="2916159550425093703">"Shfaq orën analoge kur ofrohet"</string>
    <string name="lockscreen_double_line_clock_setting_toggle" msgid="3408639316001688529">"Orë analoge"</string>
    <string name="rtt_settings_title" msgid="7049259598645966354"></string>
    <string name="rtt_settings_no_visible" msgid="7440356831140948382"></string>
    <string name="rtt_settings_visible_during_call" msgid="7866181103286073700"></string>
    <string name="rtt_settings_always_visible" msgid="2364173070088756238"></string>
    <string name="media_output_panel_stop_casting_button" msgid="6094875883164119035">"Ndalo transmetimin"</string>
    <string name="volte_5G_limited_title" msgid="5908052268836750629">"Të çaktivizohet VoLTE?"</string>
    <string name="volte_5G_limited_text" msgid="7150583768725182345">"Kjo çaktivizon gjithashtu lidhjen tënde 5G.\nGjatë një telefonate zanore, nuk mund ta përdorësh internetin dhe disa aplikacione mund të mos funksionojnë."</string>
    <string name="no_5g_in_dsds_text" product="default" msgid="772747677303920132">"Kur përdor 2 karta SIM, ky telefon do të kufizohet në 4G. "<annotation id="url">"Mëso më shumë"</annotation></string>
    <string name="no_5g_in_dsds_text" product="tablet" msgid="4757328474425714624">"Kur përdor 2 karta SIM, ky tablet do të kufizohet në 4G. "<annotation id="url">"Mëso më shumë"</annotation></string>
    <string name="no_5g_in_dsds_text" product="device" msgid="6983783505032683314">"Kur përdor 2 karta SIM, kjo pajisje do të kufizohet në 4G. "<annotation id="url">"Mëso më shumë"</annotation></string>
    <string name="cached_apps_freezer" msgid="1057519579761550350">"Pezullo ekzekutimin për aplikacionet në memorien specifike"</string>
    <string name="blob_never_expires_text" msgid="7293376386620106623">"Nuk skadon kurrë."</string>
    <string name="accessor_never_expires_text" msgid="4647624492147788340">"Qiraja nuk skadon kurrë."</string>
    <string name="overlay_settings_title" msgid="1032863083496396365">"Lejo mbivendosjet e ekranit te \"Cilësimet\""</string>
    <string name="overlay_settings_summary" msgid="2745336273786148166">"Lejo aplikacionet të cilat mund të shfaqen mbi aplikacione të tjera të mbivendosen mbi ekranet e \"Cilësimeve\""</string>
    <string name="allow_mock_modem" msgid="3832264806530479214">"Lejo modemin imitues"</string>
    <string name="allow_mock_modem_summary" msgid="9097416612748005374">"Lejo këtë pajisje të ekzekutojë shërbimin e modemit imitues për testimin e instrumenteve. Mos e lejo këtë gjatë përdorimit normal të telefonit"</string>
    <string name="media_controls_title" msgid="403271085636252597">"Media"</string>
    <string name="media_controls_resume_title" msgid="855076860336652370">"Gozhdo luajtësin e medias"</string>
    <string name="media_controls_resume_description" msgid="3163482266454802097">"Për të rifilluar shpejt luajtjen, luajtësi i medias qëndron i hapur te \"Cilësimet e shpejta\""</string>
    <string name="media_controls_recommendations_title" msgid="184225835236807677">"Shfaq rekomandimet për mediat"</string>
    <string name="media_controls_recommendations_description" msgid="7596498733126824030">"Bazuar në aktivitetin tënd"</string>
    <string name="media_controls_hide_player" msgid="2751439192580884015">"Fshih luajtësin"</string>
    <string name="media_controls_show_player" msgid="8504571042365814021">"Shfaq luajtësin"</string>
    <string name="keywords_media_controls" msgid="8345490568291778638">"media"</string>
    <string name="connected_device_see_all_summary" msgid="2056010318537268108">"Bluetooth-i do të aktivizohet"</string>
    <string name="bluetooth_setting_on" msgid="4808458394436224124">"Aktiv"</string>
    <string name="bluetooth_setting_off" msgid="4965493913199554789">"Joaktiv"</string>
    <string name="provider_internet_settings" msgid="3831259474776313323">"Interneti"</string>
    <string name="provider_network_settings_title" msgid="2624756136016346774">"Kartat SIM"</string>
    <string name="keywords_airplane_safe_networks" msgid="5902708537892978245">"aeroplan, të sigurta për në aeroplan"</string>
    <string name="calls_and_sms" msgid="1931855083959003306">"Telefonatat dhe SMS"</string>
    <string name="calls_and_sms_category" msgid="3788238090898237767">"Telefonatë me Wi-Fi"</string>
    <string name="calls_sms_wfc_summary" msgid="3940529919408667336">"Kryej dhe merr telefonata përmes Wi‑Fi"</string>
    <string name="calls_sms_footnote" msgid="1003530944232362815">"Me telefonatat me Wi‑Fi, telefonatat kryhen dhe merren përmes rrjeteve Wi-Fi jo të operatorëve celularë. "<annotation id="url">"Mëso më shumë"</annotation></string>
    <string name="calls_preference_title" msgid="7536882032182563800">"Telefonatat"</string>
    <string name="sms_preference_title" msgid="8392745501754864395">"SMS"</string>
    <string name="calls_sms_preferred" msgid="6016477652522583496">"preferohet"</string>
    <string name="calls_sms_calls_preferred" msgid="9004261125829377885">"e preferuar për telefonatat"</string>
    <string name="calls_sms_sms_preferred" msgid="3855778890660922711">"e preferuar për mesazhet SMS"</string>
    <string name="calls_sms_unavailable" msgid="4055729705246556529">"e padisponueshme"</string>
    <string name="calls_sms_temp_unavailable" msgid="8602291749338757424">"Nuk ofrohet për momentin"</string>
    <string name="calls_sms_no_sim" msgid="2336377399761819718">"Nuk ka kartë SIM"</string>
    <string name="network_and_internet_preferences_title" msgid="8635896466814033405">"Preferencat e rrjetit"</string>
    <string name="keywords_internet" msgid="7674082764898690310">"lidhja e rrjetit, internet, pa tel, të dhëna, wifi, wi-fi, wi fi, rrjeti celular, celular, operatori celular, 4g, 3g, 2g, lte"</string>
    <string name="turn_on_wifi" msgid="4868116014727533668">"Aktivizo Wi-Fi"</string>
    <string name="turn_off_wifi" msgid="8861028501067400694">"Çaktivizo Wi-Fi"</string>
    <string name="reset_your_internet_title" msgid="4856899004343241310">"Të rivendoset interneti?"</string>
    <string name="reset_internet_text" product="default" msgid="8797910368942544453">"Kjo do ta mbyllë telefonatën"</string>
    <string name="reset_internet_text" product="tablet" msgid="8797910368942544453">"Kjo do ta mbyllë telefonatën"</string>
    <string name="resetting_internet_text" msgid="6696779371800051806">"Interneti po rivendoset…"</string>
    <string name="fix_connectivity" msgid="2781433603228089501">"Rregullo problemin me lidhshmërinë"</string>
    <string name="networks_available" msgid="3299512933684383474">"Ofrohen rrjete"</string>
    <string name="to_switch_networks_disconnect_ethernet" msgid="6615374552827587197">"Për të ndërruar rrjetet, shkëput eternetin"</string>
    <string name="wifi_is_off" msgid="8308136482502734453">"Wi-Fi është joaktiv"</string>
    <string name="tap_a_network_to_connect" msgid="8044777400224037875">"Trokit te një rrjet për t\'u lidhur"</string>
    <string name="carrier_wifi_offload_title" msgid="7263365988016247722">"Lidhjet W+"</string>
    <string name="carrier_wifi_offload_summary" msgid="2980563718888371142">"Lejoji Google Fi të përdorë rrjetet W+ për të përmirësuar shpejtësinë dhe mbulimin"</string>
    <string name="carrier_wifi_network_title" msgid="5461382943873831770">"Rrjeti W+"</string>
    <string name="sim_category_title" msgid="2341314000964710495">"SIM"</string>
    <string name="downloaded_sim_category_title" msgid="8611467223348446658">"KARTA SIM E SHKARKUAR"</string>
    <string name="downloaded_sims_category_title" msgid="8779223441781763315">"KARTAT SIM TË SHKARKUARA"</string>
    <string name="sim_category_active_sim" msgid="1503823567818544012">"Aktive"</string>
    <string name="sim_category_inactive_sim" msgid="4068899490133820881">"Joaktive"</string>
    <string name="sim_category_default_active_sim" msgid="1208194173387987231">" / Parazgjedhja për <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="default_active_sim_calls" msgid="2390973682556353558">"telefonatat"</string>
    <string name="default_active_sim_sms" msgid="8041498593025994921">"SMS"</string>
    <string name="default_active_sim_mobile_data" msgid="6798083892814045301">"të dhënat celulare"</string>
    <string name="wifi_scan_notify_message" msgid="1331238142061476869">"Për të përmirësuar përvojën e pajisjes, aplikacionet dhe shërbimet mund të vazhdojnë 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 veçoritë dhe shërbimet e bazuara te vendndodhja. Mund ta ndryshosh këtë te cilësimet e skanimit të Wi-Fi."</string>
    <string name="wifi_scan_change" msgid="8438320311511852918">"Ndrysho"</string>
    <string name="preference_summary_default_combination" msgid="4643585915107796253">"<xliff:g id="STATE">%1$s</xliff:g> / <xliff:g id="NETWORKMODE">%2$s</xliff:g>"</string>
    <string name="mobile_data_connection_active" msgid="2422223108911581552">"Lidhur"</string>
    <string name="mobile_data_no_connection" msgid="905897142426974030">"Nuk ka lidhje"</string>
    <string name="mobile_data_off_summary" msgid="1884248776904165539">"Të dhënat celulare nuk do të lidhen automatikisht"</string>
    <string name="non_carrier_network_unavailable" msgid="9031567407964127997">"Nuk ofrohet asnjë rrjet tjetër"</string>
    <string name="all_network_unavailable" msgid="1163897808282057496">"Nuk ofrohet asnjë rrjet"</string>
    <string name="mobile_data_disable_title" msgid="8438714772256088913">"Të çaktivizohen të dhënat celulare?"</string>
    <string name="mobile_data_disable_message" msgid="7829414836454769970">"Nuk do të kesh qasje te të dhënat ose interneti nëpërmjet <xliff:g id="CARRIER">%s</xliff:g>. Interneti do të ofrohet vetëm nëpërmjet Wi-Fi."</string>
    <string name="mobile_data_disable_message_default_carrier" msgid="4449469407705838612">"operatori yt celular"</string>
    <string name="not_allowed_by_ent" msgid="1958611623122304411">"Nuk lejohet nga organizata jote"</string>
    <string name="aware_summary_when_bedtime_on" msgid="2063856008597376344">"Nuk ofrohet sepse modaliteti i orarit të gjumit është aktiv"</string>
    <string name="reset_importance_completed" msgid="3595536767426097205">"Rivendosja e rëndësisë së njoftimit përfundoi."</string>
    <string name="apps_dashboard_title" msgid="3269953499954393706">"Aplikacionet"</string>
    <string name="bluetooth_message_access_notification_content" msgid="5111712860712823893">"Një pajisje kërkon të ketë qasje te mesazhet e tua. Trokit për detaje."</string>
    <string name="bluetooth_message_access_dialog_title" msgid="9009836130395061579">"Të lejohet qasja te mesazhet?"</string>
    <string name="bluetooth_message_access_dialog_content" msgid="7186694737578788487">"Një pajisje me Bluetooth, <xliff:g id="DEVICE_NAME_0">%1$s</xliff:g>, kërkon të ketë qasje te mesazhet e tua.\n\nNuk je lidhur me <xliff:g id="DEVICE_NAME_1">%2$s</xliff:g> më parë."</string>
    <string name="bluetooth_phonebook_access_notification_content" msgid="9175220052703433637">"Një pajisje kërkon të ketë qasje te kontaktet dhe evidenca e telefonatave. Trokit për detaje."</string>
    <string name="bluetooth_phonebook_access_dialog_title" msgid="7624607995928968721">"Të lejohet qasja te kontaktet dhe evidenca e telefonatave?"</string>
    <string name="bluetooth_phonebook_access_dialog_content" msgid="959658135522249170">"Një pajisje me Bluetooth, <xliff:g id="DEVICE_NAME_0">%1$s</xliff:g>, kërkon të ketë qasje te kontaktet dhe evidenca e telefonatave. Kjo përfshin të dhënat në lidhje me telefonatat hyrëse dhe dalëse.\n\nNuk je lidhur me <xliff:g id="DEVICE_NAME_1">%2$s</xliff:g> më parë."</string>
    <string name="category_name_brightness" msgid="8520372392029305084">"Ndriçimi"</string>
    <string name="category_name_lock_display" msgid="8310402558217129670">"Ekrani i kyçjes"</string>
    <string name="category_name_appearance" msgid="8287486771764166805">"Paraqitja"</string>
    <string name="category_name_color" msgid="937514550918977151">"Ngjyra"</string>
    <string name="category_name_display_controls" msgid="7046581691184725216">"Kontrolle të tjera të ekranit"</string>
    <string name="category_name_others" msgid="2366006298768550310">"Të tjera"</string>
    <string name="category_name_general" msgid="7737273712848115886">"Të përgjithshme"</string>
    <string name="dark_theme_main_switch_title" msgid="4045147031947562280">"Përdor \"Temën e errët\""</string>
    <string name="bluetooth_main_switch_title" msgid="8409835540311309632">"Përdor Bluetooth-in"</string>
    <string name="prevent_ringing_main_switch_title" msgid="4726252811262086643">"Përdor parandalimin e ziles"</string>
    <string name="use_wifi_hotsopt_main_switch_title" msgid="3909731167290690539">"Përdor zonën e qasjes për Wi‑Fi"</string>
    <string name="app_pinning_main_switch_title" msgid="5465506660064032876">"Përdor gozhdimin e aplikacionit"</string>
    <string name="developer_options_main_switch_title" msgid="1720074589554152501">"Përdor opsionet e zhvilluesit"</string>
    <string name="default_print_service_main_switch_title" msgid="4697133737128324036">"Përdor shërbimin e printimit"</string>
    <string name="multiple_users_main_switch_title" msgid="6686858308083037810">"Lejo disa përdorues"</string>
    <string name="wireless_debugging_main_switch_title" msgid="8463499572781441719">"Përdor korrigjimin përmes Wi-Fi"</string>
    <string name="graphics_driver_main_switch_title" msgid="6125172901855813790">"Përdor preferencat e drejtuesit të grafikëve"</string>
    <string name="battery_saver_main_switch_title" msgid="5072135547489779352">"Përdor kursyesin e baterisë"</string>
    <string name="do_not_disturb_main_switch_title_on" msgid="6965566556539821313">"Çaktivizo tani"</string>
    <string name="do_not_disturb_main_switch_title_off" msgid="7088088515823752545">"Aktivizo tani"</string>
    <string name="night_light_main_switch_title" msgid="3428298022467805219">"Përdor \"Dritën e natës\""</string>
    <string name="nfc_main_switch_title" msgid="6295839988954817432">"Përdor NFC"</string>
    <string name="adaptive_battery_main_switch_title" msgid="3127477920505485813">"Përdor baterinë me përshtatje"</string>
    <string name="adaptive_brightness_main_switch_title" msgid="2681666805191642737">"Përdor ndriçimin e përshtatshëm"</string>
    <string name="wifi_calling_main_switch_title" msgid="4070224008346815634">"Përdor telefonatën me Wi‑Fi"</string>
    <string name="default_see_all_apps_title" msgid="7481113230662612178">"Shiko të gjitha aplikacionet"</string>
    <string name="smart_forwarding_title" msgid="8368634861971949799">"Transferimi inteligjent"</string>
    <string name="smart_forwarding_summary_enabled" msgid="3341062878373185604">"Transferimi inteligjent është aktivizuar"</string>
    <string name="smart_forwarding_summary_disabled" msgid="5033880700091914809">"Transferimi inteligjent është çaktivizuar"</string>
    <string name="smart_forwarding_ongoing_title" msgid="962226849074401228">"Cilësimet e telefonatave"</string>
    <string name="smart_forwarding_ongoing_text" msgid="2189209372407117114">"Po përditësohen cilësimet…"</string>
    <string name="smart_forwarding_failed_title" msgid="1859891191023516080">"Gabim në cilësimet e telefonatave"</string>
    <string name="smart_forwarding_failed_text" msgid="5370431503707373653">"Gabim në rrjet ose në kartën SIM."</string>
    <string name="smart_forwarding_failed_not_activated_text" msgid="997396203001257904">"Karta SIM nuk është aktivizuar."</string>
    <string name="smart_forwarding_input_mdn_title" msgid="5105463748849841763">"Fut numrat e telefonit"</string>
    <string name="smart_forwarding_input_mdn_dialog_title" msgid="7542216086697868415">"Fut numrin e telefonit"</string>
    <string name="smart_forwarding_missing_mdn_text" msgid="2907314684242542226">"Numri i telefonit mungon."</string>
    <string name="smart_forwarding_missing_alert_dialog_text" msgid="7870419247987316112">"Në rregull"</string>
    <string name="enable_2g_title" msgid="8184757884636162942">"Lejo 2G"</string>
    <string name="enable_2g_summary" msgid="2794534052372565914">"2G është më pak i sigurt, por mund të përmirësojë lidhjen tënde në disa vendndodhje. Për telefonatat e urgjencës, 2G lejohet gjithmonë."</string>
    <string name="enable_2g_summary_disabled_carrier" msgid="8141118453219482762">"<xliff:g id="CARRIER_NAME_2G">%1$s</xliff:g> ofrohet vetëm me 2G"</string>
    <string name="app_info_all_services_label" msgid="3600929226735860271">"Të gjitha shërbimet"</string>
    <string name="show_clip_access_notification" msgid="7782300987639778542">"Shfaq qasjen te kujtesa e fragmenteve"</string>
    <string name="show_clip_access_notification_summary" msgid="474090757777203207">"Shfaq një mesazh kur aplikacionet qasen te tekstet, imazhet ose përmbajtje të tjera që ke kopjuar"</string>
    <string name="all_apps" msgid="3054120149509114789">"Të gjitha aplikacionet"</string>
    <string name="request_manage_bluetooth_permission_dont_allow" msgid="8798061333407581300">"Mos lejo"</string>
    <string name="uwb_settings_title" msgid="8578498712312002231">"Brezi ultra i gjerë (UWB)"</string>
    <string name="uwb_settings_summary" msgid="3074271396764672268">"Ndihmon për të identifikuar pozicionin e përafërt të pajisjeve në afërsi që kanë UWB"</string>
    <string name="uwb_settings_summary_airplane_mode" msgid="1328864888135086484">"Çaktivizo \"Modalitetin e aeroplanit\" për të përdorur UWB."</string>
    <string name="camera_toggle_title" msgid="8952668677727244992">"Qasja te kamera"</string>
    <string name="mic_toggle_title" msgid="265145278323852547">"Qasja te mikrofoni"</string>
    <string name="location_toggle_title" msgid="5229867700421750868">"Qasja te vendndodhja"</string>
    <string name="perm_toggle_description" msgid="5754629581767319022">"Për aplikacionet dhe shërbimet"</string>
    <string name="mic_toggle_description" msgid="484139688645092237">"Për aplikacionet dhe shërbimet. Nëse ky cilësim është joaktiv, të dhënat e mikrofonit mund të vazhdojnë të ndahen kur telefonon një numër urgjence."</string>
    <string name="previous_page_content_description" msgid="6438292457923282991">"Prapa"</string>
    <string name="next_page_content_description" msgid="1641835099813416294">"Para"</string>
    <string name="colors_viewpager_content_description" msgid="2591751086138259565">"Pamja paraprake e ngjyrave"</string>
    <string name="bluetooth_sim_card_access_notification_title" msgid="5217037846900908318">"Kërkesë për qasje te karta SIM"</string>
    <string name="bluetooth_sim_card_access_notification_content" msgid="6759306429895300286">"Një pajisje dëshiron të ketë qasje te karta jote SIM. Trokit për detaje."</string>
    <string name="bluetooth_sim_card_access_dialog_title" msgid="4486768729352090174">"Të lejohet qasja te karta SIM?"</string>
    <string name="bluetooth_sim_card_access_dialog_content" msgid="4153857191661567190">"Një pajisje me Bluetooth, <xliff:g id="DEVICE_NAME_0">%1$s</xliff:g>, dëshiron të ketë qasje te të dhënat në kartën tënde SIM. Kjo përfshin kontaktet e tua.\n\nKur të jetë e lidhur, <xliff:g id="DEVICE_NAME_1">%2$s</xliff:g> do të marrë të gjitha telefonatat e kryera në numrin <xliff:g id="PHONE_NUMBER">%3$s</xliff:g>."</string>
    <string name="bluetooth_connect_access_notification_title" msgid="2573547043170883947">"Një pajisje me Bluetooth e disponueshme"</string>
    <string name="bluetooth_connect_access_notification_content" msgid="1328465545685433304">"Një pajisje dëshiron të lidhet. Trokit për detaje."</string>
    <string name="bluetooth_connect_access_dialog_title" msgid="1948056782712451381">"Të lidhet me pajisjen me Bluetooth?"</string>
    <string name="bluetooth_connect_access_dialog_content" msgid="4336436466468405850">"<xliff:g id="DEVICE_NAME_0">%1$s</xliff:g> dëshiron të lidhet me këtë telefon.\n\nNuk je lidhur me <xliff:g id="DEVICE_NAME_1">%2$s</xliff:g> më parë."</string>
    <string name="bluetooth_connect_access_dialog_negative" msgid="4944672755226375059">"Mos lidh"</string>
    <string name="bluetooth_connect_access_dialog_positive" msgid="3630561675207269710">"Lidh"</string>
    <string name="tare_settings" msgid="3788654800004869077">"Cilësimet e TARE"</string>
    <string name="tare_on" msgid="2386073225978684535">"Aktive"</string>
    <string name="tare_off" msgid="6305694402929756726">"Joaktive"</string>
    <string name="tare_revert" msgid="3855325741125236638">"Riktheji te cilësimet e parazgjedhura"</string>
    <string name="tare_settings_reverted_toast" msgid="8189887409285176731">"Cilësimet u rikthyen te parazgjedhja."</string>
    <string name="tare_max_satiated_balance" msgid="3914973999573150340">"Balancë maksimale e ngopur"</string>
    <string name="tare_balances" msgid="731881382594747961">"Balancat"</string>
    <string name="tare_consumption_limits" msgid="3230949387874396382">"Kufijtë e konsumit"</string>
    <string name="tare_initial_consumption_limit" msgid="2921646306374048384">"Kufiri fillestar i konsumit"</string>
    <string name="tare_hard_consumption_limit" msgid="7977885116447608016">"Kufiri maksimal i konsumit"</string>
    <string name="tare_modifiers" msgid="8919975635360280820">"Modifikues"</string>
    <string name="tare_actions_ctp" msgid="5110104015354916401">"Veprimet (kostoja e prodhimit)"</string>
    <string name="tare_actions_base_price" msgid="3300967942666376589">"Veprimet (çmimi bazë)"</string>
    <string name="tare_rewards_instantaneous" msgid="8358683519945340874">"Shpërblimet për çdo ngjarje"</string>
    <string name="tare_rewards_ongoing" msgid="7657030286658143416">"Shpërblimet e kohëzgjatjes së ngjarjes"</string>
    <string name="tare_rewards_max" msgid="5283055625642837010">"Numri maksimal i shpërblimeve në ditë"</string>
    <string name="tare_top_activity" msgid="7266560655483385757">"Aktivitet kryesor"</string>
    <string name="tare_notification_seen" msgid="7829963536020087742">"Njoftim i parë"</string>
    <string name="tare_notification_seen_15_min" msgid="832174185809497764">"Njoftim i parë brenda 15 minutave"</string>
    <string name="tare_notification_interaction" msgid="3806204222322830129">"Ndërveprim njoftimi"</string>
    <string name="tare_widget_interaction" msgid="2260701564089214184">"Ndërveprim miniaplikacioni"</string>
    <string name="tare_other_interaction" msgid="8069163421115212751">"Ndërveprim përdoruesi tjetër"</string>
    <string name="tare_job_max_start" msgid="1586399578665940836">"Detyrë maksimale në nisje"</string>
    <string name="tare_job_max_running" msgid="2897217372986518495">"Detyrë maksimale në ekzekutim"</string>
    <string name="tare_job_high_start" msgid="7464143754932031022">"Detyrë e lartë në nisje"</string>
    <string name="tare_job_high_running" msgid="6541171046405088669">"Detyrë e lartë në ekzekutim"</string>
    <string name="tare_job_default_start" msgid="6744427210148953151">"Detyrë e parazgjedhur në nisje"</string>
    <string name="tare_job_default_running" msgid="8429081804128945217">"Detyrë e parazgjedhur në ekzekutim"</string>
    <string name="tare_job_low_start" msgid="4605440035856891746">"Detyrë e ulët në nisje"</string>
    <string name="tare_job_low_running" msgid="831668616902849604">"Detyrë e ulët në ekzekutim"</string>
    <string name="tare_job_min_start" msgid="6508233901992538188">"Detyrë minimale në nisje"</string>
    <string name="tare_job_min_running" msgid="6167128996320622604">"Detyrë minimale në ekzekutim"</string>
    <string name="tare_job_timeout_penalty" msgid="7644332836795492506">"Penalizim skadimi detyre"</string>
    <string name="tare_min_balance_exempted" msgid="6693710075762973485">"Balanca minimale në karikim të plotë (e përjashtuar)"</string>
    <string name="tare_min_balance_headless_app" msgid="6906353766678577244">"Balanca minimale në karikim të plotë (aplikacion sistemi pa kokë)"</string>
    <string name="tare_min_balance_other_app" msgid="3404774196832506476">"Balanca minimale në karikim të plotë (aplikacionet e mbetura)"</string>
  <string-array name="tare_modifiers_subfactors">
    <item msgid="3325940509857535498">"Po karikohet"</item>
    <item msgid="658627268149681677">"Një sy gjumë"</item>
    <item msgid="1599558140284643834">"Modaliteti i kursimit të energjisë"</item>
    <item msgid="588427840913221601">"Gjendja e procesit"</item>
  </string-array>
    <string name="tare_dialog_confirm_button_title" msgid="9179397559760203348">"Konfirmo"</string>
    <string name="dream_preview_button_title" msgid="6637456541851795952">"Pamja paraprake"</string>
    <string name="dream_picker_category" msgid="7726447836872744867">"Zgjidh një mbrojtës ekrani"</string>
    <string name="dream_complications_toggle_title" msgid="4273232303027449163">"Shfaq informacione shtesë"</string>
    <string name="dream_complications_toggle_summary" msgid="4742579722349951711">"Ora në ekran, data, moti, cilësia e ajrit dhe detajet e Google Cast në mbrojtësin e ekranit"</string>
    <string name="dream_more_settings_category" msgid="3119192146760773748">"Cilësime të tjera"</string>
    <string name="dream_setup_title" msgid="2458303874255396142">"Zgjidh mbrojtësin e ekranit"</string>
    <string name="dream_setup_description" msgid="7508547154038580296">"Zgjidh se çfarë do të shohësh në ekranin tënd kur tableti të jetë lidhur me stacionin. Pajisja jote mund të përdorë më shumë energji kur përdoret një mbrojtës ekrani."</string>
    <string name="customize_button_title" msgid="1110284655990203359">"Personalizo"</string>
    <string name="reboot_dialog_enable_freeform_support" msgid="6412591361284929149">"Kërkohet të rindizet për të aktivizuar mbështetjen në formë të lirë."</string>
    <string name="reboot_dialog_force_desktop_mode" msgid="2021839270403432948">"Kërkohet të rindizet për të detyruar modalitetin e desktopit në ekranet dytësore."</string>
    <string name="reboot_dialog_reboot_now" msgid="235616015988522355">"Rindize tani"</string>
    <string name="reboot_dialog_reboot_later" msgid="4261717094186904568">"Rindize më vonë"</string>
    <string name="bluetooth_details_spatial_audio_title" msgid="1368071116994002707">"Audio hapësinore"</string>
    <string name="bluetooth_details_spatial_audio_summary" msgid="5026859623681482668">"Audioja nga media e përputhshme bëhet më përfshirëse"</string>
    <string name="bluetooth_details_head_tracking_title" msgid="5416972521040337799">"Monitorimi i lëvizjes së kokës"</string>
    <string name="bluetooth_details_head_tracking_summary" msgid="3942238746595985395">"Audioja ndryshon ndërsa ti lëviz kokën për të tingëlluar më e natyrshme"</string>
    <string name="ingress_rate_limit_title" msgid="2106694002836274350">"Kufiri i shpejtësisë së shkarkimit në rrjet"</string>
    <string name="ingress_rate_limit_summary" msgid="1097811019742438371">"Konfiguro kufirin e shpejtësisë së daljes së bandës së gjerë të rrjetit që zbatohet për të gjitha rrjetet që ofrojnë lidhje me internetin."</string>
    <string name="ingress_rate_limit_dialog_title" msgid="5359461052422633789">"Konfiguro kufirin e shpejtësisë së shkarkimit në rrjet"</string>
    <string name="ingress_rate_limit_no_limit_entry" msgid="8741098826008012163">"Pa kufi"</string>
    <string name="bluetooth_broadcast_dialog_title" msgid="9172775308463135884">"Transmetimi"</string>
    <string name="bluetooth_broadcast_dialog_broadcast_app" msgid="1016617579194329005">"Transmeto <xliff:g id="CURRENTAPP">%1$s</xliff:g>"</string>
    <string name="bluetooth_broadcast_dialog_find_message" msgid="6621660851669953883">"Dëgjo transmetime që po luhen në afërsi"</string>
    <string name="bluetooth_broadcast_dialog_broadcast_message" msgid="6198264676009094495">"Transmeto media në pajisjet në afërsi ose dëgjo transmetimin e dikujt tjetër"</string>
    <string name="bluetooth_find_broadcast_title" msgid="5385985218699831970">"Transmetimet"</string>
    <string name="bluetooth_find_broadcast_summary" msgid="3907899428626210673">"Po dëgjon"</string>
    <string name="bluetooth_find_broadcast" msgid="1768337775649457586">"Gjej transmetime"</string>
    <string name="bluetooth_find_broadcast_button_leave" msgid="7881206581147104908">"Largohu nga transmetimi"</string>
    <string name="bluetooth_find_broadcast_button_scan" msgid="3995664694641895189">"Skano kodin QR"</string>
    <string name="find_broadcast_password_dialog_title" msgid="3176988702535737484">"Fut fjalëkalimin"</string>
    <string name="find_broadcast_password_dialog_connection_error" msgid="47873617983439400">"Nuk mund të lidhet. Provo sërish."</string>
    <string name="find_broadcast_password_dialog_password_error" msgid="243855327674765">"Fjalëkalim i gabuar"</string>
    <string name="bt_le_audio_scan_qr_code_scanner" msgid="7614569515419813053">"Që të fillosh të dëgjosh, vendos në qendër kodin QR më poshtë"</string>
    <string name="bt_le_audio_qr_code_is_not_valid_format" msgid="7821837654128137901">"Kodi QR nuk është në format të vlefshëm"</string>
</resources>
