<?xml version="1.0" encoding="UTF-8"?>
<!--  Copyright (C) 2016 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="app_name" msgid="963247385700831716">"Storage Manager"</string>
    <string name="cancel" msgid="7021218262867558825">"Cancel"</string>
    <string name="storage_menu_free" msgid="1878247401436882778">"Free up space"</string>
    <string name="deletion_helper_title" msgid="3526170325226275927">"Remove items"</string>
    <string name="deletion_helper_app_summary" msgid="4904590040180275237">"<xliff:g id="DAYS">%1$d</xliff:g> days ago"</string>
    <!-- no translation found for deletion_helper_app_summary_item_size (3770886184921427886) -->
    <skip />
    <string name="deletion_helper_app_summary_never_used" msgid="2695210890063792461">"Not used in last year"</string>
    <string name="deletion_helper_app_summary_unknown_used" msgid="8576377054665785558">"Not sure when last used"</string>
    <string name="deletion_helper_free_button" msgid="1760529213407548661">"Free up <xliff:g id="FREEABLE">%1$s</xliff:g>"</string>
    <string name="deletion_helper_photos_title" msgid="2602723121486729972">"Backed up photos and videos"</string>
    <string name="deletion_helper_photos_age_summary" msgid="1820871709448371984">"Over 30 days old"</string>
    <!-- no translation found for deletion_helper_photos_summary (3194825464552700889) -->
    <skip />
    <string name="deletion_helper_downloads_title" msgid="8002058095019254694">"Downloads"</string>
    <!-- no translation found for deletion_helper_downloads_category_summary (8545989355108311347) -->
    <skip />
    <!-- no translation found for deletion_helper_downloads_summary_empty (3988054032360371887) -->
    <skip />
    <string name="deletion_helper_clear_dialog_title" msgid="9169670752655850967">"Free up space"</string>
    <string name="deletion_helper_clear_dialog_message" msgid="5196490478187120700">"<xliff:g id="CLEARABLE_BYTES">%1$s</xliff:g> of content will be removed from your device"</string>
    <string name="deletion_helper_clear_dialog_remove" msgid="863575755467985516">"Free up space"</string>
    <string name="deletion_helper_upsell_title" msgid="8512037674466762017">"Manage storage automatically?"</string>
    <string name="deletion_helper_upsell_summary" msgid="2301597713694474407">"<xliff:g id="USED">%1$s</xliff:g> now free. Let Storage Manager automatically free up space by removing backed-up content from your device?"</string>
    <string name="deletion_helper_upsell_cancel" msgid="7084167642850053889">"No, thanks"</string>
    <string name="deletion_helper_upsell_activate" msgid="7157360257760895976">"Turn on"</string>
    <string name="deletion_helper_apps_group_title" msgid="2578309121350341258">"Infrequently used apps"</string>
    <!-- no translation found for deletion_helper_apps_group_summary (360315517252452356) -->
    <skip />
    <string name="deletion_helper_automatic_title" msgid="4610119358490679299">"Automatic"</string>
    <string name="deletion_helper_manual_title" msgid="3905192395039688529">"Manual"</string>
    <string name="deletion_helper_preference_title" msgid="803484286872745892">"Free space now"</string>
    <string name="automatic_storage_manager_service_label" msgid="648592272375278978">"Automatic Storage Management Service"</string>
    <string name="automatic_storage_manager_notification_title" product="default" msgid="8480483265300964701">"Your phone is low on space"</string>
    <string name="automatic_storage_manager_notification_title" product="tablet" msgid="3150907918531844467">"Your tablet is low on space"</string>
    <string name="automatic_storage_manager_notification_summary" msgid="2267399886362245822">"Let Storage Manager free up space by automatically removing old photos and videos when your phone starts to get full again."</string>
    <string name="automatic_storage_manager_cancel_button" msgid="1826365037494962803">"No, thanks"</string>
    <string name="automatic_storage_manager_activate_button" msgid="6257070263061898041">"Turn on"</string>
    <string name="deletion_helper_photos_loading_title" msgid="2768067991066779772">"Backed up photos and videos"</string>
    <string name="deletion_helper_photos_loading_summary" msgid="8203033249458245854">"Finding items…"</string>
    <string name="deletion_helper_no_threshold" msgid="6943179204098250444">"Show all items"</string>
    <string name="deletion_helper_default_threshold" msgid="8410389370069021113">"Hide recent items"</string>
    <string name="deletion_helper_clear_dialog_message_first_time" msgid="686530413183529901">"<xliff:g id="CLEARABLE_BYTES">%1$s</xliff:g> of content will be removed from your devic"</string>
    <string name="automatic_storage_manager_activation_warning" msgid="7657017408180001078">"Your storage is now being managed by the storage manager"</string>
    <string name="empty_state_title" msgid="4033285438176545309">"Nothing to remove"</string>
    <string name="empty_state_review_items_link" msgid="8411186441239304545">"Review recent items"</string>
    <string name="empty_state_summary" msgid="8439893007424243790">"There aren\'t any older files to remove. To make space, remove recent photos, videos and apps."</string>
    <string name="app_requesting_space" msgid="857425181289960167">"<xliff:g id="APP">%1$s</xliff:g> needs <xliff:g id="CLEARABLE_BYTES">%2$s</xliff:g> of space"</string>
</resources>
