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

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

@@ -1,7 +1,8 @@
-import Version from "../Version";
-import VersionHistory from "../VersionHistory";
-import NodeIterator from "../../NodeIterator";
-import Node from "../../Node";
+import type { Version } from "../Version";
+
+import type { VersionHistory } from "../VersionHistory";
+import type { NodeIterator } from "../../NodeIterator";
+import type { Node } from "../../Node";
 
 /**
  * The <code>VersionManager</code> object is accessed via {@link
@@ -11,412 +12,11 @@ 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
  */
-interface VersionManager {
+export type VersionManager = {
   /**
    * Creates for the versionable node at <code>absPath</code> a new version
    * with a system generated version name and returns that version (which will
@@ -1077,6 +677,4 @@ interface VersionManager {
    * @since JCR 2.0
    */
   merge(activityNode: Node): NodeIterator;
-}
-
-export default VersionManager;
+};

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

package/{hidden → types}/senselogic/sitevision/api/base/Builder/index.d.ts

@@ -87,16 +87,14 @@
  *       $scriptUtil.swallow($mailBuilder.addRecipient('magnus.lovgren@sitevision.se'))
  *       #set ($mail = $mailBuilder.build())</code></pre>
  *    </li>
- * </ul>Creates an instance of type <em>T</em> using current state of this builder.
+ * </ul>
  * @author Magnus Lövgren
  * @since Sitevision 3.6
  */
-interface Builder {
+export type Builder = {
   /**
    * Creates an instance of type <em>T</em> using current state of this builder.
    * @return an instance of type <em>T</em>
    */
   build(): unknown;
-}
-
-export default Builder;
+};

package/types/senselogic/sitevision/api/base/Builder/index.js

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

package/{hidden → types}/senselogic/sitevision/api/base/Filter/index.d.ts

@@ -8,18 +8,16 @@
  * </p>
  * <p>
  *    See {@link senselogic.sitevision.api.node.NodeFilterUtil} for predefined node filters (i.e. <code>Filter&lt;Node&gt;</code>).
- * </p>Whether a given object matches the filter requirements or not.
+ * </p>
  * @author Magnus Lövgren
  * @since Sitevision 3.6.2
  * @see senselogic.sitevision.api.node.NodeFilterUtil
  */
-interface Filter {
+export type Filter = {
   /**
    * Whether a given object matches the filter requirements or not.
    * @param anObject the object to check
    * @return <code>true</code> if <code>anObject</code> is accepted by this filter, <code>false</code> otherwise
    */
   accept(anObject: unknown): boolean;
-}
-
-export default Filter;
+};

package/types/senselogic/sitevision/api/base/Filter/index.js

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

package/{hidden → types}/senselogic/sitevision/api/base/FilterSplit/index.d.ts

@@ -1,4 +1,4 @@
-import Filter from "../Filter";
+import type { Filter } from "../Filter";
 
 /**
  * This is the base interface for all filter splits in the Sitevision Utility API.
@@ -15,15 +15,11 @@ import Filter from "../Filter";
  *    to split on an iterator and
  *    {@link senselogic.sitevision.api.node.NodeFilterUtil#split(java.util.Collection, Filter)}
  *    to split on a collection.
- * </p>Gets the list of items that was accepted by the filter.
- *
- * <p>
- *    <em>Note! The accepted list will always be empty if the filter used for the filtering operation is null</em>
- * </p>Gets the list of items that was rejected by the filter.Gets the filter used for the filtering operation.
+ * </p>
  * @author Magnus Lövgren
  * @since Sitevision 3.6.3
  */
-interface FilterSplit {
+export type FilterSplit = {
   /**
    * Gets the list of items that was accepted by the filter.
    *
@@ -32,19 +28,17 @@ interface FilterSplit {
    * </p>
    * @return the list of accepted items, never <code>null</code>
    */
-  getAccepted(): unknown[];
+  getAccepted(): unknown;
 
   /**
    * Gets the list of items that was rejected by the filter.
    * @return the list of rejected items, never <code>null</code>
    */
-  getRejected(): unknown[];
+  getRejected(): unknown;
 
   /**
    * Gets the filter used for the filtering operation.
    * @return the filter used
    */
   getFilter(): Filter;
-}
-
-export default FilterSplit;
+};

package/types/senselogic/sitevision/api/base/FilterSplit/index.js

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

package/{hidden → types}/senselogic/sitevision/api/base/Loadable/index.d.ts

@@ -1,15 +1,13 @@
 /**
- * A functional interface for loading resources.Loads a resource that is identified with a specific name.
+ * A functional interface for loading resources.
  * @author Magnus Lövgren
  * @since Sitevision 4.0
  */
-interface Loadable {
+export type Loadable = {
   /**
    * Loads a resource that is identified with a specific name.
    * @param aName the name of the resource
    * @return the resource, or <code>null</code> if no resource match <code>aName</code>
    */
   load(aName: string): unknown;
-}
-
-export default Loadable;
+};

package/types/senselogic/sitevision/api/base/Loadable/index.js

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

package/{hidden → types}/senselogic/sitevision/api/base/Resolver/index.d.ts

@@ -13,19 +13,17 @@
  * <p>
  *    See {@link senselogic.sitevision.api.node.NodeResolverUtil} for predefined resolvers that operates on nodes
  *    (i.e. <code>Resolver&lt;Node,?&gt;</code>).
- * </p>Resolves a value from an object.
+ * </p>
  * @param <T> type of object to operate on
  * @param <V> type of value to produce
  * @author Magnus Lövgren
  * @since Sitevision 4.1
  */
-interface Resolver {
+export type Resolver = {
   /**
    * Resolves a value from an object.
    * @param aObject the object to operate on
    * @return the resolved value
    */
   resolve(aObject: unknown): unknown;
-}
-
-export default Resolver;
+};

package/types/senselogic/sitevision/api/base/Resolver/index.js

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