@aerokit/sdk 12.44.0

package/dist/cjs/platform/repository.js

@@ -0,0 +1,498 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var repository_exports = {};
+__export(repository_exports, {
+  Collection: () => Collection,
+  EntityInformation: () => EntityInformation,
+  Repository: () => Repository,
+  Resource: () => Resource
+});
+module.exports = __toCommonJS(repository_exports);
+var import_bytes = require("@aerokit/sdk/io/bytes");
+const RepositoryFacade = Java.type("org.eclipse.dirigible.components.api.platform.RepositoryFacade");
+class Repository {
+  /**
+   * Retrieves a resource (file) object from the repository by its path.
+   *
+   * @param {string} path The absolute path to the resource.
+   * @returns {Resource} A Resource instance wrapping the native repository object.
+   */
+  static getResource(path) {
+    const resourceInstance = RepositoryFacade.getResource(path);
+    return new Resource(resourceInstance);
+  }
+  /**
+   * Creates a new resource (file) with content provided as a string.
+   *
+   * @param {string} path The absolute path where the resource should be created.
+   * @param {string} content The string content for the resource.
+   * @param {string} contentType The MIME type of the content (e.g., "text/plain").
+   * @returns {Resource} The newly created Resource instance.
+   */
+  static createResource(path, content, contentType) {
+    const resourceInstance = RepositoryFacade.createResource(path, content, contentType);
+    return new Resource(resourceInstance);
+  }
+  /**
+   * Creates a new resource (file) with content provided as a native byte array.
+   *
+   * @param {string} path The absolute path where the resource should be created.
+   * @param {any[]} content The native byte array content.
+   * @param {string} contentType The MIME type of the content.
+   * @returns {Resource} The newly created Resource instance.
+   */
+  static createResourceNative(path, content, contentType) {
+    const resourceInstance = RepositoryFacade.createResourceNative(path, content, contentType);
+    return new Resource(resourceInstance);
+  }
+  /**
+   * Updates the content of an existing resource using a string.
+   *
+   * @param {string} path The absolute path to the resource to update.
+   * @param {string} content The new string content.
+   * @returns {Resource} The updated Resource instance.
+   */
+  static updateResource(path, content) {
+    const resourceInstance = RepositoryFacade.updateResource(path, content);
+    return new Resource(resourceInstance);
+  }
+  /**
+   * Updates the content of an existing resource using a native byte array.
+   *
+   * @param {string} path The absolute path to the resource to update.
+   * @param {any[]} content The new native byte array content.
+   * @returns {Resource} The updated Resource instance.
+   */
+  static updateResourceNative(path, content) {
+    const resourceInstance = RepositoryFacade.updateResourceNative(path, content);
+    return new Resource(resourceInstance);
+  }
+  /**
+   * Deletes the resource (file) at the specified path.
+   *
+   * @param {string} path The absolute path of the resource to delete.
+   */
+  static deleteResource(path) {
+    RepositoryFacade.deleteResource(path);
+  }
+  /**
+   * Retrieves a collection (folder) object from the repository by its path.
+   *
+   * @param {string} path The absolute path to the collection.
+   * @returns {Collection} A Collection instance wrapping the native repository object.
+   */
+  static getCollection(path) {
+    const collectionInstance = RepositoryFacade.getCollection(path);
+    return new Collection(collectionInstance);
+  }
+  /**
+   * Creates a new collection (folder) at the specified path.
+   *
+   * @param {string} path The absolute path where the collection should be created.
+   * @returns {Collection} The newly created Collection instance.
+   */
+  static createCollection(path) {
+    const collectionInstance = RepositoryFacade.createCollection(path);
+    return new Collection(collectionInstance);
+  }
+  /**
+   * Deletes the collection (folder) at the specified path.
+   *
+   * @param {string} path The absolute path of the collection to delete.
+   */
+  static deleteCollection(path) {
+    RepositoryFacade.deleteCollection(path);
+  }
+  /**
+   * Searches the repository starting from a given path for resources matching a glob pattern.
+   *
+   * @param {string} path The starting path for the search.
+   * @param {string} pattern The glob pattern to match resource names against (e.g., "*.js").
+   * @returns {string[]} An array of repository paths (strings) that match the search criteria.
+   */
+  static find(path, pattern) {
+    return JSON.parse(RepositoryFacade.find(path, pattern));
+  }
+}
+class Resource {
+  /**
+   * @constructor
+   * @param {any} native The native Java object instance representing the repository resource.
+   */
+  constructor(native) {
+    this.native = native;
+  }
+  /**
+   * Gets the name of the resource (file name).
+   * @returns {string} The name.
+   */
+  getName() {
+    return this.native.getName();
+  }
+  /**
+   * Gets the full repository path of the resource.
+   * @returns {string} The repository path.
+   */
+  getPath() {
+    return this.native.getPath();
+  }
+  /**
+   * Gets the parent collection (folder) of this resource.
+   * @returns {Collection} The parent Collection instance.
+   */
+  getParent() {
+    const collectionInstance = this.native.getParent();
+    return new Collection(collectionInstance);
+  }
+  /**
+   * Gets detailed metadata about the resource.
+   * @returns {EntityInformation} The metadata object.
+   */
+  getInformation() {
+    const informationInstance = this.native.getInformation();
+    return new EntityInformation(informationInstance);
+  }
+  /**
+   * Creates the resource if it does not already exist.
+   */
+  create() {
+    this.native.create();
+  }
+  /**
+   * Deletes the resource from the repository.
+   */
+  delete() {
+    this.native.delete();
+  }
+  /**
+   * Renames the resource within its current collection.
+   * @param {string} name The new name for the resource.
+   */
+  renameTo(name) {
+    this.native.renameTo(name);
+  }
+  /**
+   * Moves the resource to a new path.
+   * @param {string} path The new absolute path for the resource.
+   */
+  moveTo(path) {
+    this.native.moveTo(path);
+  }
+  /**
+   * Copies the resource to a new path.
+   * @param {string} path The new absolute path for the copied resource.
+   */
+  copyTo(path) {
+    this.native.copyTo(path);
+  }
+  /**
+   * Checks if the resource currently exists in the repository.
+   * @returns {boolean} True if the resource exists, false otherwise.
+   */
+  exists() {
+    return this.native.exists();
+  }
+  /**
+   * Checks if the resource (file) is empty (has zero size).
+   * @returns {boolean} True if the content is empty, false otherwise.
+   */
+  isEmpty() {
+    return this.native.isEmpty();
+  }
+  /**
+   * Gets the content of the resource as a text string.
+   * @returns {string} The text content.
+   */
+  getText() {
+    return import_bytes.Bytes.byteArrayToText(this.getContent());
+  }
+  /**
+   * Gets the content of the resource as a JavaScript-friendly byte array.
+   * @returns {any[]} The content bytes.
+   */
+  getContent() {
+    const nativeContent = this.native.getContent();
+    return import_bytes.Bytes.toJavaScriptBytes(nativeContent);
+  }
+  /**
+   * Gets the content of the resource as its native Java byte array representation.
+   * @returns {any[]} The content bytes.
+   */
+  getContentNative() {
+    return this.native.getContent();
+  }
+  /**
+   * Sets the content of the resource using a text string.
+   * The string is converted to a byte array before saving.
+   * @param {string} text The new text content.
+   */
+  setText(text) {
+    const content = import_bytes.Bytes.textToByteArray(text);
+    this.setContent(content);
+  }
+  /**
+   * Sets the content of the resource using a JavaScript byte array.
+   * The array is converted to a native byte array before saving.
+   * @param {any[]} content The new content bytes.
+   */
+  setContent(content) {
+    const nativeContent = import_bytes.Bytes.toJavaBytes(content);
+    this.native.setContent(nativeContent);
+  }
+  /**
+   * Sets the content of the resource using a native Java byte array.
+   * @param {any[]} content The new native content bytes.
+   */
+  setContentNative(content) {
+    this.native.setContent(content);
+  }
+  /**
+   * Checks if the resource content is determined to be binary.
+   * @returns {boolean} True if binary, false if text.
+   */
+  isBinary() {
+    return this.native.isBinary();
+  }
+  /**
+   * Gets the content type (MIME type) of the resource.
+   * @returns {string} The content type string.
+   */
+  getContentType() {
+    return this.native.getContentType();
+  }
+}
+class Collection {
+  /**
+   * @constructor
+   * @param {any} native The native Java object instance representing the repository collection.
+   */
+  constructor(native) {
+    this.native = native;
+  }
+  /**
+   * Gets the name of the collection (folder name).
+   * @returns {string} The name.
+   */
+  getName() {
+    return this.native.getName();
+  }
+  /**
+   * Gets the full repository path of the collection.
+   * @returns {string} The repository path.
+   */
+  getPath() {
+    return this.native.getPath();
+  }
+  /**
+   * Gets the parent collection (folder) of this collection.
+   * @returns {Collection} The parent Collection instance.
+   */
+  getParent() {
+    const collectionInstance = this.native.getParent();
+    return new Collection(collectionInstance);
+  }
+  /**
+   * Gets detailed metadata about the collection.
+   * @returns {EntityInformation} The metadata object.
+   */
+  getInformation() {
+    const informationInstance = this.native.getInformation();
+    return new EntityInformation(informationInstance);
+  }
+  /**
+   * Creates the collection if it does not already exist.
+   */
+  create() {
+    this.native.create();
+  }
+  /**
+   * Deletes the collection from the repository.
+   */
+  delete() {
+    this.native.delete();
+  }
+  /**
+   * Renames the collection within its current parent.
+   * @param {string} name The new name for the collection.
+   */
+  renameTo(name) {
+    this.native.renameTo(name);
+  }
+  /**
+   * Moves the collection to a new path.
+   * @param {string} path The new absolute path for the collection.
+   */
+  moveTo(path) {
+    this.native.moveTo(path);
+  }
+  /**
+   * Copies the collection to a new path.
+   * @param {string} path The new absolute path for the copied collection.
+   */
+  copyTo(path) {
+    this.native.copyTo(path);
+  }
+  /**
+   * Checks if the collection currently exists in the repository.
+   * @returns {boolean} True if the collection exists, false otherwise.
+   */
+  exists() {
+    return this.native.exists();
+  }
+  /**
+   * Checks if the collection is empty (contains no files or sub-directories).
+   * @returns {boolean} True if empty, false otherwise.
+   */
+  isEmpty() {
+    return this.native.isEmpty();
+  }
+  /**
+   * Gets the names of all sub-collections (folders) within this collection.
+   * @returns {string[]} An array of sub-collection names.
+   */
+  getCollectionsNames() {
+    return this.native.getCollectionsNames();
+  }
+  /**
+   * Creates a new sub-collection (folder) within this collection.
+   * @param {string} name The name of the new sub-collection.
+   * @returns {Collection} The newly created Collection instance.
+   */
+  createCollection(name) {
+    const collectionInstance = this.native.createCollection(name);
+    return new Collection(collectionInstance);
+  }
+  /**
+   * Gets a specific sub-collection by name.
+   * @param {string} name The name of the sub-collection.
+   * @returns {Collection} The child Collection instance.
+   */
+  getCollection(name) {
+    const collectionInstance = this.native.getCollection(name);
+    return new Collection(collectionInstance);
+  }
+  /**
+   * Removes a sub-collection by name.
+   * @param {string} name The name of the sub-collection to remove.
+   */
+  removeCollection(name) {
+    this.native.removeCollection(name);
+  }
+  /**
+   * Gets the names of all resources (files) within this collection.
+   * @returns {string[]} An array of resource names.
+   */
+  getResourcesNames() {
+    return this.native.getResourcesNames();
+  }
+  /**
+   * Gets a specific resource (file) by name.
+   * @param {string} name The name of the resource.
+   * @returns {Resource} The child Resource instance.
+   */
+  getResource(name) {
+    const resourceInstance = this.native.getResource(name);
+    return new Resource(resourceInstance);
+  }
+  /**
+   * Removes a resource (file) by name.
+   * @param {string} name The name of the resource to remove.
+   */
+  removeResource(name) {
+    this.native.removeResource(name);
+  }
+  /**
+   * Creates a new resource (file) within this collection.
+   * @param {string} name The name of the new resource.
+   * @param {string} content The string content for the resource.
+   * @returns {Resource} The newly created Resource instance.
+   */
+  createResource(name, content) {
+    const resourceInstance = this.native.createResource(name, content);
+    return new Resource(resourceInstance);
+  }
+}
+class EntityInformation {
+  /**
+   * @constructor
+   * @param {any} native The native Java object instance holding the entity information.
+   */
+  constructor(native) {
+    this.native = native;
+  }
+  /**
+   * Gets the name of the entity (resource or collection).
+   * @returns {string} The name.
+   */
+  getName() {
+    return this.native.getName();
+  }
+  /**
+   * Gets the full repository path of the entity.
+   * @returns {string} The repository path.
+   */
+  getPath() {
+    return this.native.getPath();
+  }
+  /**
+   * Gets the access permissions for the entity (typically an integer bitmask).
+   * @returns {number} The permissions value.
+   */
+  getPermissions() {
+    return this.native.getPermissions();
+  }
+  /**
+   * Gets the size of the resource content in bytes (0 for a collection).
+   * @returns {number} The size in bytes.
+   */
+  getSize() {
+    return this.native.getSize();
+  }
+  /**
+   * Gets the user who created the entity.
+   * @returns {string} The creator's name.
+   */
+  getCreatedBy() {
+    return this.native.getCreatedBy();
+  }
+  /**
+   * Gets the creation timestamp.
+   * @returns {Date} The creation date and time.
+   */
+  getCreatedAt() {
+    return this.native.getCreatedAt();
+  }
+  /**
+   * Gets the user who last modified the entity.
+   * @returns {string} The modifier's name.
+   */
+  getModifiedBy() {
+    return this.native.getModifiedBy();
+  }
+  /**
+   * Gets the last modification timestamp.
+   * @returns {Date} The modification date and time.
+   */
+  getModifiedAt() {
+    return this.native.getModifiedAt();
+  }
+}
+if (typeof module !== "undefined") {
+  module.exports = Repository;
+}
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/platform/repository.ts"],
  "sourcesContent": ["/**\n * Provides a wrapper for the platform's RepositoryFacade to manage files (Resources)\n * and folders (Collections), including CRUD operations, movement, and content handling.\n */\nimport { Bytes } from \"@aerokit/sdk/io/bytes\";\n\nconst RepositoryFacade = Java.type(\"org.eclipse.dirigible.components.api.platform.RepositoryFacade\");\n\n/**\n * @class Repository\n * @description Static utility class providing high-level methods for interacting with the\n * repository facade to manage resources and collections by path.\n */\nexport class Repository {\n\n\t/**\n\t * Retrieves a resource (file) object from the repository by its path.\n\t *\n\t * @param {string} path The absolute path to the resource.\n\t * @returns {Resource} A Resource instance wrapping the native repository object.\n\t */\n\tpublic static getResource(path: string): Resource {\n\t\tconst resourceInstance = RepositoryFacade.getResource(path);\n\t\treturn new Resource(resourceInstance);\n\t}\n\n\t/**\n\t * Creates a new resource (file) with content provided as a string.\n\t *\n\t * @param {string} path The absolute path where the resource should be created.\n\t * @param {string} content The string content for the resource.\n\t * @param {string} contentType The MIME type of the content (e.g., \"text/plain\").\n\t * @returns {Resource} The newly created Resource instance.\n\t */\n\tpublic static createResource(path: string, content: string, contentType: string): Resource {\n\t\tconst resourceInstance = RepositoryFacade.createResource(path, content, contentType);\n\t\treturn new Resource(resourceInstance);\n\t}\n\n\t/**\n\t * Creates a new resource (file) with content provided as a native byte array.\n\t *\n\t * @param {string} path The absolute path where the resource should be created.\n\t * @param {any[]} content The native byte array content.\n\t * @param {string} contentType The MIME type of the content.\n\t * @returns {Resource} The newly created Resource instance.\n\t */\n\tpublic static createResourceNative(path: string, content: any[], contentType: string): Resource {\n\t\tconst resourceInstance = RepositoryFacade.createResourceNative(path, content, contentType);\n\t\treturn new Resource(resourceInstance);\n\t}\n\n\t/**\n\t * Updates the content of an existing resource using a string.\n\t *\n\t * @param {string} path The absolute path to the resource to update.\n\t * @param {string} content The new string content.\n\t * @returns {Resource} The updated Resource instance.\n\t */\n\tpublic static updateResource(path: string, content: string): Resource {\n\t\tconst resourceInstance = RepositoryFacade.updateResource(path, content);\n\t\treturn new Resource(resourceInstance);\n\t}\n\n\t/**\n\t * Updates the content of an existing resource using a native byte array.\n\t *\n\t * @param {string} path The absolute path to the resource to update.\n\t * @param {any[]} content The new native byte array content.\n\t * @returns {Resource} The updated Resource instance.\n\t */\n\tpublic static updateResourceNative(path: string, content: any[]): Resource {\n\t\tconst resourceInstance = RepositoryFacade.updateResourceNative(path, content);\n\t\treturn new Resource(resourceInstance);\n\t}\n\n\t/**\n\t * Deletes the resource (file) at the specified path.\n\t *\n\t * @param {string} path The absolute path of the resource to delete.\n\t */\n\tpublic static deleteResource(path: string): void {\n\t\tRepositoryFacade.deleteResource(path);\n\t}\n\n\t/**\n\t * Retrieves a collection (folder) object from the repository by its path.\n\t *\n\t * @param {string} path The absolute path to the collection.\n\t * @returns {Collection} A Collection instance wrapping the native repository object.\n\t */\n\tpublic static getCollection(path: string): Collection {\n\t\tconst collectionInstance = RepositoryFacade.getCollection(path);\n\t\treturn new Collection(collectionInstance);\n\t}\n\n\t/**\n\t * Creates a new collection (folder) at the specified path.\n\t *\n\t * @param {string} path The absolute path where the collection should be created.\n\t * @returns {Collection} The newly created Collection instance.\n\t */\n\tpublic static createCollection(path: string): Collection {\n\t\tconst collectionInstance = RepositoryFacade.createCollection(path);\n\t\treturn new Collection(collectionInstance);\n\t}\n\n\t/**\n\t * Deletes the collection (folder) at the specified path.\n\t *\n\t * @param {string} path The absolute path of the collection to delete.\n\t */\n\tpublic static deleteCollection(path: string): void {\n\t\tRepositoryFacade.deleteCollection(path);\n\t}\n\n\t/**\n\t * Searches the repository starting from a given path for resources matching a glob pattern.\n\t *\n\t * @param {string} path The starting path for the search.\n\t * @param {string} pattern The glob pattern to match resource names against (e.g., \"*.js\").\n\t * @returns {string[]} An array of repository paths (strings) that match the search criteria.\n\t */\n\tpublic static find(path: string, pattern: string): string[] {\n\t\treturn JSON.parse(RepositoryFacade.find(path, pattern));\n\t}\n}\n\n/**\n * @class Resource\n * @description Represents a file or resource (non-collection) within the Repository,\n * providing instance methods for file operations.\n */\nexport class Resource {\n\tprivate readonly native: any;\n\n\t/**\n\t * @constructor\n\t * @param {any} native The native Java object instance representing the repository resource.\n\t */\n\tconstructor(native: any) {\n\t\tthis.native = native;\n\t}\n\n\t/**\n\t * Gets the name of the resource (file name).\n\t * @returns {string} The name.\n\t */\n\tpublic getName(): string {\n\t\treturn this.native.getName();\n\t}\n\n\t/**\n\t * Gets the full repository path of the resource.\n\t * @returns {string} The repository path.\n\t */\n\tpublic getPath(): string {\n\t\treturn this.native.getPath();\n\t}\n\n\t/**\n\t * Gets the parent collection (folder) of this resource.\n\t * @returns {Collection} The parent Collection instance.\n\t */\n\tpublic getParent(): Collection {\n\t\tconst collectionInstance = this.native.getParent();\n\t\treturn new Collection(collectionInstance);\n\t}\n\n\t/**\n\t * Gets detailed metadata about the resource.\n\t * @returns {EntityInformation} The metadata object.\n\t */\n\tpublic getInformation(): EntityInformation {\n\t\tconst informationInstance = this.native.getInformation();\n\t\treturn new EntityInformation(informationInstance);\n\t}\n\n\t/**\n\t * Creates the resource if it does not already exist.\n\t */\n\tpublic create(): void {\n\t\tthis.native.create();\n\t}\n\n\t/**\n\t * Deletes the resource from the repository.\n\t */\n\tpublic delete(): void {\n\t\tthis.native.delete();\n\t}\n\n\t/**\n\t * Renames the resource within its current collection.\n\t * @param {string} name The new name for the resource.\n\t */\n\tpublic renameTo(name: string): void {\n\t\tthis.native.renameTo(name);\n\t}\n\n\t/**\n\t * Moves the resource to a new path.\n\t * @param {string} path The new absolute path for the resource.\n\t */\n\tpublic moveTo(path: string): void {\n\t\tthis.native.moveTo(path);\n\t}\n\n\t/**\n\t * Copies the resource to a new path.\n\t * @param {string} path The new absolute path for the copied resource.\n\t */\n\tpublic copyTo(path: string): void {\n\t\tthis.native.copyTo(path);\n\t}\n\n\t/**\n\t * Checks if the resource currently exists in the repository.\n\t * @returns {boolean} True if the resource exists, false otherwise.\n\t */\n\tpublic exists(): boolean {\n\t\treturn this.native.exists();\n\t}\n\n\t/**\n\t * Checks if the resource (file) is empty (has zero size).\n\t * @returns {boolean} True if the content is empty, false otherwise.\n\t */\n\tpublic isEmpty(): boolean {\n\t\treturn this.native.isEmpty();\n\t}\n\n\t/**\n\t * Gets the content of the resource as a text string.\n\t * @returns {string} The text content.\n\t */\n\tpublic getText(): string {\n\t\treturn Bytes.byteArrayToText(this.getContent());\n\t}\n\n\t/**\n\t * Gets the content of the resource as a JavaScript-friendly byte array.\n\t * @returns {any[]} The content bytes.\n\t */\n\tpublic getContent(): any[] {\n\t\tconst nativeContent = this.native.getContent();\n\t\treturn Bytes.toJavaScriptBytes(nativeContent);\n\t}\n\n\t/**\n\t * Gets the content of the resource as its native Java byte array representation.\n\t * @returns {any[]} The content bytes.\n\t */\n\tpublic getContentNative(): any[] {\n\t\treturn this.native.getContent();\n\t}\n\n\t/**\n\t * Sets the content of the resource using a text string.\n\t * The string is converted to a byte array before saving.\n\t * @param {string} text The new text content.\n\t */\n\tpublic setText(text: string): void {\n\t\tconst content = Bytes.textToByteArray(text);\n\t\tthis.setContent(content);\n\t}\n\n\t/**\n\t * Sets the content of the resource using a JavaScript byte array.\n\t * The array is converted to a native byte array before saving.\n\t * @param {any[]} content The new content bytes.\n\t */\n\tpublic setContent(content: any[]): void {\n\t\tconst nativeContent = Bytes.toJavaBytes(content);\n\t\tthis.native.setContent(nativeContent);\n\t}\n\n\t/**\n\t * Sets the content of the resource using a native Java byte array.\n\t * @param {any[]} content The new native content bytes.\n\t */\n\tpublic setContentNative(content: any[]): void {\n\t\tthis.native.setContent(content);\n\t}\n\n\t/**\n\t * Checks if the resource content is determined to be binary.\n\t * @returns {boolean} True if binary, false if text.\n\t */\n\tpublic isBinary(): boolean {\n\t\treturn this.native.isBinary();\n\t}\n\n\t/**\n\t * Gets the content type (MIME type) of the resource.\n\t * @returns {string} The content type string.\n\t */\n\tpublic getContentType(): string {\n\t\treturn this.native.getContentType();\n\t}\n}\n\n/**\n * @class Collection\n * @description Represents a directory or folder within the Repository, providing\n * instance methods for collection and resource management.\n */\nexport class Collection {\n\tprivate readonly native: any;\n\n\t/**\n\t * @constructor\n\t * @param {any} native The native Java object instance representing the repository collection.\n\t */\n\tconstructor(native: any) {\n\t\tthis.native = native;\n\t}\n\n\t/**\n\t * Gets the name of the collection (folder name).\n\t * @returns {string} The name.\n\t */\n\tpublic getName(): string {\n\t\treturn this.native.getName();\n\t}\n\n\t/**\n\t * Gets the full repository path of the collection.\n\t * @returns {string} The repository path.\n\t */\n\tpublic getPath(): string {\n\t\treturn this.native.getPath();\n\t}\n\n\t/**\n\t * Gets the parent collection (folder) of this collection.\n\t * @returns {Collection} The parent Collection instance.\n\t */\n\tpublic getParent(): Collection {\n\t\tconst collectionInstance = this.native.getParent();\n\t\treturn new Collection(collectionInstance);\n\t}\n\n\t/**\n\t * Gets detailed metadata about the collection.\n\t * @returns {EntityInformation} The metadata object.\n\t */\n\tpublic getInformation(): EntityInformation {\n\t\tconst informationInstance = this.native.getInformation();\n\t\treturn new EntityInformation(informationInstance);\n\t}\n\n\t/**\n\t * Creates the collection if it does not already exist.\n\t */\n\tpublic create(): void {\n\t\tthis.native.create();\n\t}\n\n\t/**\n\t * Deletes the collection from the repository.\n\t */\n\tpublic delete(): void {\n\t\tthis.native.delete();\n\t}\n\n\t/**\n\t * Renames the collection within its current parent.\n\t * @param {string} name The new name for the collection.\n\t */\n\tpublic renameTo(name: string): void {\n\t\tthis.native.renameTo(name);\n\t}\n\n\t/**\n\t * Moves the collection to a new path.\n\t * @param {string} path The new absolute path for the collection.\n\t */\n\tpublic moveTo(path: string): void {\n\t\tthis.native.moveTo(path);\n\t}\n\n\t/**\n\t * Copies the collection to a new path.\n\t * @param {string} path The new absolute path for the copied collection.\n\t */\n\tpublic copyTo(path: string): void {\n\t\tthis.native.copyTo(path);\n\t}\n\n\t/**\n\t * Checks if the collection currently exists in the repository.\n\t * @returns {boolean} True if the collection exists, false otherwise.\n\t */\n\tpublic exists(): boolean {\n\t\treturn this.native.exists();\n\t}\n\n\t/**\n\t * Checks if the collection is empty (contains no files or sub-directories).\n\t * @returns {boolean} True if empty, false otherwise.\n\t */\n\tpublic isEmpty(): boolean {\n\t\treturn this.native.isEmpty();\n\t}\n\n\t/**\n\t * Gets the names of all sub-collections (folders) within this collection.\n\t * @returns {string[]} An array of sub-collection names.\n\t */\n\tpublic getCollectionsNames(): string[] {\n\t\treturn this.native.getCollectionsNames();\n\t}\n\n\t/**\n\t * Creates a new sub-collection (folder) within this collection.\n\t * @param {string} name The name of the new sub-collection.\n\t * @returns {Collection} The newly created Collection instance.\n\t */\n\tpublic createCollection(name: string): Collection {\n\t\tconst collectionInstance = this.native.createCollection(name);\n\t\treturn new Collection(collectionInstance);\n\t}\n\n\t/**\n\t * Gets a specific sub-collection by name.\n\t * @param {string} name The name of the sub-collection.\n\t * @returns {Collection} The child Collection instance.\n\t */\n\tpublic getCollection(name: string): Collection {\n\t\tconst collectionInstance = this.native.getCollection(name);\n\t\treturn new Collection(collectionInstance);\n\t}\n\n\t/**\n\t * Removes a sub-collection by name.\n\t * @param {string} name The name of the sub-collection to remove.\n\t */\n\tpublic removeCollection(name: string): void {\n\t\tthis.native.removeCollection(name);\n\t}\n\n\t/**\n\t * Gets the names of all resources (files) within this collection.\n\t * @returns {string[]} An array of resource names.\n\t */\n\tpublic getResourcesNames(): string[] {\n\t\treturn this.native.getResourcesNames();\n\t}\n\n\t/**\n\t * Gets a specific resource (file) by name.\n\t * @param {string} name The name of the resource.\n\t * @returns {Resource} The child Resource instance.\n\t */\n\tpublic getResource(name: string): Resource {\n\t\tconst resourceInstance = this.native.getResource(name);\n\t\treturn new Resource(resourceInstance);\n\t}\n\n\t/**\n\t * Removes a resource (file) by name.\n\t * @param {string} name The name of the resource to remove.\n\t */\n\tpublic removeResource(name: string): void {\n\t\tthis.native.removeResource(name);\n\t}\n\n\t/**\n\t * Creates a new resource (file) within this collection.\n\t * @param {string} name The name of the new resource.\n\t * @param {string} content The string content for the resource.\n\t * @returns {Resource} The newly created Resource instance.\n\t */\n\tpublic createResource(name: string, content: string): Resource {\n\t\tconst resourceInstance = this.native.createResource(name, content);\n\t\treturn new Resource(resourceInstance);\n\t}\n}\n\n/**\n * @class EntityInformation\n * @description Represents detailed metadata (creation date, size, permissions, etc.) for a\n * Resource or Collection.\n */\nexport class EntityInformation {\n\tprivate readonly native: any;\n\n\t/**\n\t * @constructor\n\t * @param {any} native The native Java object instance holding the entity information.\n\t */\n\tconstructor(native: any) {\n\t\tthis.native = native;\n\t}\n\n\t/**\n\t * Gets the name of the entity (resource or collection).\n\t * @returns {string} The name.\n\t */\n\tpublic getName(): string {\n\t\treturn this.native.getName();\n\t}\n\n\t/**\n\t * Gets the full repository path of the entity.\n\t * @returns {string} The repository path.\n\t */\n\tpublic getPath(): string {\n\t\treturn this.native.getPath();\n\t}\n\n\t/**\n\t * Gets the access permissions for the entity (typically an integer bitmask).\n\t * @returns {number} The permissions value.\n\t */\n\tpublic getPermissions(): number {\n\t\treturn this.native.getPermissions();\n\t}\n\n\t/**\n\t * Gets the size of the resource content in bytes (0 for a collection).\n\t * @returns {number} The size in bytes.\n\t */\n\tpublic getSize(): number {\n\t\treturn this.native.getSize();\n\t}\n\n\t/**\n\t * Gets the user who created the entity.\n\t * @returns {string} The creator's name.\n\t */\n\tpublic getCreatedBy(): string {\n\t\treturn this.native.getCreatedBy();\n\t}\n\n\t/**\n\t * Gets the creation timestamp.\n\t * @returns {Date} The creation date and time.\n\t */\n\tpublic getCreatedAt(): Date {\n\t\treturn this.native.getCreatedAt();\n\t}\n\n\t/**\n\t * Gets the user who last modified the entity.\n\t * @returns {string} The modifier's name.\n\t */\n\tpublic getModifiedBy(): string {\n\t\treturn this.native.getModifiedBy();\n\t}\n\n\t/**\n\t * Gets the last modification timestamp.\n\t * @returns {Date} The modification date and time.\n\t */\n\tpublic getModifiedAt(): Date {\n\t\treturn this.native.getModifiedAt();\n\t}\n}\n\n// @ts-ignore\nif (typeof module !== 'undefined') {\n\t// @ts-ignore\n\tmodule.exports = Repository;\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAIA,mBAAsB;AAEtB,MAAM,mBAAmB,KAAK,KAAK,gEAAgE;AAO5F,MAAM,WAAW;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQvB,OAAc,YAAY,MAAwB;AACjD,UAAM,mBAAmB,iBAAiB,YAAY,IAAI;AAC1D,WAAO,IAAI,SAAS,gBAAgB;AAAA,EACrC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAUA,OAAc,eAAe,MAAc,SAAiB,aAA+B;AAC1F,UAAM,mBAAmB,iBAAiB,eAAe,MAAM,SAAS,WAAW;AACnF,WAAO,IAAI,SAAS,gBAAgB;AAAA,EACrC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAUA,OAAc,qBAAqB,MAAc,SAAgB,aAA+B;AAC/F,UAAM,mBAAmB,iBAAiB,qBAAqB,MAAM,SAAS,WAAW;AACzF,WAAO,IAAI,SAAS,gBAAgB;AAAA,EACrC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASA,OAAc,eAAe,MAAc,SAA2B;AACrE,UAAM,mBAAmB,iBAAiB,eAAe,MAAM,OAAO;AACtE,WAAO,IAAI,SAAS,gBAAgB;AAAA,EACrC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASA,OAAc,qBAAqB,MAAc,SAA0B;AAC1E,UAAM,mBAAmB,iBAAiB,qBAAqB,MAAM,OAAO;AAC5E,WAAO,IAAI,SAAS,gBAAgB;AAAA,EACrC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,OAAc,eAAe,MAAoB;AAChD,qBAAiB,eAAe,IAAI;AAAA,EACrC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,OAAc,cAAc,MAA0B;AACrD,UAAM,qBAAqB,iBAAiB,cAAc,IAAI;AAC9D,WAAO,IAAI,WAAW,kBAAkB;AAAA,EACzC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,OAAc,iBAAiB,MAA0B;AACxD,UAAM,qBAAqB,iBAAiB,iBAAiB,IAAI;AACjE,WAAO,IAAI,WAAW,kBAAkB;AAAA,EACzC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,OAAc,iBAAiB,MAAoB;AAClD,qBAAiB,iBAAiB,IAAI;AAAA,EACvC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASA,OAAc,KAAK,MAAc,SAA2B;AAC3D,WAAO,KAAK,MAAM,iBAAiB,KAAK,MAAM,OAAO,CAAC;AAAA,EACvD;AACD;AAOO,MAAM,SAAS;AAAA;AAAA;AAAA;AAAA;AAAA,EAOrB,YAAY,QAAa;AACxB,SAAK,SAAS;AAAA,EACf;AAAA;AAAA;AAAA;AAAA;AAAA,EAMO,UAAkB;AACxB,WAAO,KAAK,OAAO,QAAQ;AAAA,EAC5B;AAAA;AAAA;AAAA;AAAA;AAAA,EAMO,UAAkB;AACxB,WAAO,KAAK,OAAO,QAAQ;AAAA,EAC5B;AAAA;AAAA;AAAA;AAAA;AAAA,EAMO,YAAwB;AAC9B,UAAM,qBAAqB,KAAK,OAAO,UAAU;AACjD,WAAO,IAAI,WAAW,kBAAkB;AAAA,EACzC;AAAA;AAAA;AAAA;AAAA;AAAA,EAMO,iBAAoC;AAC1C,UAAM,sBAAsB,KAAK,OAAO,eAAe;AACvD,WAAO,IAAI,kBAAkB,mBAAmB;AAAA,EACjD;AAAA;AAAA;AAAA;AAAA,EAKO,SAAe;AACrB,SAAK,OAAO,OAAO;AAAA,EACpB;AAAA;AAAA;AAAA;AAAA,EAKO,SAAe;AACrB,SAAK,OAAO,OAAO;AAAA,EACpB;AAAA;AAAA;AAAA;AAAA;AAAA,EAMO,SAAS,MAAoB;AACnC,SAAK,OAAO,SAAS,IAAI;AAAA,EAC1B;AAAA;AAAA;AAAA;AAAA;AAAA,EAMO,OAAO,MAAoB;AACjC,SAAK,OAAO,OAAO,IAAI;AAAA,EACxB;AAAA;AAAA;AAAA;AAAA;AAAA,EAMO,OAAO,MAAoB;AACjC,SAAK,OAAO,OAAO,IAAI;AAAA,EACxB;AAAA;AAAA;AAAA;AAAA;AAAA,EAMO,SAAkB;AACxB,WAAO,KAAK,OAAO,OAAO;AAAA,EAC3B;AAAA;AAAA;AAAA;AAAA;AAAA,EAMO,UAAmB;AACzB,WAAO,KAAK,OAAO,QAAQ;AAAA,EAC5B;AAAA;AAAA;AAAA;AAAA;AAAA,EAMO,UAAkB;AACxB,WAAO,mBAAM,gBAAgB,KAAK,WAAW,CAAC;AAAA,EAC/C;AAAA;AAAA;AAAA;AAAA;AAAA,EAMO,aAAoB;AAC1B,UAAM,gBAAgB,KAAK,OAAO,WAAW;AAC7C,WAAO,mBAAM,kBAAkB,aAAa;AAAA,EAC7C;AAAA;AAAA;AAAA;AAAA;AAAA,EAMO,mBAA0B;AAChC,WAAO,KAAK,OAAO,WAAW;AAAA,EAC/B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOO,QAAQ,MAAoB;AAClC,UAAM,UAAU,mBAAM,gBAAgB,IAAI;AAC1C,SAAK,WAAW,OAAO;AAAA,EACxB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOO,WAAW,SAAsB;AACvC,UAAM,gBAAgB,mBAAM,YAAY,OAAO;AAC/C,SAAK,OAAO,WAAW,aAAa;AAAA,EACrC;AAAA;AAAA;AAAA;AAAA;AAAA,EAMO,iBAAiB,SAAsB;AAC7C,SAAK,OAAO,WAAW,OAAO;AAAA,EAC/B;AAAA;AAAA;AAAA;AAAA;AAAA,EAMO,WAAoB;AAC1B,WAAO,KAAK,OAAO,SAAS;AAAA,EAC7B;AAAA;AAAA;AAAA;AAAA;AAAA,EAMO,iBAAyB;AAC/B,WAAO,KAAK,OAAO,eAAe;AAAA,EACnC;AACD;AAOO,MAAM,WAAW;AAAA;AAAA;AAAA;AAAA;AAAA,EAOvB,YAAY,QAAa;AACxB,SAAK,SAAS;AAAA,EACf;AAAA;AAAA;AAAA;AAAA;AAAA,EAMO,UAAkB;AACxB,WAAO,KAAK,OAAO,QAAQ;AAAA,EAC5B;AAAA;AAAA;AAAA;AAAA;AAAA,EAMO,UAAkB;AACxB,WAAO,KAAK,OAAO,QAAQ;AAAA,EAC5B;AAAA;AAAA;AAAA;AAAA;AAAA,EAMO,YAAwB;AAC9B,UAAM,qBAAqB,KAAK,OAAO,UAAU;AACjD,WAAO,IAAI,WAAW,kBAAkB;AAAA,EACzC;AAAA;AAAA;AAAA;AAAA;AAAA,EAMO,iBAAoC;AAC1C,UAAM,sBAAsB,KAAK,OAAO,eAAe;AACvD,WAAO,IAAI,kBAAkB,mBAAmB;AAAA,EACjD;AAAA;AAAA;AAAA;AAAA,EAKO,SAAe;AACrB,SAAK,OAAO,OAAO;AAAA,EACpB;AAAA;AAAA;AAAA;AAAA,EAKO,SAAe;AACrB,SAAK,OAAO,OAAO;AAAA,EACpB;AAAA;AAAA;AAAA;AAAA;AAAA,EAMO,SAAS,MAAoB;AACnC,SAAK,OAAO,SAAS,IAAI;AAAA,EAC1B;AAAA;AAAA;AAAA;AAAA;AAAA,EAMO,OAAO,MAAoB;AACjC,SAAK,OAAO,OAAO,IAAI;AAAA,EACxB;AAAA;AAAA;AAAA;AAAA;AAAA,EAMO,OAAO,MAAoB;AACjC,SAAK,OAAO,OAAO,IAAI;AAAA,EACxB;AAAA;AAAA;AAAA;AAAA;AAAA,EAMO,SAAkB;AACxB,WAAO,KAAK,OAAO,OAAO;AAAA,EAC3B;AAAA;AAAA;AAAA;AAAA;AAAA,EAMO,UAAmB;AACzB,WAAO,KAAK,OAAO,QAAQ;AAAA,EAC5B;AAAA;AAAA;AAAA;AAAA;AAAA,EAMO,sBAAgC;AACtC,WAAO,KAAK,OAAO,oBAAoB;AAAA,EACxC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOO,iBAAiB,MAA0B;AACjD,UAAM,qBAAqB,KAAK,OAAO,iBAAiB,IAAI;AAC5D,WAAO,IAAI,WAAW,kBAAkB;AAAA,EACzC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOO,cAAc,MAA0B;AAC9C,UAAM,qBAAqB,KAAK,OAAO,cAAc,IAAI;AACzD,WAAO,IAAI,WAAW,kBAAkB;AAAA,EACzC;AAAA;AAAA;AAAA;AAAA;AAAA,EAMO,iBAAiB,MAAoB;AAC3C,SAAK,OAAO,iBAAiB,IAAI;AAAA,EAClC;AAAA;AAAA;AAAA;AAAA;AAAA,EAMO,oBAA8B;AACpC,WAAO,KAAK,OAAO,kBAAkB;AAAA,EACtC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOO,YAAY,MAAwB;AAC1C,UAAM,mBAAmB,KAAK,OAAO,YAAY,IAAI;AACrD,WAAO,IAAI,SAAS,gBAAgB;AAAA,EACrC;AAAA;AAAA;AAAA;AAAA;AAAA,EAMO,eAAe,MAAoB;AACzC,SAAK,OAAO,eAAe,IAAI;AAAA,EAChC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQO,eAAe,MAAc,SAA2B;AAC9D,UAAM,mBAAmB,KAAK,OAAO,eAAe,MAAM,OAAO;AACjE,WAAO,IAAI,SAAS,gBAAgB;AAAA,EACrC;AACD;AAOO,MAAM,kBAAkB;AAAA;AAAA;AAAA;AAAA;AAAA,EAO9B,YAAY,QAAa;AACxB,SAAK,SAAS;AAAA,EACf;AAAA;AAAA;AAAA;AAAA;AAAA,EAMO,UAAkB;AACxB,WAAO,KAAK,OAAO,QAAQ;AAAA,EAC5B;AAAA;AAAA;AAAA;AAAA;AAAA,EAMO,UAAkB;AACxB,WAAO,KAAK,OAAO,QAAQ;AAAA,EAC5B;AAAA;AAAA;AAAA;AAAA;AAAA,EAMO,iBAAyB;AAC/B,WAAO,KAAK,OAAO,eAAe;AAAA,EACnC;AAAA;AAAA;AAAA;AAAA;AAAA,EAMO,UAAkB;AACxB,WAAO,KAAK,OAAO,QAAQ;AAAA,EAC5B;AAAA;AAAA;AAAA;AAAA;AAAA,EAMO,eAAuB;AAC7B,WAAO,KAAK,OAAO,aAAa;AAAA,EACjC;AAAA;AAAA;AAAA;AAAA;AAAA,EAMO,eAAqB;AAC3B,WAAO,KAAK,OAAO,aAAa;AAAA,EACjC;AAAA;AAAA;AAAA;AAAA;AAAA,EAMO,gBAAwB;AAC9B,WAAO,KAAK,OAAO,cAAc;AAAA,EAClC;AAAA;AAAA;AAAA;AAAA;AAAA,EAMO,gBAAsB;AAC5B,WAAO,KAAK,OAAO,cAAc;AAAA,EAClC;AACD;AAGA,IAAI,OAAO,WAAW,aAAa;AAElC,SAAO,UAAU;AAClB;",
  "names": []
}
