@aerokit/sdk 12.44.0

package/dist/esm/platform/engines.mjs

@@ -0,0 +1,51 @@
+const EnginesFacade = Java.type("org.eclipse.dirigible.components.api.platform.EnginesFacade");
+const HashMap = Java.type("java.util.HashMap");
+class Engine {
+  /**
+   * Creates an instance of Engine.
+   * @param {string} type The type of the execution engine (e.g., "javascript").
+   */
+  constructor(type) {
+    this.type = type;
+  }
+  /**
+   * Retrieves the list of available engine types from the platform.
+   * @returns {string[]} An array of supported engine type names.
+   */
+  static getTypes() {
+    return JSON.parse(EnginesFacade.getEngineTypes());
+  }
+  /**
+   * Executes a project script or process using the configured engine type.
+   *
+   * @param {string} projectName The name of the project.
+   * @param {string} projectFilePath The relative path to the main file to execute within the project (e.g., "lib/script.js").
+   * @param {string} projectFilePathParam A secondary file path parameter (often unused or context-specific).
+   * @param {ExecutionParameters} parameters An object containing key/value parameters to pass to the script context.
+   * @param {boolean} [debug=false] Whether to execute in debug mode.
+   * @returns {any} The result returned by the executed script.
+   */
+  execute(projectName, projectFilePath, projectFilePathParam, parameters, debug = false) {
+    const mapInstance = new HashMap();
+    for (const property in parameters) {
+      if (parameters.hasOwnProperty(property)) {
+        mapInstance.put(property, parameters[property]);
+      }
+    }
+    return EnginesFacade.execute(
+      this.type,
+      projectName,
+      projectFilePath,
+      projectFilePathParam,
+      mapInstance,
+      debug
+    );
+  }
+}
+if (typeof module !== "undefined") {
+  module.exports = Engine;
+}
+export {
+  Engine
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/platform/index.mjs

@@ -0,0 +1,27 @@
+export * from "./command";
+import { Command } from "./command";
+export * from "./engines";
+import { Engine } from "./engines";
+export * from "./lifecycle";
+import { Lifecycle } from "./lifecycle";
+export * from "./os";
+import { OS } from "./os";
+export * from "./problems";
+import { Problems } from "./problems";
+export * from "./registry";
+import { Registry } from "./registry";
+export * from "./repository";
+import { Repository } from "./repository";
+export * from "./workspace";
+import { Workspace } from "./workspace";
+export {
+  Command as command,
+  Engine as engines,
+  Lifecycle as lifecycle,
+  OS as os,
+  Problems as problems,
+  Registry as registry,
+  Repository as repository,
+  Workspace as workspace
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vc3JjL3BsYXRmb3JtL2luZGV4LnRzIl0sCiAgInNvdXJjZXNDb250ZW50IjogWyJleHBvcnQgKiBmcm9tIFwiLi9jb21tYW5kXCI7XG5leHBvcnQgeyBDb21tYW5kIGFzIGNvbW1hbmQgfSBmcm9tIFwiLi9jb21tYW5kXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9lbmdpbmVzXCI7XG5leHBvcnQgeyBFbmdpbmUgYXMgZW5naW5lcyB9IGZyb20gXCIuL2VuZ2luZXNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2xpZmVjeWNsZVwiO1xuZXhwb3J0IHsgTGlmZWN5Y2xlIGFzIGxpZmVjeWNsZSB9IGZyb20gXCIuL2xpZmVjeWNsZVwiO1xuZXhwb3J0ICogZnJvbSBcIi4vb3NcIjtcbmV4cG9ydCB7IE9TIGFzIG9zIH0gZnJvbSBcIi4vb3NcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3Byb2JsZW1zXCI7XG5leHBvcnQgeyBQcm9ibGVtcyBhcyBwcm9ibGVtcyB9IGZyb20gXCIuL3Byb2JsZW1zXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9yZWdpc3RyeVwiO1xuZXhwb3J0IHsgUmVnaXN0cnkgYXMgcmVnaXN0cnkgfSBmcm9tIFwiLi9yZWdpc3RyeVwiO1xuZXhwb3J0ICogZnJvbSBcIi4vcmVwb3NpdG9yeVwiO1xuZXhwb3J0IHsgUmVwb3NpdG9yeSBhcyByZXBvc2l0b3J5IH0gZnJvbSBcIi4vcmVwb3NpdG9yeVwiO1xuZXhwb3J0ICogZnJvbSBcIi4vd29ya3NwYWNlXCI7XG5leHBvcnQgeyBXb3Jrc3BhY2UgYXMgd29ya3NwYWNlIH0gZnJvbSBcIi4vd29ya3NwYWNlXCI7XG4iXSwKICAibWFwcGluZ3MiOiAiQUFBQSxjQUFjO0FBQ2QsU0FBb0IsZUFBZTtBQUNuQyxjQUFjO0FBQ2QsU0FBbUIsY0FBZTtBQUNsQyxjQUFjO0FBQ2QsU0FBc0IsaUJBQWlCO0FBQ3ZDLGNBQWM7QUFDZCxTQUFlLFVBQVU7QUFDekIsY0FBYztBQUNkLFNBQXFCLGdCQUFnQjtBQUNyQyxjQUFjO0FBQ2QsU0FBcUIsZ0JBQWdCO0FBQ3JDLGNBQWM7QUFDZCxTQUF1QixrQkFBa0I7QUFDekMsY0FBYztBQUNkLFNBQXNCLGlCQUFpQjsiLAogICJuYW1lcyI6IFtdCn0K

package/dist/esm/platform/lifecycle.mjs

@@ -0,0 +1,30 @@
+const LifecycleFacade = Java.type("org.eclipse.dirigible.components.api.platform.LifecycleFacade");
+class Lifecycle {
+  /**
+   * Publishes a project for a specific user and workspace.
+   *
+   * @param {string} user The username of the owner of the workspace.
+   * @param {string} workspace The name of the workspace to publish from.
+   * @param {string} [project="*"] The specific project name to publish. Use "*" to publish all projects in the workspace.
+   * @returns {boolean} True if the publish operation was successful, false otherwise.
+   */
+  static publish(user, workspace, project = "*") {
+    return LifecycleFacade.publish(user, workspace, project);
+  }
+  /**
+   * Unpublishes a currently deployed project.
+   *
+   * @param {string} [project="*"] The specific project name to unpublish. Use "*" to unpublish all currently deployed projects.
+   * @returns {boolean} True if the unpublish operation was successful, false otherwise.
+   */
+  static unpublish(project = "*") {
+    return LifecycleFacade.unpublish(project);
+  }
+}
+if (typeof module !== "undefined") {
+  module.exports = Lifecycle;
+}
+export {
+  Lifecycle
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/platform/os.mjs

@@ -0,0 +1,32 @@
+const SystemUtils = Java.type("org.apache.commons.lang3.SystemUtils");
+class OS {
+  static {
+    /**
+     * The full name of the operating system (e.g., "Windows 10", "Linux").
+     * This value is read directly from the Java system property 'os.name'.
+     * @type {string}
+     */
+    this.OS_NAME = SystemUtils.OS_NAME;
+  }
+  /**
+   * Checks if the operating system is a variant of Windows.
+   * @returns {boolean} True if the OS is Windows, false otherwise.
+   */
+  static isWindows() {
+    return SystemUtils.IS_OS_WINDOWS;
+  }
+  /**
+   * Checks if the operating system is a variant of Unix (including Linux, macOS, and BSD).
+   * @returns {boolean} True if the OS is Unix-like, false otherwise.
+   */
+  static isUnix() {
+    return SystemUtils.IS_OS_UNIX;
+  }
+}
+if (typeof module !== "undefined") {
+  module.exports = OS;
+}
+export {
+  OS
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/platform/problems.mjs

@@ -0,0 +1,108 @@
+const ProblemsFacade = Java.type("org.eclipse.dirigible.components.api.platform.ProblemsFacade");
+class Problems {
+  static {
+    /** Status indicating a newly reported or unresolved problem. */
+    this.ACTIVE = "ACTIVE";
+  }
+  static {
+    /** Status indicating a problem that has been fixed or is no longer relevant. */
+    this.SOLVED = "SOLVED";
+  }
+  static {
+    /** Status indicating a problem that is known but deliberately being disregarded. */
+    this.IGNORED = "IGNORED";
+  }
+  /**
+   * Saves a new problem entry to the system's problem log.
+   *
+   * @param {string} location The resource path or file location.
+   * @param {string} type The severity or nature of the problem.
+   * @param {string} line The line number.
+   * @param {string} column The column number.
+   * @param {string} cause The cause description.
+   * @param {string} expected The expected state/value description.
+   * @param {string} category The problem category.
+   * @param {string} module The module/component name.
+   * @param {string} source The original source content.
+   * @param {string} program The program or file name.
+   */
+  static save(location, type, line, column, cause, expected, category, module2, source, program) {
+    ProblemsFacade.save(location, type, line, column, cause, expected, category, module2, source, program);
+  }
+  /**
+   * Finds a specific problem by its unique ID.
+   * Note: The underlying facade returns a JSON string which is parsed here.
+   *
+   * @param {number} id The unique problem ID.
+   * @returns {Problem} The found Problem object.
+   */
+  static findProblem(id) {
+    return JSON.parse(ProblemsFacade.findProblem(id));
+  }
+  /**
+   * Fetches all recorded problems in the system.
+   * Note: The underlying facade returns a JSON string which is parsed here.
+   *
+   * @returns {Problem[]} An array of all Problem objects.
+   */
+  static fetchAllProblems() {
+    return JSON.parse(ProblemsFacade.fetchAllProblems());
+  }
+  /**
+   * Fetches a batch of problems based on a custom condition and limit.
+   *
+   * @param {string} condition A SQL-like condition string (e.g., "CATEGORY='Syntax'").
+   * @param {number} limit The maximum number of problems to retrieve.
+   * @returns {Problem[]} An array of Problem objects matching the condition.
+   */
+  static fetchProblemsBatch(condition, limit) {
+    return ProblemsFacade.fetchProblemsBatch(condition, limit);
+  }
+  /**
+   * Deletes a problem record by its unique ID.
+   *
+   * @param {number} id The unique problem ID to delete.
+   */
+  static deleteProblem(id) {
+    ProblemsFacade.deleteProblem(id);
+  }
+  /**
+   * Deletes all problem records that currently have the specified status.
+   *
+   * @param {string} status The status (e.g., Problems.SOLVED or Problems.IGNORED).
+   */
+  static deleteAllByStatus(status) {
+    ProblemsFacade.deleteAllByStatus(status);
+  }
+  /**
+   * Clears (deletes) all problem records in the system, regardless of status.
+   */
+  static clearAllProblems() {
+    ProblemsFacade.clearAllProblems();
+  }
+  /**
+   * Updates the status of a single problem by its ID.
+   *
+   * @param {number} id The unique problem ID.
+   * @param {string} status The new status (e.g., Problems.SOLVED).
+   */
+  static updateStatus(id, status) {
+    ProblemsFacade.updateStatus(id, status);
+  }
+  /**
+   * Updates the status of multiple problems identified by an array of IDs.
+   *
+   * @param {number[]} ids An array of unique problem IDs.
+   * @param {string} status The new status to apply to all problems.
+   */
+  static updateStatusMultiple(ids, status) {
+    ProblemsFacade.updateStatusMultiple(ids, status);
+  }
+}
+if (typeof module !== "undefined") {
+  module.exports = Problems;
+}
+export {
+  Problems
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/platform/problems.ts"],
  "sourcesContent": ["/**\n * Provides a wrapper for the platform's ProblemsFacade to manage system issues,\n * including saving new problems, fetching existing ones, and updating their status.\n */\nconst ProblemsFacade = Java.type(\"org.eclipse.dirigible.components.api.platform.ProblemsFacade\");\n\n/**\n * @interface Problem\n * @description Represents a single problem or issue recorded in the system.\n */\nexport interface Problem {\n   /** The unique identifier of the problem. */\n   id: number;\n   /** The resource path or file location where the problem was detected. */\n   location: string;\n   /** The severity or nature of the problem (e.g., \"Error\", \"Warning\"). */\n   type: string;\n   /** The line number in the source where the problem occurred. */\n   line: string;\n   /** The column number in the source where the problem occurred. */\n   column: string;\n   /** A brief description of the cause of the problem. */\n   cause: string;\n   /** A description of the expected state or value. */\n   expected: string;\n   /** The timestamp when the problem was created. */\n   createdAt: Date;\n   /** The user who created or triggered the problem record. */\n   createdBy: string;\n   /** The category of the problem (e.g., \"Syntax\", \"Deployment\"). */\n   category: string;\n   /** The module or component where the problem was found. */\n   module: string;\n   /** The original source code or content related to the problem. */\n   source: string;\n   /** The program or file name associated with the problem. */\n   program: string;\n   /** The current status of the problem (e.g., ACTIVE, SOLVED, IGNORED). */\n   status: string;\n}\n\n/**\n * @class Problems\n * @description Static utility class for managing system problems via the ProblemsFacade.\n */\nexport class Problems {\n\n   /** Status indicating a newly reported or unresolved problem. */\n   public static readonly ACTIVE = \"ACTIVE\";\n   /** Status indicating a problem that has been fixed or is no longer relevant. */\n   public static readonly SOLVED = \"SOLVED\";\n   /** Status indicating a problem that is known but deliberately being disregarded. */\n   public static readonly IGNORED = \"IGNORED\";\n\n   /**\n    * Saves a new problem entry to the system's problem log.\n    *\n    * @param {string} location The resource path or file location.\n    * @param {string} type The severity or nature of the problem.\n    * @param {string} line The line number.\n    * @param {string} column The column number.\n    * @param {string} cause The cause description.\n    * @param {string} expected The expected state/value description.\n    * @param {string} category The problem category.\n    * @param {string} module The module/component name.\n    * @param {string} source The original source content.\n    * @param {string} program The program or file name.\n    */\n   public static save(location: string, type: string, line: string, column: string, cause: string, expected: string, category: string, module: string, source: string, program: string): void {\n      ProblemsFacade.save(location, type, line, column, cause, expected, category, module, source, program);\n   }\n\n   /**\n    * Finds a specific problem by its unique ID.\n    * Note: The underlying facade returns a JSON string which is parsed here.\n    *\n    * @param {number} id The unique problem ID.\n    * @returns {Problem} The found Problem object.\n    */\n   public static findProblem(id: number): Problem {\n      return JSON.parse(ProblemsFacade.findProblem(id));\n   }\n\n   /**\n    * Fetches all recorded problems in the system.\n    * Note: The underlying facade returns a JSON string which is parsed here.\n    *\n    * @returns {Problem[]} An array of all Problem objects.\n    */\n   public static fetchAllProblems(): Problem[] {\n      return JSON.parse(ProblemsFacade.fetchAllProblems());\n   }\n\n   /**\n    * Fetches a batch of problems based on a custom condition and limit.\n    *\n    * @param {string} condition A SQL-like condition string (e.g., \"CATEGORY='Syntax'\").\n    * @param {number} limit The maximum number of problems to retrieve.\n    * @returns {Problem[]} An array of Problem objects matching the condition.\n    */\n   public static fetchProblemsBatch(condition: string, limit: number): Problem[] {\n      // Assuming ProblemsFacade.fetchProblemsBatch returns a parsed JSON array based on the original structure.\n      // If it returns a string, it should be wrapped in JSON.parse() like the others.\n      // Keeping it as is based on the original provided code.\n      return ProblemsFacade.fetchProblemsBatch(condition, limit);\n   }\n\n   /**\n    * Deletes a problem record by its unique ID.\n    *\n    * @param {number} id The unique problem ID to delete.\n    */\n   public static deleteProblem(id: number): void {\n      ProblemsFacade.deleteProblem(id);\n   }\n\n   /**\n    * Deletes all problem records that currently have the specified status.\n    *\n    * @param {string} status The status (e.g., Problems.SOLVED or Problems.IGNORED).\n    */\n   public static deleteAllByStatus(status: string): void {\n      ProblemsFacade.deleteAllByStatus(status);\n   }\n\n   /**\n    * Clears (deletes) all problem records in the system, regardless of status.\n    */\n   public static clearAllProblems(): void {\n      ProblemsFacade.clearAllProblems();\n   }\n\n   /**\n    * Updates the status of a single problem by its ID.\n    *\n    * @param {number} id The unique problem ID.\n    * @param {string} status The new status (e.g., Problems.SOLVED).\n    */\n   public static updateStatus(id: number, status: string): void {\n      ProblemsFacade.updateStatus(id, status);\n   }\n\n   /**\n    * Updates the status of multiple problems identified by an array of IDs.\n    *\n    * @param {number[]} ids An array of unique problem IDs.\n    * @param {string} status The new status to apply to all problems.\n    */\n   public static updateStatusMultiple(ids: number[], status: string): void {\n      ProblemsFacade.updateStatusMultiple(ids, status);\n   }\n}\n\n// @ts-ignore\nif (typeof module !== 'undefined') {\n\t// @ts-ignore\n\tmodule.exports = Problems;\n}"],
  "mappings": "AAIA,MAAM,iBAAiB,KAAK,KAAK,8DAA8D;AAyCxF,MAAM,SAAS;AAAA,EAGnB;AAAA;AAAA,SAAuB,SAAS;AAAA;AAAA,EAEhC;AAAA;AAAA,SAAuB,SAAS;AAAA;AAAA,EAEhC;AAAA;AAAA,SAAuB,UAAU;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAgBjC,OAAc,KAAK,UAAkB,MAAc,MAAc,QAAgB,OAAe,UAAkB,UAAkBA,SAAgB,QAAgB,SAAuB;AACxL,mBAAe,KAAK,UAAU,MAAM,MAAM,QAAQ,OAAO,UAAU,UAAUA,SAAQ,QAAQ,OAAO;AAAA,EACvG;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASA,OAAc,YAAY,IAAqB;AAC5C,WAAO,KAAK,MAAM,eAAe,YAAY,EAAE,CAAC;AAAA,EACnD;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,OAAc,mBAA8B;AACzC,WAAO,KAAK,MAAM,eAAe,iBAAiB,CAAC;AAAA,EACtD;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASA,OAAc,mBAAmB,WAAmB,OAA0B;AAI3E,WAAO,eAAe,mBAAmB,WAAW,KAAK;AAAA,EAC5D;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,OAAc,cAAc,IAAkB;AAC3C,mBAAe,cAAc,EAAE;AAAA,EAClC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,OAAc,kBAAkB,QAAsB;AACnD,mBAAe,kBAAkB,MAAM;AAAA,EAC1C;AAAA;AAAA;AAAA;AAAA,EAKA,OAAc,mBAAyB;AACpC,mBAAe,iBAAiB;AAAA,EACnC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,OAAc,aAAa,IAAY,QAAsB;AAC1D,mBAAe,aAAa,IAAI,MAAM;AAAA,EACzC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,OAAc,qBAAqB,KAAe,QAAsB;AACrE,mBAAe,qBAAqB,KAAK,MAAM;AAAA,EAClD;AACH;AAGA,IAAI,OAAO,WAAW,aAAa;AAElC,SAAO,UAAU;AAClB;",
  "names": ["module"]
}


package/dist/esm/platform/registry.mjs

@@ -0,0 +1,300 @@
+import { Bytes } from "@aerokit/sdk/io/bytes";
+import { Repository } from "@aerokit/sdk/platform/repository";
+const RegistryFacade = Java.type("org.eclipse.dirigible.components.api.platform.RegistryFacade");
+class Registry {
+  /**
+   * Retrieves the content of a registry resource at the given path, converting it into a
+   * JavaScript-friendly byte array format.
+   *
+   * @param {string} path The absolute path to the resource (e.g., "/registry/public/myFile.txt").
+   * @returns {any[]} The resource content as a JavaScript byte array.
+   */
+  static getContent(path) {
+    return Bytes.toJavaScriptBytes(RegistryFacade.getContent(path));
+  }
+  /**
+   * Retrieves the content of a registry resource at the given path in its native Java byte array format.
+   *
+   * @param {string} path The absolute path to the resource.
+   * @returns {any[]} The resource content as a native Java byte array.
+   */
+  static getContentNative(path) {
+    return RegistryFacade.getContent(path);
+  }
+  /**
+   * Retrieves the content of a registry resource at the given path as a string.
+   *
+   * @param {string} path The absolute path to the resource.
+   * @returns {string} The resource content as plain text.
+   */
+  static getText(path) {
+    return RegistryFacade.getText(path);
+  }
+  /**
+   * Searches the registry 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 registry paths (strings) that match the search criteria.
+   */
+  static find(path, pattern) {
+    return JSON.parse(RegistryFacade.find(path, pattern));
+  }
+  /**
+   * Gets the root directory object for the public registry space.
+   *
+   * @returns {Directory} A Directory instance representing the root public collection.
+   */
+  static getRoot() {
+    return new Directory(Repository.getCollection("/registry/public"));
+  }
+}
+class Artefact {
+  /**
+   * @constructor
+   * @param {any} native The native Java object instance representing the repository resource.
+   */
+  constructor(native) {
+    this.native = native;
+  }
+  /**
+   * Gets the name of the artefact (file name).
+   * @returns {string} The name.
+   */
+  getName() {
+    return this.native.getName();
+  }
+  /**
+   * Gets the full registry path of the artefact.
+   * @returns {string} The registry path.
+   */
+  getPath() {
+    return RegistryFacade.toRegistryPath(this.native.getPath());
+  }
+  /**
+   * Gets the parent directory of this artefact.
+   * @returns {Directory} The parent Directory instance.
+   */
+  getParent() {
+    const collectionInstance = this.native.getParent();
+    return new Directory(collectionInstance);
+  }
+  /**
+   * Gets detailed metadata about the artefact.
+   * @returns {ArtefactInformation} The metadata object.
+   */
+  getInformation() {
+    const informationInstance = this.native.getInformation();
+    return new ArtefactInformation(informationInstance);
+  }
+  /**
+   * Checks if the artefact currently exists in the registry.
+   * @returns {boolean} True if the artefact exists, false otherwise.
+   */
+  exists() {
+    return this.native.exists();
+  }
+  /**
+   * Checks if the artefact (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 artefact as a text string.
+   * @returns {string} The text content.
+   */
+  getText() {
+    return Bytes.byteArrayToText(this.getContent());
+  }
+  /**
+   * Gets the content of the artefact as a JavaScript-friendly byte array.
+   * @returns {any[]} The content bytes.
+   */
+  getContent() {
+    const nativeContent = this.native.getContent();
+    return Bytes.toJavaScriptBytes(nativeContent);
+  }
+  /**
+   * Gets the content of the artefact as its native Java byte array representation.
+   * @returns {any[]} The content bytes.
+   */
+  getContentNative() {
+    return this.native.getContent();
+  }
+  /**
+   * Checks if the artefact 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 artefact.
+   * @returns {string} The content type string.
+   */
+  getContentType() {
+    return this.native.getContentType();
+  }
+}
+class Directory {
+  /**
+   * @constructor
+   * @param {any} native The native Java object instance representing the repository collection.
+   */
+  constructor(native) {
+    this.native = native;
+  }
+  /**
+   * Gets the name of the directory (folder name).
+   * @returns {string} The name.
+   */
+  getName() {
+    return this.native.getName();
+  }
+  /**
+   * Gets the full registry path of the directory.
+   * @returns {string} The registry path.
+   */
+  getPath() {
+    return RegistryFacade.toRegistryPath(this.native.getPath());
+  }
+  /**
+   * Gets the parent directory.
+   * @returns {Directory} The parent Directory instance.
+   */
+  getParent() {
+    const collectionInstance = this.native.getParent();
+    return new Directory(collectionInstance);
+  }
+  /**
+   * Gets detailed metadata about the directory.
+   * @returns {ArtefactInformation} The metadata object.
+   */
+  getInformation() {
+    const informationInstance = this.native.getInformation();
+    return new ArtefactInformation(informationInstance);
+  }
+  /**
+   * Checks if the directory currently exists in the registry.
+   * @returns {boolean} True if the directory exists, false otherwise.
+   */
+  exists() {
+    return this.native.exists();
+  }
+  /**
+   * Checks if the directory 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-directories within this directory.
+   * @returns {string[]} An array of sub-directory names.
+   */
+  getDirectoriesNames() {
+    return this.native.getCollectionsNames();
+  }
+  /**
+   * Gets a specific sub-directory by name.
+   * @param {string} name The name of the sub-directory.
+   * @returns {Directory} The child Directory instance.
+   */
+  getDirectory(name) {
+    const collectionInstance = this.native.getCollection(RegistryFacade.toResourcePath(name));
+    return new Directory(collectionInstance);
+  }
+  /**
+   * Gets the names of all files (artefacts) within this directory.
+   * @returns {string[]} An array of artefact names.
+   */
+  getArtefactsNames() {
+    return this.native.getResourcesNames();
+  }
+  /**
+   * Gets a specific file (artefact) by name.
+   * @param {string} name The name of the artefact.
+   * @returns {Artefact} The child Artefact instance.
+   */
+  getArtefact(name) {
+    const resourceInstance = this.native.getResource(RegistryFacade.toResourcePath(name));
+    return new Artefact(resourceInstance);
+  }
+}
+class ArtefactInformation {
+  /**
+   * @constructor
+   * @param {any} native The native Java object instance holding the artefact information.
+   */
+  constructor(native) {
+    this.native = native;
+  }
+  /**
+   * Gets the name of the resource.
+   * @returns {string} The name.
+   */
+  getName() {
+    return this.native.getName();
+  }
+  /**
+   * Gets the full registry path of the resource.
+   * @returns {string} The registry path.
+   */
+  getPath() {
+    return RegistryFacade.toRegistryPath(this.native.getPath());
+  }
+  /**
+   * Gets the access permissions for the resource (typically an integer bitmask).
+   * @returns {number} The permissions value.
+   */
+  getPermissions() {
+    return this.native.getPermissions();
+  }
+  /**
+   * Gets the size of the resource content in bytes.
+   * @returns {number} The size in bytes.
+   */
+  getSize() {
+    return this.native.getSize();
+  }
+  /**
+   * Gets the user who created the resource.
+   * @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 resource.
+   * @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 = Registry;
+}
+export {
+  Artefact,
+  ArtefactInformation,
+  Directory,
+  Registry
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/platform/registry.ts"],
  "sourcesContent": ["/**\n * Provides a set of utilities and data structures for interacting with the platform's\n * Registry/Repository, which manages files and directories (Artefacts and Collections).\n */\nimport { Bytes } from \"@aerokit/sdk/io/bytes\";\nimport { Repository } from \"@aerokit/sdk/platform/repository\";\nconst RegistryFacade = Java.type(\"org.eclipse.dirigible.components.api.platform.RegistryFacade\");\n\n/**\n * @class Registry\n * @description Static utility class providing high-level access to the RegistryFacade for\n * retrieving content and metadata by path.\n */\nexport class Registry {\n\n\t/**\n\t * Retrieves the content of a registry resource at the given path, converting it into a\n\t * JavaScript-friendly byte array format.\n\t *\n\t * @param {string} path The absolute path to the resource (e.g., \"/registry/public/myFile.txt\").\n\t * @returns {any[]} The resource content as a JavaScript byte array.\n\t */\n\tpublic static getContent(path: string): any[] {\n\t\treturn Bytes.toJavaScriptBytes(RegistryFacade.getContent(path));\n\t}\n\n\t/**\n\t * Retrieves the content of a registry resource at the given path in its native Java byte array format.\n\t *\n\t * @param {string} path The absolute path to the resource.\n\t * @returns {any[]} The resource content as a native Java byte array.\n\t */\n\tpublic static getContentNative(path: string): any[] {\n\t\treturn RegistryFacade.getContent(path);\n\t}\n\n\t/**\n\t * Retrieves the content of a registry resource at the given path as a string.\n\t *\n\t * @param {string} path The absolute path to the resource.\n\t * @returns {string} The resource content as plain text.\n\t */\n\tpublic static getText(path: string): string {\n\t\treturn RegistryFacade.getText(path);\n\t}\n\n\t/**\n\t * Searches the registry 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 registry paths (strings) that match the search criteria.\n\t */\n\tpublic static find(path: string, pattern: string): string[] {\n\t\treturn JSON.parse(RegistryFacade.find(path, pattern));\n\t}\n\n\t/**\n\t * Gets the root directory object for the public registry space.\n\t *\n\t * @returns {Directory} A Directory instance representing the root public collection.\n\t */\n\tpublic static getRoot(): Directory {\n\t\treturn new Directory(Repository.getCollection(\"/registry/public\"));\n\t}\n}\n\n/**\n * @class Artefact\n * @description Represents a file or resource (non-collection) within the Registry.\n */\nexport class Artefact {\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 artefact (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 registry path of the artefact.\n\t * @returns {string} The registry path.\n\t */\n\tpublic getPath(): string {\n\t\treturn RegistryFacade.toRegistryPath(this.native.getPath());\n\t}\n\n\t/**\n\t * Gets the parent directory of this artefact.\n\t * @returns {Directory} The parent Directory instance.\n\t */\n\tpublic getParent(): Directory {\n\t\tconst collectionInstance = this.native.getParent();\n\t\treturn new Directory(collectionInstance);\n\t}\n\n\t/**\n\t * Gets detailed metadata about the artefact.\n\t * @returns {ArtefactInformation} The metadata object.\n\t */\n\tpublic getInformation(): ArtefactInformation {\n\t\tconst informationInstance = this.native.getInformation();\n\t\treturn new ArtefactInformation(informationInstance);\n\t}\n\n\t/**\n\t * Checks if the artefact currently exists in the registry.\n\t * @returns {boolean} True if the artefact 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 artefact (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 artefact 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 artefact 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 artefact 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 * Checks if the artefact 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 artefact.\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 Directory\n * @description Represents a collection or folder within the Registry.\n */\nexport class Directory {\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 directory (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 registry path of the directory.\n\t * @returns {string} The registry path.\n\t */\n\tpublic getPath(): string {\n\t\treturn RegistryFacade.toRegistryPath(this.native.getPath());\n\t}\n\n\t/**\n\t * Gets the parent directory.\n\t * @returns {Directory} The parent Directory instance.\n\t */\n\tpublic getParent(): Directory {\n\t\tconst collectionInstance = this.native.getParent();\n\t\treturn new Directory(collectionInstance);\n\t}\n\n\t/**\n\t * Gets detailed metadata about the directory.\n\t * @returns {ArtefactInformation} The metadata object.\n\t */\n\tpublic getInformation(): ArtefactInformation {\n\t\tconst informationInstance = this.native.getInformation();\n\t\treturn new ArtefactInformation(informationInstance);\n\t}\n\n\t/**\n\t * Checks if the directory currently exists in the registry.\n\t * @returns {boolean} True if the directory 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 directory 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-directories within this directory.\n\t * @returns {string[]} An array of sub-directory names.\n\t */\n\tpublic getDirectoriesNames(): string[] {\n\t\treturn this.native.getCollectionsNames();\n\t}\n\n\t/**\n\t * Gets a specific sub-directory by name.\n\t * @param {string} name The name of the sub-directory.\n\t * @returns {Directory} The child Directory instance.\n\t */\n\tpublic getDirectory(name: string): Directory {\n\t\tconst collectionInstance = this.native.getCollection(RegistryFacade.toResourcePath(name));\n\t\treturn new Directory(collectionInstance);\n\t}\n\n\t/**\n\t * Gets the names of all files (artefacts) within this directory.\n\t * @returns {string[]} An array of artefact names.\n\t */\n\tpublic getArtefactsNames(): string[] {\n\t\treturn this.native.getResourcesNames();\n\t}\n\n\t/**\n\t * Gets a specific file (artefact) by name.\n\t * @param {string} name The name of the artefact.\n\t * @returns {Artefact} The child Artefact instance.\n\t */\n\tpublic getArtefact(name: string): Artefact {\n\t\tconst resourceInstance = this.native.getResource(RegistryFacade.toResourcePath(name));\n\t\treturn new Artefact(resourceInstance);\n\t}\n\n}\n\n/**\n * @class ArtefactInformation\n * @description Represents detailed metadata (creation date, size, permissions, etc.) for a\n * Directory or Artefact.\n */\nexport class ArtefactInformation {\n\tprivate readonly native: any;\n\n\t/**\n\t * @constructor\n\t * @param {any} native The native Java object instance holding the artefact information.\n\t */\n\tconstructor(native: any) {\n\t\tthis.native = native;\n\t}\n\n\t/**\n\t * Gets the name of the resource.\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 registry path of the resource.\n\t * @returns {string} The registry path.\n\t */\n\tpublic getPath(): string {\n\t\treturn RegistryFacade.toRegistryPath(this.native.getPath());\n\t}\n\n\t/**\n\t * Gets the access permissions for the resource (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.\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 resource.\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 resource.\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 = Registry;\n}\n"],
  "mappings": "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",
  "names": []
}
