@aerokit/sdk 12.44.0

package/dist/esm/rabbitmq/producer.mjs

@@ -0,0 +1,19 @@
+const RabbitMQFacade = Java.type("org.eclipse.dirigible.components.api.rabbitmq.RabbitMQFacade");
+class Producer {
+  /**
+   * Sends a message to the specified RabbitMQ queue.
+   *
+   * @param queue The name of the RabbitMQ queue to send the message to.
+   * @param message The content of the message to be sent (as a string).
+   */
+  static send(queue, message) {
+    RabbitMQFacade.send(queue, message);
+  }
+}
+if (typeof module !== "undefined") {
+  module.exports = Producer;
+}
+export {
+  Producer
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vc3JjL3JhYmJpdG1xL3Byb2R1Y2VyLnRzIl0sCiAgInNvdXJjZXNDb250ZW50IjogWyIvKipcbiAqIFJhYmJpdE1RIFByb2R1Y2VyXG4gKlxuICogVGhpcyBmYWNhZGUgcHJvdmlkZXMgYSBzdGF0aWMgbWV0aG9kIHRvIHNlbmQgbWVzc2FnZXMgdG8gYSBSYWJiaXRNUSBxdWV1ZSxcbiAqIHdyYXBwaW5nIHRoZSB1bmRlcmx5aW5nIEphdmEgaW1wbGVtZW50YXRpb24gcHJvdmlkZWQgYnkgdGhlIGBSYWJiaXRNUUZhY2FkZWAuXG4gKi9cblxuY29uc3QgUmFiYml0TVFGYWNhZGUgPSBKYXZhLnR5cGUoXCJvcmcuZWNsaXBzZS5kaXJpZ2libGUuY29tcG9uZW50cy5hcGkucmFiYml0bXEuUmFiYml0TVFGYWNhZGVcIik7XG5cbmV4cG9ydCBjbGFzcyBQcm9kdWNlciB7XG5cbiAgICAvKipcbiAgICAgKiBTZW5kcyBhIG1lc3NhZ2UgdG8gdGhlIHNwZWNpZmllZCBSYWJiaXRNUSBxdWV1ZS5cbiAgICAgKlxuICAgICAqIEBwYXJhbSBxdWV1ZSBUaGUgbmFtZSBvZiB0aGUgUmFiYml0TVEgcXVldWUgdG8gc2VuZCB0aGUgbWVzc2FnZSB0by5cbiAgICAgKiBAcGFyYW0gbWVzc2FnZSBUaGUgY29udGVudCBvZiB0aGUgbWVzc2FnZSB0byBiZSBzZW50IChhcyBhIHN0cmluZykuXG4gICAgICovXG4gICAgcHVibGljIHN0YXRpYyBzZW5kKHF1ZXVlOiBzdHJpbmcsIG1lc3NhZ2U6IHN0cmluZyk6IHZvaWQge1xuICAgICAgICBSYWJiaXRNUUZhY2FkZS5zZW5kKHF1ZXVlLCBtZXNzYWdlKTtcbiAgICB9XG59XG5cbi8vIEB0cy1pZ25vcmVcbmlmICh0eXBlb2YgbW9kdWxlICE9PSAndW5kZWZpbmVkJykge1xuICAgIC8vIEB0cy1pZ25vcmVcbiAgICBtb2R1bGUuZXhwb3J0cyA9IFByb2R1Y2VyO1xufSJdLAogICJtYXBwaW5ncyI6ICJBQU9BLE1BQU0saUJBQWlCLEtBQUssS0FBSyw4REFBOEQ7QUFFeEYsTUFBTSxTQUFTO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUEsRUFRbEIsT0FBYyxLQUFLLE9BQWUsU0FBdUI7QUFDckQsbUJBQWUsS0FBSyxPQUFPLE9BQU87QUFBQSxFQUN0QztBQUNKO0FBR0EsSUFBSSxPQUFPLFdBQVcsYUFBYTtBQUUvQixTQUFPLFVBQVU7QUFDckI7IiwKICAibmFtZXMiOiBbXQp9Cg==

package/dist/esm/redis/client.mjs

@@ -0,0 +1,171 @@
+const RedisFacade = Java.type("org.eclipse.dirigible.components.api.redis.RedisFacade");
+class Client {
+  /**
+   * Initializes the Redis Client and retrieves the native client instance
+   * from the Redis Facade.
+   */
+  constructor() {
+    this.native = RedisFacade.getClient();
+  }
+  // --- Key-Value and General Operations ---
+  /**
+   * Appends a value to the value of a key. If the key does not exist,
+   * it is created and set to the initial value.
+   *
+   * @param key The key to append to.
+   * @param value The value string to append.
+   * @returns The length of the string after the append operation.
+   */
+  append(key, value) {
+    return this.native.append(key, value);
+  }
+  /**
+   * Counts the number of set bits (1s) in the string value of a key.
+   *
+   * @param key The key to perform the bitcount on.
+   * @returns The number of set bits.
+   */
+  bitcount(key) {
+    return this.native.bitcount(key);
+  }
+  /**
+   * Decrements the number stored at key by one.
+   *
+   * @param key The key holding the numeric value.
+   * @returns The value of key after the decrement.
+   */
+  decr(key) {
+    return this.native.decr(key);
+  }
+  /**
+   * Deletes the specified key.
+   *
+   * @param key The key to delete.
+   * @returns The number of keys that were removed (1 if successful, 0 otherwise).
+   */
+  del(key) {
+    return this.native.del(key);
+  }
+  /**
+   * Checks if the specified key exists.
+   *
+   * @param key The key to check.
+   * @returns True if the key exists, false otherwise.
+   */
+  exists(key) {
+    return this.native.exists(key);
+  }
+  /**
+   * Gets the value of the specified key.
+   *
+   * @param key The key to retrieve the value for.
+   * @returns The value of the key, or null if the key does not exist.
+   */
+  get(key) {
+    return this.native.get(key);
+  }
+  /**
+   * Increments the number stored at key by one.
+   *
+   * @param key The key holding the numeric value.
+   * @returns The value of key after the increment.
+   */
+  incr(key) {
+    return this.native.incr(key);
+  }
+  /**
+   * Finds all keys matching the given pattern.
+   *
+   * @param pattern The pattern to match keys against (e.g., "user:*").
+   * @returns An array of matching keys.
+   */
+  keys(pattern) {
+    return this.native.keys(pattern);
+  }
+  /**
+   * Sets the string value of a key.
+   *
+   * @param key The key to set.
+   * @param value The string value to assign to the key.
+   * @returns 'OK' on success.
+   */
+  set(key, value) {
+    return this.native.set(key, value);
+  }
+  // --- List Operations ---
+  /**
+   * Gets an element from a list by its zero-based index.
+   *
+   * @param key The key of the list.
+   * @param index The zero-based index (0 is the first element, -1 is the last).
+   * @returns The element at the specified index, or null if the index is out of range.
+   */
+  lindex(key, index) {
+    return this.native.lindex(key, index);
+  }
+  /**
+   * Gets the length of the list stored at the key.
+   *
+   * @param key The key of the list.
+   * @returns The length of the list.
+   */
+  llen(key) {
+    return this.native.llen(key);
+  }
+  /**
+   * Removes and returns the first element of the list stored at the key (Left POP).
+   *
+   * @param key The key of the list.
+   * @returns The first element of the list, or null when the list is empty.
+   */
+  lpop(key) {
+    return this.native.lpop(key);
+  }
+  /**
+   * Inserts all specified values at the head of the list stored at the key (Left PUSH).
+   *
+   * @param key The key of the list.
+   * @param value One or more values to prepend to the list.
+   * @returns The new length of the list.
+   */
+  lpush(key, ...value) {
+    return this.native.lpush(key, value);
+  }
+  /**
+   * Returns the specified elements of the list stored at the key.
+   *
+   * @param key The key of the list.
+   * @param start The starting zero-based offset.
+   * @param stop The stopping zero-based offset.
+   * @returns An array of elements in the specified range.
+   */
+  lrange(key, start, stop) {
+    return this.native.lrange(key, start, stop);
+  }
+  /**
+   * Removes and returns the last element of the list stored at the key (Right POP).
+   *
+   * @param key The key of the list.
+   * @returns The last element of the list, or null when the list is empty.
+   */
+  rpop(key) {
+    return this.native.rpop(key);
+  }
+  /**
+   * Inserts all specified values at the tail of the list stored at the key (Right PUSH).
+   *
+   * @param key The key of the list.
+   * @param value One or more values to append to the list.
+   * @returns The new length of the list.
+   */
+  rpush(key, ...value) {
+    return this.native.rpush(key, value);
+  }
+}
+if (typeof module !== "undefined") {
+  module.exports = Client;
+}
+export {
+  Client
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/redis/client.ts"],
  "sourcesContent": ["/**\n * Redis Client\n *\n * This class serves as a facade for common Redis operations, providing a convenient\n * JavaScript interface that wraps the underlying Java Redis client implementation.\n */\n\nconst RedisFacade = Java.type(\"org.eclipse.dirigible.components.api.redis.RedisFacade\");\n\nexport class Client {\n    private readonly native: any;\n\n    /**\n     * Initializes the Redis Client and retrieves the native client instance\n     * from the Redis Facade.\n     */\n    constructor() {\n        this.native = RedisFacade.getClient();\n    }\n\n    // --- Key-Value and General Operations ---\n\n    /**\n     * Appends a value to the value of a key. If the key does not exist,\n     * it is created and set to the initial value.\n     *\n     * @param key The key to append to.\n     * @param value The value string to append.\n     * @returns The length of the string after the append operation.\n     */\n    public append(key: string, value: string): number {\n        return this.native.append(key, value);\n    }\n\n    /**\n     * Counts the number of set bits (1s) in the string value of a key.\n     *\n     * @param key The key to perform the bitcount on.\n     * @returns The number of set bits.\n     */\n    public bitcount(key: string): number {\n        return this.native.bitcount(key);\n    }\n\n    /**\n     * Decrements the number stored at key by one.\n     *\n     * @param key The key holding the numeric value.\n     * @returns The value of key after the decrement.\n     */\n    public decr(key: string): number {\n        return this.native.decr(key);\n    }\n\n    /**\n     * Deletes the specified key.\n     *\n     * @param key The key to delete.\n     * @returns The number of keys that were removed (1 if successful, 0 otherwise).\n     */\n    public del(key: string): number {\n        return this.native.del(key);\n    }\n\n    /**\n     * Checks if the specified key exists.\n     *\n     * @param key The key to check.\n     * @returns True if the key exists, false otherwise.\n     */\n    public exists(key: string): boolean {\n        return this.native.exists(key);\n    }\n\n    /**\n     * Gets the value of the specified key.\n     *\n     * @param key The key to retrieve the value for.\n     * @returns The value of the key, or null if the key does not exist.\n     */\n    public get(key: string): string {\n        return this.native.get(key);\n    }\n\n    /**\n     * Increments the number stored at key by one.\n     *\n     * @param key The key holding the numeric value.\n     * @returns The value of key after the increment.\n     */\n    public incr(key: string): number {\n        return this.native.incr(key);\n    }\n\n    /**\n     * Finds all keys matching the given pattern.\n     *\n     * @param pattern The pattern to match keys against (e.g., \"user:*\").\n     * @returns An array of matching keys.\n     */\n    public keys(pattern: string): string[] {\n        return this.native.keys(pattern);\n    }\n\n    /**\n     * Sets the string value of a key.\n     *\n     * @param key The key to set.\n     * @param value The string value to assign to the key.\n     * @returns 'OK' on success.\n     */\n    public set(key: string, value: string): string {\n        return this.native.set(key, value);\n    }\n\n    // --- List Operations ---\n\n    /**\n     * Gets an element from a list by its zero-based index.\n     *\n     * @param key The key of the list.\n     * @param index The zero-based index (0 is the first element, -1 is the last).\n     * @returns The element at the specified index, or null if the index is out of range.\n     */\n    public lindex(key: string, index: number): string {\n        return this.native.lindex(key, index);\n    }\n\n    /**\n     * Gets the length of the list stored at the key.\n     *\n     * @param key The key of the list.\n     * @returns The length of the list.\n     */\n    public llen(key: string): number {\n        return this.native.llen(key);\n    }\n\n    /**\n     * Removes and returns the first element of the list stored at the key (Left POP).\n     *\n     * @param key The key of the list.\n     * @returns The first element of the list, or null when the list is empty.\n     */\n    public lpop(key: string): string {\n        return this.native.lpop(key);\n    }\n\n    /**\n     * Inserts all specified values at the head of the list stored at the key (Left PUSH).\n     *\n     * @param key The key of the list.\n     * @param value One or more values to prepend to the list.\n     * @returns The new length of the list.\n     */\n    public lpush(key: string, ...value: string[]) {\n        return this.native.lpush(key, value);\n    }\n\n    /**\n     * Returns the specified elements of the list stored at the key.\n     *\n     * @param key The key of the list.\n     * @param start The starting zero-based offset.\n     * @param stop The stopping zero-based offset.\n     * @returns An array of elements in the specified range.\n     */\n    public lrange(key: string, start: number, stop: number): string[] {\n        return this.native.lrange(key, start, stop);\n    }\n\n    /**\n     * Removes and returns the last element of the list stored at the key (Right POP).\n     *\n     * @param key The key of the list.\n     * @returns The last element of the list, or null when the list is empty.\n     */\n    public rpop(key: string): string {\n        return this.native.rpop(key);\n    }\n\n    /**\n     * Inserts all specified values at the tail of the list stored at the key (Right PUSH).\n     *\n     * @param key The key of the list.\n     * @param value One or more values to append to the list.\n     * @returns The new length of the list.\n     */\n    public rpush(key: string, ...value: string[]): number {\n        return this.native.rpush(key, value);\n    }\n}\n\n// @ts-ignore\nif (typeof module !== 'undefined') {\n    // @ts-ignore\n    module.exports = Client;\n}"],
  "mappings": "AAOA,MAAM,cAAc,KAAK,KAAK,wDAAwD;AAE/E,MAAM,OAAO;AAAA;AAAA;AAAA;AAAA;AAAA,EAOhB,cAAc;AACV,SAAK,SAAS,YAAY,UAAU;AAAA,EACxC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAYO,OAAO,KAAa,OAAuB;AAC9C,WAAO,KAAK,OAAO,OAAO,KAAK,KAAK;AAAA,EACxC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQO,SAAS,KAAqB;AACjC,WAAO,KAAK,OAAO,SAAS,GAAG;AAAA,EACnC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQO,KAAK,KAAqB;AAC7B,WAAO,KAAK,OAAO,KAAK,GAAG;AAAA,EAC/B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQO,IAAI,KAAqB;AAC5B,WAAO,KAAK,OAAO,IAAI,GAAG;AAAA,EAC9B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQO,OAAO,KAAsB;AAChC,WAAO,KAAK,OAAO,OAAO,GAAG;AAAA,EACjC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQO,IAAI,KAAqB;AAC5B,WAAO,KAAK,OAAO,IAAI,GAAG;AAAA,EAC9B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQO,KAAK,KAAqB;AAC7B,WAAO,KAAK,OAAO,KAAK,GAAG;AAAA,EAC/B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQO,KAAK,SAA2B;AACnC,WAAO,KAAK,OAAO,KAAK,OAAO;AAAA,EACnC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASO,IAAI,KAAa,OAAuB;AAC3C,WAAO,KAAK,OAAO,IAAI,KAAK,KAAK;AAAA,EACrC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAWO,OAAO,KAAa,OAAuB;AAC9C,WAAO,KAAK,OAAO,OAAO,KAAK,KAAK;AAAA,EACxC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQO,KAAK,KAAqB;AAC7B,WAAO,KAAK,OAAO,KAAK,GAAG;AAAA,EAC/B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQO,KAAK,KAAqB;AAC7B,WAAO,KAAK,OAAO,KAAK,GAAG;AAAA,EAC/B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASO,MAAM,QAAgB,OAAiB;AAC1C,WAAO,KAAK,OAAO,MAAM,KAAK,KAAK;AAAA,EACvC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAUO,OAAO,KAAa,OAAe,MAAwB;AAC9D,WAAO,KAAK,OAAO,OAAO,KAAK,OAAO,IAAI;AAAA,EAC9C;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQO,KAAK,KAAqB;AAC7B,WAAO,KAAK,OAAO,KAAK,GAAG;AAAA,EAC/B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASO,MAAM,QAAgB,OAAyB;AAClD,WAAO,KAAK,OAAO,MAAM,KAAK,KAAK;AAAA,EACvC;AACJ;AAGA,IAAI,OAAO,WAAW,aAAa;AAE/B,SAAO,UAAU;AACrB;",
  "names": []
}


package/dist/esm/redis/index.mjs

@@ -0,0 +1,6 @@
+export * from "./client";
+import { Client } from "./client";
+export {
+  Client as client
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vc3JjL3JlZGlzL2luZGV4LnRzIl0sCiAgInNvdXJjZXNDb250ZW50IjogWyJleHBvcnQgKiBmcm9tIFwiLi9jbGllbnRcIjtcbmV4cG9ydCB7IENsaWVudCBhcyBjbGllbnQgfSBmcm9tIFwiLi9jbGllbnRcIjtcbiJdLAogICJtYXBwaW5ncyI6ICJBQUFBLGNBQWM7QUFDZCxTQUFtQixjQUFjOyIsCiAgIm5hbWVzIjogW10KfQo=

package/dist/esm/security/decorators.mjs

@@ -0,0 +1,29 @@
+const UserFacade = Java.type("org.eclipse.dirigible.components.api.security.UserFacade");
+function Roles(roles) {
+  return function(target, _context) {
+    const moduleName = target.name || "<unknown>";
+    for (const methodName of Object.getOwnPropertyNames(target.prototype)) {
+      if (methodName === "constructor") {
+        continue;
+      }
+      const original = target.prototype[methodName];
+      if (typeof original !== "function") {
+        continue;
+      }
+      target.prototype[methodName] = function(...args) {
+        const allowed = roles.some((role) => UserFacade.isInRole(role));
+        if (!allowed) {
+          throw new Error(
+            "User is not allowed to call this module: " + moduleName
+          );
+        }
+        return original.apply(this, args);
+      };
+    }
+    return target;
+  };
+}
+export {
+  Roles
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/security/index.mjs

@@ -0,0 +1,10 @@
+export * from "./user";
+import { User } from "./user";
+export * from "./oauth";
+export * from "./decorators";
+import * as decorators from "./decorators";
+export {
+  decorators,
+  User as user
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vc3JjL3NlY3VyaXR5L2luZGV4LnRzIl0sCiAgInNvdXJjZXNDb250ZW50IjogWyJleHBvcnQgKiBmcm9tIFwiLi91c2VyXCI7XG5leHBvcnQgeyBVc2VyIGFzIHVzZXIgfSBmcm9tIFwiLi91c2VyXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9vYXV0aFwiO1xuZXhwb3J0ICogZnJvbSBcIi4vZGVjb3JhdG9yc1wiO1xuZXhwb3J0ICogYXMgZGVjb3JhdG9ycyBmcm9tIFwiLi9kZWNvcmF0b3JzXCI7XG4iXSwKICAibWFwcGluZ3MiOiAiQUFBQSxjQUFjO0FBQ2QsU0FBaUIsWUFBWTtBQUM3QixjQUFjO0FBQ2QsY0FBYztBQUNkLFlBQVksZ0JBQWdCOyIsCiAgIm5hbWVzIjogW10KfQo=

package/dist/esm/security/oauth.mjs

@@ -0,0 +1,56 @@
+import { client as httpClient } from "@aerokit/sdk/http";
+import { url } from "@aerokit/sdk/utils";
+class OAuthClient {
+  /**
+   * Initializes the OAuthClient with the required configuration.
+   * Sets 'client_credentials' as the default grant type if none is provided.
+   *
+   * @param config The configuration object containing URL, client ID, and secret.
+   */
+  constructor(config) {
+    this.config = config;
+    if (!config.grantType) {
+      config.grantType = "client_credentials";
+    }
+  }
+  /**
+   * Executes the OAuth token request and returns the parsed response.
+   *
+   * The request uses the client credentials grant type (default) and
+   * sends credentials as URL-encoded parameters in the body.
+   *
+   * @returns A parsed JSON object containing the OAuth token (e.g., { access_token: string, expires_in: number, ... }).
+   * @throws {Error} If the HTTP status code is not 200.
+   */
+  getToken() {
+    const params = [{
+      name: "grant_type",
+      value: this.config.grantType
+    }, {
+      name: "client_id",
+      // The client ID is URL-encoded
+      value: url.encode(this.config.clientId)
+    }, {
+      name: "client_secret",
+      // The client secret is URL-encoded
+      value: url.encode(this.config.clientSecret)
+    }];
+    const oauthResponse = httpClient.post(this.config.url, {
+      params,
+      headers: [{
+        name: "Content-Type",
+        value: "application/x-www-form-urlencoded"
+      }]
+    });
+    if (oauthResponse.statusCode !== 200) {
+      const errorMessage = `Error occurred while retrieving OAuth token. Status code: [${oauthResponse.statusCode}], text: [${oauthResponse.text}]`;
+      console.error(errorMessage);
+      throw new Error(errorMessage);
+    }
+    return JSON.parse(oauthResponse.text);
+  }
+}
+export {
+  OAuthClient
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/security/user.mjs

@@ -0,0 +1,69 @@
+const UserFacade = Java.type("org.eclipse.dirigible.components.api.security.UserFacade");
+class User {
+  /**
+   * Retrieves the principal name (username or ID) of the currently authenticated user.
+   *
+   * @returns The user's name or identifier as a string.
+   */
+  static getName() {
+    return UserFacade.getName();
+  }
+  /**
+   * Checks if the currently authenticated user is assigned to a specific security role.
+   *
+   * @param role The name of the role to check (e.g., 'Administrator', 'User').
+   * @returns True if the user is in the specified role, false otherwise.
+   */
+  static isInRole(role) {
+    return UserFacade.isInRole(role);
+  }
+  /**
+   * Retrieves the remaining session timeout for the current user session in seconds.
+   *
+   * @returns The session timeout duration in seconds.
+   */
+  static getTimeout() {
+    return UserFacade.getTimeout();
+  }
+  /**
+   * Retrieves the authentication mechanism used for the current session (e.g., 'BASIC', 'FORM').
+   *
+   * @returns The type of authentication used.
+   */
+  static getAuthType() {
+    return UserFacade.getAuthType();
+  }
+  /**
+   * Retrieves the security token associated with the current user session.
+   * This might be a session ID or an access token.
+   *
+   * @returns The security token as a string.
+   */
+  static getSecurityToken() {
+    return UserFacade.getSecurityToken();
+  }
+  /**
+   * Retrieves the number of requests (invocations) made by the current user
+   * during the lifecycle of the current session.
+   *
+   * @returns The total invocation count.
+   */
+  static getInvocationCount() {
+    return UserFacade.getInvocationCount();
+  }
+  /**
+   * Retrieves the preferred language setting (e.g., 'en', 'de', 'es') for the current user.
+   *
+   * @returns The user's preferred language code.
+   */
+  static getLanguage() {
+    return UserFacade.getLanguage();
+  }
+}
+if (typeof module !== "undefined") {
+  module.exports = User;
+}
+export {
+  User
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/template/engines.mjs

@@ -0,0 +1,120 @@
+import { Repository } from "@aerokit/sdk/platform/repository";
+const REGISTRY_PUBLIC = "/registry/public/";
+const MUSTACHE_FILE_EXTENSION = ".mustache";
+const TemplateEnginesFacade = Java.type("org.eclipse.dirigible.components.api.templates.TemplateEnginesFacade");
+class TemplateEngine {
+  /**
+   * Creates an instance of TemplateEngine.
+   *
+   * @param engine The native template engine object from the Facade.
+   * @param type The type of the engine ('mustache', 'velocity', 'javascript').
+   */
+  constructor(engine, type) {
+    this.engine = engine;
+    this.sm = type === "mustache" ? "{{" : null;
+    this.em = type === "mustache" ? "}}" : null;
+  }
+  /**
+   * Generates the final output by executing the template with the provided parameters.
+   * Note: Parameters are internally serialized to JSON before being passed to the native engine.
+   *
+   * @param location A string identifying the template (used for error reporting/caching, often a file path).
+   * @param template The raw template string content to process.
+   * @param parameters An object containing the context data to be used in the template.
+   * @returns The processed output string.
+   */
+  generate(location, template, parameters) {
+    return this.engine.generate(location, template, JSON.stringify(parameters), this.sm, this.em);
+  }
+  /**
+   * Sets a custom start marker for the template engine. This is primarily useful for Mustache.
+   *
+   * @param sm The new start marker string.
+   */
+  setSm(sm) {
+    this.sm = sm;
+  }
+  /**
+   * Sets a custom end marker for the template engine. This is primarily useful for Mustache.
+   *
+   * @param em The new end marker string.
+   */
+  setEm(em) {
+    this.em = em;
+  }
+}
+class TemplateEngines {
+  /**
+   * Retrieves the default template engine, which is currently the Velocity engine.
+   *
+   * @returns The default template engine instance.
+   */
+  static getDefaultEngine() {
+    return this.getVelocityEngine();
+  }
+  /**
+   * Retrieves the Mustache template engine instance.
+   * Mustache is often used for logic-less templating and uses '{{' and '}}' as default markers.
+   *
+   * @returns The Mustache template engine instance.
+   */
+  static getMustacheEngine() {
+    const engine = TemplateEnginesFacade.getMustacheEngine();
+    return new TemplateEngine(engine, "mustache");
+  }
+  /**
+   * Retrieves the Velocity template engine instance.
+   * Velocity is often used for complex templating with directives (e.g., #set, #foreach).
+   *
+   * @returns The Velocity template engine instance.
+   */
+  static getVelocityEngine() {
+    const engine = TemplateEnginesFacade.getVelocityEngine();
+    return new TemplateEngine(engine, "velocity");
+  }
+  /**
+   * Retrieves the JavaScript template engine instance (usually used for server-side evaluation).
+   *
+   * @returns The JavaScript template engine instance.
+   */
+  static getJavascriptEngine() {
+    const engine = TemplateEnginesFacade.getJavascriptEngine();
+    return new TemplateEngine(engine, "javascript");
+  }
+  /**
+   * Generates output by processing a raw template string using the **default template engine (Velocity)**.
+   *
+   * @param location A string identifying the template (used for error reporting/caching, often a file path).
+   * @param template The raw template string content to process.
+   * @param parameters An object containing key-value pairs to be used as context variables in the template.
+   * @returns The processed output string.
+   */
+  static generate(location, template, parameters) {
+    return this.getDefaultEngine().generate(location, template, parameters);
+  }
+  /**
+   * Loads a template from the public registry, selects an appropriate engine, and generates output.
+   * It uses the **Mustache engine** if the file extension is `.mustache`, otherwise it uses the **default (Velocity)**.
+   *
+   * @param location The path to the template file within the `/registry/public/` directory (e.g., 'templates/email.mustache').
+   * @param parameters An object containing key-value pairs to be used as context variables in the template.
+   * @returns The processed output string, or `undefined` if the resource does not exist.
+   */
+  static generateFromFile(location, parameters) {
+    const resource = Repository.getResource(REGISTRY_PUBLIC + location);
+    if (resource.exists()) {
+      const isMustacheTemplate = location.endsWith(MUSTACHE_FILE_EXTENSION);
+      const engine = isMustacheTemplate ? this.getMustacheEngine() : this.getDefaultEngine();
+      const template = resource.getText();
+      return engine.generate(location, template, parameters);
+    }
+    return void 0;
+  }
+}
+if (typeof module !== "undefined") {
+  module.exports = TemplateEngines;
+}
+export {
+  TemplateEngines
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/template/engines.ts"],
  "sourcesContent": ["import { Repository } from \"@aerokit/sdk/platform/repository\";\n\nconst REGISTRY_PUBLIC = \"/registry/public/\";\nconst MUSTACHE_FILE_EXTENSION = \".mustache\";\n\nconst TemplateEnginesFacade = Java.type(\"org.eclipse.dirigible.components.api.templates.TemplateEnginesFacade\");\n\n/**\n * An internal wrapper class that adapts a native template engine implementation.\n * It manages the engine instance and optional custom start/end markers.\n */\nclass TemplateEngine {\n\n    private engine: any;\n    /** The start marker string (e.g., '{{' for Mustache). */\n    private sm: string | null;\n    /** The end marker string (e.g., '}}' for Mustache). */\n    private em: string | null;\n\n    /**\n     * Creates an instance of TemplateEngine.\n     *\n     * @param engine The native template engine object from the Facade.\n     * @param type The type of the engine ('mustache', 'velocity', 'javascript').\n     */\n    constructor(engine: any, type: string) {\n        this.engine = engine;\n        // Default markers for Mustache engine\n        this.sm = type === \"mustache\" ? \"{{\" : null;\n        this.em = type === \"mustache\" ? \"}}\" : null;\n    }\n\n    /**\n     * Generates the final output by executing the template with the provided parameters.\n     * Note: Parameters are internally serialized to JSON before being passed to the native engine.\n     *\n     * @param location A string identifying the template (used for error reporting/caching, often a file path).\n     * @param template The raw template string content to process.\n     * @param parameters An object containing the context data to be used in the template.\n     * @returns The processed output string.\n     */\n    public generate(location: string, template: string, parameters: { [key: string]: any }): string {\n        return this.engine.generate(location, template, JSON.stringify(parameters), this.sm, this.em);\n    }\n\n    /**\n     * Sets a custom start marker for the template engine. This is primarily useful for Mustache.\n     *\n     * @param sm The new start marker string.\n     */\n    public setSm(sm: any) {\n        this.sm = sm;\n    }\n\n    /**\n     * Sets a custom end marker for the template engine. This is primarily useful for Mustache.\n     *\n     * @param em The new end marker string.\n     */\n    public setEm(em: any) {\n        this.em = em;\n    }\n}\n\n/**\n * Provides access to various server-side template engines (Velocity, Mustache, JavaScript).\n * It offers utility methods for generating content from templates directly or from files\n * stored in the registry.\n */\nexport class TemplateEngines {\n\n    /**\n     * Retrieves the default template engine, which is currently the Velocity engine.\n     *\n     * @returns The default template engine instance.\n     */\n    public static getDefaultEngine(): TemplateEngine {\n        return this.getVelocityEngine();\n    }\n\n    /**\n     * Retrieves the Mustache template engine instance.\n     * Mustache is often used for logic-less templating and uses '{{' and '}}' as default markers.\n     *\n     * @returns The Mustache template engine instance.\n     */\n    public static getMustacheEngine(): TemplateEngine {\n        const engine = TemplateEnginesFacade.getMustacheEngine();\n        return new TemplateEngine(engine, \"mustache\");\n    }\n\n    /**\n     * Retrieves the Velocity template engine instance.\n     * Velocity is often used for complex templating with directives (e.g., #set, #foreach).\n     *\n     * @returns The Velocity template engine instance.\n     */\n    public static getVelocityEngine(): TemplateEngine {\n        const engine = TemplateEnginesFacade.getVelocityEngine();\n        return new TemplateEngine(engine, \"velocity\");\n    }\n\n    /**\n     * Retrieves the JavaScript template engine instance (usually used for server-side evaluation).\n     *\n     * @returns The JavaScript template engine instance.\n     */\n    public static getJavascriptEngine(): TemplateEngine {\n        const engine = TemplateEnginesFacade.getJavascriptEngine();\n        return new TemplateEngine(engine, \"javascript\");\n    }\n\n    /**\n     * Generates output by processing a raw template string using the **default template engine (Velocity)**.\n     *\n     * @param location A string identifying the template (used for error reporting/caching, often a file path).\n     * @param template The raw template string content to process.\n     * @param parameters An object containing key-value pairs to be used as context variables in the template.\n     * @returns The processed output string.\n     */\n    public static generate(location: string, template: string, parameters: { [key: string]: any }): string {\n        return this.getDefaultEngine().generate(location, template, parameters);\n    }\n\n    /**\n     * Loads a template from the public registry, selects an appropriate engine, and generates output.\n     * It uses the **Mustache engine** if the file extension is `.mustache`, otherwise it uses the **default (Velocity)**.\n     *\n     * @param location The path to the template file within the `/registry/public/` directory (e.g., 'templates/email.mustache').\n     * @param parameters An object containing key-value pairs to be used as context variables in the template.\n     * @returns The processed output string, or `undefined` if the resource does not exist.\n     */\n    public static generateFromFile(location: string, parameters: { [key: string]: any }): string | undefined {\n        const resource = Repository.getResource(REGISTRY_PUBLIC + location);\n        if (resource.exists()) {\n            const isMustacheTemplate = location.endsWith(MUSTACHE_FILE_EXTENSION);\n            const engine = isMustacheTemplate ? this.getMustacheEngine() : this.getDefaultEngine();\n            const template = resource.getText();\n            return engine.generate(location, template, parameters);\n        }\n        return undefined;\n    }\n}\n\n// @ts-ignore\nif (typeof module !== 'undefined') {\n\t// @ts-ignore\n\tmodule.exports = TemplateEngines;\n}\n"],
  "mappings": "AAAA,SAAS,kBAAkB;AAE3B,MAAM,kBAAkB;AACxB,MAAM,0BAA0B;AAEhC,MAAM,wBAAwB,KAAK,KAAK,sEAAsE;AAM9G,MAAM,eAAe;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAcjB,YAAY,QAAa,MAAc;AACnC,SAAK,SAAS;AAEd,SAAK,KAAK,SAAS,aAAa,OAAO;AACvC,SAAK,KAAK,SAAS,aAAa,OAAO;AAAA,EAC3C;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAWO,SAAS,UAAkB,UAAkB,YAA4C;AAC5F,WAAO,KAAK,OAAO,SAAS,UAAU,UAAU,KAAK,UAAU,UAAU,GAAG,KAAK,IAAI,KAAK,EAAE;AAAA,EAChG;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOO,MAAM,IAAS;AAClB,SAAK,KAAK;AAAA,EACd;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOO,MAAM,IAAS;AAClB,SAAK,KAAK;AAAA,EACd;AACJ;AAOO,MAAM,gBAAgB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOzB,OAAc,mBAAmC;AAC7C,WAAO,KAAK,kBAAkB;AAAA,EAClC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,OAAc,oBAAoC;AAC9C,UAAM,SAAS,sBAAsB,kBAAkB;AACvD,WAAO,IAAI,eAAe,QAAQ,UAAU;AAAA,EAChD;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,OAAc,oBAAoC;AAC9C,UAAM,SAAS,sBAAsB,kBAAkB;AACvD,WAAO,IAAI,eAAe,QAAQ,UAAU;AAAA,EAChD;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,OAAc,sBAAsC;AAChD,UAAM,SAAS,sBAAsB,oBAAoB;AACzD,WAAO,IAAI,eAAe,QAAQ,YAAY;AAAA,EAClD;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAUA,OAAc,SAAS,UAAkB,UAAkB,YAA4C;AACnG,WAAO,KAAK,iBAAiB,EAAE,SAAS,UAAU,UAAU,UAAU;AAAA,EAC1E;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAUA,OAAc,iBAAiB,UAAkB,YAAwD;AACrG,UAAM,WAAW,WAAW,YAAY,kBAAkB,QAAQ;AAClE,QAAI,SAAS,OAAO,GAAG;AACnB,YAAM,qBAAqB,SAAS,SAAS,uBAAuB;AACpE,YAAM,SAAS,qBAAqB,KAAK,kBAAkB,IAAI,KAAK,iBAAiB;AACrF,YAAM,WAAW,SAAS,QAAQ;AAClC,aAAO,OAAO,SAAS,UAAU,UAAU,UAAU;AAAA,IACzD;AACA,WAAO;AAAA,EACX;AACJ;AAGA,IAAI,OAAO,WAAW,aAAa;AAElC,SAAO,UAAU;AAClB;",
  "names": []
}


package/dist/esm/template/index.mjs

@@ -0,0 +1,6 @@
+import { TemplateEngines } from "./engines";
+export * from "./engines";
+export {
+  TemplateEngines as engines
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vc3JjL3RlbXBsYXRlL2luZGV4LnRzIl0sCiAgInNvdXJjZXNDb250ZW50IjogWyJleHBvcnQgeyBUZW1wbGF0ZUVuZ2luZXMgYXMgZW5naW5lcyB9IGZyb20gXCIuL2VuZ2luZXNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2VuZ2luZXNcIjsiXSwKICAibWFwcGluZ3MiOiAiQUFBQSxTQUE0Qix1QkFBZTtBQUMzQyxjQUFjOyIsCiAgIm5hbWVzIjogW10KfQo=

package/dist/esm/utils/alphanumeric.mjs

@@ -0,0 +1,88 @@
+let LOWERCASEASCII = "abcdefghijklmnopqrstuvwxyz";
+const UPPERCASEASCII = LOWERCASEASCII.toUpperCase();
+const NUMBERS = "1234567890";
+class Alphanumeric {
+  static toAlphanumeric(string) {
+    return string.replace(/[^A-Za-z0-9_]/g, "");
+  }
+  /**
+   * Generates a random alphanumeric sequence with the specified length
+   * @param length {Integer} Defaults to 4
+   */
+  static randomString(length, charset) {
+    let text = "";
+    if (length < 1)
+      length = 4;
+    for (var i = 0; i < length; i++)
+      text += charset.charAt(Math.floor(Math.random() * charset.length));
+    return text;
+  }
+  /**
+   * Generates a random alphanumeric sequence with the specified length
+   * @param length {Integer} Defaults to 4
+   * @param lowercase {Boolean} Defaults to true
+   */
+  static alphanumeric(length, lowercase) {
+    let charset = LOWERCASEASCII + NUMBERS;
+    if (!lowercase) {
+      charset += UPPERCASEASCII;
+    }
+    return Alphanumeric.randomString(length, charset);
+  }
+  /**
+   * Generates a random ASCII sequence with the specified length
+   * @param length {Integer} Defaults to 4
+   * @param lowercase {Boolean} Defaults to true
+   */
+  static alpha(length, lowercase) {
+    let charset = LOWERCASEASCII;
+    if (!lowercase) {
+      charset += UPPERCASEASCII;
+    }
+    return Alphanumeric.randomString(length, charset);
+  }
+  /**
+   * Generates a random numeric value
+   * @param length {Integer} Defaults to 4
+   */
+  static numeric(length) {
+    return Alphanumeric.randomString(length, NUMBERS);
+  }
+  /**
+   * Tests is the provided `str` argument is a valid numeric sequence.
+   * @param str {String} the string to test
+   */
+  static isNumeric(str) {
+    let code, i, len;
+    for (i = 0, len = str.length; i < len; i++) {
+      code = str.charCodeAt(i);
+      if (!(code > 47 && code < 58)) {
+        return false;
+      }
+    }
+    return true;
+  }
+  /**
+   * Tests is the provided `str` argument is a valid alphanumeric sequence.
+   * @param str {String} the string to test
+   */
+  static isAlphanumeric(str) {
+    let code, i, len;
+    for (i = 0, len = str.length; i < len; i++) {
+      code = str.charCodeAt(i);
+      if (!(code > 47 && code < 58) && // numeric (0-9)
+      !(code > 64 && code < 91) && // upper alpha (A-Z)
+      !(code > 96 && code < 123)) {
+        return false;
+      }
+    }
+    return true;
+  }
+}
+if (typeof module !== "undefined") {
+  module.exports = Alphanumeric;
+}
+export {
+  Alphanumeric
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vc3JjL3V0aWxzL2FscGhhbnVtZXJpYy50cyJdLAogICJzb3VyY2VzQ29udGVudCI6IFsiLyoqXG4gKiBUcmFuc2Zvcm1zIGEgc3RyaW5nIHRvIGFuIGFscGhhbnVtZXJpYyBzZXF1ZW5jZSwgc3RyaXBwaW5nIG5vbi1jb25mb3JtYW50IGNoYXJhY3RlcnMgZm9yIGl0LlxuICogQHBhcmFtIHN0cmluZyB7U3RyaW5nfSB0aGUgc3RyaW5nIHRvIHRyYW5zZm9ybVxuICovXG5cbmxldCBMT1dFUkNBU0VBU0NJSSA9IFwiYWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXpcIjtcbmNvbnN0IFVQUEVSQ0FTRUFTQ0lJID0gTE9XRVJDQVNFQVNDSUkudG9VcHBlckNhc2UoKTtcbmNvbnN0IE5VTUJFUlMgPSBcIjEyMzQ1Njc4OTBcIjtcblxuZXhwb3J0IGNsYXNzIEFscGhhbnVtZXJpYyB7XG5cblx0cHVibGljIHN0YXRpYyB0b0FscGhhbnVtZXJpYyhzdHJpbmc6IHN0cmluZyk6IHN0cmluZyB7XG5cdFx0cmV0dXJuIHN0cmluZy5yZXBsYWNlKC9bXkEtWmEtejAtOV9dL2csICcnKTtcblx0fVxuXG5cdC8qKlxuXHQgKiBHZW5lcmF0ZXMgYSByYW5kb20gYWxwaGFudW1lcmljIHNlcXVlbmNlIHdpdGggdGhlIHNwZWNpZmllZCBsZW5ndGhcblx0ICogQHBhcmFtIGxlbmd0aCB7SW50ZWdlcn0gRGVmYXVsdHMgdG8gNFxuXHQgKi9cblx0cHVibGljIHN0YXRpYyByYW5kb21TdHJpbmcobGVuZ3RoOiBudW1iZXIsIGNoYXJzZXQ6IHN0cmluZyk6IHN0cmluZyB7XG5cdFx0bGV0IHRleHQgPSBcIlwiO1xuXHRcdGlmIChsZW5ndGggPCAxKVxuXHRcdFx0bGVuZ3RoID0gNDtcblx0XHRmb3IgKHZhciBpID0gMDsgaSA8IGxlbmd0aDsgaSsrKVxuXHRcdFx0dGV4dCArPSBjaGFyc2V0LmNoYXJBdChNYXRoLmZsb29yKE1hdGgucmFuZG9tKCkgKiBjaGFyc2V0Lmxlbmd0aCkpO1xuXHRcdHJldHVybiB0ZXh0O1xuXHR9XG5cblx0LyoqXG5cdCAqIEdlbmVyYXRlcyBhIHJhbmRvbSBhbHBoYW51bWVyaWMgc2VxdWVuY2Ugd2l0aCB0aGUgc3BlY2lmaWVkIGxlbmd0aFxuXHQgKiBAcGFyYW0gbGVuZ3RoIHtJbnRlZ2VyfSBEZWZhdWx0cyB0byA0XG5cdCAqIEBwYXJhbSBsb3dlcmNhc2Uge0Jvb2xlYW59IERlZmF1bHRzIHRvIHRydWVcblx0ICovXG5cdHB1YmxpYyBzdGF0aWMgYWxwaGFudW1lcmljKGxlbmd0aDogbnVtYmVyLCBsb3dlcmNhc2U6IGJvb2xlYW4pOiBzdHJpbmcge1xuXHRcdGxldCBjaGFyc2V0ID0gTE9XRVJDQVNFQVNDSUkgKyBOVU1CRVJTO1xuXHRcdGlmICghbG93ZXJjYXNlKSB7XG5cdFx0XHRjaGFyc2V0ICs9IFVQUEVSQ0FTRUFTQ0lJO1xuXHRcdH1cblx0XHRyZXR1cm4gQWxwaGFudW1lcmljLnJhbmRvbVN0cmluZyhsZW5ndGgsIGNoYXJzZXQpO1xuXHR9XG5cblx0LyoqXG5cdCAqIEdlbmVyYXRlcyBhIHJhbmRvbSBBU0NJSSBzZXF1ZW5jZSB3aXRoIHRoZSBzcGVjaWZpZWQgbGVuZ3RoXG5cdCAqIEBwYXJhbSBsZW5ndGgge0ludGVnZXJ9IERlZmF1bHRzIHRvIDRcblx0ICogQHBhcmFtIGxvd2VyY2FzZSB7Qm9vbGVhbn0gRGVmYXVsdHMgdG8gdHJ1ZVxuXHQgKi9cblx0cHVibGljIHN0YXRpYyBhbHBoYShsZW5ndGg6IG51bWJlciwgbG93ZXJjYXNlOiBib29sZWFuKTogc3RyaW5nIHtcblx0XHRsZXQgY2hhcnNldCA9IExPV0VSQ0FTRUFTQ0lJO1xuXHRcdGlmICghbG93ZXJjYXNlKSB7XG5cdFx0XHRjaGFyc2V0ICs9IFVQUEVSQ0FTRUFTQ0lJO1xuXHRcdH1cblx0XHRyZXR1cm4gQWxwaGFudW1lcmljLnJhbmRvbVN0cmluZyhsZW5ndGgsIGNoYXJzZXQpO1xuXHR9XG5cblx0LyoqXG5cdCAqIEdlbmVyYXRlcyBhIHJhbmRvbSBudW1lcmljIHZhbHVlXG5cdCAqIEBwYXJhbSBsZW5ndGgge0ludGVnZXJ9IERlZmF1bHRzIHRvIDRcblx0ICovXG5cdHB1YmxpYyBzdGF0aWMgbnVtZXJpYyhsZW5ndGg6IG51bWJlcik6IHN0cmluZyB7XG5cdFx0cmV0dXJuIEFscGhhbnVtZXJpYy5yYW5kb21TdHJpbmcobGVuZ3RoLCBOVU1CRVJTKTtcblx0fVxuXG5cdC8qKlxuXHQgKiBUZXN0cyBpcyB0aGUgcHJvdmlkZWQgYHN0cmAgYXJndW1lbnQgaXMgYSB2YWxpZCBudW1lcmljIHNlcXVlbmNlLlxuXHQgKiBAcGFyYW0gc3RyIHtTdHJpbmd9IHRoZSBzdHJpbmcgdG8gdGVzdFxuXHQgKi9cblx0cHVibGljIHN0YXRpYyBpc051bWVyaWMoc3RyOiBzdHJpbmcpOiBib29sZWFuIHtcblx0XHQvLyBhIGZhc3RlciBhbHRlcm5hdGl2ZSB0byBjaGVja2luZyB3aXRoICAvW15hLXpBLVowLTldLy50ZXN0KHN0cilcblx0XHQvLyBjb3B5IGZyb20gcHVibGljIGRvbWFpbiBhdDogaHR0cHM6Ly9zdGFja292ZXJmbG93LmNvbS9hLzI1MzUyMzAwXG5cdFx0bGV0IGNvZGUsIGksIGxlbjtcblx0XHRmb3IgKGkgPSAwLCBsZW4gPSBzdHIubGVuZ3RoOyBpIDwgbGVuOyBpKyspIHtcblx0XHRcdGNvZGUgPSBzdHIuY2hhckNvZGVBdChpKTtcblx0XHRcdGlmICghKGNvZGUgPiA0NyAmJiBjb2RlIDwgNTgpKSB7IC8vIG51bWVyaWMgKDAtOSlcblx0XHRcdFx0cmV0dXJuIGZhbHNlO1xuXHRcdFx0fVxuXHRcdH1cblx0XHRyZXR1cm4gdHJ1ZTtcblx0fVxuXG5cdC8qKlxuXHQgKiBUZXN0cyBpcyB0aGUgcHJvdmlkZWQgYHN0cmAgYXJndW1lbnQgaXMgYSB2YWxpZCBhbHBoYW51bWVyaWMgc2VxdWVuY2UuXG5cdCAqIEBwYXJhbSBzdHIge1N0cmluZ30gdGhlIHN0cmluZyB0byB0ZXN0XG5cdCAqL1xuXHRwdWJsaWMgc3RhdGljIGlzQWxwaGFudW1lcmljKHN0cjogc3RyaW5nKTogYm9vbGVhbiB7XG5cdFx0Ly8gYSBmYXN0ZXIgYWx0ZXJuYXRpdmUgdG8gY2hlY2tpbmcgd2l0aCAgL1teYS16QS1aMC05XS8udGVzdChzdHIpXG5cdFx0Ly8gY29weSBmcm9tIHB1YmxpYyBkb21haW4gYXQ6IGh0dHBzOi8vc3RhY2tvdmVyZmxvdy5jb20vYS8yNTM1MjMwMFxuXHRcdGxldCBjb2RlLCBpLCBsZW47XG5cdFx0Zm9yIChpID0gMCwgbGVuID0gc3RyLmxlbmd0aDsgaSA8IGxlbjsgaSsrKSB7XG5cdFx0XHRjb2RlID0gc3RyLmNoYXJDb2RlQXQoaSk7XG5cdFx0XHRpZiAoIShjb2RlID4gNDcgJiYgY29kZSA8IDU4KSAmJiAvLyBudW1lcmljICgwLTkpXG5cdFx0XHRcdCEoY29kZSA+IDY0ICYmIGNvZGUgPCA5MSkgJiYgLy8gdXBwZXIgYWxwaGEgKEEtWilcblx0XHRcdFx0IShjb2RlID4gOTYgJiYgY29kZSA8IDEyMykpIHsgLy8gbG93ZXIgYWxwaGEgKGEteilcblx0XHRcdFx0cmV0dXJuIGZhbHNlO1xuXHRcdFx0fVxuXHRcdH1cblx0XHRyZXR1cm4gdHJ1ZTtcblx0fVxufVxuXG4vLyBAdHMtaWdub3JlXG5pZiAodHlwZW9mIG1vZHVsZSAhPT0gJ3VuZGVmaW5lZCcpIHtcblx0Ly8gQHRzLWlnbm9yZVxuXHRtb2R1bGUuZXhwb3J0cyA9IEFscGhhbnVtZXJpYztcbn1cbiJdLAogICJtYXBwaW5ncyI6ICJBQUtBLElBQUksaUJBQWlCO0FBQ3JCLE1BQU0saUJBQWlCLGVBQWUsWUFBWTtBQUNsRCxNQUFNLFVBQVU7QUFFVCxNQUFNLGFBQWE7QUFBQSxFQUV6QixPQUFjLGVBQWUsUUFBd0I7QUFDcEQsV0FBTyxPQUFPLFFBQVEsa0JBQWtCLEVBQUU7QUFBQSxFQUMzQztBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUEsRUFNQSxPQUFjLGFBQWEsUUFBZ0IsU0FBeUI7QUFDbkUsUUFBSSxPQUFPO0FBQ1gsUUFBSSxTQUFTO0FBQ1osZUFBUztBQUNWLGFBQVMsSUFBSSxHQUFHLElBQUksUUFBUTtBQUMzQixjQUFRLFFBQVEsT0FBTyxLQUFLLE1BQU0sS0FBSyxPQUFPLElBQUksUUFBUSxNQUFNLENBQUM7QUFDbEUsV0FBTztBQUFBLEVBQ1I7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUEsRUFPQSxPQUFjLGFBQWEsUUFBZ0IsV0FBNEI7QUFDdEUsUUFBSSxVQUFVLGlCQUFpQjtBQUMvQixRQUFJLENBQUMsV0FBVztBQUNmLGlCQUFXO0FBQUEsSUFDWjtBQUNBLFdBQU8sYUFBYSxhQUFhLFFBQVEsT0FBTztBQUFBLEVBQ2pEO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBLEVBT0EsT0FBYyxNQUFNLFFBQWdCLFdBQTRCO0FBQy9ELFFBQUksVUFBVTtBQUNkLFFBQUksQ0FBQyxXQUFXO0FBQ2YsaUJBQVc7QUFBQSxJQUNaO0FBQ0EsV0FBTyxhQUFhLGFBQWEsUUFBUSxPQUFPO0FBQUEsRUFDakQ7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBLEVBTUEsT0FBYyxRQUFRLFFBQXdCO0FBQzdDLFdBQU8sYUFBYSxhQUFhLFFBQVEsT0FBTztBQUFBLEVBQ2pEO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQSxFQU1BLE9BQWMsVUFBVSxLQUFzQjtBQUc3QyxRQUFJLE1BQU0sR0FBRztBQUNiLFNBQUssSUFBSSxHQUFHLE1BQU0sSUFBSSxRQUFRLElBQUksS0FBSyxLQUFLO0FBQzNDLGFBQU8sSUFBSSxXQUFXLENBQUM7QUFDdkIsVUFBSSxFQUFFLE9BQU8sTUFBTSxPQUFPLEtBQUs7QUFDOUIsZUFBTztBQUFBLE1BQ1I7QUFBQSxJQUNEO0FBQ0EsV0FBTztBQUFBLEVBQ1I7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBLEVBTUEsT0FBYyxlQUFlLEtBQXNCO0FBR2xELFFBQUksTUFBTSxHQUFHO0FBQ2IsU0FBSyxJQUFJLEdBQUcsTUFBTSxJQUFJLFFBQVEsSUFBSSxLQUFLLEtBQUs7QUFDM0MsYUFBTyxJQUFJLFdBQVcsQ0FBQztBQUN2QixVQUFJLEVBQUUsT0FBTyxNQUFNLE9BQU87QUFBQSxNQUN6QixFQUFFLE9BQU8sTUFBTSxPQUFPO0FBQUEsTUFDdEIsRUFBRSxPQUFPLE1BQU0sT0FBTyxNQUFNO0FBQzVCLGVBQU87QUFBQSxNQUNSO0FBQUEsSUFDRDtBQUNBLFdBQU87QUFBQSxFQUNSO0FBQ0Q7QUFHQSxJQUFJLE9BQU8sV0FBVyxhQUFhO0FBRWxDLFNBQU8sVUFBVTtBQUNsQjsiLAogICJuYW1lcyI6IFtdCn0K