<?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>
    <string name="device_info_protected_single_press" msgid="3810785480060743677">"Trokit për të shfaqur informacione"</string>
    <string name="show_dev_countdown" msgid="2936506773086395069">"{count,plural, =1{Tani të duhet edhe # hap që të bëhesh një zhvillues.}other{Tani të duhen edhe # hapa që të bëhesh një zhvillues.}}"</string>
    <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_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_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="preview_pager_content_description" msgid="3762247188224576303">"Pamja paraprake"</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="stay_awake_on_fold_title" msgid="6590454679898134221">"Gjithmonë"</string>
    <string name="stay_awake_on_fold_summary" msgid="1939963751585954262">"Ekrani i përparmë ndizet kur palos pajisjen"</string>
    <string name="selective_stay_awake_title" msgid="7887645333447645168">"Vetëm lojëra, video etj."</string>
    <string name="selective_stay_awake_summary" msgid="9055967322921984543">"Ekrani i përparmë ndizet për aplikacionet që e ndalojë ekranin që të kalojë në gjendje joaktive"</string>
    <string name="sleep_on_fold_title" msgid="7626123024330501411">"Asnjëherë"</string>
    <string name="sleep_on_fold_summary" msgid="7737992842459588846">"Ekrani i përparmë kyçet kur palos pajisjen"</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="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_devices" msgid="1063177983261608277">"Pajisjet me Bluetooth"</string>
    <string name="bluetooth_device_name" msgid="1294669733490268384">"Emri i pajisjes"</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_pairing_pref_title" msgid="3497193027590444598">"Çifto pajisjen e re"</string>
    <string name="keywords_add_bt_device" msgid="4533191164203174011">"bluetooth"</string>
    <string name="bluetooth_pair_right_ear_button" msgid="3979894494803078852">"Çifto anën e djathtë"</string>
    <string name="bluetooth_pair_left_ear_button" msgid="1019938875726073791">"Çifto anën e majtë"</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="5711642363615781647">"Pajisja e dëgjimit në anën e majtë është lidhur.\n\nPër të çiftuar atë në anën e djathtë, sigurohu që të jetë e ndezur dhe gati për t\'u çiftuar."</string>
    <string name="bluetooth_pair_other_ear_dialog_right_ear_message" msgid="631521133525979967">"Pajisja e dëgjimit në anën e djathtë është lidhur.\n\nPër të çiftuar atë në anën e majtë, sigurohu që të jetë e 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_device_controls_general" msgid="1399214835599665488">"Për të gjitha pajisjet e dëgjimit që ofrohen"</string>
    <string name="bluetooth_device_controls_title" msgid="1895676556354697234">"Cilësimet e pajisjes së dëgjimit"</string>
    <string name="bluetooth_device_controls_summary" msgid="8115767735418425663">"Shkurtore, përputhshmëria me aparatet e dëgjimit"</string>
    <string name="bluetooth_device_controls_specific" msgid="7706863288754077107">"Për këtë pajisje"</string>
    <string name="bluetooth_audio_routing_title" msgid="5541729245424856226">"Dalja e audios"</string>
    <string name="bluetooth_audio_routing_about_title" msgid="5773336779246891954">"Rreth daljes së audios"</string>
    <string name="bluetooth_audio_routing_summary" msgid="7180947533985969066">"Drejto tingujt te pajisja jote e dëgjimit ose tek altoparlanti i telefonit"</string>
    <string name="bluetooth_screen_related" msgid="7976543255501825536">"Të ngjashme"</string>
    <string name="bluetooth_ringtone_title" msgid="3177308461256892085">"Toni i ziles dhe alarmet"</string>
    <string name="bluetooth_call_title" msgid="6851464952021874072">"Audioja gjatë telefonatave"</string>
    <string name="bluetooth_media_title" msgid="343705257183053699">"Media"</string>
    <string name="bluetooth_system_sounds_title" msgid="6746938637128763205">"Njoftimet dhe tingujt e tjerë"</string>
    <string name="bluetooth_audio_routing_footer_summary" msgid="410260713589309293">"Si parazgjedhje, dalja e audios caktohet nga aplikacionet individuale"</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_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_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_phonebook_request" msgid="1085102844577089889">"Kërkesë për qasje në numërator"</string>
    <string name="bluetooth_map_request" msgid="8664081227240707479">"Kërkesë për qasje në mesazhe"</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_disable_a2dp_hw_offload" msgid="5942913792817797541">"Çaktivizo shkarkimin e harduerit të Bluetooth A2DP"</string>
    <string name="bluetooth_disable_le_audio_hw_offload" msgid="4656853795514691257">"Ç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="bluetooth_disable_leaudio" msgid="8619410595945155354">"Çaktivizo Bluetooth LE Audio"</string>
    <string name="bluetooth_disable_leaudio_summary" msgid="4756307633476985470">"Çaktivizon veçorinë Bluetooth LE Audio nëse pajisja mbështet aftësitë e harduerit të LE Audio."</string>
    <string name="bluetooth_show_leaudio_device_details" msgid="3306637862550475370">"Shfaq çelësin për LE Audio te \"Detajet e pajisjes\""</string>
    <string name="bluetooth_bypass_leaudio_allowlist" msgid="7392319491894565552">"Anashkalo \"Listën e lejimeve\" të Bluetooth LE Audio"</string>
    <string name="bluetooth_bypass_leaudio_allowlist_summary" msgid="8999245286359656738">"Përdor LE Audio si parazgjedhje edhe nëse LE Audio periferike nuk është verifikuar se i ka plotësuar kriteret e \"Listës së lejimeve\"."</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_fast_pair_device_title" msgid="543124539265592392">"Lidhur me llogarinë"</string>
    <string name="connected_device_previously_associated_fast_pair_device_title" msgid="8353405823992023457">"E përdorur më parë me këtë llogari"</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_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="connected_device_fast_pair_device_see_all" msgid="4898279230458128620">"Shiko të gjitha"</string>
    <string name="stylus_device_details_title" msgid="7618295136015480864">"Stilolapsi"</string>
    <string name="stylus_default_notes_app" msgid="4165657465911764628">"Shtypja e butonit të bishtit"</string>
    <string name="stylus_default_notes_summary_work" msgid="4554643411627934223">"<xliff:g id="APP_NAME">%s</xliff:g> (Profili i punës)"</string>
    <string name="stylus_textfield_handwriting" msgid="2363579035338976327">"Shkruaj në fushat e tekstit"</string>
    <string name="stylus_ignore_button" msgid="7734540973145241391">"Shpërfill të gjitha shtypjet e butonave me stilolapsin"</string>
    <string name="stylus_connected_devices_title" msgid="2823967577941359812">"Stilolapsi"</string>
    <string name="audio_sharing_title" msgid="4144157137502923821">"Ndarja e audios"</string>
    <string name="audio_sharing_switch_title" msgid="7052827328670825701">"Ndaj audion"</string>
    <string name="calls_and_alarms_device_title" msgid="6993559028175454198">"Telefonatat dhe alarmet"</string>
    <string name="audio_sharing_streams_category_title" msgid="862958129650324581">"Lidh me një transmetim audio LE"</string>
    <string name="audio_sharing_streams_pref_title" msgid="4636293245167657721">"Transmetimet audio në afërsi"</string>
    <string name="audio_sharing_streams_title" msgid="8269455097512153101">"Transmetimet audio"</string>
    <string name="audio_sharing_streams_qr_code_summary" msgid="4231875597377863735">"Lidh me një transmetim audio duke përdorur kodin QR"</string>
    <string name="date_and_time" msgid="1788358029823431692">"Data dhe ora"</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_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="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="language_picker_category_title" msgid="1792199453060454565">"Renditja e gjuhëve të preferuara"</string>
    <string name="desc_current_default_language" msgid="1901157141663662859">"Gjuha e sistemit"</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="7617427959223831373">"Gjuhët e aplikacioneve"</string>
    <string name="app_locale_picker_summary" msgid="6742557329924446252">"Cakto gjuhën për secilin aplikacion"</string>
    <string name="app_locale_picker_title" msgid="2431448962911301366">"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="6744909281573556379">"Cakto gjuhën për secilin aplikacion."</string>
    <string name="desc_introduction_of_language_picker" msgid="1038423471887102449">"Sistemi, aplikacionet dhe uebsajtet përdorin gjuhën e parë të mbështetur nga gjuhët e tua të preferuara."</string>
    <string name="desc_notice_of_language_picker" msgid="3449290526457925447">"Për të zgjedhur një gjuhë për çdo aplikacion, shko te cilësimet e gjuhës së aplikacionit."</string>
    <string name="desc_locale_helper_footer_general" msgid="6112153921151780303">"Mëso më shumë për gjuhët e aplikacionit"</string>
    <string name="title_change_system_locale" msgid="8589844586256566951">"Të ndryshohet gjuha e sistemit në %s ?"</string>
    <string name="title_system_locale_addition" msgid="8218683660751479466">"Të shtohet %s në gjuhët e preferuara?"</string>
    <string name="desc_system_locale_addition" msgid="3409917362651596070">"Kjo i lejon aplikacionet dhe sajtet e internetit të dinë se edhe ty të pëlqen kjo gjuhë."</string>
    <string name="desc_notice_device_locale_settings_change" msgid="8311132485850714160">"Cilësimet e pajisjes dhe preferencat rajonale do të ndryshojnë."</string>
    <string name="button_label_confirmation_of_system_locale_change" msgid="5593798559604894733">"Ndrysho"</string>
    <string name="title_unavailable_locale" msgid="2628898110416542386">"%s nuk ofrohet"</string>
    <string name="desc_unavailable_locale" msgid="2201756477400935896">"Kjo gjuhë nuk mund të përdoret si një gjuhë sistemi, por ti i ke informuar aplikacionet dhe uebsajtet që preferon këtë gjuhë."</string>
    <string name="regional_preferences_title" msgid="4304567374498629528">"Preferencat rajonale"</string>
    <string name="regional_preferences_summary" msgid="1189876997389469650">"Cakto njësitë dhe preferencat e numrave"</string>
    <string name="regional_preferences_main_page_sub_title" msgid="4237109940015254725">"Tregoju aplikacioneve preferencat e tua rajonale në mënyrë që të personalizojnë përvojën tënde."</string>
    <string name="regional_preferences_option_page_sub_title" msgid="8303661099255197036">"Aplikacionet do të përdorin preferencat e tua rajonale atje ku është e mundur."</string>
    <string name="temperature_preferences_title" msgid="5009881556503629058">"Temperatura"</string>
    <string name="first_day_of_week_preferences_title" msgid="1971850087589599553">"Dita e parë e javës"</string>
    <string name="numbers_preferences_title" msgid="8197418984391195446">"Preferencat e numrave"</string>
    <string name="default_string_of_regional_preference" msgid="3428899072914884203">"Përdor të parazgjedhurën"</string>
    <string name="celsius_temperature_unit" msgid="8896459071273084507">"Celsius (°C)"</string>
    <string name="fahrenheit_temperature_unit" msgid="1118677820614569801">"Farenhait (°F)"</string>
    <string name="sunday_first_day_of_week" msgid="7644548348295686051">"E diel"</string>
    <string name="monday_first_day_of_week" msgid="7244698610476506771">"E hënë"</string>
    <string name="tuesday_first_day_of_week" msgid="5085370946936582391">"E martë"</string>
    <string name="wednesday_first_day_of_week" msgid="6544537589727042869">"E mërkurë"</string>
    <string name="thursday_first_day_of_week" msgid="3035885630945594833">"E enjte"</string>
    <string name="friday_first_day_of_week" msgid="7074795061812083541">"E premte"</string>
    <string name="saturday_first_day_of_week" msgid="3702282590450322727">"E shtunë"</string>
    <string name="title_regional_pref_footer" msgid="7450438024324794380">"Nëse një aplikacion nuk i mbështet preferencat rajonale, aplikacioni do të përdorë cilësimet e tij të parazgjedhura lokale."</string>
    <string name="desc_regional_pref_footer_learn_more" msgid="4401708653329230081">"Mëso më shumë rreth preferencave gjuhësore."</string>
    <string name="category_title_terms_of_address" msgid="4309422700380895278">"Preferenca të tjera"</string>
    <string name="terms_of_address_title" msgid="4064593634733842458">"Termat e adresimit"</string>
    <string name="terms_of_address_summary" msgid="6136134336560679144">"Cakto se si dëshiron të të adresohen"</string>
    <string name="terms_of_address_intro_title" msgid="6149691509414243483">"Aplikacionet mund të përdorin termat e tu të adresimit për të personalizuar mënyrën se si të adresohen."</string>
    <string name="terms_of_address_not_specified" msgid="4439257779351251973">"E papërcaktuar"</string>
    <string name="terms_of_address_feminine" msgid="1743479869695539283">"Femërore"</string>
    <string name="terms_of_address_masculine" msgid="983106046135098856">"Mashkullore"</string>
    <string name="terms_of_address_neutral" msgid="5475414185543112478">"Asnjanës"</string>
    <string name="dlg_remove_locales_title" msgid="3170501604483612114">"{count,plural, =1{Të hiqet gjuha e zgjedhur?}other{Të hiqen gjuhët e zgjedhura?}}"</string>
    <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="3071618135527110152">"Nuk ofrohet si gjuhë sistemi"</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="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="remove" msgid="1028414219245072102">"Hiq"</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="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_warning" msgid="7703647889040229013">"Mund të zbatohen tarifat e roaming-ut."</string>
    <string name="date_time_auto" msgid="4239202185055225869">"Cakto automatikisht orën"</string>
    <string name="zone_auto_title" msgid="5141692422373097957">"Cakto automatikisht"</string>
    <string name="auto_zone_requires_location_summary" msgid="4831038184260596735">"Kur ky çelës është aktiv, vendndodhja do të përdoret për caktimin e brezit orar"</string>
    <string name="date_time_24hour_auto" msgid="6583078135067804252">"Përdor parazgjedhjen e lokalitetit"</string>
    <string name="date_time_24hour" msgid="286679379105653406">"Përdor formatin 24-orësh"</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_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_first_sentence" msgid="1326664252091302458">"Përdor <xliff:g id="OFFSET_AND_NAME">%1$s</xliff:g>. <xliff:g id="SECOND_SENTENCE">%2$s</xliff:g>"</string>
    <string name="zone_info_footer_second_sentence" msgid="6472889173541729110">"<xliff:g id="DST_TIME_TYPE">%1$s</xliff:g> fillon më <xliff:g id="TRANSITION_DATE">%2$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="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="owner_info_settings_title" msgid="3555626140700093017">"Shto tekst në ekranin e kyçjes"</string>
    <string name="owner_info_settings_summary" msgid="347238313388083297">"Asnjë"</string>
    <string name="owner_info_settings_edit_text_hint" msgid="841926875876050274">"P.sh., pajisja Android e Admirit."</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>
    <string name="location_settings_summary_location_on" msgid="4273299717586679786">"{count,plural, =1{Aktive / # aplikacion ka qasje te vendndodhja}other{Aktive / # aplikacione kanë qasje te vendndodhja}}"</string>
    <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="349380666660145540">"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="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="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="523320857738436024">"Nevojitet konfigurimi"</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_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_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_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_how_title" msgid="3680193263037835600"></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_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_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ërko 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_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_remove_dialog_details_fingerprint" msgid="7609582230650860974">"Modeli 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 apo fjalëkalimi për të shkyçur telefonin ose për vërtetimin në aplikacione."</string>
    <string name="security_settings_face_remove_dialog_details_fingerprint_conv" msgid="2627374706274503259">"Modeli yt i fytyrës do të fshihet përgjithmonë dhe në mënyrë të sigurt.\n\nPas fshirjes, do të të duhet gjurma e gishtit, kodi 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" msgid="6387775386189204201">"Gjurmë gishti"</string>
    <string name="security_settings_fingerprint_preference_title" msgid="2484965173528415458">"Gjurma e gishtit"</string>
    <string name="security_settings_fingerprint_settings_preferences_category" msgid="8975029409126780752">"Kur përdoret \"Shkyçja me gjurmën e gishtit\""</string>
    <string name="security_settings_work_fingerprint_preference_title" msgid="2076006873519745979">"Gjurmë gishti për punë"</string>
    <string name="fingerprint_add_title" msgid="1837610443487902050">"Shto gjurmë gishti"</string>
    <string name="security_settings_fingerprint_preference_summary" msgid="8486134175759676037">"{count,plural, =1{Gjurma e gishtit u shtua}other{# gjurmë gishtash u shtuan}}"</string>
    <string name="security_settings_fingerprint_preference_summary_none" msgid="1146977379031250790">"Nevojitet konfigurimi"</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_settings_footer_learn_more" msgid="2508322993726483601">"Mëso më shumë për \"Shkyçjen me gjurmën e gishtit\""</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_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_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_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_activeunlock_preference_title" msgid="4257580421087062228">"Shkyçja me orë"</string>
    <string name="biometric_settings_intro_with_activeunlock" msgid="6583248094453119314">"Kur konfiguron \"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 mban maskë apo kur je në një zonë të errët.\n\nMund ta shkyçësh nëpërmjet orës kur fytyra ose gjurma e gishtit nuk njihet."</string>
    <string name="biometric_settings_intro_with_fingerprint" msgid="4312041617237493461">"Mund ta shkyçësh nëpërmjet orës kur gjurma e gishtit ose fytyra nuk njihet."</string>
    <string name="biometric_settings_intro_with_face" msgid="7658123658803417930">"Mund ta shkyçësh nëpërmjet orës kur fytyra ose gjurma e gishtit nuk njihet."</string>
    <string name="biometric_settings_use_fingerprint_or_watch_for" msgid="1160830065613858095">"Përdor gjurmën e gishtit ose orën"</string>
    <string name="biometric_settings_use_face_or_watch_for" msgid="1507077107150278532">"Përdor fytyrën ose gjurmën e gishtit"</string>
    <string name="biometric_settings_use_face_fingerprint_or_watch_for" msgid="7495835723072020641">"Përdor fytyrën, gjurmën e gishtit ose orën"</string>
    <string name="biometric_settings_use_watch_for" msgid="5454545622244040110">"Përdor orën"</string>
    <string name="biometric_settings_use_face_or_watch_preference_summary" msgid="4969685200340861744">"Përdor fytyrën ose orën"</string>
    <string name="biometric_settings_use_fingerprint_or_watch_preference_summary" msgid="2425628094194828407">"Përdor gjurmën e gishtit ose orën"</string>
    <string name="biometric_settings_use_face_fingerprint_or_watch_preference_summary" msgid="188805113048792007">"Përdor fytyrën, gjurmën e gishtit ose orën"</string>
    <string name="biometric_settings_use_watch_preference_summary" msgid="2311453276747908475">"Përdor orën"</string>
    <string name="security_settings_activeunlock_require_face_fingerprint_setup_title" msgid="8776904312629209685">"Konfiguro shkyçjen me fytyrë ose me gjurmën e gishtit"</string>
    <string name="security_settings_activeunlock_require_face_fingerprint_setup_message" msgid="1669326067732567911">"Mund ta shkyçësh nëpërmjet orës kur gjurma e gishtit ose fytyra nuk njihet"</string>
    <string name="security_settings_activeunlock_require_fingerprint_setup_title" msgid="6703703635881050623">"Konfiguro \"Shkyçjen me gjurmën e gishtit\" në fillim"</string>
    <string name="security_settings_activeunlock_require_fingerprint_setup_message" msgid="4966813766409918392">"Mund ta shkyçësh nëpërmjet orës kur gjurma e gishtit nuk njihet"</string>
    <string name="security_settings_activeunlock_require_face_setup_title" msgid="1428795376597739880">"Konfiguro \"Shkyçjen me fytyrë\" në fillim"</string>
    <string name="security_settings_activeunlock_require_face_setup_message" msgid="8904070645721933399">"Mund ta shkyçësh nëpërmjet orës kur fytyra nuk njihet"</string>
    <string name="security_settings_activeunlock_biometric_setup" msgid="8876454457817955475">"Konfigurimi"</string>
    <string name="security_settings_fingerprint_single_watch_preference_summary" msgid="6464470096384164369">"Gjurma e gishtit dhe <xliff:g id="WATCH">%s</xliff:g> u shtuan"</string>
    <string name="security_settings_fingerprint_multiple_watch_preference_summary" msgid="2259261786932097004">"Gjurmët e gishtave dhe <xliff:g id="WATCH">%s</xliff:g> u shtuan"</string>
    <string name="security_settings_face_watch_preference_summary" msgid="5817376447253802793">"Fytyra dhe <xliff:g id="WATCH">%s</xliff:g> u shtuan"</string>
    <string name="security_settings_fingerprint_single_face_watch_preference_summary" msgid="764951912234638192">"Fytyra, gjurma e gishtit dhe <xliff:g id="WATCH">%s</xliff:g> u shtuan"</string>
    <string name="security_settings_fingerprint_multiple_face_watch_preference_summary" msgid="3935500711366489380">"Fytyra, gjurmët e gishtave dhe <xliff:g id="WATCH">%s</xliff:g> u shtuan"</string>
    <string name="security_settings_remoteauth_preference_title" msgid="8319680328086089533">"Shkyçja me vërtetuesin në distancë"</string>
    <string name="security_settings_remoteauth_preference_summary" msgid="1507004469316635196">"Ora u shtua"</string>
    <string name="security_settings_remoteauth_enroll_introduction_title" msgid="2151004795778999671">"Konfiguro orën tënde"</string>
    <string name="security_settings_remoteauth_enroll_introduction_message" msgid="8737276885766036074">"\"Shkyçja me orë\" është një mënyrë tjetër praktike për të shkyçur këtë telefon, p.sh. kur i ke gishtat të lagur ose kur fytyra nuk njihet.\n\nMund të përdorësh orën tënde për ta shkyçur këtë telefon kur:"</string>
    <string name="security_settings_remoteauth_enroll_introduction_disagree" msgid="7639258097401796028">"Jo tani"</string>
    <string name="security_settings_remoteauth_enroll_introduction_agree" msgid="5271119227172049339">"Vazhdo"</string>
    <string name="security_settings_remoteauth_enroll_introduction_more" msgid="1644105894631257595">"Më shumë"</string>
    <string name="security_settings_remoteauth_enroll_introduction_how_title" msgid="6604152528267830349">"Si funksionon"</string>
    <string name="security_settings_remoteauth_enroll_introduction_info_lock_open" msgid="8570511335628725116">"Ora jote duhet të jetë e shkyçur në kyçin e dorës dhe të jetë në afërsi me këtë telefon. Nuk do të jetë e nevojshme ta shkyçësh përsëri orën tënde kur është në kyçin e dorës."</string>
    <string name="security_settings_remoteauth_enroll_introduction_info_notifications" msgid="4298855831154039694">"Kur ky telefon është i shkyçur, do të njoftohesh në orën tënde. Nëse është shkyçur aksidentalisht, trokit njoftimin për ta kyçur sërish telefonin."</string>
    <string name="security_settings_remoteauth_enroll_introduction_youre_in_control_title" msgid="7974976673323638524">"Kontrolli është në duart e tua"</string>
    <string name="security_settings_remoteauth_enroll_introduction_info_remove_watch" msgid="1888318677088986801">"Mund ta heqësh orën tënde nga \"Shkyçja me orë\" në çdo kohë te \"Cilësimet\""</string>
    <string name="security_settings_remoteauth_enroll_introduction_animation_tap_notification" msgid="1597397399097952974">"Trokit një njoftim"</string>
    <string name="security_settings_remoteauth_enroll_introduction_animation_swipe_up" msgid="2129230804324634653">"Rrëshqit shpejt lart në ekranin e kyçjes"</string>
    <string name="security_settings_remoteauth_enroll_enrolling_title" msgid="313016997943607675">"Zgjidh orën tënde"</string>
    <string name="security_settings_remoteauth_enroll_enrolling_list_heading" msgid="8227585438932911013">"Orët që ofrohen"</string>
    <string name="security_settings_remoteauth_enroll_enrolling_disagree" msgid="1670201454188049863">"Anulo"</string>
    <string name="security_settings_remoteauth_enroll_enrolling_agree" msgid="7048336252635730908">"Konfirmo"</string>
    <string name="security_settings_remoteauth_enroll_finish_title" msgid="3807372930755413112">"Je plotësisht gati!"</string>
    <string name="security_settings_remoteauth_enroll_finish_description" msgid="4876209907275244653">"Tani mund ta përdorësh orën për të shkyçur këtë telefon kur rrëshqet shpejt lart në ekranin e kyçjes ose kur troket një njoftim"</string>
    <string name="security_settings_remoteauth_enroll_finish_btn_next" msgid="8072138423143889592">"U krye"</string>
    <string name="security_settings_remoteauth_settings_title" msgid="1564912618737165129">"Shkyçja me orë"</string>
    <string name="security_settings_remoteauth_settings_description" msgid="2758239650119457964">"Mund ta përdorësh orën për të shkyçur këtë telefon kur rrëshqet shpejt lart në ekranin e kyçjes ose kur troket një njoftim"</string>
    <string name="security_settings_remoteauth_settings_info_footer" msgid="795894033901478120">"Për të përdorur \"Shkyçjen me orë\", ora jote duhet të jetë e shkyçur në kyçin e dorës, në afërsi dhe të jetë e lidhur me këtë telefon. Nëse lidhja ndërpritet, do të të duhet të shkyçësh telefonin para se të mund të përdorësh \"Shkyçjen me orë\".\n\nKi parasysh:\nMund të konfigurosh vetëm një orë njëkohësisht. Për të shtuar një orë tjetër, fillimisht hiq orën aktuale."</string>
    <string name="security_settings_remoteauth_settings_learn_more" msgid="5653556124819260050">"Mëso më shumë rreth \"Shkyçjes me orë\""</string>
    <string name="security_settings_remoteauth_settings_register_new_authenticator" msgid="9191331738306527887">"Shto orën"</string>
    <string name="security_settings_remoteauth_settings_remove_device" msgid="2436226120578851282">"Hiq orën"</string>
    <string name="security_settings_biometric_preference_title" msgid="5012627247749093938">"Shkyçja me gjurmë gishti dhe me fytyrë"</string>
    <string name="security_settings_work_biometric_preference_title" msgid="3121755615533533585">"Shkyçja me fytyrë dhe gjurmë gishti për profilin e punës"</string>
    <string name="security_settings_biometric_preference_summary_none_enrolled" msgid="213377753727694575">"Nevojitet konfigurimi"</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 konfiguron \"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 mban maskë apo kur je 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_category_use_face_fingerprint" msgid="4377659744376863913">"Përdor fytyrën ose gjurmën e gishtit dhe"</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_ok" msgid="1763788801883247426">"Në rregull"</string>
    <string name="biometric_settings_add_face_in_split_mode_title" msgid="6041232223862753222">"\"Shkyçja me fytyrë\" nuk mund të konfigurohet"</string>
    <string name="biometric_settings_add_face_in_split_mode_message" msgid="1904738532939614456">"Dil nga ekrani i ndarë për të konfiguruar \"Shkyçjen me fytyrë\""</string>
    <string name="biometric_settings_add_fingerprint_in_split_mode_title" msgid="9194670722730454903">"Nuk mund të konfigurohet gjurma e gishtit"</string>
    <string name="biometric_settings_add_fingerprint_in_split_mode_message" msgid="6960548382076629454">"Dil nga ekrani i ndarë për të konfiguruar \"Shkyçjen me gjurmën e gishtit\""</string>
    <string name="biometric_settings_add_biometrics_in_split_mode_ok" msgid="564103789097253645">"Në rregull"</string>
    <string name="lock_screen_intro_skip_title" msgid="342553937472568925">"Të kapërcehet kyçja e ekranit?"</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_sfps_enroll_find_sensor_title" msgid="8327884364635804363">"Prek butonin e energjisë pa e shtypur atë"</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_try_again" msgid="8117874972945407006">"Provo sërish"</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ë ndiesh një dridhje"</string>
    <string name="security_settings_sfps_enroll_start_message" msgid="9054672627477685212">"Pa e shtypur butonin, mbaje gjurmën e gishtit mbi sensor derisa të ndiesh një dridhje.\n\nLëvize paksa gishtin çdo herë. Kjo ndihmon për të regjistruar një pjesë më të madhe të gjurmës së gishtit tënd."</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 mbi 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_sfps_enroll_finger_center_title" msgid="1320688855767675739">"Vendos pjesën qendrore të gishtit tënd mbi sensor"</string>
    <string name="security_settings_sfps_enroll_fingertip_title" msgid="2737520837684516446">"Vendos majën e gishtit mbi sensor"</string>
    <string name="security_settings_sfps_enroll_left_edge_title" msgid="9022963735924413343">"Vendos skajin e majtë të gishtit mbi sensor"</string>
    <string name="security_settings_sfps_enroll_right_edge_title" msgid="823106857743394392">"Në përfundim, vendos skajin e djathtë të gishtit mbi sensor"</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_sfps_enroll_progress_a11y_message" msgid="6450772721691523736">"Regjistrimi i gjurmës së gishtit: <xliff:g id="PERCENTAGE">%d</xliff:g> për qind"</string>
    <string name="security_settings_sfps_animation_a11y_label" msgid="8808819903730940446">"Regjistruar <xliff:g id="PERCENTAGE">%d</xliff:g> për qind"</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_require_screen_on_to_auth_title" msgid="1641621458536715518">"Prek për ta shkyçur në çdo kohë"</string>
    <string name="security_settings_require_screen_on_to_auth_description" msgid="4158414711168345398">"Prek sensorin për ta shkyçur, edhe kur ekrani është i fikur. Kjo bën që shkyçja aksidentale të ketë më shumë gjasa të ndodhë."</string>
    <string name="security_settings_require_screen_on_to_auth_keywords" msgid="5557869560397089603">"Ekrani; Shkyçja"</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_skip_setup_title" msgid="6979006375138175111">"Të kapërcehet konfigurimi për: <xliff:g id="OPTIONS">%s</xliff:g>?"</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_unable_to_process_dialog_title" msgid="6305457126747942642">"Gjurma e gishtit nuk mund të konfigurohet"</string>
    <string name="security_settings_fingerprint_enroll_error_unable_to_process_message_setup" msgid="2735739618722623980">"Mund të provosh përsëri tani ose konfiguroje gjurmën e gishtit më vonë te \"Cilësimet\"."</string>
    <string name="security_settings_fingerprint_enroll_error_unable_to_process_message" msgid="5858386244898601003">"Mund të provosh përsëri tani ose konfiguroje gjurmën e gishtit më vonë."</string>
    <string name="security_settings_fingerprint_enroll_error_dialog_title" msgid="8582267776559099046">"Konfigurimi i gjurmës së gishtit skadoi"</string>
    <string name="security_settings_fingerprint_enroll_error_timeout_dialog_message_setup" msgid="8521566666541069383">"Mund ta konfigurosh gjurmën e gishtit më vonë te \"Cilësimet\"."</string>
    <string name="security_settings_fingerprint_enroll_error_generic_dialog_message_setup" msgid="8140162986046783546">"Ndodhi një gabim. Mund ta konfigurosh gjurmën e gishtit më vonë te \"Cilësimet\"."</string>
    <string name="security_settings_fingerprint_enroll_error_timeout_dialog_message" msgid="3534341971920335247">"Mund ta konfigurosh gjurmën e gishtit më vonë."</string>
    <string name="security_settings_fingerprint_enroll_error_generic_dialog_message" msgid="4344665784935791640">"Ndodhi një gabim. Mund ta konfigurosh gjurmën e gishtit më vonë."</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_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_title" msgid="3073145395701953620">"Sensori i gjurmës së gishtit nuk mund të përdoret"</string>
    <string name="security_settings_fingerprint_bad_calibration" msgid="304585658839584958">"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="more_security_privacy_settings" msgid="123465614090328851">"Më shumë siguri dhe privatësi"</string>
    <string name="security_header" msgid="961514795852103424">"Siguria"</string>
    <string name="privacy_header" msgid="5526002421324257007">"Privatësia"</string>
    <string name="work_profile_category_header" msgid="85707750968948517">"Profili i punës"</string>
    <string name="private_space_title" msgid="7078627930195569767">"Hapësira private"</string>
    <string name="private_space_summary" msgid="8237652417163408001">"Fshih aplikacionet në një dosje private"</string>
    <string name="private_space_one_lock_title" msgid="7306547190751832568">"Shkyç duke përdorur kyçjen e ekranit"</string>
    <string name="private_space_hide_title" msgid="8687034008994037610">"Fshih kur është e kyçur"</string>
    <string name="privatespace_hide_page_title" msgid="972581369094289386">"Fshih \"Hapësirën private\" kur është e kyçur"</string>
    <string name="privatespace_hide_page_summary" msgid="1052569521186403642">"Për të ndaluar që të tjerët të dinë se \"Hapësira private\" është në pajisjen tënde, mund ta fshehësh nga lista jote e aplikacioneve"</string>
    <string name="privatespace_access_header" msgid="982809349769470185">"Qasu te \"Hapësira private\" kur është e fshehur"</string>
    <string name="privatespace_search_description" msgid="983837656432484282">"Kontrollo për \"Hapësirën private\" në shiritin e kërkimit"</string>
    <string name="privatespace_tap_tile_description" msgid="4146608898639668340">"Trokit te pllakëza e \"Hapësirës private\""</string>
    <string name="privatespace_unlock_description" msgid="4132755357482447360">"Shkyç \"Hapësirën private\""</string>
    <string name="privatespace_hide_off_summary" msgid="7227778747159633671">"Joaktive"</string>
    <string name="privatespace_hide_on_summary" msgid="6136704537527640183">"Aktive"</string>
    <string name="private_space_category_system" msgid="1286843321867285700">"Sistemi"</string>
    <string name="private_space_create_title" msgid="47273568884806726">"Krijo \"Hapësirën private\""</string>
    <string name="private_space_delete_title" msgid="3075645119800272800">"Fshi \"Hapësirën private\""</string>
    <string name="private_space_created" msgid="2978055968937762232">"\"Hapësira private\" u krijua me sukses"</string>
    <string name="private_space_already_exists" msgid="1253034947621867419">"\"Hapësira private\" ekziston tashmë"</string>
    <string name="private_space_create_failed" msgid="4908100791174213808">"\"Hapësira private\" nuk mund të krijohej"</string>
    <string name="private_space_deleted" msgid="7825768516955610897">"\"Hapësira private\" u fshi me sukses"</string>
    <string name="private_space_delete_failed" msgid="8500755484258565011">"\"Hapësira private\" nuk mund të fshihej"</string>
    <string name="no_device_lock_title" msgid="1078223464721029954">"Cakto një kyçje ekrani"</string>
    <string name="no_device_lock_summary" msgid="7653477413589207824">"Për të përdorur \"Hapësirën private\", cakto një kyçje ekrani në këtë pajisje."</string>
    <string name="no_device_lock_action_label" msgid="2640487005629001288">"Cakto kyçjen e ekranit"</string>
    <string name="no_device_lock_cancel" msgid="4412602160321228863">"Anulo"</string>
    <string name="privatespace_cancel_label" msgid="362351004019511784">"Anulo"</string>
    <string name="privatespace_setup_button_label" msgid="3696372546231047258">"Konfiguro"</string>
    <string name="privatespace_setup_title" msgid="177623114624330394">"Konfiguro \"Hapësirën private\""</string>
    <string name="privatespace_hide_apps_summary" msgid="4016518749055602268">"Fshih aplikacionet private në një hapësirë të sigurt ku vetëm ti mund të qasesh"</string>
    <string name="privatespace_how_title" msgid="8794102046435526065">"Si funksionon"</string>
    <string name="privatespace_access_bottom_text" msgid="1075244097441349030">"Mund të qasesh te \"Hapësira private\" nga fundi i listës së aplikacioneve"</string>
    <string name="privatespace_protected_lock_text" msgid="7320604832432017423">"Aplikacionet në \"Hapësirën private\" janë të mbrojtura me një kyçje"</string>
    <string name="privatespace_hidden_notifications_text" msgid="8121285743543004812">"Njoftimet nga aplikacionet në \"Hapësirën private\" janë të fshehura kur ajo është e kyçur"</string>
    <string name="privatespace_apps_permission_text" msgid="4418511924151828812">"Aplikacionet e \"Hapësirës private\" nuk do të shfaqen te menaxheri i lejeve, paneli i privatësisë dhe në cilësime të tjera kur \"Hapësira private\" është e kyçur"</string>
    <string name="privatespace_setting_up_text" msgid="8532777749891406509">"\"Hapësira private\" po konfigurohet…"</string>
    <string name="privatespace_lock_protected_title" msgid="7409801274869666860">"\"Hapësira private\" është e mbrojtur me një kyçje"</string>
    <string name="privatespace_apps_hidden_title" msgid="6146605677591599107">"Informacionet e përdorimit për aplikacionet e \"Hapësirës private\" janë të fshehura kur ajo është e kyçur"</string>
    <string name="privatespace_access_from_apps_title" msgid="6787000636686810564">"Qasu te \"Hapësira private\" nga lista jote e aplikacioneve"</string>
    <string name="privatespace_error_screen_title" msgid="8658511165913662275">"\"Hapësira private\" nuk mund të konfigurohej"</string>
    <string name="privatespace_error_screen_summary" msgid="5679626031159521676">"Provo përsëri tani ose kthehu më vonë"</string>
    <string name="privatespace_tryagain_label" msgid="4091466165724929876">"Provo përsëri"</string>
    <string name="privatespace_lockscreen_title" msgid="7459425150560213662">"Të përdoret kyçja e ekranit për ta shkyçur?"</string>
    <string name="privatespace_lockscreen_summary" msgid="980268845497843861">"\"Hapësirën private\" mund ta shkyçësh në të njëjtën mënyrë që shkyç pajisjen tënde ose mund të zgjedhësh një kyçje tjetër"</string>
    <string name="privatespace_use_screenlock_label" msgid="2775404941450049991">"Përdor kyçjen e ekranit"</string>
    <string name="privatespace_set_lock_label" msgid="6277529807188602545">"Zgjidh një kyçje të re"</string>
    <string name="privatespace_success_title" msgid="4854425684898602993">"Plotësisht gati!"</string>
    <string name="privatespace_access_text" msgid="8756118686974614618">"Për t\'u qasur te \"Hapësira private\", rrëshqit shpejt lart nga fundi i ekranit bazë dhe më pas lëviz poshtë"</string>
    <string name="privatespace_done_label" msgid="5534818213879562387">"U krye"</string>
    <string name="scrolldown_to_access" msgid="5160743933093369151">"Lëviz poshtë për t\'u qasur te \"Hapësira private\""</string>
    <!-- no translation found for privatespace_retry_signin_title (495054309243289223) -->
    <skip />
    <!-- no translation found for privatespace_retry_summary (2888518420576278925) -->
    <skip />
    <string name="fingerprint_add_max" msgid="8639321019299347447">"Mund të shtosh deri në <xliff:g id="COUNT">%d</xliff:g> gjurmë gishtash"</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_delete_title" msgid="5412123164503407098">"Fshi \"<xliff:g id="FINGERPRINT_ID">%1$s</xliff:g>\""</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="encryption_settings_title" msgid="2848716008695618360">"Enkriptimi"</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 më shumë siguri, 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="no_screen_lock_issue_notification_title" msgid="1214876733592830628">"Cakto një kyçje ekrani"</string>
    <string name="no_screen_lock_issue_notification_text" msgid="8696194459170873345">"Për më shumë siguri, cakto një kod PIN, një motiv ose një fjalëkalim për këtë pajisje."</string>
    <string name="suggested_lock_settings_title" msgid="7836065447159730217">"Siguro telefonin tënd"</string>
    <string name="suggested_fingerprint_lock_settings_title" msgid="3140266181874137984">"Shto gjurmën e gishtit për ta shkyçur"</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="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="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="lock_screen_auto_pin_confirm_title" msgid="3012128112186088375">"Shkyçje me konfirmim automatik"</string>
    <string name="lock_screen_auto_pin_confirm_summary" msgid="9050818870806580819">"Shkyç automatikisht nëse fut një kod të saktë PIN prej 6 shifrash ose më shumë. Ky është disi më pak i sigurt sesa trokitja e \"Fut\" për të konfirmuar."</string>
    <string name="auto_pin_confirm_user_message" msgid="6194556173488939314">"Konfirmo automatikisht kodin e saktë PIN"</string>
    <string name="auto_pin_confirm_opt_in_security_message" msgid="580773976736184893">"Konfirmimi i kodit tënd PIN duke trokitur \"Enter\" është më i sigurt se sa përdorimi i konfirmimit automatik"</string>
    <string name="auto_confirm_on_pin_verify_description" msgid="2052240431173223502">"Fut kodin PIN të pajisjes për të aktivizuar konfirmimin automatik"</string>
    <string name="auto_confirm_off_pin_verify_description" msgid="4256219155659760047">"Fut kodin PIN të pajisjes për të çaktivizuar konfirmimin automatik"</string>
    <string name="unlock_set_unlock_launch_picker_title" msgid="4981063601772605609">"Kyçja e ekranit"</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_off_title" msgid="2831957685685921667">"Asnjë"</string>
    <string name="unlock_set_unlock_none_title" msgid="2844029875174409728">"Rrëshqitje"</string>
    <string name="unlock_set_unlock_pattern_title" msgid="8224895208452995332">"Motiv"</string>
    <string name="unlock_set_unlock_pin_title" msgid="5283636759362880407">"Kod PIN"</string>
    <string name="unlock_set_unlock_password_title" msgid="2559842616268607041">"Fjalëkalim"</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="2229689425933043901">"Motiv • Gjurmë gishti"</string>
    <string name="fingerprint_unlock_set_unlock_pin" msgid="7979848492740627674">"PIN • Gjurmë gishti"</string>
    <string name="fingerprint_unlock_set_unlock_password" msgid="6207676267295036963">"Fjalëkalim • Gjurmë gishti"</string>
    <string name="fingerprint_unlock_skip_fingerprint" msgid="7631242444064287891">"Vazhdo pa gjurmën e gishtit"</string>
    <string name="face_unlock_set_unlock_pattern" msgid="4206669838203096608">"Motiv • Fytyrë"</string>
    <string name="face_unlock_set_unlock_pin" msgid="9034912683791069602">"PIN • Fytyrë"</string>
    <string name="face_unlock_set_unlock_password" msgid="5874950853246424756">"Fjalëkalim • Fytyrë"</string>
    <string name="face_unlock_skip_face" msgid="189695556498300008">"Vazhdo pa \"Shkyçjen me fytyrë\""</string>
    <string name="biometrics_unlock_skip_biometrics" msgid="7399882488272450182">"Vazhdo pa gjurmë gishti ose fytyrë"</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_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_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>
    <string name="lockpassword_password_too_short" msgid="1938086368137797700">"{count,plural, =1{Duhet të përmbajë të paktën # karakter}other{Duhet të ketë të paktën # karaktere}}"</string>
    <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>
    <string name="lockpassword_pin_too_short" msgid="8910105226463085689">"{count,plural, =1{Kodi PIN duhet të përmbajë të paktën # shifër}other{Kodi PIN duhet të ketë të paktën # shifra}}"</string>
    <string name="lockpassword_pin_too_short_autoConfirm_extra_message" msgid="3271351502900762571">"{count,plural, =1{Kodi PIN duhet të përmbajë të paktën # shifër, por rekomandohet një kod PIN {minAutoConfirmLen}-shifror për siguri të shtuar}other{Kodi PIN duhet të përmbajë të paktën # shifra, por rekomandohet një kod PIN {minAutoConfirmLen}-shifror për siguri të shtuar}}"</string>
    <string name="lockpassword_password_too_long" msgid="1940345313260498308">"{count,plural, =1{Duhet të ketë më pak se # karakter}other{Duhet të ketë më pak se # karaktere}}"</string>
    <string name="lockpassword_pin_too_long" msgid="1678212054564388576">"{count,plural, =1{Duhet të ketë më pak se # shifër}other{Duhet të ketë më pak se # shifra}}"</string>
    <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_letters" msgid="7058340182953750553">"{count,plural, =1{Duhet të përmbajë të paktën 1 shkronjë}other{Duhet të përmbajë të paktën # shkronja}}"</string>
    <string name="lockpassword_password_requires_lowercase" msgid="3286121470522077547">"{count,plural, =1{Duhet të përmbajë të paktën 1 shkronjë të vogël}other{Duhet të përmbajë të paktën # shkronja të vogla}}"</string>
    <string name="lockpassword_password_requires_uppercase" msgid="720312543910397772">"{count,plural, =1{Duhet të përmbajë të paktën 1 shkronjë të madhe}other{Duhet të përmbajë të paktën # shkronja të mëdha}}"</string>
    <string name="lockpassword_password_requires_numeric" msgid="3886918493600507548">"{count,plural, =1{Duhet të përmbajë të paktën 1 shifër numerike}other{Duhet të përmbajë të paktën # shifra numerike}}"</string>
    <string name="lockpassword_password_requires_symbols" msgid="2904870551002210131">"{count,plural, =1{Duhet të përmbajë të paktën 1 simbol të veçantë}other{Duhet të përmbajë të paktën # simbole të veçanta}}"</string>
    <string name="lockpassword_password_requires_nonletter" msgid="1185342065898300006">"{count,plural, =1{Duhet të përmbajë të paktën 1 karakter që nuk është shkronjë}other{Duhet të përmbajë të paktën # karaktere që nuk janë shkronja}}"</string>
    <string name="lockpassword_password_requires_nonnumerical" msgid="389687423482993365">"{count,plural, =1{Duhet të përmbajë të paktën 1 karakter jonumerik}other{Duhet të përmbajë të paktën # karaktere jonumerike}}"</string>
    <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_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="manage_device_admin" msgid="1044620606203916275">"Apl. e admin. të pajisjes"</string>
    <string name="number_of_device_admins_none" msgid="152926922020437312">"Asnjë aplikacion aktiv"</string>
    <string name="number_of_device_admins" msgid="3402909995362162876">"{count,plural, =1{# aplikacion aktiv}other{# aplikacione aktive}}"</string>
    <string name="manage_trust_agents" msgid="6410149930029992356">"Agjentë besimi"</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>
    <string name="manage_trust_agents_summary_on" msgid="3302574418419446146">"{count,plural, =1{1 agjent besimi aktiv}other{# agjentë besimi aktivë }}"</string>
    <string name="bluetooth_settings" msgid="2967239493428695171">"Bluetooth-i"</string>
    <string name="bluetooth_settings_title" msgid="2642029095769509647">"Bluetooth-i"</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_group_late_bonding" msgid="5310869364570266209">"Shto një anëtar të ri te grupi ekzistues i koordinuar"</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_paring_group_msg" msgid="4609515924670823316">"Konfirmo për të çiftuar me grupin e koordinuar"</string>
    <string name="bluetooth_pairing_shares_phonebook" msgid="4329325125260724843">"Lejo qasjen te kontaktet dhe historiku i telefonatave"</string>
    <string name="bluetooth_pairing_phonebook_toggle_text" msgid="2474015367387690034">"Lejo gjithashtu qasjen te kontaktet dhe historiku i telefonatave"</string>
    <string name="bluetooth_pairing_phonebook_toggle_details" msgid="1367197978487212581">"Informacionet do të përdoren për njoftimet për telefonatat etj."</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_found_media_devices" msgid="830061195998352840">"Pajisjet që ofrohen"</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_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="786648535600075223">"Kur Bluetooth-i është i aktivizuar, pajisja jote mund të komunikojë me pajisje të tjera me Bluetooth në afërsi.\n\nPër të përmirësuar përvojën e pajisjes, aplikacionet dhe shërbimet mund të vazhdojnë të skanojnë për pajisje në afërsi në çdo kohë, edhe kur Bluetooth-i ë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 cilësimet e skanimit me Bluetooth."</string>
    <string name="bluetooth_scan_change" msgid="1744636222637390367">"Ndrysho"</string>
    <string name="device_details_title" msgid="1155622417516195481">"Detajet e pajisjes"</string>
    <string name="bluetooth_device_keyboard_settings_preference_title" msgid="3411693160917620519">"Cilësimet e tastierës"</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_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="device_details_leaudio_toggle_summary" msgid="7684848254433230809">"Eksperimentale. Përmirëson cilësinë e audios."</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_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="nfc_verbose_vendor_log_title" msgid="5554505631122964628">"Evidenca e zgjeruar e korrigjimit të shitësit të NFC-së"</string>
    <string name="nfc_verbose_vendor_log_summary" msgid="3049128322855928507">"Përfshi evidenca shtesë të shitësve, specifike për pajisjen, në raportet e defekteve në kod që mund të përfshijnë informacione private."</string>
    <string name="nfc_snoop_log_title" msgid="1576197495976952388">"Evidenca e pafiltruar për NFC NCI"</string>
    <string name="nfc_snoop_log_summary" msgid="3988383328800163180">"Kap paketat e detajuara të NFC-së, të cilat mund të përmbajnë informacione private."</string>
    <string name="nfc_reboot_dialog_title" msgid="2033983438635768169">"Të riniset pajisja?"</string>
    <string name="nfc_reboot_dialog_message" msgid="4929353168157966992">"Regjistrimi i detajuar i lidhjes NFC është i planifikuar vetëm për qëllime zhvillimi. Të dhënat shtesë të lidhjes NFC përfshihen në raportet e defekteve në kod, të cilat mund të përmbajnë informacione private. Rinise pajisjen tënde për ta ndryshuar këtë cilësim."</string>
    <string name="nfc_reboot_dialog_confirm" msgid="4769763632008584567">"Rinis"</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 wireless"</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_options_title" msgid="7584326966240865043">"Opsionet e ekranit wireless"</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="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>
    <!-- no translation found for show_hdr_sdr_ratio (4188007289024955585) -->
    <skip />
    <!-- no translation found for show_hdr_sdr_ratio_summary (986292785096013733) -->
    <skip />
    <string name="nfc_quick_toggle_title" msgid="3607620705230351666">"NFC"</string>
    <string name="nfc_secure_settings_title" msgid="4906958426927741485">"Kërkohet shkyçja e pajisjes për NFC-në"</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_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_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_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_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_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_menu_p2p" msgid="5234165837732940385">"Wi‑Fi Direct"</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_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_min_tls_ver" msgid="174023604103299457">"Version mininal i TLS"</string>
    <string name="wifi_eap_ocsp" msgid="8713933962516871238">"Statusi i certifikatës online"</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_choose_2G" msgid="1436802195991542016">"Bandë 2,4 GHz"</string>
    <string name="wifi_ap_prefer_5G" msgid="2520628479818369902">"Preferohet banda 5,0 GHz"</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="5246641326066972419">"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_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_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_confirm_allow" msgid="4154200627800959777">"Lejo"</string>
    <string name="wifi_scan_always_confirm_deny" msgid="6997087934558839256">"Refuzo"</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_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_saved_access_points_summary" msgid="6637163320524940353">"{count,plural, =1{1 rrjet}other{# rrjete}}"</string>
    <string name="wifi_saved_passpoint_access_points_summary" msgid="8939933724918673785">"{count,plural, =1{1 abonim}other{# abonime}}"</string>
    <string name="wifi_saved_all_access_points_summary" msgid="2335870101156113858">"{count,plural, =1{1 rrjet dhe abonim}other{# rrjete dhe abonime}}"</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_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="hotspot_device_details_category" msgid="3110651914598697220">"Detajet e pajisjes së zonës së qasjes për internet"</string>
    <string name="hotspot_device_details_internet_source" msgid="1563266599673281875">"Burimi i internetit"</string>
    <string name="internet_source_wifi" msgid="6952593095166435179">"Wi-Fi"</string>
    <string name="internet_source_mobile_data" msgid="877403889449201789">"Të dhënat celulare"</string>
    <string name="internet_source_ethernet" msgid="8338472576454100966">"Ethernet"</string>
    <string name="hotspot_battery_charging_summary" msgid="6690892148553288457">"<xliff:g id="BATTERY_PERCENTAGE">%1$s</xliff:g> ‑ Po karikohet"</string>
    <string name="hotspot_connection_category" msgid="4320380513982923556">"Lidhja me zonën e qasjes për internet"</string>
    <string name="hotspot_connection_strength" msgid="87359986943768421">"Fuqia e lidhjes"</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_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_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_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_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_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_hotspot_speed_title" msgid="8629448084180512685">"Shpejtësia dhe përputhshmëria"</string>
    <string name="wifi_hotspot_speed_summary_2g" msgid="5063438001736234858">"2.4 GHz / E përputhshme me shumicën e pajisjeve"</string>
    <string name="wifi_hotspot_speed_summary_5g" msgid="6221158936983135040">"5 GHz / E përputhshme me shumë pajisje"</string>
    <string name="wifi_hotspot_speed_summary_6g" msgid="8863992901226595544">"6 GHz / E përputhshme me pak pajisje"</string>
    <string name="wifi_hotspot_speed_summary_2g_and_5g" msgid="5931052946168943750">"2.4 and 5 GHz / E përputhshme me shumicën e pajisjeve"</string>
    <string name="wifi_hotspot_speed_intro" msgid="6973482196363758925">"Zgjidh një frekuencë për zonën e qasjes për internet. Frekuenca ndikon te shpejtësia e lidhjes dhe te llojet e pajisjeve që mund të gjejnë zonën e qasjes për internet."</string>
    <string name="wifi_hotspot_speed_category" msgid="5265655850463630286">"Frekuenca e preferuar"</string>
    <string name="wifi_hotspot_speed_2g" msgid="3400600834257664480">"2,4 GHz"</string>
    <string name="wifi_hotspot_speed_2g_summary" msgid="6930273933810520155">"Shpejtësi të ulëta. E përputhshme me shumicën e pajisjeve."</string>
    <string name="wifi_hotspot_speed_5g" msgid="4058116867148848395">"5 GHz"</string>
    <string name="wifi_hotspot_speed_5g_summary" msgid="562987935924535694">"Shpejtësi të larta. E përputhshme me shumë pajisje."</string>
    <string name="wifi_hotspot_speed_2g_5g" msgid="9192756255938408285">"2,4 dhe 5 GHz"</string>
    <string name="wifi_hotspot_speed_2g_5g_summary" msgid="8104575293617700173">"Shpejtësi të larta. Kjo zonë e qasjes për internet me brez të dyfishtë është e përputhshme me shumicën e pajisjeve."</string>
    <string name="wifi_hotspot_speed_6g" msgid="3787697484862730500">"6 GHz"</string>
    <string name="wifi_hotspot_speed_6g_summary" msgid="8675262219242174548">"Shpejtësitë më të larta. E përputhshme me pak pajisje."</string>
    <string name="wifi_hotspot_speed_summary_unavailable" msgid="7276080644693388756">"Nuk ofrohet në shtetin ose rajonin tënd"</string>
    <string name="wifi_hotspot_speed_footer" msgid="8846939503916795002">"Nëse frekuenca jote e preferuar nuk ofrohet, zona e qasjes për internet mund të përdorë një tjetër. Cilësimet e sigurisë së zonës së qasjes për internet mund të ndryshojnë nëse ndryshon frekuencën."</string>
    <string name="wifi_hotspot_security_summary_unavailable" msgid="117582979310345853">"Nuk ofrohet me 6 GHz"</string>
    <string name="wifi_hotspot_security_footer" msgid="4608329688744949796">"Cilësimet e sigurisë mund të ndryshojnë nëse ndryshon frekuencën e zonës së qasjes për internet"</string>
    <string name="wifi_hotspot_instant_title" msgid="7052526695338853703">"Zona e qasjes për internet në çast"</string>
    <string name="wifi_hotspot_instant_summary_on" msgid="3142749148673081288">"Aktive"</string>
    <string name="wifi_hotspot_instant_summary_off" msgid="8594065628453795615">"Joaktive"</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_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_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_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_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_disconnected_from" msgid="5249576734324159708">"U shkëput nga <xliff:g id="SSID">%1$s</xliff:g>"</string>
    <string name="sound_settings" msgid="7622986039384531304">"Tingulli dhe dridhja"</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_category_clone" msgid="7893383448944567885">"Klono llogaritë e profilit"</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_link_a11y" msgid="5146188567212233286">"Mëso më shumë për rrotullimin automatik"</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_full" msgid="2694003735219114186">"Rezolucion i plotë"</string>
    <string name="screen_resolution_footer" msgid="6772341522952795647">"Rezolucioni i plotë përdor më shumë bateri. Ndryshimi i rezolucionit mund të shkaktojë rinisjen e disa aplikacioneve."</string>
    <string name="screen_resolution_selected_a11y" msgid="6158451180032224977">"Zgjedhur"</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="brightness" msgid="6216871641021779698">"Niveli i ndriçimit"</string>
    <string name="auto_brightness_title" msgid="4239324728760986697">"Ndriçimi me përshtatje"</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 me përshtatje që të mësojë preferencat e tua."</string>
    <string name="auto_brightness_summary_on" msgid="2748088951224387004">"Aktiv"</string>
    <string name="auto_brightness_summary_off" msgid="8077066192887677956">"Joaktiv"</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="fold_lock_behavior_title" msgid="786228803694268449">"Vazhdo të përdorësh aplikacionet në Fold"</string>
    <string name="peak_refresh_rate_title" msgid="1878771412897140903">"Smooth Display"</string>
    <string name="peak_refresh_rate_summary" msgid="3212309985294885790">"Rrit automatikisht shpejtësinë e rifreskimit deri në <xliff:g id="ID_1">%1$d</xliff:g> 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_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_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_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_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_summary" msgid="5558778019594643427">"Pas <xliff:g id="TIMEOUT_DESCRIPTION">%1$s</xliff:g> pa aktivitet"</string>
    <string name="screen_timeout_summary_not_set" msgid="5107680774964178875">"Nuk është caktuar"</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_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="keywords_screensaver" msgid="7249337959432229172">"mbrojtësi i ekranit"</string>
    <string name="screensaver_settings_when_to_dream_bedtime" msgid="3279310576803094771">"Nuk ofrohet sepse modaliteti i orarit të gjumit është aktiv"</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_dock_and_charging" msgid="8485905100159376156">"Teksa është në stacion e në karikim"</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_on" msgid="4210827304351483645">"Aktiv / <xliff:g id="SCREEN_SAVER">%1$s</xliff:g>"</string>
    <string name="screensaver_settings_summary_off" msgid="8720357504939106923">"Çaktivizuar"</string>
    <string name="screensaver_settings_when_to_dream" msgid="8145025742428940520">"Kur të fillojë"</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="7331982427303002613">"Cilësimet e kyçjes së kartës SIM"</string>
    <string name="sim_lock_settings_category" msgid="6475255139493877786">"Kyçja e kartës SIM"</string>
    <string name="sim_pin_toggle" msgid="6814489621760857328">"Kyç kartën SIM"</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="6486354334679225748">"Kyç kartën SIM"</string>
    <string name="sim_disable_sim_lock" msgid="6939439812841857306">"Shkyç 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_invalid_pin_hint" msgid="3376397829969578877">"Shkruaj një kod PIN me 4 deri në 8 numra"</string>
    <string name="sim_pins_dont_match" msgid="1540348773896609260">"Kodet PIN nuk përputhen"</string>
    <string name="sim_change_succeeded" msgid="3516905528149069739">"PIN-i i kartës SIM u ndryshua me sukses."</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_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="8850185380445309835">"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="enable_auto_data_switch_dialog_title" msgid="3563043560556718994">"Të përmirësohet mbulimi i të dhënave celulare?"</string>
    <string name="enable_auto_data_switch_dialog_message" msgid="5777287241521946883">"Lejo pajisjen tënde të kalojë automatikisht në <xliff:g id="BACKUP_CARRIER">%1$s</xliff:g> për të dhënat celulare kur të ketë disponueshmëri më të mirë."</string>
    <string name="auto_data_switch_dialog_managed_profile_warning" msgid="6839438290079866605">\n\n"Telefonatat, mesazhet dhe trafiku i rrjetit mund të jenë të dukshme për organizatën tënde."</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>
    <string name="wrong_pin_code" msgid="8124222991071607958">"{count,plural, =1{Kodi PIN i kartës SIM është i pasaktë. Të ka mbetur edhe # përpjekje përpara se të të duhet të kontaktosh me operatorin celular për ta shkyçur pajisjen.}other{Kodi PIN i kartës SIM është i pasaktë. Të kanë mbetur edhe # përpjekje.}}"</string>
    <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="manufactured_year" msgid="3401517138700926475">"Viti i prodhimit"</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="battery_info" msgid="7873528123969546728">"Informacione për baterinë"</string>
    <string name="device_info_not_available" msgid="4804474466616712326">"Nuk ofrohet"</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_settings_title" msgid="486118156723194815">"Cilësimet e hapësirës ruajtëse"</string>
    <string name="status_eid" msgid="7532406028683438634">"EID"</string>
    <string name="eid_multi_sim" msgid="9087924808336397804">"EID (foleja e kartës SIM <xliff:g id="EID_SLOT_ID">%1$d</xliff:g>)"</string>
    <string name="imei_multi_sim" msgid="9001570420423929507">"IMEI (foleja e kartës <xliff:g id="IMEI_SLOT_ID">%1$d</xliff:g>)"</string>
    <string name="imei_multi_sim_primary" msgid="7914653040843734282">"IMEI (foleja e kartës <xliff:g id="IMEI_SLOT_ID_PRIMARY">%1$d</xliff:g>) (kryesore)"</string>
    <string name="view_saved_network" msgid="1232387673095080910">"Për ta shfaqur, zgjidh rrjetin e ruajtur"</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="1460689549266621286">"MEID (foleja e kartës <xliff:g id="MEID_SLOT_ID">%1$d</xliff:g>)"</string>
    <string name="meid_multi_sim_primary" msgid="8921262417580407201">"MEID (foleja e kartës <xliff:g id="MEID_SLOT_ID_PRIMARY">%1$d</xliff:g>) (kryesore)"</string>
    <string name="scanning_status_text_on" msgid="3846571210578042940">"Aktiv"</string>
    <string name="scanning_status_text_off" msgid="4002352668313705132">"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="battery_manufacture_date" msgid="7139426520156833987">"Data e prodhimit"</string>
    <string name="battery_first_use_date" msgid="3157207331722711317">"Data e përdorimit për herë të parë"</string>
    <string name="battery_cycle_count" msgid="2912949283386571900">"Numri i cikleve"</string>
    <string name="battery_cycle_count_not_available" msgid="2426584515665184664">"Nuk ofrohet"</string>
    <string name="memory_calculating_size" msgid="3898240439798661242">"Po llogarit…"</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="8903698999905354146">"Formato kartën SD si hapësirë ruajtëse të lëvizshme"</string>
    <string name="storage_menu_format_button" msgid="7623565190643699626">"Formato kartën"</string>
    <string name="storage_menu_format_public" msgid="5567214442727034630">"Formato si të lëvizshme"</string>
    <string name="storage_menu_format_option" msgid="4886059624052908432">"Formato"</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="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_other_users" msgid="7017206190449510992">"Përdorues të tjerë"</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_rename_title" msgid="5911285992205282312">"Riemërto hapësirën ruajtëse"</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="2399034372813686846">"Mund ta formatosh këtë kartë SD për të ruajtur fotografitë, videot, muzikën etj. dhe për të pasur qasje në to në pajisje të tjera. \n\n"<b>"Të gjitha të dhënat në këtë kartë SD do të spastrohen."</b>" \n\n"<b>"Para formatimit"</b>" \n\n"<b>"Rezervo fotografitë dhe mediat e tjera"</b>" \nZhvendosi skedarët e tu të medias në një hapësirë ruajtëse alternative në këtë pajisje ose transferoji te një kompjuter duke përdorur një kabllo USB. \n\n"<b>"Rezervo aplikacionet"</b>" \nTë gjitha aplikacionet e ruajtura te <xliff:g id="NAME">^1</xliff:g> do të çinstalohen dhe të dhënat e tyre do të spastrohen. Për t\'i mbajtur këto aplikacione, zhvendosi ato te një hapësirë ruajtëse alternative 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_guest" msgid="5813419895687733649">"Përdoruesit në modalitetin \"vizitor\" nuk mund t\'i formatojnë kartat SD"</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_ready_title" msgid="3631022511474086605">"<xliff:g id="NAME">^1</xliff:g> u formatua"</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_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_or" msgid="5558706089661158026">"Ose"</string>
    <string name="storage_wizard_init_v2_external_title" msgid="2786416384217054112">"Formato kartën SD si hapësirë ruajtëse të lëvizshme"</string>
    <string name="storage_wizard_init_v2_external_summary" msgid="2002761631147966185">"Ruaj fotografitë, videot, muzikën etj. dhe qasu tek ato nga pajisje të tjera. &lt;a href=https://support.google.com/android/answer/12153449&gt;Mëso më shumë për konfigurimin e një karte SD&lt;/a&gt;."</string>
    <string name="storage_wizard_init_v2_external_action" msgid="6140058734875839081">"Formato"</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 <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_body_external" msgid="5810296966099830035">"<xliff:g id="NAME_0">^1</xliff:g> duhet të formatohet për të ruajtur fotografitë, videot, muzikën etj. \n\nFormatimi do të spastrojë përmbajtjet ekzistuese te <xliff:g id="NAME_1">^2</xliff:g>. Për të shmangur humbjen e përmbajtjeve, rezervoje në një tjetër <xliff:g id="NAME_2">^3</xliff:g> ose 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_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_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="7688457485389886923">"Mund të fillosh të përdorësh <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_ready_v2_internal_body" msgid="3520269956641115883">"Mund të fillosh të përdorësh <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_ready_v2_internal_moved_body" msgid="1163588718127651062">"Mund të fillosh të përdorësh <xliff:g id="NAME">^1</xliff:g>"</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="communal_settings_title" msgid="2845678473945902115">"Të përbashkëta"</string>
    <string name="communal_settings_summary" msgid="4923914136953940317">"Cilësimet e përbashkëta"</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_add" msgid="9069613192201630934">"Shto 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_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="network_type" msgid="748590707422733595">"Lloji i rrjetit"</string>
    <string name="network_type_unspecified" msgid="7756349656194518725">"I papërcaktuar"</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_mobile_network_settings_title" msgid="5616713931258506842">"Rivendos cilësimet e rrjetit celular"</string>
    <string name="reset_mobile_network_settings_desc" msgid="7292636387692165727">"Kjo do të rivendosë të gjitha cilësimet e rrjetit celular"</string>
    <string name="reset_mobile_network_settings_confirm_title" msgid="7510965634669511241">"Rivendos cilësimet e rrjetit?"</string>
    <string name="reset_bluetooth_wifi_title" msgid="4113071322344697317">"Rivendos Bluetooth dhe Wi‑Fi"</string>
    <string name="reset_bluetooth_wifi_desc" msgid="4030295669083059711">"Kjo do të rivendosë të gjitha cilësimet e Wi‑Fi dhe Bluetooth. Nuk mund ta zhbësh këtë veprim."</string>
    <string name="reset_bluetooth_wifi_button_text" msgid="3974098137045963639">"Rivendos"</string>
    <string name="reset_bluetooth_wifi_complete_toast" msgid="5893439291030574365">"Bluetooth dhe Wi‑Fi janë rivendosur"</string>
    <string name="reset_esim_title" msgid="4194570573425902754">"Spastro eSIM-et"</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="1129251284212847939">"Të rivendosen të gjitha cilësimet e rrjetit dhe të spastrohen kartat eSIM? 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="7279607120606365250">"Kartat eSIM 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_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_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="tether_preference_summary_off" msgid="6266799346319794630">"Joaktive"</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="bluetooth_tether_checkbox_text" msgid="6108398414967813545">"Ndarje interneti përmes Bluetooth-it"</string>
    <string name="ethernet_tether_checkbox_text" msgid="959743110824197356">"Ndarja e Ethernet-it"</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 sate 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_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="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>
    <string name="location_app_permission_summary_location_on" msgid="7552095451731948984">"{count,plural, =1{# nga {total} aplikacione ka qasje te vendndodhja}other{# nga {total} aplikacione kanë qasje te vendndodhja}}"</string>
    <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="location_time_zone_detection_toggle_title" msgid="6478751613645015287">"Përdor vendndodhjen"</string>
    <string name="location_time_zone_detection_status_title" msgid="8903495354385600423">"Brezi orar nuk mund të caktohet automatikisht"</string>
    <string name="location_time_zone_detection_status_summary_degraded_by_settings" msgid="6198939835335841106"></string>
    <string name="location_time_zone_detection_status_summary_blocked_by_settings" msgid="5276280770344278768">"\"Vendndodhja\" ose \"Shërbimet e vendndodhjes\" janë joaktive"</string>
    <string name="location_time_zone_detection_status_summary_blocked_by_environment" msgid="2279833212923765802"></string>
    <string name="location_time_zone_detection_status_summary_temporarily_unavailable" msgid="6586801403644278967"></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_provider_fix_dialog_ok_button" msgid="9026666001835079126">"Rregulloje këtë"</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_time_zone_detection_auto_is_on" msgid="8797434659844659323">"Vendndodhja mund të përdoret për të caktuar brezin orar"</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="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_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_pattern_description" msgid="6808109256008481046">"Për më shumë siguri, cakto një motiv për shkyçjen e pajisjes"</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 rezervë"</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="7401165571170203743">"Vizato motivin për të vazhduar"</string>
    <string name="lockpassword_confirm_your_pin_generic" msgid="8990266101852808091">"Fut kodin PIN për të vazhduar"</string>
    <string name="lockpassword_confirm_your_password_generic" msgid="8823867445451497224">"Fut fjalëkalimin për të vazhduar"</string>
    <string name="lockpassword_confirm_your_pattern_generic_profile" msgid="7003851856761939690">"Vizato motivin e 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_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_remote_validation_header" msgid="4992647285784962073">"Verifiko që je ti"</string>
    <string name="lockpassword_remote_validation_pattern_details" msgid="4655537780358707983">"Për të transferuar \"Llogaritë e Google\", cilësimet dhe të tjera, fut motivin e pajisjes tjetër. Motivi yt është i enkriptuar."</string>
    <string name="lockpassword_remote_validation_pin_details" msgid="2373654227583206297">"Për të transferuar \"Llogaritë e Google\", cilësimet dhe të tjera, fut kodin PIN të pajisjes tjetër. Kodi yt PIN është i enkriptuar."</string>
    <string name="lockpassword_remote_validation_password_details" msgid="3482328925925888340">"Për të transferuar \"Llogaritë e Google\", cilësimet dhe të tjera, fut fjalëkalimin e pajisjes tjetër. Fjalëkalimi yt është i enkriptuar."</string>
    <string name="lockpassword_remote_validation_set_pattern_as_screenlock" msgid="7595104317648465901">"Përdor motivin për të shkyçur pajisjen"</string>
    <string name="lockpassword_remote_validation_set_pin_as_screenlock" msgid="509672303005547218">"Përdor PIN-in për të shkyçur këtë pajisje"</string>
    <string name="lockpassword_remote_validation_set_password_as_screenlock" msgid="2066701840753591922">"Përdor fjalëkalimin për të shkyçur pajisjen"</string>
    <string name="lockpassword_confirm_repair_mode_pattern_header" msgid="6669435143987988314">"Verifiko motivin"</string>
    <string name="lockpassword_confirm_repair_mode_pin_header" msgid="2585263648322879131">"Verifiko kodin PIN"</string>
    <string name="lockpassword_confirm_repair_mode_password_header" msgid="3064676176428495228">"Verifiko fjalëkalimin"</string>
    <string name="lockpassword_confirm_repair_mode_pattern_details" msgid="6187536224419477465">"Përdor motivin e pajisjes për të vazhduar"</string>
    <string name="lockpassword_confirm_repair_mode_pin_details" msgid="203022189107305807">"Fut kodin PIN të pajisjes për të vazhduar"</string>
    <string name="lockpassword_confirm_repair_mode_password_details" msgid="4860219600771003873">"Fut fjalëkalimin e pajisjes për të vazhduar"</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="work_challenge_emergency_button_text" msgid="5529942788380505927">"Urgjenca"</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_enhanced_pin_privacy_title" msgid="7172693275721931683">"Privatësi e përmirësuar e kodit PIN"</string>
    <string name="lockpattern_settings_enhanced_pin_privacy_summary" msgid="8639588868341114740">"Çaktivizo animacionet ndërsa fut kodin PIN"</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="applications_settings" msgid="1941993743933425622">"Informacioni mbi aplikacionin"</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>
    <string name="see_all_apps_title" msgid="1650653853942381797">"{count,plural, =1{Shiko të gjitha aplikacionet}other{Shiko të # aplikacionet}}"</string>
    <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="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>
    <string name="uri_permissions_text" msgid="8406345863117405105">"{count,plural, =1{1 artikull}other{# artikuj}}"</string>
    <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="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ë shpeshtat"</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="8550782670650158299">"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>"Kufizimet e lejeve"</li>\n<li>"Cilësimet e përdorimit të baterisë"</li>\n\n"Nuk do të humbasësh asnjë të dhënë të aplikacionit."</string>
    <string name="reset_app_preferences_button" msgid="2591318711372850058">"Rivendos aplikacionet"</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="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_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="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="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_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_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="storageuse_settings_title" msgid="3125650750657988194">"Përdorimi i hapësirës ruajtëse"</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="language_input_gesture_title" msgid="3292455685728572960">"Gjuhët, hyrja dhe gjestet"</string>
    <string name="language_settings" msgid="8700174277543875046">"Gjuhët dhe metodat e hyrjes"</string>
    <string name="languages_settings" msgid="5784775502251770671">"Gjuhët"</string>
    <string name="keyboard_settings" msgid="184185708597386454">"Tastiera"</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="system_language" msgid="1146762166579643257">"Gjuhët e sistemit"</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_options_category" msgid="8040137073401152608">"Opsionet"</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="5979507677602559203">"Shfaq listën e shkurtoreve"</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="keyboard_default_layout" msgid="5377811770620422301">"Parazgjedhja"</string>
    <string name="trackpad_settings" msgid="2071131324087677005">"Blloku me prekje"</string>
    <string name="trackpad_mouse_settings" msgid="136226693583218429">"Blloku me prekje dhe miu"</string>
    <string name="trackpad_settings_summary" msgid="3369855644136760402">"Shpejtësia e treguesit, gjestet"</string>
    <string name="trackpad_tap_to_click" msgid="1938230946542070746">"Trokit për të klikuar"</string>
    <string name="trackpad_touchpad_gesture_title" msgid="7568052847609914436">"Gjestet e bllokut me prekje"</string>
    <string name="trackpad_touchpad_gesture_summary" msgid="6256074591395359124">"Personalizo gjestet individuale të navigimit me bllokun me prekje"</string>
    <string name="trackpad_reverse_scrolling_title" msgid="422877284529360866">"Lëvizja në të kundërt"</string>
    <string name="trackpad_reverse_scrolling_summary" msgid="6048648562887499036">"Përmbajtja zhvendoset lart kur ti lëviz poshtë"</string>
    <string name="trackpad_bottom_right_tap_title" msgid="6275428879042702880">"Trokitja poshtë djathtas"</string>
    <string name="trackpad_bottom_right_tap_summary" msgid="8734094086900680674">"Trokit te këndi poshtë djathtas i bllokut me prekje për më shumë opsione"</string>
    <string name="trackpad_pointer_speed" msgid="7786579408631352625">"Shpejtësia e treguesit"</string>
    <string name="trackpad_touch_gesture" msgid="8641725062131922497">"Mëso gjestet e bllokut me prekje"</string>
    <string name="gesture_title_go_home" msgid="3682238648647225933">"Shko tek ekrani bazë"</string>
    <string name="gesture_summary_go_home" msgid="6409031586904205741">"Rrëshqit lart me tre gishta kudo në bllokun tënd me prekje"</string>
    <string name="gesture_title_go_back" msgid="6619462058488419802">"Kthehu prapa"</string>
    <string name="gesture_summary_go_back" msgid="4981604277892236888">"Rrëshqit shpejt nga e majta në të djathtë me tre gishta"</string>
    <string name="gesture_title_recent_apps" msgid="6082688963233208761">"Shiko aplikacionet e fundit"</string>
    <string name="gesture_summary_recent_apps" msgid="6643179135202417509">"Rrëshqit lart me tre gishta, mbaj shtypur e më pas lësho"</string>
    <string name="gesture_title_notifications" msgid="791717222472350194">"Njoftimet dhe \"Cilësimet e shpejta\""</string>
    <string name="gesture_summary_notifications" msgid="8419514601638387255">"Rrëshqit shpejt poshtë me tre gishta në ekranin bazë"</string>
    <string name="gesture_title_switch_apps" msgid="5840994412037872157">"Ndërro aplikacionet"</string>
    <string name="gesture_summary_switch_apps" msgid="6842648062151413042">"Rrëshqit shpejt majtas ose djathtas me katër gishta"</string>
    <string name="gesture_button_skip" msgid="5174842083451193213">"Anashkalo"</string>
    <string name="gesture_button_next" msgid="695288092704187356">"Tjetra"</string>
    <string name="gesture_button_restart" msgid="1895850891992530133">"Rinis"</string>
    <string name="gesture_button_done" msgid="6387900351203032188">"U krye"</string>
    <string name="trackpad_go_back_title" msgid="5312164160947491440">"Kthehu prapa"</string>
    <string name="trackpad_go_back_summary" msgid="4201901101085902768">"Rrëshqit shpejt majtas ose djathtas me tre gishta"</string>
    <string name="trackpad_go_home_title" msgid="2146525662148291552">"Shko tek ekrani bazë"</string>
    <string name="trackpad_go_home_summary" msgid="2222744701528360887">"Rrëshqit shpejt lart me tre gishta"</string>
    <string name="trackpad_recent_apps_title" msgid="8195970908411585445">"Aplikacionet e fundit"</string>
    <string name="trackpad_recent_apps_summary" msgid="2685092851677573794">"Rrëshqit shpejt lart me tre gishta dhe më pas mbaje shtypur"</string>
    <string name="trackpad_notifications_title" msgid="3521663305043747880">"Njoftimet"</string>
    <string name="trackpad_notifications_summary" msgid="7663647367648690040">"Rrëshqit shpejt poshtë me tre gishta"</string>
    <string name="trackpad_switch_apps_title" msgid="7342032935377284039">"Ndërro aplikacionet"</string>
    <string name="trackpad_switch_apps_summary" msgid="9193942041912927440">"Rrëshqit shpejt majtas ose djathtas me katër gishta"</string>
    <string name="modifier_keys_settings" msgid="2537108435032034683">"Çelësat modifikues"</string>
    <string name="modifier_keys_settings_summary" msgid="6933143361657444436">"Ndrysho sjelljen e çelësave"</string>
    <string name="modifier_keys_reset_title" msgid="948294258402761066">"Rivendosi të gjitha"</string>
    <string name="modifier_keys_default_summary" msgid="8701640508670973258">"Parazgjedhja"</string>
    <string name="modifier_keys_reset_message" msgid="5236994817619936058">"E konfirmon që dëshiron t\'i rivendosësh të gjithë çelësat modifikues te parazgjedhja e tyre?"</string>
    <string name="modifier_keys_done" msgid="8196199314913909700">"U krye"</string>
    <string name="modifier_keys_cancel" msgid="7136520252570826772">"Anulo"</string>
    <string name="modifier_keys_reset" msgid="551170906710422041">"Rivendos"</string>
    <string name="modifier_keys_picker_title" msgid="244545904150587851">"Zgjidh tastin modifikues"</string>
    <string name="modifier_keys_picker_summary" msgid="739397232249560785">"Zgjidh një çelës të ri për <xliff:g id="MODIFIER_KEY_DEFAULT_NAME">%1$s</xliff:g>:"</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="keyboard_layout_picker_category_title" msgid="2369473692906329772">"Strukturat e tastierës fizike"</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="keyboard_settings_summary" msgid="9188442758316476986">"Tastiera në ekran, veglat"</string>
    <string name="keyboard_settings_with_physical_keyboard_summary" msgid="2240779804018260938">"Tastiera në ekran, tastiera fizike, veglat"</string>
    <string name="builtin_keyboard_settings_title" msgid="5096171620714179661">"Tastiera fizike"</string>
    <string name="enabled_locales_keyboard_layout" msgid="3939886151098958639">"Struktura"</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="testing_usage_stats" msgid="4660643799010906365">"Statistikat e përdorimit"</string>
    <string name="usage_stats_sort_by_usage_time" msgid="2927310334119998301">"Rendit sipas kohës së përdorimit"</string>
    <string name="usage_stats_sort_by_last_time_used" msgid="7039213339779884017">"Rendit sipas herës së fundit të përdorimit"</string>
    <string name="usage_stats_sort_by_app_name" msgid="4463833145514850478">"Rendit sipas emrit të aplikacionit"</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="bt_hci_snoop_log_filters_dashboard_title" msgid="401330708633716596">"Filtrimi i identifikimit të përgjimit të Bluetooth HCI"</string>
    <string name="bt_hci_snoop_log_filters_dashboard_summary" msgid="1319792184194176235">"Cakto filtrat"</string>
    <string name="bt_hci_snoop_log_filters_dashboard_footer" msgid="4158945851818483666">"Çaktivizo dhe aktivizo Bluetooth që ndryshimet të zbatohen"</string>
    <string name="bt_hci_snoop_log_filter_pbap_title" msgid="1735427364451634823">"Filtrimi i PBAP-së së identifikimit të përgjimit të Bluetooth HCI"</string>
    <string name="bt_hci_snoop_log_filter_map_title" msgid="180092480793945544">"Filtrimi i hartës së identifikimit të përgjimit të Bluetooth HCI"</string>
    <string name="bt_hci_snoop_log_filter_summary" msgid="7217091930762522599">"Cakto modalitetin e filtrimit. (Çaktivizo dhe aktivizo Bluetooth që ndryshimet të zbatohen)"</string>
    <string name="bt_hci_snoop_log_filtered_mode_disabled_summary" msgid="8824952559433361848">"Cakto modalitetin e identifikimit të përgjimit të Bluetooth HCI në filtrim aktiv për ta ndryshuar"</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_always_on_title" msgid="3814297443759580936">"Mbaje aktive ndërkohë që ndërron aplikacionet"</string>
    <string name="accessibility_screen_magnification_always_on_summary" msgid="306908451430863049">"Zmadhuesi qëndron aktiv dhe zvogëlohet kur ndërron aplikacionet"</string>
    <string name="accessibility_screen_magnification_joystick_title" msgid="1803769708582404964">"Leva e kontrollit"</string>
    <string name="accessibility_screen_magnification_joystick_summary" msgid="4640300148573982720">"Aktivizo dhe lëviz zmadhuesin me një levë kontrolli në ekran. Trokit dhe mbaj, më pas zvarrit levën e kontrollit për të kontrolluar zmadhuesin. Trokit dhe zvarrit për të lëvizur vetë levën e kontrollit."</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_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_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_two_finger_triple" msgid="1090593773487065541">"Trokit tri herë me dy gishta në ekran për të 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_two_finger_triple" msgid="6205072282308562361">"Për të filluar dhe ndaluar zmadhimin, trokit tri herë me dy gishta 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_tutorial_dialog_link_button" msgid="6797349445794031781">"Cilësimet e butonit"</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 shtypur tastet e volumit"</string>
    <string name="accessibility_shortcut_hardware_keyword" msgid="3921915304537166064">"mbaj shtypur tastet e volumit"</string>
    <string name="accessibility_shortcut_edit_dialog_summary_hardware" msgid="2503134386397991634">"Shtyp dhe mbaj shtypur të dyja tastet e volumit"</string>
    <string name="accessibility_shortcut_edit_dialog_title_two_finger_triple_tap" msgid="6687765191490040899">"Trokit tri herë me dy gishta në ekran"</string>
    <string name="accessibility_shortcut_two_finger_triple_tap_keyword" msgid="4200744613585702430">"trokit tri herë me dy gishta në ekran"</string>
    <string name="accessibility_shortcut_edit_dialog_summary_two_finger_triple_tap" msgid="2631127444247448793">"Trokit shpejt {0,number,integer} herë me dy gishta në ekran"</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_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="1141723096904904336">"&lt;b&gt;Për të filluar&lt;/b&gt;&lt;br/&gt; {0,number,integer}. Shko te cilësimet e qasshmërisë&lt;br/&gt; {1,number,integer}. Zgjidh një veçori dhe trokit shkurtoren&lt;br/&gt; {2,number,integer}. Zgjidh nëse dëshiron të përdorësh një buton ose gjest për t\'u qasur te veçoria&lt;br/&gt;"</string>
    <string name="accessibility_button_description" msgid="7669538706120092399">"&lt;b&gt;Për të filluar&lt;/b&gt;&lt;br/&gt; {0,number,integer}. Shko te cilësimet e qasshmërisë&lt;br/&gt; {1,number,integer}. Zgjidh një veçori dhe trokit shkurtoren&lt;br/&gt; {2,number,integer}. Zgjidh butonin për t\'u qasur te veçoria&lt;br/&gt;"</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 në 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_action_label_panel_slice" msgid="1313725957071602932">"futur cilësimet"</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_keyboard_vibration_title" msgid="7559967730626765441">"Dridhja e tastierës"</string>
    <string name="accessibility_ring_vibration_title" msgid="4689811297654320885">"Dridhja e ziles"</string>
    <string name="accessibility_notification_vibration_title" msgid="6205679908785776478">"Dridhja e njoftimit"</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_font_scaling_auto_added_qs_tooltip_content" msgid="7229921960884718332">"Madhësia e fontit u shtua te \"Cilësimet e shpejta\". Rrëshqit shpejt poshtë për të ndryshuar madhësinë e fontit në çdo kohë."</string>
    <string name="accessibility_quick_settings_tooltip_dismiss" msgid="3269120277643884190">"Hiq"</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_captioning_primary_switch_title" msgid="3663677340286206100">"Shfaq titrat"</string>
    <string name="accessibility_captioning_primary_switch_summary" msgid="2544094070306830218">"Vetëm për aplikacionet e mbështetura"</string>
    <string name="captioning_appearance_title" msgid="3128792092290011408">"Madhësia dhe stili i titrave"</string>
    <string name="captioning_appearance_summary" msgid="4620682807315588019">"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_captioning_preference_intro" msgid="8995427146374031134">"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_captioning_preference_summary" msgid="8335768472978374255">"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="1263619711863375614">"Pajisjet e dëgjimit"</string>
    <string name="accessibility_hearingaid_intro" msgid="5856992709195963850">"Mund të përdorësh aparate dëgjimi, impiante kokleare dhe pajisje të tjera për amplifikimin e zërit me telefonin tënd"</string>
    <string name="accessibility_hearingaid_not_connected_summary" msgid="7438018718889849521">"Nuk ka pajisje dëgjimi të lidhura"</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>
    <string name="accessibility_hearing_device_pairing_title" msgid="2701812183769537320">"Çifto pajisjen e re"</string>
    <string name="accessibility_pair_hearing_device_about_title" msgid="5870335480815052755">"Rreth \"Çifto një pajisje të re\""</string>
    <string name="accessibility_hearing_device_connected_title" msgid="3785140037249487287">"Pajisjet e dëgjimit"</string>
    <string name="accessibility_hearing_device_saved_title" msgid="7573926212664909296">"Pajisjet e ruajtura"</string>
    <string name="accessibility_hearing_device_control" msgid="2661965917013100611">"Kontrollet e pajisjes së dëgjimit"</string>
    <string name="accessibility_hearing_device_shortcut_title" msgid="7645100199603031360">"Shkurtorja e pajisjes së dëgjimit"</string>
    <string name="accessibility_hac_mode_title" msgid="2037950424429555652">"Përputhshmëria me aparate dëgjimi"</string>
    <string name="accessibility_hac_mode_summary" msgid="5198760061256669067">"Përmirëson përputhshmërinë me kapësit e tingujve dhe redukton zhurmën e padëshiruar"</string>
    <string name="accessibility_hearing_device_about_title" msgid="7883758309646288250">"Rreth pajisjeve të dëgjimit"</string>
    <string name="accessibility_hearing_device_footer_summary" msgid="7451899224828040581">"Sigurohu që pajisja jote e dëgjimit të jetë e aktivizuar dhe gati për çiftim"</string>
    <string name="accessibility_hearing_device_pairing_page_title" msgid="6608901091770850295">"Çifto pajisjet e dëgjimit"</string>
    <string name="accessibility_found_hearing_devices" msgid="637407580358386553">"Pajisjet e dëgjimit që ofrohen"</string>
    <string name="accessibility_found_all_devices" msgid="7817834722148556520">"Nuk e sheh pajisjen tënde të dëgjimit?"</string>
    <string name="accessibility_list_all_devices_title" msgid="161495343959211216">"Shiko pajisje të tjera"</string>
    <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_intro_text" msgid="3502290826747650566">"Bëje ekranin më të zbehtë për ta bërë leximin më komod"</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>
    <string name="accessibilty_autoclick_preference_subtitle_short_delay" msgid="2981206111858937724">"{count,plural, =1{E shkurtër ({time} sekondë)}other{E shkurtër ({time} sekonda)}}"</string>
    <string name="accessibilty_autoclick_preference_subtitle_medium_delay" msgid="6867395206533459204">"{count,plural, =1{Mesatare ({time} sekondë)}other{Mesatare ({time} sekonda)}}"</string>
    <string name="accessibilty_autoclick_preference_subtitle_long_delay" msgid="4079139970819335593">"{count,plural, =1{E gjatë ({time} sekondë)}other{E gjatë ({time} sekonda)}}"</string>
    <string name="accessibilty_autoclick_delay_unit_second" msgid="5979297390686370567">"{count,plural, =1{{time} sekondë}other{{time} sekonda}}"</string>
    <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">"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">"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="8593989878379366798">"shikimi, dëgjimi, i verbër, i shurdhër, motorik, shkathtësi, ndihmëse, ndihmë, lehtësi përdorimi, lehtësi qasjeje, dorë, ndihmë"</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_contrast" msgid="4668393735398949873">"kontrasti i ngjyrës"</string>
    <string name="keywords_accessibility_menu" msgid="4300579436464706608"></string>
    <string name="keywords_switch_access" msgid="5813094504384313402"></string>
    <string name="keywords_auto_click" msgid="6811744211216280998">"motorik, mi, mi i jashtëm, mi me kokë, mi me përshtatje, karrige me rrota, levë kontrolli"</string>
    <string name="keywords_hearing_aids" msgid="4657889873249157071">"aparate dëgjimi, vështirësi në dëgjim, humbje e dëgjimit, impiante kokleare, pajisje për amplifikimin e zërit, përpunues të zërit, PSAP"</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="keywords_3_button_navigation" msgid="436361965016404218">"tri butona"</string>
    <string name="keywords_touch_and_hold_delay" msgid="7854640156419599912">"shkathtësi, motorik, i moshuar, artrit, rsi, goditje në tru, dridhje, sklerozë multiple, paralizë cerebrale, dridhje, lëndim nga sforcim i përsëritur, dorë"</string>
    <string name="keywords_accessibility_timeout" msgid="8903766864902000346">"vonesë, shkathtësi, i moshuar"</string>
    <string name="print_settings" msgid="8519810615863882491">"Printimi"</string>
    <string name="print_settings_summary_no_service" msgid="6721731154917653862">"Joaktive"</string>
    <string name="print_settings_summary" msgid="1458773840720811915">"{count,plural, =1{1 shërbim aktiv printimi}other{# shërbime aktive printimi}}"</string>
    <string name="print_jobs_summary" msgid="7040836482336577323">"{count,plural, =1{1 punë printimi}other{# punë printimi}}"</string>
    <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_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="power_usage_detail_screen_time" msgid="6027274749498485283">"Koha para ekranit"</string>
    <string name="power_usage_detail_background_time" msgid="3661437083554322691">"Koha në sfond"</string>
    <string name="low_battery_summary" msgid="4458925347316501953">"Bateria në nivel të ulët"</string>
    <string name="background_activity_summary" msgid="3817376868497046016">"Lejo që aplikacioni të ekzekutohet në sfond"</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_category_title" msgid="1493303237531629961">"Menaxho përdorimin e baterisë"</string>
    <string name="manager_battery_usage_allow_background_usage_title" msgid="6294649996820358852">"Lejo përdorimin në sfond"</string>
    <string name="manager_battery_usage_allow_background_usage_summary" msgid="8021153755201340819">"Aktivizo për përditësime në kohë reale; çaktivizo për të kursyer bateri"</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="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="2372763700477268393">"Shiko përdorimin që nga karikimi i fundit i plotë"</string>
    <string name="battery_details_title" msgid="3289680399291090588">"Përdorimi i baterisë për aplikacionet"</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_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="6613079613524512257">"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="6258554134146272311">"Karikimi u optimizua për të mbrojtur baterinë tënde"</string>
    <string name="battery_tip_limited_temporarily_summary" msgid="5107379280241187562">"Për të ndihmuar në zgjatjen e jetëgjatësisë së baterisë sate, është optimizuar karikimi"</string>
    <string name="battery_tip_dock_defender_future_bypass_title" msgid="4332616280495788195">"Karikimi u optimizua për të mbrojtur baterinë tënde"</string>
    <string name="battery_tip_dock_defender_future_bypass_summary" msgid="7870758621381307597">"Për të ndihmuar në zgjatjen e jetëgjatësisë së baterisë sate, karikimi është i optimizuar gjatë lidhjes me stacionin"</string>
    <string name="battery_tip_dock_defender_active_title" msgid="1414785238383255699">"Karikimi u optimizua për të mbrojtur baterinë tënde"</string>
    <string name="battery_tip_dock_defender_active_summary" msgid="3512082623718801459">"Për të ndihmuar në zgjatjen e jetëgjatësisë së baterisë sate, karikimi është i optimizuar gjatë lidhjes me stacionin"</string>
    <string name="battery_tip_dock_defender_temporarily_bypassed_title" msgid="1679449361090557201">"Po karikohet plotësisht"</string>
    <string name="battery_tip_dock_defender_temporarily_bypassed_summary" msgid="1099500476761333281">"Për të mbrojtur baterinë tënde, karikimi do të optimizohet herën tjetër kur tableti yt të jetë i lidhur me stacionin"</string>
    <string name="battery_tip_limited_temporarily_sec_button_content_description" msgid="5648444926736883551">"Mëso më shumë rreth vendosjes së karikimit në pauzë"</string>
    <string name="battery_tip_limited_temporarily_dialog_resume_charge" msgid="2302295458913832342">"Vazhdo karikimin"</string>
    <string name="battery_tip_dialog_message_footer" msgid="986542164372177504">"Përfshin aktivitetin me nivel të lartë të energjisë në sfond"</string>
    <string name="battery_tip_restrict_title" msgid="4537101947310626753">"{count,plural, =1{Kufizo # aplikacion}other{Kufizo # aplikacione}}"</string>
    <string name="battery_tip_restrict_handled_title" msgid="7142074986508706853">"{count,plural, =1{{label} i kufizuar së fundi}other{# aplikacione të kufizuara së fundi}}"</string>
    <string name="battery_tip_restrict_summary" msgid="7539469590829235277">"{count,plural, =1{{label} ka përdorim të lartë të baterisë në sfond}other{# aplikacione kanë përdorim të lartë të baterisë në sfond}}"</string>
    <string name="battery_tip_restrict_handled_summary" msgid="3535697154547199190">"{count,plural, =1{Ky aplikacion nuk mund të ekzekutohet në sfond}other{Këto aplikacione nuk mund të ekzekutohen në sfond}}"</string>
    <string name="battery_tip_restrict_app_dialog_title" msgid="1649476357343160240">"{count,plural, =1{Të kufizohet aplikacioni?}other{Të kufizohen # aplikacione?}}"</string>
    <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_charge_to_full_button" msgid="6701709034348116261">"Karikoje plotësisht"</string>
    <string name="battery_tip_incompatible_charging_title" msgid="5120763575150751300">"Problem me aksesorin e karikimit"</string>
    <string name="battery_tip_incompatible_charging_content_description" msgid="355668467640367701">"Mëso më shumë për karikimin e papërputhshëm"</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_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>
    <string name="restricted_app_summary" msgid="1022307922754893997">"{count,plural, =1{Po kufizohet përdorimi i baterisë për # aplikacion}other{Po kufizohet përdorimi i baterisë për # aplikacione}}"</string>
    <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_app_restricted" msgid="2583902700677009173">"{count,plural, =1{# aplikacion i kufizuar}other{# aplikacione të kufizuara}}"</string>
    <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="power_screen" msgid="4596900105850963806">"Ekrani"</string>
    <string name="power_cpu" msgid="1820472721627148746">"CPU"</string>
    <string name="power_flashlight" msgid="8993388636332573202">"Blici"</string>
    <string name="power_camera" msgid="4778315081581293923">"Kamera"</string>
    <string name="power_gps" msgid="6352380895542498164">"GPS"</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="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="6753248007004259000">"Kohëzgjatja e mbetur e baterisë është e përafërt dhe mund të ndryshojë sipas përdorimit"</string>
    <string name="battery_detail_power_usage" msgid="1492926471397355477">"Përdorimi i baterisë"</string>
    <string name="battery_not_usage" msgid="3851536644733662392">"Pa përdorim që 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="battery_usage_since_last_full_charge" msgid="3488425008925924769">"që nga karikimi i fundit i plotë"</string>
    <string name="battery_usage_system_apps" msgid="8659537819731575299">"Aplikacionet e sistemit"</string>
    <string name="battery_usage_uninstalled_apps" msgid="8170405012552803662">"Aplikacionet e çinstaluara"</string>
    <string name="battery_usage_others" msgid="311793281613609986">"Të tjera"</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="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_title_percentage" msgid="1178162022087559148">"Çaktivizoje në <xliff:g id="BATTERY_PERCENTAGE">%1$s</xliff:g>"</string>
    <string name="battery_saver_sticky_description_new" msgid="6472610662679038342">"\"Kursyesi i baterisë\" çaktivizohet kur bateria arrin <xliff:g id="BATTERY_PERCENTAGE">%1$s</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_last_full_charge" msgid="6570336408060566877">"Niveli i baterisë që nga karikimi i fundit i plotë"</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" msgid="8976453608783133770">"Përdorimi i aplikacioneve që nga karikimi i fundit i plotë"</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" msgid="1395943945140097585">"Përdorimi i sistemit që nga karikimi i fundit i plotë"</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_system_usage_since_last_full_charge_to" msgid="4196795733829841971">"Përdorimi i sistemit që nga karikimi i fundit i plotë deri në <xliff:g id="SLOT_TIMESTAMP">%s</xliff:g>"</string>
    <string name="battery_app_usage_since_last_full_charge_to" msgid="4339201995118102114">"Përdorimi i aplikacionit që nga karikimi i fundit i plotë deri në <xliff:g id="SLOT_TIMESTAMP">%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_screen_time_less_than_one_minute" msgid="2911989465891679033">"Koha para ekranit: më pak se një minutë"</string>
    <string name="power_usage_time_less_than_one_minute" msgid="8407404329381010144">"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_time" msgid="3973865893520804115">"Koha para ekranit: <xliff:g id="TIME">%s</xliff:g>"</string>
    <string name="battery_usage_screen_footer_empty" msgid="3301144846133808193">"Të dhënat e përdorimit të baterisë do të ofrohen pas disa orësh pasi të karikohet plotësisht"</string>
    <string name="battery_usage_chart_label_now" msgid="4598282721949430165">"tani"</string>
    <string name="battery_usage_timestamps_hyphen" msgid="7401188432989043905">"<xliff:g id="FROM_TIMESTAMP">%1$s</xliff:g> - <xliff:g id="TO_TIMESTAMP">%2$s</xliff:g>"</string>
    <string name="battery_usage_day_and_hour" msgid="1417890420844950881">"<xliff:g id="DAY">%1$s</xliff:g> <xliff:g id="HOUR">%2$s</xliff:g>⁠"</string>
    <string name="battery_usage_chart" msgid="4114747521432440017">"Grafiku i përdorimit të baterisë"</string>
    <string name="daily_battery_usage_chart" msgid="4176059567682992686">"Grafiku i përdorimit të baterisë për çdo ditë"</string>
    <string name="hourly_battery_usage_chart" msgid="3098314511076561272">"Grafiku i përdorimit të baterisë për çdo orë"</string>
    <string name="battery_usage_breakdown_title_since_last_full_charge" msgid="435006273323199906">"Përdorimi i baterisë që nga karikimi i fundit i plotë"</string>
    <string name="battery_usage_breakdown_title_for_slot" msgid="4823179483667671406">"Përdorimi i baterisë për <xliff:g id="SLOT">%s</xliff:g>"</string>
    <string name="screen_time_category_last_full_charge" msgid="8856908320256057753">"Koha para ekranit që nga karikimi i fundit i plotë"</string>
    <string name="screen_time_category_for_slot" msgid="8287722270554654959">"Koha para ekranit për <xliff:g id="SLOT">%s</xliff:g>"</string>
    <string name="battery_usage_spinner_view_by_apps" msgid="8769276544072098082">"Pamja sipas aplikacioneve"</string>
    <string name="battery_usage_spinner_view_by_systems" msgid="7904104223212160541">"Pamja sipas sistemeve"</string>
    <string name="battery_usage_less_than_percent" msgid="5873099028895001082">"&lt; <xliff:g id="PERCENTAGE">%1$s</xliff:g>"</string>
    <string name="battery_cycle_count_footer" msgid="3642121059800373545">"Për shkak të inspektimeve të cilësisë para transportit, numri i cikleve mund të mos jetë zero në përdorimin e parë"</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="on_device_recognition_settings" msgid="6503160369314598069">"Cilësimet e njohjes në pajisje"</string>
    <string name="on_device_recognition_settings_title" msgid="7137599722039096545">"Njohja në pajisje"</string>
    <string name="on_device_recognition_settings_summary" msgid="3292736423223499348">"Njohja e ligjërimit në pajisje"</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="adaptive_connectivity_main_switch_title" msgid="261045483524512420">"Përdor lidhshmërinë me përshtatje"</string>
    <string name="credentials_title" msgid="7535942196886123656">"Ruajtja e kredencialeve"</string>
    <string name="credentials_install" msgid="3933218407598415827">"Instalo një certifikatë"</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="2286560570630763556">"Instaluar për Wi-Fi"</string>
    <string name="credential_for_wifi_in_use" msgid="7276290656840986618">"Instaluar për Wi‑Fi (në përdorim)"</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 uebsajtet, 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 uebsajtet 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 ndarë 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>
    <string name="number_of_urls" msgid="1128699121050872188">"{count,plural, =1{# URL}other{# URL}}"</string>
    <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="6081829638548808795">"%d 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>
    <string name="notification_history_count" msgid="885305572972482838">"{count,plural, =1{# njoftim}other{# njoftime}}"</string>
    <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="4687734487641548872">"Aplikacionet e punës"</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_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="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="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="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="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="account_settings_menu_auto_sync_private" msgid="2315144351530596228">"Sinkronizo të dhënat private"</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_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_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="wifi_metered_title" msgid="6623732965268033931">"Përdorimi i rrjetit"</string>
    <string name="data_usage_metered_yes" msgid="4262598072030135223">"Me matje"</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_being_used_by" msgid="3682869943025283499">"Po përdoret nga"</string>
    <string name="credential_contains" msgid="3146519680449595771">"Ky regjistrim përmban"</string>
    <string name="one_userkey" msgid="6363426728683951234">"1 çelës përdoruesi"</string>
    <string name="one_usercrt" msgid="2097644070227688983">"1 certifikatë përdoruesi"</string>
    <string name="one_cacrt" msgid="982242103604501559">"1 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>
    <string name="ssl_ca_cert_dialog_title" msgid="1032088078702042090">"{count,plural, =1{Beso ose hiq certifikatën}other{Beso ose hiqi certifikatat}}"</string>
    <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>
    <string name="ssl_ca_cert_settings_button" msgid="2044927302268394991">"{count,plural, =1{Kontrollo certifikatën}other{Kontrollo certifikatat}}"</string>
    <string name="user_settings_title" msgid="6550866465409807877">"Disa përdorues"</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_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ërdorues nga ekrani i kyçjes"</string>
    <string name="switch_to_dock_user_when_docked" msgid="2324395443311905635">"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_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="guest_category_title" msgid="5562663588315329152">"Vizitor (ti)"</string>
    <string name="user_category_title" msgid="4368580529662699083">"Përdoruesit"</string>
    <string name="other_user_category_title" msgid="7089976887307643217">"Përdorues të tjerë"</string>
    <string name="remove_guest_on_exit" msgid="8202972371459611066">"Fshi aktivitetin e vizitorit"</string>
    <string name="remove_guest_on_exit_summary" msgid="3969962695703280353">"Fshi të gjitha aplikacionet dhe të dhënat e vizitorit kur del nga modaliteti \"vizitor\""</string>
    <string name="remove_guest_on_exit_dialog_title" msgid="2310442892536079416">"Të fshihet aktiviteti i vizitorit?"</string>
    <string name="remove_guest_on_exit_dialog_message" msgid="8112409834021851883">"Tani aplikacionet dhe të dhënat nga ky sesion për vizitorë do të fshihen dhe të gjitha aktivitetet e ardhshme të vizitorit do të fshihen sa herë që të dalësh nga modaliteti \"vizitor\""</string>
    <string name="remove_guest_on_exit_keywords" msgid="4961310523576166193">"fshi, vizitor, aktivitet, hiq, të dhëna, i ftuar, spastro"</string>
    <string name="enable_guest_calling" msgid="4620657197834392094">"Lejo vizitorin të bëjë telefonata"</string>
    <string name="enable_guest_calling_summary" msgid="4748224917641204782">"Historiku i telefonatave do të ndahet me këtë përdorues vizitor"</string>
    <string name="user_enable_calling_sms" msgid="8546430559552381324">"Aktivizo telefonatat dhe SMS-të"</string>
    <string name="user_grant_admin" msgid="5942118263054572074">"Bëje administrator këtë përdorues"</string>
    <string name="user_remove_user" msgid="8468203789739693845">"Fshi përdoruesin"</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="user_revoke_admin_confirm_title" msgid="3057842401861731863">"Të hiqen privilegjet e administratorit?"</string>
    <string name="user_revoke_admin_confirm_message" msgid="9207187319308572958">"Nëse i heq privilegjet e administratorit për këtë përdorues, ti ose një administrator tjetër mund t\'ia kthesh ato përsëri më vonë."</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="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 një aplikacion për pagesa, mbaje pjesën e pasme të pajisjes te një terminal 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="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="cell_broadcast_settings" msgid="2416980110093867199">"Sinjalizimet wireless 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="auto_data_switch_title" msgid="5862200603753603464">"Ndërro automatikisht të dhënat celulare"</string>
    <string name="auto_data_switch_summary" msgid="1934340931995429057">"Përdor këtë rrjet kur të ketë disponueshmëri më të mirë"</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_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_back_adoptable" msgid="1447814356855134183">"Formatoje në një mënyrë tjetër"</string>
    <string name="regulatory_info_text" msgid="1154461023369976667"></string>
    <string name="sim_settings_title" msgid="2254609719033946272">"Kartat SIM"</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_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="color_orange" msgid="216547825489739010">"Portokalli"</string>
    <string name="color_purple" msgid="6603701972079904843">"Vjollcë"</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_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="2819551384383504031">"Kartat SIM u ndryshuan."</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>
    <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-i, ç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_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="cloned_apps_dashboard_title" msgid="5542076801222950921">"Aplikacione të klonuara"</string>
    <string name="desc_cloned_apps_intro_text" msgid="1369621522882622476">"Krijo një shembull të dytë të një aplikacioni në mënyrë që të mund të përdorësh dy llogari në të njëjtën kohë."</string>
    <string name="desc_cloneable_app_list_text" msgid="3354586725814708688">"Aplikacione që mund të klonohen."</string>
    <string name="cloned_apps_summary" msgid="8805362440770795709">"<xliff:g id="CLONED_APPS_COUNT">%1$s</xliff:g> u klonuan, <xliff:g id="ALLOWED_APPS_COUNT">%2$d</xliff:g> ofrohen për të klonuar"</string>
    <string name="delete_all_app_clones" msgid="3489053361980624999">"Fshi të gjitha aplikacionet e klonuara"</string>
    <string name="delete_all_app_clones_failure" msgid="6821033414547132335">"Fshirja e të gjitha aplikacioneve të klonuara dështoi"</string>
    <string name="cloned_app_creation_summary" msgid="4642627294993918502">"Po krijohet…"</string>
    <string name="cloned_app_created_summary" msgid="7277912971544890710">"U klonua"</string>
    <string name="cloned_app_creation_toast_summary" msgid="3854494347144867870">"Kloni i <xliff:g id="PACKAGE_LABEL">%1$s</xliff:g> po krijohet"</string>
    <string name="cloned_app_created_toast_summary" msgid="755225403495544163">"Kloni i <xliff:g id="PACKAGE_LABEL">%1$s</xliff:g> u krijua"</string>
    <string name="system_dashboard_summary" msgid="7400745270362833832">"Gjuhët, gjestet, koha, rezervimi"</string>
    <string name="languages_setting_summary" msgid="2650807397396180351">"Gjuhët e sistemit, gjuhët e aplikacionit, preferencat rajonale, ligjërimi"</string>
    <string name="keywords_wifi" msgid="8156528242318351490">"wifi, wi-fi, lidhja e rrjetit, internet, wireless, 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_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, wireless, 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_fold_lock_behavior" msgid="6278990772113341581">"zgjuar, në gjumë, mos kyç, mbaj të shkyçur kur paloset, po paloset, po mbyllet, palos, mbyll, ekrani i fikur"</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_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="4221401945956122228">"rrjeti, gjendja e rrjetit celular, gjendja e shërbimit, fuqia e sinjalit, lloji i rrjetit celular, roaming"</string>
    <string name="keywords_sim_status_esim" msgid="3338719238556853609">"rrjeti, gjendja e rrjetit celular, gjendja e shërbimit, fuqia e sinjalit, lloji i rrjetit celular, roaming, eid"</string>
    <string name="keywords_sim_status_iccid" msgid="4775398796251969759">"rrjeti, gjendja e rrjetit celular, gjendja e shërbimit, fuqia e sinjalit, lloji i rrjetit celular, roaming, iccid"</string>
    <string name="keywords_sim_status_iccid_esim" msgid="4634015619840979184">"rrjeti, gjendja e rrjetit celular, gjendja e shërbimit, fuqia e sinjalit, lloji i rrjetit celular, roaming, iccid, eid"</string>
    <string name="keywords_esim_eid" msgid="8128175058237372457">"eid"</string>
    <string name="keywords_model_and_hardware" msgid="4723665865709965044">"numri i serisë, versioni i harduerit"</string>
    <string name="keywords_battery_info" msgid="3319796850366687033">"informacione për baterinë, data e prodhimit, numri i cikleve, përdorimi për herë të parë"</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_active_unlock_settings" msgid="4511320720304388889">"shkyçja me orë, shto shkyçjen me orë"</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="3367789885254807447">"ikona, theksimi, ngjyra, ekrani bazë, ekrani i kyçjes, shkurtorja, madhësia e orës"</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="1066752498285497595">"shfaqja e ambientit gjithmonë aktive, AOD"</string>
    <string name="keywords_change_nfc_tag_apps_state" msgid="9032287964590554366">"nfc, etiketë, lexues"</string>
    <string name="keywords_keyboard_vibration" msgid="6485149510591654697">"tastierë, prekje, dridhje,"</string>
    <string name="sound_dashboard_summary" msgid="6574444810552643312">"Volum, dridhje, \"Mos shqetëso\""</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="separate_ring_volume_option_title" msgid="2212910223857375951">"Volumi i ziles"</string>
    <string name="notification_volume_option_title" msgid="4838818791683615978">"Volumi i njoftimit"</string>
    <string name="ringer_content_description_silent_mode" msgid="1442257660889685934">"Zilja në heshtje"</string>
    <string name="ringer_content_description_vibrate_mode" msgid="5946432791951870480">"Zilja me dridhje"</string>
    <string name="notification_volume_content_description_vibrate_mode" msgid="6097212000507408288">"Volumi i njoftimeve u çaktivizua, njoftimet do të lëshojnë dridhje"</string>
    <string name="volume_content_description_silent_mode" msgid="377680514551405754">"<xliff:g id="VOLUME_TYPE">%1$s</xliff:g> është çaktivizuar"</string>
    <string name="notification_volume_disabled_summary" msgid="8679988555852056079">"Nuk ofrohet sepse ziles i është hequr zëri"</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_option_ramping_ringer" msgid="2798848945803840348">"Me dridhje në fillim e më pas zilja gradualisht"</string>
    <string name="spatial_audio_title" msgid="1775370104206884711">"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="826964355109667449">"Tinguj trokitjeje dhe klikimi"</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_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="3761837271201073330">"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 pajisjes do të vazhdojnë të shfaqen.\n\nKur çaktivizon \"Mos shqetëso\", gjej njoftimet e humbura duke rrëshqitur shpejt 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="6403365663466620328">"Njoftimet që nevojiten për aktivitetin dhe statusin bazë të pajisjes 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="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="general_notification_header" msgid="3669031068980713359">"Menaxho"</string>
    <string name="app_notification_field" msgid="3208079070539894909">"Njoftimet 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="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="notification_badging_title" msgid="5469616894819568917">"Pika e njoftimit në ikonën e aplikacionit"</string>
    <string name="notification_bubbles_title" msgid="5681506665322329301">"Flluskat"</string>
    <string name="bubbles_app_toggle_title" msgid="5319021259954576150">"Flluskat"</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_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_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="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="4578154430436224161">"Pas shkyçjes, shko drejtpërdrejt tek ekrani i fundit i përdorur. Njoftimet nuk do të shfaqen në ekranin e kyçjes. Rrëshqit poshtë për t\'i parë."</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="unseen_notifs_lock_screen" msgid="6910701117021324612">"Shfaq vetëm njoftimet e reja në ekranin e kyçjes"</string>
    <string name="unseen_notifs_lock_screen_summary" msgid="5996722793868021391">"Hiq automatikisht njoftimet e shikuara më parë nga ekrani i kyçjes"</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ërmbajtjet delikate vetëm pasi ta shkyçësh"</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">"Fshih përmbajtjet 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_importance_title" msgid="1545158655988342703">"Sjellja"</string>
    <string name="conversations_category_title" msgid="5586541340846847798">"Bisedat"</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="priority_conversation_count_zero" msgid="3862289535537564713">"Nuk ka biseda me përparësi"</string>
    <string name="priority_conversation_count" msgid="7291234530844412077">"{count,plural, =1{# bisedë me përparësi}other{# biseda me përparësi}}"</string>
    <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="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_title" msgid="7676541266705442501">"Minimizo"</string>
    <string name="notification_importance_high_title" msgid="394129291760607808">"Shfaq në ekran"</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="1168420867670390611">"Mund të bjerë zilja ose të dridhet në bazë të cilësimeve të pajisjes"</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 nga \"<xliff:g id="APP_NAME">%1$s</xliff:g>\""</string>
    <string name="notifications_sent_daily" msgid="10274479224185437">"{count,plural, =1{Rreth # njoftim në ditë}other{Rreth # njoftime në ditë}}"</string>
    <string name="notifications_sent_weekly" msgid="7895656213187555346">"{count,plural, =1{Rreth # njoftim në javë}other{Rreth # njoftime në javë}}"</string>
    <string name="notifications_sent_never" msgid="9081278709126812062">"Asnjëherë"</string>
    <string name="manage_notification_access_title" msgid="6481256069087219982">"Njoftime të pajisjes dhe të 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="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_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="1131986567509818121">"Aplikacioni <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="1486887096703743841">"Aplikacioni \"<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="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="notif_listener_more_settings" msgid="1348409392307208921">"Cilësime të tjera"</string>
    <string name="notif_listener_more_settings_desc" msgid="7995492074281663658">"Brenda këtij aplikacioni ofrohen cilësime të tjera"</string>
    <string name="notification_polite_title" msgid="6121016426991791557">"Reduktimi i njoftimeve"</string>
    <string name="notification_polite_all_apps" msgid="1118651561594250059">"Zbato reduktimin për të gjitha njoftimet"</string>
    <string name="notification_polite_all_apps_summary" msgid="540268373207498126">"Ul gradualisht volumin e njoftimeve kur merr shumë njoftime të njëpasnjëshme nga i njëjti aplikacion"</string>
    <string name="notification_polite_conversations" msgid="8197695136727245741">"Zbato reduktimin për bisedat"</string>
    <string name="notification_polite_conversations_summary" msgid="2677141765664359994">"Ul gradualisht volumin e njoftimeve kur merr shumë mesazhe nga e njëjta bisedë brenda një periudhe të shkurtër kohore"</string>
    <string name="notification_polite_disabled" msgid="1378078021594282842">"Mos e përdor reduktimin e njoftimeve"</string>
    <string name="notification_polite_disabled_summary" msgid="1145341260283746936">"Mos e ul asnjëherë volumin e njoftimeve, pavarësisht sasisë së njoftimeve të njëpasnjëshme nga i njëjti aplikacion"</string>
    <string name="notification_polite_vibrate_unlocked" msgid="6142573851761357903">"Lësho dridhje kur është i shkyçur"</string>
    <string name="notification_polite_vibrate_unlocked_summary" msgid="1678472892282874459">"Lësho dridhje vetëm kur ekrani është i shkyçur"</string>
    <string name="notification_polite_work" msgid="8823596456640216391">"Zbato në profilet e punës"</string>
    <string name="notification_polite_work_summary" msgid="8260947839104352075">"Zbato cilësimet e reduktimit të njoftimeve nga profili yt personal tek ai i punës"</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_switch_enabled" msgid="7294719120282287495">"Lidhur"</string>
    <string name="interact_across_profiles_switch_disabled" msgid="4312196170211463988">"Lidhi 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>
    <string name="interact_across_profiles_number_of_connected_apps" msgid="4000424798291479207">"{count,plural, =1{# aplikacion i lidhur}other{# aplikacione të lidhura}}"</string>
    <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="app_notifications_off_desc" msgid="2484843759466874201">"Nuk i ke lejuar njoftimet nga ky aplikacion"</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="app_notifications_not_send_desc" msgid="5683060986735070528">"Ky aplikacion nuk dërgon njoftime"</string>
    <string name="notification_channels" msgid="1502969522886493799">"Kategoritë"</string>
    <string name="notification_channels_other" msgid="18159805343647908">"Të tjera"</string>
    <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="deleted_channels" msgid="8489800381509312964">"{count,plural, =1{# kategori e fshirë}other{# kategori të fshira}}"</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="app_notification_fsi_permission_title" msgid="5424116606034705020">"Lejo njoftimet në ekran të plotë"</string>
    <string name="app_notification_fsi_permission_summary" msgid="7673487977631068039">"Lejo që njoftimet të zënë ekranin e plotë kur pajisja është e kyçur"</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_notifications_dialog_done" msgid="573716608705273004">"U krye"</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="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_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_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_event_rule_type_name" msgid="1921166617081971754">"Ngjarje"</string>
    <string name="zen_mode_event_rule_calendar" msgid="6279460374929508907">"Gjatë ngjarjeve për"</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_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="zen_mode_conversations_title" msgid="5491912973456026379">"Bisedat"</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_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_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_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>
    <string name="zen_mode_summary_alarms_only_by_minute" msgid="6673649005494939311">"{count,plural, =1{Ndrysho vetëm tek alarmet për një minutë deri në {time}}other{Ndrysho vetëm tek alarmet për # minuta (deri në {time})}}"</string>
    <string name="zen_mode_summary_alarms_only_by_hour" msgid="7400910210950788163">"{count,plural, =1{Ndrysho vetëm tek alarmet për një orë deri në {time}}other{Ndrysho vetëm tek alarmet për # orë deri në {time}}}"</string>
    <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="warning_button_text" msgid="1274234338874005639">"Paralajmërim"</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="5822120806426139396">"Kur një aplikacion është i gozhduar, ai mund të hapë aplikacione të tjera dhe mund të ketë qasje te të dhënat personale. \n\nPër të përdorur gozhdimin e aplikacionit: 	\n{0,number,integer}. Aktivizo gozhdimin e aplikacionit 	\n{1,number,integer}. Hap \"Përmbledhjen\" 	\n{2,number,integer}. Trokit ikonën e aplikacionit në krye të ekranit dhe më pas trokit \"Gozhdo\""</string>
    <string name="screen_pinning_guest_user_description" msgid="2307270321127139579">"Kur një aplikacion është i gozhduar, ai mund të hapë aplikacione të tjera dhe mund të ketë qasje te 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: 	\n{0,number,integer}. Aktivizo gozhdimin e aplikacionit 	\n{1,number,integer}. Hap \"Përmbledhjen\" 	\n{2,number,integer}. 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="4439657901673639063">"Verifiko që je ti përpara se të spastrosh një kartë eSIM"</string>
    <string name="memtag_title" msgid="5096176296797727201">"Mbrojtja e përparuar beta e memories"</string>
    <string name="memtag_toggle" msgid="8695028758462939212">"Mbrojtja e përparuar e memories"</string>
    <string name="memtag_intro" msgid="579408691329568953">"Kjo veçori beta të ndihmon të mbrosh pajisjen tënde nga defektet në kod që mund të vënë në rrezik sigurinë tënde."</string>
    <string name="memtag_on" msgid="824938319141503923">"Aktive"</string>
    <string name="memtag_off" msgid="4835589640091709019">"Joaktive"</string>
    <string name="memtag_on_pending" msgid="1592053425431532361">"Aktive pas rinisjes"</string>
    <string name="memtag_off_pending" msgid="1543177181383593726">"Joaktive pas rinisjes"</string>
    <string name="memtag_force_off" msgid="1143468955988138470">"Nuk ofrohet aktualisht për pajisjen tënde"</string>
    <string name="memtag_force_on" msgid="3254349938627883664">"Gjithmonë aktive për pajisjen tënde"</string>
    <string name="memtag_footer" msgid="8480784485124271376">"Do të të duhet të rinisësh pajisjen tënde për të aktivizuar ose çaktivizuar \"Mbrojtjen e përparuar të memories\". Kur është aktive, mund të vësh re një cilësi funksionimi më të ngadaltë të pajisjes."</string>
    <string name="memtag_reboot_title" msgid="1413471876903578769">"Të riniset pajisja?"</string>
    <string name="memtag_reboot_message_on" msgid="3270256606602439418">"Do të të duhet të rinisësh pajisjen tënde për të aktivizuar \"Mbrojtjen e përparuar të memories\"."</string>
    <string name="memtag_reboot_message_off" msgid="2567062468140476451">"Do të të duhet të rinisësh pajisjen tënde për të çaktivizuar \"Mbrojtjen e përparuar të memories\"."</string>
    <string name="memtag_reboot_yes" msgid="5788896350697141429">"Rinis"</string>
    <string name="memtag_reboot_no" msgid="2860671356184849330">"Jo tani"</string>
    <string name="memtag_learn_more" msgid="1596145970669119776">"Mëso më shumë rreth \"Mbrojtjen së përparuar të memories\"."</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="launch_by_default" msgid="892824422067985734">"Hap me parazgjedhje"</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_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>
    <string name="app_launch_verified_links_title" msgid="621908751569155356">"{count,plural, =1{# lidhje e verifikuar}other{# lidhje të verifikuara}}"</string>
    <string name="app_launch_verified_links_message" msgid="190871133877476176">"{count,plural, =1{Kjo lidhje është verifikuar dhe hapet automatikisht në këtë aplikacion.}other{Këto lidhje janë verifikuar dhe hapen automatikisht në këtë aplikacion.}}"</string>
    <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>
    <string name="app_launch_supported_links_title" msgid="2457931321701095763">"{count,plural, =1{# lidhje e mbështetur}other{# lidhje të mbështetura}}"</string>
    <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">"Të përdorura te <xliff:g id="STORAGE_TYPE">%2$s</xliff:g>: <xliff:g id="SIZE">%1$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_categories_off" msgid="7712037485557237328">"{count,plural, =1{# kategori u çaktivizua}other{# kategori u çaktivizuan}}"</string>
    <string name="runtime_permissions_additional_count" msgid="6071909675951786523">"{count,plural, =1{# leje shtesë}other{# leje shtesë}}"</string>
    <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>
    <string name="unused_apps_summary" msgid="4236371818881973021">"{count,plural, =1{# aplikacion i papërdorur}other{# aplikacione të papërdorura}}"</string>
    <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_blocked_apps" msgid="1065653868850012325">"Çaktivizuar"</string>
    <string name="advanced_apps" msgid="7643010673326578815">"Të përparuara"</string>
    <string name="app_permissions" msgid="8666537659217653626">"Menaxheri i lejeve"</string>
    <string name="app_data_sharing_updates_title" msgid="1694297952320402788">"Përditësime të të dhënave të ndara për vendndodhjen"</string>
    <string name="app_data_sharing_updates_summary" msgid="4465929918457739443">"Shqyrto aplikacionet që ndryshuan mënyrën se si mund të ndajnë të dhënat e vendndodhjes sate"</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="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>
    <string name="app_link_open_always_summary" msgid="4524005594295855117">"{count,plural, =1{Aplikacioni kërkon të administrojë # lidhje}other{Aplikacioni kërkon të administrojë # lidhje}}"</string>
    <string name="open_supported_links_footer" msgid="3188808142432787933">"Aplikacioni kërkon të administrojë lidhjet e mëposhtme:"</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_agree" msgid="9013334158753473359">"Pranoj"</string>
    <string name="default_browser_title" msgid="8342074390782390458">"Aplikacioni për shfletim"</string>
    <string name="default_phone_title" msgid="7616730756650803827">"Aplikacioni \"Telefoni\""</string>
    <string name="system_app" msgid="1863291702508355041">"(Sistemi)"</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="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="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_use_running_format" msgid="4376086847362492613">"<xliff:g id="MEMORY">%1$s</xliff:g> / <xliff:g id="RUNNING">%2$s</xliff:g>"</string>
    <string name="high_power_apps" msgid="5623152700992102510">"Optimizimi i baterisë"</string>
    <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_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="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">"Ndaj"</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_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_photo_transfers" msgid="4641181628966036093">"PTP"</string>
    <string name="usb_use_uvc_webcam" msgid="6595429508472038732">"Uebkamera"</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_tethering" msgid="2897063414491670531">"Ndarje interneti përmes USB-së"</string>
    <string name="usb_use_MIDI" msgid="8621338227628859789">"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_UVC" msgid="8733131110899174299">"Uebkamera"</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="usb_summary_UVC_power" msgid="226810354412154061">"Uebkamera dhe furnizimi me energji"</string>
    <string name="background_check_pref" msgid="5304564658578987535">"Kontrolli i sfondit"</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>
    <string name="memory_usage_apps_summary" msgid="7168292864155527974">"{count,plural, =1{1 aplikacion përdori memorien gjatë {time} të fundit}other{# aplikacione përdorën memorien gjatë {time} të fundit}}"</string>
    <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ë ndryshime 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="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="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="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>
    <!-- no translation found for voice_activation_apps_title (7130045161611529825) -->
    <skip />
    <!-- no translation found for permit_voice_activation_apps (9152780172988949319) -->
    <skip />
    <!-- no translation found for allow_voice_activation_apps_description (6369745626995060656) -->
    <skip />
    <string name="full_screen_intent_title" msgid="747270185715224130">"Njoftimet në ekranin e plotë"</string>
    <string name="permit_full_screen_intent" msgid="9035367640019960861">"Të lejohen njoftimet në ekranin e plotë nga ky aplikacion"</string>
    <string name="footer_description_full_screen_intent" msgid="7716518411349225528">"Lejo këtë aplikacion të shfaqë njoftime që zënë ekranin e plotë kur pajisja është e kyçur. Aplikacionet mund t’i përdorin këto për të vendosur në fokus alarmet, telefonatat hyrëse apo njoftimet e tjera urgjente."</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="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="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="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="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_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="disconnected" msgid="3469373726996129247">"Nuk është i lidhur"</string>
    <string name="keyboard_disconnected" msgid="796053864561894531">"Nuk është e lidhur"</string>
    <string name="apps_summary" msgid="4007416751775414252">"<xliff:g id="COUNT">%1$d</xliff:g> 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="display_dashboard_summary" msgid="1599453894989339454">"Tema e errët, madhësia e fontit, ndriçimi"</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="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="6852347040813204503">"U bllokua nga politika e punës"</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="disabled_by_policy_parental_consent" msgid="9166060049019018978">"Jepja telefonin prindit tënd për të lejuar që ky cilësim të ndryshohet."</string>
    <string name="default_admin_support_msg" msgid="8816296554831532033">"Për më shumë informacione, kontakto me administratorin e teknologjisë së informacionit"</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="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="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>
    <string name="data_saver_unrestricted_summary" msgid="7343571401172437542">"{count,plural, =1{1 aplikacion lejohet që të përdorë të dhëna të pakufizuara kur \"Kursyesi i të dhënave\" është aktiv}other{# aplikacione lejohen që të përdorin të dhëna të pakufizuara kur \"Kursyesi i të dhënave\" është aktiv}}"</string>
    <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_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>
    <string name="billing_cycle_days_left" msgid="174337287346866400">"{count,plural, =1{# ditë e mbetur}other{# ditë të mbetura}}"</string>
    <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_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="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="app_battery_usage_title" msgid="346558380609793334">"Përdorimi i baterisë për aplikacionet"</string>
    <string name="app_battery_usage_summary" msgid="6349965904306339539">"Cakto përdorimin e baterisë për aplikacionet"</string>
    <string name="battery_tips_card_action_button" msgid="4897793527424711648">"Shiko cilësimet"</string>
    <string name="battery_tips_card_action_button_check" msgid="1535140204105479318">"Kontrollo"</string>
    <string name="battery_tips_card_dismiss_button" msgid="1885756985544936618">"E kuptova"</string>
    <string name="battery_tips_card_feedback_info" msgid="767117835675157298">"A është i dobishëm ky mesazh?"</string>
    <string name="battery_hints_warning_icon_a11y" msgid="5312542323401447620">"Ikona e paralajmërimit për këshillat për baterinë"</string>
    <string name="battery_tips_settings_summary_brightness" msgid="546145032616077783">"Aktivizo ndriçimin me përshtatje për të rritur kohëzgjatjen e baterisë"</string>
    <string name="battery_tips_settings_summary_screen_timeout" msgid="556801426050962077">"Zvogëlo kohën e pritjes të ekranit për të rritur kohëzgjatjen e baterisë"</string>
    <string name="battery_tips_apps_summary_always_high" msgid="6334519477067044920">"<xliff:g id="APP_LABEL">%1$s</xliff:g> ka përdorur më shumë bateri"</string>
    <string name="battery_tips_apps_summary_higher_than_usual" msgid="95676961671544628">"<xliff:g id="APP_LABEL">%1$s</xliff:g> ka përdorur më shumë bateri se zakonisht"</string>
    <string name="battery_tips_apps_summary_always_high_in_background" msgid="2953858181710181126">"<xliff:g id="APP_LABEL">%1$s</xliff:g> ka përdorur më shumë bateri ndërkohë që ka qenë në sfond"</string>
    <string name="battery_tips_apps_summary_higher_than_usual_in_background" msgid="1585002072567422199">"<xliff:g id="APP_LABEL">%1$s</xliff:g> ka përdorur më shumë bateri se zakonisht ndërkohë që ka qenë në sfond"</string>
    <string name="battery_tips_apps_summary_always_high_in_foreground" msgid="1910991243576404700">"<xliff:g id="APP_LABEL">%1$s</xliff:g> ka përdorur më shumë bateri ndërkohë që ka qenë në plan të parë"</string>
    <string name="battery_tips_apps_summary_higher_than_usual_in_foreground" msgid="7937337570425168210">"<xliff:g id="APP_LABEL">%1$s</xliff:g> ka përdorur më shumë bateri se zakonisht ndërkohë që ka qenë në plan të parë"</string>
    <string name="battery_app_item_hint" msgid="4850929961461039110">"Përdorim i lartë i baterisë"</string>
    <string name="battery_app_item_hint_in_bg" msgid="596240821466388336">"Përdorim i lartë i baterisë në sfond"</string>
    <string name="battery_app_item_hint_in_fg" msgid="5091860632260799910">"Përdorim i lartë i baterisë në plan të parë"</string>
    <string name="filter_battery_unrestricted_title" msgid="821027369424198223">"E pakufizuar"</string>
    <string name="filter_battery_optimized_title" msgid="8236647176487754796">"E optimizuar"</string>
    <string name="filter_battery_restricted_title" msgid="5886859505802563232">"E kufizuar"</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_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_public_version" msgid="3057653571018432759">"versioni publik"</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_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="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>
    <string name="special_access_more" msgid="132919514147475846">"Shiko më shumë"</string>
    <string name="long_background_tasks_label" msgid="3169590134850226687">"Detyrat e gjata në sfond"</string>
    <string name="long_background_tasks_switch_title" msgid="2491623894899492543">"Lejo detyrat në sfond për një kohë të gjatë"</string>
    <string name="long_background_tasks_title" msgid="3272230637974707490">"Detyrat e gjata në sfond"</string>
    <string name="long_background_tasks_footer_title" msgid="9117342254914743097">"Lejo që ky aplikacion të ekzekutojë detyrat e gjata në sfond. Kjo lejon aplikacionin të ekzekutojë detyra që mund të zgjasin më shumë se disa minuta për të përfunduar, si p.sh. shkarkimet dhe ngarkimet. \n\nNëse kjo leje nuk jepet, sistemi do të kufizojë për sa kohë aplikacioni mund të kryejë detyra të tilla në sfond."</string>
    <string name="keywords_long_background_tasks" msgid="5788956269136054574">"punë të gjata, transferim të dhënash, detyra në sfond"</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_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="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 të direktorisë së punës në 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>
    <string name="managed_profile_settings_footer" msgid="996500759305118103">"Kur aplikacionet e punës janë të çaktivizuara, ato janë të vendosura në pauzë dhe nuk mund të hapen dhe as të të dërgojnë njoftime"</string>
    <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="gesture_preference_title" msgid="8291899281322647187">"Gjestet"</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_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="system_navigation_title" msgid="4890381153527184636">"Modaliteti i navigimit"</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="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="818109176611921504">"Për të shkuar tek ekrani bazë, rrëshqit shpejt lart nga fundi i ekranit. Për të ndërruar aplikacionet, rrëshqit shpejt lart nga fundi, mbaje dhe më pas lëshoje. Për t\'u kthyer pas, rrëshqit shpejt 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="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="low_label" msgid="6525629096999711220">"E ulët"</string>
    <string name="high_label" msgid="357503396626018487">"E 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="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_wake_screen_title" msgid="7637678749035378085">"Ekrani i zgjimit"</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_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_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_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="auto_sync_account_title" msgid="1070908045600374254">"Sinkronizo automatikisht të dhënat e aplikacionit"</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>
    <string name="enterprise_privacy_number_packages_lower_bound" msgid="5317634640873658149">"{count,plural, =1{Minimumi # aplikacion}other{Minimumi # aplikacione}}"</string>
    <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>
    <string name="enterprise_privacy_number_packages" msgid="5294444005035188274">"{count,plural, =1{# aplikacion}other{# aplikacione}}"</string>
    <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>
    <string name="enterprise_privacy_number_ca_certs" msgid="4540897122831942658">"{count,plural, =1{Minimumi # certifikatë CA}other{Minimumi # certifikata CA}}"</string>
    <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>
    <string name="enterprise_privacy_number_failed_password_wipe" msgid="2695842143305867642">"{count,plural, =1{# përpjekje}other{# përpjekje}}"</string>
    <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="7836497475568741579">"Ofruesi yt i blerjes me këste mund të ndryshojë cilësimet dhe të instalojë softuerë në këtë pajisje gjatë konfigurimit.\n\nNëse harron një pagesë, ofruesi yt i blerjes me këste mund ta kyçë pajisjen tënde dhe të ndryshojë cilësimet e pajisjes.\n\nPër të mësuar më shumë, kontakto ofruesin tënd të 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="5505016667590160732">"Të rivendosë pajisjen në gjendje fabrike nëse ndodh ndonjë problem."</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>
    <string name="financed_device_info" msgid="3871860346697308342">"Informacionet e pajisjes së financuar"</string>
    <string name="default_camera_app_title" msgid="6546248868519965998">"{count,plural, =1{Aplikacioni i kamerës}other{Aplikacionet e kamerës}}"</string>
    <string name="default_calendar_app_title" msgid="1870095225089706093">"Aplikacioni i kalendarit"</string>
    <string name="default_contacts_app_title" msgid="7740028900741944569">"Aplikacioni i kontakteve"</string>
    <string name="default_email_app_title" msgid="5411280873093244250">"{count,plural, =1{Aplikacioni i klientit të email-it}other{Aplikacionet e klientit të email-it}}"</string>
    <string name="default_map_app_title" msgid="7569231732944853320">"Aplikacioni i hartës"</string>
    <string name="default_phone_app_title" msgid="795025972645464135">"{count,plural, =1{Aplikacioni i telefonatave}other{Aplikacionet e telefonatave}}"</string>
    <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_games" msgid="1176568610086802469">"Lojëra"</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_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="default_autofill_app" msgid="372234803718251606">"Shërbimi i parazgjedhur i plotësimit automatik"</string>
    <string name="autofill_passwords" msgid="6708057251459761083">"Fjalëkalimet"</string>
    <string name="credman_chosen_app_title" msgid="872524130208251505">"Fjalëkalimet, çelësat e kalimit dhe shërbimet e të dhënave"</string>
    <string name="credman_credentials" msgid="4931371941253324143">"Ofrues shtesë"</string>
    <string name="autofill_passwords_count" msgid="6359289285822955973">"{count,plural, =1{# fjalëkalim}other{# fjalëkalime}}"</string>
    <string name="autofill_keywords" msgid="8598763328489346438">"automatikisht, plotëso, plotësimi automatik, fjalëkalim"</string>
    <string name="credman_keywords" msgid="8305600680836806170">"të dhëna, çelës kalimi, fjalëkalim"</string>
    <string name="credman_autofill_keywords" msgid="701180623776848914">"automatik, plotëso, plotësimi automatik, të dhënat, çelësi i kalimit, fjalëkalimi"</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="credman_autofill_confirmation_message" msgid="843829628024668466">"&lt;b&gt;Use &lt;xliff:g id=app_name example=Provider&gt;%1$s&lt;/xliff:g&gt;?&lt;/b&gt; &lt;br/&gt; &lt;br/&gt; Fjalëkalimet, çelësat e kalimit dhe informacionet e tjera të reja do të ruhen këtu nga tani e tutje. &lt;xliff:g id=app_name example=Provider&gt;%1$s&lt;/xliff:g&gt; mund të përdorë ato që janë në ekranin tënd për të përcaktuar se çfarë mund të plotësohet automatikisht."</string>
    <string name="credman_picker_title" msgid="8191267620665129205">"Fjalëkalimet, çelësat e kalimit dhe shërbimet e të dhënave"</string>
    <string name="credman_confirmation_message_title" msgid="8847900085593880729">"Të çaktivizohet %1$s?"</string>
    <string name="credman_confirmation_message" msgid="2357324543658635239">"&lt;b&gt;Të çaktivizohet shërbimi?&lt;/b&gt; &lt;br/&gt; &lt;br/&gt; Informacionet e ruajtura si fjalëkalimet, çelësat e kalimit, mënyrat e pagesës dhe informacione të tjera nuk do të plotësohen kur të identifikohesh. Për të përdorur informacionin tënd të ruajtur, zgjidh një fjalëkalim, çelës kalimi ose shërbim të dhënash."</string>
    <string name="credman_enable_confirmation_message_title" msgid="1037501792652277829">"Të përdoret %1$s?"</string>
    <string name="credman_enable_confirmation_message" msgid="8407841892310870169">"%1$s përdor atë që ke në ekranin për të përcaktuar se çfarë mund të plotësohet automatikisht."</string>
    <string name="credman_error_message_title" msgid="4099557206946333568">"Kufiri i fjalëkalimeve, çelësave të kalimit dhe shërbimeve të të dhënave"</string>
    <string name="credman_error_message" msgid="8334797097200415449">"Mund të kesh aktive deri në 5 fjalëkalime, çelësa kalimi dhe shërbime të dhënash në të njëjtën kohë. Çaktivizo një shërbim për të shtuar një tjetër."</string>
    <string name="credman_confirmation_message_positive_button" msgid="2812613187691345361">"Çaktivizo"</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="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="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="enable_angle_as_system_driver" msgid="4648827560023949786">"Eksperimentale: Aktivizo ANGLE"</string>
    <string name="enable_angle_as_system_driver_summary" msgid="2170215556348477481">"Paralajmërim: Aktivizo ANGLE si drejtues të parazgjedhur OpenGL ES. Kjo veçori është në eksperiment dhe mund të mos jetë e përputhshme me disa aplikacione të kamerave dhe videove."</string>
    <string name="reboot_dialog_enable_angle_as_system_driver" msgid="2619263039763150810">"Kërkohet rindezja për të ndryshuar drejtuesin e OpenGL ES për sistemin"</string>
    <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_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="disabled_dependent_setting_summary" msgid="4508635725315852504">"Varet nga një cilësim tjetër"</string>
    <string name="my_device_info_account_preference_title" msgid="9197139254007133175">"Llogaria"</string>
    <string name="my_device_info_account_preference_summary" msgid="3510582677937510545">"%d llogari"</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ë qasjeje për internetin vetëm në nivel lokal"</string>
    <string name="change_nfc_tag_apps_title" msgid="91514009058149617">"Hapja nëpërmjet NFC-së"</string>
    <string name="change_nfc_tag_apps_detail_switch" msgid="240286205725043561">"Lejo hapjen gjatë skanimit të NFC-së"</string>
    <string name="change_nfc_tag_apps_detail_summary" msgid="3338220223868942195">"Lejo këtë aplikacion të hapet kur skanohet një etiketë NFC.\nNëse kjo leje është aktive, aplikacioni do të ofrohet si opsion sa herë që zbulohet një etiketë."</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_out_summary_ongoing_call_state" msgid="475188726850090363">"Nuk ofrohet gjatë telefonatave"</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="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_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="8070356204398144241">"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="devices_title" msgid="649715719278562515">"Pajisjet"</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="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="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="9176513507571883986">"Nuk ofrohet asnjë 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>
    <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_list_add_more" msgid="5076722903436552813">"Shto kartë SIM"</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="3984452275968408382">"Aktiv / eSIM"</string>
    <string name="mobile_network_inactive_esim" msgid="8777415108263057939">"Joaktiv / eSIM"</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_erase_sim" msgid="4629071168032714930">"Spastro kartën SIM"</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_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="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="keywords_access_point_names" msgid="8174967126858505945">"APN"</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="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="8977951796005849471">"Vetëm 1 kartë eSIM 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_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="sim_action_turn_off" msgid="3506698692916473000">"Çaktivizo"</string>
    <string name="dsds_activation_failure_title" msgid="4467364110584914794">"Karta SIM nuk mund të aktivizohet"</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="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="6263064316075963775">"SIM"</string>
    <string name="erase_sim_dialog_title" msgid="4742077437653028326">"Të spastrohet kjo kartë eSIM?"</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="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="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="accessibility_usage_title" msgid="9190967143518779145">"Përdorimi i qasshmërisë"</string>
    <string name="accessibility_usage_summary" msgid="4348285359995227813">"{count,plural, =1{1 aplikacion ka qasje të plotë te pajisja jote}other{# aplikacione kanë qasje të plotë te pajisja jote}}"</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="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="development_memtag_page_title" msgid="3546667618748029188">"Shtesa e etiketimit të memories"</string>
    <string name="development_memtag_intro" msgid="8032596625527637164">"\"Shtesa e etiketimit të memories\" (MTE) e bën më të thjeshtë gjetjen e problemeve me sigurinë e memories në apl. dhe bërjen e kodeve origjinale në të më të sigurt."</string>
    <string name="development_memtag_footer" msgid="5681925148773626562">"Aktivizimi i MTE-së mund të shkaktojë performancë më të ngadaltë të pajisjes."</string>
    <string name="development_memtag_learn_more" msgid="8961984806973926704">"Mëso më shumë rreth MTE-së"</string>
    <string name="development_memtag_toggle" msgid="2474420239518386894">"Aktivizo MTE-në derisa ta çaktivizosh"</string>
    <string name="development_memtag_reboot_message_on" msgid="8100075676107327847">"Do të të duhet të rinisësh pajisjen tënde për të aktivizuar MTE-në."</string>
    <string name="development_memtag_reboot_message_off" msgid="3703925647922079456">"Do të të duhet të rinisësh pajisjen tënde për të çaktivizuar MTE-në."</string>
    <string name="reboot_with_mte_title" msgid="2320125810211279">"Aktivizo MTE-në për një seancë të vetme"</string>
    <string name="reboot_with_mte_message" msgid="1232881567956207641">"Sistemi do të rinisë dhe do të lejojë eksperimentimin me \"Shtesën e etiketimit të memories\" (MTE). MTE-ja mund të ndikojë negativisht në performancën dhe qëndrueshmërinë e sistemit. Do të rivendoset gjatë rindezjes së radhës."</string>
    <string name="reboot_with_mte_summary" msgid="3896537791216432882">"Rinis për një seancë të vetme me MTE-në e aktivizuar"</string>
    <string name="reboot_with_mte_already_enabled" msgid="4439168867613407167">"MTE-ja është e aktivizuar tashmë"</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="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="default_app_none" msgid="5420632042222036264">"Asnjë"</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="power_menu_setting_name" msgid="2394440932633137229">"Shtyp dhe mbaj shtypur butonin e energjisë"</string>
    <string name="power_menu_long_press_category_title" msgid="1051146091093775002">"Shtyp dhe mbaj shtypur butonin e energjisë për qasje"</string>
    <string name="power_menu_long_press_for_power_menu_title" msgid="477584639843663599">"Menyja e energjisë"</string>
    <string name="power_menu_long_press_for_assistant_title" msgid="6557738348262616455">"Asistenti dixhital"</string>
    <string name="power_menu_summary_long_press_for_assistant" msgid="32706459458422952">"Qasje tek asistenti dixhital"</string>
    <string name="power_menu_summary_long_press_for_power_menu" msgid="7617247135239683710">"Qasje te menyja e energjisë"</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_power_volume_up_hint" msgid="5619917593676125759">"Menyja e energjisë:\nShtyp butonin e energjisë dhe butonin e volumit lart njëkohësisht"</string>
    <string name="power_menu_power_prevent_ringing_hint" msgid="1169955014711158873">"Parandalo rënien e ziles:\nShtyp një buton volumi për shkurtoren"</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="1856477548806618829">"Shfaq skanerin e kodeve QR"</string>
    <string name="lockscreen_privacy_qr_code_scanner_summary" msgid="4577409244972250235">"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="7522918441738915364">"Nga ekrani i kyçjes"</string>
    <string name="lockscreen_trivial_controls_setting_toggle" msgid="2174300719855112358">"Përdor kontrollet e 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="4109235686687860393">"Madhësia e orës ndryshon sipas përmbajtjes së ekranit të kyçjes"</string>
    <string name="lockscreen_double_line_clock_setting_toggle" msgid="802271087416091548">"Orë dinamike"</string>
    <string name="lockscreen_quick_affordances_title" msgid="8615741551327565793">"Shkurtoret"</string>
    <plurals name="lockscreen_quick_affordances_summary" formatted="false" msgid="4225396036524703997">
      <item quantity="other"><xliff:g id="FIRST_1">%1$s</xliff:g>, <xliff:g id="SECOND">%2$s</xliff:g></item>
      <item quantity="one"><xliff:g id="FIRST_0">%1$s</xliff:g></item>
    </plurals>
    <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="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="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_lockscreen_title" msgid="2188311721857512510">"Shfaq media në ekranin e kyçjes"</string>
    <string name="media_controls_lockscreen_description" msgid="3320333660404439510">"Për të rifilluar shpejt luajtjen, luajtësi i medias qëndron i hapur në ekranin e kyçjes"</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="provider_internet_settings" msgid="3831259474776313323">"Interneti"</string>
    <string name="provider_network_settings_title" msgid="2624756136016346774">"Kartat SIM"</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_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, wireless, të dhëna, wifi, wi-fi, wi fi, rrjeti celular, celular, operatori celular, 4g, 3g, 2g, lte"</string>
    <string name="reset_your_internet_title" msgid="4856899004343241310">"Të rivendoset interneti?"</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="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="2876988650413179752">"eSIM"</string>
    <string name="downloaded_sims_category_title" msgid="487799905978489922">"Kartat eSIM"</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_temp_connection_active" msgid="3430470299756236413">"Lidhur përkohësisht"</string>
    <string name="mobile_data_temp_using" msgid="5211002380149434155">"Po përdor përkohësisht <xliff:g id="SUBNAME">%1$s</xliff:g>"</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="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_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="multiple_users_main_switch_keywords" msgid="4845954458094134356">"lejo, disa, përdorues, leje, shumë"</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="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-në"</string>
    <string name="adaptive_brightness_main_switch_title" msgid="2681666805191642737">"Përdor ndriçimin me përshtatje"</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="8682640643264071789">"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="require_cellular_encryption_title" msgid="7516008146269371585">"Kërko enkriptim"</string>
    <string name="require_cellular_encryption_summary" msgid="4813823321032908641">"Enkriptimi është më i sigurt, por mund të mos jesh në gjendje të lidhesh në disa vendndodhje. Enkriptimi nuk kërkohet asnjëherë për telefonatat e urgjencës"</string>
    <string name="app_info_all_services_label" msgid="1487070364839071105">"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="uwb_settings_summary_no_uwb_regulatory" msgid="3465456428217979428">"Veçoria UWB nuk ofrohet në vendndodhjen aktuale"</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="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="7351015416346359536">"Kërkesa për qasje në kartën SIM"</string>
    <string name="bluetooth_sim_card_access_notification_content" msgid="8685623260103018309">"Një pajisje kërkon të ketë qasje te karta jote SIM. Trokit për detaje."</string>
    <string name="bluetooth_sim_card_access_dialog_title" msgid="5616323725563125179">"Të lejohet qasja te karta SIM?"</string>
    <string name="bluetooth_sim_card_access_dialog_content" msgid="6281997628405909566">"Një pajisje me Bluetooth, <xliff:g id="DEVICE_NAME_0">%1$s</xliff:g>, kërkon të ketë qasje te të dhënat nga karta jote 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_min_consumption_limit" msgid="3293145670921755789">"Kufiri minimal i konsumit"</string>
    <string name="tare_max_consumption_limit" msgid="8335700580111808823">"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_app_install" msgid="7955806910408116882">"Instalimi i aplikacionit"</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 name="tare_min_balance_addition_app_updater" msgid="5391956072471201269">"Shtimi i balancës minimale në karikim të plotë (Përditësuesit e aplikacionit)"</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="8088911054987524904">"Shfaq gjëra të tilla si ora, moti ose informacione të tjera në mbrojtësin e ekranit"</string>
    <string name="dream_home_controls_toggle_title" msgid="706799741564479248">"Shfaq kontrollet e shtëpisë"</string>
    <string name="dream_home_controls_toggle_summary" msgid="4102519907917430579">"Shfaq butonin e kontrolleve të shtëpisë nga mbrojtësi i 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="customize_button_description" msgid="7440248477266126231">"Të personalizosh <xliff:g id="SCREENSAVER_NAME">%1$s</xliff:g>"</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="bluetooth_details_permissions_sync_title" msgid="7277580382321003521">"Sinkronizo lejet nga telefoni"</string>
    <string name="bluetooth_details_permissions_sync_summary" msgid="8125037984381432059">"Jepi orës të njëjtat leje të aplikacionit që ke lejuar në këtë telefon"</string>
    <string name="bluetooth_details_audio_device_types_title" msgid="3381941189346781614">"Lloji i pajisjes audio"</string>
    <string name="bluetooth_details_audio_device_type_unknown" msgid="839337391037998014">"E panjohur"</string>
    <string name="bluetooth_details_audio_device_type_speaker" msgid="3706227767994792124">"Altoparlant"</string>
    <string name="bluetooth_details_audio_device_type_headphones" msgid="7644588291215033798">"Kufje"</string>
    <string name="bluetooth_details_audio_device_type_hearing_aid" msgid="1310631131071939859">"Aparat dëgjimi"</string>
    <string name="bluetooth_details_audio_device_type_carkit" msgid="4439017600454703229">"Seti pa përdorur duart"</string>
    <string name="bluetooth_details_audio_device_type_other" msgid="7019481234617207563">"Tjetër"</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="disable_phantom_process_monitor_title" msgid="8348108346706188771">"Çaktivizo kufizimet e procesit dytësor"</string>
    <string name="disable_phantom_process_monitor_summary" msgid="3044464635550256985">"Çaktivizo kufizimet në përdorimin e burimeve të sistemit të proceseve dytësore të aplikacionit"</string>
    <string name="enable_notes_role_title" msgid="7662702013496114763">"Aktivizo me forcë rolin e mbajtjes së shënimeve"</string>
    <string name="enable_notes_role_summary" msgid="5495721409392395089">"Aktivizo integrimet e sistemit të mbajtjes së shënimeve nëpërmjet rolit të mbajtjes së shënimeve. Nëse roli i mbajtjes së shënimeve është aktivizuar tashmë, mos bëj asgjë. Kërkon rinisjen."</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="find_broadcast_join_broadcast_error" msgid="5486980388774711346">"Nuk mund të bashkohet me transmetimin"</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>
    <string name="convert_to_esim_title" msgid="71037864129009206">"Konverto në kartë eSIM"</string>
    <string name="transfer_esim_to_another_device_title" msgid="5286117866086383192">"Transfero kartën eSIM në një pajisje tjetër"</string>
    <string name="background_install_preference_summary" msgid="3065219346519340364">"{count,plural, =1{# aplikacion}other{# aplikacione}}"</string>
    <string name="background_install_title" msgid="607913515188276168">"Aplikacionet e instaluara në sfond"</string>
    <string name="background_install_summary" msgid="3890296129543309666">"Prodhuesi i pajisjes sate mund të instalojë aplikacione në sfond në pajisjen tënde ose mund të lejojë që operatori celular dhe partnerë të tjerë ta bëjnë këtë.\n\nAplikacionet e listuara këtu nuk janë të detyrueshme për funksionimin normal të pajisjes sate. Mund t\'i çinstalosh aplikacionet që nuk i dëshiron."</string>
    <string name="background_install_feature_list_no_entry" msgid="2071343281272266154">"Asnjë aplikacion i instaluar në sfond"</string>
    <string name="background_install_uninstall_button_description" msgid="1189649052911501249">"Çinstalo aplikacionin"</string>
    <string name="background_install_before" msgid="8608614957688912715">"{count,plural, =1{Aplikacionet e instaluara në # muajin e fundit}other{Aplikacionet e instaluara në # muajt e fundit}}"</string>
    <string name="background_install_after" msgid="7983488897570908149">"{count,plural, =1{Aplikacionet e instaluara më shumë se # muaj më parë}other{Aplikacionet e instaluara më shumë se # muaj më parë}}"</string>
    <string name="aspect_ratio_title" msgid="2451826875939676101">"Raporti i pamjes"</string>
    <string name="aspect_ratio_summary" msgid="4056406351663726494">"Provo një raport të ri pamjeje për ta parë këtë aplikacion nëse nuk është projektuar për t\'u përshtatur me pajisjen tënde <xliff:g id="DEVICE_NAME">%1$s</xliff:g>"</string>
    <string name="aspect_ratio_main_summary" msgid="4141964559612756940">"Provo një raport të ri pamjeje për ta parë këtë aplikacion nëse nuk është projektuar për t\'u përshtatur me pajisjen tënde <xliff:g id="DEVICE_NAME">%1$s</xliff:g>. Disa aplikacione mund të mos jenë të optimizuara për raporte të caktuara të pamjes."</string>
    <string name="aspect_ratio_summary_text" msgid="4737461467467220325">"Provo një raport të ri pamjeje për të parë një aplikacion nëse nuk është projektuar për t\'u përshtatur me pajisjen tënde <xliff:g id="DEVICE_NAME">%1$s</xliff:g>"</string>
    <string name="aspect_ratio_main_summary_text" msgid="5544816872094235840">"Provo një raport të ri pamjeje për të parë një aplikacion nëse nuk është projektuar për t\'u përshtatur me pajisjen tënde <xliff:g id="DEVICE_NAME">%1$s</xliff:g>. Disa aplikacione mund të mos jenë të optimizuara për raporte të caktuara të pamjes."</string>
    <string name="user_aspect_ratio_suggested_apps_label" msgid="8085934042329632039">"Aplikacionet e sugjeruara"</string>
    <string name="user_aspect_ratio_changed_apps_label" msgid="2096614916172567672">"Të ndryshuarat"</string>
    <string name="user_aspect_ratio_app_default" msgid="270065763307617837">"Parazgjedhja e aplikacionit"</string>
    <string name="user_aspect_ratio_fullscreen" msgid="1843427242540081996">"Ekran i plotë"</string>
    <string name="user_aspect_ratio_half_screen" msgid="1015852057094310209">"Gjysmë ekrani"</string>
    <string name="user_aspect_ratio_device_size" msgid="2339820985120881199">"Raporti i pamjes i pajisjes"</string>
    <string name="user_aspect_ratio_16_9" msgid="2286644872775170164">"16:9"</string>
    <string name="user_aspect_ratio_3_2" msgid="199262962518318932">"3:2"</string>
    <string name="user_aspect_ratio_4_3" msgid="5196232982878982220">"4:3"</string>
    <string name="user_aspect_ratio_option_a11y" msgid="1235801996029095219">"<xliff:g id="NUMERATOR">%1$s</xliff:g> me <xliff:g id="DENOMINATOR">%2$s</xliff:g>"</string>
    <string name="app_aspect_ratio_footer" msgid="4029509301182067475">"Aplikacioni do të riniset kur të ndryshosh raportin e pamjes. Mund t\'i humbasësh ndryshimet e paruajtura. Disa aplikacione mund të mos jenë të optimizuara për raporte të caktuara të pamjes."</string>
    <string name="aspect_ratio_experimental_title" msgid="9088785421062044831">"Raporti i pamjes (eksperimental)"</string>
    <string name="aspect_ratio_experiment_title" msgid="128614319422121040">"Raporti i pamjes (eksperiment)"</string>
    <string name="aspect_ratio_labs_title" msgid="6733893837442759383">"Raporti i pamjes (laboratorët)"</string>
    <string name="aspect_ratio_experimental_label" msgid="6319009297672567578">"Eksperimental"</string>
    <string name="aspect_ratio_experiment_label" msgid="7861871612376167784">"Eksperiment"</string>
    <string name="aspect_ratio_labs_label" msgid="7008498116297651342">"Laboratorët"</string>
    <string name="accessibility_fingerprint_label" msgid="5017431423168191733">"Sensori i gjurmës së gishtit"</string>
    <string name="flash_notifications_title" msgid="4490438861180492311">"Njoftimet me blic"</string>
    <string name="flash_notifications_about_title" msgid="9004351252928121214">"Rreth njoftimeve me blic"</string>
    <string name="flash_notifications_summary_off" msgid="6056282996770691461">"Çaktivizuar"</string>
    <string name="flash_notifications_summary_on_camera" msgid="3286405833586333730">"Aktiv/Blici i kamerës"</string>
    <string name="flash_notifications_summary_on_screen" msgid="9040640799633336219">"Aktiv/Blici i ekranit"</string>
    <string name="flash_notifications_summary_on_camera_and_screen" msgid="2326268141063768701">"Aktiv/Blici i kamerës dhe ekranit"</string>
    <string name="flash_notifications_intro" msgid="8409873413480928249">"Ndiz dritën e kamerës ose ekranin kur merr njoftime ose kur tingëllojnë alarme"</string>
    <string name="flash_notifications_intro_without_camera_flash" msgid="6297337174487793891">"Ndiz ekranin kur merr njoftime ose kur tingëllojnë alarme"</string>
    <string name="flash_notifications_note" msgid="2426125248448055075">"Përdori me kujdes njoftimet me blic nëse je i ndjeshëm ndaj dritës"</string>
    <string name="flash_notifications_keywords" msgid="2458759275318514836">"blic, dritë, vështirësi në dëgjim, humbje dëgjimi"</string>
    <string name="flash_notifications_preview" msgid="5320176885050440874">"Pamja paraprake"</string>
    <string name="camera_flash_notification_title" msgid="2475084876382922732">"Blici i kamerës"</string>
    <string name="screen_flash_notification_title" msgid="3773100725793316708">"Blici i ekranit"</string>
    <string name="screen_flash_notification_color_title" msgid="7213407653340970790">"Ngjyra e blicit të ekranit"</string>
    <string name="screen_flash_color_blue" msgid="3585766657607931371">"Blu"</string>
    <string name="screen_flash_color_azure" msgid="8691198532944992243">"E kaltër"</string>
    <string name="screen_flash_color_cyan" msgid="6878780006173747267">"E bruztë"</string>
    <string name="screen_flash_color_spring_green" msgid="4466548514738457815">"E gjelbër pranverore"</string>
    <string name="screen_flash_color_green" msgid="8418019648507964564">"E gjelbër"</string>
    <string name="screen_flash_color_chartreuse_green" msgid="7456381649919010366">"E gjelbër në të verdhë"</string>
    <string name="screen_flash_color_yellow" msgid="7413465411615454556">"E verdhë"</string>
    <string name="screen_flash_color_orange" msgid="979177126315557656">"Portokalli"</string>
    <string name="screen_flash_color_red" msgid="8954162219886445491">"E kuqe"</string>
    <string name="screen_flash_color_rose" msgid="1216848195972231251">"Trëndafil"</string>
    <string name="screen_flash_color_magenta" msgid="7726221666557102155">"E purpurt"</string>
    <string name="screen_flash_color_violet" msgid="1279950780509029495">"Vjollcë"</string>
    <string name="color_selector_dialog_done" msgid="121253968943363376">"U krye"</string>
    <string name="color_selector_dialog_cancel" msgid="8667350644753900701">"Anulo"</string>
    <string name="contrast_title" msgid="6885768151336508075">"Kontrasti"</string>
    <string name="contrast_standard" msgid="1097297089917185235">"Standard"</string>
    <string name="contrast_medium" msgid="384414510709285811">"Mesatar"</string>
    <string name="contrast_high" msgid="3988567609694797696">"I lartë"</string>
    <string name="dock_multi_instances_not_supported_text" msgid="3513493664467667084">"Ky aplikacion mund të hapet vetëm në 1 dritare"</string>
    <string name="generic_accessibility_service_on" msgid="4466229372357726824">"Aktive"</string>
    <string name="generic_accessibility_service_off" msgid="4759859497651675724">"Joaktive"</string>
    <string name="generic_accessibility_feature_shortcut_off" msgid="4022872394514077907">"Joaktive"</string>
    <string name="accessibility_shortcut_state_off" msgid="8158137799007601475">"Çaktivizuar"</string>
    <string name="daltonizer_state_on" msgid="131013270022603983">"Aktivizuar"</string>
    <string name="daltonizer_state_off" msgid="1162285688069856179">"Çaktivizuar"</string>
    <string name="color_inversion_state_on" msgid="1160969033636440368">"Aktivizuar"</string>
    <string name="color_inversion_state_off" msgid="6925638668080451724">"Çaktivizuar"</string>
    <string name="color_inversion_feature_summary" msgid="1199876648549627647">"Kthen ekranet e ndriçuara në të errëta dhe ekranet e errëta në të ndriçuara"</string>
    <string name="magnification_feature_summary" msgid="641825267460247848">"Zmadho me shpejtësi në ekran për ta bërë përmbajtjen më të madhe"</string>
    <string name="autoclick_disabled" msgid="3213396804955002120">"Çaktivizuar"</string>
    <string name="show_captions_disabled" msgid="690650956523818755">"Çaktivizuar"</string>
    <string name="show_captions_enabled" msgid="7089043007924626">"Aktivizuar"</string>
    <string name="live_caption_disabled" msgid="3562035026547887366">"Çaktivizuar"</string>
    <string name="live_caption_enabled" msgid="5269360946200718949">"Aktivizuar"</string>
    <string name="about_phone_device_name_warning" msgid="3243226572404472381">"Emri i pajisjes sate është i dukshëm për aplikacionet që ke instaluar. 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="grammatical_gender_title" msgid="8584242850477270828">"Gjinia gramatikore"</string>
    <string name="grammatical_gender_dialog_title" msgid="8754048592099871587">"Zgjidh gjininë gramatikore"</string>
    <string name="content_protection_preference_title" msgid="5069260032659193074">"Po skanon për aplikacione mashtruese"</string>
    <string name="content_protection_preference_summary" msgid="2252393849408445391">"Kontrollo aktivitetin e aplikacioneve për mashtrime"</string>
    <string name="content_protection_preference_user_consent_switch_title" msgid="1797782616799594426">"Përdor skanimin për aplikacionet mashtruese"</string>
    <string name="content_protection_preference_user_consent_work_profile_switch_title" msgid="3004347470520916069">"Përdor skanimin për aplikacionet mashtruese për punë"</string>
    <string name="content_protection_preference_subpage_summary" msgid="3595621220981703364"></string>
    <string name="content_protection_preference_subpage_info" msgid="6890886357653365489"></string>
</resources>
