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

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

@@ -1,11 +1,12 @@
 import Session from "../../../../server/Session";
-import Version from "../version/Version";
-import LockManager from "../lock/LockManager";
-import QueryManager from "../query/QueryManager";
-import NamespaceRegistry from "../NamespaceRegistry";
-import NodeTypeManager from "../nodetype/NodeTypeManager";
-import ObservationManager from "../observation/ObservationManager";
-import VersionManager from "../version/VersionManager";
+
+import type { Version } from "../version/Version";
+import type { LockManager } from "../lock/LockManager";
+import type { QueryManager } from "../query/QueryManager";
+import type { NamespaceRegistry } from "../NamespaceRegistry";
+import type { NodeTypeManager } from "../nodetype/NodeTypeManager";
+import type { ObservationManager } from "../observation/ObservationManager";
+import type { VersionManager } from "../version/VersionManager";
 
 /**
  * A <code>Workspace</code> object represents a view onto a persitent workspace
@@ -14,427 +15,31 @@ import VersionManager from "../version/VersionManager";
  * object. Each <code>Workspace</code> object is associated one-to-one with a
  * <code>Session</code> object. The <code>Workspace</code> object can be
  * acquired by calling <code>{@link Session#getWorkspace()}</code> on the
- * associated <code>Session</code> object.Returns the <code>Session</code> object through which this
- * <code>Workspace</code> object was acquired.Returns the name of the actual persistent workspace represented by this
- * <code>Workspace</code> object. This the name used in
- * <code>Repository.login</code>.This method copies the subgraph rooted at, and including, the node at
- * <code>srcAbsPath</code> to the new location at <code>destAbsPath</code>.
- * <p>
- * This is a workspace-write operation and therefore dispatches changes
- * immediately and does not require a <code>save</code>.
- * <p>
- * When a node <code>N</code> is copied to a path location where no node
- * currently exists, a new node <code>N'</code> is created at that location.
- * The subgraph rooted at and including <code>N'</code> (call it <code>S'</code>)
- * is created and is identical to the subgraph rooted at and including <code>N</code>
- * (call it <code>S</code>) with the following exceptions:
- * <ul>
- * <li>Every node in <code>S'</code> is given a new and distinct identifier.</li>
- * <li>The repository <i>may</i> automatically drop any mixin node type <code>T</code>
- * present on any node <code>M</code> in <code>S</code>. Dropping a mixin node type
- * in this context means that while <code>M</code> remains unchanged, its copy
- * <code>M'</code> will lack the mixin <code>T</code> and any child nodes and properties
- * defined by <code>T</code> that are present on <code>M</code>. For example, a node
- * <code>M</code> that is <code>mix:versionable</code> may be copied such that the
- * resulting node <code>M'</code> will be a copy of <code>N</code> except that
- * <code>M'</code> will not be <code>mix:versionable</code> and will not have any of the
- * properties defined by <code>mix:versionable</code>. In order for a mixin node type to
- * be dropped it must be listed by name in the <code>jcr:mixinTypes</code> property of
- * <code>M</code>. The resulting <code>jcr:mixinTypes</code> property of <code>M'</code>
- * will reflect any change.</li>
- * <li>If a node <code>M</code> in <code>S</code> is referenceable and its
- * <code>mix:referenceable</code> mixin is not dropped on copy, then the resulting
- * <code>jcr:uuid</code> property of <code>M'</code> will reflect the new identifier
- * assigned to <code>M'</code>.</li>
- * <li>Each <code>REFERENCE</code> or <code>WEAKEREFERENCE</code> property <code>R</code>
- * in <code>S</code> is copied to its new location <code>R'</code> in <code>S'</code>.
- * If <code>R</code> references a node <code>M</code> within <code>S</code> then the value
- * of <code>R'</code> will be the identifier of <code>M'</code>, the new copy of
- * <code>M</code>, thus preserving the reference within the subgraph.</li>
- * </ul>
- * When a node <code>N</code> is copied to a location where a node <code>N'</code> already
- * exists, the repository may either immediately throw an <code>ItemExistsException</code>
- * or attempt to update the node <code>N'</code> by selectively replacing part of its subgraph
- * with a copy of the relevant part of the subgraph of <code>N</code>. If the node types of
- * <code>N</code> and <code>N'</code> are compatible, the implementation supports update-on-copy
- * for these node types and no other errors occur, then the copy will succeed. Otherwise an
- * <code>ItemExistsException</code> is thrown.
- * <p>
- * Which node types can be updated on copy and the details of any such updates are
- * implementation-dependent. For example, some implementations may support update-on-copy
- * for <code>mix:versionable</code> nodes. In such a case the versioning-related properties
- * of the target node would remain unchanged (<code>jcr:uuid</code>,
- * <code>jcr:versionHistory</code>, etc.) while the substantive content part of the subgraph
- * would be replaced with that of the source node.
- * <p>
- * The <code>destAbsPath</code> provided must not have an index on its final
- * element. If it does then a <code>RepositoryException</code> is thrown.
- * Strictly speaking, the <code>destAbsPath</code> parameter is actually an
- * <i>absolute path</i> to the parent node of the new location, appended
- * with the new <i>name</i> desired for the copied node. It does not specify
- * a position within the child node ordering. If ordering is supported by
- * the node type of the parent node of the new location, then the new copy
- * of the node is appended to the end of the child node list.
- * <p>
- * This method cannot be used to copy an individual property by itself. It
- * copies an entire node and its subgraph.
- *
- * <p><strong>Sitevision note:</strong> Unsupported operation</p>This method copies the subgraph at <code>srcAbsPath</code> in
- * <code>srcWorkspace</code> to <code>destAbsPath</code> in
- * <code>this</code> workspace.
- * <p>
- * When a node <code>N</code> is copied to a path location where no node
- * currently exists, a new node <code>N'</code> is created at that location.
- * The subgraph rooted at and including <code>N'</code> (call it <code>S'</code>)
- * is created and is identical to the subgraph rooted at and including <code>N</code>
- * (call it <code>S</code>) with the following exceptions:
- * <ul>
- * <li>Every referenceable node in <code>S'</code> is given a new and distinct identifier
- * while every non-referenceable node in <code>S'</code> <i>may</i> be given a new and
- * distinct identifier.</li>
- * <li>The repository <i>may</i> automatically drop any mixin node type <code>T</code>
- * present on any node <code>M</code> in <code>S</code>. Dropping a mixin node type
- * in this context means that while <code>M</code> remains unchanged, its copy
- * <code>M'</code> will lack the mixin <code>T</code> and any child nodes and properties
- * defined by <code>T</code> that are present on <code>M</code>. For example, a node
- * <code>M</code> that is <code>mix:versionable</code> may be copied such that the
- * resulting node <code>M'</code> will be a copy of <code>N</code> except that
- * <code>M'</code> will not be <code>mix:versionable</code> and will not have any of the
- * properties defined by <code>mix:versionable</code>. In order for a mixin node type to
- * be dropped it must be listed by name in the <code>jcr:mixinTypes</code> property of
- * <code>M</code>. The resulting <code>jcr:mixinTypes</code> property of <code>M'</code>
- * will reflect any change.</li>
- * <li>If a node <code>M</code> in <code>S</code> is referenceable and its
- * <code>mix:referenceable</code> mixin is not dropped on copy, then the resulting
- * <code>jcr:uuid</code> property of <code>M'</code> will reflect the new identifier
- * assigned to <code>M'</code>.</li>
- * <li>Each <code>REFERENCE</code> or <code>WEAKEREFERENCE</code> property <code>R</code>
- * in <code>S</code> is copied to its new location <code>R'</code> in <code>S'</code>.
- * If <code>R</code> references a node <code>M</code> within <code>S</code> then the value
- * of <code>R'</code> will be the identifier of <code>M'</code>, the new copy of
- * <code>M</code>, thus preserving the reference within the subgraph.</li>
- * </ul>
- * When a node <code>N</code> is copied to a location where a node <code>N'</code> already
- * exists, the repository may either immediately throw an <code>ItemExistsException</code>
- * or attempt to update the node <code>N'</code> by selectively replacing part of its subgraph
- * with a copy of the relevant part of the subgraph of <code>N</code>. If the node types of
- * <code>N</code> and <code>N'</code> are compatible, the implementation supports update-on-copy
- * for these node types and no other errors occur, then the copy will succeed. Otherwise an
- * <code>ItemExistsException</code> is thrown.
- * <p>
- * Which node types can be updated on copy and the details of any such updates are
- * implementation-dependent. For example, some implementations may support update-on-copy
- * for <code>mix:versionable</code> nodes. In such a case the versioning-related properties
- * of the target node would remain unchanged (<code>jcr:uuid</code>,
- * <code>jcr:versionHistory</code>, etc.) while the substantive content part of the subgraph
- * would be replaced with that of the source node.
- * <p>
- * The <code>destAbsPath</code> provided must not have an index on its final
- * element. If it does then a <code>RepositoryException</code> is thrown.
- * Strictly speaking, the <code>destAbsPath</code> parameter is actually an
- * <i>absolute path</i> to the parent node of the new location, appended
- * with the new <i>name</i> desired for the copied node. It does not specify
- * a position within the child node ordering. If ordering is supported by
- * the node type of the parent node of the new location, then the new copy
- * of the node is appended to the end of the child node list.
- * <p>
- * This method cannot be used to copy just an individual property by itself.
- * It copies an entire node and its subgraph (including, of course, any
- * properties contained therein).
- *
- * <p><strong>Sitevision note:</strong> Unsupported operation</p>Clones the subgraph at the node <code>srcAbsPath</code> in
- * <code>srcWorkspace</code> to the new location at <code>destAbsPath</code>
- * in <code>this</code> workspace.
- * <p>
- * Unlike the signature of <code>copy</code> that copies between workspaces,
- * this method <i>does not</i> assign new identifiers to the newly cloned
- * nodes but preserves the identifiers of their respective source nodes.
- * This applies to both referenceable and non-referenceable nodes.
- * <p>
- * In some implementations there may be cases where preservation of a
- * non-referenceable identifier is not possible, due to how
- * non-referenceable identifiers are constructed in that implementation. In
- * such a case this method will throw a <code>RepositoryException</code>.
- * <p>
- * If <code>removeExisting</code> is true and an existing node in this
- * workspace (the destination workspace) has the same identifier as a node
- * being cloned from <code>srcWorkspace</code>, then the incoming node takes
- * precedence, and the existing node (and its subgraph) is removed. If
- * <code>removeExisting</code> is false then an identifier collision causes
- * this method to throw a <code>ItemExistsException</code> and no changes
- * are made.
- * <p>
- * If successful, the change is persisted immediately, there is no need to
- * call <code>save</code>.
- * <p>
- * The <code>destAbsPath</code> provided must not have an index on its final
- * element. If it does then a <code>RepositoryException</code> is thrown. If
- * ordering is supported by the node type of the parent node of the new
- * location, then the new clone of the node is appended to the end of the
- * child node list.
- * <p>
- * This method cannot be used to clone just an individual property; it
- * clones an node and its subgraph.
- *
- * <p><strong>Sitevision note:</strong> Unsupported operation</p>Moves the node at <code>srcAbsPath</code> (and its entire subgraph) to
- * the new location at <code>destAbsPath</code>.
- * <p>
- * If successful, the change is persisted immediately, there is no need to
- * call <code>save</code>. Note that this is in contrast to {@link
- * Session#move} which operates within the transient space and hence
- * requires a <code>save</code>.
- * <p>
- * The identifiers of referenceable nodes must not be changed by a
- * <code>move</code>. The identifiers of non-referenceable nodes <i>may</i>
- * change.
- * <p>
- * The <code>destAbsPath</code> provided must not have an index on its final
- * element. If it does then a <code>RepositoryException</code> is thrown.
- * Strictly speaking, the <code>destAbsPath</code> parameter is actually an
- * <i>absolute path</i> to the parent node of the new location, appended
- * with the new <i>name</i> desired for the moved node. It does not specify
- * a position within the child node ordering. If ordering is supported by
- * the node type of the parent node of the new location, then the newly
- * moved node is appended to the end of the child node list.
- * <p>
- * This method cannot be used to move just an individual property by itself.
- * It moves an entire node and its subgraph (including, of course, any
- * properties contained therein).
- * <p>
- * The identifiers of referenceable nodes must not be changed by a
- * <code>move</code>. The identifiers of non-referenceable nodes may
- * change.
- * <p>
- * A <code>ConstraintViolationException</code> is thrown if the operation
- * would violate a node-type or other implementation-specific constraint.
- * <p>
- * A <code>VersionException</code> is thrown if the parent node of
- * <code>destAbsPath</code> or the parent node of <code>srcAbsPath</code> is
- * versionable and checked-in, or is non-versionable but its nearest
- * versionable ancestor is checked-in.
- * <p>
- * An <code>AccessDeniedException</code> is thrown if the current session
- * (i.e. the session that was used to acquire this <code>Workspace</code>
- * object) does not have sufficient access rights to complete the
- * operation.
- * <p>
- * A <code>PathNotFoundException</code> is thrown if the node at
- * <code>srcAbsPath</code> or the parent of <code>destAbsPath</code> does
- * not exist.
- * <p>
- * An <code>ItemExistException</code> is thrown if a node already exists at
- * <code>destAbsPath</code> and same-name siblings are not allowed.
- * <p>
- * Note that if a property already exists at <code>destAbsPath</code>, the
- * operation succeeds, since a node may have a child node and property with
- * the same name
- * <p>
- * A <code>LockException</code> if a lock prevents the move.
- *
- * <p><strong>Sitevision note:</strong> Unsupported operation</p>Restores a set of versions at once. Used in cases where a "chicken and
- * egg" problem of mutually referring <code>REFERENCE</code> properties
- * would prevent the restore in any serial order.
- * <p>
- * If the restore succeeds the changes made to <code>this</code> node are
- * persisted immediately, there is no need to call <code>save</code>.
- * <p>
- * The following restrictions apply to the set of versions specified:
- * <p>
- * If <code>S</code> is the set of versions being restored simultaneously,
- * <ul> <li> For every version <code>V</code> in <code>S</code> that
- * corresponds to a <i>missing</i> node, there must also be a parent of V in
- * S. </li> <li> <code>S</code> must contain at least one version that
- * corresponds to an existing node in the workspace. </li> <li> No
- * <code>V</code> in <code>S</code> can be a root version
- * (<code>jcr:rootVersion</code>). </li> </ul> If any of these restrictions
- * does not hold, the restore will fail because the system will be unable to
- * determine the path locations to which one or more versions are to be
- * restored. In this case a <code>VersionException</code> is thrown.
- * <p>
- * The versionable nodes in this workspace that correspond to the versions
- * being restored define a set of (one or more) subgraphs. An identifier
- * collision occurs when this workspace contains a node <i>outside these
- * subgraphs</i> that has the same identifier as one of the nodes that would
- * be introduced by the <code>restore</code> operation <i>into one of these
- * subgraphs</i>. The result in such a case is governed by the
- * <code>removeExisting</code> flag. If <code>removeExisting</code> is
- * <code>true</code> then the incoming node takes precedence, and the
- * existing node (and its subgraph) is removed. If <code>removeExisting</code>
- * is <code>false</code> then a <code>ItemExistsException</code> is thrown
- * and no changes are made. Note that this applies not only to cases where
- * the restored node itself conflicts with an existing node but also to
- * cases where a conflict occurs with any node that would be introduced into
- * the workspace by the restore operation. In particular, conflicts
- * involving subnodes of the restored node that have
- * <code>OnParentVersion</code> settings of <code>COPY</code> or
- * <code>VERSION</code> are also governed by the <code>removeExisting</code>
- * flag.
- *
- * <p><strong>Sitevision note:</strong> Unsupported operation</p>Returns the <code>LockManager</code> object, through which locking
- * methods are accessed.
- *
- * <p><strong>Sitevision note:</strong> Unsupported operation</p>Returns the <code>QueryManager</code> object, through search methods are
- * accessed.Returns the <code>NamespaceRegistry</code> object, which is used to
- * access the mapping between prefixes and namespaces. In level 2
- * repositories the <code>NamespaceRegistry</code> can also be used to
- * change the namespace mappings.Returns the <code>NodeTypeManager</code> through which node type
- * information can be queried. There is one node type registry per
- * repository, therefore the <code>NodeTypeManager</code> is not
- * workspace-specific; it provides introspection methods for the global,
- * repository-wide set of available node types. In repositories that support
- * it, the <code>NodeTypeManager</code> can also be used to register new
- * node types.Returns the <code>ObservationManager</code> object.
- *
- * <p><strong>Sitevision note:</strong> Unsupported operation</p>Returns the <code>VersionManager</code> object.
- *
- * <p><strong>Sitevision note:</strong> Unsupported operation</p>Returns a string array containing the names of all workspaces in this
- * repository that are accessible to this user, given the
- * <code>Credentials</code> that were used to get the <code>Session</code>
- * to which this <code>Workspace</code> is tied.
- * <p>
- * In order to access one of the listed workspaces, the user performs
- * another {@link Repository#login}, specifying the name of the desired
- * workspace, and receives a new <code>Session</code> object.Returns an <code>org.xml.sax.ContentHandler</code> which can be used to
- * push SAX events into the repository. If the incoming XML stream (in the
- * form of SAX events) does not appear to be a JCR system view XML document
- * then it is interpreted as a document view XML document.
- * <p>
- * The incoming XML is deserialized into a subgraph of items immediately
- * below the node at <code>parentAbsPath</code>.
- * <p>
- * This method simply returns the <code>ContentHandler</code> without
- * altering the state of the repository; the actual deserialization is done
- * through the methods of the <code>ContentHandler</code>. Invalid XML data
- * will cause the <code>ContentHandler</code> to throw a
- * <code>SAXException</code>.
- * <p>
- * As SAX events are fed into the <code>ContentHandler</code>, changes are
- * made directly at the workspace level, without going through the
- * <code>Session</code>. As a result, there is not need to call
- * <code>save</code>. The advantage of this direct-to-workspace method is
- * that a large import will not result in a large cache of pending nodes in
- * the <code>Session</code>. The disadvantage is that structures that
- * violate node type constraints cannot be imported, fixed and then saved.
- * Instead, a constraint violation will cause the <code>ContentHandler</code>
- * to throw a <code>SAXException</code>. See <code>Session.getImportContentHandler</code>
- * for a version of this method that <i>does</i> go through the
- * <code>Session</code>.
- * <p>
- * The flag <code>uuidBehavior</code> governs how the identifiers of
- * incoming (deserialized) nodes are handled. There are four options: <ul>
- * <li>{@link ImportUUIDBehavior#IMPORT_UUID_CREATE_NEW}: Incoming nodes are
- * assigned newly created identifiers upon addition to the workspace. As a
- * result identifier collisions never occur. <li>{@link
- * ImportUUIDBehavior#IMPORT_UUID_COLLISION_REMOVE_EXISTING}: If an incoming
- * node has the same identifier as a node already existing in the workspace,
- * then the already existing node (and its subgraph) is removed from
- * wherever it may be in the workspace before the incoming node is added.
- * Note that this can result in nodes "disappearing" from locations in the
- * workspace that are remote from the location to which the incoming
- * subgraph is being written. <li>{@link ImportUUIDBehavior#IMPORT_UUID_COLLISION_REPLACE_EXISTING}:
- * If an incoming node has the same identifier as a node already existing in
- * the workspace then the already existing node is replaced by the incoming
- * node in the same position as the existing node. Note that this may result
- * in the incoming subgraph being disaggregated and "spread around" to
- * different locations in the workspace. In the most extreme case this
- * behavior may result in no node at all being added as child of
- * <code>parentAbsPath</code>. This will occur if the topmost element of the
- * incoming XML has the same identifier as an existing node elsewhere in the
- * workspace. <li>{@link ImportUUIDBehavior#IMPORT_UUID_COLLISION_THROW}: If
- * an incoming node has the same identifier as a node already existing in
- * the workspace then a <code>SAXException</code> is thrown by the returned
- * <code>ContentHandler</code> during deserialization. </ul> A
- * <code>SAXException</code> will be thrown by the returned
- * <code>ContentHandler</code> during deserialization if the top-most
- * element of the incoming XML would deserialize to a node with the same
- * name as an existing child of <code>parentAbsPath</code> and that child
- * does not allow same-name siblings.
- * <p>
- * A <code>SAXException</code> will also be thrown by the returned
- * <code>ContentHandler</code> during deserialization if
- * <code>uuidBehavior</code> is set to <code>IMPORT_UUID_COLLISION_REMOVE_EXISTING</code>
- * and an incoming node has the same identifier as the node at
- * <code>parentAbsPath</code> or one of its ancestors.
- *
- * <p><strong>Sitevision note:</strong> Unsupported operation</p>Deserializes an XML document and adds the resulting item subgraph as a
- * child of the node at <code>parentAbsPath</code>.
- * <p>
- * If the incoming XML stream does not appear to be a JCR system view XML
- * document then it is interpreted as a <b>document view</b> XML document.
- * <p>
- * The passed <code>InputStream</code> is closed before this method returns
- * either normally or because of an exception.
- * <p>
- * Changes are made directly at the workspace level, without going through
- * the <code>Session</code>. As a result, there is not need to call
- * <code>save</code>. The advantage of this direct-to-workspace method is
- * that a large import will not result in a large cache of pending nodes in
- * the <code>Session</code>. The disadvantage is that invalid data cannot be
- * imported, fixed and then saved. Instead, invalid data will cause this
- * method to throw an <code>InvalidSerializedDataException</code>. See
- * <code>Session.importXML</code> for a version of this method that
- * <i>does</i> go through the <code>Session</code>.
- * <p>
- * The flag <code>uuidBehavior</code> governs how the identifiers of
- * incoming (deserialized) nodes are handled. There are four options: <ul>
- * <li>{@link ImportUUIDBehavior#IMPORT_UUID_CREATE_NEW}: Incoming nodes are
- * assigned newly created identifiers upon addition to the workspace. As a
- * result identifier collisions never occur. <li>{@link
- * ImportUUIDBehavior#IMPORT_UUID_COLLISION_REMOVE_EXISTING}: If an incoming
- * node has the same identifier as a node already existing in the workspace
- * then the already existing node (and its subgraph) is removed from
- * wherever it may be in the workspace before the incoming node is added.
- * Note that this can result in nodes "disappearing" from locations in the
- * workspace that are remote from the location to which the incoming
- * subgraph is being written. If an incoming node has the same identifier as
- * the existing root node of this workspace then <li>{@link
- * ImportUUIDBehavior#IMPORT_UUID_COLLISION_REPLACE_EXISTING}: If an
- * incoming node has the same identifier as a node already existing in the
- * workspace then the already existing node is replaced by the incoming node
- * in the same position as the existing node. Note that this may result in
- * the incoming subgraph being disaggregated and "spread around" to
- * different locations in the workspace. In the most extreme edge case this
- * behavior may result in no node at all being added as child of
- * <code>parentAbsPath</code>. This will occur if the topmost element of the
- * incoming XML has the same identifier as an existing node elsewhere in the
- * workspace. <li>{@link ImportUUIDBehavior#IMPORT_UUID_COLLISION_THROW}: If
- * an incoming node has the same identifier as a node already existing in
- * the workspace then an <code>ItemExistsException</code> is thrown. </ul>
- * An <code>ItemExistsException</code> will be thrown if the top-most
- * element of the incoming XML would deserialize to a node with the same
- * name as an existing child of <code>parentAbsPath</code> and that child
- * does not allow same-name siblings.
- *
- * <p><strong>Sitevision note:</strong> Unsupported operation</p>Creates a new <code>Workspace</code> with the specified
- * <code>name</code>. The new workspace is empty, meaning it contains only
- * root node.
- * <p>
- * The new workspace can be accessed through a <code>login</code> specifying
- * its name.
- *
- * <p><strong>Sitevision note:</strong> Unsupported operation</p>Creates a new <code>Workspace</code> with the specified <code>name</code>
- * initialized with a <code>clone</code> of the content of the workspace
- * <code>srcWorkspace</code>. Semantically, this method is equivalent to
- * creating a new workspace and manually cloning <code>srcWorkspace</code>
- * to it; however, this method may assist some implementations in optimizing
- * subsequent <code>Node.update</code> and <code>Node.merge</code> calls
- * between the new workspace and its source.
- * <p>
- * The new workspace can be accessed through a <code>login</code> specifying
- * its name.
- *
- * <p><strong>Sitevision note:</strong> Unsupported operation</p>Deletes the workspace with the specified <code>name</code> from the
- * repository, deleting all content within it.
- *
- * <p><strong>Sitevision note:</strong> Unsupported operation</p>A constant for the name of the workspace root node.A constant for the absolute path of the workspace root node.A constant for the name of the system node.A constant for the absolute path of the system node.A constant for the name of the node type definition storage node.A constant for the absolute path of the node type definition storage
+ * associated <code>Session</code> object.A constant for the name of the workspace root node.A constant for the absolute path of the workspace root node.A constant for the name of the system node.A constant for the absolute path of the system node.A constant for the name of the node type definition storage node.A constant for the absolute path of the node type definition storage
  * node.A constant for the name of the version storage node.A constant for the absolute path of the version storage node.A constant for the name of the activities node.A constant for the absolute path of the activities node.A constant for the name of the configurations node.A constant for the absolute path of the configurations node.A constant for the name of the unfiled storage node.A constant for the absolute path of the unfiled storage node.A constant for the name of the <code>jcr:xmltext</code> node produced on
  * {@link #importXML}.A constant for the name of the <code>jcr:xmlcharacters</code> property
  * produced on {@link #importXML}.A constant for the relative path from the node representing the imported
  * XML element of the <code>jcr:xmlcharacters</code> property produced on
  * {@link #importXML}.
-  
-    */
-interface Workspace {
+ * @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
+ */
+export type Workspace = {
   /**
    * Returns the <code>Session</code> object through which this
    * <code>Workspace</code> object was acquired.
@@ -1056,6 +661,4 @@ interface Workspace {
    * @since JCR 2.0
    */
   deleteWorkspace(name: string): void;
-}
-
-export default Workspace;
+};

package/types/javax/jcr/Workspace/index.js

@@ -0,0 +1,26 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _default = {
+  getSession: function getSession() {},
+  getName: function getName() {},
+  copy: function copy() {},
+  clone: function clone() {},
+  move: function move() {},
+  restore: function restore() {},
+  getLockManager: function getLockManager() {},
+  getQueryManager: function getQueryManager() {},
+  getNamespaceRegistry: function getNamespaceRegistry() {},
+  getNodeTypeManager: function getNodeTypeManager() {},
+  getObservationManager: function getObservationManager() {},
+  getVersionManager: function getVersionManager() {},
+  getAccessibleWorkspaceNames: function getAccessibleWorkspaceNames() {},
+  getImportContentHandler: function getImportContentHandler() {},
+  importXML: function importXML() {},
+  createWorkspace: function createWorkspace() {},
+  deleteWorkspace: function deleteWorkspace() {}
+};
+exports["default"] = _default;

package/{hidden → types}/javax/jcr/lock/Lock/index.d.ts

@@ -1,48 +1,12 @@
-import Node from "../../Node";
+import type { 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 {
+export type Lock = {
   /**
    * Returns the value of the <code>jcr:lockOwner</code> property. This is
    * either the client supplied owner information (see {@link
@@ -137,6 +101,4 @@ interface Lock {
    * @throws RepositoryException if another error occurs.
    */
   refresh(): void;
-}
-
-export default Lock;
+};

package/types/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;