/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.apache.jackrabbit.spi;

import java.io.InputStream;
import java.util.Iterator;
import java.util.Map;

import javax.jcr.AccessDeniedException;
import javax.jcr.Credentials;
import javax.jcr.InvalidItemStateException;
import javax.jcr.ItemExistsException;
import javax.jcr.ItemNotFoundException;
import javax.jcr.LoginException;
import javax.jcr.MergeException;
import javax.jcr.NamespaceException;
import javax.jcr.NoSuchWorkspaceException;
import javax.jcr.Node;
import javax.jcr.PathNotFoundException;
import javax.jcr.ReferentialIntegrityException;
import javax.jcr.RepositoryException;
import javax.jcr.UnsupportedRepositoryOperationException;
import javax.jcr.ValueFormatException;
import javax.jcr.lock.LockException;
import javax.jcr.nodetype.ConstraintViolationException;
import javax.jcr.nodetype.InvalidNodeTypeDefinitionException;
import javax.jcr.nodetype.NoSuchNodeTypeException;
import javax.jcr.nodetype.NodeTypeExistsException;
import javax.jcr.query.InvalidQueryException;
import javax.jcr.version.Version;
import javax.jcr.version.VersionException;

/**
 * The <code>RepositoryService</code> interface defines methods used to
 * retrieve information from the persistent layer of the repository as well
 * as the methods that modify its persistent state.
 * The implementation of this interface is intended to hold only the state of
 * the persistent layer, no session-related state should be held. Consequently,
 * each method that alters persistent state always includes all the information
 * necessary to fully specify and authorize a change.<p/>
 * For example, consider the method
 * <pre>
 *    void RepositoryService.copy(SessionInfo sessionInfo,
 *                                String srcWorkspaceName,
 *                                NodeId srcNodeId, NodeId destParentNodeId,
 *                                Name destName)
 * </pre>
 * This method performs an immediate persistent copy of the node identified by
 * srcNodeId and that node's subtree to a position as child of the node
 * identified by destParentNodeId and assigns the newly copied node the name
 * destName.<br>
 * The <code>SessionInfo</code> object provides user and workspace identification
 * as well as eventual lock tokens required to execute the copy.<br>
 * If <code>srcWorkspaceName</code> differs from the workspace name present with
 * the SessionInfo, the copy is corresponds to a copy across workspaces.
 * The source and destination of the copy operation are specified by
 * {@link NodeId}s. The <code>Name</code> holds the new name. Taken together,
 * this information is sufficient to completely specify and authorize the copy
 * operations.<p/>
 *
 * The RepositoryService in addition allows to create and submit {@link Batch}
 * objects, that cover lists of operations that have to be applied to the
 * persistent layer at once.
 */
public interface RepositoryService {

    /**
     * Return the <code>IdFactory</code>.
     *
     * @return The <code>IdFactory</code>.
     * @throws RepositoryException If an error occurs.
     */
    public IdFactory getIdFactory() throws RepositoryException;

    /**
     * Return the <code>NameFactory</code>.
     *
     * @return The <code>NameFactory</code>.
     * @throws RepositoryException If an error occurs.
     */
    public NameFactory getNameFactory() throws RepositoryException;

    /**
     * Return the <code>PathFactory</code>.
     *
     * @return The <code>PathFactory</code>.
     * @throws RepositoryException If an error occurs.
     */
    public PathFactory getPathFactory() throws RepositoryException;

    /**
     * Return the <code>QValueFactory</code> defined with this SPI implementation.
     *
     * @return The <code>QValueFactory</code>.
     * @throws RepositoryException If an error occurs.
     */
    public QValueFactory getQValueFactory() throws RepositoryException;

    /**
     * Returns a {@link ItemInfoCache} for the given <code>SessionInfo</code>.
     * @param sessionInfo
     * @return
     * @throws RepositoryException
     */
    public ItemInfoCache getItemInfoCache(SessionInfo sessionInfo) throws RepositoryException;

    //--------------------------------------------------------------------------
    /**
     * Returns all property descriptors that can be exposed with the
     * {@link javax.jcr.Repository Repository} implementation built on top of
     * this <code>RepositoryService</code>.
     *
     * @return key-value pairs for repository descriptor keys and values.
     * @throws javax.jcr.RepositoryException
     * @see javax.jcr.Repository#getDescriptorKeys()
     * @see javax.jcr.Repository#getDescriptor(String)
     */
    public Map<String, QValue[]> getRepositoryDescriptors() throws RepositoryException;

    //-----------------------------------< SessionInfo creation and release >---
    /**
     * Returns a <code>SessionInfo</code> that will be used by other methods
     * on the <code>RepositoryService</code>.
     * An implementation may choose to authenticate the user using the supplied
     * <code>credentials</code>.
     *
     * @param credentials the credentials of the user.
     * @param workspaceName the name of the workspace the <code>SessionInfo</code>
     * should be built for. If the specified workspaceName is <code>null</code>
     * the implementation should select a default workspace.
     * @return a <code>SessionInfo</code> if authentication was successful.
     * @throws LoginException           if authentication of the user fails.
     * @throws NoSuchWorkspaceException if the specified <code>workspaceName</code>
     *                                  is not recognized.
     * @throws RepositoryException      if an error occurs.
     */
    public SessionInfo obtain(Credentials credentials, String workspaceName)
            throws LoginException, NoSuchWorkspaceException, RepositoryException;

    /**
     * Returns a new <code>SessionInfo</code> for the given workspace name that
     * will be used by other methods on the <code>RepositoryService</code>.
     *
     * @param sessionInfo for another workspace
     * @param workspaceName the name of the workspace the new <code>SessionInfo</code>
     * should be built for. If the specified workspaceName is <code>null</code>
     * the implementation should select a default workspace.
     * @return a <code>SessionInfo</code> if authentication was successful.
     * @throws LoginException           if authentication of the user fails.
     * @throws NoSuchWorkspaceException if the specified <code>workspaceName</code>
     *                                  is not recognized.
     * @throws RepositoryException      if an error occurs.
     */
    public SessionInfo obtain(SessionInfo sessionInfo, String workspaceName)
            throws LoginException, NoSuchWorkspaceException, RepositoryException;

    /**
     * Returns a <code>SessionInfo</code> that will be used by other methods
     * on the <code>RepositoryService</code>.
     *
     * @param sessionInfo
     * @param credentials
     * @return a <code>SessionInfo</code> if impersonate was successful.
     * @throws LoginException
     * @throws RepositoryException
     * @see javax.jcr.Session#impersonate(javax.jcr.Credentials)
     */
    public SessionInfo impersonate(SessionInfo sessionInfo, Credentials credentials) throws LoginException, RepositoryException;

    /**
     * Indicates to the <code>RepositoryService</code>, that the given SessionInfo
     * will not be used any more.
     *
     * @param sessionInfo
     * @throws javax.jcr.RepositoryException
     */
    public void dispose(SessionInfo sessionInfo) throws RepositoryException;

    //--------------------------------------------------------------------------
    /**
     * Return all workspace names available for the given <code>SessionInfo</code>.
     *
     * @param sessionInfo
     * @return An array of workspace names.
     * @throws javax.jcr.RepositoryException
     * @see javax.jcr.Workspace#getAccessibleWorkspaceNames()
     * @see javax.jcr.Workspace#getName()
     */
    public String[] getWorkspaceNames(SessionInfo sessionInfo) throws RepositoryException;

    //-----------------------------------------------------< Access Control >---
    /**
     * Returns true if all actions defined in the specified array are granted
     * to given <code>SessionInfo</code>. False otherwise.
     *
     * @param sessionInfo
     * @param itemId
     * @param actions
     * @return true if the session with the given <code>SessionInfo</code> has
     * the specified rights for the given item.
     * @throws javax.jcr.RepositoryException
     * @see javax.jcr.Session#checkPermission(String, String)
     * @see javax.jcr.Session#hasPermission(String, String) 
     */
    public boolean isGranted(SessionInfo sessionInfo, ItemId itemId, String[] actions) throws RepositoryException;

    //------------------------------------------------------< Reading items >---
    /**
     * Returns the <code>QNodeDefinition</code> for the <code>Node</code>
     * identified by the given id. This method should only be used if the
     * caller is not able to unambiguously determine the applicable definition
     * from the parent node type definition or if no parent exists (i.e. for
     * the root).
     *
     * @param sessionInfo
     * @param nodeId
     * @return The node definition applicable to the <code>Node</code> identified
     * by the given id.
     * @throws javax.jcr.RepositoryException
     */
    public QNodeDefinition getNodeDefinition(SessionInfo sessionInfo, NodeId nodeId) throws RepositoryException;

    /**
     * Returns the <code>QPropertyDefinition</code> for the <code>Property</code>
     * identified by the given id. This method should only be used if the
     * caller is not able to unambiguously determine the applicable definition
     * from the parent node type definition.
     *
     * @param sessionInfo
     * @param propertyId
     * @return The property definition applicable for the <code>Property</code>
     * identified by the given id.
     * @throws javax.jcr.RepositoryException
     */
    public QPropertyDefinition getPropertyDefinition(SessionInfo sessionInfo, PropertyId propertyId) throws RepositoryException;

    /**
     * Retrieve the <code>NodeInfo</code> for the node identified by the given
     * <code>NodeId</code>. See {@link #getItemInfos(SessionInfo, ItemId)} for
     * a similar method that in addition may return <code>ItemInfo</code>s of
     * children <code>Item</code>s.
     *
     * @param sessionInfo
     * @param nodeId
     * @return The <code>NodeInfo</code> for the node identified by the given id.
     * @throws javax.jcr.ItemNotFoundException
     * @throws javax.jcr.RepositoryException
     * @see javax.jcr.Session#getItem(String)
     * @see javax.jcr.Node#getNode(String)
     * @see javax.jcr.version.VersionHistory#getAllVersions()
     * @see javax.jcr.version.VersionHistory#getVersion(String)
     * @see javax.jcr.version.VersionHistory#getVersionByLabel(String)
     * @see javax.jcr.version.VersionHistory#getRootVersion()
     * @see javax.jcr.Node#getBaseVersion()
     * @see javax.jcr.Node#getVersionHistory()
     * @see javax.jcr.version.Version#getContainingHistory()
     * @deprecated Use {@link #getItemInfos(SessionInfo, ItemId)}
     */
    public NodeInfo getNodeInfo(SessionInfo sessionInfo, NodeId nodeId) throws ItemNotFoundException, RepositoryException;

    /**
     * Method used to 'batch-read' from the persistent storage. It returns the
     * <code>ItemInfo</code> for the given <code>ItemId</code> as the first
     * element in the <code>Iterator</code>. In addition the iterator may contain
     * arbitrary <code>ItemInfo</code>s.
     *
     * @param sessionInfo
     * @param itemId
     * @return An <code>Iterator</code> of <code>ItemInfo</code>s containing
     * at least a single element: the <code>ItemInfo</code> that represents
     * the Item identified by the given <code>ItemId</code>. If the Iterator
     * contains multiple elements, the first is expected to represent the Item
     * identified by the given <code>ItemId</code>.
     * @throws javax.jcr.ItemNotFoundException
     * @throws javax.jcr.RepositoryException
     * @see javax.jcr.Session#getItem(String)
     * @see javax.jcr.Node#getNode(String)
     * @see javax.jcr.version.VersionHistory#getAllVersions()
     * @see javax.jcr.version.VersionHistory#getVersion(String)
     * @see javax.jcr.version.VersionHistory#getVersionByLabel(String)
     * @see javax.jcr.version.VersionHistory#getRootVersion()
     * @see javax.jcr.Node#getBaseVersion()
     * @see javax.jcr.Node#getVersionHistory()
     * @see javax.jcr.version.Version#getContainingHistory()
     */
    public Iterator<? extends ItemInfo> getItemInfos(SessionInfo sessionInfo, ItemId itemId) throws ItemNotFoundException, RepositoryException;

    /**
     * Returns an Iterator of <code>ChildInfo</code>s present on the
     * Node represented by the given parentId.
     *
     * @param sessionInfo
     * @param parentId
     * @return An Iterator of <code>ChildInfo</code>s present on the
     * Node represented by the given parentId.
     * @throws ItemNotFoundException
     * @throws RepositoryException
     */
    public Iterator<ChildInfo> getChildInfos(SessionInfo sessionInfo, NodeId parentId) throws ItemNotFoundException, RepositoryException;

    /**
     * Returns the {@link PropertyId Id}s of the properties that are referencing
     * the node identified by the given <code>nodeId</code>. If
     * <code>weakReferences</code> is <code>true</code> the ids of
     * {@link javax.jcr.PropertyType#WEAKREFERENCE WEAKREFERENCE} properties are
     * returned, otherwise the property must be of type {@link javax.jcr.PropertyType#REFERENCE REFERENCE}.
     *
     * @param sessionInfo
     * @param nodeId
     * @param propertyName name filter of referring properties to be returned;
     * if <code>null</code> then all references are returned.
     * @param weakReferences If <code>true</code> the properties must be of type
     * {@link javax.jcr.PropertyType#WEAKREFERENCE}, otherwise of type
     * {@link javax.jcr.PropertyType#REFERENCE}.
     * @return An Iterator of {@link PropertyId Id}s of the properties that are
     * referencing the node identified by the given <code>nodeId</code> or an
     * empty iterator if the node is not referenceable or no references exist.
     * @throws ItemNotFoundException
     * @throws RepositoryException
     * @see PropertyInfo#getId()
     * @since JCR 2.0
     */
    public Iterator<PropertyId> getReferences(SessionInfo sessionInfo, NodeId nodeId, Name propertyName, boolean weakReferences) throws ItemNotFoundException, RepositoryException;

    /**
     * Returns the <code>PropertyInfo</code> for the <code>Property</code>
     * identified by the given id.
     *
     * @param sessionInfo
     * @param propertyId
     * @return The <code>PropertyInfo</code> for the <code>Property</code>
     * identified by the given id.
     * @throws javax.jcr.ItemNotFoundException
     * @throws javax.jcr.RepositoryException
     * @see javax.jcr.Session#getItem(String)
     * @see javax.jcr.Node#getProperty(String)
     * @deprecated Use {@link #getItemInfos(SessionInfo, ItemId)}
     */
    public PropertyInfo getPropertyInfo(SessionInfo sessionInfo, PropertyId propertyId) throws ItemNotFoundException, RepositoryException;

    //-----------------------------------------------< general modification >---
    /**
     * Indicates the start of a set of operations that cause modifications
     * on the underlying persistence layer. All modification called on the
     * {@link Batch} must be executed at once or non must be executed upon
     * calling {@link #submit(Batch)}.
     *
     * @param sessionInfo
     * @param itemId Id of the Item that is a common ancestor of all
     * <code>Item</code>s affected upon batch execution. This <code>Item</code>
     * might itself be modified within the scope of the <code>Batch</code>.
     * @return A Batch indicating the start of a set of transient modifications
     * that will be execute at once upon {@link #submit(Batch)}.
     * @throws RepositoryException
     * @see javax.jcr.Item#save()
     * @see javax.jcr.Session#save()
     * @see Batch
     */
    public Batch createBatch(SessionInfo sessionInfo, ItemId itemId) throws RepositoryException;

    /**
     * Completes the given {@link Batch} or discard all the previous modifications.
     * See {@link #createBatch(SessionInfo,ItemId)} for additional information
     * regarding batch creation.
     *
     * @param batch
     * @throws PathNotFoundException
     * @throws ItemNotFoundException
     * @throws NoSuchNodeTypeException
     * @throws ValueFormatException
     * @throws VersionException
     * @throws LockException
     * @throws ConstraintViolationException
     * @throws AccessDeniedException
     * @throws UnsupportedRepositoryOperationException
     * @throws RepositoryException
     * @see Batch
     */
    public void submit(Batch batch) throws PathNotFoundException, ItemNotFoundException, NoSuchNodeTypeException, ValueFormatException, VersionException, LockException, ConstraintViolationException, AccessDeniedException, UnsupportedRepositoryOperationException, RepositoryException;

    //-------------------------------------------------------------< Import >---
    /**
     * Imports the data present in the given <code>InputStream</code> into the
     * persistent layer. Note, that the implementation is responsible for
     * validating the data presented and for the integrity of the repository
     * upon completion.
     *
     * @param sessionInfo
     * @param parentId
     * @param xmlStream
     * @param uuidBehaviour
     * @throws ItemExistsException
     * @throws PathNotFoundException
     * @throws VersionException
     * @throws ConstraintViolationException
     * @throws LockException
     * @throws AccessDeniedException
     * @throws UnsupportedRepositoryOperationException
     * @throws RepositoryException
     * @see javax.jcr.Workspace#importXML(String, java.io.InputStream, int)
     */
    public void importXml(SessionInfo sessionInfo, NodeId parentId, InputStream xmlStream, int uuidBehaviour) throws ItemExistsException, PathNotFoundException, VersionException, ConstraintViolationException, LockException, AccessDeniedException, UnsupportedRepositoryOperationException, RepositoryException;

    //---------------------------------------------------------< Copy, Move >---
    /**
     * Moves the node identified by the given <code>srcNodeId</code> (and its
     * entire subtree) to the new location defined by <code>destParentNodeId</code>
     * and a new name (<code>destName</code>).
     *
     * @param sessionInfo
     * @param srcNodeId
     * @param destParentNodeId
     * @param destName
     * @throws javax.jcr.ItemExistsException
     * @throws javax.jcr.PathNotFoundException
     * @throws javax.jcr.version.VersionException
     * @throws javax.jcr.nodetype.ConstraintViolationException
     * @throws javax.jcr.lock.LockException
     * @throws javax.jcr.AccessDeniedException
     * @throws javax.jcr.UnsupportedRepositoryOperationException
     * @throws javax.jcr.RepositoryException
     * @see javax.jcr.Workspace#move(String, String)
     */
    public void move(SessionInfo sessionInfo, NodeId srcNodeId, NodeId destParentNodeId, Name destName) throws ItemExistsException, PathNotFoundException, VersionException, ConstraintViolationException, LockException, AccessDeniedException, UnsupportedRepositoryOperationException, RepositoryException;

    /**
     * Clone the subtree identified by the given <code>srcNodeId</code>
     * in workspace named <code>srcWorkspaceName</code> to the destination
     * in the workspace specified by the given <code>SessionInfo</code>. The
     * destination is composed by the given parent id and the new name
     * as indicated by <code>destName</code>.<p/>
     * Note, that <code>srcWorkspaceName</code> may be the same as the one
     * specified within the <code>SessionInfo</code>. In this case the copy
     * corresponds to a copy within a single workspace.
     *
     * @param sessionInfo
     * @param srcWorkspaceName
     * @param srcNodeId
     * @param destParentNodeId
     * @param destName
     * @throws javax.jcr.NoSuchWorkspaceException
     * @throws javax.jcr.nodetype.ConstraintViolationException
     * @throws javax.jcr.version.VersionException
     * @throws javax.jcr.AccessDeniedException
     * @throws javax.jcr.PathNotFoundException
     * @throws javax.jcr.ItemExistsException
     * @throws javax.jcr.lock.LockException
     * @throws javax.jcr.UnsupportedRepositoryOperationException
     * @throws javax.jcr.RepositoryException
     * @see javax.jcr.Workspace#copy(String, String)
     * @see javax.jcr.Workspace#copy(String, String, String)
     */
    public void copy(SessionInfo sessionInfo, String srcWorkspaceName, NodeId srcNodeId, NodeId destParentNodeId, Name destName) throws NoSuchWorkspaceException, ConstraintViolationException, VersionException, AccessDeniedException, PathNotFoundException, ItemExistsException, LockException, UnsupportedRepositoryOperationException, RepositoryException;

    //------------------------------------------------------< Update, Clone >---
    /**
     * Updates the node identified by the given <code>NodeId</code> replacing
     * it (an the complete subtree) with a clone of its corresponding node
     * present in the workspace with the given <code>srcWorkspaceName</code>.
     *
     * @param sessionInfo
     * @param nodeId
     * @param srcWorkspaceName
     * @throws javax.jcr.NoSuchWorkspaceException
     * @throws javax.jcr.AccessDeniedException
     * @throws javax.jcr.lock.LockException
     * @throws javax.jcr.InvalidItemStateException
     * @throws javax.jcr.RepositoryException
     * @see javax.jcr.Node#update(String)
     */
    public void update(SessionInfo sessionInfo, NodeId nodeId, String srcWorkspaceName) throws NoSuchWorkspaceException, AccessDeniedException, LockException, InvalidItemStateException, RepositoryException;

    /**
     * Clone the subtree identified by the given <code>srcNodeId</code>
     * in workspace named <code>srcWorkspaceName</code> to the destination
     * in the workspace specified by the given <code>SessionInfo</code>. The
     * destination is composed by the given parent id and the new name
     * as indicated by <code>destName</code>.
     *
     * @param sessionInfo
     * @param srcWorkspaceName
     * @param srcNodeId
     * @param destParentNodeId
     * @param destName
     * @param removeExisting
     * @throws javax.jcr.NoSuchWorkspaceException
     * @throws javax.jcr.nodetype.ConstraintViolationException
     * @throws javax.jcr.version.VersionException
     * @throws javax.jcr.AccessDeniedException
     * @throws javax.jcr.PathNotFoundException
     * @throws javax.jcr.ItemExistsException
     * @throws javax.jcr.lock.LockException
     * @throws javax.jcr.UnsupportedRepositoryOperationException
     * @throws javax.jcr.RepositoryException
     * @see javax.jcr.Workspace#clone(String, String, String, boolean)
     */
    public void clone(SessionInfo sessionInfo, String srcWorkspaceName, NodeId srcNodeId, NodeId destParentNodeId, Name destName, boolean removeExisting) throws NoSuchWorkspaceException, ConstraintViolationException, VersionException, AccessDeniedException, PathNotFoundException, ItemExistsException, LockException, UnsupportedRepositoryOperationException, RepositoryException;

    //------------------------------------------------------------< Locking >---
    /**
     * Returns the lock information that applies to <code>Node</code> identified
     * by the given <code>NodeId</code> or <code>null</code>. If the implementation
     * does not support locking at all, this method always returns <code>null</code>.
     *
     * @param sessionInfo
     * @param nodeId
     * @return The lock information for the Node identified by the given
     * <code>nodeId</code> or <code>null</code> if no lock applies to that Node.
     * @throws javax.jcr.AccessDeniedException
     * @throws javax.jcr.RepositoryException If some other error occurs.
     * @see Node#getLock()
     */
    public LockInfo getLockInfo(SessionInfo sessionInfo, NodeId nodeId) throws AccessDeniedException, RepositoryException;

    /**
     * Create a lock on the <code>Node</code> identified by the given id.
     *
     * @param sessionInfo
     * @param nodeId
     * @param deep
     * @param sessionScoped
     * @return The <code>LockInfo</code> associated with the new lock
     * that has been created.
     * @throws javax.jcr.UnsupportedRepositoryOperationException If this SPI
     * implementation does not support locking at all.
     * @throws javax.jcr.lock.LockException If the Node identified by the given
     * id cannot be locked due to an existing lock or due to missing mixin type.
     * @throws javax.jcr.AccessDeniedException
     * @throws javax.jcr.RepositoryException If another error occurs.
     * @see javax.jcr.Node#lock(boolean, boolean)
     */
    public LockInfo lock(SessionInfo sessionInfo, NodeId nodeId, boolean deep, boolean sessionScoped) throws UnsupportedRepositoryOperationException, LockException, AccessDeniedException, RepositoryException;

    /**
     * Create a lock on the <code>Node</code> identified by the given id.
     *
     * @param sessionInfo
     * @param nodeId
     * @param deep
     * @param sessionScoped
     * @param timeoutHint long indicating the desired lock timeout in seconds.
     * The implementation is free to ignore the hint.
     * @param ownerHint String indicating the desired lockOwner info. The
     * implementation is free to ignore the hint.
     * @return The <code>LockInfo</code> associated with the new lock
     * that has been created.
     * @throws javax.jcr.UnsupportedRepositoryOperationException If this SPI
     * implementation does not support locking at all.
     * @throws javax.jcr.lock.LockException If the Node identified by the given
     * id cannot be locked due to an existing lock or due to missing mixin type.
     * @throws javax.jcr.AccessDeniedException
     * @throws javax.jcr.RepositoryException If another error occurs.
     * @see javax.jcr.lock.LockManager#lock(String, boolean, boolean, long, String)
     * @since JCR 2.0
     */
    public LockInfo lock(SessionInfo sessionInfo, NodeId nodeId, boolean deep, boolean sessionScoped, long timeoutHint, String ownerHint) throws UnsupportedRepositoryOperationException, LockException, AccessDeniedException, RepositoryException;

    /**
     * Explicit refresh of an existing lock. Existing locks should be refreshed
     * implicitly with all read and write methods listed here.
     *
     * @param sessionInfo
     * @param nodeId
     * @throws javax.jcr.UnsupportedRepositoryOperationException If this SPI
     * implementation does not support locking at all.
     * @throws javax.jcr.lock.LockException If the Node identified by the given
     * id is not locked (any more) or if the <code>SessionInfo</code> does not
     * contain the token associated with the lock to be refreshed.
     * @throws javax.jcr.AccessDeniedException
     * @throws javax.jcr.RepositoryException If another error occurs.
     * @see javax.jcr.lock.Lock
     */
    public void refreshLock(SessionInfo sessionInfo, NodeId nodeId) throws UnsupportedRepositoryOperationException, LockException, AccessDeniedException, RepositoryException;

    /**
     * Releases the lock on the <code>Node</code> identified by the given
     * <code>NodeId</code>.<p/>
     * Please note, that on {@link javax.jcr.Session#logout() logout} all
     * session-scoped locks must be released by calling unlock.
     *
     * @param sessionInfo
     * @param nodeId
     * @throws javax.jcr.UnsupportedRepositoryOperationException If this SPI
     * implementation does not support locking at all.
     * @throws javax.jcr.lock.LockException If the Node identified by the given
     * id is not locked or if the <code>SessionInfo</code> does not contain the
     * token associated with the lock to be released.
     * @throws javax.jcr.AccessDeniedException
     * @throws javax.jcr.RepositoryException If another error occurs.
     * @see javax.jcr.Node#unlock()
     */
    public void unlock(SessionInfo sessionInfo, NodeId nodeId) throws UnsupportedRepositoryOperationException, LockException, AccessDeniedException, RepositoryException;

    //---------------------------------------------------------< Versioning >---
    /**
     * Performs a checkin for the <code>Node</code> identified by the given
     * <code>NodeId</code>.
     *
     * @param sessionInfo
     * @param nodeId
     * @return <code>NodeId</code> of newly created version
     * @throws javax.jcr.version.VersionException
     * @throws javax.jcr.UnsupportedRepositoryOperationException
     * @throws javax.jcr.InvalidItemStateException
     * @throws javax.jcr.lock.LockException
     * @throws javax.jcr.RepositoryException
     * @see javax.jcr.Node#checkin()
     */
    public NodeId checkin(SessionInfo sessionInfo, NodeId nodeId) throws VersionException, UnsupportedRepositoryOperationException, InvalidItemStateException, LockException, RepositoryException;

    /**
     * Performs a checkout for the <code>Node</code> identified by the given
     * <code>NodeId</code>. Same as {@link #checkout(SessionInfo, NodeId, NodeId)}
     * where the <code>activityId</code> is <code>null</code>.
     *
     * @param sessionInfo
     * @param nodeId
     * @throws javax.jcr.UnsupportedRepositoryOperationException
     * @throws javax.jcr.lock.LockException
     * @throws javax.jcr.RepositoryException
     * @see javax.jcr.Node#checkout()
     */
    public void checkout(SessionInfo sessionInfo, NodeId nodeId) throws UnsupportedRepositoryOperationException, LockException, RepositoryException;

    /**
     * Performs a checkout for the <code>Node</code> identified by the given
     * <code>NodeId</code> and for activity identified by the specified
     * <code>activityId</code>. If the <code>activityId</code> is <code>null</code>
     * this corresponds to {@link #checkout(SessionInfo, NodeId)}
     *
     * @param sessionInfo
     * @param nodeId
     * @param activityId  Id of the activity node set to the editing session or
     * <code>null</code> if no activity is in effect.
     * @throws UnsupportedRepositoryOperationException
     * @throws LockException
     * @throws RepositoryException
     * @since JCR 2.0
     */
    public void checkout(SessionInfo sessionInfo, NodeId nodeId, NodeId activityId) throws UnsupportedRepositoryOperationException, LockException, RepositoryException;

    /**
     * Performs a checkpoint for the <code>Node</code> identified by the given
     * <code>NodeId</code>.
     *
     * @param sessionInfo
     * @param nodeId
     * @return <code>NodeId</code> of newly created version
     * @throws javax.jcr.UnsupportedRepositoryOperationException
     * @throws javax.jcr.RepositoryException
     * @see javax.jcr.version.VersionManager#checkpoint(String)
     * @since JCR 2.0
     */
    public NodeId checkpoint(SessionInfo sessionInfo, NodeId nodeId) throws UnsupportedRepositoryOperationException, RepositoryException;

    /**
     * Performs a checkpoint for the <code>Node</code> identified by the given
     * <code>NodeId</code>. For the checkout part the specified <code>activityId</code>
     * is taken into account as specified in {@link #checkout(SessionInfo, NodeId, NodeId)}.
     *
     * @param sessionInfo
     * @param nodeId
     * @param activityId Id of the activity node set to the editing session or
     * <code>null</code> if no activity is in effect.
     * @throws UnsupportedRepositoryOperationException
     * @throws LockException
     * @throws RepositoryException
     * @since JCR 2.0
     */
    public NodeId checkpoint(SessionInfo sessionInfo, NodeId nodeId, NodeId activityId)  throws UnsupportedRepositoryOperationException, RepositoryException;
    /**
     * Remove the version identified by the specified <code>versionId</code>.
     *
     * @param sessionInfo
     * @param versionHistoryId <code>NodeId</code> identifying the version
     * history the version identified by <code>versionId</code> belongs to.
     * @param versionId
     * @throws ReferentialIntegrityException
     * @throws AccessDeniedException
     * @throws UnsupportedRepositoryOperationException
     * @throws VersionException
     * @throws RepositoryException
     * @see javax.jcr.version.VersionHistory#removeVersion(String)
     */
    public void removeVersion(SessionInfo sessionInfo, NodeId versionHistoryId, NodeId versionId) throws ReferentialIntegrityException, AccessDeniedException, UnsupportedRepositoryOperationException, VersionException, RepositoryException;

    /**
     * Restores the node identified by <code>nodeId</code> to the state defined
     * by the version with the specified <code>versionId</code>.
     *
     * @param sessionInfo
     * @param nodeId
     * @param versionId
     * @param removeExisting boolean flag indicating how to deal with an
     * identifier collision that may occur if a node exists outside the subtree
     * to be restored with the same identified as a node that would be
     * introduces by the restore. If the <code>removeExisting</code> is
     * <code>true</code> the restored node takes precedence and the
     * existing node is removed. Otherwise the restore fails.
     * @throws javax.jcr.version.VersionException
     * @throws javax.jcr.PathNotFoundException
     * @throws javax.jcr.ItemExistsException
     * @throws javax.jcr.UnsupportedRepositoryOperationException
     * @throws javax.jcr.lock.LockException
     * @throws javax.jcr.InvalidItemStateException
     * @throws javax.jcr.RepositoryException
     * @see javax.jcr.Node#restore(String, boolean)
     * @see javax.jcr.Node#restore(javax.jcr.version.Version, boolean)
     * @see javax.jcr.Node#restore(javax.jcr.version.Version, String, boolean)
     * @see javax.jcr.Node#restoreByLabel(String, boolean)
     */
    public void restore(SessionInfo sessionInfo, NodeId nodeId, NodeId versionId, boolean removeExisting) throws VersionException, PathNotFoundException, ItemExistsException, UnsupportedRepositoryOperationException, LockException, InvalidItemStateException, RepositoryException;

    /**
     * Restore multiple versions at once. The versions to be restored are
     * identified by the given array of <code>NodeId</code>s.
     *
     * @param sessionInfo
     * @param versionIds
     * @param removeExisting boolean flag indicating how to deal with an
     * identifier collision that may occur if a node exists outside the subtrees
     * to be restored with the same identified as any node that would be
     * introduces by the restore. If the <code>removeExisting</code> is
     * <code>true</code> the node to be restored takes precedence and the
     * existing node is removed. Otherwise the restore fails.
     * @throws javax.jcr.ItemExistsException
     * @throws javax.jcr.UnsupportedRepositoryOperationException
     * @throws javax.jcr.version.VersionException
     * @throws javax.jcr.lock.LockException
     * @throws javax.jcr.InvalidItemStateException
     * @throws javax.jcr.RepositoryException
     * @see javax.jcr.Workspace#restore(javax.jcr.version.Version[], boolean)
     */
    public void restore(SessionInfo sessionInfo, NodeId[] versionIds, boolean removeExisting) throws ItemExistsException, UnsupportedRepositoryOperationException, VersionException, LockException, InvalidItemStateException, RepositoryException;

    /**
     * Merge the node identified by the given <code>NodeId</code> and its subtree
     * with the corresponding node present in the workspace with the name of
     * <code>srcWorkspaceName</code>.
     *
     * @param sessionInfo
     * @param nodeId
     * @param srcWorkspaceName
     * @param bestEffort
     * @return an <code>Iterator</code> over the {@link NodeId}s of all nodes that
     * received a merge result of "fail" in the course of this operation.
     * @throws javax.jcr.NoSuchWorkspaceException
     * @throws javax.jcr.AccessDeniedException
     * @throws javax.jcr.MergeException
     * @throws javax.jcr.lock.LockException
     * @throws javax.jcr.InvalidItemStateException
     * @throws javax.jcr.RepositoryException
     * @see javax.jcr.Node#merge(String, boolean)
     */
    public Iterator<NodeId> merge(SessionInfo sessionInfo, NodeId nodeId, String srcWorkspaceName, boolean bestEffort) throws NoSuchWorkspaceException, AccessDeniedException, MergeException, LockException, InvalidItemStateException, RepositoryException;

    /**
     * Merge the node identified by the given <code>NodeId</code> and its subtree
     * with the corresponding node present in the workspace with the name of
     * <code>srcWorkspaceName</code>.
     *
     * @param sessionInfo
     * @param nodeId
     * @param srcWorkspaceName
     * @param bestEffort
     * @return an <code>Iterator</code> over the {@link NodeId}s of all nodes that
     * received a merge result of "fail" in the course of this operation.
     * @throws javax.jcr.NoSuchWorkspaceException
     * @throws javax.jcr.AccessDeniedException
     * @throws javax.jcr.MergeException
     * @throws javax.jcr.lock.LockException
     * @throws javax.jcr.InvalidItemStateException
     * @throws javax.jcr.RepositoryException
     * @see javax.jcr.version.VersionManager#merge(String, String, boolean, boolean)
     * @since JCR 2.0
     */
    public Iterator<NodeId> merge(SessionInfo sessionInfo, NodeId nodeId, String srcWorkspaceName, boolean bestEffort, boolean isShallow) throws NoSuchWorkspaceException, AccessDeniedException, MergeException, LockException, InvalidItemStateException, RepositoryException;

    /**
     * Resolve an existing merge conflict present with the node identified by
     * the given <code>NodeId</code>.
     *
     * @param sessionInfo
     * @param nodeId
     * @param mergeFailedIds The <code>NodeId</code>s remaining in the jcr:mergeFailed
     * REFERENCE property. The version id(s) to be resolved were removed from the
     * array and added to the predecessor ids in case of {@link Node#doneMerge(Version)}.
     * In case of a {@link Node#cancelMerge(Version)} the version id only gets
     * removed from the list.
     * @param predecessorIds The complete set of predecessor id including those
     * that have been added in order to resolve a merge conflict.
     * @throws javax.jcr.version.VersionException
     * @throws javax.jcr.InvalidItemStateException
     * @throws javax.jcr.UnsupportedRepositoryOperationException
     * @throws javax.jcr.RepositoryException
     * @see javax.jcr.Node#cancelMerge(javax.jcr.version.Version)
     * @see javax.jcr.Node#doneMerge(javax.jcr.version.Version)
     */
    public void resolveMergeConflict(SessionInfo sessionInfo, NodeId nodeId, NodeId[] mergeFailedIds, NodeId[] predecessorIds) throws VersionException, InvalidItemStateException, UnsupportedRepositoryOperationException, RepositoryException;

    /**
     * Add the given version label in the persistent layer.
     *
     * @param sessionInfo
     * @param versionHistoryId <code>NodeId</code> identifying the version
     * history the version identified by <code>versionId</code> belongs to.
     * @param versionId <code>NodeId</code> identifying the version the
     * label belongs to.
     * @param label The label to be added.
     * @param moveLabel If the label is already assigned to a version within
     * the same version history this parameter has the following effect: If <code>true</code>
     * the label already present gets moved to be now be a label of the version
     * indicated by <code>versionId</code>. If <code>false</code> this method
     * fails and the label remains with the original version.
     * @throws javax.jcr.version.VersionException
     * @throws javax.jcr.RepositoryException
     * @see javax.jcr.version.VersionHistory#addVersionLabel(String, String, boolean)
     */
    public void addVersionLabel(SessionInfo sessionInfo, NodeId versionHistoryId, NodeId versionId, Name label, boolean moveLabel) throws VersionException, RepositoryException;

    /**
     * Remove the given version label in the persistent layer.
     *
     * @param sessionInfo
     * @param versionHistoryId <code>NodeId</code> identifying the version
     * history the version identified by <code>versionId</code> belongs to.
     * @param versionId <code>NodeId</code> identifying the version the
     * label belongs to.
     * @param label The label to be removed.
     * @throws javax.jcr.version.VersionException
     * @throws javax.jcr.RepositoryException
     * @see javax.jcr.version.VersionHistory#removeVersionLabel(String)
     */
    public void removeVersionLabel(SessionInfo sessionInfo, NodeId versionHistoryId, NodeId versionId, Name label) throws VersionException, RepositoryException;

    /**
     * Create a new activity.
     *
     * @param sessionInfo
     * @param title
     * @return the <code>NodeId</code> of the new activity node.
     * @throws javax.jcr.UnsupportedRepositoryOperationException
     * @throws javax.jcr.RepositoryException
     * @see javax.jcr.version.VersionManager#createActivity(String)
     * @since JCR 2.0
     */
    public NodeId createActivity(SessionInfo sessionInfo, String title) throws UnsupportedRepositoryOperationException, RepositoryException;

    /**
     * Removes the activity identified by the specified <code>activityId</code>.
     *
     * @param sessionInfo
     * @param activityId
     * @throws javax.jcr.UnsupportedRepositoryOperationException
     * @throws javax.jcr.RepositoryException
     * @see javax.jcr.version.VersionManager#removeActivity(Node)
     * @since JCR 2.0
     */
    public void removeActivity(SessionInfo sessionInfo, NodeId activityId) throws UnsupportedRepositoryOperationException, RepositoryException;

    /**
     * Merges the activity identified by the given <code>activityId</code> into
     * the workspace the specified <code>sessionInfo</code> has been created for.
     *
     * @param sessionInfo
     * @param activityId
     * @return an <code>Iterator</code> over the {@link NodeId}s of all nodes that
     * received a merge result of "fail" in the course of this operation.
     * @throws UnsupportedRepositoryOperationException
     * @throws RepositoryException
     */
    public Iterator<NodeId> mergeActivity(SessionInfo sessionInfo, NodeId activityId) throws UnsupportedRepositoryOperationException, RepositoryException;

    /**
     *
     * @param sessionInfo
     * @param nodeId
     * @return
     * @throws UnsupportedRepositoryOperationException
     * @throws RepositoryException
     * @see javax.jcr.version.VersionManager#createConfiguration(String)
     */
    public NodeId createConfiguration(SessionInfo sessionInfo, NodeId nodeId) throws UnsupportedRepositoryOperationException, RepositoryException;

    //----------------------------------------------------------< Searching >---
    /**
     * Returns a String array identifying all query languages supported by this
     * SPI implementation.
     *
     * @param sessionInfo
     * @return String array identifying all query languages supported by this
     * SPI implementation.
     * @throws javax.jcr.RepositoryException
     * @see javax.jcr.query.QueryManager#getSupportedQueryLanguages()
     */
    public String[] getSupportedQueryLanguages(SessionInfo sessionInfo) throws RepositoryException;

    /**
     * Checks if the query <code>statement</code> is valid according to the
     * specified query <code>language</code> and returns the bind variable
     * names found in the query statement.
     *
     * @param sessionInfo the session info.
     * @param statement   the query statement to check.
     * @param language    the query language.
     * @param namespaces  the locally re-mapped namespace which may be used in
     *                    the query <code>statement</code>.
     * @return the bind variable names.
     * @throws InvalidQueryException if the query statement is invalid or the
     *                               language is not supported.
     * @throws RepositoryException   if an error occurs while checking the
     *                               statement.
     * @see javax.jcr.query.QueryManager#createQuery(String, String)
     */
    public String[] checkQueryStatement(SessionInfo sessionInfo, String statement, String language, Map<String, String> namespaces) throws InvalidQueryException, RepositoryException;

    /**
     * Execute the given query statement with the specified query language. The
     * additional <code>namespaces</code> parameter provides a mapping of prefix
     * to namespace uri in order to be able to properly resolve prefix:localname
     * patterns present within the query statement.
     *
     * @param sessionInfo the session info that wants to execute the query.
     * @param statement   the query statement to be execute.
     * @param language    the query language used to parse the query
     *                    <code>statement</code>.
     * @param namespaces  the locally re-mapped namespace which may be used in
     *                    the query <code>statement</code>.
     * @param limit       The maximum result size or <code>-1</code> is no
     *                    maximum is set.
     * @param offset      The offset in the total result set or <code>-1</code>
     *                    is no offset is set.
     * @param values      A Map of name/value pairs collected upon calls to
     *                    {@link javax.jcr.query.Query#bindValue(String,
     *                    javax.jcr.Value)}.
     * @return The query info.
     * @throws RepositoryException if an error occurs.
     * @see javax.jcr.query.Query#execute()
     */
    public QueryInfo executeQuery(SessionInfo sessionInfo,
                                  String statement,
                                  String language,
                                  Map<String, String> namespaces,
                                  long limit,
                                  long offset,
                                  Map<String, QValue> values)
            throws RepositoryException;

    //--------------------------------------------------------< Observation >---
    /**
     * Creates an event filter. If the repository supports observation, the
     * filter created is based on the parameters available in {@link
     * javax.jcr.observation.ObservationManager#addEventListener}.<p/>
     * Note, that an SPI implementation may support observation even if
     * the corresponding {@link javax.jcr.Repository#OPTION_OBSERVATION_SUPPORTED repository descriptor}
     * does not return 'true'.
     *
     * @param sessionInfo the session info which requests an event filter.
     * @param eventTypes A combination of one or more event type constants
     * encoded as a bitmask.
     * @param absPath An absolute path.
     * @param isDeep A <code>boolean</code>.
     * @param uuid Array of jcr:uuid properties.
     * @param nodeTypeName Array of node type names.
     * @param noLocal A <code>boolean</code>.
     * @return the event filter instance with the given parameters.
     * @throws UnsupportedRepositoryOperationException if this SPI implementation
     * does not allow to create event filters.
     * @throws RepositoryException if an error occurs while creating the
     * EventFilter.
     * @see javax.jcr.observation.ObservationManager#addEventListener(javax.jcr.observation.EventListener, int, String, boolean, String[], String[], boolean)
     */
    public EventFilter createEventFilter(SessionInfo sessionInfo, int eventTypes,
                                         Path absPath, boolean isDeep,
                                         String[] uuid, Name[] nodeTypeName,
                                         boolean noLocal)
            throws UnsupportedRepositoryOperationException, RepositoryException;

    /**
     * Creates a new {@link Subscription} for events with an initial set of
     * {@link EventFilter}s. The returned subscription must provide events from
     * the time when the subscription was created. If an empty array of filters
     * is passed no events will be available through the created subscription
     * unless the filters are later updated by calling
     * {@link RepositoryService#updateEventFilters(Subscription, EventFilter[])}.
     *
     * @param sessionInfo the session info.
     * @param filters the initial event filters for the subscription.
     * @return
     * @throws UnsupportedRepositoryOperationException
     *                             if this SPI implementation does not support
     *                             observation.
     * @throws RepositoryException if an error occurs while creating the
     *                             Subscription.
     */
    public Subscription createSubscription(SessionInfo sessionInfo, EventFilter[] filters)
            throws UnsupportedRepositoryOperationException, RepositoryException;

    /**
     * Updates events filters on the subscription. When this method returns all
     * events that go through the passed subscription and have been generated
     * after this method call must be filtered using the passed
     * <code>filters</code>.
     * <p/>
     * An implementation is required to accept at least event filter instances
     * created by {@link RepositoryService#createEventFilter}. Optionally an
     * implementation may also support event filters instanciated by the client
     * itself. An implementation may require special deployment in that case,
     * e.g. to make the event filter implementation class available to the
     * repository server.
     * <p/>
     * <b>Note on thread-safety:</b> it is permissible to call this methods
     * while another thread is blocked in calling {@link
     * RepositoryService#getEvents(Subscription, long)} using the same
     * subscription instance as a parameter.
     *
     * @param subscription the subscription where the event filters are
     *                     applied.
     * @param filters the filters that are applied to the events as they
     *                occurred on the repository. An event is included in an
     *                event bundle if it is {@link EventFilter#accept(Event,
     *                boolean) accept}ed by at least one of the supplied
     *                filters. If an empty array is passed none of the potential
     *                events are include in an event bundle. This allows a
     *                client to skip or ignore events for a certain period of
     *                time.
     * @throws RepositoryException  if an error occurs while updating the event
     *                              filters.
     */
    public void updateEventFilters(Subscription subscription, EventFilter[] filters)
            throws RepositoryException;

    /**
     * Retrieves the events that occurred since the last call to this method for
     * the passed subscription.
     * <p/>
     * Note, that an SPI implementation may support observation even if the
     * corresponding {@link javax.jcr.Repository#OPTION_OBSERVATION_SUPPORTED
     * repository descriptor} does return 'false'.
     * <p/>
     * An implementation should un-block a calling thread and let it return if
     * the associated subscription is disposed by another thread.
     *
     * @param subscription a subscription.
     * @param timeout      a timeout in milliseconds to wait at most for an
     *                     event bundle. If <code>timeout</code> is up and no
     *                     event occurred meanwhile an empty array is returned.
     * @return an array of <code>EventBundle</code>s representing the events
     *         that occurred.
     * @throws RepositoryException  if an error occurs while retrieving the
     *                              event bundles.
     * @throws InterruptedException if the calling thread is interrupted while
     *                              waiting for events within the specified
     *                              <code>timeout</code>.
     */
    public EventBundle[] getEvents(Subscription subscription, long timeout)
            throws RepositoryException, InterruptedException;

    /**
     * Returns events from the <code>EventJournal</code> after a given point in
     * time. The returned event bundle may only contain events up to a given
     * time. In order to retrieve more events a client must call this method
     * again with the timestamp from the last event bundle. An empty bundle
     * indicates that there are no more events.
     *
     * @param sessionInfo the session info.
     * @param filter      the event filter to apply. Please note: the
     *                    <code>noLocal</code> flag is ignored.
     * @param after       retrieve events that occurred after the given
     *                    timestamp.
     * @return the event bundle.
     * @throws RepositoryException if an error occurs.
     * @throws UnsupportedRepositoryOperationException
     *                             if the underlying implementation does not
     *                             support event journaling.
     */
    public EventBundle getEvents(SessionInfo sessionInfo, EventFilter filter, long after)
            throws RepositoryException, UnsupportedRepositoryOperationException;

    /**
     * Indicates that the passed subscription is no longer needed.
     * <p/>
     * <b>Note on thread-safety:</b> it is permissible to call this methods
     * while another thread is blocked in calling {@link
     * RepositoryService#getEvents(Subscription, long)} using the same
     * subscription instance as a parameter.
     *
     * @throws RepositoryException if an error occurs while the subscription is
     *                             disposed.
     */
    public void dispose(Subscription subscription) throws RepositoryException;

    //---------------------------------------------------------< Namespaces >---
    /**
     * Retrieve all registered namespaces. The namespace to prefix mapping is
     * done using the prefix as key and the namespace as value in the Map.
     *
     * @param sessionInfo
     * @return
     * @throws javax.jcr.RepositoryException
     * @see javax.jcr.Workspace#getNamespaceRegistry()
     * @see javax.jcr.NamespaceRegistry#getPrefixes()
     * @see javax.jcr.NamespaceRegistry#getURIs()
     */
    public Map<String, String> getRegisteredNamespaces(SessionInfo sessionInfo) throws RepositoryException;

    /**
     * Returns the namespace URI for the given namespace <code>prefix</code>.
     *
     * @param sessionInfo the session info.
     * @param prefix a namespace prefix to resolve.
     * @return the namespace URI for the given namespace <code>prefix</code>.
     * @throws NamespaceException if prefix is not mapped to a namespace URI.
     * @throws RepositoryException if another error occurs.
     * @see javax.jcr.NamespaceRegistry#getURI(String)
     */
    public String getNamespaceURI(SessionInfo sessionInfo, String prefix)
            throws NamespaceException, RepositoryException;

    /**
     * Returns the namespace prefix for the given namespace <code>uri</code>.
     *
     * @param sessionInfo the session info.
     * @param uri the namespace URI.
     * @return the namespace prefix.
     * @throws NamespaceException if the URI unknown.
     * @throws RepositoryException if another error occurs.
     * @see javax.jcr.NamespaceRegistry#getPrefix(String)
     */
    public String getNamespacePrefix(SessionInfo sessionInfo, String uri)
            throws NamespaceException, RepositoryException;

    /**
     * Register a new namespace with the given prefix and uri.
     *
     * @param sessionInfo
     * @param prefix Prefix of the namespace to be registered.
     * @param uri Namespace URI to be registered.
     * @throws javax.jcr.NamespaceException
     * @throws javax.jcr.UnsupportedRepositoryOperationException
     * @throws javax.jcr.AccessDeniedException
     * @throws javax.jcr.RepositoryException
     * @see javax.jcr.NamespaceRegistry#registerNamespace(String, String)
     */
    public void registerNamespace(SessionInfo sessionInfo, String prefix, String uri) throws NamespaceException, UnsupportedRepositoryOperationException, AccessDeniedException, RepositoryException;

    /**
     * Unregister the namespace identified by the given uri
     *
     * @param sessionInfo
     * @param uri Namespace URI to be unregistered.
     * @throws javax.jcr.NamespaceException
     * @throws javax.jcr.UnsupportedRepositoryOperationException
     * @throws javax.jcr.AccessDeniedException
     * @throws javax.jcr.RepositoryException
     * @see javax.jcr.NamespaceRegistry#unregisterNamespace(String)
     */
    public void unregisterNamespace(SessionInfo sessionInfo, String uri) throws NamespaceException, UnsupportedRepositoryOperationException, AccessDeniedException, RepositoryException;

    //----------------------------------------------------------< NodeTypes >---
    /**
     * Retrieve the <code>QNodeTypeDefinition</code>s of all registered nodetypes.
     *
     * @param sessionInfo
     * @return Iterator of {@link QNodeTypeDefinition}s.
     * @throws javax.jcr.RepositoryException
     * @see javax.jcr.Workspace#getNodeTypeManager()
     * @see javax.jcr.nodetype.NodeTypeManager#getAllNodeTypes()
     * @see javax.jcr.nodetype.NodeTypeManager#getMixinNodeTypes()
     * @see javax.jcr.nodetype.NodeTypeManager#getPrimaryNodeTypes()
     * @see javax.jcr.nodetype.NodeTypeManager#getNodeType(String)
     */
    public Iterator<QNodeTypeDefinition> getQNodeTypeDefinitions(SessionInfo sessionInfo) throws RepositoryException;

    /**
     * Retrieve <code>QNodeTypeDefinition</code>s for the given names. The
     * implementation is free to return additional definitions which will (probably)
     * be needed by the caller due to node type inheritance. The caller must be
     * able to deal with any kind of additional <code>QNodeTypeDefinition</code>s
     * present in the <code>Iterator</code> irrespective whether they have been
     * loaded before or not.
     *
     * @param sessionInfo
     * @param nodetypeNames names of node types to retrieve
     * @return {@link QNodeTypeDefinition}
     * @throws javax.jcr.nodetype.NoSuchNodeTypeException if for any of the given
     * names no <code>QNodeTypeDefinition</code> exists.
     * @throws javax.jcr.RepositoryException
     * @see javax.jcr.Workspace#getNodeTypeManager()
     * @see javax.jcr.nodetype.NodeTypeManager#getAllNodeTypes()
     * @see javax.jcr.nodetype.NodeTypeManager#getMixinNodeTypes()
     * @see javax.jcr.nodetype.NodeTypeManager#getPrimaryNodeTypes()
     * @see javax.jcr.nodetype.NodeTypeManager#getNodeType(String)
     */
    public Iterator<QNodeTypeDefinition> getQNodeTypeDefinitions(SessionInfo sessionInfo, Name[] nodetypeNames) throws RepositoryException;

    /**
     * Registers the node types with the specified <code>QNodeTypeDefinition</code>s.
     * If <code>allowUpdate</code> is <code>true</code> this method may also be
     * used to reregister existing node types with a modified definition, otherwise
     * this method will fail with <code>NodeTypeExistsException</code> if any of
     * the specified definition has the name of an already registered node type.
     *
     * @param sessionInfo
     * @param nodeTypeDefinitions
     * @param allowUpdate
     * @throws InvalidNodeTypeDefinitionException If any of the specified definitions
     * is invalid.
     * @throws NodeTypeExistsException If any of the specified definitions has the
     * name of an already registered node type and <code>allowUpdate</code> is <code>false</code>.
     * @throws UnsupportedRepositoryOperationException If registering node types
     * is not supported.
     * @throws RepositoryException If another error occurs.
     * @see javax.jcr.nodetype.NodeTypeManager#registerNodeTypes(javax.jcr.nodetype.NodeTypeDefinition[], boolean)
     */
    public void registerNodeTypes(SessionInfo sessionInfo, QNodeTypeDefinition[] nodeTypeDefinitions, boolean allowUpdate) throws InvalidNodeTypeDefinitionException, NodeTypeExistsException, UnsupportedRepositoryOperationException, RepositoryException;

    /**
     * Unregisters the node types with the specified <code>names</code>.
     *
     * @param sessionInfo
     * @param nodeTypeNames
     * @throws UnsupportedRepositoryOperationException If unregistering node types
     * is not supported.
     * @throws NoSuchNodeTypeException If any of the specified names has no
     * corresponding registered node type.
     * @throws RepositoryException If another error occurs.
     * @see javax.jcr.nodetype.NodeTypeManager#unregisterNodeTypes(String[])
     */
    public void unregisterNodeTypes(SessionInfo sessionInfo, Name[] nodeTypeNames) throws UnsupportedRepositoryOperationException, NoSuchNodeTypeException, RepositoryException;

    //-----------------------------------------------< Workspace Management >---
    /**
     * Create a new workspace with the specified <code>name</code>. If
     * <code>srcWorkspaceName</code> isn't <code>null</code> the content of
     * that workspace is 'cloned' to the new workspace as inital content,
     * otherwise an empty workspace will be created.
     *
     * @param sessionInfo
     * @param name The name of the new workspace.
     * @param srcWorkspaceName The name of the workspace from which the initial
     * content of the new workspace will be 'cloned'.
     * @throws AccessDeniedException
     * @throws UnsupportedRepositoryOperationException
     * @throws NoSuchWorkspaceException
     * @throws RepositoryException
     * @see javax.jcr.Workspace#createWorkspace(String)
     * @see javax.jcr.Workspace#createWorkspace(String, String)
     * @since JCR 2.0
     */
    public void createWorkspace(SessionInfo sessionInfo, String name, String srcWorkspaceName) throws AccessDeniedException, UnsupportedRepositoryOperationException, NoSuchWorkspaceException, RepositoryException;

    /**
     * Deletes the workspace with the specified <code>name</code>.
     *
     * @param sessionInfo
     * @param name  The name of the workspace to be deleted.
     * @throws AccessDeniedException
     * @throws UnsupportedRepositoryOperationException
     * @throws NoSuchWorkspaceException
     * @throws RepositoryException
     * @see javax.jcr.Workspace#deleteWorkspace(String)
     * @since JCR 2.0
     */
    public void deleteWorkspace(SessionInfo sessionInfo, String name) throws AccessDeniedException, UnsupportedRepositoryOperationException, NoSuchWorkspaceException, RepositoryException;

}
