<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
	<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1" />
	<title>Package overview</title>
</head>

<body>
	<p>Package containing the option classes.</p>
	<p>These are used to configure diverse function calls of xmpcore:<p>
	<ul>
		<li>PropertyOptions - these are used to create properties and also to retrieve information about simple, array or struct properties, as well as qualifiers
		<li>ParseOptions - used to configure the parsing of xmp metadata packets
		<li>SerializationOptions - used to control the serialization of xmp metadata packets
		<li>AliasOptions - used by XMPSchemaRegistry#registerAlias()
		<li>IteratorOptions - used to set up an XMPIterator
		<li>Options - the base class of all option classes
	</ul>
</body>
</html>
