Name Templates

environment:
  properties:
    foo: bar

[environment]
  properties.foo = "bar"

{
  "environment": {
    "properties": {
      "foo": "bar"
    }
  }
}

<jreleaser>
  <environment>
    <properties>
      <foo>bar</foo>
    </properties>
  </environment>
</jreleaser>

jreleaser {
  environment {
    properties.put('foo', 'bar')
  }
}

project:
  extraProperties:
    # Key will be capitalized and prefixed
    # with `project`, i.e, `projectFoo`.
    foo: bar

[project]
  # Key will be capitalized and prefixed
  # with `project`, i.e, `projectFoo`.
  extraProperties.foo = "bar"

{
  "project": {
    "extraProperties": {
      // Key will be capitalized and prefixed
      // with `project`, i.e, `projectFoo`.
      "foo": "bar"
    }
  }
}

<jreleaser>
  <project>
    <extraProperties>
      <!--
        Key will be capitalized and prefixed
        with `project`, i.e, `projectFoo`.
      -->
      <foo>bar</foo>
    </extraProperties>
  </project>
</jreleaser>

jreleaser {
  project {
    // Key will be capitalized and prefixed
    // with `project`, i.e, `projectFoo`.
    extraProperties.put('foo', 'bar')
  }
}

project:
  java:
    extraProperties:
      # Key will be capitalized and prefixed
      # with `java`, i.e, `javaFoo`.
      foo: bar

[project]
  # Key will be capitalized and prefixed
  # with `java`, i.e, `javaFoo`.
  java.extraProperties.foo = "bar"

{
  "project": {
    "java": {
      "extraProperties": {
        // Key will be capitalized and prefixed
        // with `java`, i.e, `javaFoo`.
        "foo": "bar"
      }
    }
  }
}

<jreleaser>
  <project>
    <java>
      <extraProperties>
        <!--
          Key will be capitalized and prefixed
          with `java`, i.e, `javaFoo`.
        -->
        <foo>bar</foo>
      </extraProperties>
    </java>
  </project>
</jreleaser>

jreleaser {
  project {
    java {
      // Key will be capitalized and prefixed
      // with `java`, i.e, `javaFoo`.
      extraProperties.put('foo', 'bar')
    }
  }
}

release:
  github:
    changelog:
      extraProperties:
        # Key will be capitalized and prefixed
        # with `changelog`, i.e, `changelogFoo`.
        foo: bar

[release.github]
  # Key will be capitalized and prefixed
  # with `changelog`, i.e, `changelogFoo`.
  changelog.extraProperties.foo = "bar"

{
  "release": {
    "github": {
      "changelog": {
        "extraProperties": {
          // Key will be capitalized and prefixed
          // with `changelog`, i.e, `changelogFoo`.
          "foo": "bar"
        }
      }
    }
  }
}

<jreleaser>
  <release>
    <github>
      <changelog>
        <extraProperties>
          <!--
            Key will be capitalized and prefixed
            with `changelog`, i.e, `changelogFoo`.
          -->
          <foo>bar</foo>
        </extraProperties>
      </changelog>
    </github>
  </release>
</jreleaser>

jreleaser {
  release {
    github {
      changelog {
        // Key will be capitalized and prefixed
        // with `changelog`, i.e, `changelogFoo`.
        extraProperties.put('foo', 'bar')
      }
    }
  }
}

distributions:
  app:
    extraProperties:
      # Key will be capitalized and prefixed
      # with `distribution`, i.e, `distributionFoo`.
      foo: bar

[distributions.app]
  # Key will be capitalized and prefixed
  # with `distribution`, i.e, `distributionFoo`.
  extraProperties.foo = "bar"

{
  "distributions": {
    "app": {
      "extraProperties": {
        // Key will be capitalized and prefixed
        // with `distribution`, i.e, `distributionFoo`.
        "foo": "bar"
      }
    }
  }
}

<jreleaser>
  <distributions>
    <app>
      <extraProperties>
        <!--
          Key will be capitalized and prefixed
          with `distribution`, i.e, `distributionFoo`.
        -->
        <foo>bar</foo>
      </extraProperties>
    </app>
  </distributions>
</jreleaser>

jreleaser {
  distributions {
    app {
      // Key will be capitalized and prefixed
      // with `distribution`, i.e, `distributionFoo`.
      extraProperties.put('foo', 'bar')
    }
  }
}

distributions:
  app:
    java:
      extraProperties:
        # Key will be capitalized and prefixed
        # with `java`, i.e, `javaFoo`.
        foo: bar

[distributions.app]
  # Key will be capitalized and prefixed
  # with `java`, i.e, `javaFoo`.
  java.extraProperties.foo = "bar"

{
  "distributions": {
    "app": {
      "java": {
        "extraProperties": {
          // Key will be capitalized and prefixed
          // with `java`, i.e, `javaFoo`.
          "foo": "bar"
        }
      }
    }
  }
}

<jreleaser>
  <distributions>
    <app>
      <java>
        <extraProperties>
          <!--
            Key will be capitalized and prefixed
            with `java`, i.e, `javaFoo`.
          -->
          <foo>bar</foo>
        </extraProperties>
      </java>
    </app>
  </distributions>
</jreleaser>

jreleaser {
  distributions {
    app {
      java {
        // Key will be capitalized and prefixed
        // with `java`, i.e, `javaFoo`.
        extraProperties.put('foo', 'bar')
      }
    }
  }
}

checksum:
  algorithms:
    - MD5
    - SHA-256

distributions:
  app:
    artifacts:
      - path: path/to/{{distributionName}}-{{projectVersion}}.zip
        extraProperties:
          main: true
      - path: path/to/{{distributionName}}-{{projectVersion}}-mac.zip
        platform: osx-aarch_64

[checksum]
  algorithms = ["MD5", "SHA-256"]

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

[[distributions.app.artifact]]
  path = "path/to/{{distributionName}}-{{projectVersion}}-mac.zip"
  platform = "osx-aarch_64"

{
  "checksums": {
    "algorithms": [
      "MD5",
      "SHA-256"
    ]
  },

  "distributions": {
    "app": {
      "artifacts": [
        {
          "path": "path/to/{{distributionName}}-{{projectVersion}}.zip",
          "extraProperties":
          {
            "main": true
          }
        },
        {
          "path": "path/to/{{distributionName}}-{{projectVersion}}-mac.zip",
          "platform": "osx-aarch_64"
        }
      ],
    }
  }
}

<jreleaser>
  <checksum>
    <algorithms>
      <algorithm>MD5</algorithm>
      <algorithm>SHA-256</algorithm>
    </algorithms>
  </checksum>
  <distributions>
    <app>
      <artifacts>
        <artifact>
          <path>path/to/{{distributionName}}-{{projectVersion}}.zip</path>
          <extraProperties>
            <main>true</main>
          </extraProperties>
        </artifact>
        <artifact>
          <path>path/to/{{distributionName}}-{{projectVersion}}-mac.zip</path>
          <platform>osx-aarch_64</platform>
        </artifact>
      </artifacts>
    </app>
  </distributions>
</jreleaser>

jreleaser {
  checksum {
    algorithm('MD5')
    algorithm('SHA-256')
  }
  distributions {
    app {
      artifact {
        path = "path/to/{{distributionName}}-{{projectVersion}}.zip"
        extraProperties.put("main", true)
      }
      artifact {
        path = "path/to/{{distributionName}}-{{projectVersion}}-mac.zip"
        platform = 'osx-aarch_64'
      }
    }
  }
}

upload:
  artifactory:
    app:
      extraProperties:
        # Key will be capitalized and prefixed
        # with `artifactory`, i.e, `artifactoryFoo`.
        foo: bar

[upload.artifactory.app]
  # Key will be capitalized and prefixed
  # with `artifactory`, i.e, `artifactoryFoo`.
  extraProperties.foo = "bar"

{
  "upload": {
    "artifactory": {
      "app": {
        "extraProperties": {
          // Key will be capitalized and prefixed
          // with `artifactory`, i.e, `artifactoryFoo`.
          "foo": "bar"
        }
      }
    }
  }
}

<jreleaser>
  <upload>
    <artifactory>
      <app>
        <extraProperties>
          <!--
            Key will be capitalized and prefixed
            with `artifactory`, i.e, `artifactoryFoo`.
          -->
          <foo>bar</foo>
        </extraProperties>
      </app>
    </artifactory>
  </upload>
</jreleaser>

jreleaser {
  upload {
    artifactory {
      app {
        // Key will be capitalized and prefixed
        // with `artifactory`, i.e, `artifactoryFoo`.
        extraProperties.put('foo', 'bar')
      }
    }
  }
}

packagers:
  appImage:
    extraProperties:
      # Key will be capitalized and prefixed
      # with `appImage`, i.e, `appImageFoo`.
      foo: bar

[packagers.appImage]
  # Key will be capitalized and prefixed
  # with `appImage`, i.e, `appImageFoo`.
  extraProperties.foo = "bar"

{
  "packagers": {
    "appImage": {
      "extraProperties": {
        // Key will be capitalized and prefixed
        // with `appImage`, i.e, `appImageFoo`.
        "foo": "bar"
      }
    }
  }
}

<jreleaser>
  <packagers>
    <appImage>
      <extraProperties>
        <!--
          Key will be capitalized and prefixed
          with `appImage`, i.e, `appImageFoo`.
        -->
        <foo>bar</foo>
      </extraProperties>
    </appImage>
  </packagers>
</jreleaser>

jreleaser {
  packagers {
    appImage {
      // Key will be capitalized and prefixed
      // with `appImage`, i.e, `appImageFoo`.
      extraProperties.put('foo', 'bar')
    }
  }
}

packagers:
  asdf:
    extraProperties:
      # Key will be capitalized and prefixed
      # with `asdf`, i.e, `asdfFoo`.
      foo: bar

[packagers.asdf]
  # Key will be capitalized and prefixed
  # with `asdf`, i.e, `asdfFoo`.
  extraProperties.foo = "bar"

{
  "packagers": {
    "asdf": {
      "extraProperties": {
        // Key will be capitalized and prefixed
        // with `asdf`, i.e, `asdfFoo`.
        "foo": "bar"
      }
    }
  }
}

<jreleaser>
  <packagers>
    <asdf>
      <extraProperties>
        <!--
          Key will be capitalized and prefixed
          with `asdf`, i.e, `asdfFoo`.
        -->
        <foo>bar</foo>
      </extraProperties>
    </asdf>
  </packagers>
</jreleaser>

jreleaser {
  packagers {
    asdf {
      // Key will be capitalized and prefixed
      // with `asdf`, i.e, `asdfFoo`.
      extraProperties.put('foo', 'bar')
    }
  }
}

announce:
  bluesky:
    extraProperties:
      # Key will be capitalized and prefixed
      # with `bluesky`, i.e, `blueskyFoo`.
      foo: bar

[announce.bluesky]
  # Key will be capitalized and prefixed
  # with `bluesky`, i.e, `blueskyFoo`.
  extraProperties.foo = "bar"

{
  "announce": {
    "bluesky": {
      "extraProperties": {
        // Key will be capitalized and prefixed
        // with `bluesky`, i.e, `blueskyFoo`.
        "foo": "bar"
      }
    }
  }
}

<jreleaser>
  <announce>
    <bluesky>
      <extraProperties>
        <!--
          Key will be capitalized and prefixed
          with `bluesky`, i.e, `blueskyFoo`.
        -->
        <foo>bar</foo>
      </extraProperties>
    </bluesky>
  </announce>
</jreleaser>

jreleaser {
  announce {
    bluesky {
      // Key will be capitalized and prefixed
      // with `bluesky`, i.e, `blueskyFoo`.
      extraProperties.put('foo', 'bar')
    }
  }
}

packagers:
  brew:
    extraProperties:
      # Key will be capitalized and prefixed
      # with `brew`, i.e, `brewFoo`.
      foo: bar

[packagers.brew]
  # Key will be capitalized and prefixed
  # with `brew`, i.e, `brewFoo`.
  extraProperties.foo = "bar"

{
  "packagers": {
    "brew": {
      "extraProperties": {
        // Key will be capitalized and prefixed
        // with `brew`, i.e, `brewFoo`.
        "foo": "bar"
      }
    }
  }
}

<jreleaser>
  <packagers>
    <brew>
      <extraProperties>
        <!--
          Key will be capitalized and prefixed
          with `brew`, i.e, `brewFoo`.
        -->
        <foo>bar</foo>
      </extraProperties>
    </brew>
  </packagers>
</jreleaser>

jreleaser {
  packagers {
    brew {
      // Key will be capitalized and prefixed
      // with `brew`, i.e, `brewFoo`.
      extraProperties.put('foo', 'bar')
    }
  }
}

packagers:
  chocolatey:
    extraProperties:
      # Key will be capitalized and prefixed
      # with `chocolatey`, i.e, `chocolateyFoo`.
      foo: bar

[packagers.chocolatey]
  # Key will be capitalized and prefixed
  # with `chocolatey`, i.e, `chocolateyFoo`.
  extraProperties.foo = "bar"

{
  "packagers": {
    "chocolatey": {
      "extraProperties": {
        // Key will be capitalized and prefixed
        // with `chocolatey`, i.e, `chocolateyFoo`.
        "foo": "bar"
      }
    }
  }
}

<jreleaser>
  <packagers>
    <chocolatey>
      <extraProperties>
        <!--
          Key will be capitalized and prefixed
          with `chocolatey`, i.e, `chocolateyFoo`.
        -->
        <foo>bar</foo>
      </extraProperties>
    </chocolatey>
  </packagers>
</jreleaser>

jreleaser {
  packagers {
    chocolatey {
      // Key will be capitalized and prefixed
      // with `chocolatey`, i.e, `chocolateyFoo`.
      extraProperties.put('foo', 'bar')
    }
  }
}

announce:
  cyclonedx:
    extraProperties:
      # Key will be capitalized and prefixed
      # with `cyclonedx`, i.e, `cyclonedxFoo`.
      foo: bar

[announce.cyclonedx]
  # Key will be capitalized and prefixed
  # with `cyclonedx`, i.e, `cyclonedxFoo`.
  extraProperties.foo = "bar"

{
  "announce": {
    "cyclonedx": {
      "extraProperties": {
        // Key will be capitalized and prefixed
        // with `cyclonedx`, i.e, `cyclonedxFoo`.
        "foo": "bar"
      }
    }
  }
}

<jreleaser>
  <announce>
    <cyclonedx>
      <extraProperties>
        <!--
          Key will be capitalized and prefixed
          with `cyclonedx`, i.e, `cyclonedxFoo`.
        -->
        <foo>bar</foo>
      </extraProperties>
    </cyclonedx>
  </announce>
</jreleaser>

jreleaser {
  announce {
    cyclonedx {
      // Key will be capitalized and prefixed
      // with `cyclonedx`, i.e, `cyclonedxFoo`.
      extraProperties.put('foo', 'bar')
    }
  }
}

packagers:
  docker:
    extraProperties:
      # Key will be capitalized and prefixed
      # with `docker`, i.e, `dockerFoo`.
      foo: bar

[packagers.docker]
  # Key will be capitalized and prefixed
  # with `docker`, i.e, `dockerFoo`.
  extraProperties.foo = "bar"

{
  "packagers": {
    "docker": {
      "extraProperties": {
        // Key will be capitalized and prefixed
        // with `docker`, i.e, `dockerFoo`.
        "foo": "bar"
      }
    }
  }
}

<jreleaser>
  <packagers>
    <docker>
      <extraProperties>
        <!--
          Key will be capitalized and prefixed
          with `docker`, i.e, `dockerFoo`.
        -->
        <foo>bar</foo>
      </extraProperties>
    </docker>
  </packagers>
</jreleaser>

jreleaser {
  packagers {
    docker {
      // Key will be capitalized and prefixed
      // with `docker`, i.e, `dockerFoo`.
      extraProperties.put('foo', 'bar')
    }
  }
}

announce:
  discord:
    extraProperties:
      # Key will be capitalized and prefixed
      # with `discord`, i.e, `discordFoo`.
      foo: bar

[announce.discord]
  # Key will be capitalized and prefixed
  # with `discord`, i.e, `discordFoo`.
  extraProperties.foo = "bar"

{
  "announce": {
    "discord": {
      "extraProperties": {
        // Key will be capitalized and prefixed
        // with `discord`, i.e, `discordFoo`.
        "foo": "bar"
      }
    }
  }
}

<jreleaser>
  <announce>
    <discord>
      <extraProperties>
        <!--
          Key will be capitalized and prefixed
          with `discord`, i.e, `discordFoo`.
        -->
        <foo>bar</foo>
      </extraProperties>
    </discord>
  </announce>
</jreleaser>

jreleaser {
  announce {
    discord {
      // Key will be capitalized and prefixed
      // with `discord`, i.e, `discordFoo`.
      extraProperties.put('foo', 'bar')
    }
  }
}

announce:
  discourse:
    extraProperties:
      # Key will be capitalized and prefixed
      # with `discourse`, i.e, `discourseFoo`.
      foo: bar

[announce.discourse]
  # Key will be capitalized and prefixed
  # with `discourse`, i.e, `discourseFoo`.
  extraProperties.foo = "bar"

{
  "announce": {
    "discourse": {
      "extraProperties": {
        // Key will be capitalized and prefixed
        // with `discourse`, i.e, `discourseFoo`.
        "foo": "bar"
      }
    }
  }
}

<jreleaser>
  <announce>
    <discourse>
      <extraProperties>
        <!--
          Key will be capitalized and prefixed
          with `discourse`, i.e, `discourseFoo`.
        -->
        <foo>bar</foo>
      </extraProperties>
    </discourse>
  </announce>
</jreleaser>

jreleaser {
  announce {
    discourse {
      // Key will be capitalized and prefixed
      // with `discourse`, i.e, `discourseFoo`.
      extraProperties.put('foo', 'bar')
    }
  }
}

announce:
  discussions:
    extraProperties:
      # Key will be capitalized and prefixed
      # with `discussions`, i.e, `discussionsFoo`.
      foo: bar

[announce.discussions]
  # Key will be capitalized and prefixed
  # with `discussions`, i.e, `discussionsFoo`.
  extraProperties.foo = "bar"

{
  "announce": {
    "discussions": {
      "extraProperties": {
        // Key will be capitalized and prefixed
        // with `discussions`, i.e, `discussionsFoo`.
        "foo": "bar"
      }
    }
  }
}

<jreleaser>
  <announce>
    <discussions>
      <extraProperties>
        <!--
          Key will be capitalized and prefixed
          with `discussions`, i.e, `discussionsFoo`.
        -->
        <foo>bar</foo>
      </extraProperties>
    </discussions>
  </announce>
</jreleaser>

jreleaser {
  announce {
    discussions {
      // Key will be capitalized and prefixed
      // with `discussions`, i.e, `discussionsFoo`.
      extraProperties.put('foo', 'bar')
    }
  }
}

announce:
  gitter:
    extraProperties:
      # Key will be capitalized and prefixed
      # with `gitter`, i.e, `gitterFoo`.
      foo: bar

[announce.gitter]
  # Key will be capitalized and prefixed
  # with `gitter`, i.e, `gitterFoo`.
  extraProperties.foo = "bar"

{
  "announce": {
    "gitter": {
      "extraProperties": {
        // Key will be capitalized and prefixed
        // with `gitter`, i.e, `gitterFoo`.
        "foo": "bar"
      }
    }
  }
}

<jreleaser>
  <announce>
    <gitter>
      <extraProperties>
        <!--
          Key will be capitalized and prefixed
          with `gitter`, i.e, `gitterFoo`.
        -->
        <foo>bar</foo>
      </extraProperties>
    </gitter>
  </announce>
</jreleaser>

jreleaser {
  announce {
    gitter {
      // Key will be capitalized and prefixed
      // with `gitter`, i.e, `gitterFoo`.
      extraProperties.put('foo', 'bar')
    }
  }
}

packagers:
  flatpak:
    extraProperties:
      # Key will be capitalized and prefixed
      # with `flatpak`, i.e, `flatpakFoo`.
      foo: bar

[packagers.flatpak]
  # Key will be capitalized and prefixed
  # with `flatpak`, i.e, `flatpakFoo`.
  extraProperties.foo = "bar"

{
  "packagers": {
    "flatpak": {
      "extraProperties": {
        // Key will be capitalized and prefixed
        // with `flatpak`, i.e, `flatpakFoo`.
        "foo": "bar"
      }
    }
  }
}

<jreleaser>
  <packagers>
    <flatpak>
      <extraProperties>
        <!--
          Key will be capitalized and prefixed
          with `flatpak`, i.e, `flatpakFoo`.
        -->
        <foo>bar</foo>
      </extraProperties>
    </flatpak>
  </packagers>
</jreleaser>

jreleaser {
  packagers {
    flatpak {
      // Key will be capitalized and prefixed
      // with `flatpak`, i.e, `flatpakFoo`.
      extraProperties.put('foo', 'bar')
    }
  }
}

announce:
  googleChat:
    extraProperties:
      # Key will be capitalized and prefixed
      # with `googleChat`, i.e, `googleChatFoo`.
      foo: bar

[announce.googleChat]
  # Key will be capitalized and prefixed
  # with `googleChat`, i.e, `googleChatFoo`.
  extraProperties.foo = "bar"

{
  "announce": {
    "googleChat": {
      "extraProperties": {
        // Key will be capitalized and prefixed
        // with `googleChat`, i.e, `googleChatFoo`.
        "foo": "bar"
      }
    }
  }
}

<jreleaser>
  <announce>
    <googleChat>
      <extraProperties>
        <!--
          Key will be capitalized and prefixed
          with `googleChat`, i.e, `googleChatFoo`.
        -->
        <foo>bar</foo>
      </extraProperties>
    </googleChat>
  </announce>
</jreleaser>

jreleaser {
  announce {
    googleChat {
      // Key will be capitalized and prefixed
      // with `googleChat`, i.e, `googleChatFoo`.
      extraProperties.put('foo', 'bar')
    }
  }
}

announce:
  linkedin:
    extraProperties:
      # Key will be capitalized and prefixed
      # with `linkedin`, i.e, `linkedinFoo`.
      foo: bar

[announce.linkedin]
  # Key will be capitalized and prefixed
  # with `linkedin`, i.e, `linkedinFoo`.
  extraProperties.foo = "bar"

{
  "announce": {
    "linkedin": {
      "extraProperties": {
        // Key will be capitalized and prefixed
        // with `linkedin`, i.e, `linkedinFoo`.
        "foo": "bar"
      }
    }
  }
}

<jreleaser>
  <announce>
    <linkedin>
      <extraProperties>
        <!--
          Key will be capitalized and prefixed
          with `linkedin`, i.e, `linkedinFoo`.
        -->
        <foo>bar</foo>
      </extraProperties>
    </linkedin>
  </announce>
</jreleaser>

jreleaser {
  announce {
    linkedin {
      // Key will be capitalized and prefixed
      // with `linkedin`, i.e, `linkedinFoo`.
      extraProperties.put('foo', 'bar')
    }
  }
}

upload:
  http:
    app:
      extraProperties:
        # Key will be capitalized and prefixed
        # with `http`, i.e, `httpFoo`.
        foo: bar

[upload.http.app]
  # Key will be capitalized and prefixed
  # with `http`, i.e, `httpFoo`.
  extraProperties.foo = "bar"

{
  "upload": {
    "http": {
      "app": {
        "extraProperties": {
          // Key will be capitalized and prefixed
          // with `http`, i.e, `httpFoo`.
          "foo": "bar"
        }
      }
    }
  }
}

<jreleaser>
  <upload>
    <http>
      <app>
        <extraProperties>
          <!--
            Key will be capitalized and prefixed
            with `http`, i.e, `httpFoo`.
          -->
          <foo>bar</foo>
        </extraProperties>
      </app>
    </http>
  </upload>
</jreleaser>

jreleaser {
  upload {
    http {
      app {
        // Key will be capitalized and prefixed
        // with `http`, i.e, `httpFoo`.
        extraProperties.put('foo', 'bar')
      }
    }
  }
}

announce:
  http:
    myHttp:
      extraProperties:
        # Key will be capitalized and prefixed
        # with `http`, i.e, `httpFoo`.
        foo: bar

[announce.http.myHttp]
  # Key will be capitalized and prefixed
  # with `http`, i.e, `httpFoo`.
  extraProperties.foo = "bar"

{
  "announce": {
    "http": {
      "myHttp": {
        "extraProperties": {
          // Key will be capitalized and prefixed
          // with `http`, i.e, `httpFoo`.
          "foo": "bar"
        }
      }
    }
  }
}

<jreleaser>
  <announce>
    <http>
      <myHttp>
        <extraProperties>
          <!--
            Key will be capitalized and prefixed
            with `http`, i.e, `httpFoo`.
          -->
          <foo>bar</foo>
        </extraProperties>
      </myHttp>
    </http>
  </announce>
</jreleaser>

jreleaser {
  announce {
    http {
      myHttp {
        // Key will be capitalized and prefixed
        // with `http`, i.e, `httpFoo`.
        extraProperties.put('foo', 'bar')
      }
    }
  }
}

packagers:
  jbang:
    extraProperties:
      # Key will be capitalized and prefixed
      # with `jbang`, i.e, `jbangFoo`.
      foo: bar

[packagers.jbang]
  # Key will be capitalized and prefixed
  # with `jbang`, i.e, `jbangFoo`.
  extraProperties.foo = "bar"

{
  "packagers": {
    "jbang": {
      "extraProperties": {
        // Key will be capitalized and prefixed
        // with `jbang`, i.e, `jbangFoo`.
        "foo": "bar"
      }
    }
  }
}

<jreleaser>
  <packagers>
    <jbang>
      <extraProperties>
        <!--
          Key will be capitalized and prefixed
          with `jbang`, i.e, `jbangFoo`.
        -->
        <foo>bar</foo>
      </extraProperties>
    </jbang>
  </packagers>
</jreleaser>

jreleaser {
  packagers {
    jbang {
      // Key will be capitalized and prefixed
      // with `jbang`, i.e, `jbangFoo`.
      extraProperties.put('foo', 'bar')
    }
  }
}

packagers:
  jib:
    extraProperties:
      # Key will be capitalized and prefixed
      # with `jib`, i.e, `jibFoo`.
      foo: bar

[packagers.jib]
  # Key will be capitalized and prefixed
  # with `jib`, i.e, `jibFoo`.
  extraProperties.foo = "bar"

{
  "packagers": {
    "jib": {
      "extraProperties": {
        // Key will be capitalized and prefixed
        // with `jib`, i.e, `jibFoo`.
        "foo": "bar"
      }
    }
  }
}

<jreleaser>
  <packagers>
    <jib>
      <extraProperties>
        <!--
          Key will be capitalized and prefixed
          with `jib`, i.e, `jibFoo`.
        -->
        <foo>bar</foo>
      </extraProperties>
    </jib>
  </packagers>
</jreleaser>

jreleaser {
  packagers {
    jib {
      // Key will be capitalized and prefixed
      // with `jib`, i.e, `jibFoo`.
      extraProperties.put('foo', 'bar')
    }
  }
}

packagers:
  macports:
    extraProperties:
      # Key will be capitalized and prefixed
      # with `macports`, i.e, `macportsFoo`.
      foo: bar

[packagers.macports]
  # Key will be capitalized and prefixed
  # with `macports`, i.e, `macportsFoo`.
  extraProperties.foo = "bar"

{
  "packagers": {
    "macports": {
      "extraProperties": {
        // Key will be capitalized and prefixed
        // with `macports`, i.e, `macportsFoo`.
        "foo": "bar"
      }
    }
  }
}

<jreleaser>
  <packagers>
    <macports>
      <extraProperties>
        <!--
          Key will be capitalized and prefixed
          with `macports`, i.e, `macportsFoo`.
        -->
        <foo>bar</foo>
      </extraProperties>
    </macports>
  </packagers>
</jreleaser>

jreleaser {
  packagers {
    macports {
      // Key will be capitalized and prefixed
      // with `macports`, i.e, `macportsFoo`.
      extraProperties.put('foo', 'bar')
    }
  }
}

announce:
  mail:
    extraProperties:
      # Key will be capitalized and prefixed
      # with `mail`, i.e, `mailFoo`.
      foo: bar

[announce.mail]
  # Key will be capitalized and prefixed
  # with `mail`, i.e, `mailFoo`.
  extraProperties.foo = "bar"

{
  "announce": {
    "mail": {
      "extraProperties": {
        // Key will be capitalized and prefixed
        // with `mail`, i.e, `mailFoo`.
        "foo": "bar"
      }
    }
  }
}

<jreleaser>
  <announce>
    <mail>
      <extraProperties>
        <!--
          Key will be capitalized and prefixed
          with `mail`, i.e, `mailFoo`.
        -->
        <foo>bar</foo>
      </extraProperties>
    </mail>
  </announce>
</jreleaser>

jreleaser {
  announce {
    mail {
      // Key will be capitalized and prefixed
      // with `mail`, i.e, `mailFoo`.
      extraProperties.put('foo', 'bar')
    }
  }
}

announce:
  mastodon:
    extraProperties:
      # Key will be capitalized and prefixed
      # with `mastodon`, i.e, `mastodonFoo`.
      foo: bar

[announce.mastodon]
  # Key will be capitalized and prefixed
  # with `mastodon`, i.e, `mastodonFoo`.
  extraProperties.foo = "bar"

{
  "announce": {
    "mastodon": {
      "extraProperties": {
        // Key will be capitalized and prefixed
        // with `mastodon`, i.e, `mastodonFoo`.
        "foo": "bar"
      }
    }
  }
}

<jreleaser>
  <announce>
    <mastodon>
      <extraProperties>
        <!--
          Key will be capitalized and prefixed
          with `mastodon`, i.e, `mastodonFoo`.
        -->
        <foo>bar</foo>
      </extraProperties>
    </mastodon>
  </announce>
</jreleaser>

jreleaser {
  announce {
    mastodon {
      // Key will be capitalized and prefixed
      // with `mastodon`, i.e, `mastodonFoo`.
      extraProperties.put('foo', 'bar')
    }
  }
}

announce:
  mattermost:
    extraProperties:
      # Key will be capitalized and prefixed
      # with `mattermost`, i.e, `mattermostFoo`.
      foo: bar

[announce.mattermost]
  # Key will be capitalized and prefixed
  # with `mattermost`, i.e, `mattermostFoo`.
  extraProperties.foo = "bar"

{
  "announce": {
    "mattermost": {
      "extraProperties": {
        // Key will be capitalized and prefixed
        // with `mattermost`, i.e, `mattermostFoo`.
        "foo": "bar"
      }
    }
  }
}

<jreleaser>
  <announce>
    <mattermost>
      <extraProperties>
        <!--
          Key will be capitalized and prefixed
          with `mattermost`, i.e, `mattermostFoo`.
        -->
        <foo>bar</foo>
      </extraProperties>
    </mattermost>
  </announce>
</jreleaser>

jreleaser {
  announce {
    mattermost {
      // Key will be capitalized and prefixed
      // with `mattermost`, i.e, `mattermostFoo`.
      extraProperties.put('foo', 'bar')
    }
  }
}

announce:
  openCollective:
    extraProperties:
      # Key will be capitalized and prefixed
      # with `openCollective`, i.e, `openCollectiveFoo`.
      foo: bar

[announce.openCollective]
  # Key will be capitalized and prefixed
  # with `openCollective`, i.e, `openCollectiveFoo`.
  extraProperties.foo = "bar"

{
  "announce": {
    "openCollective": {
      "extraProperties": {
        // Key will be capitalized and prefixed
        // with `openCollective`, i.e, `openCollectiveFoo`.
        "foo": "bar"
      }
    }
  }
}

<jreleaser>
  <announce>
    <openCollective>
      <extraProperties>
        <!--
          Key will be capitalized and prefixed
          with `openCollective`, i.e, `openCollectiveFoo`.
        -->
        <foo>bar</foo>
      </extraProperties>
    </openCollective>
  </announce>
</jreleaser>

jreleaser {
  announce {
    openCollective {
      // Key will be capitalized and prefixed
      // with `openCollective`, i.e, `openCollectiveFoo`.
      extraProperties.put('foo', 'bar')
    }
  }
}

upload:
  s3:
    app:
      extraProperties:
        # Key will be capitalized and prefixed
        # with `s3`, i.e, `s3Foo`.
        foo: bar

[upload.s3.app]
  # Key will be capitalized and prefixed
  # with `s3`, i.e, `s3Foo`.
  extraProperties.foo = "bar"

{
  "upload": {
    "s3": {
      "app": {
        "extraProperties": {
          // Key will be capitalized and prefixed
          // with `s3`, i.e, `s3Foo`.
          "foo": "bar"
        }
      }
    }
  }
}

<jreleaser>
  <upload>
    <s3>
      <app>
        <extraProperties>
          <!--
            Key will be capitalized and prefixed
            with `s3`, i.e, `s3Foo`.
          -->
          <foo>bar</foo>
        </extraProperties>
      </app>
    </s3>
  </upload>
</jreleaser>

jreleaser {
  upload {
    s3 {
      app {
        // Key will be capitalized and prefixed
        // with `s3`, i.e, `s3Foo`.
        extraProperties.put('foo', 'bar')
      }
    }
  }
}

packagers:
  scoop:
    extraProperties:
      # Key will be capitalized and prefixed
      # with `scoop`, i.e, `scoopFoo`.
      foo: bar

[packagers.scoop]
  # Key will be capitalized and prefixed
  # with `scoop`, i.e, `scoopFoo`.
  extraProperties.foo = "bar"

{
  "packagers": {
    "scoop": {
      "extraProperties": {
        // Key will be capitalized and prefixed
        // with `scoop`, i.e, `scoopFoo`.
        "foo": "bar"
      }
    }
  }
}

<jreleaser>
  <packagers>
    <scoop>
      <extraProperties>
        <!--
          Key will be capitalized and prefixed
          with `scoop`, i.e, `scoopFoo`.
        -->
        <foo>bar</foo>
      </extraProperties>
    </scoop>
  </packagers>
</jreleaser>

jreleaser {
  packagers {
    scoop {
      // Key will be capitalized and prefixed
      // with `scoop`, i.e, `scoopFoo`.
      extraProperties.put('foo', 'bar')
    }
  }
}

announce:
  sdkman:
    extraProperties:
      # Key will be capitalized and prefixed
      # with `sdkman`, i.e, `sdkmanFoo`.
      foo: bar

[announce.sdkman]
  # Key will be capitalized and prefixed
  # with `sdkman`, i.e, `sdkmanFoo`.
  extraProperties.foo = "bar"

{
  "announce": {
    "sdkman": {
      "extraProperties": {
        // Key will be capitalized and prefixed
        // with `sdkman`, i.e, `sdkmanFoo`.
        "foo": "bar"
      }
    }
  }
}

<jreleaser>
  <announce>
    <sdkman>
      <extraProperties>
        <!--
          Key will be capitalized and prefixed
          with `sdkman`, i.e, `sdkmanFoo`.
        -->
        <foo>bar</foo>
      </extraProperties>
    </sdkman>
  </announce>
</jreleaser>

jreleaser {
  announce {
    sdkman {
      // Key will be capitalized and prefixed
      // with `sdkman`, i.e, `sdkmanFoo`.
      extraProperties.put('foo', 'bar')
    }
  }
}

announce:
  slack:
    extraProperties:
      # Key will be capitalized and prefixed
      # with `slack`, i.e, `slackFoo`.
      foo: bar

[announce.slack]
  # Key will be capitalized and prefixed
  # with `slack`, i.e, `slackFoo`.
  extraProperties.foo = "bar"

{
  "announce": {
    "slack": {
      "extraProperties": {
        // Key will be capitalized and prefixed
        // with `slack`, i.e, `slackFoo`.
        "foo": "bar"
      }
    }
  }
}

<jreleaser>
  <announce>
    <slack>
      <extraProperties>
        <!--
          Key will be capitalized and prefixed
          with `slack`, i.e, `slackFoo`.
        -->
        <foo>bar</foo>
      </extraProperties>
    </slack>
  </announce>
</jreleaser>

jreleaser {
  announce {
    slack {
      // Key will be capitalized and prefixed
      // with `slack`, i.e, `slackFoo`.
      extraProperties.put('foo', 'bar')
    }
  }
}

announce:
  smtp:
    extraProperties:
      # Key will be capitalized and prefixed
      # with `smtp`, i.e, `smtpFoo`.
      foo: bar

[announce.smtp]
  # Key will be capitalized and prefixed
  # with `smtp`, i.e, `smtpFoo`.
  extraProperties.foo = "bar"

{
  "announce": {
    "smtp": {
      "extraProperties": {
        // Key will be capitalized and prefixed
        // with `smtp`, i.e, `smtpFoo`.
        "foo": "bar"
      }
    }
  }
}

<jreleaser>
  <announce>
    <smtp>
      <extraProperties>
        <!--
          Key will be capitalized and prefixed
          with `smtp`, i.e, `smtpFoo`.
        -->
        <foo>bar</foo>
      </extraProperties>
    </smtp>
  </announce>
</jreleaser>

jreleaser {
  announce {
    smtp {
      // Key will be capitalized and prefixed
      // with `smtp`, i.e, `smtpFoo`.
      extraProperties.put('foo', 'bar')
    }
  }
}

packagers:
  snap:
    extraProperties:
      # Key will be capitalized and prefixed
      # with `snap`, i.e, `snapFoo`.
      foo: bar

[packagers.snap]
  # Key will be capitalized and prefixed
  # with `snap`, i.e, `snapFoo`.
  extraProperties.foo = "bar"

{
  "packagers": {
    "snap": {
      "extraProperties": {
        // Key will be capitalized and prefixed
        // with `snap`, i.e, `snapFoo`.
        "foo": "bar"
      }
    }
  }
}

<jreleaser>
  <packagers>
    <snap>
      <extraProperties>
        <!--
          Key will be capitalized and prefixed
          with `snap`, i.e, `snapFoo`.
        -->
        <foo>bar</foo>
      </extraProperties>
    </snap>
  </packagers>
</jreleaser>

jreleaser {
  packagers {
    snap {
      // Key will be capitalized and prefixed
      // with `snap`, i.e, `snapFoo`.
      extraProperties.put('foo', 'bar')
    }
  }
}

packagers:
  spec:
    extraProperties:
      # Key will be capitalized and prefixed
      # with `spec`, i.e, `specFoo`.
      foo: bar

[packagers.spec]
  # Key will be capitalized and prefixed
  # with `spec`, i.e, `specFoo`.
  extraProperties.foo = "bar"

{
  "packagers": {
    "spec": {
      "extraProperties": {
        // Key will be capitalized and prefixed
        // with `spec`, i.e, `specFoo`.
        "foo": "bar"
      }
    }
  }
}

<jreleaser>
  <packagers>
    <spec>
      <extraProperties>
        <!--
          Key will be capitalized and prefixed
          with `spec`, i.e, `specFoo`.
        -->
        <foo>bar</foo>
      </extraProperties>
    </spec>
  </packagers>
</jreleaser>

jreleaser {
  packagers {
    spec {
      // Key will be capitalized and prefixed
      // with `spec`, i.e, `specFoo`.
      extraProperties.put('foo', 'bar')
    }
  }
}

announce:
  syft:
    extraProperties:
      # Key will be capitalized and prefixed
      # with `syft`, i.e, `syftFoo`.
      foo: bar

[announce.syft]
  # Key will be capitalized and prefixed
  # with `syft`, i.e, `syftFoo`.
  extraProperties.foo = "bar"

{
  "announce": {
    "syft": {
      "extraProperties": {
        // Key will be capitalized and prefixed
        // with `syft`, i.e, `syftFoo`.
        "foo": "bar"
      }
    }
  }
}

<jreleaser>
  <announce>
    <syft>
      <extraProperties>
        <!--
          Key will be capitalized and prefixed
          with `syft`, i.e, `syftFoo`.
        -->
        <foo>bar</foo>
      </extraProperties>
    </syft>
  </announce>
</jreleaser>

jreleaser {
  announce {
    syft {
      // Key will be capitalized and prefixed
      // with `syft`, i.e, `syftFoo`.
      extraProperties.put('foo', 'bar')
    }
  }
}

announce:
  teams:
    extraProperties:
      # Key will be capitalized and prefixed
      # with `teams`, i.e, `teamsFoo`.
      foo: bar

[announce.teams]
  # Key will be capitalized and prefixed
  # with `teams`, i.e, `teamsFoo`.
  extraProperties.foo = "bar"

{
  "announce": {
    "teams": {
      "extraProperties": {
        // Key will be capitalized and prefixed
        // with `teams`, i.e, `teamsFoo`.
        "foo": "bar"
      }
    }
  }
}

<jreleaser>
  <announce>
    <teams>
      <extraProperties>
        <!--
          Key will be capitalized and prefixed
          with `teams`, i.e, `teamsFoo`.
        -->
        <foo>bar</foo>
      </extraProperties>
    </teams>
  </announce>
</jreleaser>

jreleaser {
  announce {
    teams {
      // Key will be capitalized and prefixed
      // with `teams`, i.e, `teamsFoo`.
      extraProperties.put('foo', 'bar')
    }
  }
}

announce:
  telegram:
    extraProperties:
      # Key will be capitalized and prefixed
      # with `telegram`, i.e, `telegramFoo`.
      foo: bar

[announce.telegram]
  # Key will be capitalized and prefixed
  # with `telegram`, i.e, `telegramFoo`.
  extraProperties.foo = "bar"

{
  "announce": {
    "telegram": {
      "extraProperties": {
        // Key will be capitalized and prefixed
        // with `telegram`, i.e, `telegramFoo`.
        "foo": "bar"
      }
    }
  }
}

<jreleaser>
  <announce>
    <telegram>
      <extraProperties>
        <!--
          Key will be capitalized and prefixed
          with `telegram`, i.e, `telegramFoo`.
        -->
        <foo>bar</foo>
      </extraProperties>
    </telegram>
  </announce>
</jreleaser>

jreleaser {
  announce {
    telegram {
      // Key will be capitalized and prefixed
      // with `telegram`, i.e, `telegramFoo`.
      extraProperties.put('foo', 'bar')
    }
  }
}

announce:
  twitter:
    extraProperties:
      # Key will be capitalized and prefixed
      # with `twitter`, i.e, `twitterFoo`.
      foo: bar

[announce.twitter]
  # Key will be capitalized and prefixed
  # with `twitter`, i.e, `twitterFoo`.
  extraProperties.foo = "bar"

{
  "announce": {
    "twitter": {
      "extraProperties": {
        // Key will be capitalized and prefixed
        // with `twitter`, i.e, `twitterFoo`.
        "foo": "bar"
      }
    }
  }
}

<jreleaser>
  <announce>
    <twitter>
      <extraProperties>
        <!--
          Key will be capitalized and prefixed
          with `twitter`, i.e, `twitterFoo`.
        -->
        <foo>bar</foo>
      </extraProperties>
    </twitter>
  </announce>
</jreleaser>

jreleaser {
  announce {
    twitter {
      // Key will be capitalized and prefixed
      // with `twitter`, i.e, `twitterFoo`.
      extraProperties.put('foo', 'bar')
    }
  }
}

announce:
  webhooks:
    myWebhook:
      extraProperties:
        # Key will be capitalized and prefixed
        # with `webhook`, i.e, `webhookFoo`.
        foo: bar

[announce.webhooks.myWebhook]
  # Key will be capitalized and prefixed
  # with `webhook`, i.e, `webhookFoo`.
  extraProperties.foo = "bar"

{
  "announce": {
    "webhooks": {
      "myWebhook": {
        "extraProperties": {
          // Key will be capitalized and prefixed
          // with `webhook`, i.e, `webhookFoo`.
          "foo": "bar"
        }
      }
    }
  }
}

<jreleaser>
  <announce>
    <webhooks>
      <myWebhook>
        <extraProperties>
          <!--
            Key will be capitalized and prefixed
            with `webhook`, i.e, `webhookFoo`.
          -->
          <foo>bar</foo>
        </extraProperties>
      </myWebhook>
    </webhooks>
  </announce>
</jreleaser>

jreleaser {
  announce {
    webhooks {
      myWebhook {
        // Key will be capitalized and prefixed
        // with `webhook`, i.e, `webhookFoo`.
        extraProperties.put('foo', 'bar')
      }
    }
  }
}

packagers:
  winget:
    extraProperties:
      # Key will be capitalized and prefixed
      # with `winget`, i.e, `wingetFoo`.
      foo: bar

[packagers.winget]
  # Key will be capitalized and prefixed
  # with `winget`, i.e, `wingetFoo`.
  extraProperties.foo = "bar"

{
  "packagers": {
    "winget": {
      "extraProperties": {
        // Key will be capitalized and prefixed
        // with `winget`, i.e, `wingetFoo`.
        "foo": "bar"
      }
    }
  }
}

<jreleaser>
  <packagers>
    <winget>
      <extraProperties>
        <!--
          Key will be capitalized and prefixed
          with `winget`, i.e, `wingetFoo`.
        -->
        <foo>bar</foo>
      </extraProperties>
    </winget>
  </packagers>
</jreleaser>

jreleaser {
  packagers {
    winget {
      // Key will be capitalized and prefixed
      // with `winget`, i.e, `wingetFoo`.
      extraProperties.put('foo', 'bar')
    }
  }
}

announce:
  zulip:
    extraProperties:
      # Key will be capitalized and prefixed
      # with `zulip`, i.e, `zulipFoo`.
      foo: bar

[announce.zulip]
  # Key will be capitalized and prefixed
  # with `zulip`, i.e, `zulipFoo`.
  extraProperties.foo = "bar"

{
  "announce": {
    "zulip": {
      "extraProperties": {
        // Key will be capitalized and prefixed
        // with `zulip`, i.e, `zulipFoo`.
        "foo": "bar"
      }
    }
  }
}

<jreleaser>
  <announce>
    <zulip>
      <extraProperties>
        <!--
          Key will be capitalized and prefixed
          with `zulip`, i.e, `zulipFoo`.
        -->
        <foo>bar</foo>
      </extraProperties>
    </zulip>
  </announce>
</jreleaser>

jreleaser {
  announce {
    zulip {
      // Key will be capitalized and prefixed
      // with `zulip`, i.e, `zulipFoo`.
      extraProperties.put('foo', 'bar')
    }
  }
}