<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>

  <parent>
     <groupId>org.apache.servicemix.examples</groupId> 
     <artifactId>camel</artifactId>
     <version>4.1.0-SNAPSHOT</version>
  </parent>

  <groupId>org.apache.servicemix.examples.camel</groupId>
  <artifactId>camel-sa</artifactId>
  <packaging>jbi-service-assembly</packaging>
  <name>ServiceMix :: Samples :: Camel :: SA</name>

  <dependencies>
    <dependency>
      <groupId>org.apache.servicemix</groupId>
      <artifactId>servicemix-camel</artifactId>
      <version>${servicemix-camel-version}</version>      
    </dependency> 
    <dependency>
      <groupId>org.apache.servicemix.examples.camel</groupId>
      <artifactId>camel-simple-su</artifactId>
      <version>${project.version}</version>      
    </dependency>      
  </dependencies>
  <build>
    <plugins>
      <plugin>
        <groupId>org.apache.servicemix.tooling</groupId>
        <artifactId>jbi-maven-plugin</artifactId>
        <version>${servicemix-jbi-plugin-version}</version> 
        <extensions>true</extensions>
        <configuration>
          <type>service-assembly</type>         
        </configuration>
      </plugin>
    </plugins>
  </build>
</project>