Messages.properties

#
# SPDX-License-Identifier: Apache-2.0
#
# Copyright 2020-2022 The JReleaser authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#

###############################################################################
# TRANSLATIONS NOTES:
# - please respect the capitalization of the first word
# - DSL property names must remain as is, e.g, 'basedir'
# - do not translate 'false', 'true'
###############################################################################

yes = yes
no  = no
not = not

ERROR_unexpected_error = Unexpected error
ERROR_unsupported_platform_override = Unsupported platform '{}', using '{}' instead

ERROR_extension_manager_load                      = Failed to load ExtensionManager
ERROR_extension_manager_multiple_instances        = Too many ExtensionManager instances: {}
extension.manager.load                            = loading extension {}:{}
extension.manager.disabled                        = extension {} is disabled
extension.manager.add.extension.point             = adding {} from {} extension
extension.manager.resolve.jars                    = resolving {}
extension.manager.copy.jars                       = copying {} to {}
extension.manager.load.empty.jars                 = Could not load extension {} because directory {} is empty
extension.manager.load.directory.missing          = Could not load extension {} because directory {} is missing
extension.manager.load.directory.error            = Unexpected error loading extension {} from {}
extension.manager.load.jar.error                  = Unexpected error loading extension {} -> {}
context.creator.extension.manager.error           = Misconfigured ExtensionManager. Extensions won't be loaded.

ERROR_context_creator_parse_configuration         = Unexpected error when parsing configuration from {}
context.creator.git_root_search                   = git-root-search set to {}
context.creator.reading_configuration             = Reading configuration
context.creator.report.project-version            = Project version set to {}
context.creator.report.release                    = Release is{}snapshot
context.creator.report.timestamp                  = Timestamp is {}
context.creator.report.head                       = HEAD is at {}
context.creator.report.platform                   = Platform is {}
context.configurer.auto-config.on                 = Auto configure is ON
# do not translate basedir
context.configurer.basedir.set                    = - basedir set to {}
ERROR_context_configurer_unsupported_url          = Auto configuration does not support {}
# do not translate release.updateSections, release.update
ERROR_context_configurer_update_not_set           = release.updateSections is set but release.update is false
ERROR_context_configurer_fail_git_head            = Could not determine git HEAD
ERROR_context_configurer_fail_git_remote          = Could not determine remote
ERROR_context_configurer_jreleaser_misconfigured  = JReleaser has not been properly configured.
ERROR_context_configurer_detected_git             = Auto configure detected {} but project has {} configured
ERROR_context_configurer_detected_git_owner       = Auto configure detected '{}' as repository owner but project has '{}' configured
ERROR_context_configurer_detected_git_name        = Auto configure detected '{}' as repository name but project has '{}' configured
ERROR_context_configurer_detected_git_branch      = Auto configure detected '{}' as default branch but project has '{}' configured
ERROR_version_parse                               = Cannot parse version '{}'
ERROR_version_parse_with                          = Cannot parse version '{}' with '{}'
ERROR_unsupported_algorithm                       = Unsupported algorithm {}
ERROR_calver_year                                 = Format does not start with a YYYY/YY/0Y token: '{}'
ERROR_calver_month                                = Format defines a MM/0M token thus it cannot have a WW/0W token: '{}'
ERROR_calver_week_month                           = Format defines a WW/0W token thus it cannot have a MM/0M token: '{}'
ERROR_calver_week_day                             = Format defines a WW/0W token thus it cannot have a DD/0D token: '{}'
ERROR_calver_micro_duplicate                      = Format defines two MICRO tokens: '{}'
ERROR_calver_minor_duplicate                      = Format defines two MINOR tokens: '{}'
ERROR_calver_micro_minor                          = Format defines MINOR token after MICRO: '{}'

ERROR_command_hook_unexpected_error = Unexpected error executing command hook
ERROR_command_hook_parser_error     = Command line parse error: {}
ERROR_unbalanced_quotes             = Unbalanced quotes in {}
hooks.execution                     = Executing {} hook(s): {} in total

announcers.header                = Announcing release
announcers.not.enabled           = Announcing is not enabled. Skipping
announcers.not.configured        = No announcers have been configured. Skipping
announcers.announcer.not.found   = Announcer {} not found. Skipping
announcers.announcer.not.enabled = Announcer {} is not enabled. Skipping
announcers.announcer.excluded    = Announcer {} was excluded. Skipping
announcers.announcer.disabled    = disabled. Skipping
ERROR_unsupported_announcer      = Unsupported announcer {}
ERROR_announcer_not_configured   = Announcer {} has not been configured

assemblers.not.enabled                     = Assembling is not enabled. Skipping
assemblers.no.match                        = No assemblers match {}
assemblers.distribution.not.configured     = Distribution {} is not configured for assembling with {}
assemblers.assemble.distribution.with      = Assembling {} distribution with {}
assemblers.assemble.distribution.with.all  = Assembling {} distribution with all assemblers
assemblers.assemble.all.distributions.with = Assembling all distributions with {}
assemblers.assemble.all.distributions      = Assembling all distributions
assemblers.distribution.skip               = skipping for {} distribution
assemblers.distribution.assemble           = assembling {} distribution
assemblers.assembler.excluded              = Assembler {}:{} was excluded. Skipping
ERROR_unsupported_assembler                = Unsupported assembler {}

ERROR_unexpected_error_changelog_append = Unexpected error when appending changelog
ERROR_unexpected_error_changelog        = Unexpected error when creating changelog
ERROR_cannot_read_changelog             = Can not read changelog from {}

checksum.header                           = Calculating checksums
checksum.not.enabled                      = No files configured for checksum. Skipping
checksum.not.changed                      = All checksums are up-to-date. Skipping
checksum.not.exist                        = checksum does not exist: {}
checksum.file.newer                       = {} is newer than {}
checksum.reading                          = reading {}
checksum.calculating                      = calculating {} checksum for {}
ERROR_unexpected_error_checksum           = Unexpected error writing checksums to {}
ERROR_artifact_does_not_exist             = Artifact does not exist. {}
ERROR_unexpected_error_hash_read          = Unexpected error when reading hash from {}
ERROR_unexpected_error_calculate_checksum = Unexpected error calculating checksum for {}

packagers.packager.excluded                = packager {} was excluded. Skipping
distributions.distribution.excluded        = distribution {} was excluded. Skipping
distributions.not.enabled                  = No active distributions for {}. Skipping
distributions.no.match                     = Distribution {} does not exist
distributions.apply.action                 = {} distributions
distributions.apply.action.to              = - {} {} distribution
distributions.skip.distribution            = skipping for {} distribution
distributions.not.supported.distribution   = distribution {} with type {} is not supported. Skipping
distributions.action.preparing.capitalize  = Preparing
distributions.action.packaging.capitalize  = Packaging
distributions.action.publishing.capitalize = Publishing
distributions.action.preparing             = preparing
distributions.action.packaging             = packaging
distributions.action.publishing            = publishing
distributions.apply.action.distribution    = {} {} distribution
distributions.failure                      = failure: {}
distributions.previous.failure             = skipping due to previous failure
ERROR_unsupported_packager                 = Unsupported packager {}

ERROR_releaser_no_match = No suitable git releaser has been configured

signing.header                       = Signing files
signing.not.enabled                  = Signing is not enabled. Skipping
signing.no.match                     = No files configured for signing. Skipping
signing.up.to.date                   = All signatures are up-to-date and valid. Skipping
signing.verify.signatures            = verifying {} signatures
signing.signing.files                = signing {} files into {}
signing.signature.not.exist          = signature does not exist: {}
signing.file.newer                   = {} is newer than {}
ERROR_signing_verify_file            = Could not verify file {} with signature {}
ERROR_signing_verify_signature       = Error when verifying signature of {}
ERROR_signing_create_signature_dir   = Could not create signatures directory
ERROR_unexpected_error_signature_gen = Unexpected error when initializing signature generator
ERROR_unexpected_error_signing       = Unexpected error when signing
ERROR_unexpected_error_signing_file  = Unexpected error when signing {}
ERROR_public_key_not_found           = Did not find public key for signing
ERROR_password_incorrect             = Password does not match

deployers.not.enabled               = Deploying is not enabled. Skipping
deployers.no.match                  = No deployers match {}
deployers.deployer.not.configured   = Deployer {}/{} is not configured
deployers.deployer.not.configured2  = Deployer {} is not configured
deployers.deploy.with               = Deploying with {}/{}
deployers.deploy.all.artifacts.with = Deploying all staged artifacts with {}
deployers.deploy.all.artifacts.to   = Deploying all staged artifacts to {}
deployers.deploy.all.artifacts      = Deploying all staged artifacts
deployers.skip.deploy               = skipping deploy for {}
deployers.deploy.to                 = Deploying to {}
deployers.deployer.excluded         = Deployer {}:{} was excluded. Skipping
deployers.deployer.disabled         = Deployer {}:{} is not enabled. Skipping
ERROR_unsupported_deployer          = Unsupported deployer {}

uploaders.not.enabled               = Uploading is not enabled. Skipping
uploaders.no.match                  = No uploaders match {}
uploaders.uploader.not.configured   = Uploader {}/{} is not configured
uploaders.uploader.not.configured2  = Uploader {} is not configured
uploaders.upload.with               = Uploading with {}/{}
uploaders.upload.all.artifacts.with = Uploading all artifacts with {}
uploaders.upload.all.artifacts.to   = Uploading all artifacts to {}
uploaders.upload.all.artifacts      = Uploading all artifacts
uploaders.skip.upload               = skipping upload for {}
uploaders.upload.to                 = Uploading to {}
uploaders.uploader.excluded         = Uploader {}:{} was excluded. Skipping
uploaders.uploader.disabled         = Uploader {}:{} is not enabled. Skipping
ERROR_unsupported_uploader          = Unsupported uploader {}

downloaders.not.enabled                 = Downloading is not enabled. Skipping
downloaders.no.match                    = No downloaders match {}
downloaders.downloader.not.configured   = Downloader {}/{} is not configured
downloaders.downloader.not.configured2  = Downloader {} is not configured
downloaders.download.with               = Downloading with {}/{}
downloaders.download.all.artifacts.with = Downloading all artifacts with {}
downloaders.download.all.artifacts.from = Downloading all artifacts from {}
downloaders.download.all.artifacts      = Downloading all artifacts
downloaders.skip.download               = skipping download for {}
downloaders.download                    = downloading {}
downloaders.downloader.excluded         = Downloader {}:{} was excluded. Skipping
downloaders.downloader.disabled         = Downloader {}:{} is not enabled. Skipping
ERROR_unsupported_downloader            = Unsupported downloader {}

packager.publish.snapshot.not.supported = publication of snapshots is not allowed. Skipping.
packager.create.properties              = creating props for {}/{}
packager.skip.distribution              = skipping {} distribution
ERROR_copy_files_from_to                = Could not copy files from {} to {}
ERROR_unexpected_copy_files_from_to     = Unexpected error when copying files from {} to {}
packager.no.matching.artifacts          = no suitable artifacts found in distribution {} to be packaged with {}
packager.fill.distribution.properties   = filling distribution properties into props
packager.fill.git.properties            = filling git properties into props
packager.fill.artifact.properties       = filling artifact properties into props
packager.fill.packager.properties       = filling packager properties into props
packager.resolve.templates              = resolving templates for {}/{}
packager.skipped.template               = skipping template {} for {}/{}
packager.evaluate.template              = evaluating template {} for {}/{}
packager.write.template                 = writing template {} for {}/{}
packager.write.file                     = writing file {} for {}/{}
packager.copy.license                   = copying license files
packager.fetch.icons                    = fetching icons

ERROR_brew_multiplatform_artifacts       = There are no matching multi-platform binaries
ERROR_packager_requires_platform         = must run on {}
ERROR_packager_excludes_platform         = must not run on {}
ERROR_chocolatey_nuget_not_found         = Did not find *.nupkg at {}
dryrun.set                               = dry-run is set to true. Skipping
docker.login                             = login into {}{}
docker.tag                               = tagging {} as {}
docker.push                              = pushing {} to {}
docker.logout                            = logout from {}{}
sdkman.no.artifacts.match                = Artifact {} is not suitable for Sdkman publication. Skipping
sdkman.artifact.explicit.skip            = Artifact {} is explicitly skipped
sdkman.platform.replacement              = Platform {}: {} will replace {}
sdkman.platform.unsupported              = Sdkman does not support platform {}
sdkman.publish.major                     = publishing major release of '{}' candidate
sdkman.publish.minor                     = publishing minor release of '{}' candidate
ERROR_project_no_license_url             = Project does not define a value for licenseUrl

tool.cached                              = cached {}
tool.located                             = located {}
tool.downloading                         = downloading {}
tool.downloaded                          = downloaded {} successfully
tool.unpacked                            = unpacked {}
tool.not.found                           = {} not found
tool.download.error                      = {} could not be downloaded/copied

tool_verify_error                          = Could not verify {} {}. Skipping
tool_unavailable                           = {} is not available. Skipping
cosign.generated.keys.at                   = Generated cosign key pair at {}
WARN_cosign_password_does_not_match        = cosign password does not match
ERROR_unexpected_generate_key_pair         = Unexpected error generating key pair
assembler.fill.assembler.properties        = filling assembler properties into props
ERROR_unexpected_error_writing_file        = Unexpected error when writing to {}
ERROR_command_execution_exit_value         = Command execution error. exitValue = {}
assembler.jlink.jdk                        = jdk version is {} {}
assembler.jlink.target                     = target version is {} {}
ERROR_jlink_target_not_compatible          = Target JDK {} is not compatible with {}
assembler.copy.jars                        = copying JARs to {}
assembler.copy.files                       = copying files to {}
ERROR_assembler_delete_archive             = Could not delete previous archive {}
assembler.resolved.module.names            = resolved moduleNames: {}
assembler.module.names                     = moduleNames: {}
ERROR_assembler_no_module_names            = Could not resolve module names
ERROR_assembler_jdeps_error                = An error occurred when executing jdeps:\n{}
ERROR_assembler_delete_dir                 = Could not delete {}
ERROR_assembler_delete_image               = Could not delete previous image {}
ERROR_assembler_adjusting_image            = Could not adjust image {}
ERROR_assembler_copy_jars                  = Could not copy JARs to {}
ERROR_assembler_copy_launcher              = Could not copy launcher to {}
ERROR_assembler_invalid_jdk_release        = Invalid JDK {} release file not found
ERROR_assembler_invalid_jdk_release_file   = Invalid JDK release file {}
assembler.copying                          = copying {}
ERROR_assembler_copying_jars               = Unexpected error when copying JAR files
ERROR_assembler_copying_files              = Unexpected error when copying files
ERROR_assembler_create_directories         = Could not create directories
assembler.graal.java                       = java version is {} {}
assembler.graal.graal                      = graal version is {} {}
assembler.graal.install.native.exec        = installing native-image executable
assembler.graal.install.component          = installing {} component
ERROR_assembler_invalid_graal_release      = Invalid Graal {} release file not found
ERROR_assembler_invalid_graal_release_file = Invalid Graal release file {}
assembler.jpackage.jdk                     = jdk version is {} {}
assembler.jpackage.type                    = packaging as {}
ERROR_jpackage_minimum_jdk_required        = jpackager requires JDK 16 as a minimum. JDK version is {}
ERROR_jpackage_runtime_image_not_found     = Could not find a runtime image matching {}

ERROR_invalid_config_file       = Invalid config file. {}
ERROR_parsing_config_file       = Unexpected error parsing config file. {}
ERROR_load_resource             = Unexpected error loading resource. {}
ERROR_unsupported_config_format = Unsupported config format. {}

releaser.tag.and.release.skipped = Release and tag are skipped

artifacts.not.exists                     = Artifact does not exist: {}
artifacts.newer                          = {} is newer than {}
ERROR_artifacts_unexpected_error_copying = Unexpected error copying {} to {}.\n{}
ERROR_artifacts_glob_missing_input       = Input does not exist: {}
ERROR_artifacts_glob_resolution          = Some globs failed to be resolved
ERROR_artifacts_unexpected_error_globs   = Unexpected error when resolving globs
ERROR_artifacts_unexpected_error_path    = Unexpected error visiting path {}
ERROR_artifacts_download_url_missing     = cannot resolve downloadUrl for {}. Using default settings from {}

WARNING.validation.distribution.no.artifacts   = distribution.{} was disabled because there are no matching artifacts
WARNING.validation.packager.no.artifacts       = distribution.{}.{} was disabled because there are no matching artifacts {}
WARNING.validation.packager.multiple.artifacts = distribution.{}.{} was disabled because there are multiple matching artifacts: {}
WARNING.validation.uploader.no.artifacts       = upload.{}.{} was disabled because there are no matching artifacts
WARNING.validation.docker.buildx.no.platforms  = distribution.{}.docker was disabled because buildx defines no platforms
WARNING.validation.docker.buildx.distributions = distribution.{}.docker was disabled because buildx defines only supports {} distributions

validation.disabled                      = - disabled
validation.disabled.error                = - disabled because validation failed
validation.disabled.release              = - disabled because release is not supported
validation.disabled.no.artifacts         = - disabled because there were no matching artifacts
validation.disabled.multiple.artifacts   = - disabled because there's more than one matching artifact
validation.disabled.no.repositories      = - disabled because there were no matching repositories
validation.disabled.no.platforms         = - disabled because there were no platforms specified
validation.disabled.distributions        = - disabled because only {} distributions are supported
validation_multiple_primary_screenshots  = There's more than one primary screenshot in {}
validation_multiple_primary_icons        = There's more than one primary icon in {}
validation_no_primary_icon               = There is no primary icon in {}
validation_java_home_missing             = Java home could not be found
validation_s3_missing_download_url       = {} defines a custom endpoint but no downloadUrl
validation_gitlab_non_matching_uploader  = Uploader {}:{} is not configured
validation_artifactory_disabled_repositories = {} has no active repositories
validation_artifactory_no_repositories   = {} has not defined any repositories
validation_must_define_pattern           = {} must define a pattern
validation_version_format_missing        = {} must define a format such as {}:<format>
validation_must_not_be_blank             = {} must not be blank
validation_must_not_be_null              = {} must not be null
validation_must_be_equal                 = {} ({}) and {} ({}) must be equal
validation_is_null                       = {} is null
validation_is_empty                      = {} is empty
validation_is_missing                    = {} is missing
validation_are_missing                   = {} are missing
validation_directory_not_exist           = {} does not exist: {}
validation_is_not_a_directory            = {} is not a directory: {}
validation_directory_is_empty            = {} is empty: {}
validation_must_not_be_empty             = {} must not be empty
validation_value_cannot_be               = {} can not be {}
validation_stereotype_invalid            = {} can not be {}. It must be one of {}
validation_multiple_assemblers           = {} has more than one assembler: {}
validation_chocolatey_package_version    = Invalid chocolatey package version {}. Follow SemVer with optional .number or .yyyyMMdd as tag
validation_brew_multiple_artifact        = {} has more than one {} artifact
validation_brew_single_artifact          = {} can only have a single matching .dmg, .pkg, or .zip artifact
validation_brew_duplicate_definition     = {} is defined for more than one distribution: {}
# do not translate .buildOn
validation_snap_missing_buildon          = {}[{}].buildOn must define at least one entry
validation_packager_multiple_artifacts   = {} has more than one artifact that may be packaged
validation_discussions_enabled           = Discussions may only be used when releasing to GitHub
validation_distributions_java            = {} is set to {} but neither {} nor {} have been set
validation_distributions_multiple        = {} has more than one artifact with {} platform for extension {}
validation_distributions_java_types      = {} must be a valid Java distribution type, one of [{}]
# do no translate distribution.{}.artifact[{}].platform
validation_distributions_platform        = distribution.{}.artifact[{}].platform ({}) is not supported. \
  Please use `${name}` or `${name}-${arch}` from{}       name = {}{}       arch = {}
# keep these spaces ----------------------------->       <--------->       <------->
# do not translate distribution., platform
validation_distributions_platform_check  = distribution.{} is of type {} and {} requires a explicit platform on each artifact
# do not translate distribution.
validation_distributions_disable         = disabling distribution.{}.{} because there are no matching artifacts
validation_docker_no_registries          = Adding registry docker.io to {} with username '{}'
validation_github_releasenotes_changelog = Both releaseNotes and changelog cannot be enabled at the same time
# do not translate .sign
validation_git_signing                   = {}.sign is set to `true` but the signing block is not enabled
validation_git_signing_cosign            = {}.sign is set to `true` but the signing block is set to COSIGN mode. Disabling
validation_git_required                  = {} or {} is required
# do not translate .applyMavenCentralRules
validation_maven_deployer_signing        = {}.sign is set to `true` but the signing block is not enabled
# do not translate .changelog
validation_changelog_multiple_categories = {}.changelog has more than one category with title: {}
# do not translate distribution.{}.jbang
validation_jbang_reverse_host            = distribution.{}.jbang must define an extra property named {}
# do not translate jbang.alias
validation_jbang_multiple_definition     = jbang.alias {} is defined for more than one distribution: {}
validation_missing_assembly              = Missing outputs for {}.{}. Distribution {} has not been assembled
# do not translate java-archive.
validation_java_archive_empty_jars       = java-archive.{} does not define jars
validation_java_archive_main_jar_or_class_missing = Both javaArchive.{}.mainJar and javaArchive.{}.java.mainClass are missing.
# do not translate archive.
validation_archive_empty_fileset         = archive.{} does not define fileSets
# do not translate jlink., platform
validation_jlink_jdk_platform            = jlink.{} defines JDKs without platform
# do not translate jlink.
validation_jlink_jdk_multiple_platforms  = jlink.{} has more than one JDK for {}
# do no translate jlink.{}.targetJdk[{}].platform
validation_jlink_platform                = jlink.{}.targetJdk[{}].platform ({}) is not supported. \
  Please use `${name}` or `${name}-${arch}` from{}       name = {}{}       arch = {}
# keep these spaces ----------------------------->       <--------->       <------->
# do not translate nativeImage., platform
validation_nativeimage_jdk_platform      = nativeImage.{} defines JDKs without platform
# do not translate nativeImage.
validation_nativeimage_jdk_multiple_platforms = nativeImage.{} has more than one JDK for {}
# do no translate nativeImage.{}.graalJdk[{}].platform
validation_nativeimage_platform          = nativeImage.{}.graalJdk[{}].platform ({}) is not supported. \
  Please use `${name}` or `${name}-${arch}` from{}       name = {}{}       arch = {}
# keep these spaces ----------------------------->       <--------->       <------->
# do no translate jpackage.{}.runtimeImage[{}].platform
validation_jpackage_platform             = jpackage.{}.runtimeImage[{}].platform ({}) is not supported. \
  Please use `${name}` or `${name}-${arch}` from{}       name = {}{}       arch = {}
# keep these spaces ----------------------------->       <--------->       <------->
# do not translate jpackage., jlink, runtimeImage
validation_jpackage_jlink_application    = jpackage.{} defines both jlink and runtimeImages but only one may be used.
validation_jpackage_invalid_appversion_t = Resolved app-version has build or tag ({}).\n\
Advice to fix: Set a compatible 'app-version' value. Valid versions are one to three integers separated by dots.
validation_jpackage_invalid_appversion_n = The first number in an app-version cannot be zero or negative ({}).\n\
Advice to fix: Set a compatible 'app-version' value. Valid versions are one to three integers separated by dots.
validation_jpackage_invalid_mac_package_identifier = {} does not match {}
validation_jpackage_invalid_mac_package_name       = {} can not be longer than 16 characters
# do not translate jpackage.{}.runtimeImage.path
validation_jpackage_runtime_images_missing          = jpackage.{}.runtimeImages are missing
# do not translate jpackage.{}.vendor
validation_jpackage_missing_vendor       = jpackage.{}.vendor is missing
# do not translate jpackage., platform
validation_jpackage_runtime_image_platform = jpackage.{} defines runtime images without platform
# do not translate jpackage.
validation_jpackage_runtime_image_multiple_platforms  = jpackage.{} has more than one runtime image for {}
validation_mail_not_blank                = {} or {} must not be blank
# do not translate docker.specs
validation_packagers_docker_specs        = docker.specs can only be defined inside distributions
validation_release_no_providers          = No release provider has been configured
validation_release_requirement           = Only one of {} can be enabled
validation_skdman_disable                = There are no active distributions. Disabling Sdkman announcer
# do not translate sdkman.candidate
validation_sdkman_multiple_definition    = sdkman.candidate {} is defined for more than one distribution: {}
# do not translate slack.token, slack.webhook
validation_slack_token                   = slack.token or slack.webhook must be provided
validation_extension_gav_directory       = Cannot define both gav and directory for {}

default.discussion.title = {{projectNameCapitalized}} {{projectVersion}} released!
default.release.message  = ? {{projectNameCapitalized}} {{projectVersion}} has been released! {{releaseNotesUrl}}
default.category.feature = ? Features
default.category.bug.fix = ? Bug Fixes

ERROR_path_does_not_exist               = Path does not exist {}
ERROR_unexpected_error_reading_template = Unexpected error reading template {}
ERROR_packager_name_not_blank           = Packager name must not be blank
ERROR_packager_not_configured           = Packager {} has not been configured
ERROR_packager_not_supported            = Packager {} is not supported

environment.load.variables           = Loading variables from {}
environment.variables.load.error     = Could not load variables from {}
environment.variables.source.missing = Variables source {} does not exist

ERROR_unexpected_glob_resolve = Unexpected error resolving glob {}
ERROR_glob_resolve            = Could not resolve glob {}

context.nag                          = {} since {}. This warning will become an error in a future release.
context.path.set                     = - {} set to {}
context.platform.selection.active    = Platform selection is in effect
context.platform.selection.no.match  = The following platforms did not match: {}
context.platform.selection.valid     = Please use `${name}` or `${name}-${arch}` from{}        name = {}{}        arch = {}
# keep these spaces ------------------------------------------------------------------>        <--------->        <------->
context.platform.selection.unmatched = Unmatched platforms: {}
context.platform.selection.artifacts = Artifacts will be filtered by platform matching: {}
context.platform.rejection.artifacts = Artifacts will be filtered by platform not matching: {}
context.configuration.validation     = Validating configuration
context.configuration.strict         = Strict mode set to {}
context.adjust.assemblies            = adjusting distributions with assemblies
context.writing.properties           = Writing output properties to {}
context.writing.properties.error     = Could not write output properties to {}
ERROR_signing_init_keyring           = Could not initialize keyring
ERROR_distribution_name_is_blank     = Distribution name must not be blank
ERROR_distribution_not_found         = Distribution {} not found
ERROR_version_invalid                = Version {} does not follow the {} spec
ERROR_invalid_function_input         = Invalid input '{}' for {}

templates.resource.resolve.classpath            = resolving resource from classpath for {}
templates.templates.resolve.classpath           = resolving templates from classpath
templates.template.resolve.classpath            = resolving template from classpath for {}
changelog.preset.not.found                      = No changelog preset {} found
ERROR_classpath_template_resolve                = Could not find location of classpath templates
ERROR_unexpected_reading_template_for           = Unexpected error reading template for {} from {}
ERROR_unexpected_reading_resource_for           = Unexpected error reading resource {} from {}
ERROR_unexpected_reading_templates_distribution = Unexpected error reading templates for distribution {}/{} from {}
ERROR_unexpected_reading_templates_from         = Unexpected error reading templates from {}
ERROR_template_not_found                        = Template for {} was not found
ERROR_resource_not_found                        = Resource {} was not found

templates.announcer.not.supported = Announcer {} is not supported
templates.assembler.not.supported = Assembler {} is not supported
templates.create.directory        = Creating output directory {}
templates.writing.file            = Writing file {}
templates.file_exists.error       = File {} already exists and overwrite was set to false
# do not translate distributionType, distributionName, toolName
ERROR_unexpected_template_fail    = Unexpected error when generating template. distributionType={}, distributionName={}, toolName={}

ERROR_environment_property_check  = {} must not be blank. Configure a value using the {}, or define a {} environment variable, or define a key/value pair in {} with key = {}
ERROR_environment_property_check2 = {} must not be blank. Configure a value using the {}, or define {} environment variables, or define a key/value pair in {} with keys = {}
ERROR_files_unpack_outside_target = Entry is outside of the target dir: {}
ERROR_files_unpack_fail_dir       = failed to create directory {}
ERROR_files_copy                  = Unable to copy: {}
ERROR_files_create                = Unable to create: {}
ERROR_files_cycle                 = Cycle detected: {}
ERROR_files_copy_attributes       = Unable to copy all attributes to: {}
ERROR_mustache_write_value        = Failed to write value:
ERROR_unexpected_file_read        = Unexpected error when reading file {}
ERROR_invalid_json_input          = Could not convert input into JSON
files.copy                        = copying files from {} to {}

ERROR_unexpected_release_announce  = Unexpected error when announcing release
ERROR_unexpected_release_create    = Unexpected error when creating release
ERROR_unexpected_release_sign      = Unexpected error when signing release
listener.failure                   = {} failed
workflow.dryrun                    = dry-run set to {}
workflow.success                   = JReleaser succeeded after {}
workflow.failure                   = JReleaser failed after {}
workflow.included.announcers       = Included announcers: {}
workflow.excluded.announcers       = Excluded announcers: {}
workflow.included.assemblers       = Included assemblers: {}
workflow.excluded.assemblers       = Excluded assemblers: {}
workflow.included.distributions    = Included distributions: {}
workflow.excluded.distributions    = Excluded distributions: {}
workflow.included.packagers        = Included packagers: {}
workflow.excluded.packagers        = Excluded packagers: {}
workflow.included.uploader.types   = Included uploaders by type: {}
workflow.excluded.uploader.types   = Excluded uploaders by type: {}
workflow.included.uploader.names   = Included uploaders by name: {}
workflow.excluded.uploader.names   = Excluded uploaders by name: {}
workflow.included.downloader.types = Included downloaders by type: {}
workflow.excluded.downloader.types = Excluded downloaders by type: {}
workflow.included.downloader.names = Included downloaders by name: {}
workflow.excluded.downloader.names = Excluded downloaders by name: {}

ERROR_unexpected_article_announcer   = Unexpected error when preparing {}
# no not translate article
announcer.article.resolve.templates  = resolving templates for article announcer
announcer.article.eval.template      = evaluating template {}
announcer.article.write.template     = writing template {}
ERROR_unexpected_template_resolution = Unexpected error resolving templates from {}
repository.disabled                  = pushing to {} is disabled. Skipping
repository.setup                     = setting up repository {}
repository.locate                    = locating repository {}
repository.clone                     = cloning {}
repository.commit.setup              = setting up commit
repository.push                      = pushing to {}
repository.commit.push               = pushing commit to remote
ERROR_unexpected_repository_update   = Unexpected error updating {}
repository.copy.files                = copying files from {}
ERROR_repository_copy_files          = Could not copy files from {}

uploader.uploading.to          = uploading to {}
downloader.unpack              = unpacking {}
ERROR_login                    = Invalid credentials
ERROR_disconnect               = Unexpected error when disconnecting from {}
ERROR_ssh_mkdir                = Unexpected error when creating path {}
ERROR_unexpected_download_from = Unexpected error when downloading from {}
ERROR_unexpected_download      = Unexpected error when downloading {}
ERROR_download_url_unpack      = Unexpected error when unpacking {}

artifacts.no.match         = No matching artifacts. Skipping
ERROR_unexpected_deploy    = Unexpected error when deploying {}
ERROR_unexpected_deploy_to = Unexpected error when deploying to {}
ERROR_unexpected_upload    = Unexpected error when uploading {}
ERROR_unexpected_upload_to = Unexpected error when uploading to {}
generic.git.warning        = Releasing to a generic Git repository is not supported
changelog.shallow.warning  				= Generating a changelog from a shallow copy may cause a failure
changelog.disabled                      = Changelog is not enabled. Skipping
changelog.generator.resolve.commits     = resolving commits
changelog.generator.sort.commits        = sorting commits {}
changelog.generator.lookup.tag          = looking for tag that matches '{}'
changelog.generator.lookup.previous.tag = looking for previous tag '{}'
changelog.generator.lookup.matching.tag = looking for tags that match '{}', excluding '{}'
changelog.generator.lookup.before.tag   = looking for a tag before '{}' that matches '{}'
changelog.generator.tag.found           = found tag {}
changelog.generator.generate            = Generating changelog
changelog.generator.store               = Storing changelog: {}
changelog.generator.read                = Reading changelog from {}
issues.generator.extract                = Extracting issues from changelog
issues.generator.store                  = Storing issues: {}
ERROR_changelog_not_exist               = Changelog {} does not exist
ERROR_git_repository_remote             = repository doesn't have a remote named '{}'
ERROR_git_repository_remote_missing_url = {} remote does not have a configured URL
ERROR_git_repository_remote_url_parse   = Unparseable remote URL {}
# do not translate origin
ERROR_git_repository_origin_remote      = Could not determine 'origin' remote
ERROR_git_repository_list_local_branch  = Could not list local branches
ERROR_git_delete_tag                    = Could not delete tag {}
ERROR_git_find_tag                      = Could not find tag {}
ERROR_git_create_tag                    = Could not create tag {}
ERROR_git_commit_not_found              = No commit found for tag {}
ERROR_head_commit_not_found             = HEAD commit not found
git.tag                                 = Tagging {}
git.tag.lookup                          = looking up tag {}
git.tag.exists                          = tag {} exists
git.tag.release                         = tagging release {}
ERROR_git_release_existing_tag          = Release failed because tag {} already exists. overwrite = false
git.tag.not.exist                       = tag {} does not exist
git.push.release                        = pushing to {}
git.push.tag                            = pushing tag to remote, dryrun = {}
git.repository.lookup                   = lookup repository {}/{}
git.repository.create                   = creating repository {}/{}
git.milestone.lookup                    = lookup open milestone '{}' on {}/{}
git.milestone.lookup.closed             = lookup closed milestone '{}' on {}/{}
git.milestone.close                     = closing milestone '{}' on {}/{}
git.project.create                      = creating project {}/{}
git.fetch.current.user                  = fetching current user
git.fetch.gitlab.project_by_id          = fetching project with GitLab id {}
git.fetch.gitlab.project.by.user        = fetching project {} for user {} ({})
ERROR_project_not_exist                 = Project {} does not exist or it's not visible
git.gitlab.project.found                = found {} (ID: {})
git.list.releases                       = fetching all releases on {}/{}
git.list.branches                       = fetching all branches on {}/{}
git.list.assets.github                  = fetching all assets on {}/{} and release {}
git.fetch.release.by.tag                = fetching release on {}/{} with tag {}
git.fetch.release.on.tag                = fetching release on {} with tag {}
git.delete.tag.from                     = deleting tag {} from {}/{}
git.delete.tag.from.repository          = deleting tag {} from {}
git.delete.release.from                 = deleting release {} from {}/{}
git.delete.release.from.id              = deleting release {} from {}/{} ({})
git.create.release                      = creating release on {}/{} with tag {}
git.create.release.repository           = creating release on {} with tag {}
git.update.release                      = updating release on {}/{} with tag {}
git.upload.assets                       = uploading assets to {}/{}
git.upload.asset                        = - uploading {}
git.upload.asset.failure                = x failed to upload {}
git.delete.asset                        = - deleting {}
git.delete.asset.failure                = x failed to delete {}
git.update.asset                        = - updating {}
git.update.asset.failure                = x failed to update {}
git.upload.asset.links                  = linking assets to {}/{} with tag {}
git.upload.asset.link                   = - linking {}
git.upload.asset.link.failure           = x failed to link {}
git.user.lookup                         = looking up user for {} <{}>
gitea.delete.package                    = deleting package {}/{}/{}/{}
gitlab.delete.package                   = deleting package {} from {}
github.delete.package.version           = deleting version {} of package {}
github.delete.package                   = deleting {} package {}
gitlab.list.labels                      = fetching all labels on project {}
gitlab.list.issues                      = fetching all issues on project {}
gitlab.list.packages                    = fetching all {} packages on project {}
gitlab.list.links                       = fetching all {} asset links on project {}
gitlab.delete.file                      = deleting uploaded file {}
gitlab.delete.link                      = deleting release link {} pointing to {}
github.list.versions                    = fetching all {} versions for package {}
git.list.labels                         = fetching all labels on {}/{}
git.label.fetch                         = looking up label {}
git.label.create                        = creating label {}
git.issue.fetch                         = looking up issue #{}
git.issue.release                       = marking issue #{} as released
git.issue.release.mark                  = Marking {} issue(s) as released
git.issue.label                         = adding label {} to issue #{}
git.issue.comment                       = commenting on issue #{}
git.issue.milestone.apply               = applying milestone {} to issue #{}
git.issue.milestone.warn                = Issue #{} already has a milestone: {}. Skipping
git.issue.milestone.force               = Forcing milestone {} on issue #{}. Previous milestone was {}
ERROR_gitlab_invalid_upload_link        = Invalid upload link {}
ERROR_gitea_delete_package              = failed to delete package {}/{}/{}/{}
ERROR_github_delete_package             = failed to delete {} package {}:{}
ERROR_git_organization_not_exist        = Organization {} does not exist
ERROR_git_team_not_exist                = Team {} does not exist
git.releaser.releasing                  = Releasing to {}
git.releaser.release.lookup             = looking up release with tag {} at repository {}
git.releaser.release.exists             = release {} exists
git.releaser.release.delete             = deleting release {}
git.releaser.release.create             = creating release {}
git.releaser.release.update             = updating release {}
git.releaser.release.update.title       = updating release title to {}
git.releaser.release.update.body        = updating release body
git.releaser.release.not.found          = release {} does not exist
git.releaser.user.not.found             = Could not find user matching {}
git.releaser.repository.tag             = tagging local repository with {}
github.generate.release.notes           = Generating release notes on {}/{} for {}..{}
ERROR_git_repository_not_exists         = Repository '{}' does not exist
ERROR_git_tag_not_exists                = Tag '{}' does not exist
ERROR_git_release_branch_not_exists     = Unrecognized branch '{}'. Available branches are: {}
ERROR_git_releaser_cannot_release       = {} release failed because release {} already exists. overwrite = false; update = false
ERROR_git_releaser_fetch_label          = {} release failed because label {} was not found or could not be created
ERROR_git_releaser_update_issue         = {} release failed because issue #{} could not be updated
git.releaser.link.discussion            = linking release {} with discussion {}
git.releaser.link.discussion.error      = Could not update release {} with discussion category {}
ERROR_git_discussion_duplicate          = A discussion titled "{}" has already been posted to {}/{}
warn_ssl_disabled                       = ** SSL VALIDATION IS DISABLED. CONTINUE AT YOUR OWN RISK **
warn_ssh_disabled                       = ** SSH HOST VERIFICATION IS DISABLED. CONTINUE AT YOUR OWN RISK **
webhook.connection.open                 = opening connection
webhook.connection.configure            = configuring connection
webhook.message.send                    = sending message
webhook.data.send                       = sending data
webhook.response.handle                 = handling response
webhook.server.reply                    = server replied with {}: {}
sdk.operation.failed                    = {} operation failed
sdkman.release.announce                 = announcing {} release of '{}' candidate
ERROR_sdkman_announce                   = Failed to announce some candidates
sdkman.no.suitable.artifacts            = No suitable artifacts were found. Skipping
sdkman.release.announce.major           = Announcing major release of '{}' candidate
sdkman.release.announce.minor           = Announcing minor release of '{}' candidate
twitter.tweet                           = tweeting: {}
twitter.tweet.size                      = status is {} chars long
mastodon.toot                           = tooting: {}
mastodon.toot.size                      = status is {} chars long
ERROR_unexpected_json_format            = Unexpected error formatting message as JSON
mail.message.send                       = Sending e-mail announcement
s3.bucket.check                         = checking if bucket {} exists
s3.bucket.create                        = creating bucket {}
s3.object.check                         = checking if s3://{}/{} exists
s3.object.create                        = creating s3://{}/{}
s3.object.write                         = writing s3://{}/{}
s3.object.acl                           = adding READ permission to s3://{}/{}
ERROR_unexpected_s3_client_config       = Error while building AWS S3 client

disco.fetch.packages                    = fetching packages with {}
disco.fetch.package                     = fetching package {}
disco.multiple.packages                 = Disco returned {} package(s)
disco.package.not.downloadable          = {} can not be downloaded directly
ERROR_disco_resolve_package             = Disco returned no results: {}
ERROR_disco_resolve_pkg                 = Disco returned no result for ephemeralId {}

nexus.lookup.staging.profile            = Lookup staging profile for {}
nexus.get.staging.repository            = fetching staging repository for {}
nexus.create.staging.repository         = Creating a staging repository for {}
nexus.create.staging.repository2        = creating staging repository for {}:{}
nexus.drop.repository                   = Dropping staging repository {}
nexus.close.repository                  = Closing staging repository {}
nexus.release.repository                = Releasing staging repository {}
nexus.deploy.artifact                   = deploying {} as {}/{}
nexus.retry.attempt                     = Attempt {} of {}
nexus.retry.failed.attempt              = attempt {}/{} failed with result: {}
nexus.wait.operation                    = This operation may take some time. Please wait.
nexus.wait.repository.state             = waiting for staged repository ({}) state to be one of {}
nexus.wait.repository.transitioning     = repository {} is still transitioning
nexus.wait.repository.invalid.state     = repository {} is not in expected state(s). Expected one of {}, actual is {}
ERROR_nexus_find_staging_profile        = Could not find a staging profile matching {}
ERROR_nexus_create_staging_repository   = Could not create a staging repository for {}
ERROR_nexus_close_repository            = Could not close staging repository {}
ERROR_nexus_release_repository          = Could not release staging repository {}
ERROR_nexus_deploy_artifact             = Error when deploying artifact {}
ERROR_deployer_stage_resolution         = Some paths failed to be resolved
ERROR_deployer_unexpected_error_stage   = Unexpected error when resolving staged artifacts
ERROR_deployer_maven_central_rules      = Rules for publishing to Maven Central were not met