<?xml version="1.0" encoding="UTF-8"?>
<!--
 ~ Hibernate Search, full-text search for your domain model
 ~
 ~ License: GNU Lesser General Public License (LGPL), version 2.1 or later
 ~ See the lgpl.txt file in the root directory or <http://www.gnu.org/licenses/lgpl-2.1.html>.
  -->
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>org.hibernate.search</groupId>
    <artifactId>hibernate-search-parent</artifactId>
    <version>6.1.5.Final</version>
    <packaging>pom</packaging>

    <name>Hibernate Search Root POM</name>
    <description>Hibernate Search Root POM</description>

    <url>http://hibernate.org/search/</url>

    <inceptionYear>2006</inceptionYear>

    <issueManagement>
        <system>JIRA</system>
        <url>https://hibernate.atlassian.net/browse/HSEARCH</url>
    </issueManagement>

    <scm>
        <connection>scm:git:git://github.com/hibernate/hibernate-search.git</connection>
        <developerConnection>scm:git:git@github.com:hibernate/hibernate-search.git</developerConnection>
        <url>http://github.com/hibernate/hibernate-search</url>
        <tag>HEAD</tag>
    </scm>

    <organization>
        <name>Hibernate</name>
        <url>http://www.hibernate.org</url>
    </organization>

    <licenses>
        <license>
            <name>GNU Lesser General Public License v2.1 or later</name>
            <url>http://www.opensource.org/licenses/LGPL-2.1</url>
            <comments>See also: http://hibernate.org/license</comments>
        </license>
    </licenses>

    <ciManagement>
        <system>Jenkins</system>
        <url>https://ci.hibernate.org/job/hibernate-search/</url>
    </ciManagement>

    <developers>
        <developer>
            <id>epbernard</id>
            <name>Emmanuel Bernard</name>
            <email>emmanuel@hibernate.org</email>
            <organization>Red Hat, Inc.</organization>
            <url>http://in.relation.to/emmanuel-bernard/</url>
        </developer>
        <developer>
            <id>hardy.ferentschik</id>
            <name>Hardy Ferentschik</name>
            <email>hferents@redhat.com</email>
            <organization>Red Hat, Inc.</organization>
            <url>http://in.relation.to/hardy-ferentschik/</url>
        </developer>
        <developer>
            <id>sannegrinovero</id>
            <name>Sanne Grinovero</name>
            <email>sanne@hibernate.org</email>
            <organization>Red Hat, Inc.</organization>
            <url>http://in.relation.to/sanne-grinovero/</url>
        </developer>
        <developer>
            <id>gunnar.morling</id>
            <name>Gunnar Morling</name>
            <email>gunnar@hibernate.org</email>
            <organization>Red Hat, Inc.</organization>
            <url>http://in.relation.to/gunnar-morling/</url>
        </developer>
        <developer>
            <id>davide.dalto</id>
            <name>Davide D'Alto</name>
            <email>davide@hibernate.org</email>
            <organization>Red Hat, Inc.</organization>
            <url>http://in.relation.to/davide-dalto/</url>
        </developer>
        <developer>
            <id>guillaume.smet</id>
            <name>Guillaume Smet</name>
            <email>guillaume@hibernate.org</email>
            <organization>Red Hat, Inc.</organization>
            <url>http://in.relation.to/guillaume-smet/</url>
        </developer>
        <developer>
            <id>yoann.rodiere</id>
            <name>Yoann Rodière</name>
            <email>yoann@hibernate.org</email>
            <organization>Red Hat, Inc.</organization>
            <url>http://in.relation.to/yoann-rodiere/</url>
        </developer>
        <developer>
            <id>fabio.ercoli</id>
            <name>Fabio Massimo Ercoli</name>
            <email>fabio@hibernate.org</email>
            <organization>Red Hat, Inc.</organization>
            <url>http://in.relation.to/fabio-massimo-ercoli/</url>
        </developer>
        <developer>
            <id>mincong-h</id>
            <name>Mincong Huang</name>
            <email>mincong.h@gmail.com</email>
            <url>http://mincong-h.github.io</url>
        </developer>
    </developers>

    <mailingLists>
        <mailingList>
            <name>Hibernate Announcements</name>
            <post>hibernate-announce@lists.jboss.org</post>
            <subscribe>https://lists.jboss.org/mailman/listinfo/hibernate-announce</subscribe>
            <unsubscribe>https://lists.jboss.org/mailman/listinfo/hibernate-announce</unsubscribe>
            <archive>http://lists.jboss.org/pipermail/hibernate-dev/</archive>
        </mailingList>
        <mailingList>
            <name>Hibernate Commit Notifications</name>
            <post>hibernate-commits@lists.jboss.org</post>
            <subscribe>https://lists.jboss.org/mailman/listinfo/hibernate-commits</subscribe>
            <unsubscribe>https://lists.jboss.org/mailman/listinfo/hibernate-commits</unsubscribe>
            <archive>http://lists.jboss.org/pipermail/hibernate-commits/</archive>
        </mailingList>
        <mailingList>
            <name>Hibernate Developers</name>
            <post>hibernate-dev@lists.jboss.org</post>
            <subscribe>https://lists.jboss.org/mailman/listinfo/hibernate-dev</subscribe>
            <unsubscribe>https://lists.jboss.org/mailman/listinfo/hibernate-dev</unsubscribe>
            <archive>http://lists.jboss.org/pipermail/hibernate-dev/</archive>
            <otherArchives>
                <otherArchive>http://www.mail-archive.com/hibernate-dev%40lists.jboss.org/index.html</otherArchive>
            </otherArchives>
        </mailingList>
        <mailingList>
            <name>Hibernate Issue Notifications</name>
            <post>hibernate-issues@lists.jboss.org</post>
            <subscribe>https://lists.jboss.org/mailman/listinfo/hibernate-issues</subscribe>
            <unsubscribe>https://lists.jboss.org/mailman/listinfo/hibernate-issues</unsubscribe>
            <archive>http://lists.jboss.org/pipermail/hibernate-issues/</archive>
        </mailingList>
    </mailingLists>

    <modules>
        <module>build/config</module>
        <module>build/surefire-extension</module>
        <module>parents/internal</module>
        <module>util/internal/test/common</module>
        <module>util/internal/test/orm</module>
        <module>parents/public</module>
        <module>util/common</module>
        <module>engine</module>
        <module>backend/lucene</module>
        <module>backend/elasticsearch</module>
        <module>backend/elasticsearch-aws</module>
        <module>mapper/pojo-base</module>
        <module>mapper/javabean</module>
        <module>mapper/orm</module>
        <module>mapper/orm-coordination-outbox-polling</module>
        <module>mapper/orm-batch-jsr352/core</module>
        <module>mapper/orm-batch-jsr352/jberet</module>
        <module>v5migrationhelper/engine</module>
        <module>v5migrationhelper/orm</module>
        <module>util/internal/integrationtest</module>
        <module>parents/integrationtest</module>
        <module>integrationtest</module>
        <module>documentation</module>
    </modules>

    <properties>
        <!--
             Version to be used as baseline for API/SPI change reports,
             and for the migration guide
          -->
        <version.org.hibernate.search.previous-stable>6.0.4.Final</version.org.hibernate.search.previous-stable>

        <!-- Main dependencies -->

        <!-- >>> Common -->
        <version.org.jboss.logging.jboss-logging>3.4.3.Final</version.org.jboss.logging.jboss-logging>
        <version.org.jboss.logging.jboss-logging-tools>2.2.1.Final</version.org.jboss.logging.jboss-logging-tools>
        <javadoc.org.hibernate.search.url>https://docs.jboss.org/hibernate/search/${parsed-version.org.hibernate.search.majorVersion}.${parsed-version.org.hibernate.search.minorVersion}/api/</javadoc.org.hibernate.search.url>

        <!-- >>> Engine -->
        <!-- Nothing beyond common dependencies -->

        <!-- >>> Lucene -->
        <version.org.apache.lucene>8.11.1</version.org.apache.lucene>
        <javadoc.org.apache.lucene.tag>${parsed-version.org.apache.lucene.majorVersion}_${parsed-version.org.apache.lucene.minorVersion}_${parsed-version.org.apache.lucene.incrementalVersion}</javadoc.org.apache.lucene.tag>
        <javadoc.org.apache.lucene.core.url>https://lucene.apache.org/core/${javadoc.org.apache.lucene.tag}/core/</javadoc.org.apache.lucene.core.url>
        <javadoc.org.apache.lucene.analyzers-common.url>https://lucene.apache.org/core/${javadoc.org.apache.lucene.tag}/analyzers-common/</javadoc.org.apache.lucene.analyzers-common.url>
        <javadoc.org.apache.lucene.queryparser.url>https://lucene.apache.org/core/${javadoc.org.apache.lucene.tag}/queryparser/</javadoc.org.apache.lucene.queryparser.url>

        <!-- >>> Elasticsearch -->
        <!-- The version of the Elasticsearch client used by Hibernate Search, independently from the version of the remote cluster -->
        <!-- Use the latest open-source version here. Currently, low-level clients are open-source even in 7.16+ -->
        <version.org.elasticsearch.client>7.16.3</version.org.elasticsearch.client>
        <!-- The main compatible version of Elasticsearch, advertised by default. Used in documentation links. -->
        <!-- When updating the following version you will likely need to update the test profiles as well,
             to make sure the corresponding profile (e.g. elasticsearch-7.12) becomes the default. -->
        <version.org.elasticsearch.compatible.main>${version.org.elasticsearch.latest-7.16}</version.org.elasticsearch.compatible.main>
        <documentation.org.elasticsearch.url>https://www.elastic.co/guide/en/elasticsearch/reference/${parsed-version.org.elasticsearch.compatible.main.majorVersion}.${parsed-version.org.elasticsearch.compatible.main.minorVersion}</documentation.org.elasticsearch.url>
        <!-- The versions of Elasticsearch/OpenSearch advertised as compatible with Hibernate Search -->
        <!-- Make sure that 7.10 stays explicitly mentioned here, because that's the last open-source version -->
        <version.org.elasticsearch.compatible.regularly-tested.text>5.6, 6.8, 7.10 or 7.16</version.org.elasticsearch.compatible.regularly-tested.text>
        <version.org.opensearch.compatible.regularly-tested.text>1.0 or 1.2</version.org.opensearch.compatible.regularly-tested.text>
        <!-- The versions of Elasticsearch that may work, but are not given priority for bugfixes and new features -->
        <version.org.elasticsearch.compatible.not-regularly-tested.text>6.0 or 7.0</version.org.elasticsearch.compatible.not-regularly-tested.text>
        <!-- The latest micro of each Elasticsearch branch -->
        <version.org.elasticsearch.latest-7.16>7.16.3</version.org.elasticsearch.latest-7.16>
        <!-- 7.14 and 7.15 have annoying bugs that make almost all of our test suite fail, so we don't test them
             See https://hibernate.atlassian.net/browse/HSEARCH-4340 -->
        <version.org.elasticsearch.latest-7.13>7.13.2</version.org.elasticsearch.latest-7.13>
        <version.org.elasticsearch.latest-7.12>7.12.1</version.org.elasticsearch.latest-7.12>
        <version.org.elasticsearch.latest-7.11>7.11.2</version.org.elasticsearch.latest-7.11>
        <version.org.elasticsearch.latest-7.10>7.10.1</version.org.elasticsearch.latest-7.10>
        <version.org.elasticsearch.latest-7.9>7.9.3</version.org.elasticsearch.latest-7.9>
        <version.org.elasticsearch.latest-7.7>7.7.1</version.org.elasticsearch.latest-7.7>
        <version.org.elasticsearch.latest-7.6>7.6.2</version.org.elasticsearch.latest-7.6>
        <version.org.elasticsearch.latest-7.2>7.2.1</version.org.elasticsearch.latest-7.2>
        <version.org.elasticsearch.latest-6.8>6.8.22</version.org.elasticsearch.latest-6.8>
        <version.org.elasticsearch.latest-6.7>6.7.2</version.org.elasticsearch.latest-6.7>
        <version.org.elasticsearch.latest-6.6>6.6.2</version.org.elasticsearch.latest-6.6>
        <version.org.elasticsearch.latest-6.3>6.3.2</version.org.elasticsearch.latest-6.3>
        <version.org.elasticsearch.latest-6.2>6.2.4</version.org.elasticsearch.latest-6.2>
        <version.org.elasticsearch.latest-5.6>5.6.16</version.org.elasticsearch.latest-5.6>
        <!-- The latest micro of other Elasticsearch distributions -->
        <version.org.opensearch.latest-1.2>1.2.1</version.org.opensearch.latest-1.2>
        <version.org.opensearch.latest-1.0>1.0.0</version.org.opensearch.latest-1.0>
        <version.com.google.code.gson>2.8.9</version.com.google.code.gson>
        <version.software.amazon.awssdk>2.17.94</version.software.amazon.awssdk>
        <!-- Jackson: used by the Elasticsearch REST client, the AWS SDK and in tests (wiremock, ...) -->
        <version.com.fasterxml.jackson>2.13.1</version.com.fasterxml.jackson>
        <!--
             In the past, there has been jackson-databind bugfix releases without any jackson-core release,
             so we had to use different versions, e.g. jackson-core 2.9.9 and jackson-databind 2.9.9.3.
             That's why we have two separate properties for jackson versions,
             even though they may have the same value from time to time.
         -->
        <version.com.fasterxml.jackson.databind>2.13.1</version.com.fasterxml.jackson.databind>
        <!-- Reactive-streams: used by the AWS SDK -->
        <version.org.reactivestreams.reactive-streams>1.0.3</version.org.reactivestreams.reactive-streams>
        <!-- slf4j: used by the AWS SDK -->
        <version.org.slf4j>1.7.35</version.org.slf4j>

        <!-- >>> ORM -->
        <version.org.hibernate>5.6.8.Final</version.org.hibernate>
        <javadoc.org.hibernate.url>https://docs.jboss.org/hibernate/orm/${parsed-version.org.hibernate.majorVersion}.${parsed-version.org.hibernate.minorVersion}/javadocs/</javadoc.org.hibernate.url>
        <documentation.org.hibernate.url>https://docs.jboss.org/hibernate/orm/${parsed-version.org.hibernate.majorVersion}.${parsed-version.org.hibernate.minorVersion}/userguide/html_single/Hibernate_User_Guide.html</documentation.org.hibernate.url>
        <version.org.hibernate.commons.annotations>5.1.2.Final</version.org.hibernate.commons.annotations>
        <!-- This version must be kept in sync with the version of the dependency in Hibernate ORM.
             DO NOT USE DEPENDENCY MANAGEMENT FOR THIS DEPENDENCY!
             If we do not use dependency management for this dependency, we get a build failure
             when the versions start diverging, thanks to the maven-enforcer-plugin
             and to an artificial dependency in the mapper-orm artifact
             (which is only necessary for the maven-enforcer-plugin checks to work).
          -->
        <version.org.jboss.jandex>2.4.2.Final</version.org.jboss.jandex>
        <version.javax.persistence>2.2</version.javax.persistence>

        <!-- >>> ORM 6 / Jakarta Persistence -->
        <version.org.hibernate.orm>6.0.1.Final</version.org.hibernate.orm>
        <javadoc.org.hibernate.orm.url>https://docs.jboss.org/hibernate/orm/${parsed-version.org.hibernate.orm.majorVersion}.${parsed-version.org.hibernate.orm.minorVersion}/javadocs/</javadoc.org.hibernate.orm.url>
        <documentation.org.hibernate.orm.url>https://docs.jboss.org/hibernate/orm/${parsed-version.org.hibernate.orm.majorVersion}.${parsed-version.org.hibernate.orm.minorVersion}/userguide/html_single/Hibernate_User_Guide.html</documentation.org.hibernate.orm.url>
        <version.org.hibernate.commons.annotations.orm6>6.0.1.Final</version.org.hibernate.commons.annotations.orm6>
        <version.jakarta.persistence>3.1.0</version.jakarta.persistence>

        <!-- >>> JSR 352 -->
        <version.javax.batch>1.0.1</version.javax.batch>
        <version.jakarta.batch>2.1.0</version.jakarta.batch>
        <version.org.jberet>1.4.0.Final</version.org.jberet>
        <version.org.jberet.jakarta>2.0.4.Final</version.org.jberet.jakarta>

        <!-- >>> Java EE/Jakarta EE dependencies -->
        <!-- Used in the JSR352 integration in particular, but also in the ORM integration (?) and various tests -->
        <version.javax.inject>1</version.javax.inject>
        <version.jakarta.inject-api>2.0.1</version.jakarta.inject-api>
        <version.javax.enterprise>2.0</version.javax.enterprise>
        <version.jakarta.enterprise>3.0.1</version.jakarta.enterprise>
        <version.org.jboss.spec.javax.annotation.jboss-annotations-api_1.2_spec>1.0.2.Final</version.org.jboss.spec.javax.annotation.jboss-annotations-api_1.2_spec>
        <version.jakarta.annotation-api>2.1.0</version.jakarta.annotation-api>
        <version.org.jboss.spec.javax.transaction.jboss-transaction-api_1.2_spec>1.1.1.Final</version.org.jboss.spec.javax.transaction.jboss-transaction-api_1.2_spec>
        <version.jakarta.transaction-api>2.0.1</version.jakarta.transaction-api>
        <!-- We need dependency management on these ones to avoid dependency divergence created by our own dependencies
             (Hibernate ORM, JBatch, ...).
             Ideally, we should remove this dependency management when the dependencies fix their dependency divergence.
         -->
        <version.jakarta.xml.bind>4.0.0</version.jakarta.xml.bind>
        <version.jakarta.activation>2.1.0</version.jakarta.activation>
        <version.org.jboss.spec.javax.interceptor.jboss-interceptor-api_1.2_spec>1.0.1.Final</version.org.jboss.spec.javax.interceptor.jboss-interceptor-api_1.2_spec>
        <version.jakarta.interceptor-api>2.1.0</version.jakarta.interceptor-api>
        <!-- This is used to generate a link to the Java EE javadoc -->
        <javadoc.javaee.url>https://javaee.github.io/javaee-spec/javadocs/</javadoc.javaee.url>
        <javadoc.jakarta.batch.url>https://jakarta.ee/specifications/batch/2.0/apidocs/</javadoc.jakarta.batch.url>

        <!-- Test dependencies -->

        <!-- >>> Common -->
        <version.log4j>2.17.1</version.log4j>
        <version.junit>4.13.2</version.junit>
        <version.org.osgi.core>6.0.0</version.org.osgi.core>

        <version.org.hamcrest>2.2</version.org.hamcrest>
        <version.org.mockito>4.3.1</version.org.mockito>
        <version.org.assertj.assertj-core>3.22.0</version.org.assertj.assertj-core>
        <version.org.awaitily>4.1.1</version.org.awaitily>
        <version.org.skyscreamer.jsonassert>1.5.0</version.org.skyscreamer.jsonassert>
        <version.io.takari.junit>1.2.7</version.io.takari.junit>
        <version.com.h2database>2.1.210</version.com.h2database>
        <version.com.github.tomakehurst.wiremock>2.27.2</version.com.github.tomakehurst.wiremock>
        <version.org.apache.commons.lang3>3.12.0</version.org.apache.commons.lang3>
        <version.org.apache.commons.math3>3.6.1</version.org.apache.commons.math3>
        <version.org.apache.avro>1.11.0</version.org.apache.avro>
        <version.org.jboss.weld>3.1.5.SP1</version.org.jboss.weld>
        <version.org.jboss.weld.jakarta>4.0.3.Final</version.org.jboss.weld.jakarta>

        <!-- >>> Performance tests -->
        <version.org.openjdk.jmh>1.34</version.org.openjdk.jmh>

        <!-- >>> JSR 352: JBatch runtime -->
        <version.com.ibm.jbatch>1.0</version.com.ibm.jbatch>
        <version.com.ibm.jbatch.jakarta>2.1.0-M2</version.com.ibm.jbatch.jakarta>
        <version.org.apache.derby>10.13.1.1</version.org.apache.derby>

        <!-- >>> JSR 352: JBeret SE dependencies -->
        <version.org.jboss.marshalling>2.0.12.Final</version.org.jboss.marshalling>
        <version.org.wildfly.security.wildfly-security-manager>1.1.2.Final</version.org.wildfly.security.wildfly-security-manager>
        <version.org.google.guava>31.0.1-jre</version.org.google.guava>

        <!-- >>> Spring integration tests -->
        <version.org.springframework.boot>2.6.2</version.org.springframework.boot>

        <!-- Maven plugins versions -->

        <version.assembly.plugin>3.1.0</version.assembly.plugin>
        <version.buildhelper.plugin>3.3.0</version.buildhelper.plugin>
        <version.checkstyle.plugin>3.1.2</version.checkstyle.plugin>
        <version.bundle.plugin>5.1.4</version.bundle.plugin>
        <version.clean.plugin>3.1.0</version.clean.plugin>
        <!-- Needing 3.6.2 at least because of MCOMPILER-294 -->
        <version.compiler.plugin>3.9.0</version.compiler.plugin>
        <version.dependency.plugin>3.2.0</version.dependency.plugin>
        <!-- Check dependencies for security vulnerabilities -->
        <version.dependency-check.plugin>6.5.3</version.dependency-check.plugin>
        <version.deploy.plugin>2.8.2</version.deploy.plugin>
        <version.org.eclipse.m2e.lifecycle-mapping>1.0.0</version.org.eclipse.m2e.lifecycle-mapping>
        <version.enforcer.plugin>3.0.0</version.enforcer.plugin>
        <version.exec.plugin>3.0.0</version.exec.plugin>
        <version.forbiddenapis.plugin>3.2</version.forbiddenapis.plugin>
        <version.help.plugin>3.2.0</version.help.plugin>
        <version.install.plugin>2.5.2</version.install.plugin>
        <version.io.takari.maven>0.7.7</version.io.takari.maven>
        <version.japicmp.plugin>0.15.6</version.japicmp.plugin>
        <version.jar.plugin>3.2.2</version.jar.plugin>
        <version.javadoc.plugin>3.3.1</version.javadoc.plugin>
        <version.jdeps.plugin>0.5.1</version.jdeps.plugin>
        <version.nexus-staging.plugin>1.6.8</version.nexus-staging.plugin>
        <version.processor.plugin>4.5-jdk8</version.processor.plugin>
        <version.project-info.plugin>3.2.1</version.project-info.plugin>
        <version.release.plugin>2.5.3</version.release.plugin>
        <version.resources.plugin>3.2.0</version.resources.plugin>
        <version.shade.plugin>3.2.4</version.shade.plugin>
        <version.site.plugin>3.10.0</version.site.plugin>
        <version.source.plugin>3.2.1</version.source.plugin>
        <!-- Surefire versions are a minefield of bugs: be careful with upgrades -->
        <version.surefire.plugin>3.0.0-M5</version.surefire.plugin>
        <version.surefire.plugin.java-version.asm>9.2</version.surefire.plugin.java-version.asm>
        <version.failsafe.plugin>${version.surefire.plugin}</version.failsafe.plugin>
        <version.jacoco.plugin>0.8.7</version.jacoco.plugin>
        <version.coveralls.plugin>4.3.0</version.coveralls.plugin>
        <version.com.buschmais.jqassistant.plugin>1.11.1</version.com.buschmais.jqassistant.plugin>
        <version.docker.maven.plugin>0.39.0</version.docker.maven.plugin>
        <version.moditect.plugin>1.0.0.RC2</version.moditect.plugin>
        <version.sonar.plugin>3.9.1.2184</version.sonar.plugin>
        <version.scripting.plugin>3.0.0</version.scripting.plugin>
        <version.gpg.plugin>3.0.1</version.gpg.plugin>
        <version.org.codehaus.groovy-jsr223>3.0.9</version.org.codehaus.groovy-jsr223>
        <version.com.puppycrawl.tools.checkstyle>9.3</version.com.puppycrawl.tools.checkstyle>

        <!-- Asciidoctor -->

        <version.asciidoctor.plugin>2.2.2</version.asciidoctor.plugin>
        <version.org.hibernate.infra.hibernate-asciidoctor-theme>1.0.4.Final</version.org.hibernate.infra.hibernate-asciidoctor-theme>
        <version.org.jruby>9.3.2.0</version.org.jruby>
        <version.org.asciidoctor.asciidoctorj>2.5.3</version.org.asciidoctor.asciidoctorj>
        <version.org.asciidoctor.asciidoctorj-pdf>1.5.0-alpha.18</version.org.asciidoctor.asciidoctorj-pdf>

        <!-- Maven Central repository -->

        <mavencentral.repo.url>https://repo.maven.apache.org/maven2/</mavencentral.repo.url>

        <!-- Eclipse repository (for the ECJ compiler, disabled by default) -->

        <eclipse.repo.id>eclipse-staging</eclipse.repo.id>
        <eclipse.repo.url>https://repo.eclipse.org/content/repositories/eclipse-staging/</eclipse.repo.url>

        <!-- Repository Deployment URLs -->

        <ossrh.releases.repo.id>ossrh</ossrh.releases.repo.id>
        <ossrh.releases.repo.url>https://oss.sonatype.org/service/local/staging/deploy/maven2/</ossrh.releases.repo.url>
        <ossrh.releases.repo.baseUrl>https://oss.sonatype.org/</ossrh.releases.repo.baseUrl>
        <ossrh.snapshots.repo.id>ossrh</ossrh.snapshots.repo.id>
        <ossrh.snapshots.repo.url>https://oss.sonatype.org/content/repositories/snapshots</ossrh.snapshots.repo.url>

        <!-- Build settings -->

        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>

        <!-- JDK version required for the build; we target 8 but require at least 11 for the build -->
        <jdk.min.version>11</jdk.min.version>
        <!-- The lowest supported version of Java for applications using Hibernate Search -->
        <!-- Set statically, independently from the current JDK: we want our code to comply with this version -->
        <java-version.main.release>8</java-version.main.release>
        <java-version.main.compiler.java_home>${java.home}</java-version.main.compiler.java_home>
        <java-version.main.compiler>${java-version.main.compiler.java_home}/bin/javac</java-version.main.compiler>
        <!-- The version of test bytecode, useful for testing compatibility with newer JDKs -->
        <!-- Set to the version of the JDK running Maven by default, but overridden on CI -->
        <!-- 'java.specification.version' is only correct from Java 9 onwards, but we require Java 11 for the build anyway -->
        <java-version.test.release>${java.specification.version}</java-version.test.release>
        <java-version.test.compiler.java_home>${java.home}</java-version.test.compiler.java_home>
        <java-version.test.compiler>${java-version.test.compiler.java_home}/bin/javac</java-version.test.compiler>
        <!-- IMPORTANT: For Java 8, this must be the path to the JDK, not to the JRE -->
        <java-version.test.launcher.java_home>${java-version.test.compiler.java_home}</java-version.test.launcher.java_home>
        <java-version.test.launcher>${java-version.test.launcher.java_home}/bin/java</java-version.test.launcher>

        <!-- Set this through a property so that it can be overridden from the commandline -->
        <maven.compiler.failOnWarning>true</maven.compiler.failOnWarning>

        <maven.compiler.release>${java-version.main.release}</maven.compiler.release>
        <maven.compiler.testRelease>${java-version.test.release}</maven.compiler.testRelease>

        <!-- Also set source/target, because several other plugins rely on this and don't understand release -->
        <maven.compiler.source>${maven.compiler.release}</maven.compiler.source>
        <maven.compiler.target>${maven.compiler.release}</maven.compiler.target>
        <maven.compiler.testSource>${maven.compiler.testRelease}</maven.compiler.testSource>
        <maven.compiler.testTarget>${maven.compiler.testRelease}</maven.compiler.testTarget>

        <!--
                Options to compile with the Eclipse compiler when building with maven (not with the IDE).
                See profile "compiler-eclipse".
                Note the version of ECJ is overridden because the one bundled with the latest plexus-compiler version
                is outdated and leads to compilation errors.
         -->
        <version.org.codehaus.plexus.plexus-compiler.compiler-eclipse>2.9.0</version.org.codehaus.plexus.plexus-compiler.compiler-eclipse>
        <version.org.eclipse.jdt.ecj>3.28.0</version.org.eclipse.jdt.ecj>

        <!--
            The absolute path to the root project directory.
            This property is set by the build-helper plugin.
            We initialize it to some crude, potentially wrong value,
            because the Sonar Maven plugin uses this property indirectly,
            but ignores any change made by other plugins.
            This default value is the best we can do without the help of a Maven plugin.

            Useful resources:
             - https://www.mojohaus.org/build-helper-maven-plugin/rootlocation-mojo.html
         -->
        <rootProject.directory>${user.dir}</rootProject.directory>
        <!--
            The absolute path to an empty subdirectory of the root project.
            This is used in places where we need a path to an existing, empty directory,
            such as when fooling Sonar into thinking there is no "main" source in a project.
         -->
        <rootProject.emptySubdirectory>${rootProject.directory}/.empty</rootProject.emptySubdirectory>

        <!-- Maven version required for the build -->
        <!--
             We need at least 3.6.2, which includes Maven-resolver 1.4.0+,
             which fixes https://issues.apache.org/jira/browse/MRESOLVER-33
             WARNING: Do not forget to call 'mvn -N io.takari:maven:wrapper'
             when you update this property!
         -->
        <maven.min.version>3.8.1</maven.min.version>

        <!-- Whether javadoc problems (errors, warnings) should fail the build) -->
        <failOnJavadocError>true</failOnJavadocError>

        <!-- Can be overridden by subprojects if dependency convergence cannot be achieved -->
        <enforcer.dependencyconvergence.skip>false</enforcer.dependencyconvergence.skip>

        <!-- Test settings -->
        <!-- Set empty default values to avoid Maven leaving property references (${...}) when it doesn't find a value -->

        <surefire.jvm.args.memory>-Xmx512m -Xms128m</surefire.jvm.args.memory>
        <!-- JVM args to be customized depending on the Java version -->
        <surefire.jvm.args.java-version>
            -Djdk.attach.allowAttachSelf=true
            --illegal-access=deny
        </surefire.jvm.args.java-version>
        <!-- JVM args generated by JaCoCo -->
        <surefire.jvm.args.jacoco></surefire.jvm.args.jacoco>
        <failsafe.jvm.args.jacoco></failsafe.jvm.args.jacoco>
        <!-- JVM args to be customized by each Maven module -->
        <surefire.jvm.args.module></surefire.jvm.args.module>
        <!--
             Pass these properties as system properties to be able to switch to
             a different database without re-compiling the hibernate.properties file
             (which is located in a dependency of the integration tests modules)
         -->
        <failsafe.jvm.args.hibernate-orm></failsafe.jvm.args.hibernate-orm>
        <!-- Database profile jdbc java arguments -->
        <failsafe.jvm.args.jdbc></failsafe.jvm.args.jdbc>
        <surefire.jvm.args>${surefire.jvm.args.memory} ${surefire.jvm.args.java-version} ${surefire.jvm.args.module} ${surefire.jvm.args.jacoco}</surefire.jvm.args>
        <failsafe.jvm.args>${surefire.jvm.args.memory} ${surefire.jvm.args.java-version} ${surefire.jvm.args.module} ${failsafe.jvm.args.jacoco} ${failsafe.jvm.args.hibernate-orm} ${failsafe.jvm.args.jdbc}</failsafe.jvm.args>

        <!-- Disable integration tests selectively. To be set in specific profile, e.g. for a specific JDK version. -->
        <failsafe.spring.skip>${skipITs}</failsafe.spring.skip>

        <!-- This allows us to distinguish between multiple executions of the same test in test reports. -->
        <surefire.reportNameSuffix>${surefire.environment}-${project.artifactId}</surefire.reportNameSuffix>
        <!-- This should be set from the command line by CI jobs that execute the same tests in multiple environments -->
        <surefire.environment>default</surefire.environment>

        <!-- Containers executions tests properties -->
        <test.containers.run.skip>false</test.containers.run.skip>

        <!-- Elasticsearch tests properties -->

        <!-- Control how an Elasticsearch instance is run automatically during tests -->
        <!-- By default, the plugin is not skipped, but each container (elastic, opensearch, etc.) is skipped;
             Maven profiles will re-enable the right container depending on configuration.
          -->
        <test.elasticsearch.run.skip>true</test.elasticsearch.run.skip>

        <!-- If an external connection url is defined this property will be true -->
        <!-- See elasticsearch-run and elasticsearch-do-not-run profiles -->
        <test.elasticsearch.connection.uris.defined></test.elasticsearch.connection.uris.defined>

        <test.elasticsearch.run.elastic.skip>true</test.elasticsearch.run.elastic.skip>
        <test.elasticsearch.run.elastic.image.name>elastic/elasticsearch</test.elasticsearch.run.elastic.image.name>
        <test.elasticsearch.run.elastic.image.tag>${test.elasticsearch.connection.version}</test.elasticsearch.run.elastic.image.tag>
        <test.elasticsearch.run.opensearch.skip>true</test.elasticsearch.run.opensearch.skip>
        <test.elasticsearch.run.opensearch.image.name>opensearchproject/opensearch</test.elasticsearch.run.opensearch.image.name>
        <test.elasticsearch.run.opensearch.image.tag>${test.elasticsearch.connection.version}</test.elasticsearch.run.opensearch.image.tag>
        <!--
             These properties are transparently passed as system properties to integration tests,
             and retrieved by a test utility:
             org.hibernate.search.util.impl.integrationtest.backend.elasticsearch.ElasticsearchTestHostConnectionConfiguration
             This is better than configuration files filtered by Maven,
             because we will be able to change the configuration without re-compiling the configuration file
             (which is located in a dependency of the integration tests modules).
         -->
        <test.elasticsearch.connection.uris></test.elasticsearch.connection.uris>
        <test.elasticsearch.connection.distribution></test.elasticsearch.connection.distribution>
        <test.elasticsearch.connection.version></test.elasticsearch.connection.version>
        <test.elasticsearch.connection.username></test.elasticsearch.connection.username>
        <test.elasticsearch.connection.password></test.elasticsearch.connection.password>
        <test.elasticsearch.connection.aws.signing.enabled>false</test.elasticsearch.connection.aws.signing.enabled>
        <test.elasticsearch.connection.aws.region></test.elasticsearch.connection.aws.region>
        <test.elasticsearch.connection.aws.credentials.type></test.elasticsearch.connection.aws.credentials.type>
        <test.elasticsearch.connection.aws.credentials.access_key_id></test.elasticsearch.connection.aws.credentials.access_key_id>
        <test.elasticsearch.connection.aws.credentials.secret_access_key></test.elasticsearch.connection.aws.credentials.secret_access_key>
        <!-- Control how integration tests format the requests sent to Elasticsearch -->
        <test.elasticsearch.testdialect></test.elasticsearch.testdialect>

        <!-- Lucene tests properties -->

        <test.lucene.indexes.path>${project.build.directory}/test-indexes/</test.lucene.indexes.path>

        <!-- Mapper ORM tests properties -->

        <!-- Run containers for additional ORM databases -->
        <test.database.run.skip>true</test.database.run.skip>
        <!-- PostgreSQL -->
        <test.database.run.postgres.skip>true</test.database.run.postgres.skip>
        <test.database.run.postgres.image.name>postgres</test.database.run.postgres.image.name>
        <test.database.run.postgres.image.tag>13.1</test.database.run.postgres.image.tag>
        <!-- MariaDB -->
        <test.database.run.mariadb.skip>true</test.database.run.mariadb.skip>
        <test.database.run.mariadb.image.name>mariadb</test.database.run.mariadb.image.name>
        <test.database.run.mariadb.image.tag>10.5.8</test.database.run.mariadb.image.tag>
        <!-- MySQL -->
        <test.database.run.mysql.skip>true</test.database.run.mysql.skip>
        <test.database.run.mysql.image.name>mysql</test.database.run.mysql.image.name>
        <test.database.run.mysql.image.tag>8.0.22</test.database.run.mysql.image.tag>
        <!-- DB2 -->
        <test.database.run.db2.skip>true</test.database.run.db2.skip>
        <test.database.run.db2.image.name>ibmcom/db2</test.database.run.db2.image.name>
        <test.database.run.db2.image.tag>11.5.5.0</test.database.run.db2.image.tag>
        <!-- Oracle -->
        <test.database.run.oracle.skip>true</test.database.run.oracle.skip>
        <!-- See https://hub.docker.com/r/gvenzl/oracle-xe -->
        <test.database.run.oracle.image.name>gvenzl/oracle-xe</test.database.run.oracle.image.name>
        <test.database.run.oracle.image.tag>11-slim</test.database.run.oracle.image.tag>
        <!-- MS SQL Server -->
        <test.database.run.mssql.skip>true</test.database.run.mssql.skip>
        <test.database.run.mssql.image.name>mcr.microsoft.com/mssql/server</test.database.run.mssql.image.name>
        <test.database.run.mssql.image.tag>2019-CU8-ubuntu-16.04</test.database.run.mssql.image.tag>

        <!-- Eclipse plugin options -->

        <m2e.apt.activation>jdt_apt</m2e.apt.activation>

        <!-- Sonar options -->
        <!--
            We want to take into account coverage data from integration tests from other projects as well.
            This requires to use a single destination file for ITs, because:
             - Integration tests cover code from other modules.
             - The Sonar plugin computes coverage when inspecting each module,
               and by default only takes into account JaCoCo coverage reports from the inspected module.
               Thus it ignores some relevant ITs by default.
             - Even when configured, the Sonar plugin only accept an *explicit* list of JaCoCo coverage reports
               (no wildcards).
               Thus we cannot easily configure the Sonar plugin to inspect JaCoCo coverage reports from other modules,
               unless we somehow aggregate all of the coverage data into a single, shared JaCoCo coverage report.
            The chosen solution was to make the "reports" module invoke jacoco's "report-aggregate" goal
            to create a single aggregate report, and configure sonar to only inspect that file.

            Useful resources to understand what is going on (caution, not everything is up-to-date):
             - https://docs.sonarqube.org/display/SONAR/Analysis+Parameters
             - https://docs.sonarqube.org/display/PLUG/Usage+of+JaCoCo+with+Java+Plugin
             - https://www.devcon5.ch/en/blog/2015/05/29/multi-module-integration-test-coverage-sonar-jacoco/
             - http://javamemento.blogspot.fr/2016/02/sonar-jacoco-maven-multi-module.html
             - https://github.com/SonarSource/sonar-scanning-examples/blob/master/sonarqube-scanner-maven/pom.xml
             - https://stackoverflow.com/a/49528226/6692043
             - https://www.eclemma.org/jacoco/trunk/doc/report-aggregate-mojo.html
             - Not relevant anymore, but we used to merge *.exec files: https://www.eclemma.org/jacoco/trunk/doc/merge-mojo.html
         -->
        <sonar.coverage.jacoco.xmlReportPaths>${rootProject.directory}/reports/target/site/jacoco-aggregate/jacoco.xml</sonar.coverage.jacoco.xmlReportPaths>
        <!--
            Exclude build code and integration tests defined in the main source (utils, Showcases, Backend TCK)
            from coverage computation.
         -->
        <sonar.coverage.exclusions>
            **/org/hibernate/checkstyle/**,
            **/org/hibernate/search/util/impl/test/**,
            **/org/hibernate/search/util/impl/integrationtest/**,
            **/org/hibernate/search/integrationtest/**
        </sonar.coverage.exclusions>
        <!--
            Exclude build code, unit tests and integration tests from duplication analysis.
         -->
        <sonar.cpd.exclusions>
            **/org/hibernate/checkstyle/**,
            **/src/test/java/**,
            **/org/hibernate/search/integrationtest/**
        </sonar.cpd.exclusions>
    </properties>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.hibernate.search</groupId>
                <artifactId>hibernate-search-util-common</artifactId>
                <version>${project.version}</version>
            </dependency>
            <dependency>
                <groupId>org.hibernate.search</groupId>
                <artifactId>hibernate-search-util-internal-test-common</artifactId>
                <version>${project.version}</version>
            </dependency>
            <dependency>
                <groupId>org.hibernate.search</groupId>
                <artifactId>hibernate-search-util-internal-test-orm</artifactId>
                <version>${project.version}</version>
            </dependency>
            <dependency>
                <groupId>org.hibernate.search</groupId>
                <artifactId>hibernate-search-util-internal-test-orm-jakarta</artifactId>
                <version>${project.version}</version>
            </dependency>
            <dependency>
                <groupId>org.hibernate.search</groupId>
                <artifactId>hibernate-search-util-internal-test-orm-orm6</artifactId>
                <version>${project.version}</version>
            </dependency>
            <dependency>
                <groupId>org.hibernate.search</groupId>
                <artifactId>hibernate-search-engine</artifactId>
                <version>${project.version}</version>
            </dependency>
            <dependency>
                <groupId>org.hibernate.search</groupId>
                <artifactId>hibernate-search-backend-elasticsearch</artifactId>
                <version>${project.version}</version>
            </dependency>
            <dependency>
                <groupId>org.hibernate.search</groupId>
                <artifactId>hibernate-search-backend-elasticsearch-aws</artifactId>
                <version>${project.version}</version>
            </dependency>
            <dependency>
                <groupId>org.hibernate.search</groupId>
                <artifactId>hibernate-search-backend-lucene</artifactId>
                <version>${project.version}</version>
            </dependency>
            <dependency>
                <groupId>org.hibernate.search</groupId>
                <artifactId>hibernate-search-mapper-pojo-base</artifactId>
                <version>${project.version}</version>
            </dependency>
            <dependency>
                <groupId>org.hibernate.search</groupId>
                <artifactId>hibernate-search-mapper-javabean</artifactId>
                <version>${project.version}</version>
            </dependency>
            <dependency>
                <groupId>org.hibernate.search</groupId>
                <artifactId>hibernate-search-mapper-orm</artifactId>
                <version>${project.version}</version>
            </dependency>
            <dependency>
                <groupId>org.hibernate.search</groupId>
                <artifactId>hibernate-search-mapper-orm-jakarta</artifactId>
                <version>${project.version}</version>
            </dependency>
            <dependency>
                <groupId>org.hibernate.search</groupId>
                <artifactId>hibernate-search-mapper-orm-orm6</artifactId>
                <version>${project.version}</version>
            </dependency>
            <dependency>
                <groupId>org.hibernate.search</groupId>
                <artifactId>hibernate-search-v5migrationhelper-engine</artifactId>
                <version>${project.version}</version>
            </dependency>
            <dependency>
                <groupId>org.hibernate.search</groupId>
                <artifactId>hibernate-search-v5migrationhelper-orm</artifactId>
                <version>${project.version}</version>
            </dependency>
            <dependency>
                <groupId>org.hibernate.search</groupId>
                <artifactId>hibernate-search-v5migrationhelper-orm-jakarta</artifactId>
                <version>${project.version}</version>
            </dependency>
            <dependency>
                <groupId>org.hibernate.search</groupId>
                <artifactId>hibernate-search-v5migrationhelper-orm-orm6</artifactId>
                <version>${project.version}</version>
            </dependency>
            <dependency>
                <groupId>org.hibernate.search</groupId>
                <artifactId>hibernate-search-mapper-orm-batch-jsr352-core</artifactId>
                <version>${project.version}</version>
            </dependency>
            <dependency>
                <groupId>org.hibernate.search</groupId>
                <artifactId>hibernate-search-mapper-orm-batch-jsr352-core-jakarta</artifactId>
                <version>${project.version}</version>
            </dependency>
            <dependency>
                <groupId>org.hibernate.search</groupId>
                <artifactId>hibernate-search-mapper-orm-batch-jsr352-core-orm6</artifactId>
                <version>${project.version}</version>
            </dependency>
            <dependency>
                <groupId>org.hibernate.search</groupId>
                <artifactId>hibernate-search-mapper-orm-batch-jsr352-jberet</artifactId>
                <version>${project.version}</version>
            </dependency>
            <dependency>
                <groupId>org.hibernate.search</groupId>
                <artifactId>hibernate-search-mapper-orm-batch-jsr352-jberet-jakarta</artifactId>
                <version>${project.version}</version>
            </dependency>
            <dependency>
                <groupId>org.hibernate.search</groupId>
                <artifactId>hibernate-search-mapper-orm-batch-jsr352-jberet-orm6</artifactId>
                <version>${project.version}</version>
            </dependency>
            <dependency>
                <groupId>org.hibernate.search</groupId>
                <artifactId>hibernate-search-mapper-orm-coordination-outbox-polling</artifactId>
                <version>${project.version}</version>
            </dependency>
            <dependency>
                <groupId>org.hibernate.search</groupId>
                <artifactId>hibernate-search-mapper-orm-coordination-outbox-polling-jakarta</artifactId>
                <version>${project.version}</version>
            </dependency>
            <dependency>
                <groupId>org.hibernate.search</groupId>
                <artifactId>hibernate-search-mapper-orm-coordination-outbox-polling-orm6</artifactId>
                <version>${project.version}</version>
            </dependency>
            <dependency>
                <groupId>org.hibernate.search</groupId>
                <artifactId>hibernate-search-documentation</artifactId>
                <version>${project.version}</version>
                <type>pom</type>
            </dependency>
            <dependency>
                <groupId>org.hibernate.search</groupId>
                <artifactId>hibernate-search-integrationtest-backend-elasticsearch</artifactId>
                <version>${project.version}</version>
            </dependency>
            <dependency>
                <groupId>org.hibernate.search</groupId>
                <artifactId>hibernate-search-integrationtest-backend-lucene</artifactId>
                <version>${project.version}</version>
            </dependency>
            <dependency>
                <groupId>org.hibernate.search</groupId>
                <artifactId>hibernate-search-integrationtest-mapper-pojo-base</artifactId>
                <version>${project.version}</version>
            </dependency>
            <dependency>
                <groupId>org.hibernate.search</groupId>
                <artifactId>hibernate-search-integrationtest-mapper-orm</artifactId>
                <version>${project.version}</version>
            </dependency>
            <dependency>
                <groupId>org.hibernate.search</groupId>
                <artifactId>hibernate-search-integrationtest-mapper-orm-cdi</artifactId>
                <version>${project.version}</version>
            </dependency>
            <dependency>
                <groupId>org.hibernate.search</groupId>
                <artifactId>hibernate-search-integrationtest-mapper-orm-spring</artifactId>
                <version>${project.version}</version>
            </dependency>
            <dependency>
                <groupId>org.hibernate.search</groupId>
                <artifactId>hibernate-search-integrationtest-mapper-orm-envers</artifactId>
                <version>${project.version}</version>
            </dependency>
            <dependency>
                <groupId>org.hibernate.search</groupId>
                <artifactId>hibernate-search-integrationtest-mapper-orm-realbackend</artifactId>
                <version>${project.version}</version>
            </dependency>
            <dependency>
                <groupId>org.hibernate.search</groupId>
                <artifactId>hibernate-search-integrationtest-showcase-library</artifactId>
                <version>${project.version}</version>
            </dependency>
            <dependency>
                <groupId>org.hibernate.search</groupId>
                <artifactId>hibernate-search-integrationtest-v5migrationhelper-engine</artifactId>
                <version>${project.version}</version>
            </dependency>
            <dependency>
                <groupId>org.hibernate.search</groupId>
                <artifactId>hibernate-search-integrationtest-v5migrationhelper-orm</artifactId>
                <version>${project.version}</version>
            </dependency>
            <dependency>
                <groupId>org.hibernate.search</groupId>
                <artifactId>hibernate-search-integrationtest-mapper-orm-coordination-outbox-polling</artifactId>
                <version>${project.version}</version>
            </dependency>
            <dependency>
                <groupId>org.hibernate.search</groupId>
                <artifactId>hibernate-search-integrationtest-mapper-orm-batch-jsr352</artifactId>
                <version>${project.version}</version>
            </dependency>
            <dependency>
                <groupId>org.hibernate.search</groupId>
                <artifactId>hibernate-search-documentation</artifactId>
                <version>${project.version}</version>
            </dependency>

            <dependency>
                <groupId>org.hibernate</groupId>
                <artifactId>hibernate-core</artifactId>
                <version>${version.org.hibernate}</version>
            </dependency>
            <dependency>
                <groupId>org.hibernate</groupId>
                <artifactId>hibernate-core-jakarta</artifactId>
                <version>${version.org.hibernate}</version>
            </dependency>
            <dependency>
                <groupId>org.hibernate.orm</groupId>
                <artifactId>hibernate-core</artifactId>
                <version>${version.org.hibernate.orm}</version>
            </dependency>
            <dependency>
                <groupId>org.hibernate</groupId>
                <artifactId>hibernate-envers</artifactId>
                <version>${version.org.hibernate}</version>
            </dependency>
            <dependency>
                <groupId>org.hibernate</groupId>
                <artifactId>hibernate-envers-jakarta</artifactId>
                <version>${version.org.hibernate}</version>
            </dependency>
            <dependency>
                <groupId>org.hibernate.orm</groupId>
                <artifactId>hibernate-envers</artifactId>
                <version>${version.org.hibernate.orm}</version>
            </dependency>
            <dependency>
                <groupId>org.hibernate.common</groupId>
                <artifactId>hibernate-commons-annotations</artifactId>
                <version>${version.org.hibernate.commons.annotations}</version>
            </dependency>
            <dependency>
                <groupId>org.elasticsearch.client</groupId>
                <artifactId>elasticsearch-rest-client</artifactId>
                <version>${version.org.elasticsearch.client}</version>
            </dependency>
            <dependency>
                <groupId>org.elasticsearch.client</groupId>
                <artifactId>elasticsearch-rest-client-sniffer</artifactId>
                <version>${version.org.elasticsearch.client}</version>
            </dependency>
            <dependency>
                <groupId>com.google.code.gson</groupId>
                <artifactId>gson</artifactId>
                <version>${version.com.google.code.gson}</version>
            </dependency>
            <dependency>
                <groupId>software.amazon.awssdk</groupId>
                <artifactId>auth</artifactId>
                <version>${version.software.amazon.awssdk}</version>
            </dependency>
            <dependency>
                <groupId>org.jboss.logging</groupId>
                <artifactId>jboss-logging</artifactId>
                <version>${version.org.jboss.logging.jboss-logging}</version>
            </dependency>
            <dependency>
                <groupId>org.jboss.logging</groupId>
                <artifactId>jboss-logging-annotations</artifactId>
                <version>${version.org.jboss.logging.jboss-logging-tools}</version>
                <scope>provided</scope>
                <optional>true</optional>
            </dependency>

            <!-- Lucene backend -->
            <dependency>
                <groupId>org.apache.lucene</groupId>
                <artifactId>lucene-core</artifactId>
                <version>${version.org.apache.lucene}</version>
            </dependency>
            <dependency>
                <groupId>org.apache.lucene</groupId>
                <artifactId>lucene-analyzers-common</artifactId>
                <version>${version.org.apache.lucene}</version>
            </dependency>
            <dependency>
                <groupId>org.apache.lucene</groupId>
                <artifactId>lucene-queryparser</artifactId>
                <version>${version.org.apache.lucene}</version>
                <exclusions>
                    <!-- This artifact contains unstable, experimental code that we cannot reasonably rely on. -->
                    <exclusion>
                        <groupId>org.apache.lucene</groupId>
                        <artifactId>lucene-sandbox</artifactId>
                    </exclusion>
                </exclusions>
            </dependency>
            <dependency>
                <groupId>org.apache.lucene</groupId>
                <artifactId>lucene-join</artifactId>
                <version>${version.org.apache.lucene}</version>
            </dependency>
            <dependency>
                <groupId>org.apache.lucene</groupId>
                <artifactId>lucene-facet</artifactId>
                <version>${version.org.apache.lucene}</version>
            </dependency>

            <!-- JavaEE/JakartaEE dependencies -->
            <dependency>
                <groupId>javax.persistence</groupId>
                <artifactId>javax.persistence-api</artifactId>
                <version>${version.javax.persistence}</version>
            </dependency>
            <dependency>
                <groupId>jakarta.persistence</groupId>
                <artifactId>jakarta.persistence-api</artifactId>
                <version>${version.jakarta.persistence}</version>
            </dependency>
            <dependency>
                <groupId>javax.enterprise</groupId>
                <artifactId>cdi-api</artifactId>
                <version>${version.javax.enterprise}</version>
                <scope>provided</scope>
            </dependency>
            <dependency>
                <groupId>jakarta.enterprise</groupId>
                <artifactId>jakarta.enterprise.cdi-api</artifactId>
                <version>${version.jakarta.enterprise}</version>
            </dependency>
            <dependency>
                <groupId>javax.inject</groupId>
                <artifactId>javax.inject</artifactId>
                <version>${version.javax.inject}</version>
            </dependency>
            <dependency>
                <groupId>jakarta.inject</groupId>
                <artifactId>jakarta.inject-api</artifactId>
                <version>${version.jakarta.inject-api}</version>
            </dependency>
            <dependency>
                <groupId>org.jboss.spec.javax.annotation</groupId>
                <artifactId>jboss-annotations-api_1.2_spec</artifactId>
                <version>${version.org.jboss.spec.javax.annotation.jboss-annotations-api_1.2_spec}</version>
                <scope>provided</scope>
            </dependency>
            <dependency>
                <groupId>jakarta.annotation</groupId>
                <artifactId>jakarta.annotation-api</artifactId>
                <version>${version.jakarta.annotation-api}</version>
            </dependency>
            <dependency>
                <groupId>org.jboss.spec.javax.transaction</groupId>
                <artifactId>jboss-transaction-api_1.2_spec</artifactId>
                <version>${version.org.jboss.spec.javax.transaction.jboss-transaction-api_1.2_spec}</version>
                <scope>provided</scope>
            </dependency>
            <dependency>
                <groupId>jakarta.transaction</groupId>
                <artifactId>jakarta.transaction-api</artifactId>
                <version>${version.jakarta.transaction-api}</version>
            </dependency>
            <dependency>
                <groupId>org.jboss.spec.javax.interceptor</groupId>
                <artifactId>jboss-interceptor-api_1.2_spec</artifactId>
                <version>${version.org.jboss.spec.javax.interceptor.jboss-interceptor-api_1.2_spec}</version>
            </dependency>
            <dependency>
                <groupId>jakarta.interceptor</groupId>
                <artifactId>jakarta.interceptor-api</artifactId>
                <version>${version.jakarta.interceptor-api}</version>
            </dependency>
            <dependency>
                <groupId>javax.batch</groupId>
                <artifactId>javax.batch-api</artifactId>
                <version>${version.javax.batch}</version>
                <scope>provided</scope>
            </dependency>
            <dependency>
                <groupId>jakarta.batch</groupId>
                <artifactId>jakarta.batch-api</artifactId>
                <version>${version.jakarta.batch}</version>
                <scope>provided</scope>
            </dependency>

            <!-- Fixes for dependency divergence in Hibernate ORM -->
            <dependency>
                <groupId>jakarta.xml.bind</groupId>
                <artifactId>jakarta.xml.bind-api</artifactId>
                <version>${version.jakarta.xml.bind}</version>
            </dependency>
            <dependency>
                <groupId>jakarta.activation</groupId>
                <artifactId>jakarta.activation-api</artifactId>
                <version>${version.jakarta.activation}</version>
            </dependency>

            <!-- Jackson: used by the Elasticsearch REST client and in tests (wiremock, ...) -->
            <dependency>
                <groupId>com.fasterxml.jackson.core</groupId>
                <artifactId>jackson-core</artifactId>
                <version>${version.com.fasterxml.jackson}</version>
            </dependency>
            <dependency>
                <groupId>com.fasterxml.jackson.core</groupId>
                <artifactId>jackson-annotations</artifactId>
                <version>${version.com.fasterxml.jackson}</version>
            </dependency>
            <dependency>
                <groupId>com.fasterxml.jackson.core</groupId>
                <artifactId>jackson-databind</artifactId>
                <version>${version.com.fasterxml.jackson.databind}</version>
            </dependency>
            <dependency>
                <groupId>org.reactivestreams</groupId>
                <artifactId>reactive-streams</artifactId>
                <version>${version.org.reactivestreams.reactive-streams}</version>
            </dependency>
            <dependency>
                <groupId>org.slf4j</groupId>
                <artifactId>slf4j-api</artifactId>
                <version>${version.org.slf4j}</version>
            </dependency>

            <!-- Apache Avro used to serialize/deserialize objects in outbox polling coordination -->
            <dependency>
                <groupId>org.apache.avro</groupId>
                <artifactId>avro</artifactId>
                <version>${version.org.apache.avro}</version>
            </dependency>

            <!-- JBeret used by batch-jsr352 jberet module -->
            <dependency>
                <groupId>org.jberet</groupId>
                <artifactId>jberet-core</artifactId>
                <version>${version.org.jberet}</version>
                <exclusions>
                    <!-- These dependencies are marked as "provided" but will never be there at runtime.
                         This confuses maven-enforcer-plugin, so we'll exclude them. -->
                    <exclusion>
                        <groupId>org.jboss.logging</groupId>
                        <artifactId>jboss-logging-processor</artifactId>
                    </exclusion>
                    <exclusion>
                        <groupId>org.infinispan</groupId>
                        <artifactId>infinispan-core</artifactId>
                    </exclusion>
                    <exclusion>
                        <groupId>org.infinispan</groupId>
                        <artifactId>infinispan-commons</artifactId>
                    </exclusion>
                </exclusions>
            </dependency>

            <!-- Test -->
            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <version>${version.junit}</version>
            </dependency>
            <!--
                Manage the upgrade from Hamcrest 1.x to 2.x:
                http://hamcrest.org/JavaHamcrest/distributables#upgrading-from-hamcrest-1x
             -->
            <dependency>
                <groupId>org.hamcrest</groupId>
                <artifactId>hamcrest</artifactId>
                <version>${version.org.hamcrest}</version>
            </dependency>
            <dependency>
                <groupId>org.hamcrest</groupId>
                <artifactId>hamcrest-core</artifactId>
                <version>${version.org.hamcrest}</version>
            </dependency>
            <dependency>
                <groupId>org.hamcrest</groupId>
                <artifactId>hamcrest-library</artifactId>
                <version>${version.org.hamcrest}</version>
            </dependency>
            <dependency>
                <groupId>io.takari.junit</groupId>
                <artifactId>takari-cpsuite</artifactId>
                <version>${version.io.takari.junit}</version>
            </dependency>
            <dependency>
                <groupId>org.mockito</groupId>
                <artifactId>mockito-core</artifactId>
                <version>${version.org.mockito}</version>
            </dependency>
            <dependency>
                <groupId>org.apache.logging.log4j</groupId>
                <artifactId>log4j-core</artifactId>
                <version>${version.log4j}</version>
            </dependency>
            <dependency>
                <groupId>org.apache.logging.log4j</groupId>
                <artifactId>log4j-api</artifactId>
                <version>${version.log4j}</version>
            </dependency>
            <dependency>
                <groupId>org.apache.logging.log4j</groupId>
                <artifactId>log4j-slf4j-impl</artifactId>
                <version>${version.log4j}</version>
            </dependency>
            <dependency>
                <groupId>org.osgi</groupId>
                <artifactId>org.osgi.core</artifactId>
                <version>${version.org.osgi.core}</version>
            </dependency>
            <dependency>
                <groupId>org.assertj</groupId>
                <artifactId>assertj-core</artifactId>
                <version>${version.org.assertj.assertj-core}</version>
            </dependency>
            <dependency>
                <groupId>org.awaitility</groupId>
                <artifactId>awaitility</artifactId>
                <version>${version.org.awaitily}</version>
            </dependency>
            <dependency>
                <groupId>org.skyscreamer</groupId>
                <artifactId>jsonassert</artifactId>
                <version>${version.org.skyscreamer.jsonassert}</version>
            </dependency>
            <dependency>
                <groupId>com.github.tomakehurst</groupId>
                <artifactId>wiremock</artifactId>
                <version>${version.com.github.tomakehurst.wiremock}</version>
            </dependency>
            <dependency>
                <!-- Dependency management is necessary for Wiremock in particular (it has internal dependency divergence) -->
                <groupId>org.apache.commons</groupId>
                <artifactId>commons-lang3</artifactId>
                <version>${version.org.apache.commons.lang3}</version>
            </dependency>
            <dependency>
                <groupId>org.apache.commons</groupId>
                <artifactId>commons-math3</artifactId>
                <version>${version.org.apache.commons.math3}</version>
            </dependency>
            <dependency>
                <groupId>org.jboss.weld.se</groupId>
                <artifactId>weld-se-shaded</artifactId>
                <version>${version.org.jboss.weld}</version>
            </dependency>

            <!-- Performance tests -->
            <dependency>
                <groupId>org.openjdk.jmh</groupId>
                <artifactId>jmh-core</artifactId>
                <version>${version.org.openjdk.jmh}</version>
            </dependency>

            <!-- Hibernate ORM testing tools -->
            <dependency>
                <groupId>org.hibernate</groupId>
                <artifactId>hibernate-testing</artifactId>
                <version>${version.org.hibernate}</version>
                <exclusions>
                    <!-- we use Log4J 2 -->
                    <exclusion>
                        <groupId>log4j</groupId>
                        <artifactId>log4j</artifactId>
                    </exclusion>
                </exclusions>
            </dependency>
            <dependency>
                <groupId>org.hibernate</groupId>
                <artifactId>hibernate-testing-jakarta</artifactId>
                <version>${version.org.hibernate}</version>
                <exclusions>
                    <!-- we use Log4J 2 -->
                    <exclusion>
                        <groupId>log4j</groupId>
                        <artifactId>log4j</artifactId>
                    </exclusion>
                </exclusions>
            </dependency>
            <dependency>
                <groupId>org.hibernate.orm</groupId>
                <artifactId>hibernate-testing</artifactId>
                <version>${version.org.hibernate.orm}</version>
                <exclusions>
                    <!-- we use Log4J 2 -->
                    <exclusion>
                        <groupId>log4j</groupId>
                        <artifactId>log4j</artifactId>
                    </exclusion>
                </exclusions>
            </dependency>

            <!-- JBatch runtime -->
            <dependency>
                <groupId>com.ibm.jbatch</groupId>
                <artifactId>com.ibm.jbatch-runtime</artifactId>
                <version>${version.com.ibm.jbatch}</version>
            </dependency>
            <dependency>
                <groupId>com.ibm.jbatch</groupId>
                <artifactId>com.ibm.jbatch.container</artifactId>
                <version>${version.com.ibm.jbatch.jakarta}</version>
            </dependency>
            <dependency>
                <groupId>org.apache.derby</groupId>
                <artifactId>derby</artifactId>
                <version>${version.org.apache.derby}</version>
            </dependency>

            <!-- JBeret Core and JBeret SE runtime dependencies -->
            <dependency>
                <groupId>org.jboss.marshalling</groupId>
                <artifactId>jboss-marshalling</artifactId>
                <version>${version.org.jboss.marshalling}</version>
            </dependency>
            <dependency>
                <groupId>org.wildfly.security</groupId>
                <artifactId>wildfly-security-manager</artifactId>
                <version>${version.org.wildfly.security.wildfly-security-manager}</version>
                <scope>compile</scope>
            </dependency>
            <dependency>
                <groupId>com.google.guava</groupId>
                <artifactId>guava</artifactId>
                <version>${version.org.google.guava}</version>
                <scope>compile</scope>
            </dependency>
            <dependency>
                <groupId>org.jberet</groupId>
                <artifactId>jberet-se</artifactId>
                <version>${version.org.jberet}</version>
            </dependency>
            <dependency>
                <groupId>com.h2database</groupId>
                <artifactId>h2</artifactId>
                <version>${version.com.h2database}</version>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <build>
        <defaultGoal>install</defaultGoal>
        <plugins>
            <plugin>
                <artifactId>exec-maven-plugin</artifactId>
                <groupId>org.codehaus.mojo</groupId>
                <executions>
                    <execution>
                        <id>print-java-main-compiler-version</id>
                        <phase>initialize</phase>
                        <goals>
                            <goal>exec</goal>
                        </goals>
                        <configuration>
                            <executable>${java-version.main.compiler}</executable>
                            <commandlineArgs>-version</commandlineArgs>
                            <useMavenLogger>true</useMavenLogger>
                        </configuration>
                    </execution>
                    <!-- This is necessary even if we have the above,
                         because javac -version doesn't print the full version for Early Access releases -->
                    <execution>
                        <id>print-java-main-compiler-java-version</id>
                        <phase>initialize</phase>
                        <goals>
                            <goal>exec</goal>
                        </goals>
                        <configuration>
                            <executable>${java-version.main.compiler.java_home}/bin/java</executable>
                            <commandlineArgs>-version</commandlineArgs>
                            <useMavenLogger>true</useMavenLogger>
                        </configuration>
                    </execution>
                    <execution>
                        <id>print-java-main-release-version</id>
                        <phase>initialize</phase>
                        <goals>
                            <goal>exec</goal>
                        </goals>
                        <configuration>
                            <executable>echo</executable>
                            <commandlineArgs>Main code compiled with -release ${maven.compiler.release}</commandlineArgs>
                            <useMavenLogger>true</useMavenLogger>
                        </configuration>
                    </execution>
                    <execution>
                        <id>print-java-test-compiler-version</id>
                        <phase>initialize</phase>
                        <goals>
                            <goal>exec</goal>
                        </goals>
                        <configuration>
                            <executable>${java-version.test.compiler}</executable>
                            <commandlineArgs>-version</commandlineArgs>
                            <useMavenLogger>true</useMavenLogger>
                        </configuration>
                    </execution>
                    <!-- This is necessary even if we have the above,
                         because javac -version doesn't print the full version for Early Access releases -->
                    <execution>
                        <id>print-java-test-compiler-java-version</id>
                        <phase>initialize</phase>
                        <goals>
                            <goal>exec</goal>
                        </goals>
                        <configuration>
                            <executable>${java-version.test.compiler.java_home}/bin/java</executable>
                            <commandlineArgs>-version</commandlineArgs>
                            <useMavenLogger>true</useMavenLogger>
                        </configuration>
                    </execution>
                    <execution>
                        <id>print-java-test-launcher-version</id>
                        <phase>initialize</phase>
                        <goals>
                            <goal>exec</goal>
                        </goals>
                        <configuration>
                            <executable>${java-version.test.launcher}</executable>
                            <commandlineArgs>-version</commandlineArgs>
                            <useMavenLogger>true</useMavenLogger>
                        </configuration>
                    </execution>
                    <execution>
                        <id>print-java-test-release-version</id>
                        <phase>initialize</phase>
                        <goals>
                            <goal>exec</goal>
                        </goals>
                        <configuration>
                            <executable>echo</executable>
                            <commandlineArgs>Tests compiled with -release ${maven.compiler.testRelease}</commandlineArgs>
                            <useMavenLogger>true</useMavenLogger>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
            </plugin>
            <plugin>
                <groupId>com.github.marschall</groupId>
                <artifactId>jdeps-maven-plugin</artifactId>
                <!--
                    Not enabling automatic executions; run:
                     > mvn jdeps:jdeps
                     to get a report.
                -->
                <configuration>
                    <!-- Allows to see which JRE profiles will be needed -->
                    <profile>true</profile>
                    <failOnWarning>true</failOnWarning>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.codehaus.mojo</groupId>
                <artifactId>build-helper-maven-plugin</artifactId>
                <executions>
                    <execution>
                        <id>set-root-location-property</id>
                        <goals>
                            <goal>rootlocation</goal>
                        </goals>
                        <configuration>
                            <rootLocationProperty>rootProject.directory</rootLocationProperty>
                        </configuration>
                    </execution>
                    <execution>
                        <id>parse-project-version</id>
                        <goals>
                            <goal>parse-version</goal>
                        </goals>
                        <configuration>
                            <propertyPrefix>parsed-version.org.hibernate.search</propertyPrefix>
                            <versionString>${project.version}</versionString>
                        </configuration>
                    </execution>
                    <execution>
                        <id>parse-project-previous-stable-version</id>
                        <goals>
                            <goal>parse-version</goal>
                        </goals>
                        <configuration>
                            <propertyPrefix>parsed-version.org.hibernate.search.previous-stable</propertyPrefix>
                            <versionString>${version.org.hibernate.search.previous-stable}</versionString>
                        </configuration>
                    </execution>
                    <execution>
                        <id>parse-hibernate-version</id>
                        <goals>
                            <goal>parse-version</goal>
                        </goals>
                        <configuration>
                            <propertyPrefix>parsed-version.org.hibernate</propertyPrefix>
                            <versionString>${version.org.hibernate}</versionString>
                        </configuration>
                    </execution>
                    <execution>
                        <id>parse-hibernate-orm-version</id>
                        <goals>
                            <goal>parse-version</goal>
                        </goals>
                        <configuration>
                            <propertyPrefix>parsed-version.org.hibernate.orm</propertyPrefix>
                            <versionString>${version.org.hibernate.orm}</versionString>
                        </configuration>
                    </execution>
                    <execution>
                        <id>parse-lucene-version</id>
                        <goals>
                            <goal>parse-version</goal>
                        </goals>
                        <configuration>
                            <propertyPrefix>parsed-version.org.apache.lucene</propertyPrefix>
                            <versionString>${version.org.apache.lucene}</versionString>
                        </configuration>
                    </execution>
                    <execution>
                        <id>parse-elasticsearch-main-compatible-version</id>
                        <goals>
                            <goal>parse-version</goal>
                        </goals>
                        <configuration>
                            <propertyPrefix>parsed-version.org.elasticsearch.compatible.main</propertyPrefix>
                            <versionString>${version.org.elasticsearch.compatible.main}</versionString>
                        </configuration>
                    </execution>
                    <execution>
                        <id>parse-elasticsearch-client-version</id>
                        <goals>
                            <goal>parse-version</goal>
                        </goals>
                        <configuration>
                            <propertyPrefix>parsed-version.org.elasticsearch.client</propertyPrefix>
                            <versionString>${version.org.elasticsearch.client}</versionString>
                        </configuration>
                    </execution>
                    <execution>
                        <id>parse-gson-version</id>
                        <goals>
                            <goal>parse-version</goal>
                        </goals>
                        <configuration>
                            <propertyPrefix>parsed-version.com.google.code.gson</propertyPrefix>
                            <versionString>${version.com.google.code.gson}</versionString>
                        </configuration>
                    </execution>
                    <execution>
                        <id>parse-jpa-version</id>
                        <goals>
                            <goal>parse-version</goal>
                        </goals>
                        <configuration>
                            <propertyPrefix>parsed-version.javax.persistence</propertyPrefix>
                            <versionString>${version.javax.persistence}</versionString>
                        </configuration>
                    </execution>
                    <execution>
                        <id>parse-jakarta-persistence-version</id>
                        <goals>
                            <goal>parse-version</goal>
                        </goals>
                        <configuration>
                            <propertyPrefix>parsed-version.jakarta.persistence</propertyPrefix>
                            <versionString>${version.jakarta.persistence}</versionString>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
            <!-- Skip the deploy plugin explicitly: we use nexus-staging-maven-plugin instead -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-deploy-plugin</artifactId>
                <configuration>
                    <skip>true</skip>
                </configuration>
            </plugin>
            <!--
                 Configure the nexus-staging-maven-plugin explicitly (without <extension>true</extension>)
                 in order to work around a problem in the "reports" module (see that module's POM for more info).
             -->
            <plugin>
                <groupId>org.sonatype.plugins</groupId>
                <artifactId>nexus-staging-maven-plugin</artifactId>
                <extensions>false</extensions><!-- This is essential: do not put true here -->
                <configuration>
                    <serverId>${ossrh.releases.repo.id}</serverId>
                    <!-- The following, by default, is only used for actual releases, not for snapshot deployments -->
                    <nexusUrl>${ossrh.releases.repo.baseUrl}</nexusUrl>
                    <!-- oss.sonatype.org has been very slow when closing repositories lately;
                         let's raise the timeout until we switch to s01.sonatype.org -->
                    <stagingProgressTimeoutMinutes>60</stagingProgressTimeoutMinutes>
                </configuration>
                <executions>
                    <execution>
                        <id>default-deploy</id>
                        <phase>deploy</phase>
                        <goals>
                            <!--
                                This will only put artifacts in a staging directory.
                                See the "reports" module for actual deployment, at the end of the build.
                             -->
                            <goal>deploy</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-enforcer-plugin</artifactId>
                <executions>
                    <execution>
                        <id>enforce-common-rules</id>
                        <goals>
                            <goal>enforce</goal>
                        </goals>
                        <configuration>
                            <rules>
                                <requireJavaVersion>
                                    <version>[${jdk.min.version},)</version>
                                </requireJavaVersion>
                                <requireMavenVersion>
                                    <version>${maven.min.version}</version>
                                </requireMavenVersion>
                                <banDuplicatePomDependencyVersions />
                            </rules>
                        </configuration>
                    </execution>
                    <execution>
                        <id>enforce-dependency-convergence</id>
                        <goals>
                            <goal>enforce</goal>
                        </goals>
                        <configuration>
                            <skip>${enforcer.dependencyconvergence.skip}</skip>
                            <rules>
                                <DependencyConvergence />
                            </rules>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-release-plugin</artifactId>
                <configuration>
                    <goals>deploy</goals>
                    <arguments>-DskipTests -DskipITs</arguments>
                    <pushChanges>false</pushChanges>
                    <localCheckout>true</localCheckout>
                    <preparationGoals>clean install</preparationGoals>
                    <autoVersionSubmodules>true</autoVersionSubmodules>
                    <allowTimestampedSnapshots>true</allowTimestampedSnapshots>
                    <tagNameFormat>@{project.version}</tagNameFormat>
                </configuration>
            </plugin>
            <plugin>
                <groupId>de.thetaphi</groupId>
                <artifactId>forbiddenapis</artifactId>
            </plugin>
        </plugins>
        <pluginManagement>
            <plugins>
                <!--
                    Build configuration
                 -->

                <plugin>
                    <groupId>io.takari</groupId>
                    <artifactId>maven</artifactId>
                    <version>${version.io.takari.maven}</version>
                    <configuration>
                        <maven>${maven.min.version}</maven>
                    </configuration>
                </plugin>
                <plugin>
                    <groupId>com.github.marschall</groupId>
                    <artifactId>jdeps-maven-plugin</artifactId>
                    <version>${version.jdeps.plugin}</version>
                </plugin>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-clean-plugin</artifactId>
                    <version>${version.clean.plugin}</version>
                </plugin>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-install-plugin</artifactId>
                    <version>${version.install.plugin}</version>
                </plugin>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-resources-plugin</artifactId>
                    <version>${version.resources.plugin}</version>
                </plugin>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-site-plugin</artifactId>
                    <version>${version.site.plugin}</version>
                </plugin>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-jar-plugin</artifactId>
                    <version>${version.jar.plugin}</version>
                </plugin>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-compiler-plugin</artifactId>
                    <version>${version.compiler.plugin}</version>
                    <configuration>
                        <showWarnings>true</showWarnings>
                        <showDeprecation>true</showDeprecation>
                        <failOnWarning>${maven.compiler.failOnWarning}</failOnWarning>
                        <release>${maven.compiler.release}</release>
                        <testRelease>${maven.compiler.testRelease}</testRelease>
                        <encoding>UTF-8</encoding>
                        <!-- needed because of compiler bug: http://bugs.sun.com/view_bug.do?bug_id=6512707 -->
                        <proc>none</proc>
                        <compilerArgs>
                            <compilerArg>-Xlint:unchecked</compilerArg>
                        </compilerArgs>
                    </configuration>
                    <executions>
                        <execution>
                            <id>default-compile</id>
                            <configuration>
                                <fork>true</fork>
                                <executable>${java-version.main.compiler}</executable>
                            </configuration>
                        </execution>
                        <execution>
                            <id>default-testCompile</id>
                            <configuration>
                                <fork>true</fork>
                                <executable>${java-version.test.compiler}</executable>
                            </configuration>
                        </execution>
                    </executions>
                </plugin>
                <plugin>
                    <groupId>org.bsc.maven</groupId>
                    <artifactId>maven-processor-plugin</artifactId>
                    <version>${version.processor.plugin}</version>
                    <executions>
                        <!-- Run annotation processors on src/main/java sources -->
                        <execution>
                            <id>process</id>
                            <goals>
                                <goal>process</goal>
                            </goals>
                            <phase>process-sources</phase>
                            <configuration>
                                <processors>
                                    <processor>org.jboss.logging.processor.apt.LoggingToolsProcessor</processor>
                                </processors>
                                <!-- Disable usage of the @Generated annotation: too much trouble as requirements are different across JDK8 vs JDK9 -->
                                <!-- See also: https://github.com/jboss-logging/jboss-logging-tools/pull/60#issuecomment-293088198 -->
                                <compilerArguments>-Aorg.jboss.logging.tools.addGeneratedAnnotation=false</compilerArguments>
                                <!-- Necessary for the Jakarta artifacts, where sources are copied from other modules -->
                                <addCompileSourceRoots>true</addCompileSourceRoots>
                            </configuration>
                        </execution>
                    </executions>
                    <dependencies>
                        <dependency>
                            <groupId>org.jboss.logging</groupId>
                            <artifactId>jboss-logging-processor</artifactId>
                            <version>${version.org.jboss.logging.jboss-logging-tools}</version>
                            <scope>compile</scope>
                        </dependency>
                    </dependencies>
                </plugin>
                <plugin>
                    <groupId>org.sonatype.plugins</groupId>
                    <artifactId>nexus-staging-maven-plugin</artifactId>
                    <version>${version.nexus-staging.plugin}</version>
                </plugin>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-assembly-plugin</artifactId>
                    <version>${version.assembly.plugin}</version>
                </plugin>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-release-plugin</artifactId>
                    <version>${version.release.plugin}</version>
                </plugin>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-javadoc-plugin</artifactId>
                    <version>${version.javadoc.plugin}</version>
                </plugin>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-source-plugin</artifactId>
                    <version>${version.source.plugin}</version>
                    <executions>
                        <execution>
                            <id>attach-sources</id>
                            <phase>verify</phase>
                            <goals>
                                <goal>jar-no-fork</goal>
                            </goals>
                        </execution>
                    </executions>
                </plugin>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-deploy-plugin</artifactId>
                    <version>${version.deploy.plugin}</version>
                </plugin>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-dependency-plugin</artifactId>
                    <version>${version.dependency.plugin}</version>
                </plugin>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-help-plugin</artifactId>
                    <version>${version.help.plugin}</version>
                </plugin>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-enforcer-plugin</artifactId>
                    <version>${version.enforcer.plugin}</version>
                </plugin>
                <plugin>
                    <groupId>org.codehaus.mojo</groupId>
                    <artifactId>exec-maven-plugin</artifactId>
                    <version>${version.exec.plugin}</version>
                </plugin>
                <plugin>
                    <groupId>org.apache.felix</groupId>
                    <artifactId>maven-bundle-plugin</artifactId>
                    <extensions>true</extensions>
                    <version>${version.bundle.plugin}</version>
                </plugin>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-shade-plugin</artifactId>
                    <version>${version.shade.plugin}</version>
                </plugin>
                <plugin>
                    <groupId>org.codehaus.mojo</groupId>
                    <artifactId>build-helper-maven-plugin</artifactId>
                    <version>${version.buildhelper.plugin}</version>
                </plugin>
                <plugin>
                    <groupId>de.thetaphi</groupId>
                    <artifactId>forbiddenapis</artifactId>
                    <version>${version.forbiddenapis.plugin}</version>
                    <executions>
                        <execution>
                            <id>verify-forbidden-apis</id>
                            <configuration>
                                <!-- if the used Java version is too new, don't fail, just do nothing: -->
                                <failOnUnsupportedJava>false</failOnUnsupportedJava>
                                <excludes>
                                    <!-- JBoss Logger formats messages according to default Locale (bug or feature?) -->
                                    <!-- Also, we allow JBoss Loggers to use SearchException constructors -->
                                    <exclude>**/*_$logger.class</exclude>
                                    <!-- JBoss message bundles format messages -->
                                    <exclude>**/*_$bundle.class</exclude>
                                </excludes>
                                <suppressAnnotations>
                                    <suppressAnnotation>org.hibernate.search.util.common.annotation.impl.SuppressForbiddenApis</suppressAnnotation>
                                </suppressAnnotations>
                                <bundledSignatures>
                                    <!-- These signatures on the top are not specific to any JDK version -->
                                    <bundledSignature>jdk-system-out</bundledSignature>
                                    <bundledSignature>jdk-non-portable</bundledSignature>
                                    <!-- The jdk-reflection is not yet something we can avoid -->
                                    <!--<bundledSignature>jdk-reflection</bundledSignature>-->

                                    <!-- All following signatures should be replicated for each target JDK version we intend to support -->
                                    <bundledSignature>jdk-unsafe-1.8</bundledSignature>
                                    <bundledSignature>jdk-unsafe-9</bundledSignature>
                                    <bundledSignature>jdk-unsafe-10</bundledSignature>
                                    <bundledSignature>jdk-unsafe-11</bundledSignature>
                                    <bundledSignature>jdk-unsafe-12</bundledSignature>
                                    <bundledSignature>jdk-unsafe-13</bundledSignature>
                                    <bundledSignature>jdk-unsafe-14</bundledSignature>
                                    <bundledSignature>jdk-unsafe-15</bundledSignature>
                                    <bundledSignature>jdk-unsafe-16</bundledSignature>
                                    <bundledSignature>jdk-unsafe-17</bundledSignature>

                                    <bundledSignature>jdk-deprecated-1.8</bundledSignature>
                                    <bundledSignature>jdk-deprecated-9</bundledSignature>
                                    <bundledSignature>jdk-deprecated-10</bundledSignature>
                                    <bundledSignature>jdk-deprecated-11</bundledSignature>
                                    <bundledSignature>jdk-deprecated-12</bundledSignature>
                                    <bundledSignature>jdk-deprecated-13</bundledSignature>
                                    <bundledSignature>jdk-deprecated-14</bundledSignature>
                                    <bundledSignature>jdk-deprecated-15</bundledSignature>
                                    <bundledSignature>jdk-deprecated-16</bundledSignature>
                                    <bundledSignature>jdk-deprecated-17</bundledSignature>

                                    <bundledSignature>jdk-internal-1.8</bundledSignature>
                                    <bundledSignature>jdk-internal-9</bundledSignature>
                                    <bundledSignature>jdk-internal-10</bundledSignature>
                                    <bundledSignature>jdk-internal-11</bundledSignature>
                                    <bundledSignature>jdk-internal-12</bundledSignature>
                                    <bundledSignature>jdk-internal-13</bundledSignature>
                                    <bundledSignature>jdk-internal-14</bundledSignature>
                                    <bundledSignature>jdk-internal-15</bundledSignature>
                                    <bundledSignature>jdk-internal-16</bundledSignature>
                                    <bundledSignature>jdk-internal-17</bundledSignature>
                                </bundledSignatures>
                                <failOnMissingClasses>false</failOnMissingClasses>
                                <ignoreSignaturesOfMissingClasses>true</ignoreSignaturesOfMissingClasses>
                                <signaturesArtifacts>
                                    <signaturesArtifact>
                                        <groupId>org.hibernate.search</groupId>
                                        <artifactId>hibernate-search-build-config</artifactId>
                                        <version>${project.version}</version>
                                        <type>jar</type>
                                        <path>forbidden-runtime.txt</path>
                                    </signaturesArtifact>
                                </signaturesArtifacts>
                            </configuration>
                            <phase>compile</phase>
                            <goals>
                                <goal>check</goal>
                            </goals>
                        </execution>
                        <execution>
                            <id>verify-forbidden-test-apis</id>
                            <configuration>
                                <!-- if the used Java version is too new, don't fail, just do nothing: -->
                                <failOnUnsupportedJava>false</failOnUnsupportedJava>
                                <ignoreSignaturesOfMissingClasses>true</ignoreSignaturesOfMissingClasses>
                                <excludes>
                                    <!--
                                        Only those two classes are allowed to build search integrators,
                                        because they do it right (with guaranteed calls to close at the end of the test).
                                    -->
                                    <exclude>**/org/hibernate/search/testsupport/junit/SearchFactoryHolder.class</exclude>
                                    <exclude>**/org/hibernate/search/testsupport/junit/SearchIntegratorResource.class</exclude>
                                </excludes>
                                <bundledSignatures>
                                    <!-- This will automatically choose the right signatures based on 'targetVersion': -->
                                    <bundledSignature>jdk-unsafe</bundledSignature>
                                    <bundledSignature>jdk-deprecated</bundledSignature>
                                    <bundledSignature>jdk-non-portable</bundledSignature>
                                    <bundledSignature>jdk-internal</bundledSignature>
                                </bundledSignatures>
                                <signaturesArtifacts>
                                    <signaturesArtifact>
                                        <groupId>org.hibernate.search</groupId>
                                        <artifactId>hibernate-search-build-config</artifactId>
                                        <version>${project.version}</version>
                                        <type>jar</type>
                                        <path>forbidden-tests.txt</path>
                                    </signaturesArtifact>
                                </signaturesArtifacts>
                            </configuration>
                            <phase>test-compile</phase>
                            <goals>
                                <goal>testCheck</goal>
                            </goals>
                        </execution>
                    </executions>
                </plugin>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-checkstyle-plugin</artifactId>
                    <version>${version.checkstyle.plugin}</version>
                    <dependencies>
                        <dependency>
                            <groupId>org.hibernate.search</groupId>
                            <artifactId>hibernate-search-build-config</artifactId>
                            <version>${project.version}</version>
                        </dependency>
                        <!--
                             force SLF4J dependency to align
                             Maven internals and CheckStyle's
                             see https://github.com/jcgay/maven-color/wiki/Problems
                             If that causes problem, that can be removed
                             but maven-color won't work -->
                        <dependency>
                            <groupId>com.puppycrawl.tools</groupId>
                            <artifactId>checkstyle</artifactId>
                            <version>${version.com.puppycrawl.tools.checkstyle}</version>
                        </dependency>
                        <dependency>
                            <groupId>org.slf4j</groupId>
                            <artifactId>jcl-over-slf4j</artifactId>
                            <version>${version.org.slf4j}</version>
                        </dependency>
                        <dependency>
                            <groupId>org.slf4j</groupId>
                            <artifactId>slf4j-jdk14</artifactId>
                            <version>${version.org.slf4j}</version>
                        </dependency>
                    </dependencies>
                    <configuration>
                        <!-- Location is relative to the classpath -->
                        <configLocation>checkstyle.xml</configLocation>
                        <logViolationsToConsole>true</logViolationsToConsole>
                        <failOnViolation>true</failOnViolation>
                        <violationSeverity>error</violationSeverity>
                        <includeTestResources>true</includeTestResources>
                        <includeTestSourceDirectory>true</includeTestSourceDirectory>
                        <resourceIncludes>**/*.xml,**/*.properties</resourceIncludes>
                        <!-- generated respectively copied code -->
                        <excludes>
                            **/Generated.java,**/TypeHelper*.java,**/MatchSuppressor.java,**/CommentSuppressor.java,**/NeverSuppress.java,
                            **/*_$logger.java,**/*_$bundle.java,
                            **/module-info.java
                        </excludes>
                    </configuration>
                    <executions>
                        <execution>
                            <id>check-style</id>
                            <phase>verify</phase>
                            <!-- not using checkstyle:checkstyle here, as for
                                some reason checkstyle:check finds more errors -->
                            <goals>
                                <goal>check</goal>
                            </goals>
                        </execution>
                    </executions>
                </plugin>
                <plugin>
                    <groupId>org.moditect</groupId>
                    <artifactId>moditect-maven-plugin</artifactId>
                    <version>${version.moditect.plugin}</version>
                </plugin>
                <plugin>
                    <groupId>org.jboss.maven.plugins</groupId>
                    <artifactId>maven-injection-plugin</artifactId>
                    <version>1.0.2</version>
                </plugin>

                <!--
                    Test configuration
                 -->

                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-surefire-plugin</artifactId>
                    <version>${version.surefire.plugin}</version>
                    <configuration>
                        <forkCount>1</forkCount>
                        <reuseForks>true</reuseForks>
                        <redirectTestOutputToFile>true</redirectTestOutputToFile>
                        <runOrder>alphabetical</runOrder>
                        <!--
                             Stack traces for failing tests are useless if trimStackTrace = true (the default).
                             See https://issues.apache.org/jira/browse/SUREFIRE-1226?focusedCommentId=16187391&page=com.atlassian.jira.plugin.system.issuetabpanels%3Acomment-tabpanel#comment-16187391
                         -->
                        <trimStackTrace>false</trimStackTrace>
                        <systemPropertyVariables>
                            <com.sun.management.jmxremote>true</com.sun.management.jmxremote>
                            <org.hibernate.search.enable_performance_tests>${org.hibernate.search.enable_performance_tests}</org.hibernate.search.enable_performance_tests>
                            <org.hibernate.search.fail_on_unreleased_service>true</org.hibernate.search.fail_on_unreleased_service>
                        </systemPropertyVariables>
                        <jvm>${java-version.test.launcher}</jvm>
                        <argLine>${surefire.jvm.args}</argLine>
                        <reportNameSuffix>${surefire.reportNameSuffix}</reportNameSuffix>
                    </configuration>
                    <dependencies>
                        <!--
                             Force tests to execute with JUnit 4
                             See http://maven.apache.org/surefire/maven-failsafe-plugin/examples/junit.html
                         -->
                        <dependency>
                            <groupId>org.apache.maven.surefire</groupId>
                            <artifactId>surefire-junit47</artifactId>
                            <version>${version.failsafe.plugin}</version>
                        </dependency>
                        <!--
                             maven-surefire-plugin and maven-failsafe-plugin use an older version of ASM
                             that cannot handle Java 15+ bytecode.
                             Let's upgrade that dependency and hope for the best;
                             if it doesn't work, the build is very likely to fail and we'll know about it.
                         -->
                        <dependency>
                            <groupId>org.ow2.asm</groupId>
                            <artifactId>asm</artifactId>
                            <version>${version.surefire.plugin.java-version.asm}</version>
                        </dependency>
                    </dependencies>
                </plugin>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-failsafe-plugin</artifactId>
                    <version>${version.failsafe.plugin}</version>
                    <configuration>
                        <forkCount>1</forkCount>
                        <reuseForks>true</reuseForks>
                        <redirectTestOutputToFile>true</redirectTestOutputToFile>
                        <runOrder>alphabetical</runOrder>
                        <!--
                             Stack traces for failing tests are useless if trimStackTrace = true (the default).
                             See https://issues.apache.org/jira/browse/SUREFIRE-1226?focusedCommentId=16187391&page=com.atlassian.jira.plugin.system.issuetabpanels%3Acomment-tabpanel#comment-16187391
                         -->
                        <trimStackTrace>false</trimStackTrace>
                        <systemPropertyVariables>
                            <com.sun.management.jmxremote>true</com.sun.management.jmxremote>
                            <org.hibernate.search.version>${project.version}</org.hibernate.search.version>
                            <org.hibernate.search.enable_performance_tests>${org.hibernate.search.enable_performance_tests}</org.hibernate.search.enable_performance_tests>
                            <org.hibernate.search.fail_on_unreleased_service>true</org.hibernate.search.fail_on_unreleased_service>
                            <org.hibernate.search.integrationtest.backend.elasticsearch.testdialect>${test.elasticsearch.testdialect}</org.hibernate.search.integrationtest.backend.elasticsearch.testdialect>
                            <org.hibernate.search.integrationtest.backend.elasticsearch.version>${test.elasticsearch.connection.distribution}:${test.elasticsearch.connection.version}</org.hibernate.search.integrationtest.backend.elasticsearch.version>
                        </systemPropertyVariables>
                        <jvm>${java-version.test.launcher}</jvm>
                        <argLine>${failsafe.jvm.args}</argLine>
                        <reportNameSuffix>${surefire.reportNameSuffix}</reportNameSuffix>
                        <!-- Catch configuration problems that could cause the plugin
                             to not detect any tests.
                             For example, in the past, we've had:
                             - JUnit 5 Jupiter creeping up our classpath through transitive dependencies,
                               causing the maven-failsafe-plugin to simply switch to JUnit 5 mode and
                               ignore all JUnit 4 tests.
                             - Misconfigured "source copy" artifacts (e.g. jakarta) that ended up not copying tests
                               from the original module at all.
                         -->
                        <failIfNoTests>true</failIfNoTests>
                    </configuration>
                    <dependencies>
                        <!--
                             Force tests to execute with JUnit 4
                             See http://maven.apache.org/surefire/maven-failsafe-plugin/examples/junit.html
                         -->
                        <dependency>
                            <groupId>org.apache.maven.surefire</groupId>
                            <artifactId>surefire-junit47</artifactId>
                            <version>${version.failsafe.plugin}</version>
                        </dependency>
                        <!--
                             maven-surefire-plugin and maven-failsafe-plugin use an older version of ASM
                             that cannot handle Java 15+ bytecode.
                             Let's upgrade that dependency and hope for the best;
                             if it doesn't work, the build is very likely to fail and we'll know about it.
                         -->
                        <dependency>
                            <groupId>org.ow2.asm</groupId>
                            <artifactId>asm</artifactId>
                            <version>${version.surefire.plugin.java-version.asm}</version>
                        </dependency>
                    </dependencies>
                </plugin>
                <plugin>
                    <groupId>io.fabric8</groupId>
                    <artifactId>docker-maven-plugin</artifactId>
                    <version>${version.docker.maven.plugin}</version>
                </plugin>
                <plugin>
                    <groupId>org.apache.avro</groupId>
                    <artifactId>avro-maven-plugin</artifactId>
                    <version>${version.org.apache.avro}</version>
                </plugin>
                <plugin>
                    <groupId>org.jacoco</groupId>
                    <artifactId>jacoco-maven-plugin</artifactId>
                    <version>${version.jacoco.plugin}</version>
                </plugin>
                <plugin>
                    <groupId>org.eluder.coveralls</groupId>
                    <artifactId>coveralls-maven-plugin</artifactId>
                    <version>${version.coveralls.plugin}</version>
                    <configuration>
                        <relativeReportDirs>
                            <relativeReportDir>jacoco-aggregate</relativeReportDir>
                        </relativeReportDirs>
                    </configuration>
                    <dependencies>
                        <dependency>
                            <groupId>jakarta.xml.bind</groupId>
                            <artifactId>jakarta.xml.bind-api</artifactId>
                            <version>2.3.2</version>
                        </dependency>
                        <dependency>
                            <groupId>org.glassfish.jaxb</groupId>
                            <artifactId>jaxb-runtime</artifactId>
                            <version>2.3.2</version>
                        </dependency>
                    </dependencies>
                </plugin>
                <plugin>
                    <groupId>org.asciidoctor</groupId>
                    <artifactId>asciidoctor-maven-plugin</artifactId>
                    <version>${version.asciidoctor.plugin}</version>
                    <configuration>
                        <!-- Enabled to validate internal links -->
                        <enableVerbose>true</enableVerbose>
                        <!-- Abort the build if something seems wrong -->
                        <logHandler>
                            <failIf>
                                <severity>WARN</severity>
                            </failIf>
                        </logHandler>
                    </configuration>
                    <dependencies>
                        <dependency>
                            <groupId>org.jruby</groupId>
                            <artifactId>jruby-complete</artifactId>
                            <version>${version.org.jruby}</version>
                        </dependency>
                        <dependency>
                            <groupId>org.asciidoctor</groupId>
                            <artifactId>asciidoctorj</artifactId>
                            <version>${version.org.asciidoctor.asciidoctorj}</version>
                        </dependency>
                        <dependency>
                            <groupId>org.asciidoctor</groupId>
                            <artifactId>asciidoctorj-pdf</artifactId>
                            <version>${version.org.asciidoctor.asciidoctorj-pdf}</version>
                        </dependency>
                    </dependencies>
                </plugin>
                <plugin>
                    <groupId>org.sonarsource.scanner.maven</groupId>
                    <artifactId>sonar-maven-plugin</artifactId>
                    <version>${version.sonar.plugin}</version>
                </plugin>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-scripting-plugin</artifactId>
                    <version>${version.scripting.plugin}</version>
                    <executions>
                        <execution>
                            <id>list-container-images</id>
                            <configuration>
                                <engineName>groovy</engineName>
                                <!--
                                     Note that expressions ('${...}') are evaluated by Maven before the script is
                                     interpreted by the Groovy interpreter.
                                     That's the only way to access profile-defined properties,
                                     since accessing project.properties within the script will ignore profiles.
                                 -->
                                <script><![CDATA[
                                    def images = []
                                    def isFalseString = { string -> !string || !Boolean.parseBoolean( string ) }
                                    if ( isFalseString( '${test.elasticsearch.run.elastic.skip}' ) ) {
                                        images += '${test.elasticsearch.run.elastic.image.name}:${test.elasticsearch.run.elastic.image.tag}'
                                    }
                                    if ( isFalseString( '${test.elasticsearch.run.opensearch.skip}' ) ) {
                                        images += '${test.elasticsearch.run.opensearch.image.name}:${test.elasticsearch.run.opensearch.image.tag}'
                                    }
                                    if ( isFalseString( '${test.database.run.postgres.skip}' ) ) {
                                        images += '${test.database.run.postgres.image.name}:${test.database.run.postgres.image.tag}'
                                    }
                                    if ( isFalseString( '${test.database.run.mariadb.skip}' ) ) {
                                        images += '${test.database.run.mariadb.image.name}:${test.database.run.mariadb.image.tag}'
                                    }
                                    if ( isFalseString( '${test.database.run.mysql.skip}' ) ) {
                                        images += '${test.database.run.mysql.image.name}:${test.database.run.mysql.image.tag}'
                                    }
                                    if ( isFalseString( '${test.database.run.db2.skip}' ) ) {
                                        images += '${test.database.run.db2.image.name}:${test.database.run.db2.image.tag}'
                                    }
                                    if ( isFalseString( '${test.database.run.oracle.skip}' ) ) {
                                        images += '${test.database.run.oracle.image.name}:${test.database.run.oracle.image.tag}'
                                    }
                                    if ( isFalseString( '${test.database.run.mssql.skip}' ) ) {
                                        images += '${test.database.run.mssql.image.name}:${test.database.run.mssql.image.tag}'
                                    }
                                    new File('${containerImagesListFile}').append( images.join('\n') + '\n' )
                                ]]></script>
                            </configuration>
                        </execution>
                    </executions>
                    <dependencies>
                        <!-- ScriptEngines -->
                        <dependency>
                            <groupId>org.codehaus.groovy</groupId>
                            <artifactId>groovy-jsr223</artifactId>
                            <version>${version.org.codehaus.groovy-jsr223}</version> <!-- look for latest -->
                        </dependency>
                    </dependencies>
                </plugin>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-gpg-plugin</artifactId>
                    <version>${version.gpg.plugin}</version>
                </plugin>
                <plugin>
                    <artifactId>maven-antrun-plugin</artifactId>
                    <version>3.0.0</version>
                </plugin>
            </plugins>
        </pluginManagement>
    </build>

    <distributionManagement>
        <repository>
            <id>${ossrh.releases.repo.id}</id>
            <name>OSSRH Releases Repository</name>
            <url>${ossrh.releases.repo.url}</url>
        </repository>
        <snapshotRepository>
            <id>${ossrh.snapshots.repo.id}</id>
            <name>OSSRH Snapshots Repository</name>
            <url>${ossrh.snapshots.repo.url}</url>
        </snapshotRepository>
    </distributionManagement>

    <reporting>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-project-info-reports-plugin</artifactId>
                <version>${version.project-info.plugin}</version>
                <reportSets>
                    <reportSet>
                        <reports>
                            <report>index</report>
                        </reports>
                    </reportSet>
                </reportSets>
            </plugin>
            <plugin>
                <groupId>com.github.siom79.japicmp</groupId>
                <artifactId>japicmp-maven-plugin</artifactId>
                <version>${version.japicmp.plugin}</version>
                <reportSets>
                    <reportSet>
                        <reports>
                            <report>cmp-report</report>
                        </reports>
                    </reportSet>
                </reportSets>
                <configuration>
                    <skip>true</skip>
                    <oldVersion>
                        <dependency>
                            <groupId>org.hibernate.search</groupId>
                            <artifactId>${project.artifactId}</artifactId>
                            <version>${version.org.hibernate.search.previous-stable}</version>
                            <type>${project.packaging}</type>
                        </dependency>
                    </oldVersion>
                    <newVersion>
                        <file>
                            <path>${project.build.directory}/${project.artifactId}-${project.version}.${project.packaging}</path>
                        </file>
                    </newVersion>
                    <parameter>
                        <onlyModified>true</onlyModified>
                        <excludes>
                            <exclude>org.hibernate.search.*.impl</exclude>
                        </excludes>
                        <accessModifier>public</accessModifier>
                        <!--
                            The next two should make sure that this report is not run for this POM-packaged parent module itself
                            That's not working, though, resulting a build failure. I'm thus setting skip to "true" below, which
                            needs to be overridden within those modules for which this report should be created
                        -->
                        <skipPomModules>true</skipPomModules>
                        <packagingSupporteds>
                            <packagingSupported>jar</packagingSupported>
                        </packagingSupporteds>
                    </parameter>
                    <skip>true</skip>
                </configuration>
            </plugin>
        </plugins>
    </reporting>

    <profiles>
        <profile>
            <id>dist</id>
            <modules>
                <module>jakarta</module>
                <module>orm6</module>
                <module>distribution</module>
            </modules>
        </profile>

        <profile>
            <id>testWithJdk8</id>
            <activation>
                <property>
                    <name>java-version.test.release</name>
                    <value>8</value>
                </property>
            </activation>
            <properties>
                <surefire.jvm.args.java-version></surefire.jvm.args.java-version>
                <maven.compiler.failOnWarning>false</maven.compiler.failOnWarning>
            </properties>
        </profile>

        <profile>
            <id>testWithJdk11</id>
            <activation>
                <property>
                    <name>java-version.test.release</name>
                    <value>11</value>
                </property>
            </activation>
        </profile>

        <profile>
            <id>testWithJdk16</id>
            <activation>
                <property>
                    <name>java-version.test.release</name>
                    <value>16</value>
                </property>
            </activation>
            <properties>
                <!-- Spring isn't ready for JDK16 yet -->
                <failsafe.spring.skip>true</failsafe.spring.skip>
            </properties>
        </profile>

        <profile>
            <id>testWithJdk17</id>
            <activation>
                <property>
                    <name>java-version.test.release</name>
                    <value>17</value>
                </property>
            </activation>
            <properties>
                <!-- Spring isn't ready for JDK17 yet -->
                <failsafe.spring.skip>true</failsafe.spring.skip>
            </properties>
        </profile>

        <profile>
            <id>testWithJdk18</id>
            <activation>
                <property>
                    <name>java-version.test.release</name>
                    <value>18</value>
                </property>
            </activation>
            <properties>
                <!-- ForbiddenAPIs doesn't provide bundled signatures for JDK18 yet. -->
                <forbiddenapis.skip>true</forbiddenapis.skip>
                <!-- Spring isn't ready for JDK18 yet -->
                <failsafe.spring.skip>true</failsafe.spring.skip>
            </properties>
        </profile>

        <profile>
            <id>testWithJdk19</id>
            <activation>
                <property>
                    <name>java-version.test.release</name>
                    <value>19</value>
                </property>
            </activation>
            <properties>
                <!-- ForbiddenAPIs doesn't provide bundled signatures for JDK19 yet. -->
                <forbiddenapis.skip>true</forbiddenapis.skip>
                <!-- We need net.bytebuddy.experimental=true to make BytecodeEnhancementIT and mockito-based tests pass -->
                <surefire.jvm.args.java-version>
                    -Djdk.attach.allowAttachSelf=true
                    -Dnet.bytebuddy.experimental=true
                </surefire.jvm.args.java-version>
                <!-- Spring isn't ready for JDK19 yet -->
                <failsafe.spring.skip>true</failsafe.spring.skip>
            </properties>
        </profile>

        <profile>
            <id>compiler-eclipse</id>
            <build>
                <pluginManagement>
                    <plugins>
                        <plugin>
                            <artifactId>maven-compiler-plugin</artifactId>
                            <configuration>
                                <compilerId>eclipse</compilerId>
                                <!-- ECJ doesn't seem to understand the "release" argument -->
                                <release></release>
                                <source>${maven.compiler.release}</source>
                                <target>${maven.compiler.release}</target>
                                <compilerArgs>
                                    <!-- Ignore warnings in generated code -->
                                    <compilerArg>-nowarn:[${project.build.directory}/generated-sources/apt]</compilerArg>
                                    <!-- For a list of warning categories that can be passed to -warn,
                                         see https://git.eclipse.org/c/jdt/eclipse.jdt.core.git/tree/org.eclipse.jdt.core/batch/org/eclipse/jdt/internal/compiler/batch/messages.properties#n376
                                     -->
                                    <!-- Ignore warnings that we don't care about -->
                                    <compilerArg>-warn:-serial,intfAnnotation</compilerArg>
                                    <!-- Ignore warnings that give false positives with ecj (or are addressed by other tools) -->
                                    <compilerArg>-warn:-unusedImport,warningToken,unusedPrivate,enumSwitch</compilerArg>
                                </compilerArgs>
                            </configuration>
                            <executions>
                                <execution>
                                    <id>default-testCompile</id>
                                    <configuration>
                                        <compilerArgs combine.children="append">
                                            <!-- Ignore warnings that are too annoying for tests -->
                                            <compilerArg>-warn:-unused,resource</compilerArg>
                                        </compilerArgs>
                                    </configuration>
                                </execution>
                            </executions>
                            <dependencies>
                                <dependency>
                                    <groupId>org.codehaus.plexus</groupId>
                                    <artifactId>plexus-compiler-api</artifactId>
                                    <version>${version.org.codehaus.plexus.plexus-compiler.compiler-eclipse}</version>
                                </dependency>
                                <dependency>
                                    <groupId>org.codehaus.plexus</groupId>
                                    <artifactId>plexus-compiler-manager</artifactId>
                                    <version>${version.org.codehaus.plexus.plexus-compiler.compiler-eclipse}</version>
                                </dependency>
                                <dependency>
                                    <groupId>org.codehaus.plexus</groupId>
                                    <artifactId>plexus-compiler-eclipse</artifactId>
                                    <version>${version.org.codehaus.plexus.plexus-compiler.compiler-eclipse}</version>
                                </dependency>
                                <dependency>
                                    <groupId>org.eclipse.jdt</groupId>
                                    <artifactId>ecj</artifactId>
                                    <version>${version.org.eclipse.jdt.ecj}</version>
                                </dependency>
                            </dependencies>
                        </plugin>
                    </plugins>
                </pluginManagement>
            </build>
            <pluginRepositories>
                <!--
                     This is needed to access pre-release versions of ECJ,
                     when bugs that affect us are fixed but not yet released.
                     It's been used in particular to get a fix for https://bugs.eclipse.org/bugs/show_bug.cgi?id=547807.
                     This configuration *MUST STAY IN A SPECIFIC PROFILE*,
                     otherwise it would "taint" projects that depend on Hibernate Search.
                 -->
                <pluginRepository>
                    <id>${eclipse.repo.id}</id>
                    <url>${eclipse.repo.url}</url>
                    <releases>
                        <enabled>true</enabled>
                        <updatePolicy>never</updatePolicy>
                    </releases>
                    <snapshots>
                        <enabled>false</enabled>
                    </snapshots>
                </pluginRepository>
            </pluginRepositories>
        </profile>

        <profile>
            <id>perf</id>
            <properties>
                <org.hibernate.search.enable_performance_tests>true</org.hibernate.search.enable_performance_tests>
            </properties>
        </profile>

        <profile>
            <id>IDEA</id>
            <!--
            Dependencies to allow easy project import in IntelliJ IDEA.
            These should not be listed as project dependencies to users
            but are necessary during compile time as they include the
            JBoss Logger annotation processor.
            -->
            <activation>
                <!-- This is a trick to have the profile automatically activated by IDEA -->
                <property>
                    <name>idea.maven.embedder.version</name>
                </property>
            </activation>
            <dependencies>
                <dependency>
                    <groupId>org.jboss.logging</groupId>
                    <artifactId>jboss-logging-processor</artifactId>
                    <version>${version.org.jboss.logging.jboss-logging-tools}</version>
                    <scope>compile</scope>
                </dependency>
                <dependency>
                    <groupId>org.openjdk.jmh</groupId>
                    <artifactId>jmh-generator-annprocess</artifactId>
                    <version>${version.org.openjdk.jmh}</version>
                    <scope>compile</scope>
                </dependency>
            </dependencies>
        </profile>

        <profile>
            <id>eclipse</id>
            <activation>
                <property>
                    <!-- This is a trick to have the profile automatically activated by Eclipse -->
                    <name>m2e.version</name>
                </property>
            </activation>
            <build>
                <pluginManagement>
                    <plugins>
                        <plugin>
                            <!--
                                This plugin's configuration is used in m2e only.
                                We want to configure this in a separate profile because the plugin doesn't really exist
                                and Maven will complain because it doesn't find it if executed outside of Eclipse.
                             -->
                            <groupId>org.eclipse.m2e</groupId>
                            <artifactId>lifecycle-mapping</artifactId>
                            <version>${version.org.eclipse.m2e.lifecycle-mapping}</version>
                            <configuration>
                                <lifecycleMappingMetadata>
                                    <pluginExecutions>
                                        <pluginExecution>
                                            <pluginExecutionFilter>
                                                <groupId>org.apache.maven.plugins</groupId>
                                                <artifactId>maven-dependency-plugin</artifactId>
                                                <versionRange>[2.1,)</versionRange>
                                                <goals>
                                                    <goal>unpack</goal>
                                                    <goal>unpack-dependencies</goal>
                                                    <goal>build-classpath</goal>
                                                </goals>
                                            </pluginExecutionFilter>
                                            <action>
                                                <ignore />
                                            </action>
                                        </pluginExecution>
                                        <pluginExecution>
                                            <pluginExecutionFilter>
                                                <groupId>org.apache.felix</groupId>
                                                <artifactId>maven-bundle-plugin</artifactId>
                                                <versionRange>[2.3.7,)</versionRange>
                                                <goals>
                                                    <goal>manifest</goal>
                                                </goals>
                                            </pluginExecutionFilter>
                                            <action>
                                                <ignore />
                                            </action>
                                        </pluginExecution>
                                        <pluginExecution>
                                            <pluginExecutionFilter>
                                                <groupId>org.codehaus.mojo</groupId>
                                                <artifactId>build-helper-maven-plugin</artifactId>
                                                <versionRange>[1.9.1,)</versionRange>
                                                <goals>
                                                    <goal>parse-version</goal>
                                                </goals>
                                            </pluginExecutionFilter>
                                            <action>
                                                <ignore />
                                            </action>
                                        </pluginExecution>
                                        <pluginExecution>
                                            <pluginExecutionFilter>
                                                <groupId>de.thetaphi</groupId>
                                                <artifactId>forbiddenapis</artifactId>
                                                <versionRange>[3.1,)</versionRange>
                                                <goals>
                                                    <goal>check</goal>
                                                    <goal>testCheck</goal>
                                                </goals>
                                            </pluginExecutionFilter>
                                            <action>
                                                <ignore />
                                            </action>
                                        </pluginExecution>
                                        <pluginExecution>
                                            <pluginExecutionFilter>
                                                <groupId>
                                                    org.asciidoctor
                                                </groupId>
                                                <artifactId>
                                                    asciidoctor-maven-plugin
                                                </artifactId>
                                                <versionRange>
                                                    [2.2.1,)
                                                </versionRange>
                                                <goals>
                                                    <goal>
                                                        process-asciidoc
                                                    </goal>
                                                </goals>
                                            </pluginExecutionFilter>
                                            <action>
                                                <ignore></ignore>
                                            </action>
                                        </pluginExecution>
                                    </pluginExecutions>
                                </lifecycleMappingMetadata>
                            </configuration>
                        </plugin>
                    </plugins>
                </pluginManagement>
            </build>
        </profile>

        <profile>
            <id>coverage</id>
            <properties>
                <!--
                    Caution, we use @{...} for late property evaluation here:
                    http://maven.apache.org/surefire/maven-surefire-plugin/faq.html#late-property-evaluation
                    This is necessary for Jacoco to work as expected.
                    However, we wrap the @{...} references into two early-evaluated properties
                    because in certain environments (IntelliJ IDEA), the use of late property evaluation
                    is not supported and breaks test execution.
                    This is because IntelliJ tries to parse the POM to retrieve the surefire/failsafe
                    argLine and pass them to the test execution directly,
                    but then fails to evaluate "@{...}" references, resulting in errors.
                    As a result, this profile will not work in IntelliJ,
                    but we don't need JaCoCo in IntelliJ anyway.
                 -->
                <surefire.jvm.args.jacoco>@{surefire.jvm.args.jacoco.lateEval}</surefire.jvm.args.jacoco>
                <failsafe.jvm.args.jacoco>@{failsafe.jvm.args.jacoco.lateEval}</failsafe.jvm.args.jacoco>
            </properties>
            <build>
                <plugins>
                    <plugin>
                        <groupId>org.jacoco</groupId>
                        <artifactId>jacoco-maven-plugin</artifactId>
                        <configuration>
                            <excludes>
                                <exclude>**/*_$logger.class</exclude>
                                <exclude>**/*_$bundle.class</exclude>
                                <!-- Exclude DTOs generated by Avro -->
                                <exclude>org/hibernate/search/mapper/orm/coordination/outboxpolling/avro/generated/impl/**</exclude>
                            </excludes>
                        </configuration>
                        <executions>
                            <execution>
                                <id>jacoco-prepare-agent</id>
                                <goals>
                                    <goal>prepare-agent</goal>
                                </goals>
                                <configuration>
                                    <propertyName>surefire.jvm.args.jacoco.lateEval</propertyName>
                                </configuration>
                            </execution>
                            <execution>
                                <id>jacoco-prepare-prepare-agent-integration</id>
                                <!--
                                    This is necessary in order for the property to be set before we process resources,
                                    such as arquillian.xml in WildFly tests or maven.properties in OSGi tests.
                                 -->
                                <phase>initialize</phase>
                                <goals>
                                    <goal>prepare-agent-integration</goal>
                                </goals>
                                <configuration>
                                    <propertyName>failsafe.jvm.args.jacoco.lateEval</propertyName>
                                </configuration>
                            </execution>
                        </executions>
                    </plugin>
                </plugins>
            </build>
        </profile>

        <!--
            A profile executing jqassistant scanning and analysis for all relevant modules.
            Our rules are in jqassistant/rules.xml.
            See README.md for usage.
        -->
        <profile>
            <id>jqassistant</id>
            <build>
                <plugins>
                    <plugin>
                        <groupId>com.buschmais.jqassistant</groupId>
                        <artifactId>jqassistant-maven-plugin</artifactId>
                        <version>${version.com.buschmais.jqassistant.plugin}</version>
                        <executions>
                            <execution>
                                <goals>
                                    <goal>scan</goal>
                                    <goal>analyze</goal>
                                </goals>
                                <configuration>
                                    <warnOnSeverity>INFO</warnOnSeverity>
                                    <failOnSeverity>MAJOR</failOnSeverity>
                                </configuration>
                            </execution>
                        </executions>
                    </plugin>
                </plugins>
            </build>
        </profile>

        <profile>
            <id>owasp</id>
            <build>
                <plugins>
                    <plugin>
                        <groupId>org.owasp</groupId>
                        <artifactId>dependency-check-maven</artifactId>
                        <version>${version.dependency-check.plugin}</version>
                        <executions>
                            <execution>
                                <goals>
                                    <goal>aggregate</goal>
                                </goals>
                            </execution>
                        </executions>
                    </plugin>
                </plugins>
            </build>
        </profile>

        <!--
             WARNING: this MUST be the very last profile,
             so that the "report" module is the very last module,
             in particular when deploying artifacts to a Nexus repository.
             See the "reports" module POM for more information.
         -->
        <profile>
            <id>report-as-last-module</id>
            <activation>
                <property>
                    <name>!some.property.that.will.never.exist</name>
                </property>
            </activation>
            <modules>
                <module>reports</module>
            </modules>
        </profile>

        <!-- DO NOT ADD ANY PROFILE AFTER THIS: see above -->
    </profiles>
</project>
