defaultAccountName = Name or Email
defaultAccountGroupName = Group Name
defaultBranchName = Branch Name
defaultRevisionSpec = Revision (Branch or SHA-1)

buttonDeleteIncludedGroup = Delete
buttonAddIncludedGroup = Add
buttonDeleteGroupMembers = Delete
buttonAddGroupMember = Add
buttonRenameGroup = Rename Group
buttonSaveDescription = Save Description
buttonCreateGroup = Create Group
buttonCreateProject = Create Project
buttonChangeGroupOwner = Change Owner
buttonChangeGroupType = Change Type
buttonSelectGroup = Select
buttonSaveChanges = Save Changes
checkBoxEmptyCommit = Create initial empty commit
checkBoxPermissionsOnly = Only serve as parent for other projects
buttonBrowseProjects = Browse
projects = All projects
projectRepoBrowser = Repository Browser
useContentMerge = Automatically resolve conflicts
useContributorAgreements = Require a valid contributor agreement to upload
useSignedOffBy = Require <a href="http://gerrit-documentation.googlecode.com/svn/Documentation/2.5/user-signedoffby.html#Signed-off-by" target="_blank"><code>Signed-off-by</code></a> in commit message
requireChangeID = Require <a href="http://gerrit-documentation.googlecode.com/svn/Documentation/2.5/user-changeid.html" target="_blank"><code>Change-Id</code></a> in commit message
headingGroupOptions = Group Options
isVisibleToAll = Make group visible to all registered users.
buttonSaveGroupOptions = Save Group Options
suggestedGroupLabel = group
headingParentProjectName = Rights Inherit From
parentSuggestions = Parent Suggestion
columnProjectName = Project Name

headingGroupUUID = Group UUID
headingOwner = Owners
headingDescription = Description
headingProjectOptions = Project Options
headingMembers = Members
headingIncludedGroups = Included Groups
noMembersInfo = Group Members can only be viewed for Gerrit internal groups. For external groups and Gerrit system groups the members cannot be displayed.
headingExternalGroup = Selected External Group
headingCreateGroup = Create New Group
headingAgreements = Contributor Agreements

headingProjectSubmitType = Submit Type
projectSubmitType_FAST_FORWARD_ONLY = Fast Forward Only
projectSubmitType_MERGE_IF_NECESSARY = Merge if Necessary
projectSubmitType_REBASE_IF_NECESSARY = Rebase if Necessary
projectSubmitType_MERGE_ALWAYS = Always Merge
projectSubmitType_CHERRY_PICK = Cherry Pick

headingProjectState = State
projectState_ACTIVE = Active
projectState_READ_ONLY = Read Only
projectState_HIDDEN = Hidden

columnMember = Member
columnEmailAddress = Email Address
columnGroupName = Group Name
columnGroupDescription = Description
columnGroupType = Group Type
columnGroupNotifications = Email Only Authors
columnGroupVisibleToAll = Visible To All

columnBranchName = Branch Name
columnBranchRevision = Revision
initialRevision = Initial Revision
buttonAddBranch = Create Branch
buttonDeleteBranch = Delete
branchDeletionOpenChanges = The following branches were not deleted \
because they have open changes:

groupItemHelp = group

groupListTitle = Groups
groupFilter = Filter
createGroupTitle = Create Group
groupTabGeneral = General
groupTabMembers = Members
projectListTitle = Projects
projectFilter = Filter
createProjectTitle = Create Project
projectListQueryLink = Search for changes on this project

plugins = Plugins
pluginEnabled = Enabled
pluginDisabled = Disabled
columnPluginName = Plugin Name
columnPluginVersion = Version
columnPluginStatus = Status

noGroupSelected = (No group selected)
errorNoMatchingGroups = No Matching Groups
errorNoGitRepository = No Git Repository


addPermission = Add Permission ...

# Permission Names
permissionNames = \
	abandon, \
	create, \
	deleteDrafts, \
	editTopicName, \
	forgeAuthor, \
	forgeCommitter, \
	forgeServerAsCommitter, \
	owner, \
	publishDrafts, \
	push, \
	pushMerge, \
	pushTag, \
	pushSignedTag, \
	read, \
	rebase, \
	removeReviewer, \
	submit, \
	viewDrafts

abandon = Abandon
create = Create Reference
deleteDrafts = Delete Drafts
editTopicName = Edit Topic Name
forgeAuthor = Forge Author Identity
forgeCommitter = Forge Committer Identity
forgeServerAsCommitter = Forge Server Identity
owner = Owner
publishDrafts = Publish Drafts
push = Push
pushMerge = Push Merge Commit
pushTag = Push Annotated Tag
pushSignedTag = Push Signed Tag
read = Read
rebase = Rebase
removeReviewer = Remove Reviewer
submit = Submit
viewDrafts = View Drafts

refErrorEmpty = Reference must be supplied
refErrorBeginSlash = Reference must not start with '/'
refErrorDoubleSlash = References cannot contain '//'
refErrorNoSpace = References cannot contain spaces
refErrorPrintable = References may contain only printable characters
errorsMustBeFixed = Errors must be fixed before committing changes.

# Capability Names
capabilityNames = \
  accessDatabase, \
  administrateServer, \
  createAccount, \
  createGroup, \
  createProject, \
  emailReviewers, \
  flushCaches, \
  killTask, \
  priority, \
  queryLimit, \
  runGC, \
  startReplication, \
  viewCaches, \
  viewConnections, \
  viewQueue
accessDatabase = Access Database
administrateServer = Administrate Server
createAccount = Create Account
createGroup = Create Group
createProject = Create Project
emailReviewers = Email Reviewers
flushCaches = Flush Caches
killTask = Kill Task
priority = Priority
queryLimit = Query Limit
runGC = Run Garbage Collection
startReplication = Start Replication
viewCaches = View Caches
viewConnections = View Connections
viewQueue = View Queue

# Section Names
sectionTypeReference = Reference:
sectionTypeSection = Section:
sectionNames = \
  GLOBAL_CAPABILITIES
GLOBAL_CAPABILITIES = Global Capabilities
