<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<!-- NewPage -->
<html lang="en">
<head>
<!-- Generated by javadoc (1.8.0_281) on Sun Jan 15 15:58:36 CET 2023 -->
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>freemarker.ext.beans (FreeMarker 2.3.32 API)</title>
<meta name="date" content="2023-01-15">
<link rel="stylesheet" type="text/css" href="../../../stylesheet.css" title="Style">
<script type="text/javascript" src="../../../script.js"></script>
</head>
<body>
<h1 class="bar"><a href="../../../freemarker/ext/beans/package-summary.html" target="classFrame">freemarker.ext.beans</a></h1>
<div class="indexContainer">
<h2 title="Interfaces">Interfaces</h2>
<ul title="Interfaces">
<li><a href="AdhocTestMultimap.html" title="interface in freemarker.ext.beans" target="classFrame"><span class="interfaceName">AdhocTestMultimap</span></a></li>
<li><a href="ClassMemberAccessPolicy.html" title="interface in freemarker.ext.beans" target="classFrame"><span class="interfaceName">ClassMemberAccessPolicy</span></a></li>
<li><a href="MemberAccessPolicy.html" title="interface in freemarker.ext.beans" target="classFrame"><span class="interfaceName">MemberAccessPolicy</span></a></li>
<li><a href="MethodAppearanceFineTuner.html" title="interface in freemarker.ext.beans" target="classFrame"><span class="interfaceName">MethodAppearanceFineTuner</span></a></li>
<li><a href="SingletonCustomizer.html" title="interface in freemarker.ext.beans" target="classFrame"><span class="interfaceName">SingletonCustomizer</span></a></li>
</ul>
<h2 title="Classes">Classes</h2>
<ul title="Classes">
<li><a href="AdhocTest2.html" title="class in freemarker.ext.beans" target="classFrame">AdhocTest2</a></li>
<li><a href="AdhocTest3.html" title="class in freemarker.ext.beans" target="classFrame">AdhocTest3</a></li>
<li><a href="ArrayModel.html" title="class in freemarker.ext.beans" target="classFrame">ArrayModel</a></li>
<li><a href="BeanModel.html" title="class in freemarker.ext.beans" target="classFrame">BeanModel</a></li>
<li><a href="BeansModelCache.html" title="class in freemarker.ext.beans" target="classFrame">BeansModelCache</a></li>
<li><a href="BeansWrapper.html" title="class in freemarker.ext.beans" target="classFrame">BeansWrapper</a></li>
<li><a href="BeansWrapper.MethodAppearanceDecision.html" title="class in freemarker.ext.beans" target="classFrame">BeansWrapper.MethodAppearanceDecision</a></li>
<li><a href="BeansWrapper.MethodAppearanceDecisionInput.html" title="class in freemarker.ext.beans" target="classFrame">BeansWrapper.MethodAppearanceDecisionInput</a></li>
<li><a href="BeansWrapperBuilder.html" title="class in freemarker.ext.beans" target="classFrame">BeansWrapperBuilder</a></li>
<li><a href="BeansWrapperConfiguration.html" title="class in freemarker.ext.beans" target="classFrame">BeansWrapperConfiguration</a></li>
<li><a href="BlacklistMemberAccessPolicy.html" title="class in freemarker.ext.beans" target="classFrame">BlacklistMemberAccessPolicy</a></li>
<li><a href="BooleanModel.html" title="class in freemarker.ext.beans" target="classFrame">BooleanModel</a></li>
<li><a href="CollectionModel.html" title="class in freemarker.ext.beans" target="classFrame">CollectionModel</a></li>
<li><a href="DateModel.html" title="class in freemarker.ext.beans" target="classFrame">DateModel</a></li>
<li><a href="DefaultMemberAccessPolicy.html" title="class in freemarker.ext.beans" target="classFrame">DefaultMemberAccessPolicy</a></li>
<li><a href="EnumerationModel.html" title="class in freemarker.ext.beans" target="classFrame">EnumerationModel</a></li>
<li><a href="HashAdapter.html" title="class in freemarker.ext.beans" target="classFrame">HashAdapter</a></li>
<li><a href="IteratorModel.html" title="class in freemarker.ext.beans" target="classFrame">IteratorModel</a></li>
<li><a href="LegacyDefaultMemberAccessPolicy.html" title="class in freemarker.ext.beans" target="classFrame">LegacyDefaultMemberAccessPolicy</a></li>
<li><a href="MapModel.html" title="class in freemarker.ext.beans" target="classFrame">MapModel</a></li>
<li><a href="MemberSelectorListMemberAccessPolicy.html" title="class in freemarker.ext.beans" target="classFrame">MemberSelectorListMemberAccessPolicy</a></li>
<li><a href="MemberSelectorListMemberAccessPolicy.MemberSelector.html" title="class in freemarker.ext.beans" target="classFrame">MemberSelectorListMemberAccessPolicy.MemberSelector</a></li>
<li><a href="NumberModel.html" title="class in freemarker.ext.beans" target="classFrame">NumberModel</a></li>
<li><a href="OverloadedMethodsModel.html" title="class in freemarker.ext.beans" target="classFrame">OverloadedMethodsModel</a></li>
<li><a href="ResourceBundleModel.html" title="class in freemarker.ext.beans" target="classFrame">ResourceBundleModel</a></li>
<li><a href="SimpleMapModel.html" title="class in freemarker.ext.beans" target="classFrame">SimpleMapModel</a></li>
<li><a href="SimpleMethodModel.html" title="class in freemarker.ext.beans" target="classFrame">SimpleMethodModel</a></li>
<li><a href="StringModel.html" title="class in freemarker.ext.beans" target="classFrame">StringModel</a></li>
<li><a href="WhitelistMemberAccessPolicy.html" title="class in freemarker.ext.beans" target="classFrame">WhitelistMemberAccessPolicy</a></li>
</ul>
<h2 title="Exceptions">Exceptions</h2>
<ul title="Exceptions">
<li><a href="InvalidPropertyException.html" title="class in freemarker.ext.beans" target="classFrame">InvalidPropertyException</a></li>
</ul>
<h2 title="Annotation Types">Annotation Types</h2>
<ul title="Annotation Types">
<li><a href="TemplateAccessible.html" title="annotation in freemarker.ext.beans" target="classFrame">TemplateAccessible</a></li>
</ul>
</div>
</body>
</html>
