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
useContentMerge = Automatically resolve conflicts
useContributorAgreements = Require a valid contributor agreement to upload
useSignedOffBy = Require <a href="http://gerrit.googlecode.com/svn/documentation/2.0/user-signedoffby.html#Signed-off-by" target="_blank"><code>Signed-off-by</code></a> in commit message
requireChangeID = Require <a href="http://gerrit.googlecode.com/svn/documentation/2.0/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
headingGroupType = Group Type
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
headingCreateProject = Create New Project
headingAgreements = Contributor Agreements

projectSubmitType_FAST_FORWARD_ONLY = Fast Forward Only
projectSubmitType_MERGE_IF_NECESSARY = Merge If Necessary
projectSubmitType_MERGE_ALWAYS = Always Merge
projectSubmitType_CHERRY_PICK = Cherry Pick

projectState_ACTIVE = Active
projectState_READ_ONLY = Read Only
projectState_HIDDEN = Hidden

groupType_SYSTEM = System Group
groupType_INTERNAL = Internal Group
groupType_LDAP = LDAP Group

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

groupListPrev = Previous group
groupListNext = Next group
groupListOpen = Open group

groupListTitle = Groups
groupTabGeneral = General
groupTabMembers = Members
projectListTitle = Projects
createProjectTitle = Create Project
projectAdminTabGeneral = General
projectAdminTabBranches = Branches
projectAdminTabAccess = Access

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


addPermission = Add Permission ...

# Permission Names
permissionNames = \
	create, \
	forgeAuthor, \
	forgeCommitter, \
	forgeServerAsCommitter, \
	owner, \
	push, \
	pushMerge, \
	pushTag, \
	read, \
	rebase, \
	submit
create = Create Reference
forgeAuthor = Forge Author Identity
forgeCommitter = Forge Committer Identity
forgeServerAsCommitter = Forge Server Identity
owner = Owner
push = Push
pushMerge = Push Merge Commit
pushTag = Push Annotated Tag
read = Read
rebase = Rebase
submit = Submit

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 = \
  administrateServer, \
  createAccount, \
  createGroup, \
  createProject, \
  emailReviewers, \
  flushCaches, \
  killTask, \
  priority, \
  queryLimit, \
  startReplication, \
  viewCaches, \
  viewConnections, \
  viewQueue
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
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
