<?xml version="1.0" encoding="utf-8"?>
<resources>

    <string name="app_name" translatable="false">WordPress</string>

    <!-- account setup -->
    <string name="xmlrpc_error">Couldn\'t connect. Enter the full path to xmlrpc.php on your site and try again.</string>
    <string name="xmlrpc_missing_method_error">Couldn\'t connect. Required XML-RPC methods are missing on the server.</string>
    <string name="xmlrpc_malformed_response_error">Couldn\'t connect. The WordPress installation responded with an invalid XML-RPC document.</string>
    <string name="site_timeout_error">Couldn\'t connect to the WordPress site due to Timeout error.</string>
    <string name="no_network_title">No network available</string>
    <string name="no_network_message">There is no network available</string>
    <string name="sign_out_wpcom_confirm">Disconnecting your account will remove all of @%s’s WordPress.com data from this device, including local drafts and local changes.</string>
    <string name="account_two_step_auth_enabled">This account has two step authentication enabled. Visit your security settings on WordPress.com and generate an application-specific password.</string>

    <!-- form labels -->
    <string name="select_categories">Select categories</string>
    <string name="tags_separate_with_commas">Tags (separate tags with commas)</string>
    <string name="post_content">Content (tap to add text and media)</string>
    <string name="max_thumbnail_px_width">Default Image Width</string>
    <string name="password">Password</string>
    <string name="blogs">Blogs</string>
    <string name="account_details">Account details</string>
    <string name="status">Status</string>

    <!-- comment form labels -->
    <string name="anonymous">Anonymous</string>

    <!-- general strings -->
    <string name="device">Device</string>
    <string name="post">Post</string>
    <string name="page">Page</string>
    <string name="posts">Posts</string>
    <string name="media">Media</string>
    <string name="video">Video</string>
    <string name="themes">Themes</string>
    <string name="pages">Pages</string>
    <string name="about_the_app">About the app</string>
    <string name="username">Username</string>
    <string name="cancel">Cancel</string>
    <string name="save">Save</string>
    <string name="add">Add</string>
    <string name="remove">Remove</string>
    <string name="search">Search</string>
    <string name="show">Show</string>
    <string name="hide">Hide</string>
    <string name="select_all">Select all</string>
    <string name="deselect_all">Deselect all</string>
    <string name="notification_sound">Notification sound</string>
    <string name="notification_vibrate">Vibrate</string>
    <string name="notification_blink">Blink notification light</string>
    <string name="sure_to_remove_account">Remove this site?</string>
    <string name="yes">Yes</string>
    <string name="no">No</string>
    <string name="error">Error</string>
    <string name="could_not_remove_account">Couldn\'t remove site</string>
    <string name="edit_post">Edit post</string>
    <string name="add_comment">Add comment</string>
    <string name="connection_error">Connection error</string>
    <string name="category_refresh_error">Category refresh error</string>
    <string name="incorrect_credentials">Incorrect username or password.</string>
    <string name="cancel_edit">Cancel edit</string>
    <string name="upload_full_size_image">Upload and link to full image</string>
    <string name="upload_scaled_image">Upload and link to scaled image</string>
    <string name="scaled_image_error">Enter a valid scaled width value</string>
    <string name="scaled_image">Scaled image width</string>
    <string name="immediately">Immediately</string>
    <string name="gallery_error">The media item couldn\'t be retrieved</string>
    <string name="refresh">Refresh</string>
    <string name="blog_not_found">An error occurred when accessing this blog</string>
    <string name="post_not_found">An error occurred when loading the post. Refresh your posts and try again.</string>
    <string name="sign_in">Sign in</string>
    <string name="signing_out">Signing out…</string>
    <string name="upload">Upload</string>
    <string name="learn_more">Learn more</string>
    <string name="posting_post">Posting \"%s\"</string>
    <string name="language">Language</string>
    <string name="interface_language">Interface Language</string>
    <string name="signout">Disconnect</string>
    <string name="undo">Undo</string>
    <string name="never">Never</string>
    <string name="unknown">Unknown</string>
    <string name="off">Off</string>
    <string name="could_not_load_page">Could not load page</string>
    <string name="send">Send</string>

    <string name="button_skip">Skip</string>
    <string name="button_next">Next</string>
    <string name="button_done">Done</string>

    <!-- timestamps for posts / pages -->
    <string name="today">Today</string>
    <string name="yesterday">Yesterday</string>
    <string name="days_ago">%d days ago</string>

    <!-- MediaPicker -->
    <string name="add_to_post">Add to Post</string>
    <string name="media_picker_title">Select media</string>
    <string name="take_photo">Take a photo</string>
    <string name="take_video">Take a video</string>
    <string name="tab_title_device_images">Device Images</string>
    <string name="tab_title_device_videos">Device Videos</string>
    <string name="tab_title_site_images">Site Images</string>
    <string name="tab_title_site_videos">Site Videos</string>

    <!-- Media Gallery Action Bar -->
    <string name="media_add_popup_title">Add to media library</string>
    <string name="media_add_popup_capture_photo">Capture photo</string>
    <string name="media_add_popup_capture_video">Capture video</string>
    <string name="media_add_new_media_gallery">Create gallery</string>
    <string name="media_gallery_date_range" comment="Displaying media from 2014-01-13 to 2014-01-23">Displaying media from %1$s to %2$s</string>

    <!-- CAB -->
    <string name="cab_selected">%d selected</string>

    <!-- Media Gallery -->
    <string name="all">All</string>
    <string name="images">Images</string>
    <string name="unattached">Unattached</string>
    <string name="custom_date" comment="one of the media page filter (others are all, images, unattached, custom date), after selecting Custom Date, you can choose a date range to filter media files">Custom Date</string>
    <string name="media_gallery_settings_title">Gallery settings</string>
    <string name="media_gallery_image_order">Image order</string>
    <string name="media_gallery_image_order_random">Random</string>
    <string name="media_gallery_image_order_reverse">Reverse</string>
    <string name="media_gallery_num_columns">Number of columns</string>
    <string name="media_gallery_type">Type</string>
    <string name="media_gallery_type_thumbnail_grid">Thumbnail grid</string>
    <string name="media_gallery_type_squares">Squares</string>
    <string name="media_gallery_type_tiled">Tiled</string>
    <string name="media_gallery_type_circles">Circles</string>
    <string name="media_gallery_type_slideshow">Slideshow</string>
    <string name="media_gallery_edit">Edit gallery</string>
    <string name="pick_photo">Select photo</string>
    <string name="pick_video">Select video</string>
    <string name="capture_or_pick_photo">Capture or select photo</string>
    <string name="reader_toast_err_get_post">Unable to retrieve this post</string>
    <string name="media_error_no_permission">You don\'t have permission to view the media library</string>
    <string name="media_error_no_permission_upload">You don\'t have permission to upload media to the site</string>
    <string name="access_media_permission_required">Permissions required in order to access media</string>
    <string name="add_media_permission_required">Permissions required in order to add media</string>
    <string name="media_fetching">Fetching media…</string>
    <string name="loading_videos">Loading videos</string>
    <string name="loading_images">Loading images</string>
    <string name="loading_blog_images">Fetching images</string>
    <string name="loading_blog_videos">Fetching videos</string>
    <string name="no_media">No media</string>
    <string name="no_media_sources">Couldn\'t fetch media</string>
    <string name="error_loading_images">Error loading images</string>
    <string name="error_loading_videos">Error loading videos</string>
    <string name="error_loading_blog_images">Unable to fetch images</string>
    <string name="error_loading_blog_videos">Unable to fetch videos</string>
    <string name="no_device_images">No images</string>
    <string name="no_device_videos">No videos</string>
    <string name="no_blog_images">No images</string>
    <string name="no_blog_videos">No videos</string>
    <string name="upload_queued">Queued</string>
    <string name="media_file_type">File type: %s</string>
    <string name="media_file_name">File name: %s</string>
    <string name="media_uploaded_on">Uploaded on: %s</string>
    <string name="media_dimensions">Dimensions: %s</string>

    <!-- Upload Media -->
    <string name="image_added">Image added</string>

    <!-- Edit Media -->
    <string name="media_edit_title_text">Title</string>
    <string name="media_edit_caption_text">Caption</string>
    <string name="media_edit_description_text">Description</string>
    <string name="media_edit_title_hint">Enter a title here</string>
    <string name="media_edit_caption_hint">Enter a caption here</string>
    <string name="media_edit_description_hint">Enter a description here</string>
    <string name="media_edit_success">Updated</string>
    <string name="media_edit_failure">Failed to update</string>
    <string name="saving">Saving…</string>

    <!-- Delete Media -->
    <string name="confirm_delete_media">Delete selected item?</string>
    <string name="confirm_delete_multi_media">Delete selected items?</string>
    <string name="wait_until_upload_completes">Wait until upload completes</string>
    <string name="cannot_delete_multi_media_items">Some media can\'t be deleted at this time. Try again later.</string>
    <string name="media_empty_list">No media</string>
    <string name="media_empty_list_custom_date">No media in this time interval</string>
    <string name="delete">Delete</string>

    <!-- Media details -->
    <string name="media_details_label_date_added">Added</string>
    <string name="media_details_label_date_uploaded">Uploaded</string>
    <string name="media_details_label_file_name">File name</string>
    <string name="media_details_label_file_type">File type</string>
    <string name="media_details_copy_url">Copy URL</string>
    <string name="media_details_copy_url_toast">URL copied to clipboard</string>

    <!-- tab titles -->
    <string name="tab_comments" translatable="false">@string/comments</string>

    <!-- themes -->
    <string name="themes_live_preview">Live preview</string>
    <string name="themes_details_label">Details</string>
    <string name="themes_features_label">Features</string>
    <string name="themes_fetching">Fetching themes…</string>

    <string name="theme_activate_button">Activate</string>
    <string name="theme_activating_button">Activating</string>
    <string name="theme_fetch_failed">Failed to fetch themes</string>
    <string name="theme_set_failed">Failed to set theme</string>
    <string name="theme_set_success">Successfully set theme!</string>
    <string name="theme_auth_error_title">Failed to fetch themes</string>
    <string name="theme_auth_error_message">Ensure you have the privilege to set themes</string>
    <string name="theme_current_theme">Current theme</string>
    <string name="theme_premium_theme">Premium theme</string>
    <string name="theme_no_search_result_found">Sorry, no themes found.</string>
    <string name="theme_auth_error_authenticate">Failed to fetch themes: failed authenticate user</string>

    <!-- link view -->
    <string name="link_enter_url">URL</string>
    <string name="link_enter_url_text">Link text (optional)</string>
    <string name="create_a_link">Create a link</string>

    <!-- page view -->
    <string name="title">Title</string>
    <string name="pages_empty_list">No pages yet. Why not create one?</string>
    <string name="page_id">Page</string>
    <string name="page_settings">Page settings</string>

    <!-- posts tab -->
    <string name="untitled">Untitled</string>
    <string name="local_draft">Local draft</string>
    <string name="post_uploading">Uploading</string>
    <string name="posts_empty_list">No posts yet. Why not create one?</string>
    <string name="empty_list_default">This list is empty</string>

    <!-- buttons on post cards -->
    <string name="button_edit">Edit</string>
    <string name="button_publish">Publish</string>
    <string name="button_view">View</string>
    <string name="button_preview">Preview</string>
    <string name="button_stats">Stats</string>
    <string name="button_trash">Trash</string>
    <string name="button_delete" translatable="false">@string/delete</string>
    <string name="button_more" translatable="false">@string/more</string>
    <string name="button_back">Back</string>
    <string name="button_revert">Revert</string>

    <!-- dropdown filter above post cards -->
    <string name="filter_published_posts">Published</string>
    <string name="filter_draft_posts">Drafts</string>
    <string name="filter_scheduled_posts">Scheduled</string>
    <string name="filter_trashed_posts">Trashed</string>
    <string-array name="post_filters_array" translatable="false">
        <item>@string/filter_published_posts</item>
        <item>@string/filter_draft_posts</item>
        <item>@string/filter_scheduled_posts</item>
        <item>@string/filter_trashed_posts</item>
    </string-array>

    <!-- post view -->
    <string name="post_id">Post</string>
    <string name="upload_failed">Upload failed</string>
    <string name="post_published">Post published</string>
    <string name="page_published">Page published</string>
    <string name="post_updated">Post updated</string>
    <string name="page_updated">Page updated</string>
    <string name="post_password">Password (optional)</string>
    <string name="caption">Caption (optional)</string>
    <string name="horizontal_alignment">Horizontal alignment</string>
    <string name="width">Width</string>
    <string name="featured">Use as featured image</string>
    <string name="featured_in_post">Include image in post content</string>
    <string name="out_of_memory">Device out of memory</string>
    <string name="file_not_found">Couldn\'t find the media file for upload. Was it deleted or moved?</string>
    <string name="post_excerpt">Excerpt</string>
    <string name="download">Downloading media</string>
    <string name="post_settings">Post settings</string>
    <string name="delete_post">Delete post</string>
    <string name="delete_page">Delete page</string>
    <string name="share_url">Share URL</string>
    <string name="posts_fetching">Fetching posts…</string>
    <string name="pages_fetching">Fetching pages…</string>
    <string name="toast_err_post_uploading">Unable to open post while it\'s uploading</string>

    <!-- reload drop down -->
    <string name="loading">Loading…</string>

    <!-- comment view -->
    <string name="on">on</string>
    <string name="comment_status_approved">Approved</string>
    <string name="comment_status_unapproved">Pending</string>
    <string name="comment_status_spam">Spam</string>
    <string name="comment_status_trash">Trashed</string>
    <string name="comment_status_all">All</string>
    <string name="edit_comment">Edit comment</string>
    <string name="comments_empty_list">No comments</string>
    <string name="comments_empty_list_filtered_approved">No Approved comments</string>
    <string name="comments_empty_list_filtered_pending">No Pending comments</string>
    <string name="comments_empty_list_filtered_spam">No Spam comments</string>
    <string name="comments_empty_list_filtered_trashed">No Trashed comments</string>
    <string name="comment_reply_to_user">Reply to %s</string>
    <string name="comment_trashed">Comment trashed</string>
    <string name="comment_spammed">Comment marked as spam</string>
    <string name="comment_deleted_permanently">Comment deleted</string>
    <string name="comment">Comment</string>
    <string name="comments_fetching">Fetching comments…</string>

    <!-- comment menu and buttons on comment detail - keep these short! -->
    <string name="mnu_comment_approve">Approve</string>
    <string name="mnu_comment_unapprove">Unapprove</string>
    <string name="mnu_comment_spam">Spam</string>
    <string name="mnu_comment_unspam">Not spam</string>
    <string name="mnu_comment_trash">Trash</string>
    <string name="mnu_comment_untrash">Restore</string>
    <string name="mnu_comment_delete_permanently">Delete</string>
    <string name="mnu_comment_liked">Liked</string>

    <!-- comment dialogs - must be worded to work for moderation of single/multiple comments -->
    <string name="dlg_approving_comments">Approving</string>
    <string name="dlg_unapproving_comments">Unapproving</string>
    <string name="dlg_spamming_comments">Marking as spam</string>
    <string name="dlg_trashing_comments">Sending to trash</string>
    <string name="dlg_deleting_comments">Deleting comments</string>
    <string name="dlg_confirm_trash_comments">Send to trash?</string>
    <string name="trash_yes">Trash</string>
    <string name="trash_no">Don\'t trash</string>

    <!-- comment actions -->
    <string name="reply">Reply</string>
    <string name="trash">Trash</string>
    <string name="like">Like</string>
    <string name="approve">Approve</string>
    <string name="comment_moderated_approved">Comment approved!</string>

    <!-- edit comment view -->
    <string name="author_name">Author name</string>
    <string name="author_email">Author email</string>
    <string name="author_url">Author URL</string>
    <string name="hint_comment_content">Comment</string>
    <string name="saving_changes">Saving changes</string>
    <string name="sure_to_cancel_edit_comment">Cancel editing this comment?</string>
    <string name="dlg_sure_to_delete_comment">Permanently delete this comment?</string>
    <string name="dlg_sure_to_delete_comments">Permanently delete these comments?</string>
    <string name="content_required">Comment is required</string>
    <string name="toast_comment_unedited">Comment hasn\'t changed</string>

    <!-- context menu -->
    <string name="remove_account">Remove site</string>
    <string name="blog_removed_successfully">Site removed successfully</string>

    <!-- draft actions -->
    <string name="delete_draft">Delete draft</string>
    <string name="delete_sure">Delete this draft</string>

    <!-- page actions -->
    <string name="preview_page">Preview page</string>
    <string name="deleting_page">Deleting page</string>
    <string name="page_deleted">Page deleted</string>
    <string name="delete_sure_page">Delete this page</string>
    <string name="page_trashed">Page sent to trash</string>

    <!-- post actions -->
    <string name="preview_post">Preview post</string>
    <string name="deleting_post">Deleting post</string>
    <string name="post_deleted">Post deleted</string>
    <string name="post_trashed">Post sent to trash</string>
    <string name="comment_added">Comment added successfully</string>
    <string name="delete_sure_post">Delete this post</string>
    <string name="share_url_post">Share post</string>
    <string name="share_url_page">Share page</string>
    <string name="share_link">Share link</string>
    <string name="post_not_published">Post status isn\'t published</string>
    <string name="page_not_published">Page status isn\'t published</string>
    <string name="view_in_browser">View in browser</string>
    <string name="preview">Preview</string>
    <string name="update_verb">Update</string>
    <string name="sending_content">Uploading %s content</string>
    <string name="uploading_total">Uploading %1$d of %2$d</string>

    <!-- new account view -->
    <string name="signing_in">Signing in…</string>
    <string name="no_site_error">Couldn\'t connect to the WordPress site</string>

    <!-- media selection -->
    <string name="select_photo">Select a photo from gallery</string>
    <string name="select_video">Select a video from gallery</string>
    <string name="select_from_media_library">Select from media library</string>
    <string name="select_from_new_picker">Multi-select with the new picker</string>

    <!-- category management -->
    <string name="categories">Categories</string>
    <string name="add_new_category">Add new category</string>
    <string name="add_category">Add category</string>
    <string name="category_name">Category name</string>
    <string name="category_slug">Category slug (optional)</string>
    <string name="category_desc">Category description (optional)</string>
    <string name="category_parent">Category parent (optional):</string>
    <string name="adding_cat_failed">Adding category failed</string>
    <string name="adding_cat_success">Category added successfully</string>
    <string name="cat_name_required">The category name field is required</string>
    <string name="category_automatically_renamed">Category name %1$s isn\'t valid. It has been renamed to %2$s.</string>

    <!-- action from share intents -->
    <string name="select_a_blog">Select a WordPress site</string>
    <string name="share_action_title">Add to …</string>
    <string name="share_action_post">New post</string>
    <string name="share_action_media">Media library</string>
    <string name="share_action">Share</string>
    <string name="cant_share_no_visible_blog">You can\'t share to WordPress without a visible blog</string>
    <string name="no_account">No WordPress account found, add an account and try again</string>

    <!-- file errors -->
    <string name="file_error_create">Couldn\'t create temp file for media upload. Make sure there is enough free space on your device.</string>

    <!-- SD Card errors -->
    <string name="sdcard_title">SD Card Required</string>
    <string name="sdcard_message">A mounted SD card is required to upload media</string>

    <!-- location -->
    <string name="location">Location</string>
    <string name="location_not_found">Unknown location</string>
    <string name="add_location">Add location</string>
    <string name="current_location">Current location</string>
    <string name="search_current_location">Locate</string>
    <string name="search_location">Search</string>
    <string name="edit_location">Edit</string>
    <string name="add_location_permission_required">Permission required in order to add location</string>

    <!--     Begin     -->
    <!-- Site Settings -->
    <!--               -->

    <!-- General -->
    <string name="discussion">Discussion</string>
    <string name="privacy">Privacy</string>
    <string name="related_posts">Related Posts</string>
    <string name="more">More</string>
    <string name="none">None</string>
    <string name="disabled">Disabled</string>
    <string name="comments">Comments</string>
    <string name="close_after">Close after</string>
    <string name="oldest_first">Oldest first</string>
    <string name="newest_first">Newest first</string>
    <string name="days_quantity_one">1 day</string>
    <string name="days_quantity_other">%d days</string>

    <!-- PreferenceCategory Headers -->
    <string name="site_settings_general_header">General</string>
    <string name="site_settings_account_header">Account</string>
    <string name="site_settings_writing_header">Writing</string>
    <string name="site_settings_discussion_header" translatable="false">@string/discussion</string>
    <string name="site_settings_discussion_new_posts_header">Defaults for new posts</string>
    <string name="site_settings_comments_header" translatable="false">@string/comments</string>
    <string name="site_settings_this_device_header">This device</string>
    <string name="site_settings_advanced_header">Advanced</string>

    <!-- Preference Titles -->
    <string name="site_settings_title_title">Site Title</string>
    <string name="site_settings_tagline_title">Tagline</string>
    <string name="site_settings_address_title">Address</string>
    <string name="site_settings_privacy_title" translatable="false">@string/privacy</string>
    <string name="site_settings_language_title" translatable="false">@string/language</string>
    <string name="site_settings_username_title" translatable="false">@string/username</string>
    <string name="site_settings_password_title" translatable="false">@string/password</string>
    <string name="site_settings_location_title">Enable Location</string>
    <string name="site_settings_default_category_title">Default Category</string>
    <string name="site_settings_default_format_title">Default Format</string>
    <string name="site_settings_image_original_size">Original Size</string>
    <string name="site_settings_default_image_width_title" translatable="false">@string/max_thumbnail_px_width</string>
    <string name="site_settings_upload_and_link_image_title" translatable="false">@string/upload_full_size_image</string>
    <string name="site_settings_related_posts_title" translatable="false">@string/related_posts</string>
    <string name="site_settings_more_title" translatable="false">@string/more</string>
    <string name="site_settings_allow_comments_title">Allow Comments</string>
    <string name="site_settings_send_pingbacks_title">Send Pingbacks</string>
    <string name="site_settings_receive_pingbacks_title">Receive Pingbacks</string>
    <string name="site_settings_identity_required_title">Must include name and email</string>
    <string name="site_settings_account_required_title">Users must be signed in</string>
    <string name="site_settings_close_after_title" translatable="false">@string/close_after</string>
    <string name="site_settings_sort_by_title">Sort by</string>
    <string name="site_settings_threading_title">Threading</string>
    <string name="site_settings_paging_title">Paging</string>
    <string name="site_settings_whitelist_title">Automatically approve</string>
    <string name="site_settings_multiple_links_title">Links in comments</string>
    <string name="site_settings_moderation_hold_title">Hold for Moderation</string>
    <string name="site_settings_blacklist_title">Blacklist</string>
    <string name="site_settings_delete_site_title">Delete Site</string>

    <!-- Preference Summaries -->
    <string name="site_settings_privacy_public_summary">Public</string>
    <string name="site_settings_privacy_hidden_summary">Hidden</string>
    <string name="site_settings_privacy_private_summary">Private</string>
    <string name="site_settings_threading_summary">%d levels</string>
    <string name="site_settings_whitelist_all_summary">Comments from all users</string>
    <string name="site_settings_whitelist_known_summary">Comments from known users</string>
    <string name="site_settings_whitelist_none_summary" translatable="false">@string/none</string>

    <string name="detail_approve_manual">Require manual approval for everyone\'s comments.</string>
    <string name="detail_approve_auto_if_previously_approved">Automatically approve if the user has a previously approved comment</string>
    <string name="detail_approve_auto">Automatically approve everyone\'s comments.</string>
    <string-array name="site_settings_auto_approve_details" translatable="false">
        <item>@string/detail_approve_manual</item>
        <item>@string/detail_approve_auto_if_previously_approved</item>
        <item>@string/detail_approve_auto</item>
    </string-array>

    <string name="site_settings_multiple_links_summary_zero">Require approval for more than 0 links</string>
    <string name="site_settings_multiple_links_summary_one">Require approval for more than 1 link</string>
    <string name="site_settings_multiple_links_summary_other">Require approval for more than %d links</string>
    <string name="site_settings_paging_summary_one">1 comment per page</string>
    <string name="site_settings_paging_summary_other">%d comments per page</string>

    <string name="privacy_public">Your site is visible to everyone and may be indexed by search engines</string>
    <string name="privacy_public_not_indexed">Your site is visible to everyone but asks search engines not to index it</string>
    <string name="privacy_private">Your site is visible only to you and users you approve</string>
    <string-array name="privacy_details" translatable="false">
        <item>@string/privacy_public</item>
        <item>@string/privacy_public_not_indexed</item>
        <item>@string/privacy_private</item>
    </string-array>

    <!-- Preference Entries -->
    <string name="approve_manual">No comments</string>
    <string name="approve_auto_if_previously_approved">Known users\' comments</string>
    <string name="approve_auto">All users</string>
    <string-array name="site_settings_auto_approve_entries" translatable="false">
        <item>@string/approve_manual</item>
        <item>@string/approve_auto_if_previously_approved</item>
        <item>@string/approve_auto</item>
    </string-array>

    <string-array name="site_settings_privacy_entries" translatable="false">
        <item>@string/site_settings_privacy_public_summary</item>
        <item>@string/site_settings_privacy_hidden_summary</item>
        <item>@string/site_settings_privacy_private_summary</item>
    </string-array>

    <string-array name="site_settings_sort_entries" translatable="false">
        <item>@string/oldest_first</item>
        <item>@string/newest_first</item>
    </string-array>

    <!-- Hints (long press) -->
    <string name="site_settings_title_hint">In a few words, explain what this site is about</string>
    <string name="site_settings_tagline_hint">A short description or catchy phrase to describe your blog</string>
    <string name="site_settings_address_hint">Changing your address is not currently supported</string>
    <string name="site_settings_privacy_hint">Controls who can see your site</string>
    <string name="site_settings_language_hint">Language this blog is primarily written in</string>
    <string name="site_settings_username_hint">Current user account</string>
    <string name="site_settings_password_hint">Change your password</string>
    <string name="site_settings_location_hint">Automatically add location data to your posts</string>
    <string name="site_settings_category_hint">Sets new post category</string>
    <string name="site_settings_format_hint">Sets new post format</string>
    <string name="site_settings_image_width_hint">Resizes images in posts to this width</string>
    <string name="site_settings_upload_and_link_image_hint">Enable to always upload the fullsize image</string>
    <string name="site_settings_related_posts_hint">Show or hide related posts in reader</string>
    <string name="site_settings_more_hint">View all available Discussion settings</string>
    <string name="site_settings_discussion_hint">View and change your sites discussion settings</string>
    <string name="site_settings_allow_comments_hint">Allow readers to post comments</string>
    <string name="site_settings_send_pingbacks_hint">Attempt to notify any blogs linked to from the article</string>
    <string name="site_settings_receive_pingbacks_hint">Allow link notifications from other blogs</string>
    <string name="site_settings_close_after_hint">Disallow comments after the specified time</string>
    <string name="site_settings_sort_by_hint">Determines the order comments are displayed</string>
    <string name="site_settings_threading_hint">Allow nested comments to a certain depth</string>
    <string name="site_settings_paging_hint">Display comments in chunks of a specified size</string>
    <string name="site_settings_manual_approval_hint">Comments must be manually approved</string>
    <string name="site_settings_identity_required_hint">Comment author must fill out name and e-mail</string>
    <string name="site_settings_user_account_required_hint">Users must be registered and logged in to comment</string>
    <string name="site_settings_whitelist_hint">Comment author must have a previously approved comment</string>
    <string name="site_settings_multiple_links_hint">Ignores link limit from known users</string>
    <string name="site_settings_moderation_hold_hint">Comments that match a filter are put in the moderation queue</string>
    <string name="site_settings_blacklist_hint">Comments that match a filter are marked as spam</string>
    <string name="site_settings_delete_site_hint">Removes your site data from the app</string>

    <!-- Related Posts -->
    <string name="site_settings_rp_switch_title">Show Related Posts</string>
    <string name="site_settings_rp_switch_summary">Related Posts displays relevant content from your site below your posts.</string>
    <string name="site_settings_rp_show_header_title">Show Header</string>
    <string name="site_settings_rp_show_images_title">Show Images</string>
    <string name="site_settings_rp_preview_header" translatable="false">@string/related_posts</string>
    <string name="site_settings_rp_preview1_title">Big iPhone/iPad Update Now Available</string>
    <string name="site_settings_rp_preview1_site">in \"Mobile\"</string>
    <string name="site_settings_rp_preview2_title">The WordPress for Android App Gets a Big Facelift</string>
    <string name="site_settings_rp_preview2_site">in \"Apps\"</string>
    <string name="site_settings_rp_preview3_title">Upgrade Focus: VideoPress For Weddings</string>
    <string name="site_settings_rp_preview3_site">in \"Upgrade\"</string>

    <!-- Learn More -->
    <string name="site_settings_learn_more_header" translatable="false">@string/learn_more</string>
    <string name="site_settings_learn_more_caption">You can override these settings for individual posts.</string>

    <!-- List Editors (Blacklist, Hold for Moderation) -->
    <string name="site_settings_list_editor_summary_one">1 item</string>
    <string name="site_settings_list_editor_summary_other">%d items</string>

    <string name="site_settings_list_editor_action_mode_title">Selected %1$d</string>
    <string name="site_settings_list_editor_no_items_text">No items</string>
    <string name="site_settings_list_editor_input_hint">Enter a word or phrase</string>
    <string name="site_settings_hold_for_moderation_description">When a comment contains any of these words in its content, name, URL, e-mail, or IP, it will be held in the moderation queue. You can enter partial words, so \"press\" will match \"WordPress.\"</string>
    <string name="site_settings_blacklist_description">When a comment contains any of these words in its content, name, URL, e-mail, or IP, it will be marked as spam. You can enter partial words, so \"press\" will match \"WordPress.\"</string>

    <!-- Dialogs -->
    <string name="site_settings_discussion_title" translatable="false">@string/discussion</string>
    <string name="site_settings_close_after_dialog_title">Close commenting</string>
    <string name="site_settings_paging_dialog_header">Comments per page</string>
    <string name="site_settings_paging_dialog_description">Break comment threads into multiple pages.</string>
    <string name="site_settings_threading_dialog_header">Thread up to</string>
    <string name="site_settings_threading_dialog_description">Allow comments to be nested in threads.</string>
    <string name="site_settings_close_after_dialog_header" translatable="false">@string/close_after</string>
    <string name="site_settings_close_after_dialog_description">Automatically close comments on articles.</string>
    <string name="site_settings_close_after_dialog_switch_text">Automatically close</string>
    <string name="site_settings_multiple_links_dialog_description">Require approval for comments that include more than this number of links.</string>

    <!-- Errors -->
    <string name="site_settings_unsupported_version_error">Unsupported WordPress version</string>
    <string name="site_settings_unknown_language_code_error">Language code not recognized</string>
    <string name="site_settings_disconnected_toast">Disconnected, editing disabled.</string>

    <!--               -->
    <!-- Site Settings -->
    <!--      End      -->

    <!-- preferences -->
    <string name="open_source_licenses">Open source licenses</string>
    <string name="preference_send_usage_stats">Send statistics</string>
    <string name="preference_send_usage_stats_summary">Automatically send usage statistics to help us improve WordPress for Android</string>
    <string name="preference_editor">Editor</string>
    <string name="preference_show_visual_editor">Show visual editor</string>

    <!-- stats -->
    <string name="stats">Stats</string>
    <string name="stats_for">Stats for %s</string>
    <string name="stats_other_recent_stats_label">Other Recent Stats</string>
    <string name="stats_other_recent_stats_moved_label">Looking for your Other Recent Stats? We\'ve moved them to the Insights page.</string>
    <string name="stats_view_all">View all</string>
    <string name="stats_view">View</string>
    <string name="stats_pagination_label">Page %1$s of %2$s</string>
    <string name="stats_no_activity_this_period">No activity this period</string>
    <string name="stats_default_number_zero" translatable="false">0</string>

    <!-- stats: errors -->
    <string name="stats_no_blog">Stats couldn\'t be loaded for the required blog</string>
    <string name="stats_generic_error">Required Stats couldn\'t be loaded</string>
    <string name="stats_sign_in_jetpack_different_com_account">To view your stats, sign in to the WordPress.com account you used to connect Jetpack.</string>
    <string name="stats_enable_rest_api_in_jetpack">To view your stats, enable the JSON API module in Jetpack.</string>

    <!-- stats: Widget labels -->
    <string name="stats_widget_name">WordPress Today\'s Stats</string>
    <string name="stats_widget_name_for_blog">Today\'s Stats for %1$s</string>
    <string name="stats_widget_loading_data">Loading data…</string>
    <string name="stats_widget_error_generic">Stats couldn\'t be loaded</string>
    <string name="stats_widget_error_no_account">Please login into WordPress</string>
    <string name="stats_widget_error_no_permissions">Your WordPress.com account can\'t access Stats on this blog</string>
    <string name="stats_widget_error_no_visible_blog">Stats couldn\'t be accessed without a visible blog</string>
    <string name="stats_widget_error_readd_widget">Please remove the widget and re-add it again</string>
    <string name="stats_widget_error_jetpack_no_blogid">Please access the Stats in the app, and try adding the widget later</string>

    <!-- stats: Widget Promote Dialog -->
    <string name="stats_widget_promo_title">Home Screen Stats Widget</string>
    <string name="stats_widget_promo_desc">Add the widget to your home screen to access your Stats in one click.</string>
    <string name="stats_widget_promo_ok_btn_label">Ok, got it</string>

    <!-- stats: labels for timeframes -->
    <string name="stats_timeframe_today">Today</string>
    <string name="stats_timeframe_yesterday">Yesterday</string>
    <string name="stats_timeframe_days">Days</string>
    <string name="stats_timeframe_weeks">Weeks</string>
    <string name="stats_timeframe_months">Months</string>
    <string name="stats_timeframe_years">Years</string>

    <string name="stats_views">Views</string>
    <string name="stats_visitors">Visitors</string>
    <string name="stats_likes">Likes</string>
    <string name="stats_comments" translatable="false">@string/comments</string>

    <!-- stats: labels for the views -->
    <string name="stats_view_visitors_and_views">Visitors and Views</string>
    <string name="stats_view_countries">Countries</string>
    <string name="stats_view_top_posts_and_pages">Posts &amp; Pages</string>
    <string name="stats_view_clicks">Clicks</string>
    <string name="stats_view_tags_and_categories">Tags &amp; Categories</string>
    <string name="stats_view_authors">Authors</string>
    <string name="stats_view_referrers">Referrers</string>
    <string name="stats_view_videos">Videos</string>
    <string name="stats_view_comments" translatable="false">@string/comments</string>
    <string name="stats_view_search_terms">Search Terms</string>
    <string name="stats_view_publicize">Publicize</string>
    <string name="stats_view_followers">Followers</string>

    <!-- stats: label for the entries -->
    <string name="stats_entry_country">Country</string>
    <string name="stats_entry_posts_and_pages">Title</string>
    <string name="stats_entry_clicks_link">Link</string>
    <string name="stats_entry_tags_and_categories">Topic</string>
    <string name="stats_entry_authors">Author</string>
    <string name="stats_entry_referrers">Referrer</string>
    <string name="stats_entry_video_plays">Video</string>
    <string name="stats_entry_top_commenter">Author</string>
    <string name="stats_entry_publicize">Service</string>
    <string name="stats_entry_followers">Follower</string>
    <string name="stats_entry_search_terms">Search Term</string>

    <!-- stats: label for the totals -->
    <string name="stats_totals_views">Views</string>
    <string name="stats_totals_clicks">Clicks</string>
    <string name="stats_totals_plays">Plays</string>
    <string name="stats_totals_comments" translatable="false">@string/comments</string>
    <string name="stats_totals_publicize">Followers</string>
    <string name="stats_totals_followers">Since</string>

    <!-- stats: empty list strings -->
    <string name="stats_empty_geoviews">No countries recorded</string>
    <string name="stats_empty_geoviews_desc">Explore the list to see which countries and regions generate the most traffic to your site.</string>
    <string name="stats_empty_top_posts_title">No posts or pages viewed</string>
    <string name="stats_empty_top_posts_desc">Discover what your most-viewed content is, and check how individual posts and pages perform over time.</string>
    <string name="stats_empty_referrers_title">No referrers recorded</string>
    <string name="stats_empty_referrers_desc">Learn more about your site’s visibility by looking at the websites and search engines that send the most traffic your way</string>
    <string name="stats_empty_clicks_title">No clicks recorded</string>
    <string name="stats_empty_clicks_desc">When your content includes links to other sites, you’ll see which ones your visitors click on the most.</string>
    <string name="stats_empty_top_authors_desc">Track the views on each contributor\'s posts, and zoom in to discover the most popular content by each author.</string>
    <string name="stats_empty_tags_and_categories">No tagged posts or pages viewed</string>
    <string name="stats_empty_tags_and_categories_desc">Get an overview of the most popular topics on your site, as reflected in your top posts from the past week.</string>
    <string name="stats_empty_video">No videos played</string>
    <string name="stats_empty_video_desc">If you\'ve uploaded videos using VideoPress, find out how many times they’ve been watched.</string>
    <string name="stats_empty_comments">No comments yet</string>
    <string name="stats_empty_comments_desc">If you allow comments on your site, track your top commenters and discover what content sparks the liveliest conversations, based on the most recent 1,000 comments.</string>
    <string name="stats_bar_graph_empty">No stats available</string>
    <string name="stats_empty_publicize">No publicize followers recorded</string>
    <string name="stats_empty_publicize_desc">Keep track of your followers from various social networking services using publicize.</string>
    <string name="stats_empty_followers">No followers</string>
    <string name="stats_empty_followers_desc">Keep track of your overall number of followers, and how long each one has been following your site.</string>
    <string name="stats_empty_search_terms">No search terms recorded</string>
    <string name="stats_empty_search_terms_desc">Learn more about your search traffic by looking at the terms your visitors searched for to find your site.</string>

    <!-- stats: comments -->
    <string name="stats_comments_by_authors">By Authors</string>
    <string name="stats_comments_by_posts_and_pages">By Posts &amp; Pages</string>
    <string name="stats_comments_total_comments_followers">Total posts with comment followers: %1$s</string>

    <!-- stats: referrers -->
    <string name="stats_referrers_spam">Spam</string>
    <string name="stats_referrers_unspam">Not spam</string>
    <string name="stats_referrers_marking_spam">Marking as spam</string>
    <string name="stats_referrers_marking_not_spam">Marking as not spam</string>
    <string name="stats_referrers_spam_generic_error">Something went wrong during the operation. The spam state wasn\'t changed.</string>

    <!-- stats: followers -->
    <string name="stats_followers_wpcom_selector">WordPress.com</string>
    <string name="stats_followers_email_selector">Email</string>
    <string name="stats_followers_total_wpcom">Total WordPress.com Followers: %1$s</string>
    <string name="stats_followers_total_email">Total Email Followers: %1$s</string>
    <string name="stats_followers_total_wpcom_paged">Showing %1$d - %2$d of %3$s WordPress.com Followers</string>
    <string name="stats_followers_total_email_paged">Showing %1$d - %2$d of %3$s Email Followers</string>
    <string name="stats_followers_seconds_ago">seconds ago</string>
    <string name="stats_followers_a_minute_ago">a minute ago</string>
    <string name="stats_followers_minutes">%1$d minutes</string>
    <string name="stats_followers_an_hour_ago">an hour ago</string>
    <string name="stats_followers_hours">%1$d hours</string>
    <string name="stats_followers_a_day">A day</string>
    <string name="stats_followers_days">%1$d days</string>
    <string name="stats_followers_a_month">A month</string>
    <string name="stats_followers_months">%1$d months</string>
    <string name="stats_followers_a_year">A year</string>
    <string name="stats_followers_years">%1$d years</string>

    <!-- stats: search terms -->
    <string name="stats_search_terms_unknown_search_terms">Unknown Search Terms</string>

    <!-- stats: Authors -->
    <string name="stats_unknown_author">Unknown Author</string>

    <!-- Stats: Single post details view -->
    <string name="stats_period">Period</string>
    <string name="stats_total">Total</string>
    <string name="stats_overall">Overall</string>
    <string name="stats_months_and_years">Months and Years</string>
    <string name="stats_average_per_day">Average per Day</string>
    <string name="stats_recent_weeks">Recent Weeks</string>

    <!-- Stats insights -->
    <string name="stats_insights">Insights</string>
    <string name="stats_insights_all_time">All-time posts, views, and visitors</string>
    <string name="stats_insights_today">Today\'s Stats</string>
    <string name="stats_insights_latest_post_no_title">(no title)</string>
    <string name="stats_insights_latest_post_summary">Latest Post Summary</string>
    <string name="stats_insights_latest_post_trend">It\'s been %1$s since %2$s was published. Here\'s how the post has performed so far…</string>
    <string name="stats_insights_popular">Most popular day and hour</string>
    <string name="stats_insights_most_popular_day">Most popular day</string>
    <string name="stats_insights_most_popular_hour">Most popular hour</string>
    <string name="stats_insights_most_popular_percent_views">%1$d%% of views</string>
    <string name="stats_insights_best_ever">Best Views Ever</string>

    <!-- invalid_url -->
    <string name="invalid_site_url_message">Check that the site URL entered is valid</string>
    <string name="invalid_url_message">Check that the URL entered is valid</string>

    <!-- post status -->
    <string name="publish_post">Publish</string>
    <string name="pending_review">Pending review</string>
    <string name="draft">Draft</string>
    <string name="post_private">Private</string>
    <string name="scheduled">Scheduled</string>
    <string name="trashed">Trashed</string>

    <!-- QuickPress -->
    <string name="quickpress_window_title">Select blog for QuickPress shortcut</string>
    <string name="quickpress_add_error">Shortcut name can\'t be empty</string>
    <string name="quickpress_add_alert_title">Set shortcut name</string>

    <!-- HTTP Authentication -->
    <string name="httpuser">HTTP username</string>
    <string name="httppassword">HTTP password</string>
    <string name="settings">Settings</string>
    <string name="http_credentials">HTTP credentials (optional)</string>
    <string name="http_authorization_required">Authorization required</string>

    <!-- post scheduling and password -->
    <string name="publish_date">Publish</string>
    <string name="post_format">Post format</string>
    <string name="schedule_verb">Schedule</string>

    <!-- post date selection -->
    <string name="select_date">Select date</string>
    <string name="select_time">Select time</string>

    <!-- notifications -->
    <string name="notifications">Notifications</string>
    <string name="note_reply_successful">Reply published</string>
    <string name="new_notifications">%d new notifications</string>
    <string name="more_notifications">and %d more.</string>
    <string name="reply_failed">Reply failed</string>
    <string name="notifications_empty_list">No notifications</string>
    <string name="notifications_empty_all">No notifications&#8230;yet.</string>
    <string name="notifications_empty_unread">You\'re all caught up!</string>
    <string name="notifications_empty_comments">No new comments&#8230;yet.</string>
    <string name="notifications_empty_followers">No new followers to report&#8230;yet.</string>
    <string name="notifications_empty_likes">No new likes to show&#8230;yet.</string>
    <string name="notifications_empty_action_all">Get active! Comment on posts from blogs you follow.</string>
    <string name="notifications_empty_action_unread">Reignite the conversation: write a new post.</string>
    <string name="notifications_empty_action_comments">Join a conversation: comment on posts from blogs you follow.</string>
    <string name="notifications_empty_action_followers_likes">Get noticed: comment on posts you\'ve read.</string>
    <string name="notifications_account_required">Sign in to WordPress.com for notifications</string>
    <string name="notifications_empty_view_reader">View Reader</string>
    <string name="older_two_days">Older than 2 days</string>
    <string name="older_last_week">Older than a week</string>
    <string name="older_month">Older than a month</string>
    <string name="error_notification_open">Could not open notification</string>
    <string name="ignore">Ignore</string>
    <string name="push_auth_expired">The request has expired. Sign in to WordPress.com to try again.</string>
    <string name="unread">Unread</string>
    <string name="follows">Follows</string>

    <!-- Notification Settings -->
    <string name="notification_settings">Notification Settings</string>
    <string name="notifications_sights_and_sounds">Sights and Sounds</string>
    <string name="your_sites">Your Sites</string>
    <string name="notifications_account_emails_summary">We\'ll always send important emails regarding your account, but you can get some helpful extras, too.</string>
    <string name="notifications_account_emails">Email from WordPress.com</string>
    <string name="notifications_wpcom_updates">WordPress.com Updates</string>
    <string name="notifications_other">Other</string>
    <string name="notifications_comments_other_blogs">Comments on other sites</string>
    <string name="notifications_tab">Notifications tab</string>
    <string name="email">Email</string>
    <string name="email_address">Email address</string>
    <string name="app_notifications">App notifications</string>
    <string name="comment_likes">Comment likes</string>
    <string name="replies_to_your_comments">Replies to your comments</string>
    <string name="error_loading_notifications">Couldn\'t load notification settings</string>
    <string name="notification_types">Notification Types</string>
    <string name="notifications_disabled">App notifications have been disabled. Tap here to enable them in Settings.</string>
    <string name="notifications_tab_summary">Settings for notifications that appear in the Notifications tab.</string>
    <string name="notifications_email_summary">Settings for notifications that are sent to the email tied to your account.</string>
    <string name="notifications_push_summary">Settings for notifications that appear on your device.</string>
    <string name="search_sites">Search sites</string>
    <string name="notifications_no_search_results">No sites matched \'%s\'</string>

    <string name="comments_on_my_site">Comments on my site</string>
    <string name="likes_on_my_comments">Likes on my comments</string>
    <string name="likes_on_my_posts">Likes on my posts</string>
    <string name="site_follows">Site follows</string>
    <string name="site_achievements">Site achievements</string>
    <string name="username_mentions">Username mentions</string>
    <string-array name="notifications_blog_settings" translatable="false">
        <item>@string/comments_on_my_site</item>
        <item>@string/likes_on_my_comments</item>
        <item>@string/likes_on_my_posts</item>
        <item>@string/site_follows</item>
        <item>@string/site_achievements</item>
        <item>@string/username_mentions</item>
    </string-array>

    <string name="replies_to_my_comments">Replies to my comments</string>
    <string-array name="notifications_other_settings" translatable="false">
        <item>@string/replies_to_my_comments</item>
        <item>@string/likes_on_my_comments</item>
    </string-array>

    <string name="notif_suggestions">Suggestions</string>
    <string name="notif_research">Research</string>
    <string name="notif_community">Community</string>
    <string-array name="notifications_wpcom_settings" translatable="false">
        <item>@string/notif_suggestions</item>
        <item>@string/notif_research</item>
        <item>@string/notif_community</item>
    </string-array>

    <string name="notif_tips">Tips for getting the most out of WordPress.com.</string>
    <string name="notif_surveys">Opportunities to participate in WordPress.com research &amp; surveys.</string>
    <string name="notif_events">Information on WordPress.com courses and events (online &amp; in-person).</string>
    <string-array name="notifications_wpcom_settings_summaries" translatable="false">
        <item>@string/notif_tips</item>
        <item>@string/notif_surveys</item>
        <item>@string/notif_events</item>
    </string-array>

    <!-- reader -->
    <string name="reader">Reader</string>

    <!-- editor -->
    <string name="editor_post_title_placeholder">Post Title</string>
    <string name="editor_page_title_placeholder">Page Title</string>
    <string name="editor_content_placeholder">Share your story here…</string>
    <string name="visual_editor_enabled">Visual Editor enabled</string>
    <string name="new_editor_promo_button_label">Great, thanks!</string>
    <string name="new_editor_promo_title">Brand new editor</string>
    <string name="new_editor_promo_desc">The WordPress app for Android now includes a beautiful new visual
    editor. Try it out by creating a new post.</string>
    <string name="new_editor_reflection_error">Visual editor is not compatible with your device. It was
        automatically disabled.</string>

    <!-- editor post settings -->
    <string name="editor_post_settings_featured_image">Featured Image</string>
    <string name="editor_post_settings_set_featured_image">Set Featured Image</string>


    <!-- Post Formats -->
    <string name="post_format_aside">Aside</string>
    <string name="post_format_audio">Audio</string>
    <string name="post_format_chat">Chat</string>
    <string name="post_format_gallery">Gallery</string>
    <string name="post_format_image">Image</string>
    <string name="post_format_link">Link</string>
    <string name="post_format_quote">Quote</string>
    <string name="post_format_standard">Standard</string>
    <string name="post_format_status">Status</string>
    <string name="post_format_video">Video</string>
    <string-array name="post_formats_array" translatable="false">
        <item>@string/post_format_aside</item>
        <item>@string/post_format_audio</item>
        <item>@string/post_format_chat</item>
        <item>@string/post_format_gallery</item>
        <item>@string/post_format_image</item>
        <item>@string/post_format_link</item>
        <item>@string/post_format_quote</item>
        <item>@string/post_format_standard</item>
        <item>@string/post_format_status</item>
        <item>@string/post_format_video</item>
    </string-array>

    <!-- Menu Buttons -->
    <string name="new_post">New post</string>
    <string name="new_media">New media</string>
    <string name="edit_media">Edit media</string>
    <string name="view_site">View site</string>

    <!-- Image Alignment -->
    <string name="image_alignment">Alignment</string>

    <string name="alignment_none">None</string>
    <string name="alignment_left">Left</string>
    <string name="alignment_center">Center</string>
    <string name="alignment_right">Right</string>

    <string-array name="alignment_key_array" translatable="false">
        <item>none</item>
        <item>left</item>
        <item>center</item>
        <item>right</item>
    </string-array>

    <string-array name="alignment_array" translatable="false">
        <item>@string/alignment_none</item>
        <item>@string/alignment_left</item>
        <item>@string/alignment_center</item>
        <item>@string/alignment_right</item>
    </string-array>

    <!-- About View -->
    <string name="app_title">WordPress for Android</string>
    <string name="publisher">Publisher:</string>
    <string name="automattic_inc" translatable="false">Automattic, Inc</string>
    <string name="automattic_url" translatable="false">automattic.com</string>
    <string name="version">Version</string>
    <string name="tos">Terms of Service</string>
    <string name="privacy_policy">Privacy policy</string>

    <!-- Remote Post Changes -->
    <string name="local_changes">Local changes</string>

    <!-- message on post preview explaining what local changes, local drafts and drafts are -->
    <string name="local_changes_explainer">This post has local changes which haven\'t been published</string>
    <string name="local_draft_explainer">This post is a local draft which hasn\'t been published</string>
    <string name="draft_explainer">This post is a draft which hasn\'t been published</string>

    <!-- message on post preview explaining links are disabled -->
    <string name="preview_screen_links_disabled">Links are disabled on the preview screen</string>

    <string name="ok">OK</string>
    <string name="image_settings">Image settings</string>
    <string name="add_account_blog_url">Blog address</string>
    <string name="wordpress_blog">WordPress blog</string>
    <string name="blogusername">blogusername</string>
    <string name="dot_wordpress_dot_com_url" translatable="false">.wordpress.com</string>
    <string name="wordpress_dot_com" translatable="false">wordpress.com</string>

    <!-- Error Messages -->
    <string name="error_delete_post">An error occurred while deleting the %s</string>
    <!-- The following messages can\'t be factorized due to i18n -->
    <string name="error_refresh_posts">Posts couldn\'t be refreshed at this time</string>
    <string name="error_refresh_pages">Pages couldn\'t be refreshed at this time</string>
    <string name="error_refresh_notifications">Notifications couldn\'t be refreshed at this time</string>
    <string name="error_refresh_comments">Comments couldn\'t be refreshed at this time</string>
    <string name="error_refresh_comments_showing_older">Comments couldn\'t be refreshed at this time - showing older comments</string>
    <string name="error_refresh_stats">Stats couldn\'t be refreshed at this time</string>
    <string name="error_refresh_media">Something went wrong while refreshing the media library. Try again later.</string>

    <string name="error_refresh_unauthorized_comments">You don\'t have permission to view or edit comments</string>
    <string name="error_refresh_unauthorized_pages">You don\'t have permission to view or edit pages</string>
    <string name="error_refresh_unauthorized_posts">You don\'t have permission to view or edit posts</string>
    <string name="error_fetch_my_profile">Couldn\'t retrieve your profile</string>
    <string name="error_fetch_account_settings">Couldn\'t retrieve your account settings</string>
    <string name="error_post_my_profile">Couldn\'t save your profile</string>
    <string name="error_post_my_profile_no_connection">No connection, couldn\'t save your profile</string>
    <string name="error_post_account_settings">Couldn\'t save your account settings</string>
    <string name="error_generic">An error occurred</string>
    <string name="error_moderate_comment">An error occurred while moderating</string>
    <string name="error_edit_comment">An error occurred while editing the comment</string>
    <string name="error_publish_empty_post">Can\'t publish an empty post</string>
    <string name="error_publish_no_network">Can\'t publish while there is no connection. Saved as draft.</string>
    <string name="error_upload">An error occurred while uploading the %s</string>
    <string name="error_media_upload">An error occurred while uploading media</string>
    <string name="error_media_upload_connection">A connection error occurred while uploading media</string>
    <string name="error_blog_hidden">This blog is hidden and couldn\'t be loaded. Enable it again in settings and try again.</string>
    <string name="fatal_db_error">An error occurred while creating the app database. Try reinstalling the app.</string>
    <string name="error_copy_to_clipboard">An error occurred while copying text to clipboard</string>
    <string name="error_fetch_remote_site_settings">Couldn\'t retrieve site info</string>
    <string name="error_post_remote_site_settings">Couldn\'t save site info</string>
    <string name="error_open_list_from_notification">This post or page was published on another site</string>
    <string name="error_fetch_users_list">Couldn\'t retrieve site users</string>
    <string name="error_fetch_followers_list">Couldn\'t retrieve site followers</string>
    <string name="error_fetch_email_followers_list">Couldn\'t retrieve site email followers</string>
    <string name="error_fetch_viewers_list">Couldn\'t retrieve site viewers</string>
    <string name="error_update_role">Couldn\'t update user role</string>
    <string name="error_remove_user">Couldn\'t remove user</string>
    <string name="error_remove_follower">Couldn\'t remove follower</string>
    <string name="error_remove_viewer">Couldn\'t remove viewer</string>

    <!-- Image Descriptions for Accessibility -->
    <string name="content_description_add_media">Add media</string>
    <string name="error_load_comment">Couldn\'t load the comment</string>
    <string name="error_downloading_image">Error downloading image</string>
    <string name="cd_related_post_preview_image">Related post preview image</string>

    <!-- Passcode lock -->
    <string name="passcode_manage">Manage PIN lock</string>
    <string name="passcode_enter_passcode">Enter your PIN</string>
    <string name="passcode_enter_old_passcode">Enter your old PIN</string>
    <string name="passcode_re_enter_passcode">Re-enter your PIN</string>
    <string name="passcode_change_passcode">Change PIN</string>
    <string name="passcode_set">PIN set</string>
    <string name="passcode_wrong_passcode">Wrong PIN</string>
    <string name="passcode_preference_title">PIN lock</string>
    <string name="passcode_turn_off">Turn PIN lock off</string>
    <string name="passcode_turn_on">Turn PIN lock on</string>
    <string name="passcodelock_prompt_message">Enter your PIN</string>
    <string name="passcodelock_hint"></string>

    <!--
      Jetpack strings
    -->
    <string name="jetpack_message">The Jetpack plugin is required for stats. Do you want to install Jetpack?</string>
    <string name="jetpack_message_not_admin">The Jetpack plugin is required for stats. Contact the site administrator.</string>
    <string name="jetpack_not_found">Jetpack plugin not found</string>
    <string name="jetpack_not_connected">Jetpack plugin not connected</string>
    <string name="jetpack_not_connected_message">The Jetpack plugin is installed, but not connected to WordPress.com. Do you want to connect Jetpack?</string>

    <!--
      reader strings
    -->
    <!-- timespan shown for posts/comments published within the past 60 seconds -->
    <string name="timespan_now">now</string>

    <!-- title shown for untitled posts and blogs -->
    <string name="reader_untitled_post">(Untitled)</string>

    <!-- activity titles -->
    <string name="reader_title_applog">Application log</string>
    <string name="reader_title_blog_preview">Reader Blog</string>
    <string name="reader_title_tag_preview">Reader Tag</string>
    <string name="reader_title_post_detail">Reader Post</string>
    <string name="reader_title_related_post_detail">Related Post</string>
    <string name="reader_title_subs">Tags &amp; Blogs</string>
    <string name="reader_title_photo_viewer">%1$d of %2$d</string>
    <string name="reader_title_comments" translatable="false">@string/comments</string>
    <string name="reader_title_search_results">Search for %s</string>

    <!-- view pager titles -->
    <string name="reader_page_followed_tags">Followed tags</string>
    <string name="reader_page_followed_blogs">Followed sites</string>
    <string name="reader_page_recommended_blogs">Sites you may like</string>

    <!-- share dialog title when sharing a reader url -->
    <string name="reader_share_link">Share link</string>

    <!-- subject line when sharing a reader url -->
    <string name="reader_share_subject">Shared from %s</string>

    <!-- menu text -->
    <string name="reader_menu_tags">Edit tags and blogs</string>
    <string name="reader_menu_block_blog">Block this blog</string>

    <!-- button text -->
    <string name="reader_btn_share">Share</string>
    <string name="reader_btn_follow">Follow</string>
    <string name="reader_btn_unfollow">Following</string>

    <!-- EditText hints -->
    <string name="reader_hint_comment_on_post">Reply to post…</string>
    <string name="reader_hint_comment_on_comment">Reply to comment…</string>
    <string name="reader_hint_add_tag_or_url">Enter a URL or tag to follow</string>
    <string name="reader_hint_post_search">Search WordPress.com</string>

    <!-- TextView labels -->
    <string name="reader_label_new_posts">New posts</string>
    <string name="reader_label_new_posts_subtitle">Tap to show them</string>
    <string name="reader_label_added_tag">Added %s</string>
    <string name="reader_label_removed_tag">Removed %s</string>
    <string name="reader_label_reply">Reply</string>
    <string name="reader_label_followed_blog">Blog followed</string>
    <string name="reader_label_tag_preview">Posts tagged %s</string>
    <string name="reader_label_comments_on">Comments on</string>
    <string name="reader_label_comments_closed">Comments are closed</string>
    <string name="reader_label_comment_count_single">One comment</string>
    <string name="reader_label_comment_count_multi">%,d comments</string>
    <string name="reader_label_view_original">View original article</string>
    <string name="reader_label_follow_count">%,d followers</string>
    <string name="reader_label_submit_comment">SEND</string>
    <string name="reader_label_gap_marker">Load more posts</string>
    <string name="reader_label_post_search_explainer">Search all public WordPress.com blogs</string>
    <string name="reader_label_post_search_running">Searching…</string>
    <string name="reader_label_related_posts">Related Reading</string>
    <string name="reader_label_view_gallery">View Gallery</string>
    <string name="reader_label_image_count_one">1 image</string>
    <string name="reader_label_image_count_multi">%d images</string>

    <!-- like counts -->
    <string name="reader_label_like">Like</string>
    <string name="reader_likes_one">One person likes this</string>
    <string name="reader_likes_multi">%,d people like this</string>
    <string name="reader_likes_only_you">You like this</string>
    <string name="reader_likes_you_and_one">You and one other like this</string>
    <string name="reader_likes_you_and_multi">You and %,d others like this</string>
    <string name="reader_label_liked_by">Liked By</string>

    <string name="reader_short_like_count_none">Like</string>
    <string name="reader_short_like_count_one">1 Like</string>
    <string name="reader_short_like_count_multi">%s Likes</string>

    <string name="reader_short_comment_count_one">1 Comment</string>
    <string name="reader_short_comment_count_multi">%s Comments</string>

    <!-- toast messages -->
    <string name="reader_toast_err_comment_failed">Couldn\'t post your comment</string>
    <string name="reader_toast_err_tag_exists">You already follow this tag</string>
    <string name="reader_toast_err_tag_invalid">That isn\'t a valid tag</string>
    <string name="reader_toast_err_add_tag">Unable to add this tag</string>
    <string name="reader_toast_err_remove_tag">Unable to remove this tag</string>
    <string name="reader_toast_err_share_intent">Unable to share</string>
    <string name="reader_toast_err_view_image">Unable to view image</string>
    <string name="reader_toast_err_url_intent">Unable to open %s</string>
    <string name="reader_toast_err_get_comment">Unable to retrieve this comment</string>
    <string name="reader_toast_err_get_blog_info">Unable to show this blog</string>
    <string name="reader_toast_err_already_follow_blog">You already follow this blog</string>
    <string name="reader_toast_err_follow_blog">Unable to follow this blog</string>
    <string name="reader_toast_err_follow_blog_not_found">This blog could not be found</string>
    <string name="reader_toast_err_follow_blog_not_authorized">You are not authorized to access this blog</string>
    <string name="reader_toast_err_unfollow_blog">Unable to unfollow this blog</string>
    <string name="reader_toast_blog_blocked">Posts from this blog will no longer be shown</string>
    <string name="reader_toast_err_block_blog">Unable to block this blog</string>
    <string name="reader_toast_err_generic">Unable to perform this action</string>

    <!-- failure messages when retrieving a single reader post -->
    <string name="reader_err_get_post_generic">Unable to retrieve this post</string>
    <string name="reader_err_get_post_not_authorized">You\'re not authorized to view this post</string>
    <string name="reader_err_get_post_not_found">This post no longer exists</string>

    <!-- empty list/grid text -->
    <string name="reader_empty_posts_no_connection" translatable="false">@string/no_network_title</string>
    <string name="reader_empty_posts_request_failed">Unable to retrieve posts</string>
    <string name="reader_empty_posts_in_tag">No posts with this tag</string>
    <string name="reader_empty_posts_in_tag_updating">Fetching posts…</string>
    <string name="reader_empty_posts_in_custom_list">The sites in this list haven\'t posted anything recently</string>
    <string name="reader_empty_followed_tags">You don\'t follow any tags</string>
    <string name="reader_empty_recommended_blogs">No recommended blogs</string>
    <string name="reader_empty_followed_blogs_title">You\'re not following any sites yet</string>
    <string name="reader_empty_followed_blogs_description">But don\'t worry, just tap the icon at the top right to start exploring!</string>
    <string name="reader_empty_followed_blogs_no_recent_posts_title">No recent posts</string>
    <string name="reader_empty_followed_blogs_no_recent_posts_description">The sites you follow haven\'t posted anything recently</string>
    <string name="reader_empty_posts_liked">You haven\'t liked any posts</string>
    <string name="reader_empty_comments">No comments yet</string>
    <string name="reader_empty_posts_in_blog">This blog is empty</string>
    <string name="reader_empty_posts_in_search_title">No posts found</string>
    <string name="reader_empty_posts_in_search_description">No posts found for %s for your language</string>

    <string name="dlg_confirm_clear_search_history">Clear search history?</string>
    <string name="label_clear_search_history">Clear search history</string>

    <!-- attribution line for Discover posts, ex: "Originally posted by [AuthorName] on [BlogName] -->
    <string name="reader_discover_attribution_author_and_blog">Originally posted by %1$s on %2$s</string>
    <string name="reader_discover_attribution_author">Originally posted by %s</string>
    <string name="reader_discover_attribution_blog">Originally posted on %s</string>
    <string name="reader_discover_visit_blog">Visit %s</string>

    <!-- connection bar which appears on main activity when there's no connection -->
    <string name="connectionbar_no_connection">No connection</string>

    <!-- NUX strings -->
    <string name="create_account_wpcom">Create an account on WordPress.com</string>
    <string name="create_new_blog_wpcom">Create WordPress.com blog</string>
    <string name="new_blog_wpcom_created">WordPress.com blog created!</string>
    <string name="validating_user_data">Validating user data</string>
    <string name="validating_site_data">Validating site data</string>
    <string name="creating_your_account">Creating your account</string>
    <string name="creating_your_site">Creating your site</string>
    <string name="required_field">Required field</string>
    <string name="invalid_email_message">Your email address isn\'t valid</string>
    <string name="invalid_password_message">Password must contain at least 4 characters</string>
    <string name="invalid_username_too_short">Username must be longer than 4 characters</string>
    <string name="invalid_username_too_long">Username must be shorter than 61 characters</string>
    <string name="invalid_username_no_spaces">Username can\'t contain spaces</string>
    <string name="email_hint">Email address</string>
    <string name="agree_terms_of_service">By creating an account you agree to the fascinating %1$sTerms of Service%2$s</string>
    <string name="username_email">Email or username</string>
    <string name="site_address">Your self-hosted address (URL)</string>
    <string name="connecting_wpcom">Connecting to WordPress.com</string>
    <string name="username_only_lowercase_letters_and_numbers">Username can only contain lowercase letters (a-z) and numbers</string>
    <string name="username_required">Enter a username</string>
    <string name="username_not_allowed">Username not allowed</string>
    <string name="email_cant_be_used_to_signup">You can\'t use that email address to signup. We are having problems with them blocking some of our email. Use another email provider.</string>
    <string name="username_must_be_at_least_four_characters">Username must be at least 4 characters</string>
    <string name="username_contains_invalid_characters">Username may not contain the character “_”</string>
    <string name="username_must_include_letters">Username must have a least 1 letter (a-z)</string>
    <string name="email_invalid">Enter a valid email address</string>
    <string name="email_not_allowed">That email address isn\'t allowed</string>
    <string name="username_exists">That username already exists</string>
    <string name="email_exists">That email address is already being used</string>
    <string name="username_reserved_but_may_be_available">That username is currently reserved but may be available in a couple of days</string>
    <string name="email_reserved">That email address has already been used. Check your inbox for an activation email. If you don\'t activate you can try again in a few days.</string>
    <string name="blog_name_required">Enter a site address</string>
    <string name="blog_name_not_allowed">That site address isn\'t allowed</string>
    <string name="blog_name_no_spaced_allowed">Site address can\'t contain spaces</string>
    <string name="blog_name_must_be_at_least_four_characters">Site address must be at least 4 characters</string>
    <string name="blog_name_must_be_less_than_sixty_four_characters">The site address must be shorter than 64 characters</string>
    <string name="blog_name_contains_invalid_characters">Site address may not contain the character “_”</string>
    <string name="blog_name_cant_be_used">You may not use that site address</string>
    <string name="blog_name_only_lowercase_letters_and_numbers">Site address can only contain lowercase letters (a-z) and numbers</string>
    <string name="blog_name_must_include_letters">Site address must have at least 1 letter (a-z)</string>
    <string name="blog_name_exists">That site already exists</string>
    <string name="blog_name_reserved">That site is reserved</string>
    <string name="blog_name_reserved_but_may_be_available">That site is currently reserved but may be available in a couple days</string>
    <string name="password_invalid">You need a more secure password. Make sure to use 7 or more characters, mix uppercase and lowercase letters, numbers or special characters.</string>
    <string name="blog_name_invalid">Invalid site address</string>
    <string name="blog_title_invalid">Invalid site title</string>
    <string name="username_invalid">Invalid username</string>
    <string name="limit_reached">Limit reached. You can try again in 1 minute. Trying again before that will only increase the time you have to wait before the ban is lifted. If you think this is in error, contact support.</string>
    <string name="username_or_password_incorrect">The username or password you entered is incorrect</string>
    <string name="nux_tap_continue">Continue</string>
    <string name="nux_cannot_log_in">We can\'t log you in</string>
    <string name="nux_tutorial_get_started_title">Get started!</string>
    <string name="nux_welcome_create_account">Create account</string>
    <string name="nux_add_selfhosted_blog">Add self-hosted site</string>
    <string name="nux_oops_not_selfhosted_blog">Sign in to WordPress.com</string>
    <string name="ssl_certificate_details">Details</string>
    <string name="ssl_certificate_error">Invalid SSL certificate</string>
    <string name="ssl_certificate_ask_trust">If you usually connect to this site without problems, this error could mean that someone is trying to impersonate the site, and you shouldn\'t continue. Would you like to trust the certificate anyway?</string>
    <string name="ptr_tip_message">Tip: Pull down to refresh</string>
    <string name="verification_code">Verification code</string>
    <string name="invalid_verification_code">Invalid verification code</string>
    <string name="verify">Verify</string>
    <string name="two_step_footer_label">Enter the code from your authenticator app.</string>
    <string name="two_step_footer_button">Send code via text message</string>
    <string name="two_step_sms_sent">Check your text messages for the verification code.</string>
    <string name="sign_in_jetpack">Sign in to your WordPress.com account to connect to Jetpack.</string>
    <string name="auth_required">Sign in again to continue.</string>
    <string name="signup_succeed_signin_failed">Your account has been created but an error occured while we signed you
        in. Try to sign in with your newly created username and password.</string>
    <string name="send_link">Send link</string>
    <string name="get_a_link_sent_to_your_email_to_sign_in_instantly">Get a link sent to your email to sign in instantly</string>
    <string name="logging_in">Logging in</string>
    <string name="magic_link_unavailable_error_message">Currently unavailable. Please enter your password</string>
    <string name="check_your_email">Check your email</string>
    <string name="launch_your_email_app">Launch your email app</string>
    <string name="checking_email">Checking email</string>
    <string name="not_on_wordpress_com">Not on WordPress.com?</string>

    <!-- Help view -->
    <string name="help">Help</string>
    <string name="forgot_password">Lost your password?</string>
    <string name="nux_help_description">Visit the help center to get answers to common questions or visit the forums to ask new ones</string>
    <string name="forums">Forums</string>
    <string name="contact_us">Contact us</string>
    <string name="help_center">Help center</string>
    <string name="browse_our_faq_button">Browse our FAQ</string>
    <string name="faq_button">FAQ</string>

    <!--My Site-->
    <string name="my_site_header_external">External</string>
    <string name="my_site_header_configuration">Configuration</string>
    <string name="my_site_header_look_and_feel">Look and Feel</string>
    <string name="my_site_header_publish">Publish</string>
    <string name="my_site_btn_blog_posts">Blog Posts</string>
    <string name="my_site_btn_site_settings">Settings</string>
    <string name="my_site_btn_comments" translatable="false">@string/comments</string>
    <string name="my_site_btn_switch_site">Switch Site</string>
    <string name="my_site_btn_view_admin">View Admin</string>
    <string name="my_site_btn_view_site">View Site</string>
    <string name="my_site_no_sites_view_drake">Illustration</string>
    <string name="my_site_no_sites_view_title">You don\'t have any WordPress sites yet.</string>
    <string name="my_site_no_sites_view_subtitle">Would you like to add one?</string>

    <!-- site picker -->
    <string name="site_picker_title">Choose site</string>
    <string name="site_picker_edit_visibility">Show/hide sites</string>
    <string name="site_picker_add_site">Add site</string>
    <string name="site_picker_add_self_hosted">Add self-hosted site</string>
    <string name="site_picker_create_dotcom">Create WordPress.com site</string>
    <string name="site_picker_cant_hide_current_site">\"%s\" wasn\'t hidden because it\'s the current site</string>

    <!-- Application logs view -->
    <string name="logs_copied_to_clipboard">Application logs have been copied to the clipboard</string>

    <!-- Helpshift overridden strings -->
    <string name="hs__conversation_detail_error">Describe the problem you\'re seeing</string>
    <string name="hs__new_conversation_header">Support chat</string>
    <string name="hs__conversation_header">Support chat</string>
    <string name="hs__username_blank_error">Enter a valid name</string>
    <string name="hs__invalid_email_error">Enter a valid email address</string>

    <!--Me-->
    <string name="me_btn_app_settings">App Settings</string>
    <string name="me_btn_support">Help &amp; Support</string>
    <string name="me_btn_login_logout">Login/Logout</string>
    <string name="me_connect_to_wordpress_com">Connect to WordPress.com</string>
    <string name="me_disconnect_from_wordpress_com">Disconnect from WordPress.com</string>

    <!--TabBar Accessibility Labels-->
    <string name="tabbar_accessibility_label_my_site">My Site</string>
    <string name="tabbar_accessibility_label_me">Me</string>
    <string name="site_privacy_private_desc">I would like my site to be private, visible only to users I choose</string>
    <string name="site_privacy_hidden_desc">Discourage search engines from indexing this site</string>
    <string name="site_privacy_public_desc">Allow search engines to index this site</string>

    <!-- Static URLs -->
    <string name="privacy_settings_url" translatable="false">https://en.support.wordpress.com/privacy-settings</string>
    <string name="language_settings_url" translatable="false">https://en.support.wordpress.com/language-settings</string>
    <string name="role_info_url" translatable="false">https://en.support.wordpress.com/user-roles/</string>

    <string name="date_range_start_date">Start Date</string>
    <string name="date_range_end_date">End Date</string>

    <!-- Special characters -->
    <string name="bullet" translatable="false">\u2022</string>
    <string name="previous_button" translatable="false">&lt;</string>
    <string name="next_button" translatable="false">&gt;</string>
    <string name="vertical_line" translatable="false">\u007C</string>

    <!-- Noticons -->
    <string name="noticon_clock" translatable="false">\uf303</string>
    <string name="noticon_note" translatable="false">\uf814</string>

    <!--Theme Browser-->
    <string name="current_theme">Current Theme</string>
    <string name="customize">Customize</string>
    <string name="details">Details</string>
    <string name="support">Support</string>
    <string name="active">Active</string>

    <string name="theme_free">Free</string>
    <string name="theme_all">All</string>
    <string name="theme_premium">Premium</string>
    <string-array name="themes_filter_array" translatable="false">
        <item>@string/theme_free</item>
        <item>@string/theme_all</item>
        <item>@string/theme_premium</item>
    </string-array>

    <string name="title_activity_theme_support">Themes</string>
    <string name="theme_activate">Activate</string>
    <string name="theme_try_and_customize">Try &amp; Customize</string>
    <string name="theme_view">View</string>
    <string name="theme_details">Details</string>
    <string name="theme_support">Support</string>
    <string name="theme_done">DONE</string>
    <string name="theme_manage_site">MANAGE SITE</string>
    <string name="theme_prompt">Thanks for choosing %1$s</string>
    <string name="theme_by_author_prompt_append"> by %1$s</string>
    <string name="theme_activation_error">Something went wrong. Could not activate theme</string>
    <string name="selected_theme">Selected Theme</string>
    <string name="could_not_load_theme">Could not load theme</string>

    <!--People Management-->
    <string name="people">People</string>
    <string name="edit_user">Edit User</string>
    <string name="role">Role</string>
    <string name="follower_subscribed_since">Since %1$s</string>
    <string name="person_remove_confirmation_title">Remove %1$s</string>
    <string name="user_remove_confirmation_message">If you remove %1$s, that user will no longer be able to access this site, but any content that was created by %1$s will remain on the site.\n\nWould you still like to remove this user?</string>
    <string name="follower_remove_confirmation_message">If removed, this follower will stop receiving notifications about this site, unless they re-follow.\n\nWould you still like to remove this follower?</string>
    <string name="viewer_remove_confirmation_message">If you remove this viewer, he or she will not be able to visit this site.\n\nWould you still like to remove this viewer?</string>
    <string name="person_removed">Successfully removed %1$s</string>
    <string name="invite_people">Invite People</string>
    <string name="invite_names_title">Usernames or Emails</string>
    <string name="invite">Invite</string>
    <string name="button_invite" translatable="false">@string/invite</string>
    <string name="invite_username_not_found">%s: User not found</string>
    <string name="invite_already_a_member">%s: Already a member</string>
    <string name="invite_already_following">%s: Already following</string>
    <string name="invite_user_blocked_invites">%s: User blocked invites</string>
    <string name="invite_invalid_email">%s: Invalid email</string>
    <string name="invite_message_title">Custom Message</string>
    <string name="invite_message_remaining_zero">0 characters remaining</string>
    <string name="invite_message_remaining_one">1 character remaining</string>
    <string name="invite_message_remaining_other">%d characters remaining</string>
    <string name="invite_message_info">(Optional) You can enter a custom message of up to 500 characters that will be included in the invitation to the user(s).</string>
    <string name="invite_message_usernames_limit">Invite up to 10 email addresses and/or WordPress.com usernames. Those needing a username will be sent instructions on how to create one.</string>
    <string name="invite_error_no_usernames">Please add at least one username</string>
    <string name="invite_error_invalid_usernames_one">Cannot send: A username or email is invalid</string>
    <string name="invite_error_invalid_usernames_multiple">Cannot send: There are invalid usernames or emails</string>
    <string name="invite_error_sending">An error occurred while trying to send the invite!</string>
    <string name="invite_error_some_failed">Invite sent but error(s) occurred!</string>
    <string name="invite_error_for_username">%1$s: %2$s</string>
    <string name="invite_sent">Invite sent successfully</string>

    <string name="people_dropdown_item_team">Team</string>
    <string name="people_dropdown_item_followers">Followers</string>
    <string name="people_dropdown_item_email_followers">Email Followers</string>
    <string name="people_dropdown_item_viewers">Viewers</string>
    <string name="people_empty_list_filtered_users">You don\'t have any users yet.</string>
    <string name="people_empty_list_filtered_followers">You don\'t have any followers yet.</string>
    <string name="people_empty_list_filtered_email_followers">You don\'t have any email followers yet.</string>
    <string name="people_empty_list_filtered_viewers">You don\'t have any viewers yet.</string>
    <string name="people_fetching">Fetching users…</string>
    <string name="title_follower">Follower</string>
    <string name="title_email_follower">Email Follower</string>

    <string name="role_admin">Administrator</string>
    <string name="role_editor">Editor</string>
    <string name="role_author">Author</string>
    <string name="role_contributor">Contributor</string>
    <string name="role_follower">Follower</string>
    <string name="role_viewer">Viewer</string>

    <!--My profile-->
    <string name="my_profile">My Profile</string>
    <string name="first_name">First name</string>
    <string name="last_name">Last name</string>
    <string name="public_display_name">Public display name</string>
    <string name="public_display_name_hint">Display name will default to your username if it is not set</string>
    <string name="about_me">About me</string>
    <string name="about_me_hint">A few words about you…</string>
    <string name="start_over">Start Over</string>
    <string name="site_settings_start_over_hint">Start your site over</string>
    <string name="let_us_help">Let Us Help</string>
    <string name="start_over_text">If you want a site but don\'t want any of the posts and pages you have now, our support team can delete your posts, pages, media and comments for you.\n\nThis will keep your site and URL active, but give you a fresh start on your content creation. Just contact us to have your current content cleared out.</string>
    <string name="contact_support">Contact support</string>
    <string name="confirm_delete_site">Confirm Delete Site</string>
    <string name="confirm_delete_site_prompt">Please type in %1$s in the field below to confirm. Your site will then be gone forever.</string>
    <string name="site_settings_export_content_title">Export content</string>
    <string name="error_deleting_site">Error deleting site</string>
    <string name="error_deleting_site_summary">There was an error in deleting your site. Please contact support for more assistance</string>
    <string name="primary_domain">Primary Domain</string>
    <string name="domain_removal">Domain Removal</string>
    <string name="domain_removal_summary">Be careful! Deleting your site will also remove your domain(s) listed below.</string>
    <string name="domain_removal_hint">The domains that will not work once you remove your site</string>
    <string name="keep_your_content">Keep Your Content</string>
    <string name="export_site_summary">If you are sure, please be sure to take the time and export your content now. It can not be recovered in the future.</string>
    <string name="export_site_hint">Export your site to an XML file</string>
    <string name="are_you_sure">Are You Sure?</string>
    <string name="delete_site_summary">This action can not be undone. Deleting your site will remove all content, contributors, and domains from the site.</string>
    <string name="delete_site_hint">Delete site</string>
    <string name="delete_site_progress">Deleting site…</string>
    <string name="purchases_request_error">Something went wrong. Could not request purchases.</string>
    <string name="premium_upgrades_title">Premium Upgrades</string>
    <string name="premium_upgrades_message">You have active premium upgrades on your site. Please cancel your upgrades prior to deleting your site.</string>
    <string name="show_purchases">Show purchases</string>
    <string name="checking_purchases">Checking purchases</string>

    <!--Account Settings-->
    <string name="account_settings">Account Settings</string>
    <string name="pending_email_change_snackbar">Click the verification link in the email sent to %1$s to confirm your new address</string>
    <string name="primary_site">Primary site</string>
    <string name="web_address">Web Address</string>
    <string name="web_address_dialog_hint">Shown publicly when you comment.</string>
    <string name="exporting_content_progress">Exporting content…</string>
    <string name="export_email_sent">Export email sent!</string>
    <string name="export_your_content">Export your content</string>
    <string name="export_your_content_message">Your posts, pages, and settings will be emailed to you at %s.</string>

    <!-- Plans -->
    <string name="plan">Plan</string>
    <string name="plans">Plans</string>
    <string name="plans_loading_error">Unable to load plans</string>
    <string name="plans_manage">Manage your plan at\nWordPress.com/plans</string>
    <string name="enter_your_password_instead">Enter your password instead</string>

    <!-- Plans business post-purchase -->
    <string name="plans_post_purchase_title_intro">It\'s all yours, way to go!</string>
    <string name="plans_post_purchase_text_intro">Your site is doing somersaults in excitement! Now explore your site\'s new features and choose where you\'d like to begin.</string>
    <string name="plans_post_purchase_title_customize">Customize Fonts &amp; Colors</string>
    <string name="plans_post_purchase_text_customize">You now have access to custom fonts, custom colors, and custom CSS editing capabilities.</string>
    <string name="plans_post_purchase_button_customize">Customize my Site</string>
    <string name="plans_post_purchase_title_video">Bring posts to life with video</string>
    <string name="plans_post_purchase_text_video">You can upload and host videos on your site with VideoPress and your expanded media storage.</string>
    <string name="plans_post_purchase_button_video">Start new post</string>
    <string name="plans_post_purchase_title_themes">Find a perfect, Premium theme</string>
    <string name="plans_post_purchase_text_themes">You now have unlimited access to Premium themes. Preview any theme on your site to get started.</string>
    <string name="plans_post_purchase_button_themes">Browse Themes</string>

    <!-- gravatar -->
    <string name="gravatar_tip">New! Tap your Gravatar to change it!</string>
    <string name="error_cropping_image">Error cropping the image</string>
    <string name="error_locating_image">Error locating the cropped image</string>
    <string name="error_refreshing_gravatar">Error reloading your Gravatar</string>
    <string name="error_updating_gravatar">Error updating your Gravatar</string>
    <string name="gravatar_camera_and_media_permission_required">Permissions required in order to select or capture a photo</string>

    <!-- Editor -->
    <string name="discard">Discard</string>
    <string name="edit">Edit</string>
    <string name="tap_to_try_again">Tap to try again!</string>
    <string name="uploading">Uploading…</string>
    <string name="uploading_gallery_placeholder">Uploading gallery…</string>

    <string name="alert_insert_image_html_mode">Can\'t insert media directly in HTML mode. Please switch back to visual mode.</string>
    <string name="alert_action_while_uploading">You are currently uploading media. Please wait until this completes.</string>
    <string name="alert_error_adding_media">An error occurred while inserting media</string>

    <string name="stop_upload_dialog_title">Stop uploading?</string>
    <string name="stop_upload_button">Stop Upload</string>

    <string name="image_settings_dismiss_dialog_title">Discard unsaved changes?</string>
    <string name="image_settings_save_toast">Changes saved</string>

    <string name="image_caption">Caption</string>
    <string name="image_alt_text">Alt text</string>
    <string name="image_link_to">Link to</string>
    <string name="image_width">Width</string>

    <!-- Editor: Accessibility - format bar button descriptions -->
    <string name="format_bar_description_bold">Bold</string>
    <string name="format_bar_description_italic">Italic</string>
    <string name="format_bar_description_underline">Underline</string>
    <string name="format_bar_description_strike">Strikethrough</string>
    <string name="format_bar_description_quote">Block quote</string>
    <string name="format_bar_description_link">Insert link</string>
    <string name="format_bar_description_more">Insert more</string>
    <string name="format_bar_description_media">Insert media</string>
    <string name="format_bar_description_ul">Unordered list</string>
    <string name="format_bar_description_ol">Ordered list</string>
    <string name="format_bar_description_html">HTML mode</string>
    <string name="visual_editor">Visual editor</string>
    <string name="image_thumbnail">Image thumbnail</string>

    <!-- Editor: Errors -->
    <string name="editor_failed_uploads_switch_html">Some media uploads have failed. You can\'t switch to HTML mode
        in this state. Remove all failed uploads and continue?</string>
    <string name="editor_toast_invalid_path">Invalid file path</string>
    <string name="editor_toast_changes_saved">Changes saved</string>
    <string name="editor_toast_uploading_please_wait">You are currently uploading media. Please wait until this completes.</string>
    <string name="editor_toast_failed_uploads">Some media uploads have failed. You can\'t save or publish
        your post in this state. Would you like to remove all failed media?</string>
    <string name="editor_remove_failed_uploads">Remove failed uploads</string>

</resources>
