@jahia/javascript-modules-library 0.5.6 → 0.6.1

package/dist/index.d.ts

@@ -1,6 +1,8 @@
 export { RenderInBrowser } from "./core/server/components/render/RenderInBrowser.js";
 export { HydrateInBrowser } from "./core/server/components/render/HydrateInBrowser.js";
 export { Render } from "./core/server/components/render/Render.js";
+export { RenderChild } from "./core/server/components/render/RenderChild.js";
+export { RenderChildren } from "./core/server/components/render/RenderChildren.js";
 export { AbsoluteArea } from "./core/server/components/AbsoluteArea.js";
 export { AddContentButtons } from "./core/server/components/AddContentButtons.js";
 export { AddResources } from "./core/server/components/AddResources.js";
@@ -11,18 +13,19 @@ export { registerJahiaComponents } from "./core/server/framework/register.js";
 export { useGQLQuery } from "./core/server/hooks/useGQLQuery.js";
 export { useJCRQuery } from "./core/server/hooks/useJCRQuery.js";
 export { useServerContext, ServerContextProvider } from "./core/server/hooks/useServerContext.js";
-export { useUrlBuilder } from "./core/server/hooks/useUrlBuilder.js";
 export { getChildNodes } from "./core/server/utils/jcr/getChildNodes.js";
-export { getNodeFromPathOrId } from "./core/server/utils/jcr/getNodeFromPathOrId.js";
 export { getNodeProps } from "./core/server/utils/jcr/getNodeProps.js";
 export { getNodesByJCRQuery } from "./core/server/utils/jcr/getNodesByJCRQuery.js";
-export { buildUrl, initUrlBuilder } from "./core/server/utils/urlBuilder/urlBuilder.js";
+export { buildEndpointUrl, buildNodeUrl, buildModuleFileUrl, initUrlBuilder, } from "./core/server/utils/urlBuilder/urlBuilder.js";
+export { getSiteLocales } from "./core/server/utils/i18n.js";
 export { buildNavMenu } from "./nav/server/navBuilder/navBuilder.js";
+export type { MenuEntry } from "./nav/server/navBuilder/navBuilder.js";
 export { default as server } from "virtual:jahia-server";
 
 // Include declarations for all Java types
 export * from "./globals";
 export * from "./java.io";
+export * from "./java.lang";
 export * from "./java.net";
 export * from "./java.security";
 export * from "./java.util";

package/dist/java.io.d.ts

@@ -702,5 +702,169 @@ export class PrintWriter {
   */
   format(l: Locale, format: string, ...args: any[]): PrintWriter;
 }
+/**
+ * Serializability of a class is enabled by the class implementing the
+ * java.io.Serializable interface.
+ *
+ * Warning: Deserialization of untrusted data is inherently dangerous
+ * and should be avoided. Untrusted data should be carefully validated according to the
+ * "Serialization and Deserialization" section of the
+ * {@extLink secure_coding_guidelines_javase Secure Coding Guidelines for Java SE}.
+ * {@extLink serialization_filter_guide Serialization Filtering} describes best
+ * practices for defensive use of serial filters.
+ * 
+ *
+ * Classes that do not implement this
+ * interface will not have any of their state serialized or
+ * deserialized.  All subtypes of a serializable class are themselves
+ * serializable.  The serialization interface has no methods or fields
+ * and serves only to identify the semantics of being serializable. 
+ *
+ * It is possible for subtypes of non-serializable classes to be serialized
+ * and deserialized. During serialization, no data will be written for the
+ * fields of non-serializable superclasses. During deserialization, the fields of non-serializable
+ * superclasses will be initialized using the no-arg constructor of the first (bottommost)
+ * non-serializable superclass. This constructor must be accessible to the subclass that is being
+ * deserialized. It is an error to declare a class Serializable if this is not
+ * the case; the error will be detected at runtime. A serializable subtype may
+ * assume responsibility for saving and restoring the state of a non-serializable
+ * supertype's public, protected, and (if accessible) package-access fields. See
+ * the 
+ * Java Object Serialization Specification, section 3.1, for
+ * a detailed specification of the deserialization process, including handling of
+ * serializable and non-serializable classes. 
+ *
+ * When traversing a graph, an object may be encountered that does not
+ * support the Serializable interface. In this case the
+ * NotSerializableException will be thrown and will identify the class
+ * of the non-serializable object. 
+ *
+ * Classes that require special handling during the serialization and
+ * deserialization process must implement special methods with these exact
+ * signatures:
+ *
+ *  * private void writeObject(java.io.ObjectOutputStream out)
+ *     throws IOException
+ * private void readObject(java.io.ObjectInputStream in)
+ *     throws IOException, ClassNotFoundException;
+ * private void readObjectNoData()
+ *     throws ObjectStreamException;
+ * 
+ *
+ * The writeObject method is responsible for writing the state of the
+ * object for its particular class so that the corresponding
+ * readObject method can restore it.  The default mechanism for saving
+ * the Object's fields can be invoked by calling
+ * out.defaultWriteObject. The method does not need to concern
+ * itself with the state belonging to its superclasses or subclasses.
+ * State is saved by writing the individual fields to the
+ * ObjectOutputStream using the writeObject method or by using the
+ * methods for primitive data types supported by DataOutput.
+ *
+ * The readObject method is responsible for reading from the stream and
+ * restoring the classes fields. It may call in.defaultReadObject to invoke
+ * the default mechanism for restoring the object's non-static and
+ * non-transient fields.  The defaultReadObject method uses information in
+ * the stream to assign the fields of the object saved in the stream with the
+ * correspondingly named fields in the current object.  This handles the case
+ * when the class has evolved to add new fields. The method does not need to
+ * concern itself with the state belonging to its superclasses or subclasses.
+ * State is restored by reading data from the ObjectInputStream for
+ * the individual fields and making assignments to the appropriate fields
+ * of the object. Reading primitive data types is supported by DataInput.
+ *
+ * The readObjectNoData method is responsible for initializing the state of
+ * the object for its particular class in the event that the serialization
+ * stream does not list the given class as a superclass of the object being
+ * deserialized.  This may occur in cases where the receiving party uses a
+ * different version of the deserialized instance's class than the sending
+ * party, and the receiver's version extends classes that are not extended by
+ * the sender's version.  This may also occur if the serialization stream has
+ * been tampered; hence, readObjectNoData is useful for initializing
+ * deserialized objects properly despite a "hostile" or incomplete source
+ * stream.
+ *
+ * Serializable classes that need to designate an alternative object to be
+ * used when writing an object to the stream should implement this
+ * special method with the exact signature:
+ *
+ *  * ANY-ACCESS-MODIFIER Object writeReplace() throws ObjectStreamException;
+ * 
+ *
+ * This writeReplace method is invoked by serialization if the method
+ * exists and it would be accessible from a method defined within the
+ * class of the object being serialized. Thus, the method can have private,
+ * protected and package-private access. Subclass access to this method
+ * follows java accessibility rules. 
+ *
+ * Classes that need to designate a replacement when an instance of it
+ * is read from the stream should implement this special method with the
+ * exact signature.
+ *
+ *  * ANY-ACCESS-MODIFIER Object readResolve() throws ObjectStreamException;
+ * 
+ *
+ * This readResolve method follows the same invocation rules and
+ * accessibility rules as writeReplace.
+ *
+ * Enum types are all serializable and receive treatment defined by
+ * the 
+ * Java Object Serialization Specification during
+ * serialization and deserialization. Any declarations of the special
+ * handling methods discussed above are ignored for enum types.
+ *
+ * Record classes can implement `Serializable` and receive treatment defined
+ * by the 
+ * Java Object Serialization Specification, Section 1.13,
+ * "Serialization of Records". Any declarations of the special
+ * handling methods discussed above are ignored for record types.
+ *
+ * The serialization runtime associates with each serializable class a version
+ * number, called a serialVersionUID, which is used during deserialization to
+ * verify that the sender and receiver of a serialized object have loaded
+ * classes for that object that are compatible with respect to serialization.
+ * If the receiver has loaded a class for the object that has a different
+ * serialVersionUID than that of the corresponding sender's class, then
+ * deserialization will result in an {@link InvalidClassException}.  A
+ * serializable class can declare its own serialVersionUID explicitly by
+ * declaring a field named `"serialVersionUID"` that must be static,
+ * final, and of type `long`:
+ *
+ *  * ANY-ACCESS-MODIFIER static final long serialVersionUID = 42L;
+ * 
+ *
+ * If a serializable class does not explicitly declare a serialVersionUID, then
+ * the serialization runtime will calculate a default serialVersionUID value
+ * for that class based on various aspects of the class, as described in the
+ * Java Object Serialization
+ * Specification. This specification defines the
+ * serialVersionUID of an enum type to be 0L. However, it is strongly
+ * recommended that all serializable classes other than enum types explicitly declare
+ * serialVersionUID values, since the default serialVersionUID computation is
+ * highly sensitive to class details that may vary depending on compiler
+ * implementations, and can thus result in unexpected
+ * `InvalidClassException`s during deserialization.  Therefore, to
+ * guarantee a consistent serialVersionUID value across different java compiler
+ * implementations, a serializable class must declare an explicit
+ * serialVersionUID value.  It is also strongly advised that explicit
+ * serialVersionUID declarations use the `private` modifier where
+ * possible, since such declarations apply only to the immediately declaring
+ * class--serialVersionUID fields are not useful as inherited members. Array
+ * classes cannot declare an explicit serialVersionUID, so they always have
+ * the default computed value, but the requirement for matching
+ * serialVersionUID values is waived for array classes.
+ *
+ * @see java.io.ObjectOutputStream
+ * @see java.io.ObjectInputStream
+ * @see java.io.ObjectOutput
+ * @see java.io.ObjectInput
+ * @see java.io.Externalizable
+ * @see 
+ *      Java Object Serialization Specification
+ * @since   1.1
+*/
+export class Serializable {
+
+}
 
 }

package/dist/java.lang.d.ts

@@ -0,0 +1,16 @@
+declare module 'java.lang' {
+/**
+ * Implementing this interface allows an object to be the target of the enhanced
+ * `for` statement (sometimes called the "for-each loop" statement).
+ *
+ * @param  the type of elements returned by the iterator
+ *
+ * @since 1.5
+ * @jls 14.14.2 The enhanced `for` statement
+*/
+export class Iterable<T> {
+  [Symbol.iterator](): globalThis.Iterator<T>;
+
+}
+
+}

package/dist/java.util.d.ts

@@ -1,5 +1,6 @@
 declare module 'java.util' {
-export class Collection<E> {
+import { Iterable } from 'java.lang';
+export class Collection<E> extends Iterable<E> {
   /**
    * Returns the number of elements in this collection.  If this collection
    * contains more than `Integer.MAX_VALUE` elements, returns

package/dist/javax.jcr.d.ts

@@ -725,6 +725,19 @@ export class NodeIterator {
    *          Nodes.
   */
   nextNode(): Node;
+  /**
+   * Returns the total number of of items available through this iterator. For
+   * example, for some node N, N.getNodes().getSize()
+   * returns the number of child nodes of N visible through the
+   * current Session. In some implementations precise information
+   * about the number of elements may not be available. In such cases this
+   * method must return -1. API clients will then be able to use
+   * RangeIterator.getNumberRemaining to get an estimate on the
+   * number of elements.
+   *
+   * @return a long
+  */
+  getSize(): number;
   /**
    * Returns `true` if the iteration has more elements.
    * (In other words, returns `true` if {@link #next} would

package/dist/javax.servlet.http.d.ts

@@ -978,6 +978,76 @@ export class HttpServletRequest {
  *
 */
 export class HttpServletResponse {
+  /**
+   * Encodes the specified URL by including the session ID,
+   * or, if encoding is not needed, returns the URL unchanged.
+   * The implementation of this method includes the logic to
+   * determine whether the session ID needs to be encoded in the URL.
+   * For example, if the browser supports cookies, or session
+   * tracking is turned off, URL encoding is unnecessary.
+   * 
+   * For robust session tracking, all URLs emitted by a servlet 
+   * should be run through this
+   * method.  Otherwise, URL rewriting cannot be used with browsers
+   * which do not support cookies.
+   *
+   * If the URL is relative, it is always relative to the current
+   * HttpServletRequest.
+   *
+   * @param	url	the url to be encoded.
+   * @return		the encoded URL if encoding is needed;
+   * 			the unchanged URL otherwise.
+   * @exception IllegalArgumentException if the url is not valid
+  */
+  encodeURL(url: string): string;
+  /**
+   * Encodes the specified URL for use in the
+   * sendRedirect method or, if encoding is not needed,
+   * returns the URL unchanged.  The implementation of this method
+   * includes the logic to determine whether the session ID
+   * needs to be encoded in the URL.  For example, if the browser supports
+   * cookies, or session tracking is turned off, URL encoding is
+   * unnecessary.  Because the rules for making this determination can
+   * differ from those used to decide whether to
+   * encode a normal link, this method is separated from the
+   * encodeURL method.
+   * 
+   * All URLs sent to the HttpServletResponse.sendRedirect
+   * method should be run through this method.  Otherwise, URL
+   * rewriting cannot be used with browsers which do not support
+   * cookies.
+   *
+   * If the URL is relative, it is always relative to the current
+   * HttpServletRequest.
+   *
+   * @param	url	the url to be encoded.
+   * @return		the encoded URL if encoding is needed;
+   * 			the unchanged URL otherwise.
+   * @exception IllegalArgumentException if the url is not valid
+   *
+   * @see #sendRedirect
+   * @see #encodeUrl
+  */
+  encodeRedirectURL(url: string): string;
+  /**
+   * @deprecated	As of version 2.1, use encodeURL(String url) instead
+   *
+   * @param	url	the url to be encoded.
+   * @return		the encoded URL if encoding is needed; 
+   * 			the unchanged URL otherwise.
+   * @exception IllegalArgumentException if the url is not valid
+  */
+  encodeUrl(url: string): string;
+  /**
+   * @deprecated	As of version 2.1, use 
+   *			encodeRedirectURL(String url) instead
+   *
+   * @param	url	the url to be encoded.
+   * @return		the encoded URL if encoding is needed; 
+   * 			the unchanged URL otherwise.
+   * @exception IllegalArgumentException if the url is not valid
+  */
+  encodeRedirectUrl(url: string): string;
   /**
    * Gets the current status code of this response.
    *

package/dist/nav/server/navBuilder/navBuilder.d.ts

@@ -1,6 +1,7 @@
 import type { JCRNodeWrapper } from "org.jahia.services.content";
 import type { RenderContext, Resource } from "org.jahia.services.render";
-interface MenuEntry {
+/** @deprecated */
+export interface MenuEntry {
     /** The HTML rendered HTML menu entry */
     render: string;
     /** The node object for the menu entry */
@@ -17,6 +18,8 @@ interface MenuEntry {
 /**
  * Build a navigation menu
  *
+ * @deprecated We recommend building your own navigation menu using the JCR API; it will be more
+ *   efficient and flexible.
  * @param maxDepth The maximum depth of the menu
  * @param base The base path of the menu
  * @param menuEntryView The view to use for each menu entry
@@ -25,5 +28,4 @@ interface MenuEntry {
  * @param currentResource The current resource
  * @returns An array of menu entries objects
  */
-export declare function buildNavMenu(maxDepth: number, base: string, menuEntryView: string, startLevelValue: number, renderContext: RenderContext, currentResource: Resource): MenuEntry[];
-export {};
+export declare function buildNavMenu(maxDepth: number, base: string, menuEntryView: string | undefined, startLevelValue: number, renderContext: RenderContext, currentResource: Resource): MenuEntry[];

package/dist/org.jahia.modules.javascript.modules.engine.js.server.d.ts

@@ -192,6 +192,7 @@ export class RenderHelper {
   transformToJsNode(node: JCRNodeWrapper, includeChildren: boolean, includeDescendants: boolean, includeAllTranslations: boolean): any;
   /**
    * Get the render parameters for the given resource
+   *
    * @param resource the resource for which to retrieve the render parameters
    * @return a Map<String,Object> containing the render parameters
   */
@@ -201,6 +202,7 @@ export class RenderHelper {
    * don't need encoding are those defined 'unreserved' in section 2.3 of
    * the 'URI generic syntax' RFC 2396. Not the entire path string is escaped,
    * but every individual part (i.e. the slashes are not escaped).
+   *
    * @param path the path to encode
    * @return a String containing the escaped path
    * @throws NullPointerException if path is null.
@@ -209,15 +211,17 @@ export class RenderHelper {
   /**
    * Find the first displayable node in the given node's hierarchy. A displayable node is a node that has a content
    * or page template associated with it.
-   * @param node the node at which to start the resolution
+   *
+   * @param node          the node at which to start the resolution
    * @param renderContext the current render context
-   * @param contextSite the site in which to resolve the template
+   * @param contextSite   the site in which to resolve the template
    * @return the first displayable {@link JCRNodeWrapper} found in the hierarchy
   */
-  findDisplayableNode(node: JCRNodeWrapper, renderContext: RenderContext, contextSite: JCRSiteNode): JCRNodeWrapper;
+  findDisplayableNode(node: JCRNodeWrapper, renderContext: RenderContext, contextSite: JCRSiteNode | null): JCRNodeWrapper;
   /**
    * Returns the node which corresponds to the bound component of the j:bindedComponent property in the specified node.
-   * @param node the node to get the bound component for
+   *
+   * @param node    the node to get the bound component for
    * @param context current render context
    * @return the bound {@link JCRNodeWrapper}
   */
@@ -227,62 +231,64 @@ export class RenderHelper {
   render(attr: any, renderContext: RenderContext, currentResource: Resource): string;
   /**
    * Render a tag that adds resources to the page. Resources might for example be CSS files, Javascript files or inline
-   * @param attr may contain the following:
-   *             
-   *              insert (boolean) : If true, the resource will be inserted into the document. Typically used
-   *             for on-demand loading of resources. 
-   *              async (boolean) : If true, the resource will be loaded asynchronously. For scripts, this means
-   *             the script
-   *             will be executed as soon as it's available, without blocking the rest of the page. 
-   *              defer (boolean) : If true, the resource will be deferred, i.e., loaded after the document
-   *             has been parsed.
-   *             For scripts, this means the script will not be executed until after the page has loaded. 
-   *              type (string) : The type of the resource. This could be 'javascript' for .js files, 'css' for
-   *             .css files, etc.
-   *             The type will be used to resolve the directory in the module where the resources are located. For example
-   *             for the 'css' type it will look for the resources in the css directory of the module. 
-   *              resources (string) : The path to the resource file, relative to the module. It is also allowed to
-   *             specify multiple resources by separating them with commas. It is also allowed to use absolute URLs to
-   *             include remote resources. 
-   *              inlineResource (string) : Inline HTML that markup will be considered as a resource. 
-   *              title (string) : The title of the resource. This is typically not used for scripts or stylesheets,
-   *             but may be used for other types of resources. 
-   *              key (string) : A unique key for the resource. This could be used to prevent duplicate resources
-   *             from being added to the document. 
-   *              targetTag (string): The HTML tag where the resource should be added. This could be 'head' for
-   *             resources that should be added to the <head> tag, 'body' for resources that should be added to
-   *             the <body> tag, etc.
-   *              rel (string) : The relationship of the resource to the document. This is typically 'stylesheet'
-   *             for CSS files. 
-   *              media (string) : The media for which the resource is intended. This is typically used for CSS
-   *             files, with values like 'screen', 'print', etc. 
-   *              condition (string) : A condition that must be met for the resource to be loaded. This could be
-   *             used for conditional comments in IE, for example.
-   *             
+   *
+   * @param attr          may contain the following:
+   *                      
+   *                       insert (boolean) : If true, the resource will be inserted into the document. Typically used
+   *                      for on-demand loading of resources. 
+   *                       async (boolean) : If true, the resource will be loaded asynchronously. For scripts, this means
+   *                      the script
+   *                      will be executed as soon as it's available, without blocking the rest of the page. 
+   *                       defer (boolean) : If true, the resource will be deferred, i.e., loaded after the document
+   *                      has been parsed.
+   *                      For scripts, this means the script will not be executed until after the page has loaded. 
+   *                       type (string) : The type of the resource. This could be 'javascript' for .js files, 'css' for
+   *                      .css files, etc.
+   *                      The type will be used to resolve the directory in the module where the resources are located. For example
+   *                      for the 'css' type it will look for the resources in the css directory of the module. 
+   *                       resources (string) : The path to the resource file, relative to the module. It is also allowed to
+   *                      specify multiple resources by separating them with commas. It is also allowed to use absolute URLs to
+   *                      include remote resources. 
+   *                       inlineResource (string) : Inline HTML that markup will be considered as a resource. 
+   *                       title (string) : The title of the resource. This is typically not used for scripts or stylesheets,
+   *                      but may be used for other types of resources. 
+   *                       key (string) : A unique key for the resource. This could be used to prevent duplicate resources
+   *                      from being added to the document. 
+   *                       targetTag (string): The HTML tag where the resource should be added. This could be 'head' for
+   *                      resources that should be added to the <head> tag, 'body' for resources that should be added to
+   *                      the <body> tag, etc.
+   *                       rel (string) : The relationship of the resource to the document. This is typically 'stylesheet'
+   *                      for CSS files. 
+   *                       media (string) : The media for which the resource is intended. This is typically used for CSS
+   *                      files, with values like 'screen', 'print', etc. 
+   *                       condition (string) : A condition that must be met for the resource to be loaded. This could be
+   *                      used for conditional comments in IE, for example.
+   *                      
    * @param renderContext the current rendering context
    * @return a String containing the rendered HTML tags for the provided resources.
-   * @throws IllegalAccessException if the underlying tag cannot be accessed
+   * @throws IllegalAccessException    if the underlying tag cannot be accessed
    * @throws InvocationTargetException if the underlying tag cannot be invoked
-   * @throws JspException if the underlying tag throws a JSP exception
-   * @throws IOException if the underlying tag throws an IO exception
+   * @throws JspException              if the underlying tag throws a JSP exception
+   * @throws IOException               if the underlying tag throws an IO exception
   */
   addResources(attr: any, renderContext: RenderContext): string;
   /**
    * Add a cache dependency to the current resource. This will be used to flush the current resource when the
    * dependencies are modified.
-   * @param attr may be the following:
-   *             
-   *              node (JCRNodeWrapper) : The node to add as a dependency. 
-   *              uuid (String) : The UUID of the node to add as a dependency. 
-   *              path (String) : The path of the node to add as a dependency. 
-   *              flushOnPathMatchingRegexp (String) : A regular expression that will be used to flush the cache
-   *             when the path of the modified nodes matches the regular expression. 
-   *             
+   *
+   * @param attr          may be the following:
+   *                      
+   *                       node (JCRNodeWrapper) : The node to add as a dependency. 
+   *                       uuid (String) : The UUID of the node to add as a dependency. 
+   *                       path (String) : The path of the node to add as a dependency. 
+   *                       flushOnPathMatchingRegexp (String) : A regular expression that will be used to flush the cache
+   *                      when the path of the modified nodes matches the regular expression. 
+   *                      
    * @param renderContext the current rendering context
-   * @throws IllegalAccessException if the underlying tag cannot be accessed
+   * @throws IllegalAccessException    if the underlying tag cannot be accessed
    * @throws InvocationTargetException if the underlying tag cannot be invoked
-   * @throws JspException if the underlying tag throws a JSP exception
-   * @throws IOException if the underlying tag throws an IO exception
+   * @throws JspException              if the underlying tag throws a JSP exception
+   * @throws IOException               if the underlying tag throws an IO exception
   */
   addCacheDependency(attr: any, renderContext: RenderContext): void;
   renderAbsoluteArea(attr: any, renderContext: RenderContext): string;

package/dist/org.jahia.services.content.d.ts

@@ -1,10 +1,12 @@
 declare module 'org.jahia.services.content' {
 import { ServletRequest } from 'javax.servlet';
+import { Iterable } from 'java.lang';
 import { Locale, List, Map, Date } from 'java.util';
 import { HttpServletRequest } from 'javax.servlet.http';
 import { QueryWrapper } from 'org.jahia.services.query';
 import { JCRSiteNode } from 'org.jahia.services.content.decorator';
 import { JahiaUser } from 'org.jahia.services.usermanager';
+import { ExtendedNodeType } from 'org.jahia.services.content.nodetypes';
 import { NodeIterator, Item, Node, PropertyIterator, Binary, Property } from 'javax.jcr';
 export class JCRCallback<T> {
   /**
@@ -163,7 +165,7 @@ export class JCRItemWrapper {
 /**
  * @author Christophe Laprun
 */
-export class JCRNodeIteratorWrapper {
+export class JCRNodeIteratorWrapper extends Iterable<JCRNodeWrapper> {
   /**
    * Returns the next Node in the iteration.
    *
@@ -173,6 +175,19 @@ export class JCRNodeIteratorWrapper {
    *          Nodes.
   */
   nextNode(): Node;
+  /**
+   * Returns the total number of of items available through this iterator. For
+   * example, for some node N, N.getNodes().getSize()
+   * returns the number of child nodes of N visible through the
+   * current Session. In some implementations precise information
+   * about the number of elements may not be available. In such cases this
+   * method must return -1. API clients will then be able to use
+   * RangeIterator.getNumberRemaining to get an estimate on the
+   * number of elements.
+   *
+   * @return a long
+  */
+  getSize(): number;
   /**
    * Returns `true` if the iteration has more elements.
    * (In other words, returns `true` if {@link #next} would
@@ -204,6 +219,12 @@ export class JCRNodeWrapper {
    * @return The wrapped property at relPath.
   */
   getProperty(relPath: string): JCRPropertyWrapper;
+  /**
+   * {@inheritDoc}
+   *
+   * @return an array of  ExtendedNodeType objects.
+  */
+  getMixinNodeTypes(): ExtendedNodeType[];
   /**
    * Checks if the current user has a permission or not
    *
@@ -387,6 +408,24 @@ export class JCRNodeWrapper {
    * {@inheritDoc}
   */
   getPath(): string;
+  /**
+   * Get the translation node
+   * Use only in un-localized session
+   *
+   * @param locale
+   * @return
+   * @throws RepositoryException in case of JCR-related errors
+  */
+  getI18N(locale: Locale): Node;
+  /**
+   * Get the translation node
+   * Use only in un-localized session
+   *
+   * @param locale
+   * @return
+   * @throws RepositoryException in case of JCR-related errors
+  */
+  getI18N(locale: Locale, fallback: boolean): Node;
   /**
    * Returns available translation sub-nodes of this node.
    *
@@ -1311,6 +1350,7 @@ export class JCRSessionWrapper {
   getNode(path: string): JCRNodeWrapper;
   getNode(path: string, checkVersion: boolean): JCRNodeWrapper;
   getUser(): JahiaUser;
+  getAliasedUser(): JahiaUser;
   getNodeByIdentifier(id: string): JCRNodeWrapper;
   getProperty(absPath: string): Property;
   nodeExists(absPath: string): boolean;