<?xml version="1.0" encoding="utf-8"?>
<!-- Copyright (C) 2008 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:xliff="urn:oasis:names:tc:xliff:document:1.2">

    <!-- Deprecated strings - Move the identifiers to this section, mark as DO NOT TRANSLATE,
         and remove the actual text.  These will be removed in a bulk operation. -->
    <!-- Do Not Translate.  Unused string. -->
    <string name="special_mailbox_name_inbox"></string>
    <!-- Do Not Translate.  Unused string. -->
    <string name="special_mailbox_display_name_inbox"></string>
    <!-- Do Not Translate.  Unused string. -->
    <string name="special_mailbox_display_name_outbox"></string>
    <!-- Do Not Translate.  Unused string. -->
    <string name="special_mailbox_display_name_drafts"></string>
    <!-- Do Not Translate.  Unused string. -->
    <string name="special_mailbox_display_name_trash"></string>
    <!-- Do Not Translate.  Unused string. -->
    <string name="special_mailbox_display_name_sent"></string>
    <!-- Do Not Translate.  Unused string. -->
    <string name="special_mailbox_display_name_junk"></string>
    <!-- Do Not Translate.  Unused string. -->
    <string name="account_setup_incoming_security_ssl_optional_label"></string>
    <!-- Do Not Translate.  Unused string. -->
    <string name="account_setup_incoming_security_tls_optional_label"></string>

    <!-- Permissions label for reading attachments -->
    <string name="read_attachment_label">Read Email attachments</string>
    <!-- Permissions description for reading attachments -->
    <string name="read_attachment_desc">Allows this application to read your Email
        attachments.</string>
    <!-- Permissions label for accessing the main provider -->
    <string name="permission_access_provider_label">Access Email provider data</string>
    <!-- Permissions description for accessing the main provider -->
    <string name="permission_access_provider_desc">Allows this application to access your Email
        database, including received messages, sent messages, usernames and passwords.</string>

    <!-- Name of application on Home screen -->
    <string name="app_name">Email</string>
    <!-- Title of Accounts screen -->
    <string name="accounts_title">Email</string>
    <!-- Title of compose screen -->
    <string name="compose_title">Compose</string>
    <!-- Title of debug screen -->
    <string name="debug_title">Debug</string>

    <!-- Actions will be used as buttons and in menu items -->
    <skip />
    
    <!-- Used as part of a multi-step process -->
    <string name="next_action">Next</string> 
    <!--  Button name used to confirm acceptance of dialog boxes, warnings, errors, etc. -->
    <string name="okay_action">OK</string> 
    <!--  Button name used to cancel out of dialog boxes -->
    <string name="cancel_action">Cancel</string>
    <!-- Menu item/button name -->
    <string name="send_action">Send</string>
    <!-- Menu item/button name -->
    <string name="reply_action">Reply</string>
    <!-- Menu item/button name -->
    <string name="reply_all_action">Reply all</string>
    <!-- Menu item/button name -->
    <string name="delete_action">Delete</string>
    <!-- Menu item/button name -->
    <string name="forward_action">Forward</string>
    <!--  Button name used to complete a multi-step process -->
    <string name="done_action">Done</string> 
    <!-- Menu item/button name -->
    <string name="discard_action">Discard</string>
    <!-- Menu item/button name -->
    <string name="save_draft_action">Save as draft</string>
    <!-- Menu item/button name -->
    <string name="read_unread_action">Read/Unread</string>
    <!-- Menu item/button name -->
    <string name="read_action">Mark read</string>
    <!-- Menu item/button name -->
    <string name="unread_action">Mark unread</string>
    <!-- Menu item/button name -->
    <string name="favorite_action">Favorite</string>
    <!-- Menu item/button name -->
    <string name="set_star_action">Add star</string>
    <!-- Menu item/button name -->
    <string name="remove_star_action">Remove star</string>
    <!-- Menu item -->
    <string name="refresh_action">Refresh</string>
    <!-- Menu item -->
    <string name="add_account_action">Add account</string>
    <!-- Menu item -->
    <string name="deselect_all_action">Deselect all</string>
    <!-- Menu item -->
    <string name="compose_action">Compose</string>
    <!-- Menu item/button name -->
    <string name="search_action">Search</string>
    <!-- Menu item/button name -->
    <string name="open_action">Open</string>
    <!-- Menu item -->
    <string name="account_settings_action">Account settings</string>
    <!-- Menu item -->
    <string name="remove_account_action">Remove account</string>
    <!-- Menu item -->
    <string name="folders_action">Folders</string>
    <!-- Menu item -->
    <string name="accounts_action">Accounts</string>
    <!-- Menu item -->
    <string name="mark_as_read_action">Mark as read</string>
    <!-- Menu item -->
    <string name="mark_as_unread_action">Mark as unread</string>
    <!-- Menu item -->
    <string name="add_cc_bcc_action">Add Cc/Bcc</string>
    <!-- Menu item -->
    <string name="add_attachment_action">Add attachment</string>
    <!-- Menu item (debug screen) -->
    <string name="dump_settings_action">Dump settings</string>
    <!-- Appears in choose attachment dialog title -->
    <string name="choose_attachment_dialog_title">Choose attachment</string>
    <!-- Title of account context menu -->
    <string name="accounts_context_menu_title">Account options</string>
    <!-- Appears in message list view while messages are being loaded -->
    <string name="status_loading_more">Loading messages\u2026</string>
    <!-- Appears in message list view of outbox while messages are being sent -->
    <string name="status_sending_messages">Sending messages\u2026</string>
    <!-- Appears in message list view when there's a network error. -->
    <!-- Also appears in a toast, in the message viewer, when there's a network error. -->
    <string name="status_network_error">Connection error</string>
    <!-- Appears in message list view when error when trying to "Load more messages". -->
    <string name="status_sending_messages_failed">Retry sending messages</string>
    <!-- Appears in message list view when error when trying to "Load more messages". -->
    <string name="status_loading_more_failed">Retry loading more messages</string>
    <!-- Notification title in status bar -->
    <string name="notification_new_title">New email</string>
    <!-- Dialog text when we are unable to load the message for display -->
    <string name="error_loading_message_body">Unexpected error while loading message text.  Message
        may be too large to view.</string>

    <!-- Notification message in notifications window when one account has
         one or more new messages; e.g, "279 unread (someone@google.com)". -->
    <plurals name="notification_new_one_account_fmt">
        <!-- Case of one new message. -->
        <item quantity="one"><xliff:g id="unread_message_count" example="1">%d</xliff:g> unread (<xliff:g id="account">%s</xliff:g>)</item> 

        <!-- Case of "few" (small number of) new messages. -->
        <item quantity="few"><xliff:g id="unread_message_count" example="2">%d</xliff:g> unread (<xliff:g id="account">%s</xliff:g>)</item> 

        <!-- Case of a plural number of new messages. -->
        <item quantity="other"><xliff:g id="unread_message_count" example="279">%d</xliff:g> unread (<xliff:g id="account">%s</xliff:g>)</item>
    </plurals>


    <!-- Notification message in notifications window when 2+ accounts have new mail; e.g, "in 3 accounts". -->
    <plurals name="notification_new_multi_account_fmt">
        <!-- Case of "few" (small number of) accounts with unread messages. -->
        <item quantity="few">in <xliff:g id="number_accounts" example="2">%d</xliff:g> accounts</item>
        <!-- Case of plural number of accounts with unread messages. -->
        <item quantity="other">in <xliff:g id="number_accounts" example="10">%d</xliff:g> accounts</item>
    </plurals>
        
    <!-- The next set of strings are used server-side and must not be localized. -->
    <!-- Do Not Translate.  This is the name of the "inbox" folder, on the server. -->
    <string name="mailbox_name_server_inbox">Inbox</string>
    <!-- Do Not Translate.  This is the name of the "outbox" folder, on the server. -->
    <string name="mailbox_name_server_outbox">Outbox</string>
    <!-- Do Not Translate.  This is the name of the "drafts" folder, on the server. -->
    <string name="mailbox_name_server_drafts">Drafts</string>
    <!-- Do Not Translate.  This is the name of the "trash" folder, on the server. -->
    <string name="mailbox_name_server_trash">Trash</string>
    <!-- Do Not Translate.  This is the name of the "sent" folder, on the server. -->
    <string name="mailbox_name_server_sent">Sent</string>
    <!-- Do Not Translate.  This is the name of the "junk" folder, on the server. -->
    <string name="mailbox_name_server_junk">Junk</string>

    <!-- The next set of strings are used in local display and may be localized. -->
    <!-- In the UI, the inbox will be displayed with this name -->
    <string name="mailbox_name_display_inbox">Inbox</string>
    <!-- In the UI, the outbox will be displayed with this name -->
    <string name="mailbox_name_display_outbox">Outbox</string>
    <!-- In the UI, the drafts will be displayed with this name -->
    <string name="mailbox_name_display_drafts">Drafts</string>
    <!-- In the UI, the trash will be displayed with this name -->
    <string name="mailbox_name_display_trash">Trash</string>
    <!-- In the UI, the sent will be displayed with this name -->
    <string name="mailbox_name_display_sent">Sent</string>
    <!-- In the UI, the junk will be displayed with this name -->
    <string name="mailbox_name_display_junk">Junk</string>

    <!-- Version number, shown only on debug screen -->
    <string name="debug_version_fmt">Version: <xliff:g id="version">%s</xliff:g></string>
    <!-- Checkbox label, shown only on debug screen -->
    <string name="debug_enable_debug_logging_label">Enable extra debug logging?</string>
    <!-- Checkbox label, shown only on debug screen -->
    <string name="debug_enable_sensitive_logging_label">Enable sensitive information debug logging? (May show passwords in logs.)</string>
    <!-- Checkbox label, shown only on debug screen -->
    <string name="debug_enable_exchange_logging_label">Enable exchange parser logging? (Extremely verbose)</string>
    <!-- Checkbox label, shown only on debug screen -->
    <string name="debug_enable_exchange_file_logging_label">Enable exchange sd card logging?</string>

    <!-- The text in the small separator between smart folders and the accounts -->
    <string name="account_folder_list_separator_accounts">Accounts</string>
    <!-- The summary section entry in the AccountFolder list to display all inboxes -->
    <string name="account_folder_list_summary_inbox">Combined Inbox</string>
    <!-- The summary section entry in the AccountFolder list to display all unread -->
    <string name="account_folder_list_summary_unread">Unread</string>
    <!-- The summary section entry in the AccountFolder list to display all starred -->
    <string name="account_folder_list_summary_starred">Starred</string>
    <!-- The summary section entry in the AccountFolder list to display all drafts -->
    <string name="account_folder_list_summary_drafts">Drafts</string>
    <!-- The summary section entry in the AccountFolder list to display all outboxes -->
    <string name="account_folder_list_summary_outbox">Outbox</string>

    <!-- Title of the screen that shows a list of mailboxes for an account -->
    <string name="mailbox_list_title">Mailbox</string>

    <!-- Appears at the bottom of list of messages; user selects to load more messages from that folder. -->
    <string name="message_list_load_more_messages_action">Load more messages</string>
    <!-- Appears at the bottom of list of messages of outbox;
         user selects to send pending messages. -->
    <string name="message_list_send_pending_messages_action">Send outgoing messages</string>
    <!-- Appears at the title bar of list of messages. -->
    <string name="message_list_title"><xliff:g id="account">%s</xliff:g>: <xliff:g id="mailbox">%s</xliff:g></string>
    <!-- Hint text in To field -->
    <string name="message_compose_to_hint">To</string>
    <!-- Hint text in Cc field -->
    <string name="message_compose_cc_hint">Cc</string>
    <!-- Hint text in Bcc field -->
    <string name="message_compose_bcc_hint">Bcc</string>
    <!-- Hint text in Subject field -->
    <string name="message_compose_subject_hint">Subject</string>
    <!-- Hint text in Message composer body field -->
    <string name="message_compose_body_hint">Compose Mail</string>    
    <!-- Header for forwarded original messages -->
    <string name="message_compose_fwd_header_fmt">\n\n-------- Original Message --------\nSubject: <xliff:g id="subject">%s</xliff:g>\nFrom: <xliff:g id="sender">%s</xliff:g>\nTo: <xliff:g id="to">%s</xliff:g>\nCC: <xliff:g id="cc">%s</xliff:g>\n\n</string>
    <!-- Header for replied-to messages -->
    <string name="message_compose_reply_header_fmt">\n\n<xliff:g id="sender">%s</xliff:g> wrote:\n\n</string>
    <!-- Heading that appears before forwarded text -->
    <string name="message_compose_quoted_text_label">Quoted text</string>
    <!-- Toast that appears if you try to send with no recipients. -->
    <string name="message_compose_error_no_recipients">You must add at least one recipient.</string>
    <!-- An address field contains invalid email addresses. -->
    <string name="message_compose_error_invalid_email">Some email addresses are invalid.</string>
    <!-- Toast that appears in the context of forwarding a message with attachment(s) -->
    <string name="message_compose_attachments_skipped_toast">Some attachments cannot be forwarded because they have not downloaded.</string>
    <!-- Toast that appears when an attachment is too big to send. -->
    <string name="message_compose_attachment_size">File too large to attach.</string>
    <!-- Display name for composed message, indicating the destination of the message.
      e.g. "John and 2 others" -->
    <string name="message_compose_display_name"><xliff:g id="name" example="John">%1$s</xliff:g> and <xliff:g id="number" example="27">%2$d</xliff:g> others</string>
    <!-- Label for To field in read message view -->
    <string name="message_view_to_label">To:</string>
    <!-- Label for CC field in read message view -->
    <string name="message_view_cc_label">Cc:</string>
    <!-- Menu item -->
    <string name="message_view_attachment_view_action">Open</string>
    <!-- Button name -->
    <string name="message_view_attachment_download_action">Save</string>
    <!-- Toast after saving attachment -->
    <string name="message_view_status_attachment_saved">Attachment saved to SD card as <xliff:g id="filename">%s</xliff:g>.</string>
    <!-- Toast after attachment could not be saved-->
    <string name="message_view_status_attachment_not_saved">Unable to save attachment to SD card.</string>
    <!-- Displayed in message view -->
    <string name="message_view_show_pictures_instructions">Select \"Show pictures\" to display embedded pictures.</string>
    <!-- Button on email opened for reading -->
    <string name="message_view_show_pictures_action">Show pictures</string>
    <!-- Toast while fetching attachment -->
    <string name="message_view_fetching_attachment_toast">Fetching attachment.</string>
    <!-- Appears progress dialog for fetching attachment -->
    <string name="message_view_fetching_attachment_progress">Fetching attachment <xliff:g id="filename">%s</xliff:g></string>
    <!-- Toast shown briefly while deleting a message -->
    <string name="message_deleted_toast">Message deleted.</string>
    <!-- Toast shown briefly while deleting an unsent (draft) message -->
    <string name="message_discarded_toast">Message discarded.</string>
    <!-- Toast shown briefly while saving a draft -->
    <string name="message_saved_toast">Message saved as draft.</string>
    <!-- Dialog title when prompting before creating a contact from incoming email -->
    <string name="add_contact_dlg_title">Add Contact</string>
    <!-- Dialog message when prompting before creating a contact from incoming email.  Includes
         the email address, e.g. "Add xyz@foo.com to contacts" -->
    <string name="add_contact_dlg_message_fmt">Add \"<xliff:g id="email">%s</xliff:g>\" to contacts
        </string>
    <!-- String that is displayed when the attachment could not be displayed. -->
    <string name="message_view_display_attachment_toast">This attachment cannot be displayed.</string>

    <!-- Title of screen when setting up new email account -->
    <string name="account_setup_basics_title">Set up email</string>
    <!-- On "Set up email" screen, enthusiastic welcome message. -->
    <string name="accounts_welcome">You can configure Email for most accounts in just a few steps.
        </string>
    <!-- On "Set up email" screen, enthusiastic welcome message (in EAS mode). -->
    <string name="accounts_welcome_exchange">You can configure an Exchange account in just a few
        steps.</string>
    <!-- On "Set up email" screen, brief instructions -->
    <!--  DEPRECATED - REMOVE -->
    <string name="account_setup_basics_instructions"></string>
    <!-- On "Set up email" screen, hint for account email address text field -->
    <string name="account_setup_basics_email_hint">Email address</string>
    <!-- On "Set up email" screen, hint for account email password text field -->
    <string name="account_setup_basics_password_hint">Password</string>
    <!-- On "Set up email" screen, checkbox label for making this the new account be the default account -->
    <string name="account_setup_basics_default_label">Send email from this account by default.</string>
    <!-- Button name on "Set up email" screen -->
    <string name="account_setup_basics_manual_setup_action">Manual setup</string>
    <!-- Toast when we can't build a URI from the given email & password -->
    <!-- Note, the error message in the toast is purposefully vague, because I *don't* know exactly what's wrong. -->
    <string name="account_setup_username_password_toast">Please type a valid email address and password.</string>
    <!-- Title of dialog shown when a duplicate account is created -->
    <string name="account_duplicate_dlg_title">Duplicate Account</string>
    <!-- Message of dialog shown when a duplicate account is created.  The display name of
         the duplicate account is displayed. -->
    <string name="account_duplicate_dlg_message_fmt">
        This login is already in use for the account \"<xliff:g id="duplicate">%s</xliff:g>\".
    </string>

    <!-- Do Not Translate.  Activity Title for check-settings screen -->
    <string name="account_setup_check_settings_title"></string>
    <!-- On check-settings screen, this is the initially-displayed message. -->
    <string name="account_setup_check_settings_retr_info_msg">Retrieving account information\u2026</string>
    <!-- Appears on screen while system is checking incoming server settings -->
    <string name="account_setup_check_settings_check_incoming_msg">Checking incoming server settings\u2026</string>
    <!-- Appears on screen while system is checking outgoing server settings -->
    <string name="account_setup_check_settings_check_outgoing_msg">Checking outgoing server settings\u2026</string>
    <!-- On check-settings screen, displayed briefly when user cancels the operation. -->
    <string name="account_setup_check_settings_canceling_msg">Canceling\u2026</string>
    <!-- Title of "Set up email" screen after success -->
    <string name="account_setup_names_title">Set up email</string>
    <!-- Text that appears on top of "Set up email" screen after successfully setting up an account -->
    <string name="account_setup_names_instructions">Your account is set up, and email is on its way!</string>
    <!-- On "Set up email" screen, label of text field -->
    <string name="account_setup_names_account_name_label">Give this account a name (optional)</string>
    <!-- On "Set up email" screen, label of text field -->
    <string name="account_setup_names_user_name_label">Your name (displayed on outgoing messages)</string>

    <!-- Activity Title for the first screen in manual setup (where you select IMAP or POP3) -->
    <string name="account_setup_account_type_title">Add new email account</string>
    <!-- "Add new email account" screen, text that appears on screen -->
    <string name="account_setup_account_type_instructions">What type of account is this?</string>
    <!-- "Add new email account" screen, button name in response to what type of account this is -->
    <string name="account_setup_account_type_pop_action">POP3 account</string>
    <!-- "Add new email account" screen, button name in response to what type of account this is -->
    <string name="account_setup_account_type_imap_action">IMAP account</string>
    <!-- "Add new email account" screen, button name in response to what type of account this is -->
    <string name="account_setup_account_type_exchange_action">Exchange account</string>
    <!-- "Incoming server settings" screen, label for text field -->
    <string name="account_setup_incoming_title">Incoming server settings</string>
    <!-- "Incoming server settings" screen, label for text field -->
    <string name="account_setup_incoming_username_label">Username</string>
    <!-- "Incoming server settings" screen, label for text field -->
    <string name="account_setup_incoming_password_label">Password</string>
    <!-- "Incoming server settings" screen, label for text field -->
    <string name="account_setup_incoming_pop_server_label">POP3 server</string>
    <!-- "Incoming server settings" screen, label for text field -->
    <string name="account_setup_incoming_imap_server_label">IMAP server</string>
    <!-- "Incoming server settings" screen, label for text field -->
    <string name="account_setup_incoming_port_label">Port</string>
    <!-- "Incoming server settings" screen, label for pop-up menu -->
    <string name="account_setup_incoming_security_label">Security type</string>
    <!-- "Incoming server settings" screen, options for "Security type" pop-up menu -->
    <string name="account_setup_incoming_security_none_label">None</string>
    <!-- "Incoming server settings" screen, options for "Security type" pop-up menu -->
    <string name="account_setup_incoming_security_ssl_trust_certificates_label">SSL (Accept all certificates)</string>
    <!-- "Incoming server settings" screen, options for "Security type" pop-up menu -->
    <string name="account_setup_incoming_security_ssl_label">SSL</string>
    <!-- "Incoming server settings" screen, options for "Security type" pop-up menu -->
    <string name="account_setup_incoming_security_tls_trust_certificates_label">TLS (Accept all certificates)</string>
    <!-- "Incoming server settings" screen, options for "Security type" pop-up menu -->
    <string name="account_setup_incoming_security_tls_label">TLS</string>
    <!-- "Incoming server settings" screen, label for pop-up menu -->
    <string name="account_setup_incoming_delete_policy_label">Delete email from server</string>
    <!-- "Incoming server settings" screen, options in pop-up menu for Delete email from server: -->
    <!-- "Incoming server settings" screen, options in pop-up menu for Delete email from server: -->
    <string name="account_setup_incoming_delete_policy_never_label">Never</string>
    <!-- "Incoming server settings" screen, options in pop-up menu for Delete email from server: -->
    <string name="account_setup_incoming_delete_policy_7days_label">After 7 days</string>
    <!-- "Incoming server settings" screen, options in pop-up menu for Delete email from server: -->
    <string name="account_setup_incoming_delete_policy_delete_label">When I delete from Inbox</string>
    
    <!-- "Incoming server settings" screen, label for setting IMAP path prefix: -->
    <string name="account_setup_incoming_imap_path_prefix_label">IMAP path prefix</string>
    <!-- "Incoming server settings" screen, hint for setting IMAP path prefix: -->
    <string name="account_setup_incoming_imap_path_prefix_hint">Optional</string>
    <!-- Title of "Outgoing server settings" screen -->
    <string name="account_setup_outgoing_title">Outgoing server settings</string>
    <!-- On "Outgoing server settings" screen, label for text field -->
    <string name="account_setup_outgoing_smtp_server_label">SMTP server</string>
    <!-- On "Outgoing server settings" screen, label for text field -->
    <string name="account_setup_outgoing_port_label">Port</string>
    <!-- On "Outgoing server settings" screen, label for pop-up menu -->
    <string name="account_setup_outgoing_security_label">Security type</string>
    <!-- On "Outgoing server settings" screen, label for check box -->
    <string name="account_setup_outgoing_require_login_label">Require sign-in.</string>
    <!-- On "Outgoing server settings" screen, label for text field -->
    <string name="account_setup_outgoing_username_label">Username</string>
    <!-- On "Outgoing server settings" screen, label for text field -->
    <string name="account_setup_outgoing_password_label">Password</string>
    
    <!-- Title of "Exchange server settings" screen -->
    <string name="account_setup_exchange_title">Exchange server settings</string>
    <!-- On "Exchange" setup screen, the name of the server -->
    <string name="account_setup_exchange_server_label">Exchange Server</string>
    <!-- On "Exchange" setup screen, the domain\\username -->
    <string name="account_setup_exchange_username_label">Domain\\Username</string>
    <!-- Deprecated: On "Exchange" setup screen, the domain name label -->
    <string name="account_setup_exchange_domain_label">Domain</string>
    <!-- Deprecated: On "Exchange" setup screen, the domain name hint -->
    <string name="account_setup_exchange_domain_hint">Enter domain here</string>
    <!-- On "Exchange" setup screen, the use-SSL checkbox label -->
    <string name="account_setup_exchange_ssl_label">Use secure connection (SSL)</string>
    <!-- On "Exchange" setup screen, the trust ssl certificates checkbox label -->
    <string name="account_setup_exchange_trust_certificates_label">Accept all SSL certificates</string>

    <!-- In Account setup options screen, Activity title -->
    <string name="account_setup_options_title">Account options</string>
    <!-- In Account setup options screen, label for email check frequency selector -->
    <string name="account_setup_options_mail_check_frequency_label">Email checking frequency</string>
    <!-- In Account setup options & Account Settings screens, label for email check frequency option -->
    <string name="account_setup_options_mail_check_frequency_never">Never</string>
    <!-- In Account setup options & Account Settings screens, label for email check frequency option -->
    <string name="account_setup_options_mail_check_frequency_push">Automatic (Push)</string>
    <!-- In Account setup options & Account Settings screens, email check frequency option -->
    <string name="account_setup_options_mail_check_frequency_5min">Every 5 minutes</string>
    <!-- In Account setup options & Account Settings screens, email check frequency option -->
    <string name="account_setup_options_mail_check_frequency_10min">Every 10 minutes</string>
    <!-- In Account setup options & Account Settings screens, email check frequency option -->
    <string name="account_setup_options_mail_check_frequency_15min">Every 15 minutes</string>
    <!-- In Account setup options & Account Settings screens, email check frequency option -->
    <string name="account_setup_options_mail_check_frequency_30min">Every 30 minutes</string>
    <!-- In Account setup options & Account Settings screens, email check frequency option -->
    <string name="account_setup_options_mail_check_frequency_1hour">Every hour</string>
    <!-- Check box label on "Set up email" screen to make this the default account -->
    <!-- Note, this should usually match the default account summary preference string -->
    <string name="account_setup_options_default_label">Send email from this account by default.</string>
    <!-- In Account setup options & Account Settings screens, check box for new-mail notification -->
    <string name="account_setup_options_notify_label">Notify me when email arrives.</string>
    <!-- In Account setup options screen, optional check box to also sync contacts -->
    <string name="account_setup_options_sync_contacts_label">Sync contacts from this account.</string>
    <!-- Dialog title when "setup" could not finish -->
    <string name="account_setup_failed_dlg_title">Setup could not finish</string>
    <!-- In Account setup options screen, label for email check frequency selector -->
    <string name="account_setup_options_mail_window_label">Amount to synchronize</string>
    <!-- In account setup options & account settings screens (exchange), sync window length  -->
    <string name="account_setup_options_mail_window_1day">One day</string>
    <!-- In account setup options & account settings screens (exchange), sync window length  -->
    <string name="account_setup_options_mail_window_3days">Three days</string>
    <!-- In account setup options & account settings screens (exchange), sync window length  -->
    <string name="account_setup_options_mail_window_1week">One week</string>
    <!-- In account setup options & account settings screens (exchange), sync window length  -->
    <string name="account_setup_options_mail_window_2weeks">Two weeks</string>
    <!-- In account setup options & account settings screens (exchange), sync window length  -->
    <string name="account_setup_options_mail_window_1month">One month</string>
    <!-- In account setup options & account settings screens (exchange), sync window length  -->
    <string name="account_setup_options_mail_window_all">All mail</string>

    <!-- "Setup could not finish" dialog text; e.g., Username or password incorrect -->
    <string name="account_setup_failed_dlg_auth_message">Username or password incorrect.</string> 
    <!-- "Setup could not finish" dialog text; e.g., Username or password incorrect\n(ERR01 Account does not exist) -->
    <string name="account_setup_failed_dlg_auth_message_fmt">Username or password incorrect.\n(<xliff:g id="error">%s</xliff:g>)</string> 

    <!-- "Setup could not finish" dialog text; e.g., Cannot safely connect to server -->
    <string name="account_setup_failed_dlg_certificate_message">Cannot safely connect to server.</string> 
    <!-- "Setup could not finish" dialog text; e.g., Cannot safely connect to server\n(TLS Not Supported) -->
    <string name="account_setup_failed_dlg_certificate_message_fmt">Cannot safely connect to server.\n(<xliff:g id="error">%s</xliff:g>)</string> 

    <!-- "Setup could not finish" dialog text; e.g., Cannot connect to server -->
    <string name="account_setup_failed_dlg_server_message">Cannot connect to server.</string> 
    <!-- "Setup could not finish" dialog text; e.g., Cannot connect to server\n(Connection timed out) -->
    <string name="account_setup_failed_dlg_server_message_fmt">Cannot connect to server.\n(<xliff:g id="error">%s</xliff:g>)</string> 

    <!-- Additional diagnostic text when TLS was required but the server doesn't support it -->
    <string name="account_setup_failed_tls_required">TLS required but not supported by server.</string>
    <!-- Additional diagnostic text when server does not support any of our authentication methods -->
    <string name="account_setup_failed_auth_required">Authentication methods are not supported by server.</string>
    <!-- Additional diagnostic text when server connection failed due to security error -->
    <string name="account_setup_failed_security">Unable to open connection to server due to security error.</string>
    <!-- Additional diagnostic text when server connection failed due to io error (connection) -->
    <string name="account_setup_failed_ioerror">Unable to open connection to server.</string>

    <!-- "Setup could not finish" dialog action button -->
    <string name="account_setup_failed_dlg_edit_details_action">Edit details</string>
    <!-- On Settings screen, section heading -->
    <string name="account_settings_title_fmt">General settings</string>
    <!-- On Settings screen, setting option name -->
    <string name="account_settings_default_label">Default account</string>
    <!-- Check box "summary" label on "Account options" screen to make this the default account -->
    <!-- Note, this should usually match the default account account setup checkbox string -->
    <string name="account_settings_default_summary">Send email from this account by default</string>
    <!-- On Settings screen, setting option name -->
    <string name="account_settings_notify_label">Email notifications</string>
    <!-- On Settings screen, summary line when called via AccountManager for Exchange accounts -->
    <string name="account_settings_exchange_summary">Sync frequency, notifications, etc.</string>
    <!-- On Settings screen, setting summary text -->
    <string name="account_settings_notify_summary">Notify in status bar when email arrives</string>
    <!-- On Settings screen, setting option name and title of dialog box that opens -->
    <string name="account_settings_mail_check_frequency_label">Email check frequency</string>
    <!-- On Settings screen, setting option name -->
    <string name="account_settings_incoming_label">Incoming settings</string>
    <!-- On Settings screen, setting option name -->
    <string name="account_settings_outgoing_label">Outgoing settings</string>
    <!-- On Settings screen, setting option name -->
    <string name="account_settings_add_account_label">Add another account</string>
    <!-- On Settings screen, setting option name -->
    <string name="account_settings_description_label">Account name</string>
    <!-- On Settings screen, setting option name -->
    <string name="account_settings_name_label">Your name</string>
    <!-- On Settings screen, section heading -->
    <string name="account_settings_notifications">Notification settings</string>

    <!-- On settings screen, sync contacts check box label -->
    <string name="account_settings_sync_contacts_enable">Sync contacts</string>
    <!-- On settings screen, sync contacts summary text -->
    <string name="account_settings_sync_contacts_summary">Also sync contacts from this account</string>

    <!-- On Settings screen, setting check box label -->
    <string name="account_settings_vibrate_enable">Vibrate</string>
    <!-- On Settings screen, setting summary text -->
    <string name="account_settings_vibrate_summary">Also vibrate when email arrives</string>
    <!-- On Settings screen, setting option name -->
    <string name="account_settings_ringtone">Select ringtone</string>
    <!-- On Settings screen, section heading -->
    <string name="account_settings_servers">Server settings</string>
    <!-- Title of Remove account confirmation dialog box -->
    <string name="account_delete_dlg_title">Remove account</string>
    <!-- Message of Remove account confirmation dialog box -->
    <string name="account_delete_dlg_instructions_fmt">The account \"<xliff:g id="account">%s</xliff:g>\" will be removed from Email.</string>

    <!-- Message that appears when user adds a Yahoo mail account. This alert has no title. -->
    <string name="provider_note_yahoo">Mailbox access is not supported for some types of
        Yahoo! mail accounts.  If you have trouble connecting, visit yahoo.com for more
        information.</string>
    <!-- Message that appears when user adds a Yahoo UK mail account. -->
    <string name="provider_note_yahoo_uk">Before setting up this email account, please visit the
        Yahoo! web site and enable POP3 email access for this account.</string>
    <!-- Message that appears when adding a Windows Live Hotmail Plus account -->
    <string name="provider_note_live">Only some \"Plus\" accounts include POP access
        allowing this program to connect. If you are not able to sign in with
        your correct email address and password, you may not have a paid
        \"Plus\" account. Please launch the Web browser to gain access to
        these mail accounts.</string>
    <!-- Message that appears when adding a T-Online account -->
    <string name="provider_note_t_online">Before setting up this email account, please visit the T-Online Web site and create a password for POP3 email access.</string>

    <!-- Name of Microsoft Exchange account type; used by AccountManager -->
    <string name="exchange_name">Corporate</string>

	<!-- Message that appears if the AccountManager cannot create the system Account -->
	<string name="system_account_create_failed">The AccountManager could not create the Account; please try again.</string>
</resources>
