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

package/{hidden → types}/javax/jcr/nodetype/NodeTypeIterator/index.d.ts

@@ -1,16 +1,15 @@
-import NodeType from "../NodeType";
+import type { NodeType } from "../NodeType";
+import type { RangeIterator } from "../../RangeIterator";
 
 /**
- * An iterator for <code>NodeType</code> objects.Returns the next <code>NodeType</code> in the iteration.
+ * An iterator for <code>NodeType</code> objects.
   
     */
-interface NodeTypeIterator {
+export type NodeTypeIterator = {
   /**
    * Returns the next <code>NodeType</code> in the iteration.
    * @return the next <code>NodeType</code> in the iteration.
    * @throws java.util.NoSuchElementException if iteration has no more <code>NodeType</code>s.
    */
   nextNodeType(): NodeType;
-}
-
-export default NodeTypeIterator;
+};

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

@@ -0,0 +1,10 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _default = {
+  nextNodeType: function nextNodeType() {}
+};
+exports["default"] = _default;

package/{hidden → types}/javax/jcr/nodetype/NodeTypeManager/index.d.ts

@@ -1,55 +1,17 @@
-import NodeType from "../NodeType";
-import NodeTypeIterator from "../NodeTypeIterator";
-import NodeTypeTemplate from "../NodeTypeTemplate";
-import NodeTypeDefinition from "../NodeTypeDefinition";
-import NodeDefinitionTemplate from "../NodeDefinitionTemplate";
-import PropertyDefinitionTemplate from "../PropertyDefinitionTemplate";
+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";
 
 /**
  * Allows for the retrieval and (in implementations that support it) the
- * registration of node types. Accessed via {@link Workspace#getNodeTypeManager}.Returns the named node type.Returns <code>true</code> if a node type with the specified name is
- * registered. Returns <code>false</code> otherwise.Returns an iterator over all available node types (primary and mixin).Returns an iterator over all available primary node types.Returns an iterator over all available mixin node types. If none are
- * available, an empty iterator is returned.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>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>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>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>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>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>Unregisters the specified node type.
- *
- * <p><strong>Sitevision note:</strong> Unsupported operation</p>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>
+ * registration of node types. Accessed via {@link Workspace#getNodeTypeManager}.
   
     */
-interface NodeTypeManager {
+export type NodeTypeManager = {
   /**
    * Returns the named node type.
    * @param nodeTypeName the name of an existing node type.
@@ -213,6 +175,4 @@ interface NodeTypeManager {
    * @since JCR 2.0
    */
   unregisterNodeTypes(names: string): void;
-}
-
-export default NodeTypeManager;
+};

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

@@ -0,0 +1,21 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _default = {
+  getNodeType: function getNodeType() {},
+  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() {}
+};
+exports["default"] = _default;

package/{hidden → types}/javax/jcr/nodetype/NodeTypeTemplate/index.d.ts

@@ -1,3 +1,5 @@
+import type { NodeTypeDefinition } from "../NodeTypeDefinition";
+
 /**
  * The <code>NodeTypeTemplate</code> interface is used to define node types which
  * are then registered through the <code>NodeTypeManager.registerNodeType</code> method.
@@ -13,20 +15,10 @@
  * empty <code>NodeTypeTemplate</code> is created (as opposed to one extracted
  * from an existing <code>NodeType</code>).
  *
- * <p><strong>Sitevision note:</strong> Unsupported operation</p>Sets the name of the node type. This must be a JCR name in either
- * qualified or expanded form.Sets the names of the supertypes of the node type.
- * These must be a JCR names in either
- * qualified or expanded form.Sets the abstract flag of the node type.Sets the mixin flag of the node type.Sets the orderable child nodes flag of the node type.Sets the name of the primary item. This must be a JCR name in either
- * qualified or expanded form.Sets the queryable status of the node type.Returns a mutable <code>List</code> of <code>PropertyDefinitionTemplate</code>
- * objects. To define a new <code>NodeTypeTemplate</code> or change an
- * existing one, <code>PropertyDefinitionTemplate</code> objects can be
- * added to or removed from this <code>List</code>.Returns a mutable <code>List</code> of <code>NodeDefinitionTemplate</code>
- * objects. To define a new <code>NodeTypeTemplate</code> or change an
- * existing one, <code>NodeDefinitionTemplate</code> objects can be added to
- * or removed from this <code>List</code>.
+ * <p><strong>Sitevision note:</strong> Unsupported operation</p>
  * @since JCR 2.0
  */
-interface NodeTypeTemplate {
+export type NodeTypeTemplate = {
   /**
    * Sets the name of the node type. This must be a JCR name in either
    * qualified or expanded form.
@@ -83,7 +75,7 @@ interface NodeTypeTemplate {
    * added to or removed from this <code>List</code>.
    * @return a mutable <code>List</code> of <code>PropertyDefinitionTemplate</code> objects.
    */
-  getPropertyDefinitionTemplates(): unknown[];
+  getPropertyDefinitionTemplates(): unknown;
 
   /**
    * Returns a mutable <code>List</code> of <code>NodeDefinitionTemplate</code>
@@ -92,7 +84,5 @@ interface NodeTypeTemplate {
    * or removed from this <code>List</code>.
    * @return a mutable <code>List</code> of <code>NodeDefinitionTemplate</code> objects.
    */
-  getNodeDefinitionTemplates(): unknown[];
-}
-
-export default NodeTypeTemplate;
+  getNodeDefinitionTemplates(): unknown;
+};

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

@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _default = {
+  setName: function setName() {},
+  setDeclaredSuperTypeNames: function setDeclaredSuperTypeNames() {},
+  setAbstract: function setAbstract() {},
+  setMixin: function setMixin() {},
+  setOrderableChildNodes: function setOrderableChildNodes() {},
+  setPrimaryItemName: function setPrimaryItemName() {},
+  setQueryable: function setQueryable() {},
+  getPropertyDefinitionTemplates: function getPropertyDefinitionTemplates() {},
+  getNodeDefinitionTemplates: function getNodeDefinitionTemplates() {}
+};
+exports["default"] = _default;

package/{hidden → types}/javax/jcr/nodetype/PropertyDefinition/index.d.ts

@@ -1,251 +1,12 @@
-import Value from "../../Value";
+import type { Value } from "../../Value";
+
+import type { ItemDefinition } from "../ItemDefinition";
 
 /**
- * A property definition. Used in node type definitions.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>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>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>Reports whether this property can have multiple values. Note that the
- * <code>isMultiple</code> flag is special in that a given node type may
- * have two property definitions that are identical in every respect except
- * for the their <code>isMultiple</code> status. For example, a node type
- * can specify two string properties both called <code>X</code>, one of
- * which is multi-valued and the other not. An example of such a node type
- * is <code>nt:unstructured</code>.
- * <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>false</code>.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>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>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>
+ * A property definition. Used in node type definitions.
   
     */
-interface PropertyDefinition {
+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>
@@ -531,6 +292,4 @@ interface PropertyDefinition {
    * @since JCR 2.0
    */
   isQueryOrderable(): boolean;
-}
-
-export default PropertyDefinition;
+};

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

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _default = {
+  getRequiredType: function getRequiredType() {},
+  getValueConstraints: function getValueConstraints() {},
+  getDefaultValues: function getDefaultValues() {},
+  isMultiple: function isMultiple() {},
+  getAvailableQueryOperators: function getAvailableQueryOperators() {},
+  isFullTextSearchable: function isFullTextSearchable() {},
+  isQueryOrderable: function isQueryOrderable() {}
+};
+exports["default"] = _default;

package/{hidden → types}/javax/jcr/nodetype/PropertyDefinitionTemplate/index.d.ts

@@ -1,4 +1,5 @@
-import Value from "../../Value";
+import type { Value } from "../../Value";
+import type { PropertyDefinition } from "../PropertyDefinition";
 
 /**
  * The <code>PropertyDefinitionTemplate</code> interface extends
@@ -12,12 +13,10 @@ import Value from "../../Value";
  * empty <code>PropertyDefinitionTemplate</code> is created (as opposed to one
  * extracted from an existing <code>NodeType</code>).
  *
- * <p><strong>Sitevision note:</strong> Unsupported operation</p>Sets the name of the property. This must be a JCR name in either
- * qualified or expanded form.Sets the auto-create status of the property.Sets the mandatory status of the property.Sets the on-parent-version status of the property.Sets the protected status of the property.Sets the required type of the property.Sets the value constraints of the property.Sets the default value (or values, in the case of a multi-value property)
- * of the property.Sets the multi-value status of the property.Sets the queryable status of the property.Sets the full-text-searchable status of the property.Sets the query-orderable status of the property.
+ * <p><strong>Sitevision note:</strong> Unsupported operation</p>
  * @since JCR 2.0
  */
-interface PropertyDefinitionTemplate {
+export type PropertyDefinitionTemplate = {
   /**
    * Sets the name of the property. This must be a JCR name in either
    * qualified or expanded form.
@@ -92,6 +91,4 @@ interface PropertyDefinitionTemplate {
    * @param queryOrderable a <code>boolean</code>.
    */
   setQueryOrderable(queryOrderable: boolean): void;
-}
-
-export default PropertyDefinitionTemplate;
+};

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

@@ -0,0 +1,21 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _default = {
+  setName: function setName() {},
+  setAutoCreated: function setAutoCreated() {},
+  setMandatory: function setMandatory() {},
+  setOnParentVersion: function setOnParentVersion() {},
+  setProtected: function setProtected() {},
+  setRequiredType: function setRequiredType() {},
+  setValueConstraints: function setValueConstraints() {},
+  setDefaultValues: function setDefaultValues() {},
+  setMultiple: function setMultiple() {},
+  setAvailableQueryOperators: function setAvailableQueryOperators() {},
+  setFullTextSearchable: function setFullTextSearchable() {},
+  setQueryOrderable: function setQueryOrderable() {}
+};
+exports["default"] = _default;

package/{hidden → types}/javax/jcr/observation/Event/index.d.ts

@@ -1,25 +1,7 @@
 /**
  * An event fired by the observation mechanism.
  *
- * <p><strong>Sitevision note:</strong> Unsupported operation</p>Returns the type of this event: a constant defined by this interface. One
- * of: <ul> <li><code>NODE_ADDED</code></li> <li><code>NODE_REMOVED</code></li>
- * <li><code>PROPERTY_ADDED</code></li> <li><code>PROPERTY_REMOVED</code></li>
- * <li><code>PROPERTY_CHANGED</code></li> <li><code>NODE_MOVED</code></li>
- * <li><code>PERSIST</code></li> </ul>Returns the absolute path associated with this event or <code>null</code>
- * if this event has no associated identifier. The meaning of the associated
- * path depends upon the type of the event. See event type constants above.Returns the user ID connected with this event. This is the string
- * returned by {@link javax.jcr.Session#getUserID} of the session that
- * caused the event.Returns the identifier associated with this event or <code>null</code> if
- * this event has no associated identifier. The meaning of the associated
- * identifier depends upon the type of the event. See event type constants
- * above.Returns the information map associated with this event. The meaning of
- * the map depends upon the type of the event. See event type constants
- * above.Returns the user data set through {@link ObservationManager#setUserData}
- * on the <code>ObservationManager</code> bound to the <code>Session</code>
- * that caused the event.Returns the date when the change was persisted that caused this event.
- * The date is represented as a millisecond value that is an offset from the
- * Epoch, January 1, 1970 00:00:00.000 GMT (Gregorian). The granularity of
- * the returned value is implementation dependent.Generated on persist when a node is added. <ul> <li>{@link #getPath}
+ * <p><strong>Sitevision note:</strong> Unsupported operation</p>Generated on persist when a node is added. <ul> <li>{@link #getPath}
  * returns the absolute path of the node that was added.</li> <li>{@link
  * #getIdentifier} returns the identifier of the node that was added.</li>
  * <li>{@link #getInfo} returns an empty <code>Map</code> object.</li>
@@ -57,9 +39,10 @@
  * <code>null</code>.</li> <li>{@link #getIdentifier} returns
  * <code>null</code>.</li> <li>{@link #getInfo} returns an empty
  * <code>Map</code> object.</li> </ul>
-  
-    */
-interface Event {
+ * @since JCR 2.0
+ * @since JCR 2.0
+ */
+export type Event = {
   /**
    * Returns the type of this event: a constant defined by this interface. One
    * of: <ul> <li><code>NODE_ADDED</code></li> <li><code>NODE_REMOVED</code></li>
@@ -106,7 +89,7 @@ interface Event {
    * @throws RepositoryException if an error occurs.
    * @since JCR 2.0
    */
-  getInfo(): Record<unknown, unknown>;
+  getInfo(): unknown;
 
   /**
    * Returns the user data set through {@link ObservationManager#setUserData}
@@ -128,6 +111,4 @@ interface Event {
    * @since JCR 2.0
    */
   getDate(): number;
-}
-
-export default Event;
+};

package/types/javax/jcr/observation/Event/index.js

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _default = {
+  getType: function getType() {},
+  getPath: function getPath() {},
+  getUserID: function getUserID() {},
+  getIdentifier: function getIdentifier() {},
+  getInfo: function getInfo() {},
+  getUserData: function getUserData() {},
+  getDate: function getDate() {}
+};
+exports["default"] = _default;

package/{hidden → types}/javax/jcr/observation/EventIterator/index.d.ts

@@ -1,20 +1,19 @@
-import Event from "../Event";
+import type { Event } from "../Event";
+import type { RangeIterator } from "../../RangeIterator";
 
 /**
  * Allows easy iteration through a list of <code>Event</code>s with
  * <code>nextEvent</code> as well as a <code>skip</code> method inherited from
  * <code>RangeIterator</code>.
  *
- * <p><strong>Sitevision note:</strong> Unsupported operation</p>Returns the next <code>Event</code> in the iteration.
+ * <p><strong>Sitevision note:</strong> Unsupported operation</p>
   
     */
-interface EventIterator {
+export type EventIterator = {
   /**
    * Returns the next <code>Event</code> in the iteration.
    * @return the next <code>Event</code> in the iteration.
    * @throws java.util.NoSuchElementException if iteration has no more <code>Event</code>s.
    */
   nextEvent(): Event;
-}
-
-export default EventIterator;
+};

package/types/javax/jcr/observation/EventIterator/index.js

@@ -0,0 +1,10 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _default = {
+  nextEvent: function nextEvent() {}
+};
+exports["default"] = _default;