@aerokit/sdk 12.44.0

package/dist/cjs/cms/cmis.js

@@ -0,0 +1,689 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var cmis_exports = {};
+__export(cmis_exports, {
+  Cmis: () => Cmis,
+  Document: () => Document,
+  Folder: () => Folder
+});
+module.exports = __toCommonJS(cmis_exports);
+var streams = __toESM(require("@aerokit/sdk/io/streams"));
+const CmisFacade = Java.type("org.eclipse.dirigible.components.api.cms.CmisFacade");
+const Gson = Java.type("com.google.gson.Gson");
+const HashMap = Java.type("java.util.HashMap");
+class Cmis {
+  static {
+    // CONSTANTS
+    /**
+     * CMIS method constant for read operations.
+     */
+    this.METHOD_READ = "READ";
+  }
+  static {
+    /**
+     * CMIS method constant for write operations.
+     */
+    this.METHOD_WRITE = "WRITE";
+  }
+  static {
+    // ---- Base CMIS Properties ----
+    /** CMIS property: Object name. */
+    this.NAME = "cmis:name";
+  }
+  static {
+    /** CMIS property: Unique object identifier. */
+    this.OBJECT_ID = "cmis:objectId";
+  }
+  static {
+    /** CMIS property: Object type identifier. */
+    this.OBJECT_TYPE_ID = "cmis:objectTypeId";
+  }
+  static {
+    /** CMIS property: Base object type identifier. */
+    this.BASE_TYPE_ID = "cmis:baseTypeId";
+  }
+  static {
+    /** CMIS property: User who created the object. */
+    this.CREATED_BY = "cmis:createdBy";
+  }
+  static {
+    /** CMIS property: Timestamp of object creation. */
+    this.CREATION_DATE = "cmis:creationDate";
+  }
+  static {
+    /** CMIS property: User who last modified the object. */
+    this.LAST_MODIFIED_BY = "cmis:lastModifiedBy";
+  }
+  static {
+    /** CMIS property: Timestamp of last modification. */
+    this.LAST_MODIFICATION_DATE = "cmis:lastModificationDate";
+  }
+  static {
+    /** CMIS property: Change token for object change tracking. */
+    this.CHANGE_TOKEN = "cmis:changeToken";
+  }
+  static {
+    // ---- Document CMIS Properties ----
+    /** CMIS property: Indicates if the document is immutable. */
+    this.IS_IMMUTABLE = "cmis:isImmutable";
+  }
+  static {
+    /** CMIS property: Indicates if the document is the latest version in the version series. */
+    this.IS_LATEST_VERSION = "cmis:isLatestVersion";
+  }
+  static {
+    /** CMIS property: Indicates if the document is a major version. */
+    this.IS_MAJOR_VERSION = "cmis:isMajorVersion";
+  }
+  static {
+    /** CMIS property: Indicates if the document is the latest major version. */
+    this.IS_LATEST_MAJOR_VERSION = "cmis:isLatestMajorVersion";
+  }
+  static {
+    /** CMIS property: Label of the document version. */
+    this.VERSION_LABEL = "cmis:versionLabel";
+  }
+  static {
+    /** CMIS property: ID of the version series. */
+    this.VERSION_SERIES_ID = "cmis:versionSeriesId";
+  }
+  static {
+    /** CMIS property: Indicates if the version series is checked out. */
+    this.IS_VERSION_SERIES_CHECKED_OUT = "cmis:isVersionSeriesCheckedOut";
+  }
+  static {
+    /** CMIS property: User who checked out the version series. */
+    this.VERSION_SERIES_CHECKED_OUT_BY = "cmis:versionSeriesCheckedOutBy";
+  }
+  static {
+    /** CMIS property: ID of the checked-out document object. */
+    this.VERSION_SERIES_CHECKED_OUT_ID = "cmis:versionSeriesCheckedOutId";
+  }
+  static {
+    /** CMIS property: Comment associated with the check-in operation. */
+    this.CHECKIN_COMMENT = "cmis:checkinComment";
+  }
+  static {
+    /** CMIS property: Length of the content stream in bytes. */
+    this.CONTENT_STREAM_LENGTH = "cmis:contentStreamLength";
+  }
+  static {
+    /** CMIS property: MIME type of the content stream. */
+    this.CONTENT_STREAM_MIME_TYPE = "cmis:contentStreamMimeType";
+  }
+  static {
+    /** CMIS property: Original file name of the content stream. */
+    this.CONTENT_STREAM_FILE_NAME = "cmis:contentStreamFileName";
+  }
+  static {
+    /** CMIS property: ID of the content stream. */
+    this.CONTENT_STREAM_ID = "cmis:contentStreamId";
+  }
+  static {
+    // ---- Folder CMIS Properties ----
+    /** CMIS property: Object ID of the parent folder. */
+    this.PARENT_ID = "cmis:parentId";
+  }
+  static {
+    /** CMIS property: List of allowed object type IDs for children. */
+    this.ALLOWED_CHILD_OBJECT_TYPE_IDS = "cmis:allowedChildObjectTypeIds";
+  }
+  static {
+    /** CMIS property: Path of the folder in the repository. */
+    this.PATH = "cmis:path";
+  }
+  static {
+    // ---- Relationship CMIS Properties ----
+    /** CMIS property: Object ID of the relationship source. */
+    this.SOURCE_ID = "cmis:sourceId";
+  }
+  static {
+    /** CMIS property: Object ID of the relationship target. */
+    this.TARGET_ID = "cmis:targetId";
+  }
+  static {
+    // ---- Policy CMIS Properties ----
+    /** CMIS property: Text content of the policy. */
+    this.POLICY_TEXT = "cmis:policyText";
+  }
+  static {
+    // ---- Versioning States ----
+    /** CMIS Versioning State: No versioning. */
+    this.VERSIONING_STATE_NONE = "none";
+  }
+  static {
+    /** CMIS Versioning State: Create a new major version. */
+    this.VERSIONING_STATE_MAJOR = "major";
+  }
+  static {
+    /** CMIS Versioning State: Create a new minor version. */
+    this.VERSIONING_STATE_MINOR = "minor";
+  }
+  static {
+    /** CMIS Versioning State: Document is checked out. */
+    this.VERSIONING_STATE_CHECKEDOUT = "checkedout";
+  }
+  static {
+    // ---- Object Types ----
+    /** CMIS Object Type ID: Document. */
+    this.OBJECT_TYPE_DOCUMENT = "cmis:document";
+  }
+  static {
+    /** CMIS Object Type ID: Folder. */
+    this.OBJECT_TYPE_FOLDER = "cmis:folder";
+  }
+  static {
+    /** CMIS Object Type ID: Relationship. */
+    this.OBJECT_TYPE_RELATIONSHIP = "cmis:relationship";
+  }
+  static {
+    /** CMIS Object Type ID: Policy. */
+    this.OBJECT_TYPE_POLICY = "cmis:policy";
+  }
+  static {
+    /** CMIS Object Type ID: Item. */
+    this.OBJECT_TYPE_ITEM = "cmis:item";
+  }
+  static {
+    /** CMIS Object Type ID: Secondary. */
+    this.OBJECT_TYPE_SECONDARY = "cmis:secondary";
+  }
+  /**
+   * Gets a new CMIS session instance to interact with the repository.
+   * @returns A new {@link Session} instance.
+   */
+  static getSession() {
+    const native = CmisFacade.getSession();
+    return new Session(native);
+  }
+  /**
+   * Retrieves access control definitions for a specific path and method.
+   * @param path The path of the CMIS object.
+   * @param method The operation method (e.g., {@link Cmis.METHOD_READ}, {@link Cmis.METHOD_WRITE}).
+   * @returns A list of access definitions.
+   */
+  static getAccessDefinitions(path, method) {
+    const accessDefinitions = CmisFacade.getAccessDefinitions(path, method);
+    return JSON.parse(new Gson().toJson(accessDefinitions));
+  }
+}
+class Session {
+  constructor(native) {
+    this.native = native;
+  }
+  /**
+   * Gets information about the repository this session is connected to.
+   * @returns Repository metadata.
+   */
+  getRepositoryInfo() {
+    const native = this.native.getRepositoryInfo();
+    return new RepositoryInfo(native);
+  }
+  /**
+   * Gets the root folder of the repository.
+   * @returns The root {@link Folder} object.
+   */
+  getRootFolder() {
+    const native = this.native.getRootFolder();
+    return new Folder(native, null);
+  }
+  /**
+   * Gets the object factory for creating new CMIS objects like ContentStream.
+   * @returns An {@link ObjectFactory} instance.
+   */
+  getObjectFactory() {
+    const native = this.native.getObjectFactory();
+    return new ObjectFactory(native);
+  }
+  /**
+   * Retrieves a CMIS object (Document or Folder) by its unique ID.
+   * @param objectId The unique ID of the object.
+   * @returns A {@link Document} or {@link Folder} instance.
+   * @throws Error if the object type is unsupported.
+   */
+  getObject(objectId) {
+    const objectInstance = this.native.getObject(objectId);
+    const objectInstanceType = objectInstance.getType();
+    const objectInstanceTypeId = objectInstanceType.getId();
+    if (objectInstanceTypeId === Cmis.OBJECT_TYPE_DOCUMENT) {
+      return new Document(objectInstance, null);
+    } else if (objectInstanceTypeId === Cmis.OBJECT_TYPE_FOLDER) {
+      return new Folder(objectInstance, null);
+    }
+    throw new Error("Unsupported CMIS object type: " + objectInstanceTypeId);
+  }
+  /**
+   * Retrieves a CMIS object (Document or Folder) by its path.
+   * @param path The path of the object in the repository (e.g., "/path/to/object").
+   * @returns A {@link Document} or {@link Folder} instance.
+   * @throws Error if read access is not allowed or the object type is unsupported.
+   */
+  getObjectByPath(path) {
+    const allowed = CmisFacade.isAllowed(path, Cmis.METHOD_READ);
+    if (!allowed) {
+      throw new Error("Read access not allowed on: " + path);
+    }
+    const objectInstance = this.native.getObjectByPath(path);
+    const objectInstanceType = objectInstance.getType();
+    const objectInstanceTypeId = objectInstanceType.getId();
+    if (objectInstanceTypeId === Cmis.OBJECT_TYPE_DOCUMENT) {
+      return new Document(objectInstance, path);
+    } else if (objectInstanceTypeId === Cmis.OBJECT_TYPE_FOLDER) {
+      return new Folder(objectInstance, path);
+    }
+    throw new Error("Unsupported CMIS object type: " + objectInstanceTypeId);
+  }
+  /**
+   * Creates a folder structure recursively based on a path. This is a convenience method that
+   * creates all non-existent parent folders.
+   * Example: `createFolder("/new/path/structure")`
+   * @param location The path of the folder to create.
+   * @returns The newly created (or existing) innermost {@link Folder} object.
+   */
+  createFolder(location) {
+    if (location.startsWith("/")) {
+      location = location.substring(1, location.length);
+    }
+    if (location.endsWith("/")) {
+      location = location.substring(0, location.length - 1);
+    }
+    const segments = location.split("/");
+    let folder = this.getRootFolder();
+    for (const next of segments) {
+      const properties = {
+        [Cmis.OBJECT_TYPE_ID]: Cmis.OBJECT_TYPE_FOLDER,
+        [Cmis.NAME]: next
+      };
+      folder = folder.createFolder(properties);
+    }
+    return folder;
+  }
+  /**
+   * Creates a new document at the specified location. This method ensures the parent folder structure exists.
+   * @param location The path of the parent folder (e.g., "/path/to/folder").
+   * @param properties A map of CMIS properties for the new document (must include {@link Cmis.NAME}).
+   * @param contentStream The content stream containing the document's binary data.
+   * @param versioningState The versioning state (e.g., {@link Cmis.VERSIONING_STATE_MAJOR}).
+   * @returns The newly created {@link Document} object.
+   */
+  createDocument(location, properties, contentStream, versioningState) {
+    const folder = this.createFolder(location);
+    return folder.createDocument(properties, contentStream, versioningState);
+  }
+}
+class RepositoryInfo {
+  constructor(native) {
+    this.native = native;
+  }
+  /**
+   * Gets the unique identifier of the repository.
+   * @returns The repository ID.
+   */
+  getId() {
+    return this.native.getId();
+  }
+  /**
+   * Gets the name of the repository.
+   * @returns The repository name.
+   */
+  getName() {
+    return this.native.getName();
+  }
+}
+class Folder {
+  constructor(native, path) {
+    this.native = native;
+    this.path = path;
+  }
+  /**
+   * Gets the unique identifier of the folder.
+   * @returns The folder ID.
+   */
+  getId() {
+    return this.native.getId();
+  }
+  /**
+   * Gets the name of the folder.
+   * @returns The folder name.
+   */
+  getName() {
+    return this.native.getName();
+  }
+  /**
+   * Creates a new folder within this folder.
+   * @param properties A map of CMIS properties for the new folder (must include {@link Cmis.NAME}).
+   * @returns The newly created {@link Folder} object.
+   * @throws Error if write access is not allowed.
+   */
+  createFolder(properties) {
+    var allowed = CmisFacade.isAllowed(this.getPath(), Cmis.METHOD_WRITE);
+    if (!allowed) {
+      throw new Error("Write access not allowed on: " + this.getPath());
+    }
+    var mapInstance = new HashMap();
+    for (var property in properties) {
+      if (properties.hasOwnProperty(property)) {
+        mapInstance.put(property, properties[property]);
+      }
+    }
+    var native = this.native.createFolder(mapInstance);
+    var folder = new Folder(native, null);
+    return folder;
+  }
+  /**
+   * Creates a new document within this folder.
+   * @param properties A map of CMIS properties for the new document (must include {@link Cmis.NAME}).
+   * @param contentStream The content stream containing the document's binary data.
+   * @param versioningState The versioning state (e.g., {@link Cmis.VERSIONING_STATE_MAJOR}).
+   * @returns The newly created {@link Document} object.
+   * @throws Error if write access is not allowed.
+   */
+  createDocument(properties, contentStream, versioningState) {
+    const allowed = CmisFacade.isAllowed(this.getPath(), Cmis.METHOD_WRITE);
+    if (!allowed) {
+      throw new Error("Write access not allowed on: " + this.getPath());
+    }
+    const mapInstance = new HashMap();
+    for (const property in properties) {
+      if (properties.hasOwnProperty(property)) {
+        mapInstance.put(property, properties[property]);
+      }
+    }
+    const state = CmisFacade.getVersioningState(versioningState);
+    const native = this.native.createDocument(mapInstance, contentStream.native, state);
+    return new Document(native, null);
+  }
+  /**
+   * Retrieves the children of this folder.
+   * @returns A list of generic {@link CmisObject} wrappers for the children.
+   * @throws Error if read access is not allowed.
+   */
+  getChildren() {
+    const allowed = CmisFacade.isAllowed(this.getPath(), Cmis.METHOD_READ);
+    if (!allowed) {
+      throw new Error("Read access not allowed on: " + this.getPath());
+    }
+    const children = [];
+    const childrenInstance = this.native.getChildren();
+    const childrenInstanceIterator = childrenInstance.iterator();
+    while (childrenInstanceIterator.hasNext()) {
+      const cmisObjectInstance = childrenInstanceIterator.next();
+      const cmisObject = new CmisObject(cmisObjectInstance);
+      children.push(cmisObject);
+    }
+    return children;
+  }
+  /**
+   * Gets the path of the folder.
+   * @returns The folder path.
+   */
+  getPath() {
+    return this.path;
+  }
+  /**
+   * Checks if this folder is the root folder of the repository.
+   * @returns True if it is the root folder, false otherwise.
+   */
+  isRootFolder() {
+    return this.native.isRootFolder();
+  }
+  /**
+   * Gets the parent folder of this folder.
+   * @returns The parent {@link Folder} object.
+   */
+  getFolderParent() {
+    const native = this.native.getFolderParent();
+    return new Folder(native, null);
+  }
+  /**
+   * Deletes this folder (must be empty to succeed).
+   * @throws Error if write access is not allowed.
+   */
+  delete() {
+    const allowed = CmisFacade.isAllowed(this.getPath(), Cmis.METHOD_WRITE);
+    if (!allowed) {
+      throw new Error("Write access not allowed on: " + this.getPath());
+    }
+    this.native.delete();
+  }
+  /**
+   * Renames this folder.
+   * @param newName The new name for the folder.
+   * @throws Error if write access is not allowed.
+   */
+  rename(newName) {
+    const allowed = CmisFacade.isAllowed(this.getPath(), Cmis.METHOD_WRITE);
+    if (!allowed) {
+      throw new Error("Write access not allowed on: " + this.getPath());
+    }
+    this.native.rename(newName);
+  }
+  /**
+   * Deletes this folder and all its contents recursively.
+   * @throws Error if write access is not allowed.
+   */
+  deleteTree() {
+    const allowed = CmisFacade.isAllowed(this.getPath(), Cmis.METHOD_WRITE);
+    if (!allowed) {
+      throw new Error("Write access not allowed on: " + this.getPath());
+    }
+    const unifiedObjectDelete = CmisFacade.getUnifiedObjectDelete();
+    this.native.deleteTree(true, unifiedObjectDelete, true);
+  }
+  /**
+   * Gets the type definition of the folder.
+   * @returns The folder's {@link TypeDefinition}.
+   */
+  getType() {
+    const native = this.native.getType();
+    return new TypeDefinition(native);
+  }
+}
+class CmisObject {
+  constructor(native) {
+    this.native = native;
+  }
+  /**
+   * Gets the unique identifier of the object.
+   * @returns The object ID.
+   */
+  getId() {
+    return this.native.getId();
+  }
+  /**
+   * Gets the name of the object.
+   * @returns The object name.
+   */
+  getName() {
+    return this.native.getName();
+  }
+  /**
+   * Gets the path of the CMIS object. Handles differences in native CMIS implementations.
+   * @returns The object path.
+   * @throws Error if the path cannot be determined.
+   */
+  getPath() {
+    if (this.native.getPath) {
+      return this.native.getPath();
+    }
+    if (this.native.getPaths) {
+      return this.native.getPaths()[0];
+    }
+    throw new Error(`Path not found for CmisObject with id ${this.getId()}`);
+  }
+  /**
+   * Gets the type definition of the object.
+   * @returns The object's {@link TypeDefinition}.
+   */
+  getType() {
+    const native = this.native.getType();
+    return new TypeDefinition(native);
+  }
+  /**
+   * Deletes the CMIS object.
+   */
+  delete() {
+    this.native.delete();
+  }
+  /**
+   * Renames the CMIS object.
+   * @param newName The new name for the object.
+   */
+  rename(newName) {
+    this.native.rename(newName);
+  }
+}
+class ObjectFactory {
+  constructor(native) {
+    this.native = native;
+  }
+  /**
+   * Creates a new content stream instance that can be used to create or update document content.
+   * @param filename The name of the file.
+   * @param length The size of the content stream in bytes.
+   * @param mimetype The MIME type of the content.
+   * @param inputStream The input stream containing the data.
+   * @returns A new {@link ContentStream} object.
+   */
+  createContentStream(filename, length, mimetype, inputStream) {
+    const native = this.native.createContentStream(filename, length, mimetype, inputStream.native);
+    return new ContentStream(native);
+  }
+}
+class ContentStream {
+  constructor(native) {
+    this.native = native;
+  }
+  /**
+   * Gets the Java-backed input stream for reading the content.
+   * @returns An {@link streams.InputStream} wrapper.
+   */
+  getStream() {
+    const native = this.native.getStream();
+    return new streams.InputStream(native);
+  }
+  /**
+   * Gets the MIME type of the content stream.
+   * @returns The MIME type string.
+   */
+  getMimeType() {
+    return this.native.getMimeType();
+  }
+}
+class Document {
+  constructor(native, path) {
+    this.native = native;
+    this.path = path;
+  }
+  /**
+   * Gets the unique identifier of the document.
+   * @returns The document ID.
+   */
+  getId() {
+    return this.native.getId();
+  }
+  /**
+   * Gets the name of the document.
+   * @returns The document name.
+   */
+  getName() {
+    return this.native.getName();
+  }
+  /**
+   * Gets the type definition of the document.
+   * @returns The document's {@link TypeDefinition}.
+   */
+  getType() {
+    const native = this.native.getType();
+    return new TypeDefinition(native);
+  }
+  /**
+   * Gets the path of the document.
+   * @returns The document path.
+   */
+  getPath() {
+    return this.path;
+  }
+  /**
+   * Deletes this document.
+   * @throws Error if write access is not allowed.
+   */
+  delete() {
+    const allowed = CmisFacade.isAllowed(this.getPath(), Cmis.METHOD_WRITE);
+    if (!allowed) {
+      throw new Error("Write access not allowed on: " + this.getPath());
+    }
+    return this.native.delete(true);
+  }
+  /**
+   * Gets the binary content stream of the document.
+   * @returns The {@link ContentStream} object, or `null` if the document has no content.
+   */
+  getContentStream() {
+    const native = this.native.getContentStream();
+    if (native !== null) {
+      return new ContentStream(native);
+    }
+    return null;
+  }
+  /**
+   * Gets the size of the document's content stream in bytes.
+   * @returns The size in bytes.
+   */
+  getSize() {
+    return this.native.getSize();
+  }
+  /**
+   * Renames this document.
+   * @param newName The new name for the document.
+   * @throws Error if write access is not allowed.
+   */
+  rename(newName) {
+    const allowed = CmisFacade.isAllowed(this.getPath(), Cmis.METHOD_WRITE);
+    if (!allowed) {
+      throw new Error("Write access not allowed on: " + this.getPath());
+    }
+    this.native.rename(newName);
+  }
+}
+class TypeDefinition {
+  constructor(native) {
+    this.native = native;
+  }
+  /**
+   * Gets the unique ID of the object type (e.g., 'cmis:document').
+   * @returns The type ID.
+   */
+  getId() {
+    return this.native.getId();
+  }
+}
+if (typeof module !== "undefined") {
+  module.exports = Cmis;
+}
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/cms/cmis.ts"],
  "sourcesContent": ["/**\n * API CMIS\n * * Note: This module is supported only with the Mozilla Rhino engine\n * * Provides static access to the CMIS (Content Management Interoperability Services) repository session and utility constants.\n */\n\nimport * as streams from \"@aerokit/sdk/io/streams\";\nconst CmisFacade = Java.type(\"org.eclipse.dirigible.components.api.cms.CmisFacade\");\nconst Gson = Java.type(\"com.google.gson.Gson\");\nconst HashMap = Java.type(\"java.util.HashMap\");\n\nexport class Cmis {\n\n\t// CONSTANTS\n\t/**\n\t * CMIS method constant for read operations.\n\t */\n\tpublic static readonly METHOD_READ = \"READ\";\n\t/**\n\t * CMIS method constant for write operations.\n\t */\n\tpublic static readonly METHOD_WRITE = \"WRITE\";\n\n\t// ---- Base CMIS Properties ----\n\t/** CMIS property: Object name. */\n\tpublic static readonly NAME = \"cmis:name\";\n\t/** CMIS property: Unique object identifier. */\n\tpublic static readonly OBJECT_ID = \"cmis:objectId\";\n\t/** CMIS property: Object type identifier. */\n\tpublic static readonly OBJECT_TYPE_ID = \"cmis:objectTypeId\";\n\t/** CMIS property: Base object type identifier. */\n\tpublic static readonly BASE_TYPE_ID = \"cmis:baseTypeId\";\n\t/** CMIS property: User who created the object. */\n\tpublic static readonly CREATED_BY = \"cmis:createdBy\";\n\t/** CMIS property: Timestamp of object creation. */\n\tpublic static readonly CREATION_DATE = \"cmis:creationDate\";\n\t/** CMIS property: User who last modified the object. */\n\tpublic static readonly LAST_MODIFIED_BY = \"cmis:lastModifiedBy\";\n\t/** CMIS property: Timestamp of last modification. */\n\tpublic static readonly LAST_MODIFICATION_DATE = \"cmis:lastModificationDate\";\n\t/** CMIS property: Change token for object change tracking. */\n\tpublic static readonly CHANGE_TOKEN = \"cmis:changeToken\";\n\n\t// ---- Document CMIS Properties ----\n\t/** CMIS property: Indicates if the document is immutable. */\n\tpublic static readonly IS_IMMUTABLE = \"cmis:isImmutable\";\n\t/** CMIS property: Indicates if the document is the latest version in the version series. */\n\tpublic static readonly IS_LATEST_VERSION = \"cmis:isLatestVersion\";\n\t/** CMIS property: Indicates if the document is a major version. */\n\tpublic static readonly IS_MAJOR_VERSION = \"cmis:isMajorVersion\";\n\t/** CMIS property: Indicates if the document is the latest major version. */\n\tpublic static readonly IS_LATEST_MAJOR_VERSION = \"cmis:isLatestMajorVersion\";\n\t/** CMIS property: Label of the document version. */\n\tpublic static readonly VERSION_LABEL = \"cmis:versionLabel\";\n\t/** CMIS property: ID of the version series. */\n\tpublic static readonly VERSION_SERIES_ID = \"cmis:versionSeriesId\";\n\t/** CMIS property: Indicates if the version series is checked out. */\n\tpublic static readonly IS_VERSION_SERIES_CHECKED_OUT = \"cmis:isVersionSeriesCheckedOut\";\n\t/** CMIS property: User who checked out the version series. */\n\tpublic static readonly VERSION_SERIES_CHECKED_OUT_BY = \"cmis:versionSeriesCheckedOutBy\";\n\t/** CMIS property: ID of the checked-out document object. */\n\tpublic static readonly VERSION_SERIES_CHECKED_OUT_ID = \"cmis:versionSeriesCheckedOutId\";\n\t/** CMIS property: Comment associated with the check-in operation. */\n\tpublic static readonly CHECKIN_COMMENT = \"cmis:checkinComment\";\n\t/** CMIS property: Length of the content stream in bytes. */\n\tpublic static readonly CONTENT_STREAM_LENGTH = \"cmis:contentStreamLength\";\n\t/** CMIS property: MIME type of the content stream. */\n\tpublic static readonly CONTENT_STREAM_MIME_TYPE = \"cmis:contentStreamMimeType\";\n\t/** CMIS property: Original file name of the content stream. */\n\tpublic static readonly CONTENT_STREAM_FILE_NAME = \"cmis:contentStreamFileName\";\n\t/** CMIS property: ID of the content stream. */\n\tpublic static readonly CONTENT_STREAM_ID = \"cmis:contentStreamId\";\n\n\t// ---- Folder CMIS Properties ----\n\t/** CMIS property: Object ID of the parent folder. */\n\tpublic static readonly PARENT_ID = \"cmis:parentId\";\n\t/** CMIS property: List of allowed object type IDs for children. */\n\tpublic static readonly ALLOWED_CHILD_OBJECT_TYPE_IDS = \"cmis:allowedChildObjectTypeIds\";\n\t/** CMIS property: Path of the folder in the repository. */\n\tpublic static readonly PATH = \"cmis:path\";\n\n\t// ---- Relationship CMIS Properties ----\n\t/** CMIS property: Object ID of the relationship source. */\n\tpublic static readonly SOURCE_ID = \"cmis:sourceId\";\n\t/** CMIS property: Object ID of the relationship target. */\n\tpublic static readonly TARGET_ID = \"cmis:targetId\";\n\n\t// ---- Policy CMIS Properties ----\n\t/** CMIS property: Text content of the policy. */\n\tpublic static readonly POLICY_TEXT = \"cmis:policyText\";\n\n\t// ---- Versioning States ----\n\t/** CMIS Versioning State: No versioning. */\n\tpublic static readonly VERSIONING_STATE_NONE = \"none\";\n\t/** CMIS Versioning State: Create a new major version. */\n\tpublic static readonly VERSIONING_STATE_MAJOR = \"major\";\n\t/** CMIS Versioning State: Create a new minor version. */\n\tpublic static readonly VERSIONING_STATE_MINOR = \"minor\";\n\t/** CMIS Versioning State: Document is checked out. */\n\tpublic static readonly VERSIONING_STATE_CHECKEDOUT = \"checkedout\";\n\n\t// ---- Object Types ----\n\t/** CMIS Object Type ID: Document. */\n\tpublic static readonly OBJECT_TYPE_DOCUMENT = \"cmis:document\";\n\t/** CMIS Object Type ID: Folder. */\n\tpublic static readonly OBJECT_TYPE_FOLDER = \"cmis:folder\";\n\t/** CMIS Object Type ID: Relationship. */\n\tpublic static readonly OBJECT_TYPE_RELATIONSHIP = \"cmis:relationship\";\n\t/** CMIS Object Type ID: Policy. */\n\tpublic static readonly OBJECT_TYPE_POLICY = \"cmis:policy\";\n\t/** CMIS Object Type ID: Item. */\n\tpublic static readonly OBJECT_TYPE_ITEM = \"cmis:item\";\n\t/** CMIS Object Type ID: Secondary. */\n\tpublic static readonly OBJECT_TYPE_SECONDARY = \"cmis:secondary\";\n\n\t/**\n\t * Gets a new CMIS session instance to interact with the repository.\n\t * @returns A new {@link Session} instance.\n\t */\n\tpublic static getSession(): Session {\n\t\tconst native = CmisFacade.getSession();\n\t\treturn new Session(native);\n\t}\n\n\t/**\n\t * Retrieves access control definitions for a specific path and method.\n\t * @param path The path of the CMIS object.\n\t * @param method The operation method (e.g., {@link Cmis.METHOD_READ}, {@link Cmis.METHOD_WRITE}).\n\t * @returns A list of access definitions.\n\t */\n\tpublic static getAccessDefinitions(path: string, method: string): AccessDefinition[] {\n\t\tconst accessDefinitions = CmisFacade.getAccessDefinitions(path, method);\n\t\treturn JSON.parse(new Gson().toJson(accessDefinitions));\n\t}\n}\n\n/**\n * Represents an access control entry (ACE) for a CMIS object, detailing\n * who has what permissions on a path.\n */\ninterface AccessDefinition {\n\t/** Gets the unique identifier for the access definition. */\n\tgetId(): string;\n\t/** Gets the scope of the definition (e.g., 'user', 'group'). */\n\tgetScope(): string;\n\t/** Gets the path of the CMIS object this definition applies to. */\n\tgetPath(): string;\n\t/** Gets the method/operation this definition applies to (e.g., 'READ', 'WRITE'). */\n\tgetMethod(): string;\n\t/** Gets the security role (e.g., 'Administrator', 'Viewer'). */\n\tgetRole(): string;\n}\n\n/**\n * Session object\n * * Represents an active connection to a CMIS repository, used as the main entry point for CMIS operations.\n */\nclass Session {\n\n\tprivate readonly native: any;\n\n\tconstructor(native: any) {\n\t\tthis.native = native;\n\t}\n\n\t/**\n\t * Gets information about the repository this session is connected to.\n\t * @returns Repository metadata.\n\t */\n\tpublic getRepositoryInfo(): RepositoryInfo {\n\t\tconst native = this.native.getRepositoryInfo();\n\t\treturn new RepositoryInfo(native);\n\t}\n\n\t/**\n\t * Gets the root folder of the repository.\n\t * @returns The root {@link Folder} object.\n\t */\n\tpublic getRootFolder(): Folder {\n\t\tconst native = this.native.getRootFolder();\n\t\treturn new Folder(native, null);\n\t}\n\n\t/**\n\t * Gets the object factory for creating new CMIS objects like ContentStream.\n\t * @returns An {@link ObjectFactory} instance.\n\t */\n\tpublic getObjectFactory(): ObjectFactory {\n\t\tconst native = this.native.getObjectFactory();\n\t\treturn new ObjectFactory(native);\n\t}\n\n\t/**\n\t * Retrieves a CMIS object (Document or Folder) by its unique ID.\n\t * @param objectId The unique ID of the object.\n\t * @returns A {@link Document} or {@link Folder} instance.\n\t * @throws Error if the object type is unsupported.\n\t */\n\tpublic getObject(objectId: string): Folder | Document {\n\t\tconst objectInstance = this.native.getObject(objectId);\n\t\tconst objectInstanceType = objectInstance.getType();\n\t\tconst objectInstanceTypeId = objectInstanceType.getId();\n\t\tif (objectInstanceTypeId === Cmis.OBJECT_TYPE_DOCUMENT) {\n\t\t\treturn new Document(objectInstance, null);\n\t\t} else if (objectInstanceTypeId === Cmis.OBJECT_TYPE_FOLDER) {\n\t\t\treturn new Folder(objectInstance, null);\n\t\t}\n\t\tthrow new Error(\"Unsupported CMIS object type: \" + objectInstanceTypeId);\n\t}\n\n\t/**\n\t * Retrieves a CMIS object (Document or Folder) by its path.\n\t * @param path The path of the object in the repository (e.g., \"/path/to/object\").\n\t * @returns A {@link Document} or {@link Folder} instance.\n\t * @throws Error if read access is not allowed or the object type is unsupported.\n\t */\n\tpublic getObjectByPath(path: string): Folder | Document {\n\t\tconst allowed = CmisFacade.isAllowed(path, Cmis.METHOD_READ);\n\t\tif (!allowed) {\n\t\t\tthrow new Error(\"Read access not allowed on: \" + path);\n\t\t}\n\t\tconst objectInstance = this.native.getObjectByPath(path);\n\t\tconst objectInstanceType = objectInstance.getType();\n\t\tconst objectInstanceTypeId = objectInstanceType.getId();\n\t\tif (objectInstanceTypeId === Cmis.OBJECT_TYPE_DOCUMENT) {\n\t\t\treturn new Document(objectInstance, path);\n\t\t} else if (objectInstanceTypeId === Cmis.OBJECT_TYPE_FOLDER) {\n\t\t\treturn new Folder(objectInstance, path);\n\t\t}\n\t\tthrow new Error(\"Unsupported CMIS object type: \" + objectInstanceTypeId);\n\t}\n\n\t/**\n\t * Creates a folder structure recursively based on a path. This is a convenience method that\n\t * creates all non-existent parent folders.\n\t * Example: `createFolder(\"/new/path/structure\")`\n\t * @param location The path of the folder to create.\n\t * @returns The newly created (or existing) innermost {@link Folder} object.\n\t */\n\tpublic createFolder(location: string): Folder {\n\t\tif (location.startsWith(\"/\")) {\n\t\t\tlocation = location.substring(1, location.length);\n\t\t}\n\t\tif (location.endsWith(\"/\")) {\n\t\t\tlocation = location.substring(0, location.length - 1);\n\t\t}\n\t\tconst segments = location.split(\"/\");\n\t\tlet folder = this.getRootFolder();\n\t\tfor (const next of segments) {\n\t\t\tconst properties = {\n\t\t\t\t[Cmis.OBJECT_TYPE_ID]: Cmis.OBJECT_TYPE_FOLDER,\n\t\t\t\t[Cmis.NAME]: next\n\t\t\t};\n\t\t\tfolder = folder.createFolder(properties);\n\t\t}\n\t\treturn folder;\n\t}\n\n\t/**\n\t * Creates a new document at the specified location. This method ensures the parent folder structure exists.\n\t * @param location The path of the parent folder (e.g., \"/path/to/folder\").\n\t * @param properties A map of CMIS properties for the new document (must include {@link Cmis.NAME}).\n\t * @param contentStream The content stream containing the document's binary data.\n\t * @param versioningState The versioning state (e.g., {@link Cmis.VERSIONING_STATE_MAJOR}).\n\t * @returns The newly created {@link Document} object.\n\t */\n\tpublic createDocument(location: string, properties: { [key: string]: any }, contentStream: ContentStream, versioningState: string): Document {\n\t\tconst folder = this.createFolder(location);\n\t\treturn folder.createDocument(properties, contentStream, versioningState);\n\t}\n\n}\n\n/**\n * RepositoryInfo object\n * * Provides basic information about the connected CMIS repository.\n */\nclass RepositoryInfo {\n\n\tprivate readonly native: any;\n\n\tconstructor(native: any) {\n\t\tthis.native = native;\n\t}\n\n\t/**\n\t * Gets the unique identifier of the repository.\n\t * @returns The repository ID.\n\t */\n\tpublic getId(): string {\n\t\treturn this.native.getId();\n\t}\n\n\t/**\n\t * Gets the name of the repository.\n\t * @returns The repository name.\n\t */\n\tpublic getName(): string {\n\t\treturn this.native.getName();\n\t}\n}\n\n/**\n * Folder object\n * * Represents a CMIS folder object, allowing operations like creating children, deleting, and renaming.\n */\nexport class Folder {\n\tprivate readonly native: any;\n\tprivate path: any;\n\n\tconstructor(native: any, path: any) {\n\t\tthis.native = native;\n\t\tthis.path = path;\n\t}\n\n\t/**\n\t * Gets the unique identifier of the folder.\n\t * @returns The folder ID.\n\t */\n\tpublic getId(): string {\n\t\treturn this.native.getId();\n\t}\n\n\t/**\n\t * Gets the name of the folder.\n\t * @returns The folder name.\n\t */\n\tpublic getName(): string {\n\t\treturn this.native.getName();\n\t}\n\n\t/**\n\t * Creates a new folder within this folder.\n\t * @param properties A map of CMIS properties for the new folder (must include {@link Cmis.NAME}).\n\t * @returns The newly created {@link Folder} object.\n\t * @throws Error if write access is not allowed.\n\t */\n\tpublic createFolder(properties: { [key: string]: any }): Folder {\n\t\tvar allowed = CmisFacade.isAllowed(this.getPath(), Cmis.METHOD_WRITE);\n\t\tif (!allowed) {\n\t\t\tthrow new Error(\"Write access not allowed on: \" + this.getPath());\n\t\t}\n\t\tvar mapInstance = new HashMap();\n\t\tfor (var property in properties) {\n\t\t\tif (properties.hasOwnProperty(property)) {\n\t\t\t\tmapInstance.put(property, properties[property]);\n\t\t\t}\n\t\t}\n\t\tvar native = this.native.createFolder(mapInstance);\n\t\tvar folder = new Folder(native, null);\n\t\treturn folder;\n\t}\n\n\t/**\n\t * Creates a new document within this folder.\n\t * @param properties A map of CMIS properties for the new document (must include {@link Cmis.NAME}).\n\t * @param contentStream The content stream containing the document's binary data.\n\t * @param versioningState The versioning state (e.g., {@link Cmis.VERSIONING_STATE_MAJOR}).\n\t * @returns The newly created {@link Document} object.\n\t * @throws Error if write access is not allowed.\n\t */\n\tpublic createDocument(properties: { [key: string]: any }, contentStream: ContentStream, versioningState: string): Document {\n\t\tconst allowed = CmisFacade.isAllowed(this.getPath(), Cmis.METHOD_WRITE);\n\t\tif (!allowed) {\n\t\t\tthrow new Error(\"Write access not allowed on: \" + this.getPath());\n\t\t}\n\t\tconst mapInstance = new HashMap();\n\t\tfor (const property in properties) {\n\t\t\tif (properties.hasOwnProperty(property)) {\n\t\t\t\tmapInstance.put(property, properties[property]);\n\t\t\t}\n\t\t}\n\t\tconst state = CmisFacade.getVersioningState(versioningState);\n\n\t\t// @ts-ignore\n\t\tconst native = this.native.createDocument(mapInstance, contentStream.native, state);\n\t\treturn new Document(native, null);\n\t};\n\n\t/**\n\t * Retrieves the children of this folder.\n\t * @returns A list of generic {@link CmisObject} wrappers for the children.\n\t * @throws Error if read access is not allowed.\n\t */\n\tpublic getChildren(): CmisObject[] {\n\t\tconst allowed = CmisFacade.isAllowed(this.getPath(), Cmis.METHOD_READ);\n\t\tif (!allowed) {\n\t\t\tthrow new Error(\"Read access not allowed on: \" + this.getPath());\n\t\t}\n\t\tconst children = [];\n\t\tconst childrenInstance = this.native.getChildren();\n\t\tconst childrenInstanceIterator = childrenInstance.iterator();\n\t\twhile (childrenInstanceIterator.hasNext()) {\n\t\t\tconst cmisObjectInstance = childrenInstanceIterator.next();\n\t\t\tconst cmisObject = new CmisObject(cmisObjectInstance);\n\t\t\tchildren.push(cmisObject);\n\t\t}\n\t\treturn children;\n\t}\n\n\t/**\n\t * Gets the path of the folder.\n\t * @returns The folder path.\n\t */\n\tpublic getPath(): string {\n\t\treturn this.path;\n\t}\n\n\t/**\n\t * Checks if this folder is the root folder of the repository.\n\t * @returns True if it is the root folder, false otherwise.\n\t */\n\tpublic isRootFolder(): boolean {\n\t\treturn this.native.isRootFolder();\n\t}\n\n\t/**\n\t * Gets the parent folder of this folder.\n\t * @returns The parent {@link Folder} object.\n\t */\n\tpublic getFolderParent(): Folder {\n\t\tconst native = this.native.getFolderParent();\n\t\treturn new Folder(native, null);\n\t};\n\n\t/**\n\t * Deletes this folder (must be empty to succeed).\n\t * @throws Error if write access is not allowed.\n\t */\n\tpublic delete(): void {\n\t\tconst allowed = CmisFacade.isAllowed(this.getPath(), Cmis.METHOD_WRITE);\n\t\tif (!allowed) {\n\t\t\tthrow new Error(\"Write access not allowed on: \" + this.getPath());\n\t\t}\n\t\tthis.native.delete();\n\t};\n\n\t/**\n\t * Renames this folder.\n\t * @param newName The new name for the folder.\n\t * @throws Error if write access is not allowed.\n\t */\n\tpublic rename(newName: string): void {\n\t\tconst allowed = CmisFacade.isAllowed(this.getPath(), Cmis.METHOD_WRITE);\n\t\tif (!allowed) {\n\t\t\tthrow new Error(\"Write access not allowed on: \" + this.getPath());\n\t\t}\n\t\tthis.native.rename(newName);\n\t}\n\n\t/**\n\t * Deletes this folder and all its contents recursively.\n\t * @throws Error if write access is not allowed.\n\t */\n\tpublic deleteTree(): void {\n\t\tconst allowed = CmisFacade.isAllowed(this.getPath(), Cmis.METHOD_WRITE);\n\t\tif (!allowed) {\n\t\t\tthrow new Error(\"Write access not allowed on: \" + this.getPath());\n\t\t}\n\t\tconst unifiedObjectDelete = CmisFacade.getUnifiedObjectDelete();\n\t\tthis.native.deleteTree(true, unifiedObjectDelete, true);\n\t}\n\n\t/**\n\t * Gets the type definition of the folder.\n\t * @returns The folder's {@link TypeDefinition}.\n\t */\n\tpublic getType(): TypeDefinition {\n\t\tconst native = this.native.getType();\n\t\treturn new TypeDefinition(native);\n\t}\n}\n\n/**\n * CmisObject object\n * * A generic wrapper for CMIS objects, used primarily for children lists.\n */\nclass CmisObject {\n\n\tprivate readonly native: any;\n\n\tconstructor(native: any) {\n\t\tthis.native = native;\n\t}\n\n\t/**\n\t * Gets the unique identifier of the object.\n\t * @returns The object ID.\n\t */\n\tpublic getId(): string {\n\t\treturn this.native.getId();\n\t}\n\n\t/**\n\t * Gets the name of the object.\n\t * @returns The object name.\n\t */\n\tpublic getName(): string {\n\t\treturn this.native.getName();\n\t}\n\n\t/**\n\t * Gets the path of the CMIS object. Handles differences in native CMIS implementations.\n\t * @returns The object path.\n\t * @throws Error if the path cannot be determined.\n\t */\n\tpublic getPath(): string {\n\t\t//this is caused by having different underlying native objects in different environments.\n\t\tif (this.native.getPath) {\n\t\t\treturn this.native.getPath();\n\t\t}\n\n\t\t//Apache Chemistry CmisObject has no getPath() but getPaths() - https://chemistry.apache.org/docs/cmis-samples/samples/retrieve-objects/index.html\n\t\tif (this.native.getPaths) {\n\t\t\treturn this.native.getPaths()[0];\n\t\t}\n\n\t\tthrow new Error(`Path not found for CmisObject with id ${this.getId()}`);\n\t}\n\n\t/**\n\t * Gets the type definition of the object.\n\t * @returns The object's {@link TypeDefinition}.\n\t */\n\tpublic getType(): TypeDefinition {\n\t\tconst native = this.native.getType();\n\t\treturn new TypeDefinition(native);\n\t}\n\n\t/**\n\t * Deletes the CMIS object.\n\t */\n\tpublic delete(): void {\n\t\tthis.native.delete();\n\t}\n\n\t/**\n\t * Renames the CMIS object.\n\t * @param newName The new name for the object.\n\t */\n\tpublic rename(newName: string): void {\n\t\tthis.native.rename(newName);\n\t}\n\n}\n\n/**\n * ObjectFactory object\n * * Provides methods to create content streams.\n */\nclass ObjectFactory {\n\n\tprivate readonly native: any;\n\n\tconstructor(native: any) {\n\t\tthis.native = native;\n\t}\n\n\t/**\n\t * Creates a new content stream instance that can be used to create or update document content.\n\t * @param filename The name of the file.\n\t * @param length The size of the content stream in bytes.\n\t * @param mimetype The MIME type of the content.\n\t * @param inputStream The input stream containing the data.\n\t * @returns A new {@link ContentStream} object.\n\t */\n\tpublic createContentStream(filename: string, length: number, mimetype: string, inputStream: streams.InputStream): ContentStream {\n\t\t// @ts-ignore\n\t\tconst native = this.native.createContentStream(filename, length, mimetype, inputStream.native);\n\t\treturn new ContentStream(native);\n\t}\n}\n\n/**\n * ContentStream object\n * * Represents the binary content stream of a CMIS Document.\n */\nclass ContentStream {\n\n\tprivate readonly native: any;\n\n\tconstructor(native: any) {\n\t\tthis.native = native;\n\t}\n\n\t/**\n\t * Gets the Java-backed input stream for reading the content.\n\t * @returns An {@link streams.InputStream} wrapper.\n\t */\n\tpublic getStream(): streams.InputStream {\n\t\tconst native = this.native.getStream();\n\t\treturn new streams.InputStream(native);\n\t}\n\n\t/**\n\t * Gets the MIME type of the content stream.\n\t * @returns The MIME type string.\n\t */\n\tpublic getMimeType(): string {\n\t\treturn this.native.getMimeType();\n\t}\n}\n\n/**\n * Document object\n * * Represents a CMIS document object, allowing operations like reading content, deleting, and renaming.\n */\nexport class Document {\n\n\tprivate readonly native: any;\n\tprivate path: string;\n\n\tconstructor(native: any, path: string) {\n\t\tthis.native = native;\n\t\tthis.path = path;\n\t}\n\n\t/**\n\t * Gets the unique identifier of the document.\n\t * @returns The document ID.\n\t */\n\tpublic getId(): string {\n\t\treturn this.native.getId();\n\t}\n\n\t/**\n\t * Gets the name of the document.\n\t * @returns The document name.\n\t */\n\tpublic getName(): string {\n\t\treturn this.native.getName();\n\t}\n\n\t/**\n\t * Gets the type definition of the document.\n\t * @returns The document's {@link TypeDefinition}.\n\t */\n\tpublic getType(): TypeDefinition {\n\t\tconst native = this.native.getType();\n\t\treturn new TypeDefinition(native);\n\t}\n\n\t/**\n\t * Gets the path of the document.\n\t * @returns The document path.\n\t */\n\tpublic getPath(): string {\n\t\treturn this.path;\n\t}\n\n\t/**\n\t * Deletes this document.\n\t * @throws Error if write access is not allowed.\n\t */\n\tpublic delete(): void {\n\t\tconst allowed = CmisFacade.isAllowed(this.getPath(), Cmis.METHOD_WRITE);\n\t\tif (!allowed) {\n\t\t\tthrow new Error(\"Write access not allowed on: \" + this.getPath());\n\t\t}\n\t\treturn this.native.delete(true);\n\t}\n\n\t/**\n\t * Gets the binary content stream of the document.\n\t * @returns The {@link ContentStream} object, or `null` if the document has no content.\n\t */\n\tpublic getContentStream(): ContentStream | null {\n\t\tconst native = this.native.getContentStream();\n\t\tif (native !== null) {\n\t\t\treturn new ContentStream(native);\n\t\t}\n\t\treturn null;\n\t};\n\n\t/**\n\t * Gets the size of the document's content stream in bytes.\n\t * @returns The size in bytes.\n\t */\n\tpublic getSize(): number {\n\t\treturn this.native.getSize();\n\t}\n\n\t/**\n\t * Renames this document.\n\t * @param newName The new name for the document.\n\t * @throws Error if write access is not allowed.\n\t */\n\tpublic rename(newName: string): void {\n\t\tconst allowed = CmisFacade.isAllowed(this.getPath(), Cmis.METHOD_WRITE);\n\t\tif (!allowed) {\n\t\t\tthrow new Error(\"Write access not allowed on: \" + this.getPath());\n\t\t}\n\t\tthis.native.rename(newName);\n\t}\n}\n\n/**\n * Represents the definition of a CMIS object type (e.g., cmis:document, cmis:folder).\n */\nclass TypeDefinition {\n\n\tprivate readonly native: any;\n\n\tconstructor(native: any) {\n\t\tthis.native = native;\n\t}\n\n\t/**\n\t * Gets the unique ID of the object type (e.g., 'cmis:document').\n\t * @returns The type ID.\n\t */\n\tpublic getId(): string {\n\t\treturn this.native.getId();\n\t}\n}\n\n// @ts-ignore\nif (typeof module !== 'undefined') {\n\t// @ts-ignore\n\tmodule.exports = Cmis;\n}\n"],
  "mappings": "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",
  "names": []
}
