<!--
/***************************************************************************************************************************
 * 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.
 ***************************************************************************************************************************/
-->
<ol class='toc'>
	<li><p class='toc2'><a class='doclink' href='{OVERVIEW_URL}#Introduction'>Introduction</a></p>
	<ol>
		<li><p class='updated'><a class='doclink' href='{OVERVIEW_URL}#Introduction.Features'>Features</a></p>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#Introduction.Components'>Components</a></p>
	</ol>
	<li><p class='toc2'><a class='doclink' href='{OVERVIEW_URL}#juneau-marshall'>juneau-marshall</a></p>
	<ol>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-marshall.Serializers'>Serializers</a></p>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-marshall.Parsers'>Parsers</a></p>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-marshall.Marshalls'>Marshalls</a></p>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-marshall.HttpPartSerializers'>HTTP Part Serializers</a></p>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-marshall.HttpPartParsers'>HTTP Part Parsers</a></p>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-marshall.ConfigurableProperties'>Configurable Properties</a></p>
		<ol>
			<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-marshall.ConfigurableProperties.Common'>Common Serializer Properties</a></p>
			<li><p class='updated'><a class='doclink' href='{OVERVIEW_URL}#juneau-marshall.ConfigurableProperties.CommonSerializer'>Common Serializer Properties</a></p>
			<li><p class='update'><a class='doclink' href='{OVERVIEW_URL}#juneau-marshall.ConfigurableProperties.CommonParser'>Common Parser Properties</a></p>
		</ol>
		<li><p class='new'><a class='doclink' href='{OVERVIEW_URL}#juneau-marshall.ConfigurableAnnotations'>Configurable Annotations</a></p>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-marshall.ObjectMap'>ObjectMap and ObjectList</a></p>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-marshall.Groups'>SerializerGroups and ParserGroups</a></p>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-marshall.ContextsBuildersSessionsPropertyStores'>Contexts, Builders, Sessions, and PropertyStores</a></p>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-marshall.Transforms'>Transforms</a></p>
		<ol>
			<li><p class='updated'><a class='doclink' href='{OVERVIEW_URL}#juneau-marshall.Transforms.PojoSwaps'>PojoSwaps</a></p>
			<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-marshall.Transforms.DefaultPojoSwaps'>Default PojoSwaps</a></p>
			<li><p class='new'><a class='doclink' href='{OVERVIEW_URL}#juneau-marshall.Transforms.AutoPojoSwaps'>Auto-detected POJO swaps</a></p>
			<li><p class='updated'><a class='doclink' href='{OVERVIEW_URL}#juneau-marshall.Transforms.PerMediaTypePojoSwaps'>Per-media-type PojoSwaps</a></p>
			<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-marshall.Transforms.OneWayPojoSwaps'>One-way PojoSwaps</a></p>
			<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-marshall.Transforms.SwapAnnotation'>@Swap Annotation</a></p>
			<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-marshall.Transforms.TemplatedSwaps'>Templated Swaps</a></p>
			<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-marshall.Transforms.SurrogateClasses'>Surrogate Classes</a></p>
			<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-marshall.Transforms.BeanAnnotation'>@Bean Annotation</a></p>
			<li><p class='updated'><a class='doclink' href='{OVERVIEW_URL}#juneau-marshall.Transforms.BeanPropertyAnnotation'>@BeanProperty Annotation</a></p>
			<li><p class='updated'><a class='doclink' href='{OVERVIEW_URL}#juneau-marshall.Transforms.BeanConstructorAnnotation'>@BeanConstructor Annotation</a></p>
			<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-marshall.Transforms.BeanIgnoreAnnotation'>@BeanIgnore Annotation</a></p>
			<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-marshall.Transforms.NamePropertyAnnotation'>@NameProperty Annotation</a></p>
			<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-marshall.Transforms.ParentPropertyAnnotation'>@ParentProperty Annotation</a></p>
			<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-marshall.Transforms.PojoBuilders'>POJO Builders</a></p>
			<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-marshall.Transforms.BeanFilters'>BeanFilter Class</a></p>
			<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-marshall.Transforms.InterfaceFilters'>Interface Filters</a></p>
			<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-marshall.Transforms.StopClasses'>Stop Classes</a></p>
			<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-marshall.Transforms.BypassSerialization'>Bypass Serialization using Readers and InputStreams</a></p>
		</ol>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-marshall.BeanDictionaries'>Bean Names and Dictionaries</a></p>
		<ol>
			<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-marshall.BeanDictionaries.BeanSubTypes'>Bean Subtypes</a></p>
		</ol>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-marshall.VirtualBeans'>Virtual Beans</a></p>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-marshall.Recursion'>Non-Tree Models and Recursion Detection</a></p>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-marshall.ParsingIntoGenericModels'>Parsing into Generic Models</a></p>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-marshall.ReadingContinuousStreams'>Reading Continuous Streams</a></p>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-marshall.URIs'>URIs</a></p>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-marshall.JacksonComparison'>Comparison with Jackson</a></p>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-marshall.PojoCategories'>POJO Categories</a></p>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-marshall.JsonDetails'>JSON Details</a></p>
		<ol>
			<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-marshall.JsonDetails.Methodology'>JSON Methodology</a></p>
			<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-marshall.JsonDetails.Serializers'>JSON Serializers</a></p>
			<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-marshall.JsonDetails.SimplifiedJson'>Simplified JSON</a></p>
			<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-marshall.JsonDetails.Parsers'>JSON Parsers</a></p>
			<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-marshall.JsonDetails.JsonAnnotation'>@Json Annotation</a></p>
			<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-marshall.JsonDetails.JsonSchema'>JSON-Schema Support</a></p>
		</ol>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-marshall.XmlDetails'>XML Details</a></p>
		<ol>
			<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-marshall.XmlDetails.Methodology'>XML Methodology</a></p>
			<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-marshall.XmlDetails.Serializers'>XML Serializers</a></p>
			<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-marshall.XmlDetails.Parsers'>XML Parsers</a></p>
			<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-marshall.XmlDetails.BeanTypeNameAnnotation'>@Bean(typeName) Annotation</a></p>
			<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-marshall.XmlDetails.XmlChildNameAnnotation'>@Xml(childName) Annotation</a></p>
			<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-marshall.XmlDetails.XmlFormatAnnotation'>@Xml(format) Annotation</a></p>
			<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-marshall.XmlDetails.Namespaces'>Namespaces</a></p>
			<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-marshall.XmlDetails.XmlSchema'>XML-Schema Support</a></p>
		</ol>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-marshall.HtmlDetails'>HTML Details</a></p>
		<ol>
			<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-marshall.HtmlDetails.Methodology'>HTML Methodology</a></p>
			<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-marshall.HtmlDetails.Serializers'>HTML Serializers</a></p>
			<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-marshall.HtmlDetails.Parsers'>HTML Parsers</a></p>
			<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-marshall.HtmlDetails.HtmlAnnotation'>@Html Annotation</a></p>
			<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-marshall.HtmlDetails.HtmlRenderAnnotation'>@Html(render) Annotation</a></p>
			<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-marshall.HtmlDetails.HtmlDocSerializer'>HtmlDocSerializer</a></p>
			<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-marshall.HtmlDetails.BasicHtmlDocTemplate'>BasicHtmlDocTemplate</a></p>
			<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-marshall.HtmlDetails.CustomTemplates'>Custom Templates</a></p>
			<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-marshall.HtmlDetails.HtmlSchema'>HTML-Schema Support</a></p>
		</ol>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-marshall.UonDetails'>UON Details</a></p>
		<ol>
			<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-marshall.UonDetails.Methodology'>UON Methodology</a></p>
			<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-marshall.UonDetails.Serializers'>UON Serializers</a></p>
			<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-marshall.UonDetails.Parsers'>UON Parsers</a></p>
		</ol>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-marshall.UrlEncodingDetails'>URL-Encoding Details</a></p>
		<ol>
			<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-marshall.UrlEncodingDetails.Methodology'>URL-Encoding Methodology</a></p>
			<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-marshall.UrlEncodingDetails.Serializers'>URL-Encoding Serializers</a></p>
			<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-marshall.UrlEncodingDetails.Parsers'>URL-Encoding Parsers</a></p>
			<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-marshall.UrlEncodingDetails.UrlEncodingAnnotation'>@UrlEncoding Annotation</a></p>
		</ol>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-marshall.MsgPackDetails'>MessagePack Details</a></p>
		<ol>
			<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-marshall.MsgPackDetails.Serializers'>MessagePack Serializers</a></p>
			<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-marshall.MsgPackDetails.Parsers'>MessagePack Parsers</a></p>
		</ol>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-marshall.OpenApiDetails'>OpenAPI Details</a></p>
		<ol>
			<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-marshall.OpenApiDetails.Methodology'>OpenAPI Methodology</a></p>
			<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-marshall.OpenApiDetails.Serializers'>OpenAPI Serializers</a></p>
			<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-marshall.OpenApiDetails.Parsers'>OpenAPI Parsers</a></p>
		</ol>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-marshall.BestPractices'>Best Practices</a></p>
	</ol>
	<li><p class='toc2'><a class='doclink' href='{OVERVIEW_URL}#juneau-marshall-rdf'>juneau-marshall-rdf</a></p>
	<ol>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-marshall-rdf.RdfDetails'>RDF Details</a></p>
		<ol>
			<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-marshall-rdf.RdfDetails.Serializers'>RDF Serializers</a></p>
			<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-marshall-rdf.RdfDetails.Parsers'>RDF Parsers</a></p>
			<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-marshall-rdf.RdfDetails.RdfAnnotation'>@Rdf Annotation</a></p>
			<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-marshall-rdf.RdfDetails.Namespaces'>Namespaces</a></p>
			<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-marshall-rdf.RdfDetails.UriProperties'>URI Properties</a></p>
			<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-marshall-rdf.RdfDetails.RootProperty'>Root Property</a></p>
			<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-marshall-rdf.RdfDetails.TypedLiterals'>Typed Literals</a></p>
		</ol>
	</ol>
	<li><p class='toc2'><a class='doclink' href='{OVERVIEW_URL}#juneau-dto'>juneau-dto</a></p>
	<ol>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-dto.HTML5'>HTML5</a></p>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-dto.Atom'>Atom</a></p>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-dto.Swagger'>Swagger</a></p>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-dto.SwaggerUI'>Swagger UI</a></p>
	</ol>
	<li><p class='toc2'><a class='doclink' href='{OVERVIEW_URL}#juneau-svl'>juneau-svl</a></p>
	<ol>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-svl.SimpleVarLanguage'>Simple Variable Language</a></p>
		<li><p class='updated'><a class='doclink' href='{OVERVIEW_URL}#juneau-svl.SvlVariables'>SVL Variables</a></p>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-svl.VarResolvers'>VarResolvers and VarResolverSessions</a></p>
		<li><p class='new'><a class='doclink' href='{OVERVIEW_URL}#juneau-svl.DefaultVarResolver'>VarResolver.DEFAULT</a></p>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-svl.OtherNotes'>Other Notes</a></p>
	</ol>
	<li><p class='toc2'><a class='doclink' href='{OVERVIEW_URL}#juneau-config'>juneau-config</a></p>
	<ol>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-config.Overview'>Overview</a></p>
		<ol>
			<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-config.Overview.SyntaxRules'>Syntax Rules</a></p>
		</ol>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-config.EntryTypes'>Entry Types</a></p>
		<ol>
			<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-config.EntryTypes.PrimitiveTypes'>Primitive Types</a></p>
			<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-config.EntryTypes.POJOs'>POJOs</a></p>
			<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-config.EntryTypes.Arrays'>Arrays</a></p>
			<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-config.EntryTypes.Collections'>Collections</a></p>
			<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-config.EntryTypes.BinaryData'>Binary Data</a></p>
		</ol>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-config.Variables'>Variables</a></p>
		<ol>
			<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-config.Variables.LogicVariables'>Logic Variables</a></p>
		</ol>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-config.EncodedEntries'>Encoded Entries</a></p>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-config.SectionMaps'>Section Maps</a></p>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-config.SectionBeans'>Section Beans</a></p>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-config.SectionInterfaces'>Section Interfaces</a></p>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-config.SettingValues'>Setting Values</a></p>
		<ol>
			<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-config.SettingValues.FileSystemChanges'>File System Changes</a></p>
			<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-config.SettingValues.CustomEntrySerialization'>Custom Entry Serialization</a></p>
			<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-config.SettingValues.BulkSettingValues'>Setting Values in Bulk</a></p>
		</ol>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-config.Listeners'>Listeners</a></p>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-config.Serializing'>Serializing</a></p>
		<li><p class='new'><a class='doclink' href='{OVERVIEW_URL}#juneau-config.Imports'>Imports</a></p>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-config.ConfigStores'>Config Stores</a></p>
		<ol>
			<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-config.ConfigStores.ConfigMemoryStore'>ConfigMemoryStore</a></p>
			<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-config.ConfigStores.ConfigFileStore'>ConfigFileStore</a></p>
			<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-config.ConfigStores.CustomConfigStores'>Custom ConfigStores</a></p>
			<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-config.ConfigStores.ConfigStoreListeners'>ConfigStore Listeners</a></p>
		</ol>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-config.ReadOnlyConfigs'>Read-only Configs</a></p>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-config.ClosingConfigs'>Closing Configs</a></p>
		<li><p class='updated'><a class='doclink' href='{OVERVIEW_URL}#juneau-config.SystemDefaultConfig'>System Default Config</a></p>
	</ol>
	<li><p class='toc2'><a class='doclink' href='{OVERVIEW_URL}#juneau-rest-server'>juneau-rest-server</a></p>
	<ol>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-rest-server.HelloWorldExample'>Hello World Example</a></p>
		<li><p class='updated'><a class='doclink' href='{OVERVIEW_URL}#juneau-rest-server.ClassHierarchy'>Class Hierarchy</a></p>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-rest-server.Instantiation'>Instantiation</a></p>
		<ol>
			<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-rest-server.Instantiation.RestServlet'>RestServlet</a></p>
			<li><p class='updated'><a class='doclink' href='{OVERVIEW_URL}#juneau-rest-server.Instantiation.BasicRestServlet'>BasicRestServlet</a></p>
			<li><p class='new'><a class='doclink' href='{OVERVIEW_URL}#juneau-rest-server.Instantiation.BasicRest'>BasicRest</a></p>
			<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-rest-server.Instantiation.Children'>Children</a></p>
			<li><p class='updated'><a class='doclink' href='{OVERVIEW_URL}#juneau-rest-server.Instantiation.BasicRestServletGroup'>BasicRestServletGroup</a></p>
			<li><p class='new'><a class='doclink' href='{OVERVIEW_URL}#juneau-rest-server.Instantiation.BasicRestGroup'>BasicRestGroup</a></p>
			<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-rest-server.Instantiation.ResourceResolvers'>Resource Resolvers</a></p>
			<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-rest-server.Instantiation.LifecycleHooks'>Lifecycle Hooks</a></p>
		</ol>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-rest-server.RestResource'>@RestResource</a></p>
		<ol>
			<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-rest-server.RestResource.AnnotationInheritance'>Annotation Inheritance</a></p>
			<li><p class='new'><a class='doclink' href='{OVERVIEW_URL}#juneau-rest-server.RestResource.RestResourcePath'>@RestResource(path)</a></p>
		</ol>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-rest-server.RestContext'>RestContext</a></p>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-rest-server.RestMethod'>@RestMethod</a></p>
		<ol>
			<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-rest-server.RestMethod.MethodParameters'>Java Method Parameters</a></p>
			<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-rest-server.RestMethod.RestRequest'>RestRequest</a></p>
			<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-rest-server.RestMethod.RestResponse'>RestResponse</a></p>
			<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-rest-server.RestMethod.RequestBody'>RequestBody</a></p>
			<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-rest-server.RestMethod.RequestHeaders'>RequestHeaders</a></p>
			<li><p class='new'><a class='doclink' href='{OVERVIEW_URL}#juneau-rest-server.RestMethod.RequestAttributes'>RequestAttributes</a></p>
			<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-rest-server.RestMethod.RequestQuery'>RequestQuery</a></p>
			<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-rest-server.RestMethod.RequestFormData'>RequestFormData</a></p>
			<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-rest-server.RestMethod.RestMethodPath'>@RestMethod(path)</a></p>
			<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-rest-server.RestMethod.RequestPathMatch'>RequestPathMatch</a></p>
			<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-rest-server.RestMethod.MethodReturnTypes'>Method Return Types</a></p>
			<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-rest-server.RestMethod.ReaderResource'>ReaderResource</a></p>
			<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-rest-server.RestMethod.StreamResource'>StreamResource</a></p>
			<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-rest-server.RestMethod.RestMethodMatchers'>@RestMethod(matchers)</a></p>
			<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-rest-server.RestMethod.PredefinedResponses'>Predefined Responses</a></p>
			<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-rest-server.RestMethod.PredefinedExceptions'>Predefined Exceptions</a></p>
			<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-rest-server.RestMethod.PredefinedHelperBeans'>Predefined Helper Beans</a></p>
		</ol>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-rest-server.restRPC'>restRPC</a></p>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-rest-server.OpenApiSchemaPartParsing'>OpenAPI Schema Part Parsing</a></p>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-rest-server.OpenApiSchemaPartSerializing'>OpenAPI Schema Part Serializing</a></p>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-rest-server.HttpPartAnnotations'>HTTP-Part Annotations</a></p>
		<ol>
			<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-rest-server.HttpPartAnnotations.Body'>@Body</a></p>
			<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-rest-server.HttpPartAnnotations.FormData'>@FormData</a></p>
			<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-rest-server.HttpPartAnnotations.HasFormData'>@HasFormData</a></p>
			<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-rest-server.HttpPartAnnotations.Query'>@Query</a></p>
			<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-rest-server.HttpPartAnnotations.HasQuery'>@HasQuery</a></p>
			<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-rest-server.HttpPartAnnotations.Header'>@Header</a></p>
			<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-rest-server.HttpPartAnnotations.Path'>@Path</a></p>
			<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-rest-server.HttpPartAnnotations.Request'>@Request</a></p>
			<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-rest-server.HttpPartAnnotations.Response'>@Response</a></p>
			<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-rest-server.HttpPartAnnotations.ResponseHeader'>@ResponseHeader</a></p>
			<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-rest-server.HttpPartAnnotations.ResponseStatus'>@ResponseStatus</a></p>
		</ol>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-rest-server.HandlingFormPosts'>Handling Form Posts</a></p>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-rest-server.HandlingMultiPartFormPosts'>Handling Multi-Part Form Posts</a></p>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-rest-server.Serializers'>Serializers</a></p>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-rest-server.Parsers'>Parsers</a></p>
		<li><p class='updated'><a class='doclink' href='{OVERVIEW_URL}#juneau-rest-server.ConfigurableProperties'>Configurable Properties</a></p>
		<li><p class='new'><a class='doclink' href='{OVERVIEW_URL}#juneau-rest-server.ConfigurableAnnotations'>Configurable Annotations</a></p>
		<li><p class='updated'><a class='doclink' href='{OVERVIEW_URL}#juneau-rest-server.Transforms'>Transforms</a></p>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-rest-server.URIs'>URIs</a></p>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-rest-server.Guards'>Guards</a></p>
		<li><p class='new'><a class='doclink' href='{OVERVIEW_URL}#juneau-rest-server.RoleGuards'>Role guards</a></p>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-rest-server.Converters'>Converters</a></p>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-rest-server.Messages'>Messages</a></p>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-rest-server.Encoders'>Encoders</a></p>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-rest-server.SvlVariables'>SVL Variables</a></p>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-rest-server.ConfigurationFiles'>Configuration Files</a></p>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-rest-server.StaticFiles'>Static files</a></p>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-rest-server.ClientVersioning'>Client Versioning</a></p>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-rest-server.RestInfoProvider'>RestInfoProvider</a></p>
		<ol>
			<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-rest-server.RestInfoProvider.BasicRestInfoProvider'>BasicRestInfoProvider</a></p>
		</ol>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-rest-server.Swagger'>Swagger</a></p>
		<ol>
			<li><p class='updated'><a class='doclink' href='{OVERVIEW_URL}#juneau-rest-server.Swagger.BasicRestServlet'>BasicRestServlet</a></p>
			<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-rest-server.Swagger.BasicSwaggerInfo'>Basic Swagger Info</a></p>
			<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-rest-server.Swagger.Tags'>Tags</a></p>
			<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-rest-server.Swagger.Operations'>Operations</a></p>
			<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-rest-server.Swagger.Parameters'>Parameters</a></p>
			<li><p class='updated'><a class='doclink' href='{OVERVIEW_URL}#juneau-rest-server.Swagger.ParameterExamples'>Parameter Examples</a></p>
			<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-rest-server.Swagger.Responses'>Responses</a></p>
			<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-rest-server.Swagger.ResponseExamples'>Response Examples</a></p>
			<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-rest-server.Swagger.Models'>Models</a></p>
			<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-rest-server.Swagger.Stylesheet'>SwaggerUI.css</a></p>
		</ol>
		<li><p class='updated'><a class='doclink' href='{OVERVIEW_URL}#juneau-rest-server.HtmlDocAnnotation'>@HtmlDocConfig</a></p>
		<ol>
			<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-rest-server.HtmlDocAnnotation.UIvsDI'>User Interfaces (UI) vs. Developer Interfaces (DI)</a></p>
			<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-rest-server.HtmlDocAnnotation.Widgets'>Widgets</a></p>
			<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-rest-server.HtmlDocAnnotation.PredefinedWidgets'>Predefined Widgets</a></p>
			<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-rest-server.HtmlDocAnnotation.UiCustomization'>UI Customization</a></p>
			<li><p class='updated'><a class='doclink' href='{OVERVIEW_URL}#juneau-rest-server.HtmlDocAnnotation.Stylesheets'>Stylesheets</a></p>
		</ol>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-rest-server.DefaultHeaders'>Default Headers</a></p>
		<li><p class='new'><a class='doclink' href='{OVERVIEW_URL}#juneau-rest-server.LoggingAndDebugging'>Logging / Debugging</a></p>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-rest-server.HttpStatusCodes'>HTTP Status Codes</a></p>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-rest-server.OverloadingHttpMethods'>Overloading HTTP Methods</a></p>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-rest-server.BuiltInParameters'>Built-in Parameters</a></p>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-rest-server.CustomSerializersAndParsers'>Custom Serializers and Parsers</a></p>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-rest-server.UsingWithOsgi'>Using with OSGi</a></p>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-rest-server.Injection'>Using with Spring and Injection frameworks</a></p>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-rest-server.HTTP2'>Using HTTP/2 features</a></p>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-rest-server.OtherNotes'>Other Notes</a></p>
	</ol>
	<li><p class='toc2'><a class='doclink' href='{OVERVIEW_URL}#juneau-rest-server-jaxrs'>juneau-rest-server-jaxrs</a></p>
	<ol>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-rest-server-jaxrs.BaseProvider'>Juneau JAX-RS Provider</a></p>
	</ol>
	<li><p class='toc2'><a class='doclink' href='{OVERVIEW_URL}#juneau-rest-server-springboot'>juneau-rest-server-springboot</a></p>
	<ol>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-rest-server-springboot.Overview'>Overview</a></p>
		<li><p class='new'><a class='doclink' href='{OVERVIEW_URL}#juneau-rest-server-springboot.ChildResources'>Child Resources</a></p>
	</ol>
	<li><p class='toc2'><a class='doclink' href='{OVERVIEW_URL}#juneau-rest-client'>juneau-rest-client</a></p>
	<ol>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-rest-client.RestProxies'>REST Proxies</a></p>
		<ol>
			<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-rest-client.RestProxies.RemoteResource'>@RemoteResource</a></p>
			<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-rest-client.RestProxies.RemoteMethod'>@RemoteMethod</a></p>
			<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-rest-client.RestProxies.Body'>@Body</a></p>
			<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-rest-client.RestProxies.FormData'>@FormData</a></p>
			<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-rest-client.RestProxies.Query'>@Query</a></p>
			<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-rest-client.RestProxies.Header'>@Header</a></p>
			<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-rest-client.RestProxies.Path'>@Path</a></p>
			<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-rest-client.RestProxies.Request'>@Request</a></p>
			<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-rest-client.RestProxies.Response'>@Response</a></p>
			<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-rest-client.RestProxies.DualPurposeInterfaces'>Dual-purpose (end-to-end) interfaces</a></p>
		</ol>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-rest-client.SSL'>SSL Support</a></p>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-rest-client.Authentication'>Authentication</a></p>
		<ol>
			<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-rest-client.Authentication.BASIC'>BASIC Authentication</a></p>
			<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-rest-client.Authentication.FORM'>FORM-based Authentication</a></p>
			<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-rest-client.Authentication.OIDC'>OIDC Authentication</a></p>
		</ol>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-rest-client.ResponsePatterns'>Using Response Patterns</a></p>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-rest-client.PipingOutput'>Piping Response Output</a></p>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-rest-client.Debugging'>Debugging</a></p>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-rest-client.Logging'>Logging</a></p>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-rest-client.Interceptors'>Interceptors</a></p>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-rest-client.Other'>Other Useful Methods</a></p>
	</ol>
	<li><p class='new'><a class='doclink' href='{OVERVIEW_URL}#juneau-rest-mock'>juneau-rest-mock</a></p>
	<ol>
		<li><p class='new'><a class='doclink' href='{OVERVIEW_URL}#juneau-rest-mock.MockRest'>MockRest</a></p>
		<li><p class='new'><a class='doclink' href='{OVERVIEW_URL}#juneau-rest-mock.MockRemoteResource'>MockRemoteResource</a></p>
	</ol>
	<li><p class='toc2'><a class='doclink' href='{OVERVIEW_URL}#juneau-microservice-core'>juneau-microservice-core</a></p>
	<ol>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-microservice-core.Overview'>Microservice Overview</a></p>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-microservice-core.LifecycleMethods'>Lifecycle Methods</a></p>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-microservice-core.Args'>Args</a></p>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-microservice-core.Manifest'>Manifest</a></p>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-microservice-core.Config'>Config</a></p>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-microservice-core.SystemProperties'>System properties</a></p>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-microservice-core.VarResolver'>VarResolver</a></p>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-microservice-core.ConsoleCommands'>Console Commands</a></p>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-microservice-core.Logging'>Logging</a></p>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-microservice-core.Listeners'>Listeners</a></p>
	</ol>
	<li><p class='toc2'><a class='doclink' href='{OVERVIEW_URL}#juneau-microservice-jetty'>juneau-microservice-jetty</a></p>
	<ol>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-microservice-jetty.Overview'>Overview</a></p>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-microservice-jetty.LifecycleMethods'>Lifecycle Methods</a></p>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-microservice-jetty.ResourceClasses'>Resource Classes</a></p>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-microservice-jetty.PredefinedResourceClasses'>Predefined Resource Classes</a></p>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-microservice-jetty.Config'>Config</a></p>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-microservice-jetty.JettyXml'>Jetty.xml file</a></p>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-microservice-jetty.UiCustomization'>UI Customization</a></p>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-microservice-jetty.Extending'>Extending JettyMicroservice</a></p>
	</ol>
	<li><p class='toc2'><a class='doclink' href='{OVERVIEW_URL}#my-jetty-microservice'>my-jetty-microservice</a></p>
	<ol>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#my-jetty-microservice.Installing'>Installing in Eclipse</a></p>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#my-jetty-microservice.Running'>Running in Eclipse</a></p>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#my-jetty-microservice.Building'>Building and Running from Command-Line</a></p>
	</ol>
	<li><p class='toc2'><a class='doclink' href='{OVERVIEW_URL}#my-springboot-microservice'>my-springboot-microservice</a></p>
	<ol>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#my-springboot-microservice.Installing'>Installing in Eclipse</a></p>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#my-springboot-microservice.Running'>Running in Eclipse</a></p>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#my-springboot-microservice.Building'>Building and Running from Command-Line</a></p>
	</ol>
	<li><p class='toc2'><a class='doclink' href='{OVERVIEW_URL}#juneau-examples-core'>juneau-examples-core</a></p>
	<ol>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-examples-core.Installing'>Installing in Eclipse</a></p>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-examples-core.Examples'>Examples</a></p>
	</ol>
	<li><p class='toc2'><a class='doclink' href='{OVERVIEW_URL}#juneau-examples-rest'>juneau-examples-rest</a></p>
	<ol>
		<li><p class='updated'><a class='doclink' href='{OVERVIEW_URL}#juneau-examples-rest.RootResources'>RootResources</a></p>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-examples-rest.HelloWorldResource'>HelloWorldResource</a></p>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-examples-rest.PetStoreResource'>PetStore</a></p>
		<li><p class='updated'><a class='doclink' href='{OVERVIEW_URL}#juneau-examples-rest.DtoExamples'>DtoExamples</a></p>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-examples-rest.ConfigResource'>ConfigResource</a></p>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-examples-rest.LogsResource'>LogsResource</a></p>
	</ol>
	<li><p class='toc2'><a class='doclink' href='{OVERVIEW_URL}#juneau-examples-rest-jetty'>juneau-examples-rest-jetty</a></p>
	<ol>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-examples-rest-jetty.Installing'>Installing in Eclipse</a></p>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-examples-rest-jetty.Running'>Running in Eclipse</a></p>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-examples-rest-jetty.Building'>Building and Running from Command-Line</a></p>
	</ol>
	<li><p class='toc2'><a class='doclink' href='{OVERVIEW_URL}#juneau-examples-rest-springboot'>juneau-examples-rest-springboot</a></p>
	<ol>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-examples-rest-springboot.Installing'>Installing in Eclipse</a></p>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-examples-rest-springboot.Running'>Running in Eclipse</a></p>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-examples-rest-springboot.Building'>Building and Running from Command-Line</a></p>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#juneau-examples-rest-springboot.DeployingToHeroku'>Deploying to Heroku</a></p>
	</ol>
	<li><p class='toc2'><a class='doclink' href='{OVERVIEW_URL}#Security'>Security Best-Practices</a></p>
	<ol>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#Security.juneau-marshall'>juneau-marshall</a></p>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#Security.juneau-svl'>juneau-svl</a></p>
		<li><p class=''><a class='doclink' href='{OVERVIEW_URL}#Security.juneau-rest-server'>juneau-rest-server</a></p>
	</ol>
</ol>
