javonet-nodejs-sdk 2.5.9 → 2.5.10

package/dist/Javonet.d.ts

@@ -36,7 +36,12 @@ declare module "Binaries/Nodejs/lib/utils/CommandType" {
     export let EnableNamespace: 34;
     export let EnableType: 35;
     export let CreateNull: 36;
-    export let InvokeStandaloneMethod: 37;
+    export let GetStaticMethodAsDelegate: 37;
+    export let GetInstanceMethodAsDelegate: 38;
+    export let PassDelegate: 39;
+    export let InvokeDelegate: 40;
+    export let ConvertType: 41;
+    export let InvokeStandaloneMethod: 42;
 }
 declare module "Binaries/Nodejs/lib/utils/Command" {
     export = Command;
@@ -309,6 +314,33 @@ declare module "Binaries/Nodejs/lib/core/interpreter/Interpreter" {
     }
     type WsConnectionData = any;
 }
+declare module "Binaries/Nodejs/lib/utils/guid/generateGuid" {
+    export = generateGUID;
+    function generateGUID(): string;
+}
+declare module "Binaries/Nodejs/lib/core/delegatesCache/DelegatesCache" {
+    const _exports: DelegatesCache;
+    export = _exports;
+    /**
+     * A cache for storing and retrieving delegates.
+     */
+    class DelegatesCache {
+        cache: Map<any, any>;
+        /**
+         * Adds a delegate to the cache and returns its unique ID.
+         * @param {Function} delegateInstance - The delegate function to store.
+         * @returns {string} The unique ID for the delegate.
+         */
+        addDelegate(delegateInstance: Function): string;
+        /**
+         * Retrieves a delegate by its unique ID.
+         * @param {string} delegateId - The unique ID of the delegate.
+         * @returns {Function} The delegate function.
+         * @throws {Error} If the delegate is not found.
+         */
+        getDelegate(delegateId: string): Function;
+    }
+}
 declare module "Binaries/Nodejs/lib/utils/ExceptionType" {
     export let EXCEPTION: 0;
     export let IO_EXCEPTION: 1;
@@ -496,6 +528,26 @@ declare module "Binaries/Nodejs/lib/sdk/InvocationContext" {
          * @method
          */
         createNull(): InvocationContext;
+        /**
+         * Creates a null object of a specific type on the target runtime.
+         * @param {string} methodName - The name of the method to invoke.
+         * @param {...any} args - Method arguments.
+         * @returns {InvocationContext} An InvocationContext instance with the command to create a null object.
+         * TODO: connect documentation page url
+         * @see [Javonet Guides](https://www.javonet.com/guides/)
+         * @method
+         */
+        getStaticMethodAsDelegate(methodName: string, ...args: any[]): InvocationContext;
+        /**
+         * Creates a null object of a specific type on the target runtime.
+         * @param {string} methodName - The name of the method to invoke.
+         * @param {...any} args - Method arguments.
+         * @returns {InvocationContext} An InvocationContext instance with the command to create a null object.
+         * TODO: connect documentation page url
+         * @see [Javonet Guides](https://www.javonet.com/guides/)
+         * @method
+         */
+        getInstanceMethodAsDelegate(methodName: string, ...args: any[]): InvocationContext;
         /**
          * Retrieves an array from the target runtime.
          * @returns {InvocationContext} A new InvocationContext instance that wraps the command to retrieve the array.
@@ -762,6 +814,7 @@ declare module "Binaries/Nodejs/index" {
     import TypeDeserializer = require("Binaries/Nodejs/lib/core/protocol/TypeDeserializer");
     import TypeSerializer = require("Binaries/Nodejs/lib/core/protocol/TypeSerializer");
     import Interpreter = require("Binaries/Nodejs/lib/core/interpreter/Interpreter");
+    import DelegatesCache = require("Binaries/Nodejs/lib/core/delegatesCache/DelegatesCache");
     import { InvocationContext } from "Binaries/Nodejs/lib/sdk/InvocationContext";
     import { InvocationWsContext } from "Binaries/Nodejs/lib/sdk/InvocationContext";
     import RuntimeContext = require("Binaries/Nodejs/lib/sdk/RuntimeContext");
@@ -779,7 +832,7 @@ declare module "Binaries/Nodejs/index" {
     import WsConnectionData = require("Binaries/Nodejs/lib/utils/connectionData/WsConnectionData");
     import ExceptionSerializer = require("Binaries/Nodejs/lib/utils/exception/ExceptionSerializer");
     import ExceptionThrower = require("Binaries/Nodejs/lib/utils/exception/ExceptionThrower");
-    export { CommandSerializer, CommandDeserializer, TypeDeserializer, TypeSerializer, Interpreter, InvocationContext, InvocationWsContext, RuntimeContext, RuntimeFactory, Command, CommandType, ConnectionType, ExceptionType, RuntimeName, RuntimeNameHandler, StringEncodingMode, Type, IConnectionData, InMemoryConnectionData, WsConnectionData, ExceptionSerializer, ExceptionThrower };
+    export { CommandSerializer, CommandDeserializer, TypeDeserializer, TypeSerializer, Interpreter, DelegatesCache, InvocationContext, InvocationWsContext, RuntimeContext, RuntimeFactory, Command, CommandType, ConnectionType, ExceptionType, RuntimeName, RuntimeNameHandler, StringEncodingMode, Type, IConnectionData, InMemoryConnectionData, WsConnectionData, ExceptionSerializer, ExceptionThrower };
 }
 declare module "Binaries/Nodejs/lib/core/generator/handler/AbstractGeneratorHandler" {
     export = AbstractGeneratorHandler;
@@ -1017,6 +1070,81 @@ declare module "Binaries/Nodejs/lib/core/handler/CastingHandler" {
     }
     import AbstractHandler = require("Binaries/Nodejs/lib/core/handler/AbstractHandler");
 }
+declare module "Binaries/Nodejs/lib/utils/TypesConverter" {
+    /**
+     * ConvertTypeHandler class handles the conversion of JType to Type.
+     */
+    export class ConvertTypeHandler {
+        /**
+         * Minimum required parameters count for the command.
+         * @type {number}
+         */
+        requiredParametersCount: number;
+        /**
+         * Processes the given command to convert JType to Type.
+         * @param {Object} command - The command to process.
+         * @returns {any} The converted type.
+         */
+        process(command: Object): any;
+        /**
+         * Validates the command to ensure it has enough parameters.
+         * @param {Object} command - The command to validate.
+         */
+        validateCommand(command: Object): void;
+    }
+    /**
+     * TypesConverter class provides utilities for converting between types.
+     */
+    export class TypesConverter {
+        /**
+         * Converts a JavaScript type to a JType equivalent.
+         * @param {Function} type - The JavaScript type.
+         * @returns {number} The corresponding JType.
+         */
+        static convertTypeToJType(type: Function): number;
+        /**
+         * Converts a JType to a JavaScript type equivalent.
+         * @param {number} type - The JType to convert.
+         * @returns {Function} The corresponding JavaScript type.
+         */
+        static convertJTypeToType(type: number): Function;
+    }
+    /**
+     * Enum for JType mappings.
+     */
+    export type JType = number;
+    export namespace JType {
+        let Boolean: number;
+        let Float: number;
+        let String: number;
+        let Null: number;
+    }
+}
+declare module "Binaries/Nodejs/lib/core/handler/ConvertTypeHandler" {
+    export = ConvertTypeHandler;
+    /**
+     * ConvertTypeHandler class handles the conversion of JType to Type.
+     */
+    class ConvertTypeHandler extends AbstractHandler {
+        /**
+         * Minimum required parameters count for the command.
+         * @type {number}
+         */
+        requiredParametersCount: number;
+        /**
+         * Processes the given command to convert JType to Type.
+         * @param {Object} command - The command to process.
+         * @returns {any} The converted type.
+         */
+        process(command: Object): any;
+        /**
+         * Validates the command to ensure it has enough parameters.
+         * @param {Object} command - The command to validate.
+         */
+        validateCommand(command: Object): void;
+    }
+    import AbstractHandler = require("Binaries/Nodejs/lib/core/handler/AbstractHandler");
+}
 declare module "Binaries/Nodejs/lib/core/handler/CreateClassInstanceHandler" {
     const _exports: CreateClassInstanceHandler;
     export = _exports;
@@ -1123,6 +1251,48 @@ declare module "Binaries/Nodejs/lib/core/handler/GetInstanceFieldHandler" {
     }
     import AbstractHandler = require("Binaries/Nodejs/lib/core/handler/AbstractHandler");
 }
+declare module "Binaries/Nodejs/lib/core/handler/GetInstanceMethodAsDelegateHandler" {
+    const _exports: GetInstanceMethodAsDelegateHandler;
+    export = _exports;
+    /**
+     * Handles retrieving an instance method as a delegate.
+     */
+    class GetInstanceMethodAsDelegateHandler extends AbstractHandler {
+        /** @type {Function|null} */
+        method: Function | null;
+        /** @type {number} */
+        requiredParametersCount: number;
+        /** @type {Array<*>} */
+        args: Array<any>;
+        /** @type {Object|null} */
+        instance: Object | null;
+        /**
+         * Processes a command to retrieve an instance method as a delegate.
+         * @param {Object} command - The command containing payload data.
+         * @param {Array<*>} command.payload - The payload containing instance, method name, and arguments.
+         * @returns {Function} The delegate for the instance method.
+         * @throws {Error} If the parameters mismatch or the method cannot be found.
+         */
+        process(command: {
+            payload: Array<any>;
+        }): Function;
+        /**
+         * Retrieves the method from the type.
+         * @param {Object} type - The class or constructor to search for the method.
+         * @param {string} methodName - The name of the method.
+         * @returns {Function|null} The found method or null if not found.
+         */
+        getMethod(type: Object, methodName: string): Function | null;
+        /**
+         * Creates an error message when the method is not found.
+         * @param {Object} type - The class or constructor.
+         * @param {string} methodName - The method name.
+         * @returns {Error} The error with detailed message.
+         */
+        createMethodNotFoundError(type: Object, methodName: string): Error;
+    }
+    import AbstractHandler = require("Binaries/Nodejs/lib/core/handler/AbstractHandler");
+}
 declare module "Binaries/Nodejs/lib/core/handler/GetStaticFieldHandler" {
     const _exports: GetStaticFieldHandler;
     export = _exports;
@@ -1132,6 +1302,47 @@ declare module "Binaries/Nodejs/lib/core/handler/GetStaticFieldHandler" {
     }
     import AbstractHandler = require("Binaries/Nodejs/lib/core/handler/AbstractHandler");
 }
+declare module "Binaries/Nodejs/lib/core/handler/GetStaticMethodAsDelegateHandler" {
+    const _exports: GetStaticMethodAsDelegateHandler;
+    export = _exports;
+    /**
+     * Handles retrieving a static method as a delegate.
+     */
+    class GetStaticMethodAsDelegateHandler extends AbstractHandler {
+        /** @type {Array<*>} */
+        args: Array<any>;
+        /** @type {Function|null} */
+        method: Function | null;
+        /** @type {number} */
+        requiredParametersCount: number;
+        /**
+         * Processes a command to retrieve a static method as a delegate.
+         * @param {Command} command - The command containing payload data.
+         * @param {Array<*>} command.payload - The payload containing type, method name, and arguments.
+         * @returns {Function} The delegate for the static method.
+         * @throws {Error} If the parameters mismatch or the method cannot be found.
+         */
+        process(command: Command): Function;
+        /**
+         * Retrieves the method from the type.
+         * @param {Object} type - The class or constructor to search for the method.
+         * @param {string} methodName - The name of the method.
+         * @param {Array<Function>} argsType - The argument types.
+         * @param {Object} modifier - Parameter modifier (not used in JS implementation).
+         * @returns {Function|null} The found method or null if not found.
+         */
+        getMethod(type: Object, methodName: string): Function | null;
+        /**
+         * Creates an error message when the method is not found.
+         * @param {Object} type - The class or constructor.
+         * @param {string} methodName - The method name.
+         * @returns {Error} The error with detailed message.
+         */
+        createMethodNotFoundError(type: Object, methodName: string): Error;
+    }
+    import AbstractHandler = require("Binaries/Nodejs/lib/core/handler/AbstractHandler");
+    import { Command } from "Binaries/Nodejs";
+}
 declare module "Binaries/Nodejs/lib/core/handler/LoadLibraryHandler" {
     const _exports: LoadLibraryHandler;
     export = _exports;
@@ -1228,6 +1439,125 @@ declare module "Binaries/Nodejs/lib/core/handler/InvokeStandaloneMethodHandler"
     }
     import AbstractHandler = require("Binaries/Nodejs/lib/core/handler/AbstractHandler");
 }
+declare module "Binaries/Nodejs/lib/core/handler/PassDelegateHandler" {
+    const _exports: PassDelegateHandler;
+    export = _exports;
+    /**
+     * PassDelegateHandler class responsible for processing a command to create a delegate.
+     */
+    class PassDelegateHandler extends AbstractHandler {
+        /**
+         * Minimum required parameters count for the command.
+         * @type {number}
+         */
+        requiredParametersCount: number;
+        interpreter: Interpreter;
+        /**
+         * Processes the given command to create and compile a delegate.
+         * @param {Command} command - The command to process.
+         * @returns {Function} The compiled delegate function.
+         */
+        process(command: Command): Function;
+        /**
+         * Validates the command to ensure it has enough parameters.
+         * @param {Command} command - The command to validate.
+         */
+        validateCommand(command: Command): void;
+        /**
+         * Retrieves the arguments from the command payload.
+         * @param {Command} command - The command containing the payload.
+         * @returns {Array} The extracted arguments.
+         */
+        getArguments(command: Command): any[];
+        /**
+         * Extracts argument types from the arguments array.
+         * @param {Array} args - The arguments array.
+         * @returns {Array} The argument types.
+         */
+        getArgumentTypes(args: any[]): any[];
+        /**
+         * Retrieves the return type from the arguments array.
+         * @param {Array} args - The arguments array.
+         * @returns {Function} The return type.
+         */
+        getReturnType(args: any[]): Function;
+        /**
+         * Creates parameter expressions from argument types.
+         * @param {Array} argsTypes - The argument types.
+         * @returns {Array} The parameter expressions.
+         */
+        createParameters(argsTypes: any[]): any[];
+        /**
+         * Creates an array of arguments for the delegate.
+         * @param {string} delegateGuid - The delegate identifier.
+         * @param {Array} parameters - The parameter expressions.
+         * @returns {Array} The arguments array.
+         */
+        createArgsArray(delegateGuid: string, parameters: any[]): any[];
+        /**
+         * Creates a command expression.
+         * @param {string} callingRuntimeName - The runtime name.
+         * @param {Array} payload - The arguments array.
+         * @returns {Object} The command object.
+         */
+        createCommand(callingRuntimeName: string, payload: any[]): Object;
+        /**
+         * Creates a method call to execute the command.
+         * @param {Command} command - The command object.
+         * @returns {Object} The response object.
+         */
+        createExecuteCall(command: Command): Object;
+        /**
+         * Retrieves the response payload from the execution call.
+         * @param {Object} executeCall - The execution call.
+         * @returns {Array} The response payload.
+         */
+        getResponse(executeCall: Object): any[];
+        /**
+         * Converts the first element of the response to the return type.
+         * @param {Array} response - The response payload.
+         * @param {Function} returnType - The return type.
+         * @returns {*} The converted first element.
+         */
+        convertFirstElement(response: any[], returnType: Function): any;
+        /**
+         * Creates a block of expressions for the delegate.
+         * @param {Function} returnType - The return type.
+         * @param {*} convertedFirstElement - The converted first element.
+         * @returns {Object} The block expression.
+         */
+        createBlock(returnType: Function, convertedFirstElement: any): Object;
+        /**
+         * Creates a delegate type.
+         * @param {Array} parameters - The parameter expressions.
+         * @param {Function} returnType - The return type.
+         * @returns {Function} The delegate type.
+         */
+        createDelegateType(parameters: any[], returnType: Function): Function;
+    }
+    import AbstractHandler = require("Binaries/Nodejs/lib/core/handler/AbstractHandler");
+    import { Interpreter } from "Binaries/Nodejs";
+    import { Command } from "Binaries/Nodejs";
+}
+declare module "Binaries/Nodejs/lib/core/handler/InvokeDelegateHandler" {
+    const _exports: InvokeDelegateHandler;
+    export = _exports;
+    /**
+     * Handles invoking a delegate by GUID.
+     */
+    class InvokeDelegateHandler extends AbstractHandler {
+        /** @type {number} */
+        requiredParametersCount: number;
+        /**
+         * Processes a command to invoke a delegate.
+         * @param {Command} command - The command containing payload data.
+         * @returns {*} The result of the delegate invocation.
+         * @throws {Error} If the parameters mismatch or the delegate cannot be found.
+         */
+        process(command: Command): any;
+    }
+    import AbstractHandler = require("Binaries/Nodejs/lib/core/handler/AbstractHandler");
+}
 declare module "Binaries/Nodejs/lib/core/handler/Handler" {
     export class Handler {
         handleCommand(command: any): Command;
@@ -1331,7 +1661,7 @@ declare module "Binaries/Nodejs/lib/core/handler/Handler" {
             iterate(cmd: any): void;
             process_stack_trace(error: any, class_name: any): any;
         };
-        37: {
+        42: {
             requiredParametersCount: number;
             process(command: any): any;
             throwError(type: any, methodName: any): void;
@@ -1410,8 +1740,66 @@ declare module "Binaries/Nodejs/lib/core/handler/Handler" {
             iterate(cmd: any): void;
             process_stack_trace(error: any, class_name: any): any;
         };
+        37: {
+            args: Array<any>;
+            method: Function | null;
+            requiredParametersCount: number;
+            process(command: Command): Function;
+            getMethod(type: Object, methodName: string): Function | null;
+            createMethodNotFoundError(type: Object, methodName: string): Error;
+            handlers: any[];
+            handleCommand(command: any): void;
+            iterate(cmd: any): void;
+            process_stack_trace(error: any, class_name: any): any;
+        };
+        38: {
+            method: Function | null;
+            requiredParametersCount: number;
+            args: Array<any>;
+            instance: Object | null;
+            process(command: {
+                payload: Array<any>;
+            }): Function;
+            getMethod(type: Object, methodName: string): Function | null;
+            createMethodNotFoundError(type: Object, methodName: string): Error;
+            handlers: any[];
+            handleCommand(command: any): void;
+            iterate(cmd: any): void;
+            process_stack_trace(error: any, class_name: any): any;
+        };
+        39: {
+            requiredParametersCount: number;
+            interpreter: import("Binaries/Nodejs").Interpreter;
+            process(command: Command): Function;
+            validateCommand(command: Command): void;
+            getArguments(command: Command): any[];
+            getArgumentTypes(args: any[]): any[];
+            getReturnType(args: any[]): Function;
+            createParameters(argsTypes: any[]): any[];
+            createArgsArray(delegateGuid: string, parameters: any[]): any[];
+            createCommand(callingRuntimeName: string, payload: any[]): Object;
+            createExecuteCall(command: Command): Object;
+            getResponse(executeCall: Object): any[];
+            convertFirstElement(response: any[], returnType: Function): any;
+            createBlock(returnType: Function, convertedFirstElement: any): Object;
+            createDelegateType(parameters: any[], returnType: Function): Function;
+            handlers: any[];
+            handleCommand(command: any): void;
+            iterate(cmd: any): void;
+            process_stack_trace(error: any, class_name: any): any;
+        };
+        40: {
+            requiredParametersCount: number;
+            process(command: Command): any;
+            handlers: any[];
+            handleCommand(command: any): void;
+            iterate(cmd: any): void;
+            process_stack_trace(error: any, class_name: any): any;
+        };
+        41: typeof ConvertTypeHandler;
     };
     import { Command } from "Binaries/Nodejs";
+    import { ConvertTypeHandler } from "Binaries/Nodejs/lib/utils/TypesConverter";
 }
 declare module "Binaries/Nodejs/lib/core/handler/SetGlobalStaticFieldHandler" {
     const _exports: SetGlobalStaticFieldHandler;
@@ -1674,7 +2062,12 @@ declare module "dist/lib/utils/CommandType" {
     export let EnableNamespace: 34;
     export let EnableType: 35;
     export let CreateNull: 36;
-    export let InvokeStandaloneMethod: 37;
+    export let GetStaticMethodAsDelegate: 37;
+    export let GetInstanceMethodAsDelegate: 38;
+    export let PassDelegate: 39;
+    export let InvokeDelegate: 40;
+    export let ConvertType: 41;
+    export let InvokeStandaloneMethod: 42;
 }
 declare module "dist/lib/utils/Command" {
     export = Command;
@@ -1947,6 +2340,33 @@ declare module "dist/lib/core/interpreter/Interpreter" {
     }
     type WsConnectionData = any;
 }
+declare module "dist/lib/utils/guid/generateGuid" {
+    export = generateGUID;
+    function generateGUID(): string;
+}
+declare module "dist/lib/core/delegatesCache/DelegatesCache" {
+    const _exports: DelegatesCache;
+    export = _exports;
+    /**
+     * A cache for storing and retrieving delegates.
+     */
+    class DelegatesCache {
+        cache: Map<any, any>;
+        /**
+         * Adds a delegate to the cache and returns its unique ID.
+         * @param {Function} delegateInstance - The delegate function to store.
+         * @returns {string} The unique ID for the delegate.
+         */
+        addDelegate(delegateInstance: Function): string;
+        /**
+         * Retrieves a delegate by its unique ID.
+         * @param {string} delegateId - The unique ID of the delegate.
+         * @returns {Function} The delegate function.
+         * @throws {Error} If the delegate is not found.
+         */
+        getDelegate(delegateId: string): Function;
+    }
+}
 declare module "dist/lib/utils/ExceptionType" {
     export let EXCEPTION: 0;
     export let IO_EXCEPTION: 1;
@@ -2134,6 +2554,26 @@ declare module "dist/lib/sdk/InvocationContext" {
          * @method
          */
         createNull(): InvocationContext;
+        /**
+         * Creates a null object of a specific type on the target runtime.
+         * @param {string} methodName - The name of the method to invoke.
+         * @param {...any} args - Method arguments.
+         * @returns {InvocationContext} An InvocationContext instance with the command to create a null object.
+         * TODO: connect documentation page url
+         * @see [Javonet Guides](https://www.javonet.com/guides/)
+         * @method
+         */
+        getStaticMethodAsDelegate(methodName: string, ...args: any[]): InvocationContext;
+        /**
+         * Creates a null object of a specific type on the target runtime.
+         * @param {string} methodName - The name of the method to invoke.
+         * @param {...any} args - Method arguments.
+         * @returns {InvocationContext} An InvocationContext instance with the command to create a null object.
+         * TODO: connect documentation page url
+         * @see [Javonet Guides](https://www.javonet.com/guides/)
+         * @method
+         */
+        getInstanceMethodAsDelegate(methodName: string, ...args: any[]): InvocationContext;
         /**
          * Retrieves an array from the target runtime.
          * @returns {InvocationContext} A new InvocationContext instance that wraps the command to retrieve the array.
@@ -2400,6 +2840,7 @@ declare module "dist/index" {
     import TypeDeserializer = require("@javonet/core/lib/core/protocol/TypeDeserializer");
     import TypeSerializer = require("@javonet/core/lib/core/protocol/TypeSerializer");
     import Interpreter = require("@javonet/core/lib/core/interpreter/Interpreter");
+    import DelegatesCache = require("@javonet/core/lib/core/delegatesCache/DelegatesCache");
     import { InvocationContext } from "@javonet/core/lib/sdk/InvocationContext";
     import { InvocationWsContext } from "@javonet/core/lib/sdk/InvocationContext";
     import RuntimeContext = require("@javonet/core/lib/sdk/RuntimeContext");
@@ -2417,7 +2858,7 @@ declare module "dist/index" {
     import WsConnectionData = require("@javonet/core/lib/utils/connectionData/WsConnectionData");
     import ExceptionSerializer = require("@javonet/core/lib/utils/exception/ExceptionSerializer");
     import ExceptionThrower = require("@javonet/core/lib/utils/exception/ExceptionThrower");
-    export { CommandSerializer, CommandDeserializer, TypeDeserializer, TypeSerializer, Interpreter, InvocationContext, InvocationWsContext, RuntimeContext, RuntimeFactory, Command, CommandType, ConnectionType, ExceptionType, RuntimeName, RuntimeNameHandler, StringEncodingMode, Type, IConnectionData, InMemoryConnectionData, WsConnectionData, ExceptionSerializer, ExceptionThrower };
+    export { CommandSerializer, CommandDeserializer, TypeDeserializer, TypeSerializer, Interpreter, DelegatesCache, InvocationContext, InvocationWsContext, RuntimeContext, RuntimeFactory, Command, CommandType, ConnectionType, ExceptionType, RuntimeName, RuntimeNameHandler, StringEncodingMode, Type, IConnectionData, InMemoryConnectionData, WsConnectionData, ExceptionSerializer, ExceptionThrower };
 }
 declare module "dist/lib/core/generator/handler/AbstractGeneratorHandler" {
     export = AbstractGeneratorHandler;
@@ -2655,6 +3096,81 @@ declare module "dist/lib/core/handler/CastingHandler" {
     }
     import AbstractHandler = require("@javonet/core/lib/core/handler/AbstractHandler");
 }
+declare module "dist/lib/utils/TypesConverter" {
+    /**
+     * ConvertTypeHandler class handles the conversion of JType to Type.
+     */
+    export class ConvertTypeHandler {
+        /**
+         * Minimum required parameters count for the command.
+         * @type {number}
+         */
+        requiredParametersCount: number;
+        /**
+         * Processes the given command to convert JType to Type.
+         * @param {Object} command - The command to process.
+         * @returns {any} The converted type.
+         */
+        process(command: Object): any;
+        /**
+         * Validates the command to ensure it has enough parameters.
+         * @param {Object} command - The command to validate.
+         */
+        validateCommand(command: Object): void;
+    }
+    /**
+     * TypesConverter class provides utilities for converting between types.
+     */
+    export class TypesConverter {
+        /**
+         * Converts a JavaScript type to a JType equivalent.
+         * @param {Function} type - The JavaScript type.
+         * @returns {number} The corresponding JType.
+         */
+        static convertTypeToJType(type: Function): number;
+        /**
+         * Converts a JType to a JavaScript type equivalent.
+         * @param {number} type - The JType to convert.
+         * @returns {Function} The corresponding JavaScript type.
+         */
+        static convertJTypeToType(type: number): Function;
+    }
+    /**
+     * Enum for JType mappings.
+     */
+    export type JType = number;
+    export namespace JType {
+        let Boolean: number;
+        let Float: number;
+        let String: number;
+        let Null: number;
+    }
+}
+declare module "dist/lib/core/handler/ConvertTypeHandler" {
+    export = ConvertTypeHandler;
+    /**
+     * ConvertTypeHandler class handles the conversion of JType to Type.
+     */
+    class ConvertTypeHandler extends AbstractHandler {
+        /**
+         * Minimum required parameters count for the command.
+         * @type {number}
+         */
+        requiredParametersCount: number;
+        /**
+         * Processes the given command to convert JType to Type.
+         * @param {Object} command - The command to process.
+         * @returns {any} The converted type.
+         */
+        process(command: Object): any;
+        /**
+         * Validates the command to ensure it has enough parameters.
+         * @param {Object} command - The command to validate.
+         */
+        validateCommand(command: Object): void;
+    }
+    import AbstractHandler = require("@javonet/core/lib/core/handler/AbstractHandler");
+}
 declare module "dist/lib/core/handler/CreateClassInstanceHandler" {
     const _exports: CreateClassInstanceHandler;
     export = _exports;
@@ -2761,6 +3277,48 @@ declare module "dist/lib/core/handler/GetInstanceFieldHandler" {
     }
     import AbstractHandler = require("@javonet/core/lib/core/handler/AbstractHandler");
 }
+declare module "dist/lib/core/handler/GetInstanceMethodAsDelegateHandler" {
+    const _exports: GetInstanceMethodAsDelegateHandler;
+    export = _exports;
+    /**
+     * Handles retrieving an instance method as a delegate.
+     */
+    class GetInstanceMethodAsDelegateHandler extends AbstractHandler {
+        /** @type {Function|null} */
+        method: Function | null;
+        /** @type {number} */
+        requiredParametersCount: number;
+        /** @type {Array<*>} */
+        args: Array<any>;
+        /** @type {Object|null} */
+        instance: Object | null;
+        /**
+         * Processes a command to retrieve an instance method as a delegate.
+         * @param {Object} command - The command containing payload data.
+         * @param {Array<*>} command.payload - The payload containing instance, method name, and arguments.
+         * @returns {Function} The delegate for the instance method.
+         * @throws {Error} If the parameters mismatch or the method cannot be found.
+         */
+        process(command: {
+            payload: Array<any>;
+        }): Function;
+        /**
+         * Retrieves the method from the type.
+         * @param {Object} type - The class or constructor to search for the method.
+         * @param {string} methodName - The name of the method.
+         * @returns {Function|null} The found method or null if not found.
+         */
+        getMethod(type: Object, methodName: string): Function | null;
+        /**
+         * Creates an error message when the method is not found.
+         * @param {Object} type - The class or constructor.
+         * @param {string} methodName - The method name.
+         * @returns {Error} The error with detailed message.
+         */
+        createMethodNotFoundError(type: Object, methodName: string): Error;
+    }
+    import AbstractHandler = require("@javonet/core/lib/core/handler/AbstractHandler");
+}
 declare module "dist/lib/core/handler/GetStaticFieldHandler" {
     const _exports: GetStaticFieldHandler;
     export = _exports;
@@ -2770,6 +3328,47 @@ declare module "dist/lib/core/handler/GetStaticFieldHandler" {
     }
     import AbstractHandler = require("@javonet/core/lib/core/handler/AbstractHandler");
 }
+declare module "dist/lib/core/handler/GetStaticMethodAsDelegateHandler" {
+    const _exports: GetStaticMethodAsDelegateHandler;
+    export = _exports;
+    /**
+     * Handles retrieving a static method as a delegate.
+     */
+    class GetStaticMethodAsDelegateHandler extends AbstractHandler {
+        /** @type {Array<*>} */
+        args: Array<any>;
+        /** @type {Function|null} */
+        method: Function | null;
+        /** @type {number} */
+        requiredParametersCount: number;
+        /**
+         * Processes a command to retrieve a static method as a delegate.
+         * @param {Command} command - The command containing payload data.
+         * @param {Array<*>} command.payload - The payload containing type, method name, and arguments.
+         * @returns {Function} The delegate for the static method.
+         * @throws {Error} If the parameters mismatch or the method cannot be found.
+         */
+        process(command: Command): Function;
+        /**
+         * Retrieves the method from the type.
+         * @param {Object} type - The class or constructor to search for the method.
+         * @param {string} methodName - The name of the method.
+         * @param {Array<Function>} argsType - The argument types.
+         * @param {Object} modifier - Parameter modifier (not used in JS implementation).
+         * @returns {Function|null} The found method or null if not found.
+         */
+        getMethod(type: Object, methodName: string): Function | null;
+        /**
+         * Creates an error message when the method is not found.
+         * @param {Object} type - The class or constructor.
+         * @param {string} methodName - The method name.
+         * @returns {Error} The error with detailed message.
+         */
+        createMethodNotFoundError(type: Object, methodName: string): Error;
+    }
+    import AbstractHandler = require("@javonet/core/lib/core/handler/AbstractHandler");
+    import { Command } from "@javonet/core";
+}
 declare module "dist/lib/core/handler/LoadLibraryHandler" {
     const _exports: LoadLibraryHandler;
     export = _exports;
@@ -2866,23 +3465,142 @@ declare module "dist/lib/core/handler/InvokeStandaloneMethodHandler" {
     }
     import AbstractHandler = require("@javonet/core/lib/core/handler/AbstractHandler");
 }
-declare module "dist/lib/core/handler/Handler" {
-    export class Handler {
-        handleCommand(command: any): Command;
-        parseCommand(response: any, runtimeName: any): Command;
-    }
-    export const handlers: {
-        0: {
-            process(command: any): any;
-            handlers: any[];
-            handleCommand(command: any): void;
-            iterate(cmd: any): void;
-            process_stack_trace(error: any, class_name: any): any;
-        };
-        1: {
-            requiredParametersCount: number;
-            process(command: any): number;
-            getLoadedLibraries(): any[];
+declare module "dist/lib/core/handler/PassDelegateHandler" {
+    const _exports: PassDelegateHandler;
+    export = _exports;
+    /**
+     * PassDelegateHandler class responsible for processing a command to create a delegate.
+     */
+    class PassDelegateHandler extends AbstractHandler {
+        /**
+         * Minimum required parameters count for the command.
+         * @type {number}
+         */
+        requiredParametersCount: number;
+        interpreter: Interpreter;
+        /**
+         * Processes the given command to create and compile a delegate.
+         * @param {Command} command - The command to process.
+         * @returns {Function} The compiled delegate function.
+         */
+        process(command: Command): Function;
+        /**
+         * Validates the command to ensure it has enough parameters.
+         * @param {Command} command - The command to validate.
+         */
+        validateCommand(command: Command): void;
+        /**
+         * Retrieves the arguments from the command payload.
+         * @param {Command} command - The command containing the payload.
+         * @returns {Array} The extracted arguments.
+         */
+        getArguments(command: Command): any[];
+        /**
+         * Extracts argument types from the arguments array.
+         * @param {Array} args - The arguments array.
+         * @returns {Array} The argument types.
+         */
+        getArgumentTypes(args: any[]): any[];
+        /**
+         * Retrieves the return type from the arguments array.
+         * @param {Array} args - The arguments array.
+         * @returns {Function} The return type.
+         */
+        getReturnType(args: any[]): Function;
+        /**
+         * Creates parameter expressions from argument types.
+         * @param {Array} argsTypes - The argument types.
+         * @returns {Array} The parameter expressions.
+         */
+        createParameters(argsTypes: any[]): any[];
+        /**
+         * Creates an array of arguments for the delegate.
+         * @param {string} delegateGuid - The delegate identifier.
+         * @param {Array} parameters - The parameter expressions.
+         * @returns {Array} The arguments array.
+         */
+        createArgsArray(delegateGuid: string, parameters: any[]): any[];
+        /**
+         * Creates a command expression.
+         * @param {string} callingRuntimeName - The runtime name.
+         * @param {Array} payload - The arguments array.
+         * @returns {Object} The command object.
+         */
+        createCommand(callingRuntimeName: string, payload: any[]): Object;
+        /**
+         * Creates a method call to execute the command.
+         * @param {Command} command - The command object.
+         * @returns {Object} The response object.
+         */
+        createExecuteCall(command: Command): Object;
+        /**
+         * Retrieves the response payload from the execution call.
+         * @param {Object} executeCall - The execution call.
+         * @returns {Array} The response payload.
+         */
+        getResponse(executeCall: Object): any[];
+        /**
+         * Converts the first element of the response to the return type.
+         * @param {Array} response - The response payload.
+         * @param {Function} returnType - The return type.
+         * @returns {*} The converted first element.
+         */
+        convertFirstElement(response: any[], returnType: Function): any;
+        /**
+         * Creates a block of expressions for the delegate.
+         * @param {Function} returnType - The return type.
+         * @param {*} convertedFirstElement - The converted first element.
+         * @returns {Object} The block expression.
+         */
+        createBlock(returnType: Function, convertedFirstElement: any): Object;
+        /**
+         * Creates a delegate type.
+         * @param {Array} parameters - The parameter expressions.
+         * @param {Function} returnType - The return type.
+         * @returns {Function} The delegate type.
+         */
+        createDelegateType(parameters: any[], returnType: Function): Function;
+    }
+    import AbstractHandler = require("@javonet/core/lib/core/handler/AbstractHandler");
+    import { Interpreter } from "@javonet/core";
+    import { Command } from "@javonet/core";
+}
+declare module "dist/lib/core/handler/InvokeDelegateHandler" {
+    const _exports: InvokeDelegateHandler;
+    export = _exports;
+    /**
+     * Handles invoking a delegate by GUID.
+     */
+    class InvokeDelegateHandler extends AbstractHandler {
+        /** @type {number} */
+        requiredParametersCount: number;
+        /**
+         * Processes a command to invoke a delegate.
+         * @param {Command} command - The command containing payload data.
+         * @returns {*} The result of the delegate invocation.
+         * @throws {Error} If the parameters mismatch or the delegate cannot be found.
+         */
+        process(command: Command): any;
+    }
+    import AbstractHandler = require("@javonet/core/lib/core/handler/AbstractHandler");
+}
+declare module "dist/lib/core/handler/Handler" {
+    export class Handler {
+        handleCommand(command: any): Command;
+        parseCommand(response: any, runtimeName: any): Command;
+    }
+    export const handlers: {
+        0: {
+            process(command: any): any;
+            handlers: any[];
+            handleCommand(command: any): void;
+            iterate(cmd: any): void;
+            process_stack_trace(error: any, class_name: any): any;
+        };
+        1: {
+            requiredParametersCount: number;
+            process(command: any): number;
+            getLoadedLibraries(): any[];
             handlers: any[];
             handleCommand(command: any): void;
             iterate(cmd: any): void;
@@ -2969,7 +3687,7 @@ declare module "dist/lib/core/handler/Handler" {
             iterate(cmd: any): void;
             process_stack_trace(error: any, class_name: any): any;
         };
-        37: {
+        42: {
             requiredParametersCount: number;
             process(command: any): any;
             throwError(type: any, methodName: any): void;
@@ -3048,8 +3766,66 @@ declare module "dist/lib/core/handler/Handler" {
             iterate(cmd: any): void;
             process_stack_trace(error: any, class_name: any): any;
         };
+        37: {
+            args: Array<any>;
+            method: Function | null;
+            requiredParametersCount: number;
+            process(command: Command): Function;
+            getMethod(type: Object, methodName: string): Function | null;
+            createMethodNotFoundError(type: Object, methodName: string): Error;
+            handlers: any[];
+            handleCommand(command: any): void;
+            iterate(cmd: any): void;
+            process_stack_trace(error: any, class_name: any): any;
+        };
+        38: {
+            method: Function | null;
+            requiredParametersCount: number;
+            args: Array<any>;
+            instance: Object | null;
+            process(command: {
+                payload: Array<any>;
+            }): Function;
+            getMethod(type: Object, methodName: string): Function | null;
+            createMethodNotFoundError(type: Object, methodName: string): Error;
+            handlers: any[];
+            handleCommand(command: any): void;
+            iterate(cmd: any): void;
+            process_stack_trace(error: any, class_name: any): any;
+        };
+        39: {
+            requiredParametersCount: number;
+            interpreter: import("@javonet/core").Interpreter;
+            process(command: Command): Function;
+            validateCommand(command: Command): void;
+            getArguments(command: Command): any[];
+            getArgumentTypes(args: any[]): any[];
+            getReturnType(args: any[]): Function;
+            createParameters(argsTypes: any[]): any[];
+            createArgsArray(delegateGuid: string, parameters: any[]): any[];
+            createCommand(callingRuntimeName: string, payload: any[]): Object;
+            createExecuteCall(command: Command): Object;
+            getResponse(executeCall: Object): any[];
+            convertFirstElement(response: any[], returnType: Function): any;
+            createBlock(returnType: Function, convertedFirstElement: any): Object;
+            createDelegateType(parameters: any[], returnType: Function): Function;
+            handlers: any[];
+            handleCommand(command: any): void;
+            iterate(cmd: any): void;
+            process_stack_trace(error: any, class_name: any): any;
+        };
+        40: {
+            requiredParametersCount: number;
+            process(command: Command): any;
+            handlers: any[];
+            handleCommand(command: any): void;
+            iterate(cmd: any): void;
+            process_stack_trace(error: any, class_name: any): any;
+        };
+        41: typeof ConvertTypeHandler;
     };
     import { Command } from "@javonet/core";
+    import { ConvertTypeHandler } from "@javonet/core/lib/utils/TypesConverter";
 }
 declare module "dist/lib/core/handler/SetGlobalStaticFieldHandler" {
     const _exports: SetGlobalStaticFieldHandler;
@@ -3510,6 +4286,81 @@ declare module "lib/core/handler/CastingHandler" {
     }
     import AbstractHandler = require("lib/core/handler/AbstractHandler");
 }
+declare module "lib/utils/TypesConverter" {
+    /**
+     * ConvertTypeHandler class handles the conversion of JType to Type.
+     */
+    export class ConvertTypeHandler {
+        /**
+         * Minimum required parameters count for the command.
+         * @type {number}
+         */
+        requiredParametersCount: number;
+        /**
+         * Processes the given command to convert JType to Type.
+         * @param {Object} command - The command to process.
+         * @returns {any} The converted type.
+         */
+        process(command: Object): any;
+        /**
+         * Validates the command to ensure it has enough parameters.
+         * @param {Object} command - The command to validate.
+         */
+        validateCommand(command: Object): void;
+    }
+    /**
+     * TypesConverter class provides utilities for converting between types.
+     */
+    export class TypesConverter {
+        /**
+         * Converts a JavaScript type to a JType equivalent.
+         * @param {Function} type - The JavaScript type.
+         * @returns {number} The corresponding JType.
+         */
+        static convertTypeToJType(type: Function): number;
+        /**
+         * Converts a JType to a JavaScript type equivalent.
+         * @param {number} type - The JType to convert.
+         * @returns {Function} The corresponding JavaScript type.
+         */
+        static convertJTypeToType(type: number): Function;
+    }
+    /**
+     * Enum for JType mappings.
+     */
+    export type JType = number;
+    export namespace JType {
+        let Boolean: number;
+        let Float: number;
+        let String: number;
+        let Null: number;
+    }
+}
+declare module "lib/core/handler/ConvertTypeHandler" {
+    export = ConvertTypeHandler;
+    /**
+     * ConvertTypeHandler class handles the conversion of JType to Type.
+     */
+    class ConvertTypeHandler extends AbstractHandler {
+        /**
+         * Minimum required parameters count for the command.
+         * @type {number}
+         */
+        requiredParametersCount: number;
+        /**
+         * Processes the given command to convert JType to Type.
+         * @param {Object} command - The command to process.
+         * @returns {any} The converted type.
+         */
+        process(command: Object): any;
+        /**
+         * Validates the command to ensure it has enough parameters.
+         * @param {Object} command - The command to validate.
+         */
+        validateCommand(command: Object): void;
+    }
+    import AbstractHandler = require("lib/core/handler/AbstractHandler");
+}
 declare module "lib/core/handler/CreateClassInstanceHandler" {
     const _exports: CreateClassInstanceHandler;
     export = _exports;
@@ -3616,6 +4467,48 @@ declare module "lib/core/handler/GetInstanceFieldHandler" {
     }
     import AbstractHandler = require("lib/core/handler/AbstractHandler");
 }
+declare module "lib/core/handler/GetInstanceMethodAsDelegateHandler" {
+    const _exports: GetInstanceMethodAsDelegateHandler;
+    export = _exports;
+    /**
+     * Handles retrieving an instance method as a delegate.
+     */
+    class GetInstanceMethodAsDelegateHandler extends AbstractHandler {
+        /** @type {Function|null} */
+        method: Function | null;
+        /** @type {number} */
+        requiredParametersCount: number;
+        /** @type {Array<*>} */
+        args: Array<any>;
+        /** @type {Object|null} */
+        instance: Object | null;
+        /**
+         * Processes a command to retrieve an instance method as a delegate.
+         * @param {Object} command - The command containing payload data.
+         * @param {Array<*>} command.payload - The payload containing instance, method name, and arguments.
+         * @returns {Function} The delegate for the instance method.
+         * @throws {Error} If the parameters mismatch or the method cannot be found.
+         */
+        process(command: {
+            payload: Array<any>;
+        }): Function;
+        /**
+         * Retrieves the method from the type.
+         * @param {Object} type - The class or constructor to search for the method.
+         * @param {string} methodName - The name of the method.
+         * @returns {Function|null} The found method or null if not found.
+         */
+        getMethod(type: Object, methodName: string): Function | null;
+        /**
+         * Creates an error message when the method is not found.
+         * @param {Object} type - The class or constructor.
+         * @param {string} methodName - The method name.
+         * @returns {Error} The error with detailed message.
+         */
+        createMethodNotFoundError(type: Object, methodName: string): Error;
+    }
+    import AbstractHandler = require("lib/core/handler/AbstractHandler");
+}
 declare module "lib/core/handler/GetStaticFieldHandler" {
     const _exports: GetStaticFieldHandler;
     export = _exports;
@@ -3625,6 +4518,47 @@ declare module "lib/core/handler/GetStaticFieldHandler" {
     }
     import AbstractHandler = require("lib/core/handler/AbstractHandler");
 }
+declare module "lib/core/handler/GetStaticMethodAsDelegateHandler" {
+    const _exports: GetStaticMethodAsDelegateHandler;
+    export = _exports;
+    /**
+     * Handles retrieving a static method as a delegate.
+     */
+    class GetStaticMethodAsDelegateHandler extends AbstractHandler {
+        /** @type {Array<*>} */
+        args: Array<any>;
+        /** @type {Function|null} */
+        method: Function | null;
+        /** @type {number} */
+        requiredParametersCount: number;
+        /**
+         * Processes a command to retrieve a static method as a delegate.
+         * @param {Command} command - The command containing payload data.
+         * @param {Array<*>} command.payload - The payload containing type, method name, and arguments.
+         * @returns {Function} The delegate for the static method.
+         * @throws {Error} If the parameters mismatch or the method cannot be found.
+         */
+        process(command: Command): Function;
+        /**
+         * Retrieves the method from the type.
+         * @param {Object} type - The class or constructor to search for the method.
+         * @param {string} methodName - The name of the method.
+         * @param {Array<Function>} argsType - The argument types.
+         * @param {Object} modifier - Parameter modifier (not used in JS implementation).
+         * @returns {Function|null} The found method or null if not found.
+         */
+        getMethod(type: Object, methodName: string): Function | null;
+        /**
+         * Creates an error message when the method is not found.
+         * @param {Object} type - The class or constructor.
+         * @param {string} methodName - The method name.
+         * @returns {Error} The error with detailed message.
+         */
+        createMethodNotFoundError(type: Object, methodName: string): Error;
+    }
+    import AbstractHandler = require("lib/core/handler/AbstractHandler");
+    import { Command } from "@javonet/core";
+}
 declare module "lib/core/handler/LoadLibraryHandler" {
     const _exports: LoadLibraryHandler;
     export = _exports;
@@ -3721,6 +4655,125 @@ declare module "lib/core/handler/InvokeStandaloneMethodHandler" {
     }
     import AbstractHandler = require("lib/core/handler/AbstractHandler");
 }
+declare module "lib/core/handler/PassDelegateHandler" {
+    const _exports: PassDelegateHandler;
+    export = _exports;
+    /**
+     * PassDelegateHandler class responsible for processing a command to create a delegate.
+     */
+    class PassDelegateHandler extends AbstractHandler {
+        /**
+         * Minimum required parameters count for the command.
+         * @type {number}
+         */
+        requiredParametersCount: number;
+        interpreter: Interpreter;
+        /**
+         * Processes the given command to create and compile a delegate.
+         * @param {Command} command - The command to process.
+         * @returns {Function} The compiled delegate function.
+         */
+        process(command: Command): Function;
+        /**
+         * Validates the command to ensure it has enough parameters.
+         * @param {Command} command - The command to validate.
+         */
+        validateCommand(command: Command): void;
+        /**
+         * Retrieves the arguments from the command payload.
+         * @param {Command} command - The command containing the payload.
+         * @returns {Array} The extracted arguments.
+         */
+        getArguments(command: Command): any[];
+        /**
+         * Extracts argument types from the arguments array.
+         * @param {Array} args - The arguments array.
+         * @returns {Array} The argument types.
+         */
+        getArgumentTypes(args: any[]): any[];
+        /**
+         * Retrieves the return type from the arguments array.
+         * @param {Array} args - The arguments array.
+         * @returns {Function} The return type.
+         */
+        getReturnType(args: any[]): Function;
+        /**
+         * Creates parameter expressions from argument types.
+         * @param {Array} argsTypes - The argument types.
+         * @returns {Array} The parameter expressions.
+         */
+        createParameters(argsTypes: any[]): any[];
+        /**
+         * Creates an array of arguments for the delegate.
+         * @param {string} delegateGuid - The delegate identifier.
+         * @param {Array} parameters - The parameter expressions.
+         * @returns {Array} The arguments array.
+         */
+        createArgsArray(delegateGuid: string, parameters: any[]): any[];
+        /**
+         * Creates a command expression.
+         * @param {string} callingRuntimeName - The runtime name.
+         * @param {Array} payload - The arguments array.
+         * @returns {Object} The command object.
+         */
+        createCommand(callingRuntimeName: string, payload: any[]): Object;
+        /**
+         * Creates a method call to execute the command.
+         * @param {Command} command - The command object.
+         * @returns {Object} The response object.
+         */
+        createExecuteCall(command: Command): Object;
+        /**
+         * Retrieves the response payload from the execution call.
+         * @param {Object} executeCall - The execution call.
+         * @returns {Array} The response payload.
+         */
+        getResponse(executeCall: Object): any[];
+        /**
+         * Converts the first element of the response to the return type.
+         * @param {Array} response - The response payload.
+         * @param {Function} returnType - The return type.
+         * @returns {*} The converted first element.
+         */
+        convertFirstElement(response: any[], returnType: Function): any;
+        /**
+         * Creates a block of expressions for the delegate.
+         * @param {Function} returnType - The return type.
+         * @param {*} convertedFirstElement - The converted first element.
+         * @returns {Object} The block expression.
+         */
+        createBlock(returnType: Function, convertedFirstElement: any): Object;
+        /**
+         * Creates a delegate type.
+         * @param {Array} parameters - The parameter expressions.
+         * @param {Function} returnType - The return type.
+         * @returns {Function} The delegate type.
+         */
+        createDelegateType(parameters: any[], returnType: Function): Function;
+    }
+    import AbstractHandler = require("lib/core/handler/AbstractHandler");
+    import { Interpreter } from "@javonet/core";
+    import { Command } from "@javonet/core";
+}
+declare module "lib/core/handler/InvokeDelegateHandler" {
+    const _exports: InvokeDelegateHandler;
+    export = _exports;
+    /**
+     * Handles invoking a delegate by GUID.
+     */
+    class InvokeDelegateHandler extends AbstractHandler {
+        /** @type {number} */
+        requiredParametersCount: number;
+        /**
+         * Processes a command to invoke a delegate.
+         * @param {Command} command - The command containing payload data.
+         * @returns {*} The result of the delegate invocation.
+         * @throws {Error} If the parameters mismatch or the delegate cannot be found.
+         */
+        process(command: Command): any;
+    }
+    import AbstractHandler = require("lib/core/handler/AbstractHandler");
+}
 declare module "lib/core/handler/Handler" {
     export class Handler {
         handleCommand(command: any): Command;
@@ -3824,7 +4877,7 @@ declare module "lib/core/handler/Handler" {
             iterate(cmd: any): void;
             process_stack_trace(error: any, class_name: any): any;
         };
-        37: {
+        42: {
             requiredParametersCount: number;
             process(command: any): any;
             throwError(type: any, methodName: any): void;
@@ -3903,8 +4956,66 @@ declare module "lib/core/handler/Handler" {
             iterate(cmd: any): void;
             process_stack_trace(error: any, class_name: any): any;
         };
+        37: {
+            args: Array<any>;
+            method: Function | null;
+            requiredParametersCount: number;
+            process(command: Command): Function;
+            getMethod(type: Object, methodName: string): Function | null;
+            createMethodNotFoundError(type: Object, methodName: string): Error;
+            handlers: any[];
+            handleCommand(command: any): void;
+            iterate(cmd: any): void;
+            process_stack_trace(error: any, class_name: any): any;
+        };
+        38: {
+            method: Function | null;
+            requiredParametersCount: number;
+            args: Array<any>;
+            instance: Object | null;
+            process(command: {
+                payload: Array<any>;
+            }): Function;
+            getMethod(type: Object, methodName: string): Function | null;
+            createMethodNotFoundError(type: Object, methodName: string): Error;
+            handlers: any[];
+            handleCommand(command: any): void;
+            iterate(cmd: any): void;
+            process_stack_trace(error: any, class_name: any): any;
+        };
+        39: {
+            requiredParametersCount: number;
+            interpreter: import("@javonet/core").Interpreter;
+            process(command: Command): Function;
+            validateCommand(command: Command): void;
+            getArguments(command: Command): any[];
+            getArgumentTypes(args: any[]): any[];
+            getReturnType(args: any[]): Function;
+            createParameters(argsTypes: any[]): any[];
+            createArgsArray(delegateGuid: string, parameters: any[]): any[];
+            createCommand(callingRuntimeName: string, payload: any[]): Object;
+            createExecuteCall(command: Command): Object;
+            getResponse(executeCall: Object): any[];
+            convertFirstElement(response: any[], returnType: Function): any;
+            createBlock(returnType: Function, convertedFirstElement: any): Object;
+            createDelegateType(parameters: any[], returnType: Function): Function;
+            handlers: any[];
+            handleCommand(command: any): void;
+            iterate(cmd: any): void;
+            process_stack_trace(error: any, class_name: any): any;
+        };
+        40: {
+            requiredParametersCount: number;
+            process(command: Command): any;
+            handlers: any[];
+            handleCommand(command: any): void;
+            iterate(cmd: any): void;
+            process_stack_trace(error: any, class_name: any): any;
+        };
+        41: typeof ConvertTypeHandler;
     };
     import { Command } from "@javonet/core";
+    import { ConvertTypeHandler } from "lib/utils/TypesConverter";
 }
 declare module "lib/core/handler/SetGlobalStaticFieldHandler" {
     const _exports: SetGlobalStaticFieldHandler;
@@ -4218,86 +5329,10 @@ declare module "lib/sdk/RuntimeContext" {
      * @see [Javonet Guides]{@link https://www.javonet.com/guides/v2/javascript/foundations/runtime-context}
      * @class
      */
-    class RuntimeContext {
-        static memoryRuntimeContexts: Map<any, any>;
-        static networkRuntimeContexts: Map<any, any>;
-        static webSocketRuntimeContexts: Map<any, any>;
-        static getInstance(runtimeName: any, connectionData: any): any;
-        constructor(runtimeName: any, connectionData: any);
-        runtimeName: any;
-        connectionData: any;
-        /**
-         * Executes the current command. The initial state of RuntimeContext is non-materialized,
-         * wrapping either a single command or a chain of recursively nested commands.
-         * Commands become nested through each invocation of methods on RuntimeContext.
-         * Each invocation triggers the creation of a new RuntimeContext instance wrapping the current command with a new parent command.
-         * The developer can decide at any moment of the materialization for the context, taking full control of the chunks of the expression being transferred and processed on the target runtime.
-         * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/foundations/execute-method)
-         * @method
-         */
-        execute(): void;
-        /**
-         * Adds a reference to a library. Javonet allows you to reference and use modules or packages written in various languages.
-         * This method allows you to use any library from all supported technologies. The necessary libraries need to be referenced.
-         * The argument is a relative or full path to the library. If the library has dependencies on other libraries, the latter needs to be added first.
-         * After referencing the library, any objects stored in this package can be used. Use static classes, create instances, call methods, use fields and properties, and much more.
-         * @param {string} libraryPath - The relative or full path to the library.
-         * @returns {RuntimeContext} RuntimeContext instance.
-         * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/getting-started/adding-references-to-libraries)
-         * @method
-         */
-        loadLibrary(libraryPath: string): RuntimeContext;
-        /**
-         * Retrieves a reference to a specific type. The type can be a class, interface or enum. The type can be retrieved from any referenced library.
-         * @param {string} typeName - The full name of the type.
-         * @param {...any} args - The arguments to be passed, if needed
-         * @returns {InvocationContext} InvocationContext instance, that wraps the command to get the type.
-         * @method
-         */
-        getType(typeName: string, ...args: any[]): InvocationContext;
-        /**
-         * Casts the provided value to a specific type. This method is used when invoking methods that require specific types of arguments.
-         * The arguments include the target type and the value to be cast. The target type must be retrieved from the called runtime using the getType method.
-         * After casting the value, it can be used as an argument when invoking methods.
-         * @param {...any} args - The target type and the value to be cast.
-         * @returns {InvocationContext} InvocationContext instance that wraps the command to cast the value.
-         * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/casting/casting)
-         * @method
-         */
-        cast(...args: any[]): InvocationContext;
-        /**
-         * Retrieves a specific item from an enum type. This method is used when working with enums from the called runtime.
-         * The arguments include the enum type and the name of the item. The enum type must be retrieved from the called runtime using the getType method.
-         * After retrieving the item, it can be used as an argument when invoking methods or for other operations.
-         * @param {...any} args - The enum type and the name of the item.
-         * @returns {InvocationContext} InvocationContext instance that wraps the command to get the enum item.
-         * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/enums/using-enum-type)
-         * @method
-         */
-        getEnumItem(...args: any[]): InvocationContext;
-        /**
-         * Creates a reference type argument that can be passed to a method with a ref parameter modifier. This method is used when working with methods from the called runtime that require arguments to be passed by reference.
-         * The arguments include the value and optionally the type of the reference. The type must be retrieved from the called runtime using the getType method.
-         * After creating the reference, it can be used as an argument when invoking methods.
-         * @param {...any} args - The value and optionally the type of the reference.
-         * @returns {InvocationContext} InvocationContext instance that wraps the command to create a reference as ref.
-         * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/methods-arguments/passing-arguments-by-reference-with-ref-keyword)
-         * @method
-         */
-        asRef(...args: any[]): InvocationContext;
-        /**
-         * Creates a reference type argument that can be passed to a method with an out parameter modifier. This method is used when working with methods from the called runtime that require arguments to be passed by reference.
-         * The arguments include the value and optionally the type of the reference. The type must be retrieved from the called runtime using the getType method.
-         * After creating the reference, it can be used as an argument when invoking methods.
-         * @param {...any} args - The value and optionally the type of the reference.
-         * @returns {InvocationContext} InvocationContext instance that wraps the command to create a reference as out.
-         * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/methods-arguments/passing-arguments-by-reference-with-out-keyword |Passing Arguments by Reference with out Keyword Guide)
-         * @method
-         */
-        asOut(...args: any[]): InvocationContext;
-        healthCheck(): void;
+    class RuntimeContext extends RuntimeContextCore {
         #private;
     }
+    import { RuntimeContext as RuntimeContextCore } from "@javonet/core";
 }
 declare module "lib/sdk/RuntimeFactory" {
     export = RuntimeFactory;