@sitevision/api 2.0.0-alpha.1 → 2.0.0-alpha.2

package/types/javax/jcr/nodetype/NodeTypeDefinition/index.d.ts

@@ -1,5 +1,5 @@
-import type { PropertyDefinition } from "../PropertyDefinition";
-import type { NodeDefinition } from "../NodeDefinition";
+import type PropertyDefinition from "../PropertyDefinition";
+import type NodeDefinition from "../NodeDefinition";
 
 /**
  * The <code>NodeTypeDefinition</code> interface provides methods for
@@ -14,7 +14,7 @@ import type { NodeDefinition } from "../NodeDefinition";
  * implementing the subinterface <code>NodeType</code> will be encountered.
  * @since JCR 2.0
  */
-export type NodeTypeDefinition = {
+type NodeTypeDefinition = {
   /**
    * Returns the name of the node type.
    * <p>
@@ -27,19 +27,6 @@ export type NodeTypeDefinition = {
    */
   getName(): string;
 
-  /**
-   * Returns the names of the supertypes actually declared in this node type.
-   * <p>
-   * In implementations that support node type registration, if this
-   * <code>NodeTypeDefinition</code> object is actually a newly-created empty
-   * <code>NodeTypeTemplate</code>, then this method will return an empty array.
-   *
-   * <p><strong>Sitevision note:</strong> Unsupported operation</p>
-   * @return an array of <code>String</code>s
-   * @since JCR 2.0
-   */
-  getDeclaredSupertypeNames(): string;
-
   /**
    * Returns <code>true</code> if this is an abstract node type; returns
    * <code>false</code> otherwise.
@@ -69,95 +56,6 @@ export type NodeTypeDefinition = {
    * @since JCR 2.0 moved here from JCR 1.0 <code>NodeType</code>.
    */
   isMixin(): boolean;
-
-  /**
-   * Returns <code>true</code> if nodes of this type must support orderable
-   * child nodes; returns <code>false</code> otherwise. If a node type returns
-   * <code>true</code> on a call to this method, then all nodes of that node
-   * type <i>must</i> support the method <code>Node.orderBefore</code>. If a
-   * node type returns <code>false</code> on a call to this method, then nodes
-   * of that node type <i>may</i> support <code>Node.orderBefore</code>. Only
-   * the primary node type of a node controls that node's status in this
-   * regard. This setting on a mixin node type will not have any effect on the
-   * node.
-   * <p>
-   * In implementations that support node type registration, if this
-   * <code>NodeTypeDefinition</code> object is actually a newly-created empty
-   * <code>NodeTypeTemplate</code>, then this method will return
-   * <code>false</code>.
-   *
-   * <p><strong>Sitevision note:</strong> Unsupported operation</p>
-   * @return a <code>boolean</code>
-   * @since JCR 2.0 moved here from JCR 1.0 <code>NodeType</code>.
-   */
-  hasOrderableChildNodes(): boolean;
-
-  /**
-   * Returns <code>true</code> if the node type is queryable, meaning that the
-   * available-query-operators, full-text-searchable and query-orderable
-   * attributes of its property definitions take effect. See {@link
-   * javax.jcr.nodetype.PropertyDefinition#getAvailableQueryOperators()},
-   * {@link javax.jcr.nodetype.PropertyDefinition#isFullTextSearchable()} and
-   * {@link javax.jcr.nodetype.PropertyDefinition#isQueryOrderable()}.
-   * <p>
-   * If a node type is declared non-queryable then these attributes of its
-   * property definitions have no effect.
-   * <p>
-   * In implementations that support node type registration, if this
-   * <code>NodeTypeDefinition</code> object is actually a newly-created empty
-   * <code>NodeTypeTemplate</code>, then this method will return
-   * an implementation-determined defalt value.
-   *
-   * <p><strong>Sitevision note:</strong> Unsupported operation</p>
-   * @return a <code>boolean</code>
-   * @since JCR 2.0
-   */
-  isQueryable(): boolean;
-
-  /**
-   * Returns the name of the primary item (one of the child items of the nodes
-   * of this node type). If this node has no primary item, then this method
-   * returns <code>null</code>. This indicator is used by the method
-   * <code>Node.getPrimaryItem()</code>.
-   * <p>
-   * In implementations that support node type registration, if this
-   * <code>NodeTypeDefinition</code> object is actually a newly-created empty
-   * <code>NodeTypeTemplate</code>, then this method will return
-   * <code>null</code>.
-   *
-   * <p><strong>Sitevision note:</strong> Unsupported operation</p>
-   * @return a <code>String</code>
-   * @since JCR 2.0 moved here from JCR 1.0 <code>NodeType</code>.
-   */
-  getPrimaryItemName(): string;
-
-  /**
-   * Returns an array containing the property definitions actually declared in
-   * this node type.
-   * <p>
-   * In implementations that support node type registration, if this
-   * <code>NodeTypeDefinition</code> object is actually a newly-created empty
-   * <code>NodeTypeTemplate</code>, then this method will return
-   * <code>null</code>.
-   *
-   * <p><strong>Sitevision note:</strong> Unsupported operation</p>
-   * @return an array of <code>PropertyDefinition</code>s
-   * @since JCR 2.0 moved here from JCR 1.0 <code>NodeType</code>.
-   */
-  getDeclaredPropertyDefinitions(): PropertyDefinition;
-
-  /**
-   * Returns an array containing the child node definitions actually declared
-   * in this node type.
-   * <p>
-   * In implementations that support node type registration, if this
-   * <code>NodeTypeDefinition</code> object is actually a newly-created empty
-   * <code>NodeTypeTemplate</code>, then this method will return
-   * <code>null</code>.
-   *
-   * <p><strong>Sitevision note:</strong> Unsupported operation</p>
-   * @return an array of <code>NodeDefinition</code>s
-   * @since JCR 2.0 moved here from JCR 1.0 <code>NodeType</code>.
-   */
-  getDeclaredChildNodeDefinitions(): NodeDefinition;
 };
+
+export = NodeTypeDefinition;

package/types/javax/jcr/nodetype/NodeTypeDefinition/index.js

@@ -6,13 +6,7 @@ Object.defineProperty(exports, "__esModule", {
 exports["default"] = void 0;
 var _default = {
   getName: function getName() {},
-  getDeclaredSupertypeNames: function getDeclaredSupertypeNames() {},
   isAbstract: function isAbstract() {},
-  isMixin: function isMixin() {},
-  hasOrderableChildNodes: function hasOrderableChildNodes() {},
-  isQueryable: function isQueryable() {},
-  getPrimaryItemName: function getPrimaryItemName() {},
-  getDeclaredPropertyDefinitions: function getDeclaredPropertyDefinitions() {},
-  getDeclaredChildNodeDefinitions: function getDeclaredChildNodeDefinitions() {}
+  isMixin: function isMixin() {}
 };
 exports["default"] = _default;

package/types/javax/jcr/nodetype/NodeTypeIterator/index.d.ts

@@ -1,11 +1,11 @@
-import type { NodeType } from "../NodeType";
-import type { RangeIterator } from "../../RangeIterator";
+import type NodeType from "../NodeType";
+import type RangeIterator from "../../RangeIterator";
 
 /**
  * An iterator for <code>NodeType</code> objects.
   
     */
-export type NodeTypeIterator = {
+type NodeTypeIterator = RangeIterator & {
   /**
    * Returns the next <code>NodeType</code> in the iteration.
    * @return the next <code>NodeType</code> in the iteration.
@@ -13,3 +13,5 @@ export type NodeTypeIterator = {
    */
   nextNodeType(): NodeType;
 };
+
+export = NodeTypeIterator;

package/types/javax/jcr/nodetype/NodeTypeManager/index.d.ts

@@ -1,17 +1,17 @@
-import type { NodeType } from "../NodeType";
+import type NodeType from "../NodeType";
 
-import type { NodeTypeIterator } from "../NodeTypeIterator";
-import type { NodeTypeTemplate } from "../NodeTypeTemplate";
-import type { NodeTypeDefinition } from "../NodeTypeDefinition";
-import type { NodeDefinitionTemplate } from "../NodeDefinitionTemplate";
-import type { PropertyDefinitionTemplate } from "../PropertyDefinitionTemplate";
+import type NodeTypeIterator from "../NodeTypeIterator";
+import type NodeTypeTemplate from "../NodeTypeTemplate";
+import type NodeTypeDefinition from "../NodeTypeDefinition";
+import type NodeDefinitionTemplate from "../NodeDefinitionTemplate";
+import type PropertyDefinitionTemplate from "../PropertyDefinitionTemplate";
 
 /**
  * Allows for the retrieval and (in implementations that support it) the
  * registration of node types. Accessed via {@link Workspace#getNodeTypeManager}.
   
     */
-export type NodeTypeManager = {
+type NodeTypeManager = {
   /**
    * Returns the named node type.
    * @param nodeTypeName the name of an existing node type.
@@ -52,127 +52,6 @@ export type NodeTypeManager = {
    * @throws RepositoryException if an error occurs.
    */
   getMixinNodeTypes(): NodeTypeIterator;
-
-  /**
-   * Returns an empty <code>NodeTypeTemplate</code> which can then be used to
-   * define a node type and passed to <code>NodeTypeManager.registerNodeType</code>.
-   *
-   * <p><strong>Sitevision note:</strong> Unsupported operation</p>
-   * @return A <code>NodeTypeTemplate</code>.
-   * @throws UnsupportedRepositoryOperationException if this implementation does not support node type registration.
-   * @throws RepositoryException if another error occurs.
-   * @since JCR 2.0
-   */
-  createNodeTypeTemplate(): NodeTypeTemplate;
-
-  /**
-   * Returns a <code>NodeTypeTemplate</code> holding the specified node type
-   * definition. This template can then be altered and passed to
-   * <code>NodeTypeManager.registerNodeType</code>.
-   *
-   * <p><strong>Sitevision note:</strong> Unsupported operation</p>
-   * @param ntd a <code>NodeTypeDefinition</code>.
-   * @return A <code>NodeTypeTemplate</code>.
-   * @throws UnsupportedRepositoryOperationException if this implementation does not support node type registration.
-   * @throws RepositoryException if another error occurs.
-   * @since JCR 2.0
-   */
-  createNodeTypeTemplate(ntd: NodeTypeDefinition): NodeTypeTemplate;
-
-  /**
-   * Returns an empty <code>NodeDefinitionTemplate</code> which can then be
-   * used to create a child node definition and attached to a
-   * <code>NodeTypeTemplate</code>.
-   *
-   * <p><strong>Sitevision note:</strong> Unsupported operation</p>
-   * @return A <code>NodeDefinitionTemplate</code>.
-   * @throws UnsupportedRepositoryOperationException if this implementation does not support node type registration.
-   * @throws RepositoryException if another error occurs.
-   * @since JCR 2.0
-   */
-  createNodeDefinitionTemplate(): NodeDefinitionTemplate;
-
-  /**
-   * Returns an empty <code>PropertyDefinitionTemplate</code> which can then
-   * be used to create a property definition and attached to a
-   * <code>NodeTypeTemplate</code>.
-   *
-   * <p><strong>Sitevision note:</strong> Unsupported operation</p>
-   * @return A <code>PropertyDefinitionTemplate</code>.
-   * @throws UnsupportedRepositoryOperationException if this implementation does not support node type registration.
-   * @throws RepositoryException if another error occurs.
-   * @since JCR 2.0
-   */
-  createPropertyDefinitionTemplate(): PropertyDefinitionTemplate;
-
-  /**
-   * Registers a new node type or updates an existing node type using the
-   * specified definition and returns the resulting <code>NodeType</code>
-   * object.
-   * <p>
-   * Typically, the object passed to this method will be a
-   * <code>NodeTypeTemplate</code> (a subclass of <code>NodeTypeDefinition</code>)
-   * acquired from <code>NodeTypeManager.createNodeTypeTemplate</code> and
-   * then filled-in with definition information.
-   *
-   * <p><strong>Sitevision note:</strong> Unsupported operation</p>
-   * @param ntd an <code>NodeTypeDefinition</code>.
-   * @param allowUpdate a boolean
-   * @return the registered node type
-   * @throws InvalidNodeTypeDefinitionException if the <code>NodeTypeDefinition</code> is invalid.
-   * @throws NodeTypeExistsException if <code>allowUpdate</code> is <code>false</code> and the <code>NodeTypeDefinition</code> specifies a node type name that is already registered.
-   * @throws UnsupportedRepositoryOperationException if this implementation does not support node type registration.
-   * @throws RepositoryException if another error occurs.
-   * @since JCR 2.0
-   */
-  registerNodeType(ntd: NodeTypeDefinition, allowUpdate: boolean): NodeType;
-
-  /**
-   * Registers or updates the specified array of <code>NodeTypeDefinition</code>
-   * objects. This method is used to register or update a set of node types
-   * with mutual dependencies. Returns an iterator over the resulting
-   * <code>NodeType</code> objects.
-   * <p>
-   * The effect of the method is "all or nothing"; if an error occurs, no node
-   * types are registered or updated.
-   *
-   * <p><strong>Sitevision note:</strong> Unsupported operation</p>
-   * @param ntds a collection of <code>NodeTypeDefinition</code>s
-   * @param allowUpdate a boolean
-   * @return the registered node types.
-   * @throws InvalidNodeTypeDefinitionException if a <code>NodeTypeDefinition</code> within the <code>Collection</code> is invalid or if the <code>Collection</code> contains an object of a type other than <code>NodeTypeDefinition</code>.
-   * @throws NodeTypeExistsException if <code>allowUpdate</code> is <code>false</code> and a <code>NodeTypeDefinition</code> within the <code>Collection</code> specifies a node type name that is already registered.
-   * @throws UnsupportedRepositoryOperationException if this implementation does not support node type registration.
-   * @throws RepositoryException if another error occurs.
-   * @since JCR 2.0
-   */
-  registerNodeTypes(
-    ntds: NodeTypeDefinition,
-    allowUpdate: boolean
-  ): NodeTypeIterator;
-
-  /**
-   * Unregisters the specified node type.
-   *
-   * <p><strong>Sitevision note:</strong> Unsupported operation</p>
-   * @param name a <code>String</code>.
-   * @throws UnsupportedRepositoryOperationException if this implementation does not support node type registration.
-   * @throws NoSuchNodeTypeException if no registered node type exists with the specified name.
-   * @throws RepositoryException if another error occurs.
-   * @since JCR 2.0
-   */
-  unregisterNodeType(name: string): void;
-
-  /**
-   * Unregisters the specified set of node types. Used to unregister a set of
-   * node types with mutual dependencies.
-   *
-   * <p><strong>Sitevision note:</strong> Unsupported operation</p>
-   * @param names a <code>String</code> array
-   * @throws UnsupportedRepositoryOperationException if this implementation does not support node type registration.
-   * @throws NoSuchNodeTypeException if one of the names listed is not a registered node type.
-   * @throws RepositoryException if another error occurs.
-   * @since JCR 2.0
-   */
-  unregisterNodeTypes(names: string): void;
 };
+
+export = NodeTypeManager;

package/types/javax/jcr/nodetype/NodeTypeManager/index.js

@@ -9,13 +9,6 @@ var _default = {
   hasNodeType: function hasNodeType() {},
   getAllNodeTypes: function getAllNodeTypes() {},
   getPrimaryNodeTypes: function getPrimaryNodeTypes() {},
-  getMixinNodeTypes: function getMixinNodeTypes() {},
-  createNodeTypeTemplate: function createNodeTypeTemplate() {},
-  createNodeDefinitionTemplate: function createNodeDefinitionTemplate() {},
-  createPropertyDefinitionTemplate: function createPropertyDefinitionTemplate() {},
-  registerNodeType: function registerNodeType() {},
-  registerNodeTypes: function registerNodeTypes() {},
-  unregisterNodeType: function unregisterNodeType() {},
-  unregisterNodeTypes: function unregisterNodeTypes() {}
+  getMixinNodeTypes: function getMixinNodeTypes() {}
 };
 exports["default"] = _default;

package/types/javax/jcr/nodetype/NodeTypeTemplate/index.d.ts

@@ -1,4 +1,4 @@
-import type { NodeTypeDefinition } from "../NodeTypeDefinition";
+import type NodeTypeDefinition from "../NodeTypeDefinition";
 
 /**
  * The <code>NodeTypeTemplate</code> interface is used to define node types which
@@ -18,7 +18,7 @@ import type { NodeTypeDefinition } from "../NodeTypeDefinition";
  * <p><strong>Sitevision note:</strong> Unsupported operation</p>
  * @since JCR 2.0
  */
-export type NodeTypeTemplate = {
+type NodeTypeTemplate = NodeTypeDefinition & {
   /**
    * Sets the name of the node type. This must be a JCR name in either
    * qualified or expanded form.
@@ -86,3 +86,5 @@ export type NodeTypeTemplate = {
    */
   getNodeDefinitionTemplates(): unknown;
 };
+
+export = NodeTypeTemplate;

package/types/javax/jcr/nodetype/PropertyDefinition/index.d.ts

@@ -1,203 +1,12 @@
-import type { Value } from "../../Value";
+import type Value from "../../Value";
 
-import type { ItemDefinition } from "../ItemDefinition";
+import type ItemDefinition from "../ItemDefinition";
 
 /**
  * A property definition. Used in node type definitions.
   
     */
-export type PropertyDefinition = {
-  /**
-   * Gets the required type of the property. One of: <ul>
-   * <li><code>PropertyType.STRING</code></li> <li><code>PropertyType.DATE</code></li>
-   * <li><code>PropertyType.BINARY</code></li> <li><code>PropertyType.DOUBLE</code></li>
-   * <li><code>PropertyType.DECIMAL</code></li> <li><code>PropertyType.LONG</code></li>
-   * <li><code>PropertyType.BOOLEAN</code></li> <li><code>PropertyType.NAME</code></li>
-   * <li><code>PropertyType.PATH</code></li> <li><code>PropertyType.URI</code></li>
-   * <li><code>PropertyType.REFERENCE</code></li> <li><code>PropertyType.WEAKREFERENCE</code></li>
-   * <li><code>PropertyType.UNDEFINED</code></li> </ul>
-   * <code>PropertyType.UNDEFINED</code> is returned if this property may be
-   * of any type.
-   * <p>
-   * In implementations that support node type registration, if this
-   * <code>PropertyDefinition</code> object is actually a newly-created empty
-   * <code>PropertyDefinitionTemplate</code>, then this method will return
-   * <code>PropertyType.STRING</code>.
-   *
-   * <p><strong>Sitevision note:</strong> Unsupported operation</p>
-   * @return an <code>int</code> constant member of <code>PropertyType</code>.
-   */
-  getRequiredType(): number;
-
-  /**
-   * Gets the array of constraint strings. Each string in the array specifies
-   * a constraint on the value of the property. The constraints are OR-ed
-   * together, meaning that in order to be valid, the value must meet at least
-   * one of the constraints. For example, a constraint array of
-   * <code>["constraint1", "constraint2", "constraint3"]</code> has the
-   * interpretation: "the value of this property must meet at least one of
-   * <code>constraint1</code>, <code>constraint2 </code>or
-   * <code>constraint3</code>".
-   * <p>
-   * Reporting of value constraints is optional. An implementation may return
-   * <code>null</code>, indicating that value constraint information is
-   * unavailable (though a constraint may still exist).
-   * <p>
-   * Returning an empty array, on the other hand, indicates that value
-   * constraint information is available and that no constraints are placed on
-   * this value.
-   * <p>
-   * In the case of multi-value properties, the constraint string array
-   * returned applies to all the values of the property.
-   * <p>
-   * The constraint strings themselves having differing formats and
-   * interpretations depending on the type of the property in question. The
-   * following describes the value constraint syntax for each property type:
-   * <ul> <li> <code>STRING</code> and <code>URI</code>: The constraint string
-   * is a regular expression pattern. For example the regular expression
-   * "<code>.*</code>" means "any string, including the empty string". Whereas
-   * a simple literal string (without any RE-specific meta-characters) like
-   * "<code>banana</code>" matches only the string "<code>banana</code>".
-   * </li> <li> <code>PATH</code>: The constraint string is a <i>JCR path</i>
-   * with an optional "<code>*</code>" character after the last
-   * "<code>/</code>" character. For example, possible constraint strings for
-   * a property of type <code>PATH</code> include: <ol> <li>
-   * "<code>/myapp:products/myapp:televisions</code>" </li> <li>
-   * "<code>/myapp:products/myapp:televisions/</code>" </li> <li>
-   * "<code>/myapp:products/*</code>" </li> <li> "<code>myapp:products/myapp:televisions</code>"
-   * </li> <li> "<code>../myapp:televisions</code>" </li> <li>
-   * "<code>../myapp:televisions/*</code>" </li> </ol> The following
-   * principles apply: <ul> <li> The "*" means "matches descendants" not
-   * "matches any subsequent path". For example, <code>/a/*</code> does not
-   * match <code>/a/../c</code>. The constraint must match the normalized
-   * path. </li> <li> Relative path constraint only match relative path values
-   * and absolute path constraints only match absolute path values. </li> <li>
-   * A trailing "<code>/</code>" has no effect (hence, <code>1</code> and
-   * <code>2</code>, above, are equivalent). </li> <li> The trailing
-   * "<code>*</code>" character means that the value of the <code>PATH</code>
-   * property is restricted to the indicated subgraph (in other words any
-   * additional relative path can replace the "<code>*</code>"). For example,
-   * 3, above would allow <code>/myapp:products/myapp:radios</code>,
-   * <code>/myapp:products/myapp:microwaves/X900</code>, and so forth. </li>
-   * <li> A constraint without a "<code>*</code>" means that the
-   * <code>PATH</code> property is restricted to that precise path. For
-   * example, <code>1</code>, above, would allow only the value
-   * <code>/myapp:products/myapp:televisions</code>. </li> <li> The constraint
-   * can indicate either a relative path or an absolute path depending on
-   * whether it includes a leading "<code>/</code>" character. <code>1</code>
-   * and <code>4</code>, above for example, are distinct. </li> <li> The
-   * string returned must reflect the namespace mapping in the current
-   * <code>Session</code> (i.e., the current state of the namespace registry
-   * overlaid with any session-specific mappings). Constraint strings for
-   * <code>PATH</code> properties should be stored in fully-qualified form
-   * (using the actual URI instead of the prefix) and then be converted to
-   * prefix form according to the current mapping upon the
-   * <code>PropertyDefinition.getValueConstraints</code> call. </li> </ul>
-   * </li> <li> <code>NAME</code>: The constraint string is a <i>JCR name</i>
-   * in prefix form. For example "<code>myapp:products</code>". No wildcards
-   * or other pattern matching are supported. As with <code>PATH</code>
-   * properties, the string returned must reflect the namespace mapping in the
-   * current <code>Session</code>. Constraint strings for <code>NAME</code>
-   * properties should be stored in fully-qualified form (using the actual URI
-   * instead of the prefix) and then be converted to prefix form according to
-   * the current mapping. </li> <li> <code>REFERENCE</code> and
-   * <code>WEAKREFERENCE</code>: The constraint string is a <i>JCR name</i> in
-   * prefix form. This name is interpreted as a node type name and the
-   * <code>REFERENCE</code> or <code>WEAKREFERENCE</code> property is
-   * restricted to referring only to nodes that have at least the indicated
-   * node type. For example, a constraint of "<code>mytype:document</code>"
-   * would indicate that the property in question can only refer to nodes that
-   * have at least the node type <code>mytype:document</code> (assuming this
-   * was the only constraint returned in the array, recall that the array of
-   * constraints are to be ORed together). No wildcards or other pattern
-   * matching are supported. As with <code>PATH</code> properties, the string
-   * returned must reflect the namespace mapping in the current
-   * <code>Session</code>. Constraint strings for <code>REFERENCE</code> and
-   * <code>WEAKREFERENCE</code> properties should be stored by the
-   * implementation in fully-qualified form (using the actual URI instead of
-   * the prefix) and then be converted to prefix form according to the current
-   * mapping. </li> <li> <code>BOOLEAN</code>: A constraint string can be
-   * either "true" or "false". In most cases <code>getValueConstraints</code>
-   * will return an empty array since placing a constraint on a
-   * <code>BOOLEAN</code> value does not usually make sense. </li> </ul> The
-   * remaining types all have value constraints in the form of inclusive or
-   * exclusive ranges: i.e., "<code>[min, max]</code>", "<code>(min,
-   * max)</code>", "<code>(min, max]</code>" or "<code>[min, max)</code>".
-   * Where "<code>[</code>" and "<code>]</code>" indicate "inclusive", while
-   * "<code>(</code>" and "<code>)</code>" indicate "exclusive". A missing
-   * <code>min</code> or <code>max</code> value indicates no bound in that
-   * direction. For example [,5] means no minimum but a maximum of 5
-   * (inclusive) while [,] means simply that any value will suffice, The
-   * meaning of the <code>min</code> and <code>max</code> values themselves
-   * differ between types as follows: <ul> <li> <code>BINARY</code>:
-   * <code>min</code> and <code>max</code> specify the allowed size range of
-   * the binary value in bytes. </li> <li> <code>DATE</code>: <code>min</code>
-   * and <code>max</code> are dates specifying the allowed date range. The
-   * date strings must be in the ISO8601-compliant format:
-   * <code>YYYY-MM-DDThh:mm:ss.sssTZD</code>. </li> <li> <code>LONG</code>,
-   * <code>DOUBLE</code>: min and max are numbers. </li> </ul> In
-   * implementations that support node type registration, when specifying that
-   * a <code>DATE</code>, <code>LONG </code>or <code>DOUBLE </code> is
-   * constrained to be equal to some disjunctive set of constants, a string
-   * consisting of just the constant itself, "c" may be used as a shorthand
-   * for the standard constraint notation of "[c, c]", where c is the
-   * constant. For example, to indicate that particular LONG property is
-   * constrained to be one of the values 2, 4, or 8, the constraint string
-   * array {"2", "4", "8"} can be used instead of the standard notation,
-   * {"[2,2]", "[4,4]", "[8,8]"}. However, even if this shorthand is used on
-   * registration, the value returned by <code>PropertyDefinition.getValueConstraints()</code>
-   * will always use the standard notation.
-   * <p>
-   * Because constraints are returned as an array of disjunctive constraints,
-   * in many cases the elements of the array can serve directly as a "choice
-   * list". This may, for example, be used by an application to display
-   * options to the end user indicating the set of permitted values.
-   * <p>
-   * In implementations that support node type registration, if this
-   * <code>PropertyDefinition</code> object is actually a newly-created empty
-   * <code>PropertyDefinitionTemplate</code>, then this method will return
-   * <code>null</code>.
-   *
-   * <p><strong>Sitevision note:</strong> Unsupported operation</p>
-   * @return a <code>String</code> array.
-   */
-  getValueConstraints(): string;
-
-  /**
-   * Gets the default value(s) of the property. These are the values that the
-   * property defined by this PropertyDefinition will be assigned if it is
-   * automatically created (that is, if {@link #isAutoCreated()} returns
-   * <code>true</code>).
-   * <p>
-   * This method returns an array of <code>Value</code> objects. If the
-   * property is multi-valued, then this array represents the full set of
-   * values that the property will be assigned upon being auto-created. Note
-   * that this could be the empty array. If the property is single-valued,
-   * then the array returned will be of size 1.
-   * <p>
-   * If <code>null</code> is returned, then the property has no fixed default
-   * value. This does not exclude the possibility that the property still
-   * assumes some value automatically, but that value may be parametrized (for
-   * example, "the current date") and hence not expressible as a single fixed
-   * value. In particular, this <i>must</i> be the case if
-   * <code>isAutoCreated</code> returns <code>true</code> and this method
-   * returns <code>null</code>.
-   * <p>
-   * Note that to indicate a <code>null</code> value for this attribute in a
-   * node type definition that is stored in content, the
-   * <code>jcr:defaultValues</code> property is simply removed (since
-   * <code>null</code> values for properties are not allowed.
-   * <p>
-   * In implementations that support node type registration, if this
-   * <code>PropertyDefinition</code> object is actually a newly-created empty
-   * <code>PropertyDefinitionTemplate</code>, then this method will return
-   * <code>null</code>.
-   *
-   * <p><strong>Sitevision note:</strong> Unsupported operation</p>
-   * @return an array of <code>Value</code> objects.
-   */
-  getDefaultValues(): Value;
-
+type PropertyDefinition = ItemDefinition & {
   /**
    * Reports whether this property can have multiple values. Note that the
    * <code>isMultiple</code> flag is special in that a given node type may
@@ -214,82 +23,6 @@ export type PropertyDefinition = {
    * @return a <code>boolean</code>
    */
   isMultiple(): boolean;
-
-  /**
-   * Returns the set of query comparison operators supported by this
-   * property.
-   * <p>
-   * This attribute only takes effect if the node type holding the property
-   * definition has a queryable setting of <code>true</code>.
-   * <p>
-   * JCR defines the following comparison operators: <ul> <li>{@link
-   * javax.jcr.query.qom.QueryObjectModelConstants#JCR_OPERATOR_EQUAL_TO},</li>
-   * <li>{@link javax.jcr.query.qom.QueryObjectModelConstants#JCR_OPERATOR_NOT_EQUAL_TO},</li>
-   * <li>{@link javax.jcr.query.qom.QueryObjectModelConstants#JCR_OPERATOR_LESS_THAN},</li>
-   * <li>{@link javax.jcr.query.qom.QueryObjectModelConstants#JCR_OPERATOR_LESS_THAN_OR_EQUAL_TO},</li>
-   * <li>{@link javax.jcr.query.qom.QueryObjectModelConstants#JCR_OPERATOR_GREATER_THAN},</li>
-   * <li>{@link javax.jcr.query.qom.QueryObjectModelConstants#JCR_OPERATOR_GREATER_THAN_OR_EQUAL_TO},
-   * or</li> <li>{@link javax.jcr.query.qom.QueryObjectModelConstants#JCR_OPERATOR_LIKE}</li>
-   * </ul> An implementation may define additional comparison operators.
-   * <p>
-   * Note that the set of operators that can appear in this attribute may be
-   * limited by implementation-specific constraints that differ across
-   * property types. For example, some implementations may permit property
-   * definitions to provide <code>JCR_OPERATOR_EQUAL_TO</code> and
-   * <code>JCR_OPERATOR_NOT_EQUAL_TO</code> as available operators for
-   * <code>BINARY</code> properties while others may not.
-   * <p>
-   * However, in all cases where a JCR-defined operator <i>is</i> potentially
-   * available for a given property type, its behavior must conform to the
-   * comparison semantics defined in the specification document (see 3.6.5
-   * <i>Comparison of Values</i>).
-   * <p>
-   * In implementations that support node type registration, if this
-   * <code>NodeTypeDefinition</code> object is actually a newly-created empty
-   * <code>NodeTypeTemplate</code>, then this method will return an impementation-
-   * determined default set of operator constants.
-   *
-   * <p><strong>Sitevision note:</strong> Unsupported operation</p>
-   * @return a <code>String</code> array.
-   * @since JCR 2.0
-   */
-  getAvailableQueryOperators(): string;
-
-  /**
-   * Returns <code>true</code> if this property is full-text searchable,
-   * meaning that its value is accessible through the full-text search
-   * function within a query.
-   * <p>
-   * This attribute only takes effect if the node type holding the property
-   * definition has a queryable setting of <code>true</code>.
-   * <p>
-   * In implementations that support node type registration, if this
-   * <code>NodeTypeDefinition</code> object is actually a newly-created empty
-   * <code>NodeTypeTemplate</code>, then this method will return an impementation-
-   * determined default value.
-   *
-   * <p><strong>Sitevision note:</strong> Unsupported operation</p>
-   * @return a <code>boolean</code>
-   * @since JCR 2.0
-   */
-  isFullTextSearchable(): boolean;
-
-  /**
-   * Returns <code>true</code> if this property is query-orderable, meaning
-   * that query results may be ordered by this property using the order-by
-   * clause of a query.
-   * <p>
-   * This attribute only takes effect if the node type holding the property
-   * definition has a queryable setting of <code>true</code>.
-   * <p>
-   * In implementations that support node type registration, if this
-   * <code>NodeTypeDefinition</code> object is actually a newly-created empty
-   * <code>NodeTypeTemplate</code>, then this method will return an impementation-
-   * determined default value.
-   *
-   * <p><strong>Sitevision note:</strong> Unsupported operation</p>
-   * @return a <code>boolean</code>
-   * @since JCR 2.0
-   */
-  isQueryOrderable(): boolean;
 };
+
+export = PropertyDefinition;