@sitevision/api 2023.2.1 → 2023.2.2-beta.1

package/types/javax/jcr/Workspace/index.d.ts

@@ -1,4 +1,5 @@
-import { Session } from "../../../../server/Session";
+import type { Session } from "../../../../server/Session";
+import type { String } from "../../../java/lang/String";
 
 import type { Version } from "../version/Version";
 import type { LockManager } from "../lock/LockManager";
@@ -8,35 +9,37 @@ import type { NodeTypeManager } from "../nodetype/NodeTypeManager";
 import type { ObservationManager } from "../observation/ObservationManager";
 import type { VersionManager } from "../version/VersionManager";
 
+import type { InputStream } from "../../../java/io/InputStream";
+
 /**
  * A <code>Workspace</code> object represents a view onto a persitent workspace
- * within a repository. This view is defined by the authorization settings of
- * the <code>Session</code> object associated with the <code>Workspace</code>
- * 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.
+ *  within a repository. This view is defined by the authorization settings of
+ *  the <code>Session</code> object associated with the <code>Workspace</code>
+ *  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.
   
     */
 export type Workspace = {
   /**
    * Returns the <code>Session</code> object through which this
-   * <code>Workspace</code> object was acquired.
+   *  <code>Workspace</code> object was acquired.
    * @return a <code>{@link Session}</code> object.
    */
   getSession(): Session;
 
   /**
    * Returns the name of the actual persistent workspace represented by this
-   * <code>Workspace</code> object. This the name used in
-   * <code>Repository.login</code>.
+   *  <code>Workspace</code> object. This the name used in
+   *  <code>Repository.login</code>.
    * @return the name of this workspace.
    */
   getName(): string;
 
   /**
    * Returns the <code>QueryManager</code> object, through search methods are
-   * accessed.
+   *  accessed.
    * @return the <code>QueryManager</code> object.
    * @throws RepositoryException if an error occurs.
    */
@@ -44,9 +47,9 @@ export type Workspace = {
 
   /**
    * 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.
+   *  access the mapping between prefixes and namespaces. In level 2
+   *  repositories the <code>NamespaceRegistry</code> can also be used to
+   *  change the namespace mappings.
    * @return the <code>NamespaceRegistry</code>.
    * @throws RepositoryException if an error occurs.
    */
@@ -54,12 +57,12 @@ export type Workspace = {
 
   /**
    * 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.
+   *  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.
    * @return a <code>NodeTypeManager</code> object.
    * @throws RepositoryException if an error occurs.
    */
@@ -67,13 +70,13 @@ export type Workspace = {
 
   /**
    * 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.
+   *  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.
    * @return string array of names of accessible workspaces.
    * @throws RepositoryException if an error occurs
    */
@@ -111,7 +114,7 @@ export type Workspace = {
 
   /**
    * A constant for the absolute path of the node type definition storage
-   * node.
+   *  node.
    * @since JCR 2.0
    */
   PATH_NODE_TYPES_NODE: string;
@@ -166,22 +169,22 @@ export type Workspace = {
 
   /**
    * A constant for the name of the <code>jcr:xmltext</code> node produced on
-   * {@link #importXML}.
+   *  {@link #importXML}.
    * @since JCR 2.0
    */
   NAME_JCR_XMLTEXT: string;
 
   /**
    * A constant for the name of the <code>jcr:xmlcharacters</code> property
-   * produced on {@link #importXML}.
+   *  produced on {@link #importXML}.
    * @since JCR 2.0
    */
   NAME_JCR_XMLCHARACTERS: string;
 
   /**
    * 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}.
+   *  XML element of the <code>jcr:xmlcharacters</code> property produced on
+   *  {@link #importXML}.
    * @since JCR 2.0
    */
   RELPATH_JCR_XMLCHARACTERS: string;

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

@@ -1,58 +1,60 @@
+import type { String } from "../../../../java/lang/String";
+
 import type { Node } from "../../Node";
 
 /**
  * Represents a lock placed on an item.
- *
- * <p><strong>Sitevision note:</strong> Unsupported operation</p>
+ * 
+ *  <p><strong>Sitevision note:</strong> Unsupported operation</p>
   
     */
 export type Lock = {
   /**
    * 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.
+   *  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.
    * @return a user ID.
    */
   getLockOwner(): string;
 
   /**
    * Returns <code>true</code> if this is a deep lock; <code>false</code>
-   * otherwise.
+   *  otherwise.
    * @return a boolean
    */
   isDeep(): boolean;
 
   /**
    * 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>.
+   *  (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>.
    * @return an <code>Node</code>.
    */
   getNode(): Node;
 
   /**
    * 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>.
+   *  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>.
    * @return a <code>String</code>.
    */
   getLockToken(): string;
 
   /**
    * 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.
+   *  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.
    * @return the number of seconds remaining until this lock times out.
    * @throws RepositoryException if an error occurs.
    * @since JCR 2.0
@@ -61,16 +63,16 @@ export type Lock = {
 
   /**
    * 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>.
+   *  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>.
    * @return a <code>boolean</code>.
    * @throws RepositoryException if an error occurs.
    */
@@ -78,16 +80,16 @@ export type Lock = {
 
   /**
    * 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.
+   *  is bound to the current session. Returns <code>false</code> otherwise.
    * @return a <code>boolean</code>.
    */
   isSessionScoped(): boolean;
 
   /**
    * 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.
+   *  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.
    * @return a <code>boolean</code>.
    * @since JCR 2.0
    */
@@ -95,9 +97,9 @@ export type Lock = {
 
   /**
    * 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.
-   * @throws LockException if this <code>Session</code> does not hold the correct lock token for this lock.
+   *  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.
+   * @throws LockException if this <code>Session</code> does not hold the&#xA; correct lock token for this lock.
    * @throws RepositoryException if another error occurs.
    */
   refresh(): void;

package/types/javax/jcr/lock/LockException/index.d.ts

@@ -0,0 +1,16 @@
+import type { String } from "../../../../java/lang/String";
+import type { RepositoryException } from "../../RepositoryException";
+
+/**
+ * Exception thrown by when a lock-related error occurs.
+  
+    */
+export type LockException = RepositoryException & {
+  /**
+   * Returns the absolute path of the node that caused the error or
+   *  <code>null</code> if the implementation chooses not to, or cannot, return
+   *  a path.
+   * @return path of the node that caused the error
+   */
+  getFailureNodePath(): string;
+};

package/types/javax/jcr/lock/LockException/index.js

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

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

@@ -1,41 +1,43 @@
+import type { String } from "../../../../java/lang/String";
+
 import type { Lock } from "../Lock";
 
 /**
  * This interface encapsulates methods for the management of locks.
  *
- * <p><strong>Sitevision note:</strong> Unsupported operation</p>
+ *  <p><strong>Sitevision note:</strong> Unsupported operation</p>
  * @since Sitevision 3.5
  * @since JCR 2.0
  */
 export type LockManager = {
   /**
    * Adds the specified lock token to the current <code>Session</code>.
-   * Holding a lock token makes the current <code>Session</code> the owner of
-   * the lock specified by that particular lock token.
+   *  Holding a lock token makes the current <code>Session</code> the owner of
+   *  the lock specified by that particular lock token.
    * @param lockToken a lock token (a string).
-   * @throws LockException if the specified lock token is already held by another <code>Session</code> and the implementation does not support simultaneous ownership of open-scoped locks.
+   * @throws LockException if the specified lock token is already held by&#xA; another <code>Session</code> and the implementation does not support&#xA; simultaneous ownership of open-scoped locks.
    * @throws RepositoryException if another error occurs.
    */
-  addLockToken(lockToken: string): void;
+  addLockToken(lockToken: String | string): void;
 
   /**
    * Returns the <code>Lock</code> object that applies to the node at the
-   * specified <code>absPath</code>. This may be either a lock on that node
-   * itself or a deep lock on a node above that node.
-   * <p>
+   *  specified <code>absPath</code>. This may be either a lock on that node
+   *  itself or a deep lock on a node above that node.
+   *  <p>
    * @param absPath absolute path of node for which to obtain the lock
    * @return The applicable <code>Lock</code> object.
    * @throws LockException if no lock applies to this node.
-   * @throws AccessDeniedException if the current session does not have sufficent access to get the lock.
-   * @throws PathNotFoundException if no node is found at <code>absPath</code>
+   * @throws AccessDeniedException if the current session does not have&#xA; sufficent access to get the lock.
+   * @throws PathNotFoundException if no node is found at&#xA; <code>absPath</code>
    * @throws RepositoryException if another error occurs.
    */
-  getLock(absPath: string): Lock;
+  getLock(absPath: String | string): Lock;
 
   /**
    * Returns an array containing all lock tokens currently held by the current
-   * <code>Session</code>. Note that any such tokens will represent
-   * open-scoped locks, since session-scoped locks do not have tokens.
+   *  <code>Session</code>. Note that any such tokens will represent
+   *  open-scoped locks, since session-scoped locks do not have tokens.
    * @return an array of lock tokens (strings)
    * @throws RepositoryException if an error occurs.
    */
@@ -43,113 +45,113 @@ export type LockManager = {
 
   /**
    * Returns <code>true</code> if the node at <code>absPath</code> holds a
-   * lock; otherwise returns <code>false</code>. To <i>hold</i> a lock means
-   * that this node has actually had a lock placed on it specifically, as
-   * opposed to just having a lock <i>apply</i> to it due to a deep lock held
-   * by a node above.
+   *  lock; otherwise returns <code>false</code>. To <i>hold</i> a lock means
+   *  that this node has actually had a lock placed on it specifically, as
+   *  opposed to just having a lock <i>apply</i> to it due to a deep lock held
+   *  by a node above.
    * @param absPath absolute path of node
    * @return a <code>boolean</code>.
-   * @throws PathNotFoundException if no node is found at <code>absPath</code>
+   * @throws PathNotFoundException if no node is found at&#xA; <code>absPath</code>
    * @throws RepositoryException if an error occurs.
    */
-  holdsLock(absPath: string): boolean;
+  holdsLock(absPath: String | string): boolean;
 
   /**
    * <p> Places a lock on the node at <code>absPath</code>. If successful,
-   * the node is said to <i>hold</i> the lock.  <p> If <code>isDeep</code> is
-   * <code>true</code> then the lock applies to the specified node and all its
-   * descendant nodes; if <code>false</code>, the lock applies only to the
-   * specified node. On a successful lock, the <code>jcr:lockIsDeep</code>
-   * property of the locked node is set to this value.  <p> If
-   * <code>isSessionScoped</code> is <code>true</code> then this lock will
-   * expire upon the expiration of the current session (either through an
-   * automatic or explicit <code>Session.logout</code>); if false, this lock
-   * does not expire until it is explicitly unlocked, it times out, or it is
-   * automatically unlocked due to a implementation-specific limitation. <p>
-   * The timeout parameter specifies the number of seconds until the lock
-   * times out (if it is not refreshed with <code>Lock.refresh</code> in the
-   * meantime). An implementation may use this information as a hint or ignore
-   * it altogether. Clients can discover the actual timeout by inspecting the
-   * returned <code>Lock</code> object.  <p> The <code>ownerInfo</code>
-   * parameter can be used to pass a string holding owner information relevant
-   * to the client. An implementation may either use or ignore this parameter.
-   * If it uses the parameter it must set the <code>jcr:lockOwner</code>
-   * property of the locked node to this value and return this value on
-   * <code>Lock.getLockOwner</code>. If it ignores this parameter the
-   * <code>jcr:lockOwner</code> property (and the value returned by
-   * <code>Lock.getLockOwner</code>) is set to either the value returned by
-   * <code>Session.getUserID</code> of the owning session or an
-   * implementation-specific string identifying the owner.  <p> The method
-   * returns a <code>Lock</code> object representing the new lock. If the lock
-   * is open-scoped the returned lock will include a lock token. The lock
-   * token is also automatically added to the set of lock tokens held by the
-   * current session.  <p> The addition or change of the properties
-   * <code>jcr:lockIsDeep</code> and <code>jcr:lockOwner</code> are persisted
-   * immediately; there is no need to call <code>save</code>.  <p> It is
-   * possible to lock a node even if it is checked-in.
+   *  the node is said to <i>hold</i> the lock.  <p> If <code>isDeep</code> is
+   *  <code>true</code> then the lock applies to the specified node and all its
+   *  descendant nodes; if <code>false</code>, the lock applies only to the
+   *  specified node. On a successful lock, the <code>jcr:lockIsDeep</code>
+   *  property of the locked node is set to this value.  <p> If
+   *  <code>isSessionScoped</code> is <code>true</code> then this lock will
+   *  expire upon the expiration of the current session (either through an
+   *  automatic or explicit <code>Session.logout</code>); if false, this lock
+   *  does not expire until it is explicitly unlocked, it times out, or it is
+   *  automatically unlocked due to a implementation-specific limitation. <p>
+   *  The timeout parameter specifies the number of seconds until the lock
+   *  times out (if it is not refreshed with <code>Lock.refresh</code> in the
+   *  meantime). An implementation may use this information as a hint or ignore
+   *  it altogether. Clients can discover the actual timeout by inspecting the
+   *  returned <code>Lock</code> object.  <p> The <code>ownerInfo</code>
+   *  parameter can be used to pass a string holding owner information relevant
+   *  to the client. An implementation may either use or ignore this parameter.
+   *  If it uses the parameter it must set the <code>jcr:lockOwner</code>
+   *  property of the locked node to this value and return this value on
+   *  <code>Lock.getLockOwner</code>. If it ignores this parameter the
+   *  <code>jcr:lockOwner</code> property (and the value returned by
+   *  <code>Lock.getLockOwner</code>) is set to either the value returned by
+   *  <code>Session.getUserID</code> of the owning session or an
+   *  implementation-specific string identifying the owner.  <p> The method
+   *  returns a <code>Lock</code> object representing the new lock. If the lock
+   *  is open-scoped the returned lock will include a lock token. The lock
+   *  token is also automatically added to the set of lock tokens held by the
+   *  current session.  <p> The addition or change of the properties
+   *  <code>jcr:lockIsDeep</code> and <code>jcr:lockOwner</code> are persisted
+   *  immediately; there is no need to call <code>save</code>.  <p> It is
+   *  possible to lock a node even if it is checked-in.
    * @param absPath absolute path of node to be locked
-   * @param isDeep if <code>true</code> this lock will apply to this node and all its descendants; if <code>false</code>, it applies only to this node.
-   * @param isSessionScoped if <code>true</code>, this lock expires with the current session; if <code>false</code> it expires when explicitly or automatically unlocked for some other reason.
-   * @param timeoutHint desired lock timeout in seconds (servers are free to ignore this value); specify {@link Long#MAX_VALUE} for no timeout.
-   * @param ownerInfo a string containing owner information supplied by the client; servers are free to ignore this value.
+   * @param isDeep if <code>true</code> this lock will apply to this node and&#xA; all its descendants; if <code>false</code>, it applies only to this&#xA; node.
+   * @param isSessionScoped if <code>true</code>, this lock expires with the&#xA; current session; if <code>false</code> it expires when explicitly or&#xA; automatically unlocked for some other reason.
+   * @param timeoutHint desired lock timeout in seconds (servers are free to&#xA; ignore this value); specify {@link Long#MAX_VALUE} for no timeout.
+   * @param ownerInfo a string containing owner information supplied by the&#xA; client; servers are free to ignore this value.
    * @return A <code>Lock</code> object containing a lock token.
-   * @throws LockException if this node is not <code>mix:lockable</code> or this node is already locked or <code>isDeep</code> is <code>true</code> and a descendant node of this node already holds a lock.
-   * @throws AccessDeniedException if this session does not have sufficent access to lock this node.
-   * @throws InvalidItemStateException if this node has pending unsaved changes.
-   * @throws PathNotFoundException if no node is found at <code>absPath</code>
+   * @throws LockException if this node is not <code>mix:lockable</code> or&#xA; this node is already locked or <code>isDeep</code> is <code>true</code>&#xA; and a descendant node of this node already holds a lock.
+   * @throws AccessDeniedException if this session does not have sufficent&#xA; access to lock this node.
+   * @throws InvalidItemStateException if this node has pending unsaved&#xA; changes.
+   * @throws PathNotFoundException if no node is found at&#xA; <code>absPath</code>
    * @throws RepositoryException if another error occurs.
    */
   lock(
-    absPath: string,
+    absPath: String | string,
     isDeep: boolean,
     isSessionScoped: boolean,
     timeoutHint: number,
-    ownerInfo: string
+    ownerInfo: String | string
   ): Lock;
 
   /**
    * Returns <code>true</code> if the node at <code>absPath</code> is locked
-   * either as a result of a lock held by that node or by a deep lock on a
-   * node above that node; otherwise returns <code>false</code>.
+   *  either as a result of a lock held by that node or by a deep lock on a
+   *  node above that node; otherwise returns <code>false</code>.
    * @param absPath absolute path of node
    * @return a <code>boolean</code>.
-   * @throws PathNotFoundException if no node is found at <code>absPath</code>
+   * @throws PathNotFoundException if no node is found at&#xA; <code>absPath</code>
    * @throws RepositoryException if an error occurs.
    */
-  isLocked(absPath: string): boolean;
+  isLocked(absPath: String | string): boolean;
 
   /**
    * Removes the specified lock token from this <code>Session</code>.
    * @param lockToken a lock token (a string)
-   * @throws LockException if the current <code>Session</code> does not hold the specified lock token.
+   * @throws LockException if the current <code>Session</code> does not hold&#xA; the specified lock token.
    * @throws RepositoryException if another error occurs.
    */
-  removeLockToken(lockToken: string): void;
+  removeLockToken(lockToken: String | string): void;
 
   /**
    * Removes the lock on the node at <code>absPath</code>. Also removes the
-   * properties <code>jcr:lockOwner</code> and <code>jcr:lockIsDeep</code>
-   * from that node. As well, the corresponding lock token is removed from the
-   * set of lock tokens held by the current <code>Session</code>.
-   * <p>
-   * If the node does not currently hold a lock or holds a lock for which this
-   * <code>Session</code> is not the owner and is not a "lock-superuser", then
-   * a <code>LockException</code> is thrown. Note that the system may give
-   * permission to a non-owning session to unlock a lock. Typically, such
-   * "lock-superuser" capability is intended to facilitate administrational
-   * clean-up of orphaned open-scoped locks.
-   * <p>
-   * Note that it is possible to unlock a node even if it is checked-in (the
-   * lock-related properties will be changed despite the checked-in status).
-   * <p>
-   * If the current session does not have sufficient privileges to remove the
-   * lock, an <code>AccessDeniedException</code> is thrown.
+   *  properties <code>jcr:lockOwner</code> and <code>jcr:lockIsDeep</code>
+   *  from that node. As well, the corresponding lock token is removed from the
+   *  set of lock tokens held by the current <code>Session</code>.
+   *  <p>
+   *  If the node does not currently hold a lock or holds a lock for which this
+   *  <code>Session</code> is not the owner and is not a "lock-superuser", then
+   *  a <code>LockException</code> is thrown. Note that the system may give
+   *  permission to a non-owning session to unlock a lock. Typically, such
+   *  "lock-superuser" capability is intended to facilitate administrational
+   *  clean-up of orphaned open-scoped locks.
+   *  <p>
+   *  Note that it is possible to unlock a node even if it is checked-in (the
+   *  lock-related properties will be changed despite the checked-in status).
+   *  <p>
+   *  If the current session does not have sufficient privileges to remove the
+   *  lock, an <code>AccessDeniedException</code> is thrown.
    * @param absPath absolute path of node to be unlocked
-   * @throws LockException if this node does not currently hold a lock or holds a lock for which this Session does not have the correct lock token.
-   * @throws AccessDeniedException if the current session does not have permission to unlock this node.
-   * @throws InvalidItemStateException if this node has pending unsaved changes.
-   * @throws PathNotFoundException if no node is found at <code>absPath</code>
+   * @throws LockException if this node does not currently hold a lock or&#xA; holds a lock for which this Session does not have the correct lock&#xA; token.
+   * @throws AccessDeniedException if the current session does not have&#xA; permission to unlock this node.
+   * @throws InvalidItemStateException if this node has pending unsaved&#xA; changes.
+   * @throws PathNotFoundException if no node is found at&#xA; <code>absPath</code>
    * @throws RepositoryException if another error occurs.
    */
-  unlock(absPath: string): void;
+  unlock(absPath: String | string): void;
 };

package/types/javax/jcr/nodetype/ConstraintViolationException/index.d.ts

@@ -0,0 +1,9 @@
+import type { RepositoryException } from "../../RepositoryException";
+
+/**
+ * Exception thrown when an action would violate a constraint on repository
+ *  structure. For example, when an attempt is made to persistently add an item
+ *  to a node that would violate that node's node type.
+  
+    */
+export type ConstraintViolationException = RepositoryException & {};

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

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

package/types/javax/jcr/nodetype/InvalidNodeTypeDefinitionException/index.d.ts

@@ -0,0 +1,8 @@
+import type { RepositoryException } from "../../RepositoryException";
+
+/**
+ * Exception thrown when an attempt is made to register an invalid node type
+ *  definition template.
+ * @since JCR 2.0
+ */
+export type InvalidNodeTypeDefinitionException = RepositoryException & {};

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

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