<?xml version='1.0'?>
<!--
  Licensed to the Apache Software Foundation (ASF) under one or more
  contributor license agreements.  See the NOTICE file distributed with
  this work for additional information regarding copyright ownership.
  The ASF licenses this file to You 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

      http://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.
-->

<!--
This file is also used by the maven-changes-plugin to generate the release notes.
Useful ways of finding items to add to this file are:

1.  Add items when you fix a bug or add a feature (this makes the
release process easy :-).

2.  Do a JIRA search for tickets closed since the previous release.

3.  Use the report generated by the maven-changelog-plugin to see all
SVN commits. TBA how to use this with SVN.

To generate the release notes from this file:

mvn changes:announcement-generate -Prelease-notes [-Dchanges.version=nn]
then tweak the formatting if necessary
and commit.
Run with changes.version-parameter in order to not generate a SNAPSHOT changelog

The <action> type attribute can be add,update,fix,remove.

    Please list action attributes in the following order:
    issue - required
    type - required
    the rest are optional; order not important

    having the issue number first makes it easier to read the XML outline
-->
<document xmlns="http://maven.apache.org/changes/1.0.0"
          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xsi:schemaLocation="http://maven.apache.org/changes/1.0.0 http://maven.apache.org/xsd/changes-1.0.0.xsd">
  <properties>
    <title>Changes in Apache Creadur Tentacles</title>
    <author email="dev@creadur.apache.org">Apache Creadur Tentacles developers</author>
  </properties>

  <body>
    <!--release version="0.2-SNAPSHOT" date="xxxx-yy-zz" description="Current SNAPSHOT - release to be done">
      <action issue="TENTACLES-xxx" type="update" dev="pottlinger" due-to="dependabot">
        TODO: collect all dependabot updates for release 0.17.
      </action>
    </release>
    -->
    <release version="0.1" date="2022-10-??" description="Initial release of Tentacles.">
      <action issue="TENTACLES-16" type="add" dev="pottlinger">
        Initial infrastructure for changelogs added.
      </action>
      <action issue="TENTACLES-12" type="update" dev="pottlinger">
        Updated log4j and build pipeline and dependencies.
      </action>
      <action issue="TENTACLES-11" type="update" dev="khmarbaise">
        Update RAT plugin to 0.12.
      </action>
    </release>
  </body>
</document>
