@sitevision/api 1.0.19 → 1.1.0-alpha.1

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

@@ -0,0 +1,142 @@
+import Node from "../../Node";
+
+/**
+ * Represents a lock placed on an item.
+ *
+ * <p><strong>Sitevision note:</strong> Unsupported operation</p>Returns the value of the <code>jcr:lockOwner</code> property. This is
+ * either the client supplied owner information (see {@link
+ * LockManager#lock(String, boolean, boolean, long, String)}), an
+ * implementation-dependent string identifying the user who either created
+ * the lock or who is bound to the session holding the lock, or
+ * <code>null</code> if none of these are available. The lock owner's
+ * identity is only provided for informational purposes. It does not govern
+ * who can perform an unlock or make changes to the locked nodes; that
+ * depends entirely upon who the token holder is.Returns <code>true</code> if this is a deep lock; <code>false</code>
+ * otherwise.Returns the lock holding node. Note that <code>N.getLock().getNode()</code>
+ * (where <code>N</code> is a locked node) will only return <code>N</code>
+ * if <code>N</code> is the lock holder. If <code>N</code> is in the
+ * subgraph of the lock holder, <code>H</code>, then this call will return
+ * <code>H</code>.May return the lock token for this lock. If this lock is open-scoped and
+ * the current session either holds the lock token for this lock, or the
+ * repository chooses to expose the lock token to the current session, then
+ * this method will return that lock token. Otherwise this method will
+ * return <code>null</code>.Returns the number of seconds remaining until this locks times out. If
+ * the lock has already timed out, a negative value is returned. If the
+ * number of seconds remaining is infinite or unknown,
+ * <code>Long.MAX_VALUE</code> is returned.Returns true if this <code>Lock</code> object represents a lock that is
+ * currently in effect. If this lock has been unlocked either explicitly or
+ * due to an implementation-specific limitation (like a timeout) then it
+ * returns <code>false</code>. Note that this method is intended for those
+ * cases where one is holding a <code>Lock</code> Java object and wants to
+ * find out whether the lock (the JCR-level entity that is attached to the
+ * lockable node) that this object originally represented still exists. For
+ * example, a timeout or explicit <code>unlock</code> will remove a lock
+ * from a node but the <code>Lock</code> Java object corresponding to that
+ * lock may still exist, and in that case its <code>isLive</code> method
+ * will return <code>false</code>.Returns <code>true</code> if this is a session-scoped lock and the scope
+ * is bound to the current session. Returns <code>false</code> otherwise.Returns <code>true</code> if the current session is the owner of this
+ * lock, either because it is session-scoped and bound to this session or
+ * open-scoped and this session currently holds the token for this lock.
+ * Returns <code>false</code> otherwise.If this lock's time-to-live is governed by a timer, this method resets
+ * that timer so that the lock does not timeout and expire. If this lock's
+ * time-to-live is not governed by a timer, then this method has no effect.
+  
+    */
+interface 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.
+   * @return a user ID.
+   */
+  getLockOwner(): string;
+
+  /**
+   * Returns <code>true</code> if this is a deep lock; <code>false</code>
+   * 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>.
+   * @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>.
+   * @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.
+   * @return the number of seconds remaining until this lock times out.
+   * @throws RepositoryException if an error occurs.
+   * @since JCR 2.0
+   */
+  getSecondsRemaining(): number;
+
+  /**
+   * 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>.
+   * @return a <code>boolean</code>.
+   * @throws RepositoryException if an error occurs.
+   */
+  isLive(): boolean;
+
+  /**
+   * 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.
+   * @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.
+   * @return a <code>boolean</code>.
+   * @since JCR 2.0
+   */
+  isLockOwningSession(): boolean;
+
+  /**
+   * 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.
+   * @throws RepositoryException if another error occurs.
+   */
+  refresh(): void;
+}
+
+export default Lock;

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

@@ -0,0 +1,217 @@
+import Lock from "../Lock";
+
+/**
+ * This interface encapsulates methods for the management of locks.
+ *
+ * <p><strong>Sitevision note:</strong> Unsupported operation</p>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.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>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.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.<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.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>.Removes the specified lock token from this <code>Session</code>.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.
+ * @since Sitevision 3.5
+ * @since JCR 2.0
+ */
+interface 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.
+   * @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 RepositoryException if another error occurs.
+   */
+  addLockToken(lockToken: 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>
+   * @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 RepositoryException if another error occurs.
+   */
+  getLock(absPath: 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.
+   * @return an array of lock tokens (strings)
+   * @throws RepositoryException if an error occurs.
+   */
+  getLockTokens(): string;
+
+  /**
+   * 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.
+   * @param absPath absolute path of node
+   * @return a <code>boolean</code>.
+   * @throws PathNotFoundException if no node is found at <code>absPath</code>
+   * @throws RepositoryException if an error occurs.
+   */
+  holdsLock(absPath: 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.
+   * @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.
+   * @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 RepositoryException if another error occurs.
+   */
+  lock(
+    absPath: string,
+    isDeep: boolean,
+    isSessionScoped: boolean,
+    timeoutHint: number,
+    ownerInfo: 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>.
+   * @param absPath absolute path of node
+   * @return a <code>boolean</code>.
+   * @throws PathNotFoundException if no node is found at <code>absPath</code>
+   * @throws RepositoryException if an error occurs.
+   */
+  isLocked(absPath: 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 RepositoryException if another error occurs.
+   */
+  removeLockToken(lockToken: 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.
+   * @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 RepositoryException if another error occurs.
+   */
+  unlock(absPath: string): void;
+}
+
+export default LockManager;

package/hidden/javax/jcr/nodetype/ItemDefinition/index.d.ts

@@ -0,0 +1,219 @@
+import NodeType from "../NodeType";
+
+/**
+ * Superclass of {@link NodeDefinition} and {@link PropertyDefinition}.Gets the node type that contains the declaration of <i>this</i>
+ * <code>ItemDefinition</code>.
+ * <p>
+ * In implementations that support node type registration an
+ * <code>ItemDefinition</code> object may be acquired (in the form of a
+ * <code>NodeDefinitionTemplate</code> or <code>PropertyDefinitionTemplate</code>)
+ * that is not attached to a live <code>NodeType</code>. In such cases this
+ * method returns <code>null</code>.
+ *
+ * <p><strong>Sitevision note:</strong> Unsupported operation</p>Gets the name of the child item. If <code>"*"</code>, this
+ * <code>ItemDefinition</code> defines a residual set of child items. That
+ * is, it defines the characteristics of all those child items with names
+ * apart from the names explicitly used in other child item definitions.
+ * <p>
+ * In implementations that support node type registration, if this
+ * <code>ItemDefinition</code> object is actually a newly-created empty
+ * <code>PropertyDefinitionTemplate</code> or <code>NodeDefinitionTemplate</code>,
+ * then this method will return <code>null</code>.
+ *
+ * <p><strong>Sitevision note:</strong> Unsupported operation</p>Reports whether the item is to be automatically created when its parent
+ * node is created. If <code>true</code>, then this <code>ItemDefinition</code>
+ * will necessarily not be a residual set definition but will specify an
+ * actual item name (in other words getName() will not return "*").
+ * <p>
+ * An autocreated non-protected item must be created immediately when its
+ * parent node is created in the transient session space. Creation of
+ * autocreated non-protected items is never delayed until
+ * <code>save</code>.
+ * </p>
+ * <p>
+ * An autocreated protected item should be created immediately when its
+ * parent node is created in the transient session space. Creation of
+ * autocreated protected items should not be delayed until
+ * <code>save</code>, though doing so does not violate JCR compliance.
+ * <p>
+ * In implementations that support node type registration, if this
+ * <code>ItemDefinition</code> object is actually a newly-created empty
+ * <code>PropertyDefinitionTemplate</code> or <code>NodeDefinitionTemplate</code>,
+ * then this method will return <code>false</code>.
+ *
+ * <p><strong>Sitevision note:</strong> Unsupported operation</p>Reports whether the item is mandatory. A mandatory item is one that, if
+ * its parent node exists, must also exist.
+ * <p>
+ * This means that a mandatory single-value property must have a value
+ * (since there is no such thing a <code>null</code> value). In the case of
+ * multi-value properties this means that the property must exist, though it
+ * can have zero or more values.
+ * <p>
+ * An attempt to save a node that has a mandatory child item without first
+ * creating that child item  will throw a <code>ConstraintViolationException</code>
+ * on <code>save</code>.
+ * <p>
+ * In implementations that support node type registration, if this
+ * <code>ItemDefinition</code> object is actually a newly-created empty
+ * <code>PropertyDefinitionTemplate</code> or <code>NodeDefinitionTemplate</code>,
+ * then this method will return <code>false</code>.
+ * <p>
+ * An item definition cannot be both residual and mandatory.
+ *
+ * <p><strong>Sitevision note:</strong> Unsupported operation</p>Gets the <code>OnParentVersion </code> status of the child item. This
+ * governs what occurs (in implementations that support versioning) when the
+ * parent node of this item is checked-in. One of: <ul>
+ * <li><code>OnParentVersionAction.COPY</code></li> <li><code>OnParentVersionAction.VERSION</code></li>
+ * <li><code>OnParentVersionAction.IGNORE</code></li>
+ * <li><code>OnParentVersionAction.INITIALIZE</code></li>
+ * <li><code>OnParentVersionAction.COMPUTE</code></li>
+ * <li><code>OnParentVersionAction.ABORT</code></li> </ul>
+ * <p>
+ * In implementations that support node type registration, if this
+ * <code>ItemDefinition</code> object is actually a newly-created empty
+ * <code>PropertyDefinitionTemplate</code> or <code>NodeDefinitionTemplate</code>,
+ * then this method will return <code>OnParentVersionAction.COPY</code>.
+ *
+ * <p><strong>Sitevision note:</strong> Unsupported operation</p>Reports whether the child item is protected. In level 2 implementations,
+ * a protected item is one that cannot be removed (except by removing its
+ * parent) or modified through the the standard write methods of this API
+ * (that is, <code>Item.remove</code>, <code>Node.addNode</code>,
+ * <code>Node.setProperty</code> and <code>Property.setValue</code>).
+ * <p>
+ * A protected node may be removed or modified (in a level 2
+ * implementation), however, through some mechanism not defined by this
+ * specification or as a side-effect of operations other than the standard
+ * write methods of the API.
+ * <p>
+ * In implementations that support node type registration, if this
+ * <code>ItemDefinition</code> object is actually a newly-created empty
+ * <code>PropertyDefinitionTemplate</code> or <code>NodeDefinitionTemplate</code>,
+ * then this method will return <code>false</code>.
+  
+    */
+interface ItemDefinition {
+  /**
+   * Gets the node type that contains the declaration of <i>this</i>
+   * <code>ItemDefinition</code>.
+   * <p>
+   * In implementations that support node type registration an
+   * <code>ItemDefinition</code> object may be acquired (in the form of a
+   * <code>NodeDefinitionTemplate</code> or <code>PropertyDefinitionTemplate</code>)
+   * that is not attached to a live <code>NodeType</code>. In such cases this
+   * method returns <code>null</code>.
+   *
+   * <p><strong>Sitevision note:</strong> Unsupported operation</p>
+   * @return a <code>NodeType</code> object.
+   */
+  getDeclaringNodeType(): NodeType;
+
+  /**
+   * Gets the name of the child item. If <code>"*"</code>, this
+   * <code>ItemDefinition</code> defines a residual set of child items. That
+   * is, it defines the characteristics of all those child items with names
+   * apart from the names explicitly used in other child item definitions.
+   * <p>
+   * In implementations that support node type registration, if this
+   * <code>ItemDefinition</code> object is actually a newly-created empty
+   * <code>PropertyDefinitionTemplate</code> or <code>NodeDefinitionTemplate</code>,
+   * then this method will return <code>null</code>.
+   *
+   * <p><strong>Sitevision note:</strong> Unsupported operation</p>
+   * @return a <code>String</code> denoting the name or <code>"*"</code>.
+   */
+  getName(): string;
+
+  /**
+   * Reports whether the item is to be automatically created when its parent
+   * node is created. If <code>true</code>, then this <code>ItemDefinition</code>
+   * will necessarily not be a residual set definition but will specify an
+   * actual item name (in other words getName() will not return "*").
+   * <p>
+   * An autocreated non-protected item must be created immediately when its
+   * parent node is created in the transient session space. Creation of
+   * autocreated non-protected items is never delayed until
+   * <code>save</code>.
+   * </p>
+   * <p>
+   * An autocreated protected item should be created immediately when its
+   * parent node is created in the transient session space. Creation of
+   * autocreated protected items should not be delayed until
+   * <code>save</code>, though doing so does not violate JCR compliance.
+   * <p>
+   * In implementations that support node type registration, if this
+   * <code>ItemDefinition</code> object is actually a newly-created empty
+   * <code>PropertyDefinitionTemplate</code> or <code>NodeDefinitionTemplate</code>,
+   * then this method will return <code>false</code>.
+   *
+   * <p><strong>Sitevision note:</strong> Unsupported operation</p>
+   * @return a <code>boolean</code>.
+   */
+  isAutoCreated(): boolean;
+
+  /**
+   * Reports whether the item is mandatory. A mandatory item is one that, if
+   * its parent node exists, must also exist.
+   * <p>
+   * This means that a mandatory single-value property must have a value
+   * (since there is no such thing a <code>null</code> value). In the case of
+   * multi-value properties this means that the property must exist, though it
+   * can have zero or more values.
+   * <p>
+   * An attempt to save a node that has a mandatory child item without first
+   * creating that child item  will throw a <code>ConstraintViolationException</code>
+   * on <code>save</code>.
+   * <p>
+   * In implementations that support node type registration, if this
+   * <code>ItemDefinition</code> object is actually a newly-created empty
+   * <code>PropertyDefinitionTemplate</code> or <code>NodeDefinitionTemplate</code>,
+   * then this method will return <code>false</code>.
+   * <p>
+   * An item definition cannot be both residual and mandatory.
+   *
+   * <p><strong>Sitevision note:</strong> Unsupported operation</p>
+   * @return a <code>boolean</code>
+   */
+  isMandatory(): boolean;
+
+  /**
+   * Gets the <code>OnParentVersion </code> status of the child item. This
+   * governs what occurs (in implementations that support versioning) when the
+   * parent node of this item is checked-in. One of: <ul>
+   * <li><code>OnParentVersionAction.COPY</code></li> <li><code>OnParentVersionAction.VERSION</code></li>
+   * <li><code>OnParentVersionAction.IGNORE</code></li>
+   * <li><code>OnParentVersionAction.INITIALIZE</code></li>
+   * <li><code>OnParentVersionAction.COMPUTE</code></li>
+   * <li><code>OnParentVersionAction.ABORT</code></li> </ul>
+   * <p>
+   * In implementations that support node type registration, if this
+   * <code>ItemDefinition</code> object is actually a newly-created empty
+   * <code>PropertyDefinitionTemplate</code> or <code>NodeDefinitionTemplate</code>,
+   * then this method will return <code>OnParentVersionAction.COPY</code>.
+   *
+   * <p><strong>Sitevision note:</strong> Unsupported operation</p>
+   * @return a <code>int</code> constant member of {@link javax.jcr.version.OnParentVersionAction}.
+   */
+  getOnParentVersion(): number;
+
+  /**
+   * Reports whether the child item is protected. In level 2 implementations,
+   * a protected item is one that cannot be removed (except by removing its
+   * parent) or modified through the the standard write methods of this API
+   * (that is, <code>Item.remove</code>, <code>Node.addNode</code>,
+   * <code>Node.setProperty</code> and <code>Property.setValue</code>).
+   * <p>
+   * A protected node may be removed or modified (in a level 2
+   * implementation), however, through some mechanism not defined by this
+   * specification or as a side-effect of operations other than the standard
+   * write methods of the API.
+   * <p>
+   * In implementations that support node type registration, if this
+   * <code>ItemDefinition</code> object is actually a newly-created empty
+   * <code>PropertyDefinitionTemplate</code> or <code>NodeDefinitionTemplate</code>,
+   * then this method will return <code>false</code>.
+   * @return a <code>boolean</code>.
+   */
+  isProtected(): boolean;
+}
+
+export default ItemDefinition;