<!--
  Licensed to the Apache Software Foundation (ASF) under one
  or more contributor license agreements.  See the NOTICE file
  distributed with this work for additional information
  regarding copyright ownership.  The ASF licenses this file
  to you under the Apache License, Version 2.0 (the
  "License"); you may not use this file except in compliance
  with the License.  You may obtain a copy of the License at
  
    http://www.apache.org/licenses/LICENSE-2.0
  
  Unless required by applicable law or agreed to in writing,
  software distributed under the License is distributed on an
  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  KIND, either express or implied.  See the License for the
  specific language governing permissions and limitations
  under the License.
-->

<ivysettings>
  <!-- As we use our own resolved, we rather don't use the user level Ivy cache: -->
  <caches defaultCacheDir="${ivy.project.dir}/.ivy/cache">
    <cache name="freemarkerCache" useOrigin="true" />
  </caches>
  
  <settings defaultResolver="default" />
  <property name="localMaveRepoDir" value="${user.home}/.m2/repository/" />
  <resolvers>
    <chain name="default">
      <!--
      <filesystem name="mavenLocal" m2compatible="true">
        <artifact pattern="${localMaveRepoDir}/[organisation]/[module]/[revision]/[module]-[revision].[ext]" />
        <ivy pattern="${localMaveRepoDir}/[organisation]/[module]/[revision]/[module]-[revision].pom" />
      </filesystem>
      -->
      <ibiblio name="mavenCentral" m2compatible="true" />
      <ibiblio name="mavenApacheStaging" m2compatible="true" root="https://repository.apache.org/content/repositories/staging/" />
      <ibiblio name="mavenApacheSnapshot" m2compatible="true" root="https://repository.apache.org/content/repositories/snapshots/" />
    </chain>
  </resolvers>
</ivysettings>
