javonet-nodejs-sdk 2.6.12 → 2.6.14

package/dist/sdk/configuration/configResolvers/ConfigResolver.cjs

@@ -39,17 +39,15 @@ class ConfigResolver {
     return import_RuntimeNameHandler.RuntimeNameHandler.getRuntime(normalized);
   }
   /**
-   * Build appropriate connection data object from a host string.
-   * - empty / null => InMemoryConnectionData
-   * - "inmemory" or "in-memory" => InMemoryConnectionData
-   * - ws:// or wss:// => WsConnectionData(fullAddress)
-   * - tcp://... => parsed by parseTcp
-   * - host:port or host:port/... => TcpConnectionData(host, port) if valid, otherwise InMemoryConnectionData
+   * Builds connection data from the host string from config (JSON, YAML, or connection string).
+   * Recognized formats: empty (in-memory), "inmemory"/"in-memory", ws://..., wss://..., tcp://host:port, host:port.
+   * When the value is missing, invalid, or unparseable, falls back to InMemoryConnectionData and logs the reason.
    * @param {string} hostValue
    * @returns {InMemoryConnectionData|WsConnectionData|TcpConnectionData}
    */
   static buildConnectionData(hostValue) {
     if (!hostValue || String(hostValue).trim() === "") {
+      console.warn("Host not specified; using in-memory.");
       return new import_InMemoryConnectionData.InMemoryConnectionData();
     }
     const hv = String(hostValue).trim();
@@ -64,6 +62,7 @@ class ConfigResolver {
       try {
         return ConfigResolver.parseTcp(hv.slice(6));
       } catch (e) {
+        console.warn("Invalid or unparseable tcp:// address '" + hv + "'; falling back to in-memory.");
         return new import_InMemoryConnectionData.InMemoryConnectionData();
       }
     }
@@ -84,12 +83,14 @@ class ConfigResolver {
           try {
             return new import_TcpConnectionData.TcpConnectionData(hostOnly, port);
           } catch (e) {
+            console.warn("Could not create TCP connection for '" + hv + "'; falling back to in-memory.");
             return new import_InMemoryConnectionData.InMemoryConnectionData();
           }
         }
       } catch (e) {
       }
     }
+    console.warn("Host value '" + hv + "' is not a recognized connection format (expected: empty, 'inmemory', 'in-memory', 'ws://...', 'wss://...', 'tcp://host:port', or 'host:port'). Falling back to in-memory.");
     return new import_InMemoryConnectionData.InMemoryConnectionData();
   }
   /**

package/dist/sdk/tools/DtoHelper.cjs

@@ -0,0 +1,100 @@
+"use strict";
+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 DtoHelper_exports = {};
+__export(DtoHelper_exports, {
+  DtoHelper: () => DtoHelper
+});
+module.exports = __toCommonJS(DtoHelper_exports);
+var import_Command = require("../../utils/Command.cjs");
+var import_CommandType = require("../../utils/CommandType.cjs");
+class DtoHelper {
+  /**
+   * Attempts to retrieve a DTO field value by field name from a command chain.
+   *
+   * @param {Command | null} command - The command to search through.
+   * @param {string} fieldName - The name of the field to retrieve.
+   * @returns {any}
+   */
+  static tryGetDtoFieldValue(command, fieldName) {
+    let value = null;
+    let currentCommand = command;
+    while (currentCommand !== void 0 && currentCommand !== null) {
+      if (currentCommand.commandType === import_CommandType.CommandType.SetInstanceField && DtoHelper._tryGetDtoFieldName(currentCommand) && DtoHelper._getDtoFieldName(currentCommand) === fieldName) {
+        value = DtoHelper._tryGetDtoFieldValueFromCommand(currentCommand);
+        return value;
+      }
+      if (!currentCommand.payload || currentCommand.payload.length === 0) {
+        break;
+      }
+      const firstPayload = currentCommand.payload[0];
+      currentCommand = firstPayload instanceof import_Command.Command ? firstPayload : null;
+    }
+    return null;
+  }
+  /**
+   * Attempts to extract the field name from a SetInstanceField command.
+   * @param {Command} command
+   * @returns {boolean}
+   */
+  static _tryGetDtoFieldName(command) {
+    if (command.payload.length < 2) {
+      return false;
+    }
+    const nameValue = DtoHelper._tryGetPayloadValue(command.payload[1]);
+    return typeof nameValue === "string";
+  }
+  /**
+   * Extracts the field name from a SetInstanceField command.
+   * @param {Command} command
+   * @returns {string}
+   */
+  static _getDtoFieldName(command) {
+    if (command.payload.length < 2) {
+      return "";
+    }
+    const nameValue = DtoHelper._tryGetPayloadValue(command.payload[1]);
+    return typeof nameValue === "string" ? nameValue : "";
+  }
+  /**
+   * Attempts to extract the field value from a SetInstanceField command.
+   * @param {Command} command
+   * @returns {any}
+   */
+  static _tryGetDtoFieldValueFromCommand(command) {
+    if (command.payload.length < 3) {
+      return null;
+    }
+    return DtoHelper._tryGetPayloadValue(command.payload[2]);
+  }
+  /**
+   * Attempts to extract a value from a payload item, handling Value command types.
+   * @param {any} payloadItem
+   * @returns {any}
+   */
+  static _tryGetPayloadValue(payloadItem) {
+    if (payloadItem instanceof import_Command.Command && payloadItem.commandType === import_CommandType.CommandType.Value && payloadItem.payload.length > 0) {
+      return payloadItem.payload[0];
+    }
+    return payloadItem;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DtoHelper
+});

package/dist/types/core/handler/ArraySetItemHandler.d.ts

@@ -7,6 +7,6 @@ export class ArraySetItemHandler extends AbstractHandler {
     /**
      * @param {Command} command
      */
-    process(command: Command): number;
+    process(command: Command): any;
 }
 import { AbstractHandler } from './AbstractHandler.js';

package/dist/types/core/handler/AsDtoHandler.d.ts

@@ -0,0 +1,7 @@
+export class AsDtoHandler extends AbstractHandler {
+    /**
+     * @param {any} command
+     */
+    process(command: any): void;
+}
+import { AbstractHandler } from './AbstractHandler.js';

package/dist/types/core/handler/AsKwargsHandler.d.ts

@@ -2,6 +2,6 @@ export class AsKwargsHandler extends AbstractHandler {
     /**
      * @param {any} command
      */
-    handleCommand(command: any): void;
+    process(command: any): void;
 }
 import { AbstractHandler } from './AbstractHandler.js';

package/dist/types/core/handler/DestructReferenceHandler.d.ts

@@ -3,9 +3,10 @@ export type Command = import("../../utils/Command.js").Command;
  * @typedef {import('../../utils/Command.js').Command} Command
  */
 export class DestructReferenceHandler extends AbstractHandler {
+    requiredParametersCount: number;
     /**
      * @param {Command} command
      */
-    process(command: Command): number;
+    process(command: Command): boolean;
 }
 import { AbstractHandler } from './AbstractHandler.js';

package/dist/types/core/handler/DtoPropertyHandler.d.ts

@@ -0,0 +1,7 @@
+export class DtoPropertyHandler extends AbstractHandler {
+    /**
+     * @param {any} command
+     */
+    process(command: any): void;
+}
+import { AbstractHandler } from './AbstractHandler.js';

package/dist/types/core/handler/ProjectResultAsDtoHandler.d.ts

@@ -0,0 +1,9 @@
+export class ProjectResultAsDtoHandler extends AbstractHandler {
+    requiredParametersCount: number;
+    /**
+     * @param {Command} command
+     */
+    process(command: Command): any[];
+}
+import { AbstractHandler } from './AbstractHandler.js';
+import { Command } from '../../utils/Command.js';

package/dist/types/core/handler/SetInstanceFieldHandler.d.ts

@@ -7,6 +7,6 @@ export class SetInstanceFieldHandler extends AbstractHandler {
     /**
      * @param {Command} command
      */
-    process(command: Command): number;
+    process(command: Command): any;
 }
 import { AbstractHandler } from './AbstractHandler.js';

package/dist/types/core/handler/SetStaticFieldHandler.d.ts

@@ -7,6 +7,6 @@ export class SetStaticFieldHandler extends AbstractHandler {
     /**
      * @param {Command} command
      */
-    process(command: Command): number;
+    process(command: Command): any;
 }
 import { AbstractHandler } from './AbstractHandler.js';

package/dist/types/core/interpreter/Interpreter.d.ts

@@ -1,11 +1,11 @@
 export class Interpreter {
     /**
-     *
+     * @param {string} runtimeContextId
      * @param {Command} command
      * @param {IConnectionData} connectionData
      * @returns {Promise<Command>}
      */
-    static execute(command: Command, connectionData: IConnectionData): Promise<Command>;
+    static execute(runtimeContextId: string, command: Command, connectionData: IConnectionData): Promise<Command>;
     /**
      *
      * @param {Uint8Array} messageByteArray
@@ -15,4 +15,4 @@ export class Interpreter {
 }
 export type IConnectionData = import("../../utils/connectionData/IConnectionData.js").IConnectionData;
 export type RuntimeNameType = typeof import("../../types.d.ts").RuntimeName;
-export type Command = import("../../utils/Command.js").Command;
+import { Command } from '../../utils/Command.js';

package/dist/types/core/protocol/CommandDeserializer.d.ts

@@ -28,5 +28,6 @@ export class CommandDeserializer {
     readUllong(): bigint;
     readUInt(): number;
     readNull(): null;
+    readUndefined(): undefined;
 }
 import { Command } from '../../utils/Command.js';

package/dist/types/core/protocol/TypeDeserializer.d.ts

@@ -46,5 +46,6 @@ export class TypeDeserializer {
      */
     static deserializeUInt(encodedUInt: Uint8Array): number;
     static deserializeNull(encodedNull?: null): null;
+    static deserializeUndefined(encodedUndefined?: null): undefined;
 }
 import { Command } from '../../utils/Command.js';

package/dist/types/core/protocol/TypeSerializer.d.ts

@@ -48,6 +48,7 @@ export class TypeSerializer {
      */
     static serializeUInt(uint_value: number): Buffer<ArrayBuffer>;
     static serializeNull(): Buffer<ArrayBuffer>;
+    static serializeUndefined(): Buffer<ArrayBuffer>;
     /**
      * @param {number} int_value
      */

package/dist/types/core/referenceCache/ReferencesCache.d.ts

@@ -17,8 +17,8 @@ export class ReferencesCache {
      */
     resolveReference(id: string): any;
     /**
-     * @param {string} id
-     * @returns {number}
+     * @param {string} reference_guid
+     * @returns {boolean}
      */
-    deleteReference(id: string): number;
+    deleteReference(reference_guid: string): boolean;
 }

package/dist/types/plugins/PluginImplementationRegistry.d.ts

@@ -0,0 +1,121 @@
+/**
+ * A registry for managing plugins and their implementations.
+ * Provides access to registered plugin instances and their typed variants,
+ * allowing for dynamic plugin resolution at runtime.
+ *
+ * This class acts as a lightweight alternative to a dependency injection container,
+ * supporting both singleton and transient lifecycles for plugins.
+ * Plugins can be resolved by type, and optionally created with constructor arguments.
+ */
+export class PluginImplementationRegistry {
+    /** @type {Map<string, Function>} Map of interface names to implementation constructors for transient plugins */
+    static "__#2@#transientImplementations": Map<string, Function>;
+    /** @type {Map<Function, object>} Map of implementation types to singleton instances */
+    static "__#2@#singletonImplementations": Map<Function, object>;
+    /** @type {Map<Function, object>} Map of settings types to configuration objects */
+    static "__#2@#pluginConfigurations": Map<Function, object>;
+    /**
+     * Registers a transient plugin implementation. A new instance will be created each time the plugin is resolved.
+     *
+     * @param {Function} InterfaceClass - The interface or base class of the plugin (must be a class/constructor)
+     * @param {Function} ImplementationClass - The concrete class that implements InterfaceClass
+     * @throws {TypeError} If InterfaceClass is not a function/constructor
+     * @throws {TypeError} If ImplementationClass is not a function/constructor
+     *
+     * @example
+     * PluginImplementationRegistry.registerPluginTransientImplementation(IJwtAuthorize, JwtAuthorizeImpl)
+     */
+    static registerPluginTransientImplementation(InterfaceClass: Function, ImplementationClass: Function): void;
+    /**
+     * Resolves a new instance of a transiently registered plugin.
+     *
+     * @param {Function} InterfaceClass - The type of the plugin interface to resolve
+     * @param {...any} constructorArgs - Optional arguments to pass to the constructor
+     * @returns {object} A newly created instance of the registered implementation
+     * @throws {Error} If the plugin type has not been registered as transient
+     * @throws {TypeError} If InterfaceClass is not a function/constructor
+     *
+     * @example
+     * const jwtAuthorize = PluginImplementationRegistry.resolvePluginTransientImplementation(IJwtAuthorize)
+     */
+    static resolvePluginTransientImplementation(InterfaceClass: Function, ...constructorArgs: any[]): object;
+    /**
+     * Registers a plugin configuration/settings object.
+     *
+     * @param {Function} SettingsClass - The settings class type
+     * @param {object} settings - The settings instance to register
+     * @throws {TypeError} If SettingsClass is not a function/constructor
+     * @throws {TypeError} If settings is not an object
+     *
+     * @example
+     * const settings = new JwtGraftocodePluginSettings()
+     * settings.username = 'user'
+     * settings.secretKey = 'key'
+     * PluginImplementationRegistry.registerPluginConfiguration(JwtGraftocodePluginSettings, settings)
+     */
+    static registerPluginConfiguration(SettingsClass: Function, settings: object): void;
+    /**
+     * Retrieves the configuration object of the specified type for a given plugin.
+     *
+     * @param {Function} SettingsClass - The expected configuration type
+     * @returns {object | null} The configuration object, or null if not found
+     * @throws {TypeError} If SettingsClass is not a function/constructor
+     *
+     * @example
+     * const config = PluginImplementationRegistry.getPluginConfiguration(JwtGraftocodePluginSettings)
+     * if (config) {
+     *   console.log(config.username)
+     * }
+     */
+    static getPluginConfiguration(SettingsClass: Function): object | null;
+    /**
+     * Checks whether a configuration has been registered for the specified plugin type.
+     *
+     * @param {Function} SettingsClass - The settings class type to check
+     * @returns {boolean} True if a configuration entry exists, false otherwise
+     * @throws {TypeError} If SettingsClass is not a function/constructor
+     *
+     * @example
+     * if (PluginImplementationRegistry.isPluginConfigurationAvailable(JwtGraftocodePluginSettings)) {
+     *   // Configuration exists
+     * }
+     */
+    static isPluginConfigurationAvailable(SettingsClass: Function): boolean;
+    /**
+     * Registers a new plugin implementation of the specified type and stores it as a singleton instance.
+     *
+     * @param {Function} InterfaceClass - The interface or base class that the plugin implementation inherits or implements
+     * @param {Function} ImplementationClass - The concrete plugin type to register
+     * @param {...any} constructorArgs - Optional arguments to pass to the constructor
+     * @throws {TypeError} If InterfaceClass is not a function/constructor
+     * @throws {TypeError} If ImplementationClass is not a function/constructor
+     *
+     * @example
+     * PluginImplementationRegistry.registerPluginSingletonImplementation(IJwtAuthorize, JwtAuthorizeImpl)
+     * // Or with constructor arguments:
+     * PluginImplementationRegistry.registerPluginSingletonImplementation(IJwtAuthorize, JwtAuthorizeImpl, 'arg1', 'arg2')
+     */
+    static registerPluginSingletonImplementation(InterfaceClass: Function, ImplementationClass: Function, ...constructorArgs: any[]): void;
+    /**
+     * Resolves a registered plugin implementation by its type.
+     *
+     * @param {Function} ImplementationClass - The type of the plugin implementation to resolve
+     * @returns {object} The registered plugin instance
+     * @throws {Error} If no plugin instance of the specified type is found in the registry
+     * @throws {TypeError} If ImplementationClass is not a function/constructor
+     *
+     * @example
+     * const plugin = PluginImplementationRegistry.resolvePluginSingletonImplementation(JwtAuthorizeImpl)
+     */
+    static resolvePluginSingletonImplementation(ImplementationClass: Function): object;
+    /**
+     * Resets the entire plugin implementation registry to its initial state.
+     * Clears all registered plugins and configurations.
+     * Useful for testing or reconfiguration scenarios.
+     *
+     * @example
+     * PluginImplementationRegistry.reset()
+     * // Can now register new plugins
+     */
+    static reset(): void;
+}

package/dist/types/plugins/PluginPayloadBuilder.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Builds serialized payloads from registered plugins.
+ * This class is responsible for retrieving plugins from the registry,
+ * executing them, and serializing their output for transmission.
+ */
+export class PluginPayloadBuilder {
+    /**
+     * Builds the plugin payload for a specific runtime context.
+     * Retrieves the sending plugin registered for the given runtime context ID,
+     * executes it, and returns the serialized result.
+     *
+     * @param {string} runtimeContextId - The UUID of the runtime context
+     * @returns {string} JSON-serialized plugin payload
+     * @throws {Error} If no plugin is found for the runtime context
+     * @throws {Error} If plugin execution fails
+     *
+     * @example
+     * const payload = PluginPayloadBuilder.buildPluginsPayload(runtimeContextId)
+     * // Returns: '{"token":"abc123","timestamp":1234567890}'
+     */
+    static buildPluginsPayload(runtimeContextId: string): string;
+    /**
+     * Serializes an object to JSON string.
+     *
+     * @param {object} payload - The payload object to serialize
+     * @returns {string} JSON-serialized string
+     * @throws {Error} If serialization fails
+     *
+     * @private
+     */
+    private static serializeObject;
+}

package/dist/types/plugins/PluginRegistry.d.ts

@@ -0,0 +1,157 @@
+/**
+ * A thread-safe registry for managing plugins.
+ * Provides access to registered plugin instances and their typed variants,
+ * allowing for dynamic plugin resolution at runtime.
+ *
+ * Note: JavaScript is single-threaded (event loop), so thread-safety considerations
+ * from the .NET implementation are not needed here. However, the freeze pattern
+ * is still used to prevent modifications after the registration phase.
+ */
+export class PluginRegistry {
+    /** @type {Map<string, object>} Map of runtime context IDs to sending plugin instances */
+    static "__#1@#sendingPlugins": Map<string, object>;
+    /** @type {Map<string, object> | null} Immutable snapshot of sending plugins after freeze */
+    static "__#1@#sendingSnapshot": Map<string, object> | null;
+    /** @type {SendingPluginCacheEntry | null} Hot cache for last accessed plugin */
+    static "__#1@#sendingCache": SendingPluginCacheEntry | null;
+    /** @type {object | null} The receiving plugin instance */
+    static "__#1@#receivingPlugin": object | null;
+    /** @type {Function | null} The receiving plugin constructor/class */
+    static "__#1@#receivingPluginType": Function | null;
+    /** @type {string[] | null} Array of registered runtime context IDs for fast lookup */
+    static "__#1@#registeredKeys": string[] | null;
+    /** @type {boolean} Whether to create new plugin instances on each resolve */
+    static "__#1@#useTransientPlugins": boolean;
+    /** @type {boolean} Whether the registry has been frozen */
+    static "__#1@#isFrozen": boolean;
+    /**
+     * Checks if a receiving plugin has been registered
+     * @returns {boolean} True if a receiving plugin exists
+     */
+    static get hasReceivingPlugin(): boolean;
+    /**
+     * Registers a sending plugin implementation for a specific runtime context.
+     * The plugin is stored as a singleton instance and can later be resolved using the runtime context ID.
+     *
+     * @param {string} runtimeContextId - The UUID of the runtime context
+     * @param {object} plugin - Plugin instance that implements ICommunitySendingPlugin interface
+     * @throws {Error} If registry is already frozen
+     * @throws {TypeError} If plugin doesn't have required execute method
+     *
+     * @example
+     * const plugin = new JwtPlugin('token123')
+     * PluginRegistry.registerSendingPlugin(runtimeCtx.runtimeContextId, plugin)
+     */
+    static registerSendingPlugin(runtimeContextId: string, plugin: object): void;
+    /**
+     * Registers a receiving plugin implementation.
+     * The plugin is stored as a singleton instance and executed on the receiving side.
+     * Only one receiving plugin can be registered per application.
+     *
+     * @param {object} plugin - Plugin instance that implements ICommunityReceivingPlugin interface
+     * @throws {Error} If a receiving plugin is already registered
+     * @throws {Error} If registry is already frozen
+     * @throws {TypeError} If plugin doesn't have required execute method
+     *
+     * @example
+     * const plugin = new ValidationPlugin()
+     * PluginRegistry.registerReceivingPlugin(plugin)
+     */
+    static registerReceivingPlugin(plugin: object): void;
+    /**
+     * Resolves and returns the registered receiving plugin instance.
+     * If transient mode is enabled, creates a new instance.
+     *
+     * @returns {object} The receiving plugin instance
+     * @throws {Error} If no receiving plugin has been registered
+     *
+     * @example
+     * const plugin = PluginRegistry.resolveReceivingPlugin()
+     * const result = plugin.execute(payload, target)
+     */
+    static resolveReceivingPlugin(): object;
+    /**
+     * Attempts to retrieve a sending plugin registered for the specified runtime context.
+     * First checks a single-entry hot cache for the last accessed plugin,
+     * and if not found, falls back to the map of registered plugins.
+     * On a successful map lookup, the cache is updated with the resolved entry
+     * for faster access in subsequent calls.
+     *
+     * @param {string} runtimeContextId - The identifier of the runtime context
+     * @returns {{success: boolean, plugin: object | null}} Object with success flag and plugin instance
+     *
+     * @example
+     * const result = PluginRegistry.tryGetSendingPlugin(runtimeContextId)
+     * if (result.success) {
+     *   const payload = result.plugin.execute()
+     * }
+     */
+    static tryGetSendingPlugin(runtimeContextId: string): {
+        success: boolean;
+        plugin: object | null;
+    };
+    /**
+     * Checks whether any plugins have been registered for given RuntimeContext ID.
+     *
+     * @param {string} runtimeContextId - The identifier of the runtime context
+     * @returns {boolean} True if at least one plugin is registered for the runtime context
+     *
+     * @example
+     * if (PluginRegistry.arePluginsRegisteredForRuntime(runtimeContextId)) {
+     *   // Build and wrap command with plugin payload
+     * }
+     */
+    static arePluginsRegisteredForRuntime(runtimeContextId: string): boolean;
+    /**
+     * Finalizes the plugin registration phase by creating a compact snapshot of all registered keys.
+     * This snapshot is stored to allow extremely fast lookups on the hot path.
+     * After calling freeze(), no more plugins can be registered unless reset() is called.
+     *
+     * @param {boolean} useTransientPlugins - If true, creates new plugin instances on each resolve
+     *
+     * @example
+     * // Register all plugins
+     * PluginRegistry.registerSendingPlugin(rtmCtx.runtimeContextId, plugin1)
+     * PluginRegistry.registerSendingPlugin(rtmCtx2.runtimeContextId, plugin2)
+     *
+     * // Freeze the registry
+     * PluginRegistry.freeze()
+     *
+     * // Or freeze with transient mode
+     * PluginRegistry.freeze(true)
+     */
+    static freeze(useTransientPlugins?: boolean): void;
+    /**
+     * Resets the entire plugin registry to its initial state.
+     * Clears all registered plugins and unfreezes the registry.
+     * Useful for testing or reconfiguration scenarios.
+     *
+     * @example
+     * PluginRegistry.reset()
+     * // Can now register new plugins
+     */
+    static reset(): void;
+    /**
+     * Checks if the registry has been frozen
+     * @returns {boolean} True if the registry is frozen
+     */
+    static get isFrozen(): boolean;
+}
+export type SendingPluginCacheEntry = {
+    /**
+     * - The runtime context ID
+     */
+    key: string;
+    /**
+     * - The plugin instance
+     */
+    value: object;
+    /**
+     * - Whether the entry has a value
+     */
+    hasValue: boolean;
+    /**
+     * - The plugin constructor/class
+     */
+    type: Function;
+};

package/dist/types/plugins/index.d.ts

@@ -0,0 +1,8 @@
+export { PluginRegistry } from "./PluginRegistry.js";
+export { PluginPayloadBuilder } from "./PluginPayloadBuilder.js";
+export { ICommunityPlugin } from "./interfaces/ICommunityPlugin.js";
+export { ICommunitySendingPlugin } from "./interfaces/ICommunitySendingPlugin.js";
+export { ICommunityReceivingPlugin } from "./interfaces/ICommunityReceivingPlugin.js";
+export { PluginImplementationRegistry } from "./PluginImplementationRegistry.js";
+export { JwtGraftocodePluginSettings } from "./settings/JwtGraftocodePluginSettings.js";
+export { BasePluginSettings, PluginLangType } from "./settings/BasePluginSettings.js";

package/dist/types/plugins/interfaces/ICommunityPlugin.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Represents a plugin that can be registered, configured, and executed within the system.
+ * This is the base interface that all plugins must implement.
+ *
+ * @interface ICommunityPlugin
+ */
+export class ICommunityPlugin {
+    /**
+     * Unique identifier for the plugin.
+     * This should be a string that uniquely identifies the plugin across the system.
+     * @type {string}
+     */
+    pluginId: string;
+}