<?xml version="1.0" encoding="UTF-8"?>
<!--
  Copyright (c) 2012, 2018 Eclipse Foundation and others.
  All rights reserved. This program and the accompanying materials
  are made available under the terms of the Eclipse Distribution License v1.0
  which accompanies this distribution, and is available at
  http://www.eclipse.org/org/documents/edl-v10.php
 
  Contributors:
    Thanh Ha (Eclipse Foundation) - initial implementation
-->

<project xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd" xmlns="http://maven.apache.org/POM/4.0.0"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
  <modelVersion>4.0.0</modelVersion>
  <parent>
    <groupId>org.eclipse.webtools.servertools</groupId>
    <artifactId>org.eclipse.webtools.servertools</artifactId>
    <version>3.6.0-SNAPSHOT</version>
    <relativePath>../../</relativePath>
  </parent>

  <groupId>org.eclipse.webtools.servertools</groupId>
  <artifactId>org.eclipse.jst.server_sdk.feature</artifactId>
  <version>3.4.301-SNAPSHOT</version>
  <packaging>eclipse-feature</packaging>
</project>
