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

package/hidden/javax/jcr/lock/Lock/index.d.ts

@@ -3,43 +3,7 @@ import Node from "../../Node";
 /**
  * Represents a lock placed on an item.
  *
- * <p><strong>Sitevision note:</strong> Unsupported operation</p>Returns the value of the <code>jcr:lockOwner</code> property. This is
- * either the client supplied owner information (see {@link
- * LockManager#lock(String, boolean, boolean, long, String)}), an
- * implementation-dependent string identifying the user who either created
- * the lock or who is bound to the session holding the lock, or
- * <code>null</code> if none of these are available. The lock owner's
- * identity is only provided for informational purposes. It does not govern
- * who can perform an unlock or make changes to the locked nodes; that
- * depends entirely upon who the token holder is.Returns <code>true</code> if this is a deep lock; <code>false</code>
- * otherwise.Returns the lock holding node. Note that <code>N.getLock().getNode()</code>
- * (where <code>N</code> is a locked node) will only return <code>N</code>
- * if <code>N</code> is the lock holder. If <code>N</code> is in the
- * subgraph of the lock holder, <code>H</code>, then this call will return
- * <code>H</code>.May return the lock token for this lock. If this lock is open-scoped and
- * the current session either holds the lock token for this lock, or the
- * repository chooses to expose the lock token to the current session, then
- * this method will return that lock token. Otherwise this method will
- * return <code>null</code>.Returns the number of seconds remaining until this locks times out. If
- * the lock has already timed out, a negative value is returned. If the
- * number of seconds remaining is infinite or unknown,
- * <code>Long.MAX_VALUE</code> is returned.Returns true if this <code>Lock</code> object represents a lock that is
- * currently in effect. If this lock has been unlocked either explicitly or
- * due to an implementation-specific limitation (like a timeout) then it
- * returns <code>false</code>. Note that this method is intended for those
- * cases where one is holding a <code>Lock</code> Java object and wants to
- * find out whether the lock (the JCR-level entity that is attached to the
- * lockable node) that this object originally represented still exists. For
- * example, a timeout or explicit <code>unlock</code> will remove a lock
- * from a node but the <code>Lock</code> Java object corresponding to that
- * lock may still exist, and in that case its <code>isLive</code> method
- * will return <code>false</code>.Returns <code>true</code> if this is a session-scoped lock and the scope
- * is bound to the current session. Returns <code>false</code> otherwise.Returns <code>true</code> if the current session is the owner of this
- * lock, either because it is session-scoped and bound to this session or
- * open-scoped and this session currently holds the token for this lock.
- * Returns <code>false</code> otherwise.If this lock's time-to-live is governed by a timer, this method resets
- * that timer so that the lock does not timeout and expire. If this lock's
- * time-to-live is not governed by a timer, then this method has no effect.
+ * <p><strong>Sitevision note:</strong> Unsupported operation</p>
   
     */
 interface Lock {

package/hidden/javax/jcr/lock/Lock/index.js

@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _default = {
+  getLockOwner: function getLockOwner() {},
+  isDeep: function isDeep() {},
+  getNode: function getNode() {},
+  getLockToken: function getLockToken() {},
+  getSecondsRemaining: function getSecondsRemaining() {},
+  isLive: function isLive() {},
+  isSessionScoped: function isSessionScoped() {},
+  isLockOwningSession: function isLockOwningSession() {},
+  refresh: function refresh() {}
+};
+exports["default"] = _default;

package/hidden/javax/jcr/lock/LockManager/index.d.ts

@@ -3,67 +3,7 @@ import Lock from "../Lock";
 /**
  * This interface encapsulates methods for the management of locks.
  *
- * <p><strong>Sitevision note:</strong> Unsupported operation</p>Adds the specified lock token to the current <code>Session</code>.
- * Holding a lock token makes the current <code>Session</code> the owner of
- * the lock specified by that particular lock token.Returns the <code>Lock</code> object that applies to the node at the
- * specified <code>absPath</code>. This may be either a lock on that node
- * itself or a deep lock on a node above that node.
- * <p>Returns an array containing all lock tokens currently held by the current
- * <code>Session</code>. Note that any such tokens will represent
- * open-scoped locks, since session-scoped locks do not have tokens.Returns <code>true</code> if the node at <code>absPath</code> holds a
- * lock; otherwise returns <code>false</code>. To <i>hold</i> a lock means
- * that this node has actually had a lock placed on it specifically, as
- * opposed to just having a lock <i>apply</i> to it due to a deep lock held
- * by a node above.<p> Places a lock on the node at <code>absPath</code>. If successful,
- * the node is said to <i>hold</i> the lock.  <p> If <code>isDeep</code> is
- * <code>true</code> then the lock applies to the specified node and all its
- * descendant nodes; if <code>false</code>, the lock applies only to the
- * specified node. On a successful lock, the <code>jcr:lockIsDeep</code>
- * property of the locked node is set to this value.  <p> If
- * <code>isSessionScoped</code> is <code>true</code> then this lock will
- * expire upon the expiration of the current session (either through an
- * automatic or explicit <code>Session.logout</code>); if false, this lock
- * does not expire until it is explicitly unlocked, it times out, or it is
- * automatically unlocked due to a implementation-specific limitation. <p>
- * The timeout parameter specifies the number of seconds until the lock
- * times out (if it is not refreshed with <code>Lock.refresh</code> in the
- * meantime). An implementation may use this information as a hint or ignore
- * it altogether. Clients can discover the actual timeout by inspecting the
- * returned <code>Lock</code> object.  <p> The <code>ownerInfo</code>
- * parameter can be used to pass a string holding owner information relevant
- * to the client. An implementation may either use or ignore this parameter.
- * If it uses the parameter it must set the <code>jcr:lockOwner</code>
- * property of the locked node to this value and return this value on
- * <code>Lock.getLockOwner</code>. If it ignores this parameter the
- * <code>jcr:lockOwner</code> property (and the value returned by
- * <code>Lock.getLockOwner</code>) is set to either the value returned by
- * <code>Session.getUserID</code> of the owning session or an
- * implementation-specific string identifying the owner.  <p> The method
- * returns a <code>Lock</code> object representing the new lock. If the lock
- * is open-scoped the returned lock will include a lock token. The lock
- * token is also automatically added to the set of lock tokens held by the
- * current session.  <p> The addition or change of the properties
- * <code>jcr:lockIsDeep</code> and <code>jcr:lockOwner</code> are persisted
- * immediately; there is no need to call <code>save</code>.  <p> It is
- * possible to lock a node even if it is checked-in.Returns <code>true</code> if the node at <code>absPath</code> is locked
- * either as a result of a lock held by that node or by a deep lock on a
- * node above that node; otherwise returns <code>false</code>.Removes the specified lock token from this <code>Session</code>.Removes the lock on the node at <code>absPath</code>. Also removes the
- * properties <code>jcr:lockOwner</code> and <code>jcr:lockIsDeep</code>
- * from that node. As well, the corresponding lock token is removed from the
- * set of lock tokens held by the current <code>Session</code>.
- * <p>
- * If the node does not currently hold a lock or holds a lock for which this
- * <code>Session</code> is not the owner and is not a "lock-superuser", then
- * a <code>LockException</code> is thrown. Note that the system may give
- * permission to a non-owning session to unlock a lock. Typically, such
- * "lock-superuser" capability is intended to facilitate administrational
- * clean-up of orphaned open-scoped locks.
- * <p>
- * Note that it is possible to unlock a node even if it is checked-in (the
- * lock-related properties will be changed despite the checked-in status).
- * <p>
- * If the current session does not have sufficient privileges to remove the
- * lock, an <code>AccessDeniedException</code> is thrown.
+ * <p><strong>Sitevision note:</strong> Unsupported operation</p>
  * @since Sitevision 3.5
  * @since JCR 2.0
  */

package/hidden/javax/jcr/lock/LockManager/index.js

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _default = {
+  addLockToken: function addLockToken() {},
+  getLock: function getLock() {},
+  getLockTokens: function getLockTokens() {},
+  holdsLock: function holdsLock() {},
+  lock: function lock() {},
+  isLocked: function isLocked() {},
+  removeLockToken: function removeLockToken() {},
+  unlock: function unlock() {}
+};
+exports["default"] = _default;

package/hidden/javax/jcr/nodetype/ItemDefinition/index.d.ts

@@ -1,94 +1,7 @@
 import NodeType from "../NodeType";
 
 /**
- * Superclass of {@link NodeDefinition} and {@link PropertyDefinition}.Gets the node type that contains the declaration of <i>this</i>
- * <code>ItemDefinition</code>.
- * <p>
- * In implementations that support node type registration an
- * <code>ItemDefinition</code> object may be acquired (in the form of a
- * <code>NodeDefinitionTemplate</code> or <code>PropertyDefinitionTemplate</code>)
- * that is not attached to a live <code>NodeType</code>. In such cases this
- * method returns <code>null</code>.
- *
- * <p><strong>Sitevision note:</strong> Unsupported operation</p>Gets the name of the child item. If <code>"*"</code>, this
- * <code>ItemDefinition</code> defines a residual set of child items. That
- * is, it defines the characteristics of all those child items with names
- * apart from the names explicitly used in other child item definitions.
- * <p>
- * In implementations that support node type registration, if this
- * <code>ItemDefinition</code> object is actually a newly-created empty
- * <code>PropertyDefinitionTemplate</code> or <code>NodeDefinitionTemplate</code>,
- * then this method will return <code>null</code>.
- *
- * <p><strong>Sitevision note:</strong> Unsupported operation</p>Reports whether the item is to be automatically created when its parent
- * node is created. If <code>true</code>, then this <code>ItemDefinition</code>
- * will necessarily not be a residual set definition but will specify an
- * actual item name (in other words getName() will not return "*").
- * <p>
- * An autocreated non-protected item must be created immediately when its
- * parent node is created in the transient session space. Creation of
- * autocreated non-protected items is never delayed until
- * <code>save</code>.
- * </p>
- * <p>
- * An autocreated protected item should be created immediately when its
- * parent node is created in the transient session space. Creation of
- * autocreated protected items should not be delayed until
- * <code>save</code>, though doing so does not violate JCR compliance.
- * <p>
- * In implementations that support node type registration, if this
- * <code>ItemDefinition</code> object is actually a newly-created empty
- * <code>PropertyDefinitionTemplate</code> or <code>NodeDefinitionTemplate</code>,
- * then this method will return <code>false</code>.
- *
- * <p><strong>Sitevision note:</strong> Unsupported operation</p>Reports whether the item is mandatory. A mandatory item is one that, if
- * its parent node exists, must also exist.
- * <p>
- * This means that a mandatory single-value property must have a value
- * (since there is no such thing a <code>null</code> value). In the case of
- * multi-value properties this means that the property must exist, though it
- * can have zero or more values.
- * <p>
- * An attempt to save a node that has a mandatory child item without first
- * creating that child item  will throw a <code>ConstraintViolationException</code>
- * on <code>save</code>.
- * <p>
- * In implementations that support node type registration, if this
- * <code>ItemDefinition</code> object is actually a newly-created empty
- * <code>PropertyDefinitionTemplate</code> or <code>NodeDefinitionTemplate</code>,
- * then this method will return <code>false</code>.
- * <p>
- * An item definition cannot be both residual and mandatory.
- *
- * <p><strong>Sitevision note:</strong> Unsupported operation</p>Gets the <code>OnParentVersion </code> status of the child item. This
- * governs what occurs (in implementations that support versioning) when the
- * parent node of this item is checked-in. One of: <ul>
- * <li><code>OnParentVersionAction.COPY</code></li> <li><code>OnParentVersionAction.VERSION</code></li>
- * <li><code>OnParentVersionAction.IGNORE</code></li>
- * <li><code>OnParentVersionAction.INITIALIZE</code></li>
- * <li><code>OnParentVersionAction.COMPUTE</code></li>
- * <li><code>OnParentVersionAction.ABORT</code></li> </ul>
- * <p>
- * In implementations that support node type registration, if this
- * <code>ItemDefinition</code> object is actually a newly-created empty
- * <code>PropertyDefinitionTemplate</code> or <code>NodeDefinitionTemplate</code>,
- * then this method will return <code>OnParentVersionAction.COPY</code>.
- *
- * <p><strong>Sitevision note:</strong> Unsupported operation</p>Reports whether the child item is protected. In level 2 implementations,
- * a protected item is one that cannot be removed (except by removing its
- * parent) or modified through the the standard write methods of this API
- * (that is, <code>Item.remove</code>, <code>Node.addNode</code>,
- * <code>Node.setProperty</code> and <code>Property.setValue</code>).
- * <p>
- * A protected node may be removed or modified (in a level 2
- * implementation), however, through some mechanism not defined by this
- * specification or as a side-effect of operations other than the standard
- * write methods of the API.
- * <p>
- * In implementations that support node type registration, if this
- * <code>ItemDefinition</code> object is actually a newly-created empty
- * <code>PropertyDefinitionTemplate</code> or <code>NodeDefinitionTemplate</code>,
- * then this method will return <code>false</code>.
+ * Superclass of {@link NodeDefinition} and {@link PropertyDefinition}.
   
     */
 interface ItemDefinition {

package/hidden/javax/jcr/nodetype/ItemDefinition/index.js

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _default = {
+  getDeclaringNodeType: function getDeclaringNodeType() {},
+  getName: function getName() {},
+  isAutoCreated: function isAutoCreated() {},
+  isMandatory: function isMandatory() {},
+  getOnParentVersion: function getOnParentVersion() {},
+  isProtected: function isProtected() {}
+};
+exports["default"] = _default;

package/hidden/javax/jcr/nodetype/NodeDefinition/index.d.ts

@@ -1,65 +1,9 @@
 import NodeType from "../NodeType";
 
+import ItemDefinition from "../ItemDefinition";
+
 /**
- * A node definition. Used in node type definitions.Gets the minimum set of primary node types that the child node must have.
- * Returns an array to support those implementations with multiple
- * inheritance. This method never returns an empty array. If this node
- * definition places no requirements on the primary node type, then this
- * method will return an array containing only the <code>NodeType</code>
- * object representing <code>nt:base</code>, which is the base of all
- * primary node types and therefore constitutes the least restrictive node
- * type requirement. Note that any particular node instance still has only
- * one assigned primary node type, but in multiple-inheritance-supporting
- * implementations the <code>RequiredPrimaryTypes</code> attribute can be
- * used to restrict that assigned node type to be a subtype of <i>all</i> of
- * a specified set of node types.
- * <p>
- * In implementations that support node type registration an
- * <code>NodeDefinition</code> object may be acquired (in the form of a
- * <code>NodeDefinitionTemplate</code>) that is not attached to a live
- * <code>NodeType</code>. In such cases this method returns
- * <code>null</code>.Returns the names of the required primary node types.
- * <p>
- * If this <code>NodeDefinition</code> is acquired from a live
- * <code>NodeType</code> this list will reflect the node types returned by
- * <code>getRequiredPrimaryTypes</code>, above.
- * <p>
- * If this <code>NodeDefinition</code> is actually a
- * <code>NodeDefinitionTemplate</code> that is not part of a registered node
- * type, then this method will return the required primary types as set in
- * that template. If that template is a newly-created empty one, then this
- * method will return <code>null</code>.Gets the default primary node type that will be assigned to the child
- * node if it is created without an explicitly specified primary node type.
- * This node type must be a subtype of (or the same type as) the node types
- * returned by <code>getRequiredPrimaryTypes</code>.
- * <p>
- * If <code>null</code> is returned this indicates that no default primary
- * type is specified and that therefore an attempt to create this node
- * without specifying a node type will throw a <code>ConstraintViolationException</code>.
- * <p>
- * In implementations that support node type registration an
- * <code>NodeDefinition</code> object may be acquired (in the form of a
- * <code>NodeDefinitionTemplate</code>) that is not attached to a live
- * <code>NodeType</code>. In such cases this method returns
- * <code>null</code>.Returns the name of the default primary node type.
- * <p>
- * If this <code>NodeDefinition</code> is acquired from a live
- * <code>NodeType</code> this list will reflect the NodeType returned by
- * getDefaultPrimaryType, above.
- * <p>
- * If this <code>NodeDefinition</code> is actually a
- * <code>NodeDefinitionTemplate</code> that is not part of a registered node
- * type, then this method will return the required primary types as set in
- * that template. If that template is a newly-created empty one, then this
- * method will return <code>null</code>.Reports whether this child node can have same-name siblings. In other
- * words, whether the parent node can have more than one child node of this
- * name.
- * <p>
- * If this <code>NodeDefinition</code> is actually a
- * <code>NodeDefinitionTemplate</code> that is not part of a registered node
- * type, then this method will return the same name siblings status as set
- * in that template. If that template is a newly-created empty one, then
- * this method will return <code>false</code>.
+ * A node definition. Used in node type definitions.
  * @see NodeType#getChildNodeDefinitions
  * @see javax.jcr.Node#getDefinition
  */

package/hidden/javax/jcr/nodetype/NodeDefinition/index.js

@@ -0,0 +1,14 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _default = {
+  getRequiredPrimaryTypes: function getRequiredPrimaryTypes() {},
+  getRequiredPrimaryTypeNames: function getRequiredPrimaryTypeNames() {},
+  getDefaultPrimaryType: function getDefaultPrimaryType() {},
+  getDefaultPrimaryTypeName: function getDefaultPrimaryTypeName() {},
+  allowsSameNameSiblings: function allowsSameNameSiblings() {}
+};
+exports["default"] = _default;

package/hidden/javax/jcr/nodetype/NodeDefinitionTemplate/index.d.ts

@@ -1,3 +1,5 @@
+import NodeDefinition from "../NodeDefinition";
+
 /**
  * The <code>NodeDefinitionTemplate</code> interface extends
  * <code>NodeDefinition</code> with the addition of write methods, enabling the
@@ -9,10 +11,7 @@
  * <code>NodeDefinitionTemplate</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. This must be a JCR name in either
- * qualified or expanded form.Sets the auto-create status of the node.Sets the mandatory status of the node.Sets the on-parent-version status of the node.Sets the protected status of the node.Sets the names of the required primary types of this node.
- * These must be a JCR names in either qualified or expanded form.Sets the name of the default primary type of this node.
- * This must be a JCR name in either qualified or expanded form.Sets the same-name sibling status of this node.
+ * <p><strong>Sitevision note:</strong> Unsupported operation</p>
  * @since JCR 2.0
  */
 interface NodeDefinitionTemplate {

package/hidden/javax/jcr/nodetype/NodeDefinitionTemplate/index.js

@@ -0,0 +1,17 @@
+"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() {},
+  setRequiredPrimaryTypeNames: function setRequiredPrimaryTypeNames() {},
+  setDefaultPrimaryTypeName: function setDefaultPrimaryTypeName() {},
+  setSameNameSiblings: function setSameNameSiblings() {}
+};
+exports["default"] = _default;

package/hidden/javax/jcr/nodetype/NodeType/index.d.ts

@@ -1,69 +1,13 @@
 import NodeTypeIterator from "../NodeTypeIterator";
+
 import PropertyDefinition from "../PropertyDefinition";
 import NodeDefinition from "../NodeDefinition";
 import Value from "../../Value";
+import NodeTypeDefinition from "../NodeTypeDefinition";
 
 /**
  * A <code>NodeType</code> object represents a "live" node type that is
- * registered in the repository.Returns all supertypes of this node type in the node type inheritance
- * hierarchy. For primary types apart from <code>nt:base</code>, this list
- * will always include at least <code>nt:base</code>. For mixin types, there
- * is no required supertype.
- *
- * <p><strong>Sitevision note:</strong> Unsupported operation</p>Returns the <i>direct</i> supertypes of this node type in the node type
- * inheritance hierarchy, that is, those actually declared in this node
- * type. In single-inheritance systems, this will always be an array of size
- * 0 or 1. In systems that support multiple inheritance of node types this
- * array may be of size greater than 1.
- *
- * <p><strong>Sitevision note:</strong> Unsupported operation</p>Returns all subtypes of this node type in the node type inheritance
- * hierarchy.
- *
- * <p><strong>Sitevision note:</strong> Unsupported operation</p>Returns the <i>direct</i> subtypes of this node type in the node type
- * inheritance hierarchy, that is, those which actually declared this node
- * type in their list of supertypes.
- *
- * <p><strong>Sitevision note:</strong> Unsupported operation</p>Returns <code>true</code> if the name of <i>this</i> node type or any of
- * its direct or indirect supertypes is equal to <code>nodeTypeName</code>,
- * otherwise returns <code>false</code>.Returns an array containing the property definitions of this node type.
- * This includes both those property definitions actually declared in this
- * node type and those inherited from the supertypes of this type.
- *
- * <p><strong>Sitevision note:</strong> Unsupported operation</p>Returns an array containing the child node definitions of this node type.
- * This includes both those child node definitions actually declared in this
- * node type and those inherited from the supertypes of this node type.
- *
- * <p><strong>Sitevision note:</strong> Unsupported operation</p>Returns <code>true</code> if setting <code>propertyName</code> to
- * <code>value</code> is allowed by this node type. Otherwise returns
- * <code>false</code>.
- *
- * <p><strong>Sitevision note:</strong> Unsupported operation</p>Returns <code>true</code> if setting <code>propertyName</code> to
- * <code>values</code> is allowed by this node type. Otherwise returns
- * <code>false</code>.
- *
- * <p><strong>Sitevision note:</strong> Unsupported operation</p>Returns <code>true</code> if this node type allows the addition of a
- * child node called <code>childNodeName</code> without specific node type
- * information (that is, given the definition of this parent node type, the
- * child node name is sufficient to determine the intended child node type).
- * Returns <code>false</code> otherwise.
- *
- * <p><strong>Sitevision note:</strong> Unsupported operation</p>Returns <code>true</code> if this node type allows the addition of a
- * child node called <code>childNodeName</code> of node type
- * <code>nodeTypeName</code>. Returns <code>false</code> otherwise.
- *
- * <p><strong>Sitevision note:</strong> Unsupported operation</p>Returns <code>true</code> if removing the child item called
- * <code>itemName</code> is allowed by this node type. Returns
- * <code>false</code> otherwise.
- *
- * <p><strong>Sitevision note:</strong> Unsupported operation</p>Returns <code>true</code> if removing the child node called
- * <code>nodeName</code> is allowed by this node type. Returns
- * <code>false</code> otherwise.
- *
- * <p><strong>Sitevision note:</strong> Unsupported operation</p>Returns <code>true</code> if removing the property called
- * <code>propertyName</code> is allowed by this node type. Returns
- * <code>false</code> otherwise.
- *
- * <p><strong>Sitevision note:</strong> Unsupported operation</p>A constant for the node type name <code>nt:base</code> (in expanded
+ * registered in the repository.A constant for the node type name <code>nt:base</code> (in expanded
  * form). Constants for the names of the properties declared by
  * <code>nt:base</code> are: <ul> <li>{@link javax.jcr.Property#JCR_PRIMARY_TYPE}</li>
  * <li>{@link javax.jcr.Property#JCR_MIXIN_TYPES}</li> </ul>A constant for the node type name <code>nt:hierarchyNode</code> (in
@@ -178,8 +122,36 @@ import Value from "../../Value";
  * form). Constants for the names of the properties declared by
  * <code>nt:query</code> are: <ul> <li>{@link javax.jcr.Property#JCR_STATEMENT}</li>
  * <li>{@link javax.jcr.Property#JCR_LANGUAGE}</li> </ul>
-  
-    */
+ * @since JCR 2.0
+ * @since JCR 2.0
+ * @since JCR 2.0
+ * @since JCR 2.0
+ * @since JCR 2.0
+ * @since JCR 2.0
+ * @since JCR 2.0
+ * @since JCR 2.0
+ * @since JCR 2.0
+ * @since JCR 2.0
+ * @since JCR 2.0
+ * @since JCR 2.0
+ * @since JCR 2.0
+ * @since JCR 2.0
+ * @since JCR 2.0
+ * @since JCR 2.0
+ * @since JCR 2.0
+ * @since JCR 2.0
+ * @since JCR 2.0
+ * @since JCR 2.0
+ * @since JCR 2.0
+ * @since JCR 2.0
+ * @since JCR 2.0
+ * @since JCR 2.0
+ * @since JCR 2.0
+ * @since JCR 2.0
+ * @since JCR 2.0
+ * @since JCR 2.0
+ * @since JCR 2.0
+ */
 interface NodeType {
   /**
    * Returns all supertypes of this node type in the node type inheritance

package/hidden/javax/jcr/nodetype/NodeType/index.js

@@ -0,0 +1,21 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _default = {
+  getSupertypes: function getSupertypes() {},
+  getDeclaredSupertypes: function getDeclaredSupertypes() {},
+  getSubtypes: function getSubtypes() {},
+  getDeclaredSubtypes: function getDeclaredSubtypes() {},
+  isNodeType: function isNodeType() {},
+  getPropertyDefinitions: function getPropertyDefinitions() {},
+  getChildNodeDefinitions: function getChildNodeDefinitions() {},
+  canSetProperty: function canSetProperty() {},
+  canAddChildNode: function canAddChildNode() {},
+  canRemoveItem: function canRemoveItem() {},
+  canRemoveNode: function canRemoveNode() {},
+  canRemoveProperty: function canRemoveProperty() {}
+};
+exports["default"] = _default;

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

@@ -11,90 +11,7 @@ import NodeDefinition from "../NodeDefinition";
  * implementations that support node type registration. In those cases it serves
  * as the superclass of both <code>NodeType</code> and <code>NodeTypeTemplate</code>.
  * In implementations that do not support node type registration, only objects
- * implementing the subinterface <code>NodeType</code> will be encountered.Returns the name of the 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>.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>Returns <code>true</code> if this is an abstract node type; returns
- * <code>false</code> otherwise.
- * <p>
- * An abstract node type is one that cannot be assigned as the primary or
- * mixin type of a node but can be used in the definitions of other node
- * types as a superclass.
- * <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>.Returns <code>true</code> if this is a mixin type; returns
- * <code>false</code> if it is primary.
- * <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>.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>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>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>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>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>
+ * implementing the subinterface <code>NodeType</code> will be encountered.
  * @since JCR 2.0
  */
 interface NodeTypeDefinition {

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

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

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

@@ -1,7 +1,8 @@
 import NodeType from "../NodeType";
+import 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 {