@aerokit/sdk 14.76.0 → 14.81.0

package/dist/cjs/core/configurations.js

@@ -21,6 +21,7 @@ __export(configurations_exports, {
 });
 module.exports = __toCommonJS(configurations_exports);
 const Configuration = Java.type("org.eclipse.dirigible.commons.config.Configuration");
+const ConfigurationsFacade = Java.type("org.eclipse.dirigible.components.api.core.ConfigurationsFacade");
 class Configurations {
   /**
    * Retrieves the configuration value associated with the given key.
@@ -55,6 +56,23 @@ class Configurations {
   static getKeys() {
     return Configuration.getKeys();
   }
+  /**
+   * Retrieves the configuration groups, in display order, with the number of keys and of set keys in each.
+   * @returns The groups.
+   */
+  static getGroups() {
+    return JSON.parse(ConfigurationsFacade.getGroups());
+  }
+  /**
+   * Retrieves the described configuration keys, grouped: default, effective value, its source and the value
+   * of each source. Sensitive values are masked.
+   * @param group A group id (e.g. "database") or several; all groups when omitted.
+   * @returns The groups that have keys.
+   */
+  static getDescriptors(group) {
+    const groups = group === void 0 ? null : Array.isArray(group) ? group.join(",") : group;
+    return JSON.parse(ConfigurationsFacade.getDescriptors(groups));
+  }
   /**
    * Loads configuration properties from a file at the specified path, overriding existing ones.
    * @param path The file path to load configurations from.
@@ -107,4 +125,4 @@ class Configurations {
 if (typeof module !== "undefined") {
   module.exports = Configurations;
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/core/configurations.ts"],
  "sourcesContent": ["/**\n * @module core/configurations\n * @package @aerokit/sdk/core\n * @name Configurations\n * @overview\n * \n * The Configurations API provides a centralized, type-safe interface for managing application configuration properties and detecting the runtime operating system. It serves as the foundation for environment-specific settings and system-aware behavior in Aerokit applications.\n * \n * ### Key Features\n * \n * - **Static Interface**: Thread-safe, singleton-like access to configuration data\n * - **Type Safety**: Full TypeScript support with proper type definitions\n * - **File Loading**: Support for loading configurations from external files\n * - **OS Detection**: Comprehensive operating system identification\n * - **Memory Efficient**: In-memory storage with optional persistence\n * \n * ### Use Cases\n * - Application configuration management\n * - Environment variable management\n * - Feature flag configuration\n * - Database connection settings\n * - API endpoint configuration\n * - Platform-specific behavior adaptation\n * \n * ### Example Usage\n * ```ts\n * import { Configurations } from \"@aerokit/sdk/core\";\n * \n * // Set a configuration property\n * Configurations.set(\"apiEndpoint\", \"https://api.example.com\");\n * // Get a configuration property\n * const apiEndpoint = Configurations.get(\"apiEndpoint\");\n * console.log(apiEndpoint); // Output: \"https://api.example.com\"\n * \n * // Check the operating system\n * if (Configurations.isOSWindows()) {\n *   console.log(\"Running on Windows\");\n * } else if (Configurations.isOSMac()) {\n *   console.log(\"Running on Mac\");\n * } else if (Configurations.isOSUNIX()) {\n *   console.log(\"Running on UNIX\");\n * }\n * ```\n*/\n\nconst Configuration = Java.type(\"org.eclipse.dirigible.commons.config.Configuration\");\nconst ConfigurationsFacade = Java.type(\"org.eclipse.dirigible.components.api.core.ConfigurationsFacade\");\n\n/**\n * A configuration group with the number of its keys and of the keys any source sets.\n */\nexport interface ConfigurationGroup {\n\tid: string;\n\tsection: string;\n\tlabel: string;\n\torder: number;\n\ttotal: number;\n\tset: number;\n}\n\n/**\n * A described configuration key. Every value is masked as \"********\" when the key is sensitive.\n */\nexport interface ConfigurationDescriptor {\n\tkey: string;\n\tsubgroup?: string;\n\ttype?: string;\n\tdefaultValue?: string;\n\t/** The effective value. */\n\tvalue?: string;\n\t/** Where the effective value comes from. */\n\tsource: \"runtime\" | \"environment\" | \"deployment\" | \"module\" | \"default\" | \"unset\";\n\t/** The value each source gives the key. */\n\tvalues: { runtime?: string; environment?: string; deployment?: string; module?: string };\n\tsensitive: boolean;\n\trestartRequired?: boolean;\n\ttenantOverridable: boolean;\n\tdeprecatedBy?: string;\n}\n\n/**\n * A configuration group with its described keys.\n */\nexport interface ConfigurationDescriptorGroup {\n\tgroup: string;\n\tsection: string;\n\tlabel: string;\n\tentries: ConfigurationDescriptor[];\n}\n\nexport class Configurations {\n\n\t/**\n\t * Retrieves the configuration value associated with the given key.\n\t * @param key The configuration key.\n\t * @param defaultValue The optional default value to return if the key is not found.\n\t * @returns The configuration value as a string, or `undefined` if the key is not found and no default is provided.\n\t */\n\tpublic static get(key: string, defaultValue?: string): string | undefined {\n\t\tconst value = Configuration.get(key, defaultValue);\n\t\treturn value ?? undefined;\n\t}\n\n\t/**\n\t * Sets the configuration value for the given key.\n\t * If the key already exists, its value is overwritten.\n\t * @param key The configuration key.\n\t * @param value The configuration value to set.\n\t */\n\tpublic static set(key: string, value: string): void {\n\t\tConfiguration.set(key, value);\n\t}\n\n\t/**\n\t * Removes the configuration property associated with the given key.\n\t * @param key The configuration key to remove.\n\t */\n\tpublic static remove(key: string): void {\n\t\tConfiguration.remove(key);\n\t}\n\n\t/**\n\t * Retrieves a list of all current configuration keys.\n\t * @returns An array of configuration keys (strings).\n\t */\n\tpublic static getKeys(): string[] {\n\t\treturn Configuration.getKeys();\n\t}\n\n\t/**\n\t * Retrieves the configuration groups, in display order, with the number of keys and of set keys in each.\n\t * @returns The groups.\n\t */\n\tpublic static getGroups(): ConfigurationGroup[] {\n\t\treturn JSON.parse(ConfigurationsFacade.getGroups());\n\t}\n\n\t/**\n\t * Retrieves the described configuration keys, grouped: default, effective value, its source and the value\n\t * of each source. Sensitive values are masked.\n\t * @param group A group id (e.g. \"database\") or several; all groups when omitted.\n\t * @returns The groups that have keys.\n\t */\n\tpublic static getDescriptors(group?: string | string[]): ConfigurationDescriptorGroup[] {\n\t\tconst groups = group === undefined ? null : Array.isArray(group) ? group.join(\",\") : group;\n\t\treturn JSON.parse(ConfigurationsFacade.getDescriptors(groups));\n\t}\n\n\t/**\n\t * Loads configuration properties from a file at the specified path, overriding existing ones.\n\t * @param path The file path to load configurations from.\n\t */\n\tpublic static load(path: string): void {\n\t\tConfiguration.load(path);\n\t}\n\n\t/**\n\t * Reloads or updates the current configuration settings from their source (e.g., persistence layer).\n\t */\n\tpublic static update(): void {\n\t\tConfiguration.update();\n\t}\n\n\t/**\n\t * Retrieves the name of the current Operating System.\n\t * @returns The OS name as a string (e.g., \"Windows\", \"Linux\", \"Mac OS X\").\n\t */\n\tpublic static getOS(): string {\n\t\treturn Configuration.getOS();\n\t}\n\n\t/**\n\t * Checks if the current Operating System is Windows.\n\t * @returns True if the OS is Windows, false otherwise.\n\t */\n\tpublic static isOSWindows(): boolean {\n\t\treturn Configuration.isOSWindows();\n\t}\n\n\t/**\n\t * Checks if the current Operating System is Mac OS (or Mac OS X).\n\t * @returns True if the OS is Mac, false otherwise.\n\t */\n\tpublic static isOSMac(): boolean {\n\t\treturn Configuration.isOSMac();\n\t}\n\n\t/**\n\t * Checks if the current Operating System is a UNIX-like system (e.g., Linux, macOS, or others).\n\t * @returns True if the OS is a UNIX variant, false otherwise.\n\t */\n\tpublic static isOSUNIX(): boolean {\n\t\treturn Configuration.isOSUNIX();\n\t}\n\n\t/**\n\t * Checks if the current Operating System is Solaris.\n\t * @returns True if the OS is Solaris, false otherwise.\n\t */\n\tpublic static isOSSolaris(): boolean {\n\t\treturn Configuration.isOSSolaris();\n\t}\n\n}\n\n// @ts-ignore\nif (typeof module !== 'undefined') {\n\t// @ts-ignore\n\tmodule.exports = Configurations;\n}"],
  "mappings": ";;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AA6CA,MAAM,gBAAgB,KAAK,KAAK,oDAAoD;AACpF,MAAM,uBAAuB,KAAK,KAAK,gEAAgE;AA4ChG,MAAM,eAAe;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQ3B,OAAc,IAAI,KAAa,cAA2C;AACzE,UAAM,QAAQ,cAAc,IAAI,KAAK,YAAY;AACjD,WAAO,SAAS;AAAA,EACjB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,OAAc,IAAI,KAAa,OAAqB;AACnD,kBAAc,IAAI,KAAK,KAAK;AAAA,EAC7B;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,OAAc,OAAO,KAAmB;AACvC,kBAAc,OAAO,GAAG;AAAA,EACzB;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,OAAc,UAAoB;AACjC,WAAO,cAAc,QAAQ;AAAA,EAC9B;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,OAAc,YAAkC;AAC/C,WAAO,KAAK,MAAM,qBAAqB,UAAU,CAAC;AAAA,EACnD;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,OAAc,eAAe,OAA2D;AACvF,UAAM,SAAS,UAAU,SAAY,OAAO,MAAM,QAAQ,KAAK,IAAI,MAAM,KAAK,GAAG,IAAI;AACrF,WAAO,KAAK,MAAM,qBAAqB,eAAe,MAAM,CAAC;AAAA,EAC9D;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,OAAc,KAAK,MAAoB;AACtC,kBAAc,KAAK,IAAI;AAAA,EACxB;AAAA;AAAA;AAAA;AAAA,EAKA,OAAc,SAAe;AAC5B,kBAAc,OAAO;AAAA,EACtB;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,OAAc,QAAgB;AAC7B,WAAO,cAAc,MAAM;AAAA,EAC5B;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,OAAc,cAAuB;AACpC,WAAO,cAAc,YAAY;AAAA,EAClC;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,OAAc,UAAmB;AAChC,WAAO,cAAc,QAAQ;AAAA,EAC9B;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,OAAc,WAAoB;AACjC,WAAO,cAAc,SAAS;AAAA,EAC/B;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,OAAc,cAAuB;AACpC,WAAO,cAAc,YAAY;AAAA,EAClC;AAED;AAGA,IAAI,OAAO,WAAW,aAAa;AAElC,SAAO,UAAU;AAClB;",
  "names": []
}


package/dist/dts/core/configurations.d.ts

@@ -42,6 +42,50 @@
  * }
  * ```
 */
+/**
+ * A configuration group with the number of its keys and of the keys any source sets.
+ */
+export interface ConfigurationGroup {
+    id: string;
+    section: string;
+    label: string;
+    order: number;
+    total: number;
+    set: number;
+}
+/**
+ * A described configuration key. Every value is masked as "********" when the key is sensitive.
+ */
+export interface ConfigurationDescriptor {
+    key: string;
+    subgroup?: string;
+    type?: string;
+    defaultValue?: string;
+    /** The effective value. */
+    value?: string;
+    /** Where the effective value comes from. */
+    source: "runtime" | "environment" | "deployment" | "module" | "default" | "unset";
+    /** The value each source gives the key. */
+    values: {
+        runtime?: string;
+        environment?: string;
+        deployment?: string;
+        module?: string;
+    };
+    sensitive: boolean;
+    restartRequired?: boolean;
+    tenantOverridable: boolean;
+    deprecatedBy?: string;
+}
+/**
+ * A configuration group with its described keys.
+ */
+export interface ConfigurationDescriptorGroup {
+    group: string;
+    section: string;
+    label: string;
+    entries: ConfigurationDescriptor[];
+}
 export declare class Configurations {
     /**
      * Retrieves the configuration value associated with the given key.
@@ -67,6 +111,18 @@ export declare class Configurations {
      * @returns An array of configuration keys (strings).
      */
     static getKeys(): string[];
+    /**
+     * Retrieves the configuration groups, in display order, with the number of keys and of set keys in each.
+     * @returns The groups.
+     */
+    static getGroups(): ConfigurationGroup[];
+    /**
+     * Retrieves the described configuration keys, grouped: default, effective value, its source and the value
+     * of each source. Sensitive values are masked.
+     * @param group A group id (e.g. "database") or several; all groups when omitted.
+     * @returns The groups that have keys.
+     */
+    static getDescriptors(group?: string | string[]): ConfigurationDescriptorGroup[];
     /**
      * Loads configuration properties from a file at the specified path, overriding existing ones.
      * @param path The file path to load configurations from.

package/dist/esm/core/configurations.mjs

@@ -1,4 +1,5 @@
 const Configuration = Java.type("org.eclipse.dirigible.commons.config.Configuration");
+const ConfigurationsFacade = Java.type("org.eclipse.dirigible.components.api.core.ConfigurationsFacade");
 class Configurations {
   /**
    * Retrieves the configuration value associated with the given key.
@@ -33,6 +34,23 @@ class Configurations {
   static getKeys() {
     return Configuration.getKeys();
   }
+  /**
+   * Retrieves the configuration groups, in display order, with the number of keys and of set keys in each.
+   * @returns The groups.
+   */
+  static getGroups() {
+    return JSON.parse(ConfigurationsFacade.getGroups());
+  }
+  /**
+   * Retrieves the described configuration keys, grouped: default, effective value, its source and the value
+   * of each source. Sensitive values are masked.
+   * @param group A group id (e.g. "database") or several; all groups when omitted.
+   * @returns The groups that have keys.
+   */
+  static getDescriptors(group) {
+    const groups = group === void 0 ? null : Array.isArray(group) ? group.join(",") : group;
+    return JSON.parse(ConfigurationsFacade.getDescriptors(groups));
+  }
   /**
    * Loads configuration properties from a file at the specified path, overriding existing ones.
    * @param path The file path to load configurations from.
@@ -88,4 +106,4 @@ if (typeof module !== "undefined") {
 export {
   Configurations
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/core/configurations.ts"],
  "sourcesContent": ["/**\n * @module core/configurations\n * @package @aerokit/sdk/core\n * @name Configurations\n * @overview\n * \n * The Configurations API provides a centralized, type-safe interface for managing application configuration properties and detecting the runtime operating system. It serves as the foundation for environment-specific settings and system-aware behavior in Aerokit applications.\n * \n * ### Key Features\n * \n * - **Static Interface**: Thread-safe, singleton-like access to configuration data\n * - **Type Safety**: Full TypeScript support with proper type definitions\n * - **File Loading**: Support for loading configurations from external files\n * - **OS Detection**: Comprehensive operating system identification\n * - **Memory Efficient**: In-memory storage with optional persistence\n * \n * ### Use Cases\n * - Application configuration management\n * - Environment variable management\n * - Feature flag configuration\n * - Database connection settings\n * - API endpoint configuration\n * - Platform-specific behavior adaptation\n * \n * ### Example Usage\n * ```ts\n * import { Configurations } from \"@aerokit/sdk/core\";\n * \n * // Set a configuration property\n * Configurations.set(\"apiEndpoint\", \"https://api.example.com\");\n * // Get a configuration property\n * const apiEndpoint = Configurations.get(\"apiEndpoint\");\n * console.log(apiEndpoint); // Output: \"https://api.example.com\"\n * \n * // Check the operating system\n * if (Configurations.isOSWindows()) {\n *   console.log(\"Running on Windows\");\n * } else if (Configurations.isOSMac()) {\n *   console.log(\"Running on Mac\");\n * } else if (Configurations.isOSUNIX()) {\n *   console.log(\"Running on UNIX\");\n * }\n * ```\n*/\n\nconst Configuration = Java.type(\"org.eclipse.dirigible.commons.config.Configuration\");\nconst ConfigurationsFacade = Java.type(\"org.eclipse.dirigible.components.api.core.ConfigurationsFacade\");\n\n/**\n * A configuration group with the number of its keys and of the keys any source sets.\n */\nexport interface ConfigurationGroup {\n\tid: string;\n\tsection: string;\n\tlabel: string;\n\torder: number;\n\ttotal: number;\n\tset: number;\n}\n\n/**\n * A described configuration key. Every value is masked as \"********\" when the key is sensitive.\n */\nexport interface ConfigurationDescriptor {\n\tkey: string;\n\tsubgroup?: string;\n\ttype?: string;\n\tdefaultValue?: string;\n\t/** The effective value. */\n\tvalue?: string;\n\t/** Where the effective value comes from. */\n\tsource: \"runtime\" | \"environment\" | \"deployment\" | \"module\" | \"default\" | \"unset\";\n\t/** The value each source gives the key. */\n\tvalues: { runtime?: string; environment?: string; deployment?: string; module?: string };\n\tsensitive: boolean;\n\trestartRequired?: boolean;\n\ttenantOverridable: boolean;\n\tdeprecatedBy?: string;\n}\n\n/**\n * A configuration group with its described keys.\n */\nexport interface ConfigurationDescriptorGroup {\n\tgroup: string;\n\tsection: string;\n\tlabel: string;\n\tentries: ConfigurationDescriptor[];\n}\n\nexport class Configurations {\n\n\t/**\n\t * Retrieves the configuration value associated with the given key.\n\t * @param key The configuration key.\n\t * @param defaultValue The optional default value to return if the key is not found.\n\t * @returns The configuration value as a string, or `undefined` if the key is not found and no default is provided.\n\t */\n\tpublic static get(key: string, defaultValue?: string): string | undefined {\n\t\tconst value = Configuration.get(key, defaultValue);\n\t\treturn value ?? undefined;\n\t}\n\n\t/**\n\t * Sets the configuration value for the given key.\n\t * If the key already exists, its value is overwritten.\n\t * @param key The configuration key.\n\t * @param value The configuration value to set.\n\t */\n\tpublic static set(key: string, value: string): void {\n\t\tConfiguration.set(key, value);\n\t}\n\n\t/**\n\t * Removes the configuration property associated with the given key.\n\t * @param key The configuration key to remove.\n\t */\n\tpublic static remove(key: string): void {\n\t\tConfiguration.remove(key);\n\t}\n\n\t/**\n\t * Retrieves a list of all current configuration keys.\n\t * @returns An array of configuration keys (strings).\n\t */\n\tpublic static getKeys(): string[] {\n\t\treturn Configuration.getKeys();\n\t}\n\n\t/**\n\t * Retrieves the configuration groups, in display order, with the number of keys and of set keys in each.\n\t * @returns The groups.\n\t */\n\tpublic static getGroups(): ConfigurationGroup[] {\n\t\treturn JSON.parse(ConfigurationsFacade.getGroups());\n\t}\n\n\t/**\n\t * Retrieves the described configuration keys, grouped: default, effective value, its source and the value\n\t * of each source. Sensitive values are masked.\n\t * @param group A group id (e.g. \"database\") or several; all groups when omitted.\n\t * @returns The groups that have keys.\n\t */\n\tpublic static getDescriptors(group?: string | string[]): ConfigurationDescriptorGroup[] {\n\t\tconst groups = group === undefined ? null : Array.isArray(group) ? group.join(\",\") : group;\n\t\treturn JSON.parse(ConfigurationsFacade.getDescriptors(groups));\n\t}\n\n\t/**\n\t * Loads configuration properties from a file at the specified path, overriding existing ones.\n\t * @param path The file path to load configurations from.\n\t */\n\tpublic static load(path: string): void {\n\t\tConfiguration.load(path);\n\t}\n\n\t/**\n\t * Reloads or updates the current configuration settings from their source (e.g., persistence layer).\n\t */\n\tpublic static update(): void {\n\t\tConfiguration.update();\n\t}\n\n\t/**\n\t * Retrieves the name of the current Operating System.\n\t * @returns The OS name as a string (e.g., \"Windows\", \"Linux\", \"Mac OS X\").\n\t */\n\tpublic static getOS(): string {\n\t\treturn Configuration.getOS();\n\t}\n\n\t/**\n\t * Checks if the current Operating System is Windows.\n\t * @returns True if the OS is Windows, false otherwise.\n\t */\n\tpublic static isOSWindows(): boolean {\n\t\treturn Configuration.isOSWindows();\n\t}\n\n\t/**\n\t * Checks if the current Operating System is Mac OS (or Mac OS X).\n\t * @returns True if the OS is Mac, false otherwise.\n\t */\n\tpublic static isOSMac(): boolean {\n\t\treturn Configuration.isOSMac();\n\t}\n\n\t/**\n\t * Checks if the current Operating System is a UNIX-like system (e.g., Linux, macOS, or others).\n\t * @returns True if the OS is a UNIX variant, false otherwise.\n\t */\n\tpublic static isOSUNIX(): boolean {\n\t\treturn Configuration.isOSUNIX();\n\t}\n\n\t/**\n\t * Checks if the current Operating System is Solaris.\n\t * @returns True if the OS is Solaris, false otherwise.\n\t */\n\tpublic static isOSSolaris(): boolean {\n\t\treturn Configuration.isOSSolaris();\n\t}\n\n}\n\n// @ts-ignore\nif (typeof module !== 'undefined') {\n\t// @ts-ignore\n\tmodule.exports = Configurations;\n}"],
  "mappings": "AA6CA,MAAM,gBAAgB,KAAK,KAAK,oDAAoD;AACpF,MAAM,uBAAuB,KAAK,KAAK,gEAAgE;AA4ChG,MAAM,eAAe;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQ3B,OAAc,IAAI,KAAa,cAA2C;AACzE,UAAM,QAAQ,cAAc,IAAI,KAAK,YAAY;AACjD,WAAO,SAAS;AAAA,EACjB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,OAAc,IAAI,KAAa,OAAqB;AACnD,kBAAc,IAAI,KAAK,KAAK;AAAA,EAC7B;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,OAAc,OAAO,KAAmB;AACvC,kBAAc,OAAO,GAAG;AAAA,EACzB;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,OAAc,UAAoB;AACjC,WAAO,cAAc,QAAQ;AAAA,EAC9B;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,OAAc,YAAkC;AAC/C,WAAO,KAAK,MAAM,qBAAqB,UAAU,CAAC;AAAA,EACnD;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,OAAc,eAAe,OAA2D;AACvF,UAAM,SAAS,UAAU,SAAY,OAAO,MAAM,QAAQ,KAAK,IAAI,MAAM,KAAK,GAAG,IAAI;AACrF,WAAO,KAAK,MAAM,qBAAqB,eAAe,MAAM,CAAC;AAAA,EAC9D;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,OAAc,KAAK,MAAoB;AACtC,kBAAc,KAAK,IAAI;AAAA,EACxB;AAAA;AAAA;AAAA;AAAA,EAKA,OAAc,SAAe;AAC5B,kBAAc,OAAO;AAAA,EACtB;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,OAAc,QAAgB;AAC7B,WAAO,cAAc,MAAM;AAAA,EAC5B;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,OAAc,cAAuB;AACpC,WAAO,cAAc,YAAY;AAAA,EAClC;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,OAAc,UAAmB;AAChC,WAAO,cAAc,QAAQ;AAAA,EAC9B;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,OAAc,WAAoB;AACjC,WAAO,cAAc,SAAS;AAAA,EAC/B;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,OAAc,cAAuB;AACpC,WAAO,cAAc,YAAY;AAAA,EAClC;AAED;AAGA,IAAI,OAAO,WAAW,aAAa;AAElC,SAAO,UAAU;AAClB;",
  "names": []
}


package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aerokit/sdk",
-  "version": "14.76.0",
+  "version": "14.81.0",
   "description": "Unified TypeScript SDK for modern cloud platforms.",
   "scripts": {
     "clean": "rm -rf dist",

package/test/flows/list.js

@@ -40,10 +40,43 @@ export function listFlow(manifest, entity) {
     const emptyState = page.getByText('Get started by creating the first record').filter({ visible: true }).first();
     await expect(firstHeader.or(emptyState).first()).toBeVisible();
     if (entity.expectSeedData || (await firstHeader.isVisible())) {
-      for (const field of (entity.fields ?? []).filter((f) => f.major !== false && !f.primaryKey)) {
-        await expect(page.getByRole('columnheader').filter({ hasText: labelOf(field) }).first()).toBeVisible();
+      for (const label of declaredColumns(entity)) {
+        await expect(page.getByRole('columnheader').filter({ hasText: label }).first()).toBeVisible();
+      }
+      for (const label of hiddenColumns(entity)) {
+        await expect(page.getByRole('columnheader').filter({ hasText: label })).toHaveCount(0);
       }
       await expect(page.locator('tbody tr:visible').first()).toBeVisible();
     }
   });
 }
+
+// The headers the list is expected to render, in order (dirigible #7664). `list:` curates the list
+// INDEPENDENTLY of each field's own `major`, so an entity that declares it renders exactly those
+// columns and the `major` rule says nothing about it - which is why asserting the rule against a
+// curated entity failed on the first instance that held a row, and passed on every empty one,
+// where the assertion never runs at all.
+function declaredColumns(entity) {
+  if (entity.list?.length) return entity.list.map((name) => columnLabel(entity, name));
+  return (entity.fields ?? []).filter((f) => f.major !== false && !f.primaryKey).map(labelOf);
+}
+
+// ...and the ones it must NOT render. A curated list is the whole statement, so a field left off it
+// is absent from the table however its own `major` reads - the half that catches a `list:` the page
+// ignored.
+function hiddenColumns(entity) {
+  if (!entity.list?.length) return [];
+  const listed = new Set(entity.list);
+  return (entity.fields ?? [])
+    .filter((f) => !f.primaryKey && !listed.has(f.name))
+    .map(labelOf);
+}
+
+// A `list:` entry names a property - a field, or a to-one relation - and the header carries that
+// property's own label, which is what the manifest's `label` on the field already is.
+function columnLabel(entity, name) {
+  const field = (entity.fields ?? []).find((f) => f.name === name);
+  if (field) return labelOf(field);
+  const relation = (entity.relations ?? []).find((r) => r.name === name);
+  return relation?.label ?? name;
+}

package/test/form.js

@@ -86,9 +86,20 @@ export async function resolveRelationSamples(request, manifest, entity) {
     if (relation.entityStatus) continue;
     // a filtered picker needs a matching candidate, so fetch a page and filter client-side; a
     // constrained relation needs alternatives to choose from
-    const wide = relation.where || relation.leafOnly || constrained.has(relation.name);
+    const wide =
+      relation.where || relation.leafOnly || relation.pickable || relation.forbiddenTarget || constrained.has(relation.name);
     const { rows: fetched, labelFrom } = await fetchRows(relation, wide ? 200 : 1);
     let rows = relation.where ? fetched?.filter((r) => String(r[relation.where.by]) === String(relation.where.value)) : fetched;
+    // A picker rule narrows what the chooser OFFERS (dirigible #7663) and the child's own
+    // forbidWhen decides which parent it accepts at all (#7667). Both refuse a row the manifest
+    // otherwise describes as a candidate, so the sample has to respect them or the record is built
+    // from a row the UI never offers and the REST create is answered 400.
+    if (rows?.length && relation.pickable?.when?.length) {
+      rows = rows.filter((row) => relation.pickable.when.every((term) => termHolds(row, term)));
+    }
+    if (rows?.length && relation.forbiddenTarget?.length) {
+      rows = rows.filter((row) => !relation.forbiddenTarget.some((term) => termHolds(row, term)));
+    }
     if (relation.leafOnly && rows?.length) {
       // the generated validation rejects a non-leaf target - pick a row no other row parents
       const prop = relation.leafOnly.hierarchyProperty;
@@ -97,7 +108,7 @@ export async function resolveRelationSamples(request, manifest, entity) {
     }
     if (!rows?.length) {
       // a required FK cannot be satisfied - fail loudly; an optional one is simply left unset
-      if (relation.required) throw new Error(`Relation ${entity.name}.${relation.name}: no ${relation.to} rows to pick from`);
+      if (relation.required) throw new Error(`Relation ${entity.name}.${relation.name}: ${noCandidateReason(relation)}`);
       continue;
     }
     const label = rows[0][labelFrom];
@@ -178,3 +189,26 @@ export async function fillForm(page, manifest, entity, record, relationSamples,
   const dependents = pickable.filter((s) => s.relation.dependsOn);
   for (const sample of [...triggers, ...dependents]) await pickDropdown(page, sample.relation, sample.label);
 }
+
+// One term of a picker rule or of a forbidWhen reaching through a relation, as the manifest writes
+// it: `{ by, op, value }` with `op` one of eq / ne / present / absent, a presence test carrying no
+// value. Compared as strings, because an id arrives as a number from REST and as text from a
+// rendered option.
+function termHolds(row, term) {
+  const value = row?.[term.by];
+  const empty = value == null || String(value).trim() === '';
+  if (term.op === 'present') return !empty;
+  if (term.op === 'absent') return empty;
+  if (term.op === 'ne') return String(value) !== String(term.value);
+  return String(value) === String(term.value);
+}
+
+// Why a required relation had nothing to pick: the rule that excluded every row, in the words the
+// model authored it in, so the failure names the business rule rather than "no rows".
+function noCandidateReason(relation) {
+  const refusal = (relation.forbiddenTarget ?? []).find((term) => term.message)?.message;
+  if (refusal) return `every ${relation.to} is refused - ${refusal}`;
+  if (relation.forbiddenTarget?.length) return `every ${relation.to} is in a state this record refuses`;
+  if (relation.pickable?.when?.length) return `no ${relation.to} row satisfies the picker rule`;
+  return `no ${relation.to} rows to pick from`;
+}

package/dist/cjs/kafka/consumer.js

@@ -1,71 +0,0 @@
-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 consumer_exports = {};
-__export(consumer_exports, {
-  Consumer: () => Consumer
-});
-module.exports = __toCommonJS(consumer_exports);
-const KafkaFacade = Java.type("org.eclipse.dirigible.components.api.kafka.KafkaFacade");
-class Consumer {
-  /**
-   * Creates a new topic configuration wrapper that can be used to start or
-   * stop listening for messages on a Kafka topic.
-   *
-   * @param destination The name of the Kafka topic to consume messages from.
-   * @param configuration Optional key-value object containing Kafka consumer properties
-   * (e.g., 'group.id', 'auto.offset.reset').
-   * @returns A {@link Topic} instance configured for the specified destination and properties.
-   */
-  static topic(destination, configuration = {}) {
-    return new Topic(destination, configuration);
-  }
-}
-class Topic {
-  destination;
-  configuration = {};
-  /**
-   * @param destination The name of the Kafka topic.
-   * @param configuration Optional key-value object for consumer properties.
-   */
-  constructor(destination, configuration = {}) {
-    this.destination = destination;
-    this.configuration = configuration;
-  }
-  /**
-   * Starts listening to the configured topic in a background process.
-   *
-   * @param handler The path to the script or function name that will handle the incoming Kafka messages.
-   * This function should accept two arguments: `message` (string) and `headers` (object).
-   * @param timeout The maximum amount of time (in milliseconds) the consumer should wait for messages.
-   */
-  startListening(handler, timeout) {
-    KafkaFacade.startListening(this.destination, handler, timeout, JSON.stringify(this.configuration));
-  }
-  /**
-   * Stops the background process that is listening to the configured topic.
-   * Note: Stopping is based on matching the topic and configuration, so the same
-   * configuration object used in `startListening` should be used here.
-   */
-  stopListening() {
-    KafkaFacade.stopListening(this.destination, JSON.stringify(this.configuration));
-  }
-}
-if (typeof module !== "undefined") {
-  module.exports = Consumer;
-}
-//# sourceMappingURL=data:application/json;base64,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

package/dist/cjs/kafka/index.js

@@ -1,29 +0,0 @@
-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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var kafka_exports = {};
-__export(kafka_exports, {
-  consumer: () => import_consumer.Consumer,
-  producer: () => import_producer.Producer
-});
-module.exports = __toCommonJS(kafka_exports);
-var import_consumer = require("./consumer");
-__reExport(kafka_exports, require("./consumer"), module.exports);
-var import_producer = require("./producer");
-__reExport(kafka_exports, require("./producer"), module.exports);
-//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vc3JjL2thZmthL2luZGV4LnRzIl0sCiAgInNvdXJjZXNDb250ZW50IjogWyIvKipcbiAqIEBtb2R1bGUga2Fma2EvaW5kZXhcbiAqIEBwYWNrYWdlIEBhZXJva2l0L3Nkay9rYWZrYVxuICogQG92ZXJ2aWV3XG4gKiBcbiAqIFRoaXMgbW9kdWxlIHByb3ZpZGVzIGZ1bmN0aW9uYWxpdGllcyBmb3IgS2Fma2EgaW50ZWdyYXRpb24gd2l0aGluIHRoZSBBZXJva2l0IFNESy4gSXQgaW5jbHVkZXMgY2xhc3NlcyBhbmQgbWV0aG9kcyBmb3IgcHJvZHVjaW5nIGFuZCBjb25zdW1pbmcgbWVzc2FnZXMgZnJvbSBLYWZrYSB0b3BpY3MsIGFzIHdlbGwgYXMgbWFuYWdpbmcgS2Fma2EgY29uZmlndXJhdGlvbnMgYW5kIGNvbm5lY3Rpb25zLlxuICogXG4gKiBUaGUgbWFpbiBjb21wb25lbnRzIG9mIHRoaXMgbW9kdWxlIGFyZTpcbiAqIC0gQ29uc3VtZXI6IFJlcHJlc2VudHMgYSBLYWZrYSBjb25zdW1lciB0aGF0IGNhbiBzdWJzY3JpYmUgdG8gdG9waWNzIGFuZCBjb25zdW1lIG1lc3NhZ2VzLlxuICogLSBQcm9kdWNlcjogUmVwcmVzZW50cyBhIEthZmthIHByb2R1Y2VyIHRoYXQgY2FuIHNlbmQgbWVzc2FnZXMgdG8gdG9waWNzLlxuICovXG5cbmV4cG9ydCB7IENvbnN1bWVyIGFzIGNvbnN1bWVyIH0gZnJvbSBcIi4vY29uc3VtZXJcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2NvbnN1bWVyXCI7XG5leHBvcnQgeyBQcm9kdWNlciBhcyBwcm9kdWNlciB9IGZyb20gXCIuL3Byb2R1Y2VyXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9wcm9kdWNlclwiOyJdLAogICJtYXBwaW5ncyI6ICI7Ozs7Ozs7Ozs7Ozs7Ozs7OztBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQVlBLHNCQUFxQztBQUNyQywwQkFBYyx1QkFiZDtBQWNBLHNCQUFxQztBQUNyQywwQkFBYyx1QkFmZDsiLAogICJuYW1lcyI6IFtdCn0K

package/dist/cjs/kafka/producer.js

@@ -1,72 +0,0 @@
-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 producer_exports = {};
-__export(producer_exports, {
-  Producer: () => Producer
-});
-module.exports = __toCommonJS(producer_exports);
-const KafkaFacade = Java.type("org.eclipse.dirigible.components.api.kafka.KafkaFacade");
-class Producer {
-  /**
-   * Creates a new topic configuration wrapper that can be used to send messages
-   * to a specific Kafka topic.
-   *
-   * @param destination The name of the Kafka topic to send messages to.
-   * @param configuration Optional key-value object containing Kafka producer properties
-   * (e.g., 'bootstrap.servers', 'acks').
-   * @returns A {@link Topic} instance configured for the specified destination and properties.
-   */
-  static topic(destination, configuration = {}) {
-    return new Topic(destination, configuration);
-  }
-  /**
-   * Closes the Kafka producer connection pool, releasing associated resources.
-   * This should be called when message sending is complete to ensure proper cleanup.
-   *
-   * @param configuration Optional key-value object containing the configuration
-   * used to initialize the producer to be closed.
-   */
-  static close(configuration = {}) {
-    KafkaFacade.closeProducer(configuration);
-  }
-}
-class Topic {
-  destination;
-  configuration;
-  /**
-   * @param destination The name of the Kafka topic.
-   * @param configuration Key-value object for producer properties.
-   */
-  constructor(destination, configuration) {
-    this.destination = destination;
-    this.configuration = configuration;
-  }
-  /**
-   * Sends a message with an optional key to the configured Kafka topic.
-   *
-   * @param key The key of the message. Messages with the same key go to the same partition.
-   * @param value The content of the message to be sent.
-   */
-  send(key, value) {
-    KafkaFacade.send(this.destination, key, value, JSON.stringify(this.configuration));
-  }
-}
-if (typeof module !== "undefined") {
-  module.exports = Producer;
-}
-//# sourceMappingURL=data:application/json;base64,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

package/dist/dts/kafka/consumer.d.ts

@@ -1,79 +0,0 @@
-/**
- * @module kafka/consumer
- * @package @aerokit/sdk/kafka
- * @name Consumer
- * @overview
- *
- * The Consumer module provides an API for configuring and managing Kafka consumers, allowing scripts to start and stop listening to specific topics. It abstracts the complexities of Kafka consumer configuration and lifecycle management, enabling developers to easily integrate Kafka message consumption into their applications.
- *
- * ### Key Features:
- * - **Topic Configuration**: The `Consumer.topic` method allows developers to create a topic configuration wrapper with specified destination and properties.
- * - **Background Listening**: The `startListening` method starts a background process that listens for messages on the configured topic, invoking a specified handler function for incoming messages.
- * - **Graceful Shutdown**: The `stopListening` method allows developers to stop the background listening process based on the topic and configuration.
- *
- * ### Use Cases:
- * - **Real-time Data Processing**: Developers can use this module to consume messages from Kafka topics in real-time, enabling use cases such as stream processing, event-driven architectures, and microservices communication.
- * - **Integration with Other Systems**: By consuming Kafka messages, applications can integrate with other systems that produce messages to Kafka, facilitating data flow across different components of an ecosystem.
- *
- * ### Example Usage:
- * ```ts
- * import { Consumer } from "@aerokit/sdk/kafka";
- *
- * // Create a consumer for the "orders" topic with specific configuration
- * const ordersConsumer = Consumer.topic("orders", { "group.id": "order-processors" });
- *
- * // Start listening to the "orders" topic with a message handler and timeout
- * ordersConsumer.startListening("handleOrderMessage", 30000);
- *
- * // Later, stop listening to the "orders" topic
- * ordersConsumer.stopListening();
- * ```
- */
-/**
- * The Consumer class acts as the main entry point for creating and configuring
- * Kafka topic consumers.
- */
-export declare class Consumer {
-    /**
-     * Creates a new topic configuration wrapper that can be used to start or
-     * stop listening for messages on a Kafka topic.
-     *
-     * @param destination The name of the Kafka topic to consume messages from.
-     * @param configuration Optional key-value object containing Kafka consumer properties
-     * (e.g., 'group.id', 'auto.offset.reset').
-     * @returns A {@link Topic} instance configured for the specified destination and properties.
-     */
-    static topic(destination: string, configuration?: {
-        [key: string]: string;
-    }): Topic;
-}
-/**
- * Represents a configured Kafka topic consumer capable of starting and stopping
- * background message listening.
- */
-declare class Topic {
-    private destination;
-    private configuration;
-    /**
-     * @param destination The name of the Kafka topic.
-     * @param configuration Optional key-value object for consumer properties.
-     */
-    constructor(destination: string, configuration?: {
-        [key: string]: string;
-    });
-    /**
-     * Starts listening to the configured topic in a background process.
-     *
-     * @param handler The path to the script or function name that will handle the incoming Kafka messages.
-     * This function should accept two arguments: `message` (string) and `headers` (object).
-     * @param timeout The maximum amount of time (in milliseconds) the consumer should wait for messages.
-     */
-    startListening(handler: string, timeout: number): void;
-    /**
-     * Stops the background process that is listening to the configured topic.
-     * Note: Stopping is based on matching the topic and configuration, so the same
-     * configuration object used in `startListening` should be used here.
-     */
-    stopListening(): void;
-}
-export {};

package/dist/dts/kafka/index.d.ts

@@ -1,15 +0,0 @@
-/**
- * @module kafka/index
- * @package @aerokit/sdk/kafka
- * @overview
- *
- * This module provides functionalities for Kafka integration within the Aerokit SDK. It includes classes and methods for producing and consuming messages from Kafka topics, as well as managing Kafka configurations and connections.
- *
- * The main components of this module are:
- * - Consumer: Represents a Kafka consumer that can subscribe to topics and consume messages.
- * - Producer: Represents a Kafka producer that can send messages to topics.
- */
-export { Consumer as consumer } from "./consumer";
-export * from "./consumer";
-export { Producer as producer } from "./producer";
-export * from "./producer";

package/dist/dts/kafka/producer.d.ts

@@ -1,81 +0,0 @@
-/**
- * @module kafka/producer
- * @package @aerokit/sdk/kafka
- * @name Producer
- * @overview
- *
- * The Producer module provides an API for configuring and managing Kafka producers, allowing scripts to create topics, send messages, and close the producer connection. It abstracts the complexities of Kafka producer configuration and message sending, enabling developers to easily integrate Kafka message production into their applications.
- *
- * ### Key Features:
- * - **Topic Configuration**: The `Producer.topic` method allows developers to create a topic configuration wrapper with specified destination and properties.
- * - **Message Sending**: The `send` method on the Topic class enables sending messages with optional keys to the configured Kafka topic.
- * - **Connection Management**: The `close` method allows developers to close the Kafka producer connection pool, ensuring proper resource cleanup.
- *
- * ### Use Cases:
- * - **Event Production**: Developers can use this module to produce messages to Kafka topics in real-time, enabling use cases such as event-driven architectures and microservices communication.
- * - **Integration with Other Systems**: By sending Kafka messages, applications can integrate with other systems that consume messages from Kafka, facilitating data flow across different components of an ecosystem.
- *
- * ### Example Usage:
- * ```ts
- * import { Producer } from "@aerokit/sdk/kafka";
- *
- * // Create a producer for the "orders" topic with specific configuration
- * const ordersProducer = Producer.topic("orders", { "bootstrap.servers": "localhost:9092" });
- *
- * // Send a message with a key to the "orders" topic
- * ordersProducer.send("order123", "New order placed");
- *
- * // Later, close the producer connection
- * Producer.close({ "bootstrap.servers": "localhost:9092" });
- * ```
- */
-/**
- * The Producer class serves as the main entry point for creating and configuring
- * Kafka topic producers.
- */
-export declare class Producer {
-    /**
-     * Creates a new topic configuration wrapper that can be used to send messages
-     * to a specific Kafka topic.
-     *
-     * @param destination The name of the Kafka topic to send messages to.
-     * @param configuration Optional key-value object containing Kafka producer properties
-     * (e.g., 'bootstrap.servers', 'acks').
-     * @returns A {@link Topic} instance configured for the specified destination and properties.
-     */
-    static topic(destination: string, configuration?: {
-        [key: string]: string;
-    }): Topic;
-    /**
-     * Closes the Kafka producer connection pool, releasing associated resources.
-     * This should be called when message sending is complete to ensure proper cleanup.
-     *
-     * @param configuration Optional key-value object containing the configuration
-     * used to initialize the producer to be closed.
-     */
-    static close(configuration?: {
-        [key: string]: string;
-    }): void;
-}
-/**
- * Represents a configured Kafka topic that can be used to send messages.
- */
-declare class Topic {
-    private destination;
-    private configuration;
-    /**
-     * @param destination The name of the Kafka topic.
-     * @param configuration Key-value object for producer properties.
-     */
-    constructor(destination: string, configuration: {
-        [key: string]: string;
-    });
-    /**
-     * Sends a message with an optional key to the configured Kafka topic.
-     *
-     * @param key The key of the message. Messages with the same key go to the same partition.
-     * @param value The content of the message to be sent.
-     */
-    send(key: string, value: string): void;
-}
-export {};

package/dist/esm/kafka/consumer.mjs

@@ -1,52 +0,0 @@
-const KafkaFacade = Java.type("org.eclipse.dirigible.components.api.kafka.KafkaFacade");
-class Consumer {
-  /**
-   * Creates a new topic configuration wrapper that can be used to start or
-   * stop listening for messages on a Kafka topic.
-   *
-   * @param destination The name of the Kafka topic to consume messages from.
-   * @param configuration Optional key-value object containing Kafka consumer properties
-   * (e.g., 'group.id', 'auto.offset.reset').
-   * @returns A {@link Topic} instance configured for the specified destination and properties.
-   */
-  static topic(destination, configuration = {}) {
-    return new Topic(destination, configuration);
-  }
-}
-class Topic {
-  destination;
-  configuration = {};
-  /**
-   * @param destination The name of the Kafka topic.
-   * @param configuration Optional key-value object for consumer properties.
-   */
-  constructor(destination, configuration = {}) {
-    this.destination = destination;
-    this.configuration = configuration;
-  }
-  /**
-   * Starts listening to the configured topic in a background process.
-   *
-   * @param handler The path to the script or function name that will handle the incoming Kafka messages.
-   * This function should accept two arguments: `message` (string) and `headers` (object).
-   * @param timeout The maximum amount of time (in milliseconds) the consumer should wait for messages.
-   */
-  startListening(handler, timeout) {
-    KafkaFacade.startListening(this.destination, handler, timeout, JSON.stringify(this.configuration));
-  }
-  /**
-   * Stops the background process that is listening to the configured topic.
-   * Note: Stopping is based on matching the topic and configuration, so the same
-   * configuration object used in `startListening` should be used here.
-   */
-  stopListening() {
-    KafkaFacade.stopListening(this.destination, JSON.stringify(this.configuration));
-  }
-}
-if (typeof module !== "undefined") {
-  module.exports = Consumer;
-}
-export {
-  Consumer
-};
-//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vc3JjL2thZmthL2NvbnN1bWVyLnRzIl0sCiAgInNvdXJjZXNDb250ZW50IjogWyIvKipcbiAqIEBtb2R1bGUga2Fma2EvY29uc3VtZXJcbiAqIEBwYWNrYWdlIEBhZXJva2l0L3Nkay9rYWZrYVxuICogQG5hbWUgQ29uc3VtZXJcbiAqIEBvdmVydmlld1xuICogXG4gKiBUaGUgQ29uc3VtZXIgbW9kdWxlIHByb3ZpZGVzIGFuIEFQSSBmb3IgY29uZmlndXJpbmcgYW5kIG1hbmFnaW5nIEthZmthIGNvbnN1bWVycywgYWxsb3dpbmcgc2NyaXB0cyB0byBzdGFydCBhbmQgc3RvcCBsaXN0ZW5pbmcgdG8gc3BlY2lmaWMgdG9waWNzLiBJdCBhYnN0cmFjdHMgdGhlIGNvbXBsZXhpdGllcyBvZiBLYWZrYSBjb25zdW1lciBjb25maWd1cmF0aW9uIGFuZCBsaWZlY3ljbGUgbWFuYWdlbWVudCwgZW5hYmxpbmcgZGV2ZWxvcGVycyB0byBlYXNpbHkgaW50ZWdyYXRlIEthZmthIG1lc3NhZ2UgY29uc3VtcHRpb24gaW50byB0aGVpciBhcHBsaWNhdGlvbnMuXG4gKiBcbiAqICMjIyBLZXkgRmVhdHVyZXM6XG4gKiAtICoqVG9waWMgQ29uZmlndXJhdGlvbioqOiBUaGUgYENvbnN1bWVyLnRvcGljYCBtZXRob2QgYWxsb3dzIGRldmVsb3BlcnMgdG8gY3JlYXRlIGEgdG9waWMgY29uZmlndXJhdGlvbiB3cmFwcGVyIHdpdGggc3BlY2lmaWVkIGRlc3RpbmF0aW9uIGFuZCBwcm9wZXJ0aWVzLlxuICogLSAqKkJhY2tncm91bmQgTGlzdGVuaW5nKio6IFRoZSBgc3RhcnRMaXN0ZW5pbmdgIG1ldGhvZCBzdGFydHMgYSBiYWNrZ3JvdW5kIHByb2Nlc3MgdGhhdCBsaXN0ZW5zIGZvciBtZXNzYWdlcyBvbiB0aGUgY29uZmlndXJlZCB0b3BpYywgaW52b2tpbmcgYSBzcGVjaWZpZWQgaGFuZGxlciBmdW5jdGlvbiBmb3IgaW5jb21pbmcgbWVzc2FnZXMuXG4gKiAtICoqR3JhY2VmdWwgU2h1dGRvd24qKjogVGhlIGBzdG9wTGlzdGVuaW5nYCBtZXRob2QgYWxsb3dzIGRldmVsb3BlcnMgdG8gc3RvcCB0aGUgYmFja2dyb3VuZCBsaXN0ZW5pbmcgcHJvY2VzcyBiYXNlZCBvbiB0aGUgdG9waWMgYW5kIGNvbmZpZ3VyYXRpb24uXG4gKiBcbiAqICMjIyBVc2UgQ2FzZXM6XG4gKiAtICoqUmVhbC10aW1lIERhdGEgUHJvY2Vzc2luZyoqOiBEZXZlbG9wZXJzIGNhbiB1c2UgdGhpcyBtb2R1bGUgdG8gY29uc3VtZSBtZXNzYWdlcyBmcm9tIEthZmthIHRvcGljcyBpbiByZWFsLXRpbWUsIGVuYWJsaW5nIHVzZSBjYXNlcyBzdWNoIGFzIHN0cmVhbSBwcm9jZXNzaW5nLCBldmVudC1kcml2ZW4gYXJjaGl0ZWN0dXJlcywgYW5kIG1pY3Jvc2VydmljZXMgY29tbXVuaWNhdGlvbi5cbiAqIC0gKipJbnRlZ3JhdGlvbiB3aXRoIE90aGVyIFN5c3RlbXMqKjogQnkgY29uc3VtaW5nIEthZmthIG1lc3NhZ2VzLCBhcHBsaWNhdGlvbnMgY2FuIGludGVncmF0ZSB3aXRoIG90aGVyIHN5c3RlbXMgdGhhdCBwcm9kdWNlIG1lc3NhZ2VzIHRvIEthZmthLCBmYWNpbGl0YXRpbmcgZGF0YSBmbG93IGFjcm9zcyBkaWZmZXJlbnQgY29tcG9uZW50cyBvZiBhbiBlY29zeXN0ZW0uXG4gKiBcbiAqICMjIyBFeGFtcGxlIFVzYWdlOlxuICogYGBgdHNcbiAqIGltcG9ydCB7IENvbnN1bWVyIH0gZnJvbSBcIkBhZXJva2l0L3Nkay9rYWZrYVwiO1xuICogXG4gKiAvLyBDcmVhdGUgYSBjb25zdW1lciBmb3IgdGhlIFwib3JkZXJzXCIgdG9waWMgd2l0aCBzcGVjaWZpYyBjb25maWd1cmF0aW9uXG4gKiBjb25zdCBvcmRlcnNDb25zdW1lciA9IENvbnN1bWVyLnRvcGljKFwib3JkZXJzXCIsIHsgXCJncm91cC5pZFwiOiBcIm9yZGVyLXByb2Nlc3NvcnNcIiB9KTtcbiAqIFxuICogLy8gU3RhcnQgbGlzdGVuaW5nIHRvIHRoZSBcIm9yZGVyc1wiIHRvcGljIHdpdGggYSBtZXNzYWdlIGhhbmRsZXIgYW5kIHRpbWVvdXRcbiAqIG9yZGVyc0NvbnN1bWVyLnN0YXJ0TGlzdGVuaW5nKFwiaGFuZGxlT3JkZXJNZXNzYWdlXCIsIDMwMDAwKTtcbiAqIFxuICogLy8gTGF0ZXIsIHN0b3AgbGlzdGVuaW5nIHRvIHRoZSBcIm9yZGVyc1wiIHRvcGljXG4gKiBvcmRlcnNDb25zdW1lci5zdG9wTGlzdGVuaW5nKCk7XG4gKiBgYGBcbiAqL1xuXG5jb25zdCBLYWZrYUZhY2FkZSA9IEphdmEudHlwZShcIm9yZy5lY2xpcHNlLmRpcmlnaWJsZS5jb21wb25lbnRzLmFwaS5rYWZrYS5LYWZrYUZhY2FkZVwiKTtcblxuLyoqXG4gKiBUaGUgQ29uc3VtZXIgY2xhc3MgYWN0cyBhcyB0aGUgbWFpbiBlbnRyeSBwb2ludCBmb3IgY3JlYXRpbmcgYW5kIGNvbmZpZ3VyaW5nXG4gKiBLYWZrYSB0b3BpYyBjb25zdW1lcnMuXG4gKi9cbmV4cG9ydCBjbGFzcyBDb25zdW1lciB7XG5cbiAgICAvKipcbiAgICAgKiBDcmVhdGVzIGEgbmV3IHRvcGljIGNvbmZpZ3VyYXRpb24gd3JhcHBlciB0aGF0IGNhbiBiZSB1c2VkIHRvIHN0YXJ0IG9yXG4gICAgICogc3RvcCBsaXN0ZW5pbmcgZm9yIG1lc3NhZ2VzIG9uIGEgS2Fma2EgdG9waWMuXG4gICAgICpcbiAgICAgKiBAcGFyYW0gZGVzdGluYXRpb24gVGhlIG5hbWUgb2YgdGhlIEthZmthIHRvcGljIHRvIGNvbnN1bWUgbWVzc2FnZXMgZnJvbS5cbiAgICAgKiBAcGFyYW0gY29uZmlndXJhdGlvbiBPcHRpb25hbCBrZXktdmFsdWUgb2JqZWN0IGNvbnRhaW5pbmcgS2Fma2EgY29uc3VtZXIgcHJvcGVydGllc1xuICAgICAqIChlLmcuLCAnZ3JvdXAuaWQnLCAnYXV0by5vZmZzZXQucmVzZXQnKS5cbiAgICAgKiBAcmV0dXJucyBBIHtAbGluayBUb3BpY30gaW5zdGFuY2UgY29uZmlndXJlZCBmb3IgdGhlIHNwZWNpZmllZCBkZXN0aW5hdGlvbiBhbmQgcHJvcGVydGllcy5cbiAgICAgKi9cbiAgICBwdWJsaWMgc3RhdGljIHRvcGljKGRlc3RpbmF0aW9uOiBzdHJpbmcsIGNvbmZpZ3VyYXRpb246IHsgW2tleTogc3RyaW5nXTogc3RyaW5nIH0gPSB7fSk6IFRvcGljIHtcbiAgICAgICAgcmV0dXJuIG5ldyBUb3BpYyhkZXN0aW5hdGlvbiwgY29uZmlndXJhdGlvbik7XG4gICAgfVxufVxuXG4vKipcbiAqIFJlcHJlc2VudHMgYSBjb25maWd1cmVkIEthZmthIHRvcGljIGNvbnN1bWVyIGNhcGFibGUgb2Ygc3RhcnRpbmcgYW5kIHN0b3BwaW5nXG4gKiBiYWNrZ3JvdW5kIG1lc3NhZ2UgbGlzdGVuaW5nLlxuICovXG5jbGFzcyBUb3BpYyB7XG4gICAgcHJpdmF0ZSBkZXN0aW5hdGlvbjogc3RyaW5nO1xuICAgIHByaXZhdGUgY29uZmlndXJhdGlvbjogeyBba2V5OiBzdHJpbmddOiBzdHJpbmcgfSA9IHt9O1xuXG4gICAgLyoqXG4gICAgICogQHBhcmFtIGRlc3RpbmF0aW9uIFRoZSBuYW1lIG9mIHRoZSBLYWZrYSB0b3BpYy5cbiAgICAgKiBAcGFyYW0gY29uZmlndXJhdGlvbiBPcHRpb25hbCBrZXktdmFsdWUgb2JqZWN0IGZvciBjb25zdW1lciBwcm9wZXJ0aWVzLlxuICAgICAqL1xuICAgIGNvbnN0cnVjdG9yKGRlc3RpbmF0aW9uOiBzdHJpbmcsIGNvbmZpZ3VyYXRpb246IHsgW2tleTogc3RyaW5nXTogc3RyaW5nIH0gPSB7fSkge1xuICAgICAgICB0aGlzLmRlc3RpbmF0aW9uID0gZGVzdGluYXRpb247XG4gICAgICAgIHRoaXMuY29uZmlndXJhdGlvbiA9IGNvbmZpZ3VyYXRpb247XG4gICAgfVxuXG4gICAgLyoqXG4gICAgICogU3RhcnRzIGxpc3RlbmluZyB0byB0aGUgY29uZmlndXJlZCB0b3BpYyBpbiBhIGJhY2tncm91bmQgcHJvY2Vzcy5cbiAgICAgKlxuICAgICAqIEBwYXJhbSBoYW5kbGVyIFRoZSBwYXRoIHRvIHRoZSBzY3JpcHQgb3IgZnVuY3Rpb24gbmFtZSB0aGF0IHdpbGwgaGFuZGxlIHRoZSBpbmNvbWluZyBLYWZrYSBtZXNzYWdlcy5cbiAgICAgKiBUaGlzIGZ1bmN0aW9uIHNob3VsZCBhY2NlcHQgdHdvIGFyZ3VtZW50czogYG1lc3NhZ2VgIChzdHJpbmcpIGFuZCBgaGVhZGVyc2AgKG9iamVjdCkuXG4gICAgICogQHBhcmFtIHRpbWVvdXQgVGhlIG1heGltdW0gYW1vdW50IG9mIHRpbWUgKGluIG1pbGxpc2Vjb25kcykgdGhlIGNvbnN1bWVyIHNob3VsZCB3YWl0IGZvciBtZXNzYWdlcy5cbiAgICAgKi9cbiAgICBwdWJsaWMgc3RhcnRMaXN0ZW5pbmcoaGFuZGxlcjogc3RyaW5nLCB0aW1lb3V0OiBudW1iZXIpOiB2b2lkIHtcbiAgICAgICAgS2Fma2FGYWNhZGUuc3RhcnRMaXN0ZW5pbmcodGhpcy5kZXN0aW5hdGlvbiwgaGFuZGxlciwgdGltZW91dCwgSlNPTi5zdHJpbmdpZnkodGhpcy5jb25maWd1cmF0aW9uKSk7XG4gICAgfVxuXG4gICAgLyoqXG4gICAgICogU3RvcHMgdGhlIGJhY2tncm91bmQgcHJvY2VzcyB0aGF0IGlzIGxpc3RlbmluZyB0byB0aGUgY29uZmlndXJlZCB0b3BpYy5cbiAgICAgKiBOb3RlOiBTdG9wcGluZyBpcyBiYXNlZCBvbiBtYXRjaGluZyB0aGUgdG9waWMgYW5kIGNvbmZpZ3VyYXRpb24sIHNvIHRoZSBzYW1lXG4gICAgICogY29uZmlndXJhdGlvbiBvYmplY3QgdXNlZCBpbiBgc3RhcnRMaXN0ZW5pbmdgIHNob3VsZCBiZSB1c2VkIGhlcmUuXG4gICAgICovXG4gICAgcHVibGljIHN0b3BMaXN0ZW5pbmcoKTogdm9pZCB7XG4gICAgICAgIEthZmthRmFjYWRlLnN0b3BMaXN0ZW5pbmcodGhpcy5kZXN0aW5hdGlvbiwgSlNPTi5zdHJpbmdpZnkodGhpcy5jb25maWd1cmF0aW9uKSk7XG4gICAgfVxufVxuXG4vLyBAdHMtaWdub3JlXG5pZiAodHlwZW9mIG1vZHVsZSAhPT0gJ3VuZGVmaW5lZCcpIHtcbiAgICAvLyBAdHMtaWdub3JlXG4gICAgbW9kdWxlLmV4cG9ydHMgPSBDb25zdW1lcjtcbn0iXSwKICAibWFwcGluZ3MiOiAiQUFnQ0EsTUFBTSxjQUFjLEtBQUssS0FBSyx3REFBd0Q7QUFNL0UsTUFBTSxTQUFTO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUEsRUFXbEIsT0FBYyxNQUFNLGFBQXFCLGdCQUEyQyxDQUFDLEdBQVU7QUFDM0YsV0FBTyxJQUFJLE1BQU0sYUFBYSxhQUFhO0FBQUEsRUFDL0M7QUFDSjtBQU1BLE1BQU0sTUFBTTtBQUFBLEVBQ0E7QUFBQSxFQUNBLGdCQUEyQyxDQUFDO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQSxFQU1wRCxZQUFZLGFBQXFCLGdCQUEyQyxDQUFDLEdBQUc7QUFDNUUsU0FBSyxjQUFjO0FBQ25CLFNBQUssZ0JBQWdCO0FBQUEsRUFDekI7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBLEVBU08sZUFBZSxTQUFpQixTQUF1QjtBQUMxRCxnQkFBWSxlQUFlLEtBQUssYUFBYSxTQUFTLFNBQVMsS0FBSyxVQUFVLEtBQUssYUFBYSxDQUFDO0FBQUEsRUFDckc7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUEsRUFPTyxnQkFBc0I7QUFDekIsZ0JBQVksY0FBYyxLQUFLLGFBQWEsS0FBSyxVQUFVLEtBQUssYUFBYSxDQUFDO0FBQUEsRUFDbEY7QUFDSjtBQUdBLElBQUksT0FBTyxXQUFXLGFBQWE7QUFFL0IsU0FBTyxVQUFVO0FBQ3JCOyIsCiAgIm5hbWVzIjogW10KfQo=

package/dist/esm/kafka/index.mjs

@@ -1,9 +0,0 @@
-import { Consumer } from "./consumer";
-export * from "./consumer";
-import { Producer } from "./producer";
-export * from "./producer";
-export {
-  Consumer as consumer,
-  Producer as producer
-};
-//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vc3JjL2thZmthL2luZGV4LnRzIl0sCiAgInNvdXJjZXNDb250ZW50IjogWyIvKipcbiAqIEBtb2R1bGUga2Fma2EvaW5kZXhcbiAqIEBwYWNrYWdlIEBhZXJva2l0L3Nkay9rYWZrYVxuICogQG92ZXJ2aWV3XG4gKiBcbiAqIFRoaXMgbW9kdWxlIHByb3ZpZGVzIGZ1bmN0aW9uYWxpdGllcyBmb3IgS2Fma2EgaW50ZWdyYXRpb24gd2l0aGluIHRoZSBBZXJva2l0IFNESy4gSXQgaW5jbHVkZXMgY2xhc3NlcyBhbmQgbWV0aG9kcyBmb3IgcHJvZHVjaW5nIGFuZCBjb25zdW1pbmcgbWVzc2FnZXMgZnJvbSBLYWZrYSB0b3BpY3MsIGFzIHdlbGwgYXMgbWFuYWdpbmcgS2Fma2EgY29uZmlndXJhdGlvbnMgYW5kIGNvbm5lY3Rpb25zLlxuICogXG4gKiBUaGUgbWFpbiBjb21wb25lbnRzIG9mIHRoaXMgbW9kdWxlIGFyZTpcbiAqIC0gQ29uc3VtZXI6IFJlcHJlc2VudHMgYSBLYWZrYSBjb25zdW1lciB0aGF0IGNhbiBzdWJzY3JpYmUgdG8gdG9waWNzIGFuZCBjb25zdW1lIG1lc3NhZ2VzLlxuICogLSBQcm9kdWNlcjogUmVwcmVzZW50cyBhIEthZmthIHByb2R1Y2VyIHRoYXQgY2FuIHNlbmQgbWVzc2FnZXMgdG8gdG9waWNzLlxuICovXG5cbmV4cG9ydCB7IENvbnN1bWVyIGFzIGNvbnN1bWVyIH0gZnJvbSBcIi4vY29uc3VtZXJcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2NvbnN1bWVyXCI7XG5leHBvcnQgeyBQcm9kdWNlciBhcyBwcm9kdWNlciB9IGZyb20gXCIuL3Byb2R1Y2VyXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9wcm9kdWNlclwiOyJdLAogICJtYXBwaW5ncyI6ICJBQVlBLFNBQXFCLGdCQUFnQjtBQUNyQyxjQUFjO0FBQ2QsU0FBcUIsZ0JBQWdCO0FBQ3JDLGNBQWM7IiwKICAibmFtZXMiOiBbXQp9Cg==

package/dist/esm/kafka/producer.mjs

@@ -1,53 +0,0 @@
-const KafkaFacade = Java.type("org.eclipse.dirigible.components.api.kafka.KafkaFacade");
-class Producer {
-  /**
-   * Creates a new topic configuration wrapper that can be used to send messages
-   * to a specific Kafka topic.
-   *
-   * @param destination The name of the Kafka topic to send messages to.
-   * @param configuration Optional key-value object containing Kafka producer properties
-   * (e.g., 'bootstrap.servers', 'acks').
-   * @returns A {@link Topic} instance configured for the specified destination and properties.
-   */
-  static topic(destination, configuration = {}) {
-    return new Topic(destination, configuration);
-  }
-  /**
-   * Closes the Kafka producer connection pool, releasing associated resources.
-   * This should be called when message sending is complete to ensure proper cleanup.
-   *
-   * @param configuration Optional key-value object containing the configuration
-   * used to initialize the producer to be closed.
-   */
-  static close(configuration = {}) {
-    KafkaFacade.closeProducer(configuration);
-  }
-}
-class Topic {
-  destination;
-  configuration;
-  /**
-   * @param destination The name of the Kafka topic.
-   * @param configuration Key-value object for producer properties.
-   */
-  constructor(destination, configuration) {
-    this.destination = destination;
-    this.configuration = configuration;
-  }
-  /**
-   * Sends a message with an optional key to the configured Kafka topic.
-   *
-   * @param key The key of the message. Messages with the same key go to the same partition.
-   * @param value The content of the message to be sent.
-   */
-  send(key, value) {
-    KafkaFacade.send(this.destination, key, value, JSON.stringify(this.configuration));
-  }
-}
-if (typeof module !== "undefined") {
-  module.exports = Producer;
-}
-export {
-  Producer
-};
-//# sourceMappingURL=data:application/json;base64,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