= Name Templates

Several fields in the JReleaser config file support templating. JReleaser makes use of the
link:https://mustache.github.io/[Mustache] format for its templating support. Packagers rely on input files that
also support templates. A template name can be used as `{{name}}`

The following is a list of pre-defined template names:

== Environment

All environment variables are accessible with the `Env.` prefix, for example an environment variable named `JAVA_OPTS`
becomes `{{Env.JAVA_OPTS}}`.

Additionally, every key/value from `environment.properties` becomes available

[tabs]
====
YAML::
+
[source,yaml]
[subs="+macros"]
----
environment:
  properties:
    foo: bar
----
TOML::
+
[source,toml]
[subs="+macros"]
----
[environment]
  properties.foo = "bar"
----
JSON::
+
[source,json]
[subs="+macros"]
----
{
  "environment": {
    "properties": {
      "foo": "bar"
    }
  }
}
----
Maven::
+
[source,xml]
[subs="+macros,verbatim"]
----
<jreleaser>
  <environment>
    <properties>
      <foo>bar</foo>
    </properties>
  </environment>
</jreleaser>
----
Gradle::
+
[source,groovy]
[subs="+macros"]
----
jreleaser {
  environment {
    properties.put('foo', 'bar')
  }
}
----
====

The key `foo` becomes `{{foo}}` and will be evaluated to the String `bar`.

== Build

The following names are related to the current build

[%header, cols="<2,<5", width="100%"]
|===
| Key                 | Description
| commitShortHash     | head commit hash abbreviated to 7 characters
| commitFullHash      | head commit hash
| timestamp           | current timestamp with RFC3339 format
| outputDirectory     | JReleaser's output directory
| checksumDirectory   | directory where checksums are found
| signaturesDirectory | directory where signatures are found
| assembleDirectory   | directory where assembled distributions are found
| artifactsDirectory  | directory where transformed artifacts are found
| prepareDirectory    | base directory for preparing distributions
| packageDirectory    | base directory for packaging distributions
|===

== Project

The following names are related to xref:configuration:project.adoc[]

[%header, cols="<2,<5", width="100%"]
|===
| Key                      | Description
| projectName              | the project name
| projectNameCapitalized   | the project name, capitalized, hyphens replaced by spaces.
| projectVersion           | the project version
| projectEffectiveVersion  | the project effective version
| projectVersionMajor      | the major number of the project's version (semver)
| projectVersionMinor      | the minor number (if any) of the project's version (semver)
| projectVersionPatch      | the patch number (if any) of the project's version (semver)
| projectVersionTag        | the tag (if any) of the project's version (semver)
| projectVersionNumber     | the version number of the project's version (java_module)
| projectVersionPrerelease | the prelease (if any) of the project's version (java_module)
| projectVersionBuild      | the build info (if any) of the project's version (semver, java_module)
| projectDescription       | the project description
| projectLongDescription   | the project long description
| projectWebsite           | link to the project website
| projectLicense           | the project license, typically an SPDX identifier
| projectCopyright         | the project copyright notice
| projectDocsUrl           | link to the project's documentation
| projectAuthorsBySpace    | space separated list of author names
| projectAuthorsByComma    | commma separated list of author names
| projectTagsBySpace       | space separate list of project tags
| projectTagsByComma       | comma separate list of project tags
| projectJavaGroupId       | the project groupId (Maven coordinates)
| projectJavaArtifactId    | the project artifactId (Maven coordinates)
| projectJavaVersion       | the project Java version (full)
| projectJavaVersionMajor  | the project Java version (major)
| projectJavaVersionMinor  | the project Java version (minor)
| projectJavaVersionPatch  | the project Java version (patch)
| projectJavaVersionTag    | the project Java version (tag)
| projectJavaVersionBuild  | the project Java version (build)
| projectMainClass         | the main class launched by the executable script launcher
|===

The value of `projectEffectiveVersion` is calculated as follows:

* if the project is snapshot the value becomes "`early-access`". `projectVersion` remains unchanged.
* if the project is release the value is the same as `projectVersion`.

Additionally, every key/value from `project.extraProperties` is mapped with `project` as key prefix and the capitalized
key, such that

[tabs]
====
YAML::
+
[source,yaml]
[subs="+macros"]
----
project:
  extraProperties:
    # Key will be capitalized and prefixed
    # with `project`, i.e, `projectFoo`.
    foo: bar
----
TOML::
+
[source,toml]
[subs="+macros"]
----
[project]
  # Key will be capitalized and prefixed
  # with `project`, i.e, `projectFoo`.
  extraProperties.foo = "bar"
----
JSON::
+
[source,json]
[subs="+macros"]
----
{
  "project": {
    "extraProperties": {
      // Key will be capitalized and prefixed
      // with `project`, i.e, `projectFoo`.
      "foo": "bar"
    }
  }
}
----
Maven::
+
[source,xml]
[subs="+macros,verbatim"]
----
<jreleaser>
  <project>
    <extraProperties>
      <!--
        Key will be capitalized and prefixed
        with `project`, i.e, `projectFoo`.
      -->
      <foo>bar</foo>
    </extraProperties>
  </project>
</jreleaser>
----
Gradle::
+
[source,groovy]
[subs="+macros"]
----
jreleaser {
  project {
    // Key will be capitalized and prefixed
    // with `project`, i.e, `projectFoo`.
    extraProperties.put('foo', 'bar')
  }
}
----
====

Additionally, every key/value from `project.java.extraProperties` is mapped with `java` as key prefix and the capitalized
key, such that

[tabs]
====
YAML::
+
[source,yaml]
[subs="+macros"]
----
project:
  java:
    extraProperties:
      # Key will be capitalized and prefixed
      # with `java`, i.e, `javaFoo`.
      foo: bar
----
TOML::
+
[source,toml]
[subs="+macros"]
----
[project]
  # Key will be capitalized and prefixed
  # with `java`, i.e, `javaFoo`.
  java.extraProperties.foo = "bar"
----
JSON::
+
[source,json]
[subs="+macros"]
----
{
  "project": {
    "java": {
      "extraProperties": {
        // Key will be capitalized and prefixed
        // with `java`, i.e, `javaFoo`.
        "foo": "bar"
      }
    }
  }
}
----
Maven::
+
[source,xml]
[subs="+macros,verbatim"]
----
<jreleaser>
  <project>
    <java>
      <extraProperties>
        <!--
          Key will be capitalized and prefixed
          with `java`, i.e, `javaFoo`.
        -->
        <foo>bar</foo>
      </extraProperties>
    </java>
  </project>
</jreleaser>
----
Gradle::
+
[source,groovy]
[subs="+macros"]
----
jreleaser {
  project {
    java {
      // Key will be capitalized and prefixed
      // with `java`, i.e, `javaFoo`.
      extraProperties.put('foo', 'bar')
    }
  }
}
----
====

== Platform

The following names are related to detected OS/Platform settings

[%header, cols="<2,<5", width="100%"]
|===
| Key        | Description
| osName     | normalized value of System.getProperty("os.name")
| osArch     | normalized value of System.getProperty("os.arch")
| osPlatform | combination of `${osName}-${osArch}`
| osVersion  | value of System.getProperty("os.version")
|===

== Release

The following names are related to xref:configuration:release/index.adoc[]

[%header, cols="<2,<5", width="100%"]
|===
| Key                   | Description
| repoHost              | the Git host, i.e. "github.com"
| repoOwner             | the owner of the Git repository
| repoName              | the name of the Git repository
| repoBranch            | the branch on which the release is made
| tagName               | the tag being release, defaults to `v{{projectVersion}}`
| releaseName           | the release name, defaults to `Release {{tagName}}`
| milestoneName         | the milestone name/title, defaults to `{{tagName}}`
| repoCanonicalName     | the canonical name of the repository, `{{repoOwner}}/{{repoName}}`
| repoUrl               | the repository URL, `pass:[https://{{repoHost}}/{{repoOwner}}/{{repoName}}]`
| repoCloneUrl          | the repository clone URL, `pass:[https://{{repoHost}}/{{repoOwner}}/{{repoName}}.git]`
| commitsUrl            | the URL to find commits
| releaseNotesUrl       | the URL pointing to the release
| latestReleaseUrl      | the URL pointing to latest release
| issueTrackerUrl       | the URL of the issue tracker
| reverseRepoHost       | reversed Git host, i.e. "com.github"
| changelogChanges      | formatted commit changes
| changelogContributors | list of unique names of all commit contributors
| changelog             | full changelog contents
|===

The value of `tagName` is calculated as follows:

* if the project is snapshot the value becomes "`early-access`".
* if the project is release the value remains unchanged.

== Distribution

The following names are related to xref:configuration:distributions.adoc[]

[%header, cols="<2,<5", width="100%"]
|===
| Key                          | Description
| distributionName             | the name of the distribution
| distributionExecutable       | the name of the executable script launcher
| distributionTagsBySpace      | space separate list of distribution tags
| distributionTagsByComma      | comma separate list of distribution tags
| distributionJavaGroupId      | the distribution groupId (Maven coordinates)
| distributionJavaArtifactId   | the distribution artifactId (Maven coordinates)
| distributionJavaVersion      | the distribution Java version (full)
| distributionJavaVersionMajor | the distribution Java version (major)
| distributionJavaVersionMinor | the distribution Java version (minor)
| distributionJavaVersionPatch | the distribution Java version (patch)
| distributionJavaVersionTag   | the distribution Java version (tag)
| distributionJavaVersionBuild | the distribution Java version (build)
| distributionMainClass        | the main class launched by the executable script launcher
|===

Additionally, every key/value from `distribution.<name>.extraProperties` is mapped with `distribution` as key prefix 
and the capitalized key, such that

[tabs]
====
YAML::
+
[source,yaml]
[subs="+macros"]
----
distributions:
  app:
    extraProperties:
      # Key will be capitalized and prefixed
      # with `distribution`, i.e, `distributionFoo`.
      foo: bar
----
TOML::
+
[source,toml]
[subs="+macros"]
----
[distributions.app]
  # Key will be capitalized and prefixed
  # with `distribution`, i.e, `distributionFoo`.
  extraProperties.foo = "bar"
----
JSON::
+
[source,json]
[subs="+macros"]
----
{
  "distributions": {
    "app": {
      "extraProperties": {
        // Key will be capitalized and prefixed
        // with `distribution`, i.e, `distributionFoo`.
        "foo": "bar"
      }
    }
  }
}
----
Maven::
+
[source,xml]
[subs="+macros,verbatim"]
----
<jreleaser>
  <distributions>
    <app>
      <extraProperties>
        <!--
          Key will be capitalized and prefixed
          with `distribution`, i.e, `distributionFoo`.
        -->
        <foo>bar</foo>
      </extraProperties>
    </app>
  </distributions>
</jreleaser>
----
Gradle::
+
[source,groovy]
[subs="+macros"]
----
jreleaser {
  distributions {
    app {
      // Key will be capitalized and prefixed
      // with `distribution`, i.e, `distributionFoo`.
      extraProperties.put('foo', 'bar')
    }
  }
}
----
====

Additionally, every key/value from `distribution.<name>.java.extraProperties` is mapped with `java` as key prefix
and the capitalized key, such that

[tabs]
====
YAML::
+
[source,yaml]
[subs="+macros"]
----
distributions:
  app:
    java:
      extraProperties:
        # Key will be capitalized and prefixed
        # with `java`, i.e, `javaFoo`.
        foo: bar
----
TOML::
+
[source,toml]
[subs="+macros"]
----
[distributions.app]
  # Key will be capitalized and prefixed
  # with `java`, i.e, `javaFoo`.
  java.extraProperties.foo = "bar"
----
JSON::
+
[source,json]
[subs="+macros"]
----
{
  "distributions": {
    "app": {
      "java": {
        "extraProperties": {
          // Key will be capitalized and prefixed
          // with `java`, i.e, `javaFoo`.
          "foo": "bar"
        }
      }
    }
  }
}
----
Maven::
+
[source,xml]
[subs="+macros,verbatim"]
----
<jreleaser>
  <distributions>
    <app>
      <java>
        <extraProperties>
          <!--
            Key will be capitalized and prefixed
            with `java`, i.e, `javaFoo`.
          -->
          <foo>bar</foo>
        </extraProperties>
      </java>
    </app>
  </distributions>
</jreleaser>
----
Gradle::
+
[source,groovy]
[subs="+macros"]
----
jreleaser {
  distributions {
    app {
      java {
        // Key will be capitalized and prefixed
        // with `java`, i.e, `javaFoo`.
        extraProperties.put('foo', 'bar')
      }
    }
  }
}
----
====

== Artifact

The following names identify an artifact without explicit `platform`

[%header, cols="<2,<5", width="100%"]
|===
| Key                    | Description
| artifactUrl            | the URL required to download the artifact
| artifactChecksum${SHA} | the matching checksum of the artifact's file, per configured algorithm
| artifactFileName       | the name of the artifact file
| artifactName           | the name of the artifact file without extension
|===

The following names match the first artifact in a distribution

[%header, cols="<2,<5", width="100%"]
|===
| Key                          | Description
| distributionUrl              | the URL required to download the artifact
| distributionChecksum${SHA}   | the matching checksum of the artifact's file, per configured algorithm
| distributionArtifactFileName | the name of the artifact file
| distributionArtifactName     | the name of the artifact file without extension
|===

Additional names become available when the artifact defines a `platform`

[%header, cols="<2,<5", width="100%"]
|===
| Key                                           | Description
| artifact{{CapitalizedPlatform}}Url            | the URL required to download the artifact
| artifact{{CapitalizedPlatform}}Checksum${SHA} | the matching checksum of the artifact's file, per configured algorithm
| artifact{{CapitalizedPlatform}}FileName       | the name of the artifact file
| artifact{{CapitalizedPlatform}}Name           | the name of the artifact file without extension
|===

Additionally, every key/value from `artifact.extraProperties` is mapped with `artifact` as key prefix for the first
artifact, and `artifact{{CapitalizedPlatform}}` for all artifacts, and the capitalized key.

Thus, for artifacts defined as

[tabs]
====
YAML::
+
[source,yaml]
[subs="+macros"]
----
checksum:
  algorithms:
    - MD5
    - SHA256

distributions:
  app:
    artifacts:
      - path: path/to/{{distributionName}}-{{projectVersion}}.zip
        extraProperties:
          main: true
      - path: path/to/{{distributionName}}-{{projectVersion}}-mac.zip
        platform: osx
----
TOML::
+
[source,toml]
[subs="+macros"]
----
[checksum]
  algorithms = ["MD5", "SHA256"]

pass:[[[distributions.app.artifact]]]
  path: "path/to/{{distributionName}}-{{projectVersion}}.zip"
  extraProperties.main = true

pass:[[[distributions.app.artifact]]]
  path = "path/to/{{distributionName}}-{{projectVersion}}-mac.zip"
  platform = "osx"
----
JSON::
+
[source,json]
[subs="+macros"]
----
{
  "checksums": {
    "algorithms": [
      "MD5",
      "SHA256"
    ]
  },

  "distributions": {
    "app": {
      "artifacts": [
        {
          "path": "path/to/{{distributionName}}-{{projectVersion}}.zip",
          "extraProperties":
          {
            "main": true
          }
        },
        {
          "path": "path/to/{{distributionName}}-{{projectVersion}}-mac.zip",
          "platform": "osx"
        }
      ],
    }
  }
}
----
Maven::
+
[source,xml]
[subs="+macros,verbatim"]
----
<jreleaser>
  <checksum>
    <algorithms>
      <algorithm>MD5</algorithm>
      <algorithm>SHA256</algorithm>
    </algorithms>
  </checksum>
  <distributions>
    <app>
      <artifacts>
        <artifact>
          <path>path/to/${project.artifactId}-${project.version}.zip</path>
          <extraProperties>
            <main>true</main>
          </extraProperties>
        </artifact>
        <artifact>
          <path>path/to/${project.artifactId}-${project.version}-mac.zip</path>
          <platform>osx</platform>
        </artifact>
      </artifacts>
    </app>
  </distributions>
</jreleaser>
----
Gradle::
+
[source,groovy]
[subs="+macros"]
----
jreleaser {
  checksum {
    algorithm('MD5')
    algorithm('SHA256')
  }
  distributions {
    app {
      artifacts {
        artifact {
          path = "path/to/${project.name}-${project.version}.zip"
          extraProperties.put("main", true)
        }
        artifact {
          path = "path/to/${project.name}-${project.version}-mac.zip"
          platform = 'osx'
        }
      }
    }
  }
}
----
====

The following names will be calculated:

*1st artifact*

* artifactUrl
* artifactChecksumMd5
* artifactChecksumSha256
* artifactFileName: `${project.name}-${project.version}.zip`
* artifactName: `${project.name}-${project.version}`
* artifactMain: true
* distributionUrl
* distributionChecksummd5
* distributionChecksumSha256
* distributionArtifactFileName: `${project.name}-${project.version}.zip`
* distributionArtifactName: `${project.name}-${project.version}`

*Platform specific artifact*

* artifactOsxUrl
* artifactOsxChekcsumMd5
* artifactOsxChekcsumSha256
* artifactOsxFileName: `${project.name}-${project.version}-mac.zip`
* artifactOsxName: `${project.name}-${project.version}-mac`

== Brew

The following names are related to xref:configuration:packagers/homebrew.adoc[]

[%header, cols="<2,<5", width="100%"]
|===
| Key                 | Description
| brewTapRepoUrl      | the tap repository URL, `pass:[https://{{repoHost}}/{{repoOwner}}/{{repoName}}]`
| brewTapRepoCloneUrl | the tap repository clone URL, `pass:[https://{{repoHost}}/{{repoOwner}}/{{repoName}}.git]`
| brewFormulaName     | the formula name. Defaults to `{{projectNameCapitalized}}`
| brewDependencies    | a map of key/value pairs
|===

Additionally, every key/value from `brew.extraProperties` is mapped with `brew` as key prefix and the capitalized
key, such that

[tabs]
====
YAML::
+
[source,yaml]
[subs="+macros"]
----
packagers:
  brew:
    extraProperties:
      # Key will be capitalized and prefixed
      # with `brew`, i.e, `brewFoo`.
      foo: bar
----
TOML::
+
[source,toml]
[subs="+macros"]
----
[packagers.brew]
  # Key will be capitalized and prefixed
  # with `brew`, i.e, `brewFoo`.
  extraProperties.foo = "bar"
----
JSON::
+
[source,json]
[subs="+macros"]
----
{
  "packagers": {
    "brew": {
      "extraProperties": {
        // Key will be capitalized and prefixed
        // with `brew`, i.e, `brewFoo`.
        "foo": "bar"
      }
    }
  }
}
----
Maven::
+
[source,xml]
[subs="+macros,verbatim"]
----
<jreleaser>
  <packagers>
    <brew>
      <extraProperties>
        <!--
          Key will be capitalized and prefixed
          with `brew`, i.e, `brewFoo`.
        -->
        <foo>bar</foo>
      </extraProperties>
    </brew>
  </packagers>
</jreleaser>
----
Gradle::
+
[source,groovy]
[subs="+macros"]
----
jreleaser {
  packagers {
    brew {
      // Key will be capitalized and prefixed
      // with `brew`, i.e, `brewFoo`.
      extraProperties.put('foo', 'bar')
    }
  }
}
----
====

== Chocolatey

The following names are related to xref:configuration:packagers/chocolatey.adoc[]

[%header, cols="<2,<5", width="100%"]
|===
| Key                          | Description
| chocolateyUsername           | the name of the Chocolatey username
| chocolateyBucketRepoUrl      | the bucket repository URL, `pass:[https://{{repoHost}}/{{repoOwner}}/{{repoName}}]`
| chocolateyBucketRepoCloneUrl | the bucket clone repository URL, `pass:[https://{{repoHost}}/{{repoOwner}}/{{repoName}}.git]`
|===

Additionally, every key/value from `chocolatey.extraProperties` is mapped with `chocolatey` as key prefix and the capitalized
key, such that

[tabs]
====
YAML::
+
[source,yaml]
[subs="+macros"]
----
packagers:
  chocolatey:
    extraProperties:
      # Key will be capitalized and prefixed
      # with `chocolatey`, i.e, `chocolateyFoo`.
      foo: bar
----
TOML::
+
[source,toml]
[subs="+macros"]
----
[packagers.chocolatey]
  # Key will be capitalized and prefixed
  # with `chocolatey`, i.e, `chocolateyFoo`.
  extraProperties.foo = "bar"
----
JSON::
+
[source,json]
[subs="+macros"]
----
{
  "packagers": {
    "chocolatey": {
      "extraProperties": {
        // Key will be capitalized and prefixed
        // with `chocolatey`, i.e, `chocolateyFoo`.
        "foo": "bar"
      }
    }
  }
}
----
Maven::
+
[source,xml]
[subs="+macros,verbatim"]
----
<jreleaser>
  <packagers>
    <chocolatey>
      <extraProperties>
        <!--
          Key will be capitalized and prefixed
          with `chocolatey`, i.e, `chocolateyFoo`.
        -->
        <foo>bar</foo>
      </extraProperties>
    </chocolatey>
  </packagers>
</jreleaser>
----
Gradle::
+
[source,groovy]
[subs="+macros"]
----
jreleaser {
  packagers {
    chocolatey {
      // Key will be capitalized and prefixed
      // with `chocolatey`, i.e, `chocolateyFoo`.
      extraProperties.put('foo', 'bar')
    }
  }
}
----
====

== Docker

The following names are related to xref:configuration:packagers/homedocker.adoc[]

[%header, cols="<2,<5", width="100%"]
|===
| Key             | Description
| dockerBaseImage | the base Docker image
| dockerLabels    | a list of formatted labels
| dockerSpecName  | tha name of the current Docker spec
|===

Additionally, every key/value from `docker.extraProperties` is mapped with `docker` as key prefix and the capitalized
key, such that

[tabs]
====
YAML::
+
[source,yaml]
[subs="+macros"]
----
packagers:
  docker:
    extraProperties:
      # Key will be capitalized and prefixed
      # with `docker`, i.e, `dockerFoo`.
      foo: bar
----
TOML::
+
[source,toml]
[subs="+macros"]
----
[packagers.docker]
  # Key will be capitalized and prefixed
  # with `docker`, i.e, `dockerFoo`.
  extraProperties.foo = "bar"
----
JSON::
+
[source,json]
[subs="+macros"]
----
{
  "packagers": {
    "docker": {
      "extraProperties": {
        // Key will be capitalized and prefixed
        // with `docker`, i.e, `dockerFoo`.
        "foo": "bar"
      }
    }
  }
}
----
Maven::
+
[source,xml]
[subs="+macros,verbatim"]
----
<jreleaser>
  <packagers>
    <docker>
      <extraProperties>
        <!--
          Key will be capitalized and prefixed
          with `docker`, i.e, `dockerFoo`.
        -->
        <foo>bar</foo>
      </extraProperties>
    </docker>
  </packagers>
</jreleaser>
----
Gradle::
+
[source,groovy]
[subs="+macros"]
----
jreleaser {
  packagers {
    docker {
      // Key will be capitalized and prefixed
      // with `docker`, i.e, `dockerFoo`.
      extraProperties.put('foo', 'bar')
    }
  }
}
----
====

== JBang

The following names are related to xref:configuration:packagers/jbang.adoc[]

[%header, cols="<2,<5", width="100%"]
|===
| Key                      | Description
| jbangCatalogRepoUrl      | the catalog repository URL, `pass:[https://{{repoHost}}/{{repoOwner}}/{{repoName}}]`
| jbangCatalogRepoCloneUrl | the catalog repository clone URL, `pass:[https://{{repoHost}}/{{repoOwner}}/{{repoName}}.git]`
| jbangAliasName           | the name of the jbang alias, `{{distributionExecutable}}` or `{{distributionExecutable}}-snapshot`
| jbangScriptName          | the name of the jbang script file, `{{distributionExecutable}}` or `{{distributionExecutable}}_snapshot`
| jbangDistributionGA     a| calculated Maven coordinates for link:https://jitpack.io[]

single:: `{{reverseRepoHost}}.{{repoOwner}}:{{distributionArtifactId}` +
multi:: `{{reverseRepoHost}}.{{repoOwner}}.{{repoName}}:{{distributionArtifactId}`
|===

Additionally, every key/value from `jbang.extraProperties` is mapped with `jbang` as key prefix and the capitalized
key, such that

[tabs]
====
YAML::
+
[source,yaml]
[subs="+macros"]
----
packagers:
  jbang:
    extraProperties:
      # Key will be capitalized and prefixed
      # with `jbang`, i.e, `jbangFoo`.
      foo: bar
----
TOML::
+
[source,toml]
[subs="+macros"]
----
[packagers.jbang]
  # Key will be capitalized and prefixed
  # with `jbang`, i.e, `jbangFoo`.
  extraProperties.foo = "bar"
----
JSON::
+
[source,json]
[subs="+macros"]
----
{
  "packagers": {
    "jbang": {
      "extraProperties": {
        // Key will be capitalized and prefixed
        // with `jbang`, i.e, `jbangFoo`.
        "foo": "bar"
      }
    }
  }
}
----
Maven::
+
[source,xml]
[subs="+macros,verbatim"]
----
<jreleaser>
  <packagers>
    <jbang>
      <extraProperties>
        <!--
          Key will be capitalized and prefixed
          with `jbang`, i.e, `jbangFoo`.
        -->
        <foo>bar</foo>
      </extraProperties>
    </jbang>
  </packagers>
</jreleaser>
----
Gradle::
+
[source,groovy]
[subs="+macros"]
----
jreleaser {
  packagers {
    jbang {
      // Key will be capitalized and prefixed
      // with `jbang`, i.e, `jbangFoo`.
      extraProperties.put('foo', 'bar')
    }
  }
}
----
====

== Scoop

The following names are related to xref:configuration:packagers/scoop.adoc[]

[%header, cols="<2,<5", width="100%"]
|===
| Key                     | Description
| scoopBucketRepoUrl      | the bucket repository URL, `pass:[https://{{repoHost}}/{{repoOwner}}/{{repoName}}]`
| scoopBucketRepoCloneUrl | the bucket repository clone URL, `pass:[https://{{repoHost}}/{{repoOwner}}/{{repoName}}.git]`
| scoopCheckverUrl        | the URL used to check for a release version
| scoopAutoupdateUrl      | the URL pattern used to update the package
|===

Additionally, every key/value from `scoop.extraProperties` is mapped with `scoop` as key prefix and the capitalized
key, such that

[tabs]
====
YAML::
+
[source,yaml]
[subs="+macros"]
----
packagers:
  scoop:
    extraProperties:
      # Key will be capitalized and prefixed
      # with `scoop`, i.e, `scoopFoo`.
      foo: bar
----
TOML::
+
[source,toml]
[subs="+macros"]
----
[packagers.scoop]
  # Key will be capitalized and prefixed
  # with `scoop`, i.e, `scoopFoo`.
  extraProperties.foo = "bar"
----
JSON::
+
[source,json]
[subs="+macros"]
----
{
  "packagers": {
    "scoop": {
      "extraProperties": {
        // Key will be capitalized and prefixed
        // with `scoop`, i.e, `scoopFoo`.
        "foo": "bar"
      }
    }
  }
}
----
Maven::
+
[source,xml]
[subs="+macros,verbatim"]
----
<jreleaser>
  <packagers>
    <scoop>
      <extraProperties>
        <!--
          Key will be capitalized and prefixed
          with `scoop`, i.e, `scoopFoo`.
        -->
        <foo>bar</foo>
      </extraProperties>
    </scoop>
  </packagers>
</jreleaser>
----
Gradle::
+
[source,groovy]
[subs="+macros"]
----
jreleaser {
  packagers {
    scoop {
      // Key will be capitalized and prefixed
      // with `scoop`, i.e, `scoopFoo`.
      extraProperties.put('foo', 'bar')
    }
  }
}
----
====

== Snap

The following names are related to xref:configuration:packagers/snap.adoc[]

[%header, cols="<2,<5", width="100%"]
|===
| Key               | Description
| snapRepoUrl       | the snap repository URL, `pass:[https://{{repoHost}}/{{repoOwner}}/{{repoName}}]`
| snapRepoCloneUrl  | the snap repository clone URL, `pass:[https://{{repoHost}}/{{repoOwner}}/{{repoName}}.git]`
| snapBase          | the snap base
| snapGrade         | the snap grade
| snapConfinement   | the snap confinement
| snapHasPlugs      | a boolean, when there snap defines plugs
| snapPlugs         | a list of `Plugs`
| snapHasSlots      | a boolean, when the snap defines slots
| snapSlots         | a list of `Slots`
| snapHasLocalPlugs | a boolean, when the snap defines plug names
| snapLocalPlugs    | a list of plug names
| snapHasLocalSlots | a boolean, when the snap defines  slot names
| snapLocalSlots    | a list of slot names
|===

A `Plug` defines the following fields

[%header, cols="<2,<5", width="100%"]
|===
| Key        | Description
| name       | the plug's name
| attributes | a map of key/value attributes
|===

A `Slot` defines the following fields

[%header, cols="<2,<5", width="100%"]
|===
| Key        | Description
| name       | the slot's name
| attributes | a map of key/value attributes
| reads      | a list of read names
| writes     | a list of write names
| hasReads   | a boolean, when the slot defines reads
| hasWrites  | a boolean, when the slot defines writes
|===

Additionally, every key/value from `snap.extraProperties` is mapped with `snap` as key prefix and the capitalized
key, such that

[tabs]
====
YAML::
+
[source,yaml]
[subs="+macros"]
----
packagers:
  snap:
    extraProperties:
      # Key will be capitalized and prefixed
      # with `snap`, i.e, `snapFoo`.
      foo: bar
----
TOML::
+
[source,toml]
[subs="+macros"]
----
[packagers.snap]
  # Key will be capitalized and prefixed
  # with `snap`, i.e, `snapFoo`.
  extraProperties.foo = "bar"
----
JSON::
+
[source,json]
[subs="+macros"]
----
{
  "packagers": {
    "snap": {
      "extraProperties": {
        // Key will be capitalized and prefixed
        // with `snap`, i.e, `snapFoo`.
        "foo": "bar"
      }
    }
  }
}
----
Maven::
+
[source,xml]
[subs="+macros,verbatim"]
----
<jreleaser>
  <packagers>
    <snap>
      <extraProperties>
        <!--
          Key will be capitalized and prefixed
          with `snap`, i.e, `snapFoo`.
        -->
        <foo>bar</foo>
      </extraProperties>
    </snap>
  </packagers>
</jreleaser>
----
Gradle::
+
[source,groovy]
[subs="+macros"]
----
jreleaser {
  packagers {
    snap {
      // Key will be capitalized and prefixed
      // with `snap`, i.e, `snapFoo`.
      extraProperties.put('foo', 'bar')
    }
  }
}
----
====

== Discord

Every key/value from `discord.extraProperties` is mapped with `discord` as key prefix and the capitalized
key, such that

[tabs]
====
YAML::
+
[source,yaml]
[subs="+macros"]
----
announce:
  discord:
    extraProperties:
      # Key will be capitalized and prefixed
      # with `discord`, i.e, `discordFoo`.
      foo: bar
----
TOML::
+
[source,toml]
[subs="+macros"]
----
[announce.discord]
  # Key will be capitalized and prefixed
  # with `discord`, i.e, `discordFoo`.
  extraProperties.foo = "bar"
----
JSON::
+
[source,json]
[subs="+macros"]
----
{
  "announce": {
    "discord": {
      "extraProperties": {
        // Key will be capitalized and prefixed
        // with `discord`, i.e, `discordFoo`.
        "foo": "bar"
      }
    }
  }
}
----
Maven::
+
[source,xml]
[subs="+macros,verbatim"]
----
<jreleaser>
  <announce>
    <discord>
      <extraProperties>
        <!--
          Key will be capitalized and prefixed
          with `discord`, i.e, `discordFoo`.
        -->
        <foo>bar</foo>
      </extraProperties>
    </discord>
  </announce>
</jreleaser>
----
Gradle::
+
[source,groovy]
[subs="+macros"]
----
jreleaser {
  announce {
    discord {
      // Key will be capitalized and prefixed
      // with `discord`, i.e, `discordFoo`.
      extraProperties.put('foo', 'bar')
    }
  }
}
----
====

== Discussions

Every key/value from `discussions.extraProperties` is mapped with `discussions` as key prefix and the capitalized
key, such that

[tabs]
====
YAML::
+
[source,yaml]
[subs="+macros"]
----
announce:
  discussions:
    extraProperties:
      # Key will be capitalized and prefixed
      # with `discussions`, i.e, `discussionsFoo`.
      foo: bar
----
TOML::
+
[source,toml]
[subs="+macros"]
----
[announce.discussions]
  # Key will be capitalized and prefixed
  # with `discussions`, i.e, `discussionsFoo`.
  extraProperties.foo = "bar"
----
JSON::
+
[source,json]
[subs="+macros"]
----
{
  "announce": {
    "discussions": {
      "extraProperties": {
        // Key will be capitalized and prefixed
        // with `discussions`, i.e, `discussionsFoo`.
        "foo": "bar"
      }
    }
  }
}
----
Maven::
+
[source,xml]
[subs="+macros,verbatim"]
----
<jreleaser>
  <announce>
    <discussions>
      <extraProperties>
        <!--
          Key will be capitalized and prefixed
          with `discussions`, i.e, `discussionsFoo`.
        -->
        <foo>bar</foo>
      </extraProperties>
    </discussions>
  </announce>
</jreleaser>
----
Gradle::
+
[source,groovy]
[subs="+macros"]
----
jreleaser {
  announce {
    discussions {
      // Key will be capitalized and prefixed
      // with `discussions`, i.e, `discussionsFoo`.
      extraProperties.put('foo', 'bar')
    }
  }
}
----
====

== Mail

Every key/value from `mail.extraProperties` is mapped with `mail` as key prefix and the capitalized
key, such that

[tabs]
====
YAML::
+
[source,yaml]
[subs="+macros"]
----
announce:
  mail:
    extraProperties:
      # Key will be capitalized and prefixed
      # with `mail`, i.e, `mailFoo`.
      foo: bar
----
TOML::
+
[source,toml]
[subs="+macros"]
----
[announce.mail]
  # Key will be capitalized and prefixed
  # with `mail`, i.e, `mailFoo`.
  extraProperties.foo = "bar"
----
JSON::
+
[source,json]
[subs="+macros"]
----
{
  "announce": {
    "mail": {
      "extraProperties": {
        // Key will be capitalized and prefixed
        // with `mail`, i.e, `mailFoo`.
        "foo": "bar"
      }
    }
  }
}
----
Maven::
+
[source,xml]
[subs="+macros,verbatim"]
----
<jreleaser>
  <announce>
    <mail>
      <extraProperties>
        <!--
          Key will be capitalized and prefixed
          with `mail`, i.e, `mailFoo`.
        -->
        <foo>bar</foo>
      </extraProperties>
    </mail>
  </announce>
</jreleaser>
----
Gradle::
+
[source,groovy]
[subs="+macros"]
----
jreleaser {
  announce {
    mail {
      // Key will be capitalized and prefixed
      // with `mail`, i.e, `mailFoo`.
      extraProperties.put('foo', 'bar')
    }
  }
}
----
====

== Mastodon

Every key/value from `mastodon.extraProperties` is mapped with `mastodon` as key prefix and the capitalized
key, such that

[tabs]
====
YAML::
+
[source,yaml]
[subs="+macros"]
----
announce:
  mastodon:
    extraProperties:
      # Key will be capitalized and prefixed
      # with `mastodon`, i.e, `mastodonFoo`.
      foo: bar
----
TOML::
+
[source,toml]
[subs="+macros"]
----
[announce.mastodon]
  # Key will be capitalized and prefixed
  # with `mastodon`, i.e, `mastodonFoo`.
  extraProperties.foo = "bar"
----
JSON::
+
[source,json]
[subs="+macros"]
----
{
  "announce": {
    "mastodon": {
      "extraProperties": {
        // Key will be capitalized and prefixed
        // with `mastodon`, i.e, `mastodonFoo`.
        "foo": "bar"
      }
    }
  }
}
----
Maven::
+
[source,xml]
[subs="+macros,verbatim"]
----
<jreleaser>
  <announce>
    <mastodon>
      <extraProperties>
        <!--
          Key will be capitalized and prefixed
          with `mastodon`, i.e, `mastodonFoo`.
        -->
        <foo>bar</foo>
      </extraProperties>
    </mastodon>
  </announce>
</jreleaser>
----
Gradle::
+
[source,groovy]
[subs="+macros"]
----
jreleaser {
  announce {
    mastodon {
      // Key will be capitalized and prefixed
      // with `mastodon`, i.e, `mastodonFoo`.
      extraProperties.put('foo', 'bar')
    }
  }
}
----
====

== Mattermost

Every key/value from `mattermost.extraProperties` is mapped with `mattermost` as key prefix and the capitalized
key, such that

[tabs]
====
YAML::
+
[source,yaml]
[subs="+macros"]
----
announce:
  mattermost:
    extraProperties:
      # Key will be capitalized and prefixed
      # with `mattermost`, i.e, `mattermostFoo`.
      foo: bar
----
TOML::
+
[source,toml]
[subs="+macros"]
----
[announce.mattermost]
  # Key will be capitalized and prefixed
  # with `mattermost`, i.e, `mattermostFoo`.
  extraProperties.foo = "bar"
----
JSON::
+
[source,json]
[subs="+macros"]
----
{
  "announce": {
    "mattermost": {
      "extraProperties": {
        // Key will be capitalized and prefixed
        // with `mattermost`, i.e, `mattermostFoo`.
        "foo": "bar"
      }
    }
  }
}
----
Maven::
+
[source,xml]
[subs="+macros,verbatim"]
----
<jreleaser>
  <announce>
    <mattermost>
      <extraProperties>
        <!--
          Key will be capitalized and prefixed
          with `mattermost`, i.e, `mattermostFoo`.
        -->
        <foo>bar</foo>
      </extraProperties>
    </mattermost>
  </announce>
</jreleaser>
----
Gradle::
+
[source,groovy]
[subs="+macros"]
----
jreleaser {
  announce {
    mattermost {
      // Key will be capitalized and prefixed
      // with `mattermost`, i.e, `mattermostFoo`.
      extraProperties.put('foo', 'bar')
    }
  }
}
----
====

== Sdkman

Every key/value from `sdkman.extraProperties` is mapped with `sdkman` as key prefix and the capitalized
key, such that

[tabs]
====
YAML::
+
[source,yaml]
[subs="+macros"]
----
announce:
  sdkman:
    extraProperties:
      # Key will be capitalized and prefixed
      # with `sdkman`, i.e, `sdkmanFoo`.
      foo: bar
----
TOML::
+
[source,toml]
[subs="+macros"]
----
[announce.sdkman]
  # Key will be capitalized and prefixed
  # with `sdkman`, i.e, `sdkmanFoo`.
  extraProperties.foo = "bar"
----
JSON::
+
[source,json]
[subs="+macros"]
----
{
  "announce": {
    "sdkman": {
      "extraProperties": {
        // Key will be capitalized and prefixed
        // with `sdkman`, i.e, `sdkmanFoo`.
        "foo": "bar"
      }
    }
  }
}
----
Maven::
+
[source,xml]
[subs="+macros,verbatim"]
----
<jreleaser>
  <announce>
    <sdkman>
      <extraProperties>
        <!--
          Key will be capitalized and prefixed
          with `sdkman`, i.e, `sdkmanFoo`.
        -->
        <foo>bar</foo>
      </extraProperties>
    </sdkman>
  </announce>
</jreleaser>
----
Gradle::
+
[source,groovy]
[subs="+macros"]
----
jreleaser {
  announce {
    sdkman {
      // Key will be capitalized and prefixed
      // with `sdkman`, i.e, `sdkmanFoo`.
      extraProperties.put('foo', 'bar')
    }
  }
}
----
====

== Slack

Every key/value from `slack.extraProperties` is mapped with `slack` as key prefix and the capitalized
key, such that

[tabs]
====
YAML::
+
[source,yaml]
[subs="+macros"]
----
announce:
  slack:
    extraProperties:
      # Key will be capitalized and prefixed
      # with `slack`, i.e, `slackFoo`.
      foo: bar
----
TOML::
+
[source,toml]
[subs="+macros"]
----
[announce.slack]
  # Key will be capitalized and prefixed
  # with `slack`, i.e, `slackFoo`.
  extraProperties.foo = "bar"
----
JSON::
+
[source,json]
[subs="+macros"]
----
{
  "announce": {
    "slack": {
      "extraProperties": {
        // Key will be capitalized and prefixed
        // with `slack`, i.e, `slackFoo`.
        "foo": "bar"
      }
    }
  }
}
----
Maven::
+
[source,xml]
[subs="+macros,verbatim"]
----
<jreleaser>
  <announce>
    <slack>
      <extraProperties>
        <!--
          Key will be capitalized and prefixed
          with `slack`, i.e, `slackFoo`.
        -->
        <foo>bar</foo>
      </extraProperties>
    </slack>
  </announce>
</jreleaser>
----
Gradle::
+
[source,groovy]
[subs="+macros"]
----
jreleaser {
  announce {
    slack {
      // Key will be capitalized and prefixed
      // with `slack`, i.e, `slackFoo`.
      extraProperties.put('foo', 'bar')
    }
  }
}
----
====

== Teams

Every key/value from `teams.extraProperties` is mapped with `teams` as key prefix and the capitalized
key, such that

[tabs]
====
YAML::
+
[source,yaml]
[subs="+macros"]
----
announce:
  teams:
    extraProperties:
      # Key will be capitalized and prefixed
      # with `teams`, i.e, `teamsFoo`.
      foo: bar
----
TOML::
+
[source,toml]
[subs="+macros"]
----
[announce.teams]
  # Key will be capitalized and prefixed
  # with `teams`, i.e, `teamsFoo`.
  extraProperties.foo = "bar"
----
JSON::
+
[source,json]
[subs="+macros"]
----
{
  "announce": {
    "teams": {
      "extraProperties": {
        // Key will be capitalized and prefixed
        // with `teams`, i.e, `teamsFoo`.
        "foo": "bar"
      }
    }
  }
}
----
Maven::
+
[source,xml]
[subs="+macros,verbatim"]
----
<jreleaser>
  <announce>
    <teams>
      <extraProperties>
        <!--
          Key will be capitalized and prefixed
          with `teams`, i.e, `teamsFoo`.
        -->
        <foo>bar</foo>
      </extraProperties>
    </teams>
  </announce>
</jreleaser>
----
Gradle::
+
[source,groovy]
[subs="+macros"]
----
jreleaser {
  announce {
    teams {
      // Key will be capitalized and prefixed
      // with `teams`, i.e, `teamsFoo`.
      extraProperties.put('foo', 'bar')
    }
  }
}
----
====

== Twitter

Every key/value from `twitter.extraProperties` is mapped with `twitter` as key prefix and the capitalized
key, such that

[tabs]
====
YAML::
+
[source,yaml]
[subs="+macros"]
----
announce:
  twitter:
    extraProperties:
      # Key will be capitalized and prefixed
      # with `twitter`, i.e, `twitterFoo`.
      foo: bar
----
TOML::
+
[source,toml]
[subs="+macros"]
----
[announce.twitter]
  # Key will be capitalized and prefixed
  # with `twitter`, i.e, `twitterFoo`.
  extraProperties.foo = "bar"
----
JSON::
+
[source,json]
[subs="+macros"]
----
{
  "announce": {
    "twitter": {
      "extraProperties": {
        // Key will be capitalized and prefixed
        // with `twitter`, i.e, `twitterFoo`.
        "foo": "bar"
      }
    }
  }
}
----
Maven::
+
[source,xml]
[subs="+macros,verbatim"]
----
<jreleaser>
  <announce>
    <twitter>
      <extraProperties>
        <!--
          Key will be capitalized and prefixed
          with `twitter`, i.e, `twitterFoo`.
        -->
        <foo>bar</foo>
      </extraProperties>
    </twitter>
  </announce>
</jreleaser>
----
Gradle::
+
[source,groovy]
[subs="+macros"]
----
jreleaser {
  announce {
    twitter {
      // Key will be capitalized and prefixed
      // with `twitter`, i.e, `twitterFoo`.
      extraProperties.put('foo', 'bar')
    }
  }
}
----
====

== Zulip

Every key/value from `zulip.extraProperties` is mapped with `zulip` as key prefix and the capitalized
key, such that

[tabs]
====
YAML::
+
[source,yaml]
[subs="+macros"]
----
announce:
  zulip:
    extraProperties:
      # Key will be capitalized and prefixed
      # with `zulip`, i.e, `zulipFoo`.
      foo: bar
----
TOML::
+
[source,toml]
[subs="+macros"]
----
[announce.zulip]
  # Key will be capitalized and prefixed
  # with `zulip`, i.e, `zulipFoo`.
  extraProperties.foo = "bar"
----
JSON::
+
[source,json]
[subs="+macros"]
----
{
  "announce": {
    "zulip": {
      "extraProperties": {
        // Key will be capitalized and prefixed
        // with `zulip`, i.e, `zulipFoo`.
        "foo": "bar"
      }
    }
  }
}
----
Maven::
+
[source,xml]
[subs="+macros,verbatim"]
----
<jreleaser>
  <announce>
    <zulip>
      <extraProperties>
        <!--
          Key will be capitalized and prefixed
          with `zulip`, i.e, `zulipFoo`.
        -->
        <foo>bar</foo>
      </extraProperties>
    </zulip>
  </announce>
</jreleaser>
----
Gradle::
+
[source,groovy]
[subs="+macros"]
----
jreleaser {
  announce {
    zulip {
      // Key will be capitalized and prefixed
      // with `zulip`, i.e, `zulipFoo`.
      extraProperties.put('foo', 'bar')
    }
  }
}
----
====

