@sitevision/api 2023.2.1 → 2023.2.2-beta.2

package/types/javax/jcr/query/qom/SameNode/index.d.ts

@@ -1,15 +1,16 @@
+import type { String } from "../../../../../java/lang/String";
 import type { Constraint } from "../Constraint";
 
 /**
  * Tests whether the {@link #getSelectorName selector} node is reachable by
- * absolute path {@link #getPath path}.
- * <p>
- * A node-tuple satisfies the constraint only if:
- * <pre>  selectorNode.isSame(session.getNode(path))</pre>
- * would return true, where <code>selectorNode</code> is the node for the
- * specified selector.
+ *  absolute path {@link #getPath path}.
+ *  <p>
+ *  A node-tuple satisfies the constraint only if:
+ *  <pre>  selectorNode.isSame(session.getNode(path))</pre>
+ *  would return true, where <code>selectorNode</code> is the node for the
+ *  specified selector.
  *
- * <p><strong>Sitevision note:</strong> Unsupported operation</p>
+ *  <p><strong>Sitevision note:</strong> Unsupported operation</p>
  * @since JCR 2.0
  */
 export type SameNode = Constraint & {

package/types/javax/jcr/query/qom/SameNodeJoinCondition/index.d.ts

@@ -1,18 +1,19 @@
+import type { String } from "../../../../../java/lang/String";
 import type { JoinCondition } from "../JoinCondition";
 
 /**
  * Tests whether two nodes are "the same" according to the <code>isSame</code>
- * method of <code>javax.jcr.Item</code>.
- * <p>
- * Tests whether the {@link #getSelector1Name selector1} node is the same as a node identified by
- * relative path from the {@link #getSelector2Name selector2} node.
- * A node-tuple satisfies the constraint only if:
- * <pre>  selector1Node.isSame(selector2Node.getNode(selector2Path))</pre>
- * would return true, where <code>selector1Node</code> is the node for {@link
- * #getSelector1Name selector1} and <code>selector2Node</code> is the node for
- * {@link #getSelector2Name selector2}.
+ *  method of <code>javax.jcr.Item</code>.
+ *  <p>
+ *  Tests whether the {@link #getSelector1Name selector1} node is the same as a node identified by
+ *  relative path from the {@link #getSelector2Name selector2} node.
+ *  A node-tuple satisfies the constraint only if:
+ *  <pre>  selector1Node.isSame(selector2Node.getNode(selector2Path))</pre>
+ *  would return true, where <code>selector1Node</code> is the node for {@link
+ *  #getSelector1Name selector1} and <code>selector2Node</code> is the node for
+ *  {@link #getSelector2Name selector2}.
  *
- * <p><strong>Sitevision note:</strong> Unsupported operation</p>
+ *  <p><strong>Sitevision note:</strong> Unsupported operation</p>
  * @since JCR 2.0
  */
 export type SameNodeJoinCondition = JoinCondition & {

package/types/javax/jcr/query/qom/Selector/index.d.ts

@@ -1,17 +1,18 @@
+import type { String } from "../../../../../java/lang/String";
 import type { Source } from "../Source";
 
 /**
  * Selects a subset of the nodes in the repository based on node type.
- * <p>
- * A selector selects every node in the repository, subject to access control
- * constraints, that satisfies at least one of the following conditions: <ul>
- * <li>the node's primary node type is {@link #getNodeTypeName nodeType},
- * or</li> <li>the node's primary node type is a subtype of {@link
- * #getNodeTypeName nodeType}, or</li> <li>the node has a mixin node type that
- * is {@link #getNodeTypeName nodeType}, or</li> <li>the node has a mixin node
- * type that is a subtype of {@link #getNodeTypeName nodeType}.</li> </ul>
+ *  <p>
+ *  A selector selects every node in the repository, subject to access control
+ *  constraints, that satisfies at least one of the following conditions: <ul>
+ *  <li>the node's primary node type is {@link #getNodeTypeName nodeType},
+ *  or</li> <li>the node's primary node type is a subtype of {@link
+ *  #getNodeTypeName nodeType}, or</li> <li>the node has a mixin node type that
+ *  is {@link #getNodeTypeName nodeType}, or</li> <li>the node has a mixin node
+ *  type that is a subtype of {@link #getNodeTypeName nodeType}.</li> </ul>
  *
- * <p><strong>Sitevision note:</strong> Unsupported operation</p>
+ *  <p><strong>Sitevision note:</strong> Unsupported operation</p>
  * @since JCR 2.0
  */
 export type Selector = Source & {
@@ -23,9 +24,9 @@ export type Selector = Source & {
 
   /**
    * Gets the selector name.
-   * <p>
-   * A selector's name can be used elsewhere in the query to identify the
-   * selector.
+   *  <p>
+   *  A selector's name can be used elsewhere in the query to identify the
+   *  selector.
    * @return the selector name; non-null
    */
   getSelectorName(): string;

package/types/javax/jcr/query/qom/Source/index.d.ts

@@ -1,9 +1,7 @@
 /**
  * Evaluates to a set of node-tuples.
  *
- * <p><strong>Sitevision note:</strong> Unsupported operation</p>
+ *  <p><strong>Sitevision note:</strong> Unsupported operation</p>
  * @since JCR 2.0
  */
-export type Source = {
-  undefined;
-};
+export type Source = {};

package/types/javax/jcr/query/qom/StaticOperand/index.d.ts

@@ -2,11 +2,9 @@ import type { Operand } from "../Operand";
 
 /**
  * An operand whose value can be determined from static analysis of the query,
- * prior to its evaluation.
+ *  prior to its evaluation.
  *
- * <p><strong>Sitevision note:</strong> Unsupported operation</p>
+ *  <p><strong>Sitevision note:</strong> Unsupported operation</p>
  * @since JCR 2.0
  */
-export type StaticOperand = Operand & {
-  undefined;
-};
+export type StaticOperand = Operand & {};

package/types/javax/jcr/query/qom/UpperCase/index.d.ts

@@ -2,17 +2,17 @@ import type { DynamicOperand } from "../DynamicOperand";
 
 /**
  * Evaluates to the upper-case string value (or values, if multi-valued) of
- * {@link #getOperand operand}.
- * <p>
- * If {@link #getOperand operand} does not evaluate to a string value, its value
- * is first converted to a string.  The upper-case string value is computed as
- * though the <code>toUpperCase()</code> method of <code>java.lang.String</code>
- * were called.
- * <p>
- * If {@link #getOperand operand} evaluates to null, the <code>UpperCase</code>
- * operand also evaluates to null.
+ *  {@link #getOperand operand}.
+ *  <p>
+ *  If {@link #getOperand operand} does not evaluate to a string value, its value
+ *  is first converted to a string.  The upper-case string value is computed as
+ *  though the <code>toUpperCase()</code> method of <code>java.lang.String</code>
+ *  were called.
+ *  <p>
+ *  If {@link #getOperand operand} evaluates to null, the <code>UpperCase</code>
+ *  operand also evaluates to null.
  *
- * <p><strong>Sitevision note:</strong> Unsupported operation</p>
+ *  <p><strong>Sitevision note:</strong> Unsupported operation</p>
  * @since JCR 2.0
  */
 export type UpperCase = DynamicOperand & {

package/types/javax/jcr/retention/Hold/index.d.ts

@@ -1,14 +1,16 @@
+import type { String } from "../../../../java/lang/String";
+
 /**
  * <code>Hold</code> represents a hold that can be applied to an existing node
- * in order to prevent the node from being modified or removed. The format and
- * interpretation of the name are not specified. They are
- * application-dependent.
- * <p>
- * If {@link #isDeep()} is <code>true</code>, the hold applies to the node and
- * its entire subgraph. Otherwise the hold applies to the node and its
- * properties only.
+ *  in order to prevent the node from being modified or removed. The format and
+ *  interpretation of the name are not specified. They are
+ *  application-dependent.
+ *  <p>
+ *  If {@link #isDeep()} is <code>true</code>, the hold applies to the node and
+ *  its entire subgraph. Otherwise the hold applies to the node and its
+ *  properties only.
  *
- * <p><strong>Sitevision note:</strong> Unsupported operation</p>
+ *  <p><strong>Sitevision note:</strong> Unsupported operation</p>
  * @see RetentionManager#getHolds(String)
  * @see RetentionManager#addHold(String, String, boolean)
  * @see RetentionManager#removeHold(String, Hold)

package/types/javax/jcr/retention/RetentionManager/index.d.ts

@@ -1,135 +1,143 @@
+import type { String } from "../../../../java/lang/String";
 import type { Hold } from "../Hold";
 
 import type { RetentionPolicy } from "../RetentionPolicy";
 
 /**
  * The <code>RetentionManager</code> object is accessed via {@link
- * javax.jcr.Session#getRetentionManager()}.
+ *  javax.jcr.Session#getRetentionManager()}.
  *
- * <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 RetentionManager = {
   /**
    * Returns all hold objects that have been added through this API to the
-   * existing node at <code>absPath</code>. If no hold has been set before,
-   * this method returns an empty array.
+   *  existing node at <code>absPath</code>. If no hold has been set before,
+   *  this method returns an empty array.
    * @param absPath an absolute path.
-   * @return All hold objects that have been added to the existing node at <code>absPath</code> through this API or an empty array if no hold has been set.
-   * @throws PathNotFoundException if no node at <code>absPath</code> exists or the session does not have sufficent access to retrieve the node.
-   * @throws AccessDeniedException if the current session does not have sufficient access to retrieve the holds.
+   * @return All hold objects that have been added to the existing node at&#xA; <code>absPath</code> through this API or an empty array if no&#xA; hold has been set.
+   * @throws PathNotFoundException if no node at <code>absPath</code> exists&#xA; or the session does not have sufficent access to retrieve the node.
+   * @throws AccessDeniedException if the current session does not have&#xA; sufficient access to retrieve the holds.
    * @throws RepositoryException if another error occurs.
    */
-  getHolds(absPath: string): Hold;
+  getHolds(absPath: String | string): Hold;
 
   /**
    * Places a hold on the existing node at <code>absPath</code>. If
-   * <code>isDeep</code> is <code>true</code>) the hold applies to this node
-   * and its subgraph. The hold does not take effect until a <code>save</code>
-   * is performed. A node may have more than one hold.
-   * <p>
-   * The format and interpretation of the <code>name</code> are not specified.
-   * They are application-dependent.
-   * <p>
-   * A <code>VersionException</code> will be thrown either immediately, on
-   * dispatch or on persists, if the node at <code>absPath</code> is read-only
-   * due to a checked-in node. Implementations may differ on when this
-   * validation is performed.
-   * <p>
-   * A <code>LockException</code> will be thrown either immediately, on
-   * dispatch or on persists, if a lock prevents the operation.
-   * Implementations may differ on when this validation is performed.
+   *  <code>isDeep</code> is <code>true</code>) the hold applies to this node
+   *  and its subgraph. The hold does not take effect until a <code>save</code>
+   *  is performed. A node may have more than one hold.
+   *  <p>
+   *  The format and interpretation of the <code>name</code> are not specified.
+   *  They are application-dependent.
+   *  <p>
+   *  A <code>VersionException</code> will be thrown either immediately, on
+   *  dispatch or on persists, if the node at <code>absPath</code> is read-only
+   *  due to a checked-in node. Implementations may differ on when this
+   *  validation is performed.
+   *  <p>
+   *  A <code>LockException</code> will be thrown either immediately, on
+   *  dispatch or on persists, if a lock prevents the operation.
+   *  Implementations may differ on when this validation is performed.
    * @param absPath an absolute path.
    * @param name an application-dependent string.
    * @param isDeep a boolean indicating if the hold applies to the subgraph.
    * @return The <code>Hold</code> applied.
-   * @throws PathNotFoundException if no node at <code>absPath</code> exists or the session does not have sufficient access to retrieve the node.
-   * @throws AccessDeniedException if the current session does not have sufficient access to perform the operation.
-   * @throws LockException if a lock applies at the node at <code>absPath</code> and this implementation performs this validation immediately.
-   * @throws VersionException if the node at <code>absPath</code> is read-only due to a checked-in node. and this implementation performs this validation immediately.
+   * @throws PathNotFoundException if no node at <code>absPath</code> exists&#xA; or the session does not have sufficient access to retrieve the node.
+   * @throws AccessDeniedException if the current session does not have&#xA; sufficient access to perform the operation.
+   * @throws LockException if a lock applies at the node at&#xA; <code>absPath</code> and this implementation performs this validation&#xA; immediately.
+   * @throws VersionException if the node at <code>absPath</code> is read-only&#xA; due to a checked-in node. and this implementation performs this&#xA; validation immediately.
    * @throws RepositoryException if another error occurs.
    */
-  addHold(absPath: string, name: string, isDeep: boolean): Hold;
+  addHold(
+    absPath: String | string,
+    name: String | string,
+    isDeep: boolean
+  ): Hold;
 
   /**
    * Removes the specified <code>hold</code> from the node at
-   * <code>absPath</code>. The removal does not take effect until a
-   * <code>save</code> is performed.
-   * <p>
-   * A <code>VersionException</code> will be thrown either immediately, on
-   * dispatch or on persists, if the node at <code>absPath</code> is read-only
-   * due to a checked-in node. Implementations may differ on when this
-   * validation is performed.
-   * <p>
-   * A <code>LockException</code> will be thrown either immediately, on
-   * dispatch or on persists, if a lock prevents the operation.
-   * Implementations may differ on when this validation is performed.
+   *  <code>absPath</code>. The removal does not take effect until a
+   *  <code>save</code> is performed.
+   *  <p>
+   *  A <code>VersionException</code> will be thrown either immediately, on
+   *  dispatch or on persists, if the node at <code>absPath</code> is read-only
+   *  due to a checked-in node. Implementations may differ on when this
+   *  validation is performed.
+   *  <p>
+   *  A <code>LockException</code> will be thrown either immediately, on
+   *  dispatch or on persists, if a lock prevents the operation.
+   *  Implementations may differ on when this validation is performed.
    * @param absPath an absolute path.
    * @param hold the hold to be removed.
-   * @throws PathNotFoundException if no node at <code>absPath</code> exists or the session does not have sufficient access to retrieve the node.
-   * @throws AccessDeniedException if the current session does not have sufficient access to perform the operation.
-   * @throws LockException if a lock applies at the node at <code>absPath</code> and this implementation performs this validation immediately.
-   * @throws VersionException if the node at <code>absPath</code> is read-only due to a checked-in node and this implementation performs this validation immediately.
+   * @throws PathNotFoundException if no node at <code>absPath</code> exists&#xA; or the session does not have sufficient access to retrieve the node.
+   * @throws AccessDeniedException if the current session does not have&#xA; sufficient access to perform the operation.
+   * @throws LockException if a lock applies at the node at&#xA; <code>absPath</code> and this implementation performs this validation&#xA; immediately.
+   * @throws VersionException if the node at <code>absPath</code> is read-only&#xA; due to a checked-in node and this implementation performs this validation&#xA; immediately.
    * @throws RepositoryException if another error occurs.
    */
-  removeHold(absPath: string, hold: Hold): void;
+  removeHold(absPath: String | string, hold: Hold): void;
 
   /**
    * Returns the retention policy that has been set using {@link
-   * #setRetentionPolicy} on the node at <code>absPath</code> or
-   * <code>null</code> if no policy has been set.
+   *  #setRetentionPolicy} on the node at <code>absPath</code> or
+   *  <code>null</code> if no policy has been set.
    * @param absPath an absolute path to an existing node.
-   * @return The retention policy that applies to the existing node at <code>absPath</code> or <code>null</code> if no policy applies.
-   * @throws PathNotFoundException if no node at <code>absPath</code> exists or the session does not have sufficent access to retrieve the node.
-   * @throws AccessDeniedException if the current session does not have sufficient access to retrieve the policy.
+   * @return The retention policy that applies to the existing node at&#xA; <code>absPath</code> or <code>null</code> if no policy applies.
+   * @throws PathNotFoundException if no node at <code>absPath</code> exists&#xA; or the session does not have sufficent access to retrieve the node.
+   * @throws AccessDeniedException if the current session does not have&#xA; sufficient access to retrieve the policy.
    * @throws RepositoryException if another error occurs.
    */
-  getRetentionPolicy(absPath: string): RetentionPolicy;
+  getRetentionPolicy(absPath: String | string): RetentionPolicy;
 
   /**
    * Sets the retention policy of the node at <code>absPath</code> to that
-   * defined in the specified policy node. Interpretation and enforcement of
-   * this policy is an implementation issue. In any case the policy does does
-   * not take effect until a <code>save</code> is performed.
-   * <p>
-   * A <code>VersionException</code> will be thrown either immediately, on
-   * dispatch or on persists, if the node at <code>absPath</code> is read-only
-   * due to a checked-in node. Implementations may differ on when this
-   * validation is performed.
-   * <p>
-   * A <code>LockException</code> will be thrown either immediately, on
-   * dispatch or on persists, if a lock prevents the operation.
-   * Implementations may differ on when this validation is performed.
+   *  defined in the specified policy node. Interpretation and enforcement of
+   *  this policy is an implementation issue. In any case the policy does does
+   *  not take effect until a <code>save</code> is performed.
+   *  <p>
+   *  A <code>VersionException</code> will be thrown either immediately, on
+   *  dispatch or on persists, if the node at <code>absPath</code> is read-only
+   *  due to a checked-in node. Implementations may differ on when this
+   *  validation is performed.
+   *  <p>
+   *  A <code>LockException</code> will be thrown either immediately, on
+   *  dispatch or on persists, if a lock prevents the operation.
+   *  Implementations may differ on when this validation is performed.
    * @param absPath an absolute path to an existing node.
    * @param retentionPolicy a retention policy.
-   * @throws PathNotFoundException if no node at <code>absPath</code> exists or the session does not have sufficient access to retrieve the node.
-   * @throws AccessDeniedException if the current session does not have sufficient access to perform the operation.
-   * @throws LockException if a lock applies at the node at <code>absPath</code> and this implementation performs this validation immediately.
-   * @throws VersionException if the node at <code>absPath</code> is read-only due to a checked-in node and this implementation performs this validation immediately.
+   * @throws PathNotFoundException if no node at <code>absPath</code> exists&#xA; or the session does not have sufficient access to retrieve the node.
+   * @throws AccessDeniedException if the current session does not have&#xA; sufficient access to perform the operation.
+   * @throws LockException if a lock applies at the node at&#xA; <code>absPath</code> and this implementation performs this validation&#xA; immediately.
+   * @throws VersionException if the node at <code>absPath</code> is read-only&#xA; due to a checked-in node and this implementation performs this validation&#xA; immediately.
    * @throws RepositoryException if another error occurs.
    */
-  setRetentionPolicy(absPath: string, retentionPolicy: RetentionPolicy): void;
+  setRetentionPolicy(
+    absPath: String | string,
+    retentionPolicy: RetentionPolicy
+  ): void;
 
   /**
    * Causes the current retention policy on the node at <code>absPath</code>
-   * to no longer apply. The removal does not take effect until a
-   * <code>save</code> is performed.
-   * <p>
-   * A <code>VersionException</code> will be thrown either immediately, on
-   * dispatch or on persists, if the node at <code>absPath</code> is read-only
-   * due to a checked-in node. Implementations may differ on when this
-   * validation is performed.
-   * <p>
-   * A <code>LockException</code> will be thrown either immediately, on
-   * dispatch or on persists, if a lock prevents the operation.
-   * Implementations may differ on when this validation is performed.
+   *  to no longer apply. The removal does not take effect until a
+   *  <code>save</code> is performed.
+   *  <p>
+   *  A <code>VersionException</code> will be thrown either immediately, on
+   *  dispatch or on persists, if the node at <code>absPath</code> is read-only
+   *  due to a checked-in node. Implementations may differ on when this
+   *  validation is performed.
+   *  <p>
+   *  A <code>LockException</code> will be thrown either immediately, on
+   *  dispatch or on persists, if a lock prevents the operation.
+   *  Implementations may differ on when this validation is performed.
    * @param absPath an absolute path to an existing node.
-   * @throws PathNotFoundException if no node at <code>absPath</code> exists or the session does not have sufficient access to retrieve the node.
-   * @throws AccessDeniedException if the current session does not have sufficient access to perform the operation.
-   * @throws LockException if a lock applies at the node at <code>absPath</code> and this implementation performs this validation immediately.
-   * @throws VersionException if the node at <code>absPath</code> is read-only due to a checked-in node and this implementation performs this validation immediately.
+   * @throws PathNotFoundException if no node at <code>absPath</code> exists&#xA; or the session does not have sufficient access to retrieve the node.
+   * @throws AccessDeniedException if the current session does not have&#xA; sufficient access to perform the operation.
+   * @throws LockException if a lock applies at the node at&#xA; <code>absPath</code> and this implementation performs this validation&#xA; immediately.
+   * @throws VersionException if the node at <code>absPath</code> is read-only&#xA; due to a checked-in node and this implementation performs this validation&#xA; immediately.
    * @throws RepositoryException if another error occurs.
    */
-  removeRetentionPolicy(absPath: string): void;
+  removeRetentionPolicy(absPath: String | string): void;
 };

package/types/javax/jcr/retention/RetentionPolicy/index.d.ts

@@ -1,8 +1,10 @@
+import type { String } from "../../../../java/lang/String";
+
 /**
  * An <code>RetentionPolicy</code> is an object with a name and an optional
- * description.
+ *  description.
  *
- * <p><strong>Sitevision note:</strong> Unsupported operation</p>
+ *  <p><strong>Sitevision note:</strong> Unsupported operation</p>
  * @see RetentionManager#getRetentionPolicy(String)
  * @see RetentionManager#setRetentionPolicy(String, RetentionPolicy)
  * @see RetentionManager#removeRetentionPolicy(String)

package/types/javax/jcr/security/AccessControlEntry/index.d.ts

@@ -1,10 +1,11 @@
+import type { Principal } from "../../../../java/security/Principal";
 import type { Privilege } from "../Privilege";
 
 /**
  * An <code>AccessControlEntry</code> represents the association of one or more
- * <code>Privilege</code> objects with a specific <code>Principal</code>.
+ *  <code>Privilege</code> objects with a specific <code>Principal</code>.
  *
- * <p><strong>Sitevision note:</strong> Unsupported operation</p>
+ *  <p><strong>Sitevision note:</strong> Unsupported operation</p>
  * @since JCR 2.0
  */
 export type AccessControlEntry = {
@@ -12,7 +13,7 @@ export type AccessControlEntry = {
    * Returns the principal associated with this access control entry.
    * @return a <code>Principal</code>.
    */
-  getPrincipal(): unknown;
+  getPrincipal(): Principal;
 
   /**
    * Returns the privileges associated with this access control entry.

package/types/javax/jcr/security/AccessControlException/index.d.ts

@@ -0,0 +1,9 @@
+import type { RepositoryException } from "../../RepositoryException";
+
+/**
+ * Exception thrown by access control related methods of
+ *  <code>AccessControlManager</code>.
+ * @since Sitevision 3.5
+ * @since JCR 2.0
+ */
+export type AccessControlException = RepositoryException & {};

package/types/javax/jcr/security/AccessControlException/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/security/AccessControlList/index.d.ts

@@ -1,28 +1,28 @@
 import type { AccessControlEntry } from "../AccessControlEntry";
-
+import type { Principal } from "../../../../java/security/Principal";
 import type { Privilege } from "../Privilege";
 
 import type { AccessControlPolicy } from "../AccessControlPolicy";
 
 /**
  * The <code>AccessControlList</code> is an <code>AccessControlPolicy</code>
- * representing a list of {@link AccessControlEntry access control entries}. It
- * is mutable before being {@link AccessControlManager#setPolicy(String,
- * AccessControlPolicy) set} to the AccessControlManager and consequently
- * defines methods to read and mutate the list i.e. to get, add or remove
- * individual entries.
+ *  representing a list of {@link AccessControlEntry access control entries}. It
+ *  is mutable before being {@link AccessControlManager#setPolicy(String,
+ *  AccessControlPolicy) set} to the AccessControlManager and consequently
+ *  defines methods to read and mutate the list i.e. to get, add or remove
+ *  individual entries.
  *
- * <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 AccessControlList = AccessControlPolicy & {
   /**
    * Returns all access control entries present with this policy.
-   * <p>
-   * This method is only guaranteed to return an <code>AccessControlEntry</code>
-   * if that <code>AccessControlEntry</code> has been assigned <i>through this
-   * API</i>.
+   *  <p>
+   *  This method is only guaranteed to return an <code>AccessControlEntry</code>
+   *  if that <code>AccessControlEntry</code> has been assigned <i>through this
+   *  API</i>.
    * @return all access control entries present with this policy.
    * @throws RepositoryException if an error occurs.
    */
@@ -30,38 +30,38 @@ export type AccessControlList = AccessControlPolicy & {
 
   /**
    * Adds an access control entry to this policy consisting of the specified
-   * <code>principal</code> and the specified <code>privileges</code>.
-   * <p>
-   * This method returns <code>true</code> if this policy was modified,
-   * <code>false</code> otherwise.
-   * <p>
-   * How the entries are grouped within the list is an implementation detail.
-   * An implementation may e.g. combine the specified privileges with those
-   * added by a previous call to <code>addAccessControlEntry</code> for the
-   * same <code>Principal</code>. However, a call to <code>addAccessControlEntry</code>
-   * for a given <code>Principal</code> can never remove a
-   * <code>Privilege</code> added by a previous call.
-   * <p>
-   * The modification does not take effect until this policy has been set to a
-   * node by calling {@link AccessControlManager#setPolicy(String,
-   * AccessControlPolicy)} and <code>save</code> is performed.
+   *  <code>principal</code> and the specified <code>privileges</code>.
+   *  <p>
+   *  This method returns <code>true</code> if this policy was modified,
+   *  <code>false</code> otherwise.
+   *  <p>
+   *  How the entries are grouped within the list is an implementation detail.
+   *  An implementation may e.g. combine the specified privileges with those
+   *  added by a previous call to <code>addAccessControlEntry</code> for the
+   *  same <code>Principal</code>. However, a call to <code>addAccessControlEntry</code>
+   *  for a given <code>Principal</code> can never remove a
+   *  <code>Privilege</code> added by a previous call.
+   *  <p>
+   *  The modification does not take effect until this policy has been set to a
+   *  node by calling {@link AccessControlManager#setPolicy(String,
+   *  AccessControlPolicy)} and <code>save</code> is performed.
    * @param principal a <code>Principal</code>.
    * @param privileges an array of <code>Privilege</code>s.
-   * @return <code>true</code> if this policy was modify; <code>false</code> otherwise.
-   * @throws AccessControlException if the specified principal or any of the privileges does not exist or if some other access control related exception occurs.
+   * @return <code>true</code> if this policy was modify; <code>false</code>&#xA; otherwise.
+   * @throws AccessControlException if the specified principal or any of the&#xA; privileges does not exist or if some other access control related&#xA; exception occurs.
    * @throws RepositoryException if another error occurs.
    */
-  addAccessControlEntry(principal: unknown, privileges: Privilege): boolean;
+  addAccessControlEntry(principal: Principal, privileges: Privilege[]): boolean;
 
   /**
    * Removes the specified <code>AccessControlEntry</code> from this policy.
-   * <p>
-   * Only exactly those entries obtained through <code>getAccessControlEntries</code>
-   * can be removed. This method does not take effect until this policy has
-   * been re-set to a node by calling {@link AccessControlManager#setPolicy(String,
-   * AccessControlPolicy)} and <code>save</code> is performed.
+   *  <p>
+   *  Only exactly those entries obtained through <code>getAccessControlEntries</code>
+   *  can be removed. This method does not take effect until this policy has
+   *  been re-set to a node by calling {@link AccessControlManager#setPolicy(String,
+   *  AccessControlPolicy)} and <code>save</code> is performed.
    * @param ace the access control entry to be removed.
-   * @throws AccessControlException if the specified entry is not present on the specified node.
+   * @throws AccessControlException if the specified entry is not present on&#xA; the specified node.
    * @throws RepositoryException if another error occurs.
    */
   removeAccessControlEntry(ace: AccessControlEntry): void;