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

package/hidden/javax/jcr/version/Version/index.d.ts

@@ -1,39 +1,12 @@
 import VersionHistory from "../VersionHistory";
+
 import Node from "../../Node";
 
 /**
  * A <code>Version</code> object wraps an <code>nt:version</code> node. It
  * provides convenient access to version information.
  *
- * <p><strong>Sitevision note:</strong> Unsupported operation</p>Returns the <code>VersionHistory</code> that contains this
- * <code>Version</code>.Returns the date this version was created. This corresponds to the value
- * of the <code>jcr:created</code> property in the <code>nt:version</code>
- * node that represents this version.Assuming that this <code>Version</code> object was acquired through a
- * <code>Workspace</code> <code>W</code> and is within the
- * <code>VersionHistory</code> <code>H</code>, this method returns the
- * successor of this version along the same line of descent as is returned
- * by <code>H.getAllLinearVersions()</code> where <code>H</code> was also
- * acquired through <code>W</code>.
- * <p>
- * Note that under simple versioning the behavior of this method is
- * equivalent to getting the unique successor (if any) of this version.Returns the successor versions of this version. This corresponds to
- * returning all the <code>nt:version</code> nodes referenced by the
- * <code>jcr:successors</code> multi-value property in the
- * <code>nt:version</code> node that represents this version.
- * <p>
- * In a simple versioning repository this methodAssuming that this <code>Version</code> object was acquired through a
- * <code>Workspace</code> <code>W</code> and is within the
- * <code>VersionHistory</code> <code>H</code>, this method returns the
- * predecessor of this version along the same line of descent as is returned
- * by <code>H.getAllLinearVersions()</code> where <code>H</code> was also
- * acquired through <code>W</code>.
- * <p>
- * Note that under simple versioning the behavior of this method is
- * equivalent to getting the unique predecessor (if any) of this version.In both simple and full versioning repositories, this method returns the
- * predecessor versions of this version. This corresponds to returning all
- * the <code>nt:version</code> nodes whose <code>jcr:successors</code>
- * property includes a reference to the <code>nt:version</code> node that
- * represents this version.Returns the frozen node of this version.
+ * <p><strong>Sitevision note:</strong> Unsupported operation</p>
   
     */
 interface Version {

package/hidden/javax/jcr/version/Version/index.js

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _default = {
+  getContainingHistory: function getContainingHistory() {},
+  getCreated: function getCreated() {},
+  getLinearSuccessor: function getLinearSuccessor() {},
+  getSuccessors: function getSuccessors() {},
+  getLinearPredecessor: function getLinearPredecessor() {},
+  getPredecessors: function getPredecessors() {},
+  getFrozenNode: function getFrozenNode() {}
+};
+exports["default"] = _default;

package/hidden/javax/jcr/version/VersionHistory/index.d.ts

@@ -2,90 +2,13 @@ import Version from "../Version";
 import VersionIterator from "../VersionIterator";
 import NodeIterator from "../../NodeIterator";
 
+import Node from "../../Node";
+
 /**
  * A <code>VersionHistory</code> object wraps an <code>nt:versionHistory</code>
  * node. It provides convenient access to version history information.
  *
- * <p><strong>Sitevision note:</strong> Unsupported operation</p>Returns the identifier of the versionable node for which this is the
- * version history.Returns the identifier of the versionable node for which this is the
- * version history.Returns the root version of this version history.This method returns an iterator over all the versions in the <i>line of
- * descent</i> from the root version to that base version within this
- * history <i>that is bound to the workspace through which this
- * <code>VersionHistory</code> was accessed</i>.
- * <p>
- * Within a version history <code>H</code>, <code>B</code> is the base
- * version bound to workspace <code>W</code> if and only if there exists a
- * versionable node <code>N</code> in <code>W</code> whose version history
- * is <code>H</code> and <code>B</code> is the base version of
- * <code>N</code>.
- * <p>
- * The <i>line of descent</i> from version <code>V1</code> to
- * <code>V2</code>, where <code>V2</code> is a successor of <code>V1</code>,
- * is the ordered list of versions starting with <code>V1</code> and
- * proceeding through each direct successor to <code>V2</code>.
- * <p>
- * The versions are returned in order of creation date, from oldest to
- * newest.
- * <p>
- * Note that in a simple versioning repository the behavior of this method
- * is equivalent to returning all versions in the version history in order
- * from oldest to newest.Returns an iterator over all the versions within this version history. If
- * the version graph of this history is linear then the versions are
- * returned in order of creation date, from oldest to newest. Otherwise the
- * order of the returned versions is implementation-dependent.This method returns all the frozen nodes of all the versions in this
- * version history in the same order as {@link #getAllLinearVersions}.Returns an iterator over all the frozen nodes of all the versions of this
- * version history. Under simple versioning the order of the returned nodes
- * will be the order of their creation. Under full versioning the order is
- * implementation-dependent.Retrieves a particular version from this version history by version
- * name.Retrieves a particular version from this version history by version
- * label.Adds the specified label to the specified version.
- * <p>
- * The label must be a JCR name in either qualified or expanded form and
- * therefore must conform to the syntax restriction that apply to such
- * names. In particular a colon (":") should not be used unless it is
- * intended as a prefix delimiter in a qualified name.
- * <p>
- * Adding a version label to a version corresponds to adding a reference
- * property with a name specified by the <code>label</code> parameter to the
- * <code>jcr:versionLabels</code> sub node of the <code>nt:versionHistory</code>
- * node. The reference property points to the <code>nt:version</code> node
- * that represents the specified version.
- * <p>
- * This is a workspace-write method and therefore the change is made
- * immediately.
- * <p>
- * Within a particular version history, a given label may appear a maximum
- * of once. If the specified label is already assigned to a version in this
- * history and <code>moveLabel</code> is <code>true</code> then the label is
- * removed from its current location and added to the version with the
- * specified <code>versionName</code>. If <code>moveLabel</code> is
- * <code>false</code>, then an attempt to add a label that already exists
- * will fail.Removes the specified label from among the labels of this version
- * history. The label must be a JCR name in either qualified or expanded
- * form. This corresponds to removing a property from the
- * <code>jcr:versionLabels</code> child node of the <code>nt:versionHistory</code>
- * node that represents this version history.
- * <p>
- * This is workspace-write method and therefore the change is made
- * immediately.Returns <code>true</code> if any version in the history has the given
- * <code>label</code>. The label must be a JCR name in either qualified or
- * expanded form.Returns true if the given version has the given <code>label</code>. The
- * label must be a JCR name in either qualified or expanded form.Returns all version labels of the history or an empty array if there are
- * none.Returns all version labels of the given <code>version</code> - empty
- * array if none. Throws a <code>VersionException</code> if the specified
- * <code>version</code> is not in this version history.Removes the named version from this version history and automatically
- * repairs the version graph. If the version to be removed is
- * <code>V</code>, <code>V</code>'s predecessor set is <code>P</code> and
- * <code>V</code>'s successor set is <code>S</code>, then the version graph
- * is repaired s follows: <ul> <li>For each member of <code>P</code>, remove
- * the reference to <code>V</code> from its successor list and add
- * references to each member of <code>S</code>. <li>For each member of
- * <code>S</code>, remove the reference to <code>V</code> from its
- * predecessor list and add references to each member of <code>P</code>.
- * </ul> Note that this change is made immediately; there is no need to call
- * <code>save</code>. In fact, since the the version storage is read-only
- * with respect to normal repository methods, <code>save</code> does not
- * even function in this context.
+ * <p><strong>Sitevision note:</strong> Unsupported operation</p>
   
     */
 interface VersionHistory {

package/hidden/javax/jcr/version/VersionHistory/index.js

@@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _default = {
+  getVersionableUUID: function getVersionableUUID() {},
+  getVersionableIdentifier: function getVersionableIdentifier() {},
+  getRootVersion: function getRootVersion() {},
+  getAllLinearVersions: function getAllLinearVersions() {},
+  getAllVersions: function getAllVersions() {},
+  getAllLinearFrozenNodes: function getAllLinearFrozenNodes() {},
+  getAllFrozenNodes: function getAllFrozenNodes() {},
+  getVersion: function getVersion() {},
+  getVersionByLabel: function getVersionByLabel() {},
+  addVersionLabel: function addVersionLabel() {},
+  removeVersionLabel: function removeVersionLabel() {},
+  hasVersionLabel: function hasVersionLabel() {},
+  getVersionLabels: function getVersionLabels() {},
+  removeVersion: function removeVersion() {}
+};
+exports["default"] = _default;

package/hidden/javax/jcr/version/VersionIterator/index.d.ts

@@ -1,11 +1,12 @@
 import Version from "../Version";
+import RangeIterator from "../../RangeIterator";
 
 /**
  * Allows easy iteration through a list of <code>Version</code>s objects with
  * <code>nextVersion</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>Version</code> in the iteration.
+ * <p><strong>Sitevision note:</strong> Unsupported operation</p>
   
     */
 interface VersionIterator {

package/hidden/javax/jcr/version/VersionIterator/index.js

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

package/hidden/javax/jcr/version/VersionManager/index.d.ts

@@ -1,4 +1,5 @@
 import Version from "../Version";
+
 import VersionHistory from "../VersionHistory";
 import NodeIterator from "../../NodeIterator";
 import Node from "../../Node";
@@ -11,408 +12,7 @@ import Node from "../../Node";
  * checkpoint)</li> <li>Restore feature</li> <li>Label feature</li> <li>Merge
  * feature</li> <li>Configuration feature</li> <li>Activity feature</li> </ul>
  *
- * <p><strong>Sitevision note:</strong> Unsupported operation</p>Creates for the versionable node at <code>absPath</code> a new version
- * with a system generated version name and returns that version (which will
- * be the new base version of this node). Sets the <code>jcr:checkedOut</code>
- * property to false thus putting the node into the <i>checked-in</i> state.
- * This means that the node and its <i>connected non-versionable
- * subgraph</i> become read-only. A node's connected non-versionable
- * subgraph is the set of non-versionable descendant nodes reachable from
- * that node through child links without encountering any versionable nodes.
- * In other words, the read-only status flows down from the checked-in node
- * along every child link until either a versionable node is encountered or
- * an item with no children is encountered. In a system that supports only
- * simple versioning the connected non-versionable subgraph will be
- * equivalent to the whole subgraph, since simple-versionable nodes cannot
- * have simple-versionable descendants.
- * <p>
- * Read-only status means that an item cannot be altered by the client using
- * standard API methods (<code>addNode</code>, <code>setProperty</code>,
- * etc.). The only exceptions to this rule are the {@link #restore} (all
- * signatures), {@link #restoreByLabel}, {@link #restore}, {@link #merge}
- * and {@link Node#update} operations; these do not respect read-only status
- * due to check-in. Note that <code>remove</code> of a read-only node is
- * possible, as long as its parent is not read-only (since removal is an
- * alteration of the parent node).
- * <p>
- * If the node is already checked-in, this method has no effect but returns
- * the current base version of the node at <code>absPath</code>.
- * <p>
- * If a repository supports configurations and baselines and the node at
- * <code>absPath</code> is a configuration proxy node in configuration storage
- * then checkin of that node has the additional side effect of storing in the
- * created version, the state of the configuration that this proxy node represents.
- * In particular, the current bs version of each versionable node within the
- * configuration is recorded in some implementation-specific way within the
- * version created by the checkin. For checkin to succeed on a configuration
- * proxy node, every versionable node within the configuration in question must
- * have been checked-in at least once (i.e., each must have a current base version
- * which is not the root version of its version history).
- * <p>
- * If <code>checkin</code> succeeds, the change to the
- * <code>jcr:isCheckedOut</code> property is dispatched immediately;
- * there is no need to call <code>save</code>.Sets the versionable node at <code>absPath</code> to checked-out status
- * by setting its <code>jcr:isCheckedOut</code> property to
- * <code>true</code>. Under full versioning it also sets the
- * <code>jcr:predecessors</code> property to be a reference to the current
- * base version (the same value as held in <code>jcr:baseVersion</code>).
- * <p> This method puts the node into the <i>checked-out</i> state, making
- * it and its connected non-versionable subgraph no longer read-only (see
- * {@link #checkin(String)} for an explanation of the term "connected
- * non-versionable subgraph". Under simple versioning this will simply be
- * the whole subgraph). <p> If successful, these changes are dispatched
- * immediately; there is no need to call <code>save</code>. <p> If the node
- * at <code>absPath</code> is already checked-out, this method has no
- * effect.Performs a <code>checkin()</code> followed by a <code>checkout()</code>
- * on the versionable node at <code>absPath</code>.
- * <p>
- * If the node is already checked-in, this method is equivalent to
- * <code>checkout()</code>.Returns <code>true</code> if the node at <code>absPath</code> is either
- * <ul> <li>versionable (full or simple) and currently checked-out,</li>
- * <li>non-versionable and its nearest versionable ancestor is checked-out
- * or</li> <li>non-versionable and it has no versionable ancestor.</li>
- * </ul>
- * <p>
- * Returns <code>false</code> if the node at <code>absPath</code> is either
- * <ul> <li>versionable (full or simple) and currently checked-in or</li>
- * <li>non-versionable and its nearest versionable ancestor is
- * checked-in.</li> </ul>Returns the <code>VersionHistory</code> object of the node at
- * <code>absPath</code>. This object provides access to the
- * <code>nt:versionHistory</code> node holding the node's versions.Returns the current base version of the versionable node at
- * <code>absPath</code>.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 are
- * dispatched 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>
- * <p>
- * 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 the current workspace that correspond to the
- * versions being restored define a set of (one or more) subgraphs. An
- * identifier collision occurs when the current 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.Restores the node at <code>absPath</code> to the state defined by the
- * version with the specified <code>versionName</code>.
- * <p>
- * If the node at <code>absPath</code> is not versionable, an
- * <code>UnsupportedRepositoryOperationException</code> is thrown.
- * <p>
- * If successful, the change is dispatched immediately; there is no need
- * to call <code>save</code>. This method will work regardless of whether
- * the node at <code>absPath</code> is checked-in or not.
- * <p>
- * An identifier collision occurs when a node exists <i>outside the subgraph
- * rooted at this node</i> with the same identifier as a node that would be
- * introduced by the <code>restore</code> operation <i>into the subgraph at
- * this node</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 possible; otherwise a
- * <code>RepositoryException</code> is thrown). 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.Restores the node in the current workspace that is the versionable node of the
- * specified <code>version</code> to the state reflected in that version.
- * <p>
- * If successful, the change is dispatched immediately; there is no need to call <code>save</code>.
- * This method ignores checked-in status.
- * <p>
- * An identifier collision occurs when a node exists <i>outside the subgraph
- * rooted at this node</i> with the same identifier as a node that would be
- * introduced by the <code>restore</code> operation <i>into the subgraph at
- * this node</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 possible; otherwise a
- * <code>RepositoryException</code> is thrown). 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.Restores the specified version to <code>absPath</code>.
- * <p>
- * There must be no existing node at <code>absPath</code>. If one exists,
- * a <code>VersionException</code> is thrown.
- * <p>
- * There must be a parent node to the location at
- * <code>absPath</code>, otherwise a <code>PathNotFoundException</code>
- * is thrown.
- * <p>
- * An identifier collision occurs when a node exists <i>outside the subgraph
- * rooted at <code>absPath</code></i> with the same identifier as a node
- * that would be introduced by the <code>restore</code> operation <i>into
- * the subgraph at <code>absPath</code></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
- * possible; otherwise a <code>RepositoryException</code> is thrown). 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>
- * If the would-be parent of the location <code>absPath</code> is actually a
- * property, or if a node type restriction would be violated, then a
- * <code>ConstraintViolationException</code> is thrown.
- * <p>
- * If the <code>restore</code> succeeds, the changes made to this node are
- * dispatched immediately; there is no need to call <code>save</code>.Restores the version of the node at <code>absPath</code> with the
- * specified version label. If successful, the change is dispatched
- * immediately; there is no need to call <code>save</code>.
- * <p>
- * This method will work regardless of whether the node at
- * <code>absPath</code> is checked-in or not.
- * <p>
- * An identifier collision occurs when a node exists <i>outside the subgraph
- * rooted at this node</i> with the same identifier as a node that would be
- * introduced by the <code>restoreByLabel</code> operation <i>into the
- * subgraph at this node</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 possible; otherwise a
- * <code>RepositoryException</code> is thrown). 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.This method recursively tests each versionable node in the subgraph of
- * the node at <code>absPath</code> against its corresponding node in
- * <code>srcWorkspace</code> with respect to the relation between their
- * respective base versions and either updates the node in question or not,
- * depending on the outcome of the test.
- * <p>
- * When a versionable node V with base version B is encountered whose
- * corresponding node V' has a base version B': <ul> <li>If B' is an
- * eventual predecessor of B then V is left unchanged.</li> <li>If B' is an
- * eventual successor of B then V is updated to the state of V'.</li> <li>If
- * B' and B are ob divergent branches of the version history then V
- * <i>fails</i> the merge.</li> </ul> If <code>bestEffort</code> is
- * <code>true</code> then each failed node is marked and traversal
- * continues. If <code>bestEffort</code> is <code>false</code> then the
- * first failed node results in a <code>MergeException</code>.
- * <p>
- * This is a workspace-write method and therefore any changes are dispatched
- * immediately; there is no need to call <code>save</code>.
- * <p>
- * This method returns a <code>NodeIterator</code> over all versionable
- * nodes in the subgraph that received a merge result of <i>fail</i>. If
- * <code>bestEffort</code> is <code>false</code>, this iterator will be
- * empty (since if <code>merge</code> returns successfully, instead of
- * throwing an exception, it will be because no failures were encountered).
- * If <code>bestEffort</code> is <code>true</code>, this iterator will
- * contain all nodes that received a <i>fail</i> during the course of this
- * <code>merge</code> operation.
- * <p>
- * See the JCR specifications for more details on the behavior of this
- * method.Same as {@link #merge(String absPath, String srcWorkspace, boolean
- * bestEffort)} except that an option exists to make the merge
- * <i>shallow</i>.
- * <p>
- * If <code>isShallow</code> is <code>true</code>, this method tests this
- * versionable node against its corresponding node in
- * <code>srcWorkspace</code> with respect to the relation between their
- * respective base versions and either updates the node in question or not,
- * depending on the outcome of the test.
- * <p>
- * If <code>isShallow</code> is <code>false</code>, it recursively tests
- * each versionable node in the subgraph as mentioned above. See {@link
- * #merge(String absPath, String srcWorkspace, boolean bestEffort)}.
- * <p>
- * If <code>isShallow</code> is <code>true</code> and this node is not
- * versionable, then this method returns and no changes are made.
- * <p>
- * If successful, the changes are dispatched immediately; there is no need to
- * call <code>save</code>.
- * <p>
- * This method returns a <code>NodeIterator</code> over all versionable
- * nodes in the subgraph that received a merge result of <i>fail</i>. If
- * <code>bestEffort</code> is <code>false</code>, this iterator will be
- * empty (since if <code>merge</code> returns successfully, instead of
- * throwing an exception, it will be because no failures were encountered).
- * If <code>bestEffort</code> is <code>true</code>, this iterator will
- * contain all nodes that received a <i>fail</i> during the course of this
- * <code>merge</code> operation.Completes the merge process with respect to the node at
- * <code>absPath</code> and the specified <code>version</code>.
- * <p>
- * When the {@link #merge} method is called on a node, every versionable
- * node in that subgraph is compared with its corresponding node in the
- * indicated other workspace and a "merge test result" is determined
- * indicating one of the following:
- * </p>
- * <ol> <li> This node will be updated to the state of its correspondee (if
- * the base version of the correspondee is more recent in terms of version
- * history) </li> <li> This node will be left alone (if this node's base
- * version is more recent in terms of version history). </li> <li> This node
- * will be marked as having failed the merge test (if this node's base
- * version is on a different branch of the version history from the base
- * version of its corresponding node in the other workspace, thus preventing
- * an automatic determination of which is more recent). </li> </ol>
- * <p>
- * (See {@link #merge} for more details)
- * </p>
- * <p>
- * In the last case the merge of the non-versionable subgraph (the
- * "content") of this node must be done by the application (for example, by
- * providing a merge tool for the user).
- * </p>
- * <p>
- * Additionally, once the content of the nodes has been merged, their
- * version graph branches must also be merged. The JCR versioning system
- * provides for this by keeping a record, for each versionable node that
- * fails the merge test, of the base version of the corresponding node that
- * caused the merge failure. This record is kept in the
- * <code>jcr:mergeFailed</code> property of this node. After a
- * <code>merge</code>, this property will contain one or more (if multiple
- * merges have been performed) <code>REFERENCE</code>s that point to the
- * "offending versions".
- * </p>
- * <p>
- * To complete the merge process, the client calls <code>doneMerge(Version
- * v)</code> passing the version object referred to be the
- * <code>jcr:mergeFailed</code> property that the client wishes to connect
- * to <code>this</code> node in the version graph. This has the effect of
- * moving the reference to the indicated version from the
- * <code>jcr:mergeFailed</code> property of <code>this</code> node to the
- * <code>jcr:predecessors</code>.
- * </p>
- * <p>
- * If the client chooses not to connect this node to a particular version
- * referenced in the <code>jcr:mergeFailed</code> property, he calls {@link
- * #cancelMerge(String, Version)}. This has the effect of removing the
- * reference to the specified <code>version</code> from
- * <code>jcr:mergeFailed</code> <i>without</i> adding it to
- * <code>jcr:predecessors</code>.
- * </p>
- * <p>
- * Once the last reference in <code>jcr:mergeFailed</code> has been either
- * moved to <code>jcr:predecessors</code> (with <code>doneMerge</code>) or
- * just removed from <code>jcr:mergeFailed</code> (with
- * <code>cancelMerge</code>) the <code>jcr:mergeFailed</code> property is
- * automatically removed, thus enabling <code>this</code> node to be
- * checked-in, creating a new version (note that before the
- * <code>jcr:mergeFailed</code> is removed, its <code>OnParentVersion</code>
- * setting of <code>ABORT</code> prevents checkin). This new version will
- * have a predecessor connection to each version for which
- * <code>doneMerge</code> was called, thus joining those branches of the
- * version graph.
- * </p>
- * <p>
- * If successful, these changes are dispatched immediately; there is no need
- * to call <code>save</code>.
- * </p>Cancels the merge process with respect to the node at
- * <code>absPath</code> and the specified <code>version</code>.
- * <p>
- * See {@link #doneMerge} for a full explanation. Also see {@link #merge}
- * for more details.
- * <p>
- * If successful, these changes are dispatched immediately; there is no need
- * to call <code>save</code>.Calling <code>createConfiguration</code> on the node <i>N</i> at
- * <code>absPath</code> creates, in the configuration storage, a new
- * <code>nt:configuration</code> node whose root is <i>N</i>. A reference to
- * <i>N</i> is recorded in the <code>jcr:root</code> property of the new
- * configuration, and a reference to the new configuration is recorded in
- * the <code>jcr:configuration</code> property of <i>N</i>.
- * <p>
- * A new version history is created to store baselines of the new configuration,
- * and the <code>jcr:baseVersion</code> of the new configuration references
- * the root version of the new version history.
- * <p>
- * The changes are dispatched immediately; a <code>save</code> is not
- * required.This method is called by the client to set the current activity on the
- * current session by specifying a previously created <code>nt:activity</code>
- * node (see {@link #createActivity}). Changing the
- * current activity is done by calling <code>setActivity</code> again.
- * Cancelling the current activity (so that the session has no current
- * activity) is done by calling <code>setActivity(null)</code>. The previously
- * set <code>nt:activity</code> node is returned, or <code>null</code> if no activity
- * was previously set.Returns the node representing the current activity or <code>null</code>
- * if there is no current activity.This method creates a new <code>nt:activity</code> at an
- * implementation-determined location in the <code>/jcr:system/jcr:activities</code>
- * subgraph.
- * <p>
- * The repository may, but is not required to, use the <code>title</code> as
- * a hint for what to name the new activity node. The new activity
- * <code>Node</code> is returned.
- * <p>
- * The new node addition is dispatched immediately and does not require a
- * <code>save</code>.
- * <p>This method removes the given <code>activityNode</code> and all <code>REFERENCE</code> properties
- * within all workspaces that refer to the <code>activityNode</code>.
- * However, the existence of a <code>REFERENCE</code> to the <code>activityNode</code>
- * from within version storage will cause a <code>VersionException</code> to be thrown.
- * <p>
- * The change is dispatched immediately and does not require a <code>save</code>.This method merges the changes that were made under the specified
- * activity into the current workspace.
- * <p>
- * An activity <i>A</i> will be associated with a set of versions through
- * the <code>jcr:activity</code> reference of each version node in the set.
- * We call each such associated version a <i>member of A</i>.
- * <p>
- * For each version history <i>H</i> that contains one or more members of
- * <i>A</i>, one such member will be the latest member of <i>A</i> in
- * <i>H</i>. The latest member of <i>A</i> in <i>H</i> is the version in
- * <i>H</i> that is a member of <i>A</i> and that has no successor versions
- * (to any degree) that are also members of <i>A</i>.
- * <p>
- * The set of versions that are the latest members of <i>A</i> in their
- * respective version histories is called the change set of <i>A</i>. It
- * fully describes the changes made under the activity <i>A</i>.
- * <p>
- * This method performs a shallow merge into the current workspace of each
- * version in the change set of the activity specified by
- * <code>activityNode</code>. If there is no corresponding node in this
- * workspace for a given member of the change set, that member is ignored.
- * <p>
- * This method returns a <code>NodeIterator</code> over all versionable
- * nodes in the subgraph that received a merge result of <i>fail</i>.
- * <p>
- * The changes are dispatched immediately and do not require a <code>save</code>.
+ * <p><strong>Sitevision note:</strong> Unsupported operation</p>
  * @since Sitevision 3.5
  * @since JCR 2.0
  */

package/hidden/javax/jcr/version/VersionManager/index.js

@@ -0,0 +1,25 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _default = {
+  checkin: function checkin() {},
+  checkout: function checkout() {},
+  checkpoint: function checkpoint() {},
+  isCheckedOut: function isCheckedOut() {},
+  getVersionHistory: function getVersionHistory() {},
+  getBaseVersion: function getBaseVersion() {},
+  restore: function restore() {},
+  restoreByLabel: function restoreByLabel() {},
+  merge: function merge() {},
+  doneMerge: function doneMerge() {},
+  cancelMerge: function cancelMerge() {},
+  createConfiguration: function createConfiguration() {},
+  setActivity: function setActivity() {},
+  getActivity: function getActivity() {},
+  createActivity: function createActivity() {},
+  removeActivity: function removeActivity() {}
+};
+exports["default"] = _default;