<!--
/***************************************************************************************************************************
 * 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.
 ***************************************************************************************************************************/
 -->
<p>
	Apache Juneau&trade; is a single cohesive Java ecosystem consisting of the following parts:
</p>
<table class='styled w800'>
	<tr>
		<th>Group</th><th>Component</th><th>Description</th>
	</tr>
	<tr class='dark bb'>
		<td rowspan="5" style='text-align:center;font-weight:bold;padding:20px;' class='code'>juneau-core</td>
		<td class='code'><a class='doclink' href='http://juneau.apache.org/site/apidocs-{@property juneauVersion}/overview-summary.html#juneau-marshall'>juneau-marshall</a></td>
		<td>
			A universal toolkit for marshalling POJOs to a wide variety of content types using a common framework with no external library dependencies.
		</td>
	</tr>
	<tr class='dark bb'>
		<td class='code'><a class='doclink' href='http://juneau.apache.org/site/apidocs-{@property juneauVersion}/overview-summary.html##juneau-marshall-rdf'>juneau-marshall-rdf</a></td>
		<td>
			Extended marshalling support for RDF languages.				
		</td>
	</tr>
	<tr class='dark bb'>
		<td class='code'><a class='doclink' href='http://juneau.apache.org/site/apidocs-{@property juneauVersion}/overview-summary.html##juneau-dto'>juneau-dto</a></td>
		<td>
			A variety of predefined DTOs for serializing and parsing languages such as HTML5, Swagger and ATOM.
		</td>
	</tr>
	<tr class='dark bb'>
		<td class='code'><a class='doclink' href='http://juneau.apache.org/site/apidocs-{@property juneauVersion}/overview-summary.html##juneau-config'>juneau-config</a></td>
		<td>
			A sophisticated configuration file API.
		</td>
	</tr>
	<tr class='light bb'>
		<td rowspan="4" style='text-align:center;font-weight:bold;padding:20px;' class='code'>juneau-rest</td>
		<td class='code'><a class='doclink' href='http://juneau.apache.org/site/apidocs-{@property juneauVersion}/overview-summary.html##juneau-rest-server'>juneau-rest-server</a></td>
		<td>
			A universal REST server API for creating Swagger-based self-documenting REST interfaces using POJOs, simply deployed as 
			one or more top-level servlets in any Servlet 3.1.0+ container.
		</td>
	</tr>
	<tr class='light bb'>
		<td class='code'><a class='doclink' href='http://juneau.apache.org/site/apidocs-{@property juneauVersion}/overview-summary.html##juneau-rest-server-springboot'>juneau-rest-server-springboot</a></td>
		<td>
			Spring Boot integration support
		</td>
	</tr>
	<tr class='light bb'>
		<td class='code'><a class='doclink' href='http://juneau.apache.org/site/apidocs-{@property juneauVersion}/overview-summary.html##juneau-rest-server-jaxrs'>juneau-rest-server-jaxrs</a></td>
		<td>
			JAX/RS integration support.
		</td>
	</tr>
	<tr class='light bb'>
		<td class='code'><a class='doclink' href='http://juneau.apache.org/site/apidocs-{@property juneauVersion}/overview-summary.html##juneau-rest-client'>juneau-rest-client</a></td>
		<td>
			A universal REST client API for interacting with Juneau or 3rd-party REST interfaces using POJOs and proxy interfaces.
		</td>
	</tr>
</table>
