javonet-ruby-sdk 2.5.14 → 2.5.16

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/sdk/tools/nodejs/JsonFileResolver.cjs

@@ -0,0 +1,120 @@
+"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 JsonFileResolver_exports = {};
+__export(JsonFileResolver_exports, {
+  JsonFileResolver: () => JsonFileResolver
+});
+module.exports = __toCommonJS(JsonFileResolver_exports);
+var import_Runtime = require("../../../utils/Runtime.cjs");
+const import_meta = {};
+const requireDynamic = (0, import_Runtime.getRequire)(import_meta.url);
+let fsExtra = null;
+function hasOwnProperty(obj, key) {
+  return Object.prototype.hasOwnProperty.call(obj, key);
+}
+class JsonFileResolver {
+  constructor(path) {
+    this.path = path;
+    try {
+      if (!fsExtra) {
+        fsExtra = requireDynamic("fs-extra");
+      }
+      const data = fsExtra.readFileSync(this.path, "utf8");
+      this.jsonObject = JSON.parse(data);
+    } catch (err) {
+      throw err;
+    }
+  }
+  getLicenseKey() {
+    if (!hasOwnProperty(this.jsonObject, "licenseKey")) {
+      throw new Error(
+        "License key not found in configuration file. Please check your configuration file."
+      );
+    }
+    return this.jsonObject.licenseKey;
+  }
+  getRuntimes() {
+    return this.jsonObject.runtimes;
+  }
+  getRuntime(runtimeName, configName) {
+    const runtimes = this.getRuntimes();
+    if (hasOwnProperty(runtimes, runtimeName)) {
+      const runtime = runtimes[runtimeName];
+      if (Array.isArray(runtime)) {
+        for (let item of runtime) {
+          if (item.name === configName) {
+            return item;
+          }
+        }
+      } else if (runtime.name === configName) {
+        return runtime;
+      }
+    }
+    throw new Error(
+      `Runtime config ${configName} not found in configuration file for runtime ${runtimeName}. Please check your configuration file.`
+    );
+  }
+  getChannel(runtimeName, configName) {
+    const runtime = this.getRuntime(runtimeName, configName);
+    if (!hasOwnProperty(runtime, "channel")) {
+      throw new Error(
+        `Channel key not found in configuration file for config ${configName}. Please check your configuration file.`
+      );
+    }
+    return runtime.channel;
+  }
+  getChannelType(runtimeName, configName) {
+    const channel = this.getChannel(runtimeName, configName);
+    if (!hasOwnProperty(channel, "type")) {
+      throw new Error(
+        `Channel type not found in configuration file for config ${configName}. Please check your configuration file.`
+      );
+    }
+    return channel.type;
+  }
+  getChannelHost(runtimeName, configName) {
+    const channel = this.getChannel(runtimeName, configName);
+    if (!hasOwnProperty(channel, "host")) {
+      throw new Error(
+        `Channel host not found in configuration file for config ${configName}. Please check your configuration file.`
+      );
+    }
+    return channel.host;
+  }
+  getChannelPort(runtimeName, configName) {
+    const channel = this.getChannel(runtimeName, configName);
+    if (!hasOwnProperty(channel, "port")) {
+      throw new Error(
+        `Channel port not found in configuration file for config ${configName}. Please check your configuration file.`
+      );
+    }
+    return channel.port;
+  }
+  getModules(runtimeName, configName) {
+    const runtime = this.getRuntime(runtimeName, configName);
+    if (hasOwnProperty(runtime, "modules")) {
+      return runtime.modules;
+    }
+    return "";
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  JsonFileResolver
+});

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/sdk/tools/nodejs/SdkExceptionHelper.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 SdkExceptionHelper_exports = {};
+__export(SdkExceptionHelper_exports, {
+  sendExceptionToAppInsights: () => sendExceptionToAppInsights
+});
+module.exports = __toCommonJS(SdkExceptionHelper_exports);
+var import_Runtime = require("../../../utils/Runtime.cjs");
+const import_meta = {};
+const requireDynamic = (0, import_Runtime.getRequire)(import_meta.url);
+let https = null;
+let os = null;
+const address = "https://dc.services.visualstudio.com/v2/track";
+if ((0, import_Runtime.isNodejsRuntime)()) {
+  try {
+    https = requireDynamic("https", import_meta.url);
+    os = requireDynamic("os", import_meta.url);
+  } catch (error) {
+    throw error;
+  }
+}
+function sendExceptionToAppInsights(e, licenseKey) {
+  return new Promise((resolve, reject) => {
+    try {
+      const instrumentationKey = "2c751560-90c8-40e9-b5dd-534566514723";
+      const javonetVersion = "2.0.0";
+      const nodeName = os.hostname();
+      const operationName = "JavonetSdkException";
+      const osName = os.platform();
+      const callingRuntimeName = "Nodejs";
+      const eventMessage = e.message;
+      const nowGMT = (/* @__PURE__ */ new Date()).toISOString();
+      const jsonPayload = JSON.stringify({
+        name: "AppEvents",
+        time: nowGMT,
+        iKey: instrumentationKey,
+        tags: {
+          "ai.application.ver": javonetVersion,
+          "ai.cloud.roleInstance": nodeName,
+          "ai.operation.id": "0",
+          "ai.operation.parentId": "0",
+          "ai.operation.name": operationName,
+          "ai.internal.sdkVersion": "javonet:" + javonetVersion,
+          "ai.internal.nodeName": nodeName
+        },
+        data: {
+          baseType: "EventData",
+          baseData: {
+            ver: 2,
+            name: eventMessage,
+            properties: {
+              OperatingSystem: osName,
+              LicenseKey: licenseKey,
+              CallingTechnology: callingRuntimeName
+            }
+          }
+        }
+      });
+      const options = {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "Content-Length": jsonPayload.length
+        }
+      };
+      const req = https.request(address, options, (res) => {
+        console.log("POST Response Code ::", res.statusCode);
+        resolve(res.statusCode);
+      });
+      req.on("error", (error) => {
+        console.error(error);
+        reject(error);
+      });
+      req.write(jsonPayload);
+      req.end();
+    } catch (error) {
+      reject(error);
+    }
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  sendExceptionToAppInsights
+});

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/types/core/delegatesCache/DelegatesCache.d.ts

@@ -0,0 +1,21 @@
+export const delegatesCacheInstance: DelegatesCache;
+/**
+ * A cache for storing and retrieving delegates.
+ */
+declare 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;
+}
+export {};

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/types/core/handler/AbstractHandler.d.ts

@@ -0,0 +1,7 @@
+export class AbstractHandler {
+    handlers: any[];
+    process(command: any): void;
+    handleCommand(command: any): void;
+    iterate(cmd: any): void;
+    process_stack_trace(error: any, class_name: any): any;
+}

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/types/core/handler/ArrayGetItemHandler.d.ts

@@ -0,0 +1,5 @@
+export class ArrayGetItemHandler extends AbstractHandler {
+    requiredParametersCount: number;
+    process(command: any): any;
+}
+import { AbstractHandler } from './AbstractHandler.js';

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/types/core/handler/ArrayGetRankHandler.d.ts

@@ -0,0 +1,5 @@
+export class ArrayGetRankHandler extends AbstractHandler {
+    requiredParametersCount: number;
+    process(command: any): number;
+}
+import { AbstractHandler } from './AbstractHandler.js';

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/types/core/handler/ArrayGetSizeHandler.d.ts

@@ -0,0 +1,5 @@
+export class ArrayGetSizeHandler extends AbstractHandler {
+    requiredParametersCount: number;
+    process(command: any): number;
+}
+import { AbstractHandler } from './AbstractHandler.js';

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/types/core/handler/ArrayHandler.d.ts

@@ -0,0 +1,4 @@
+export class ArrayHandler extends AbstractHandler {
+    process(command: any): any;
+}
+import { AbstractHandler } from './AbstractHandler.js';

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/types/core/handler/ArraySetItemHandler.d.ts

@@ -0,0 +1,5 @@
+export class ArraySetItemHandler extends AbstractHandler {
+    requiredParametersCount: number;
+    process(command: any): number;
+}
+import { AbstractHandler } from './AbstractHandler.js';

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/types/core/handler/CastingHandler.d.ts

@@ -0,0 +1,3 @@
+export class CastingHandler extends AbstractHandler {
+}
+import { AbstractHandler } from './AbstractHandler.js';

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/types/core/handler/ConvertTypeHandler.d.ts

@@ -0,0 +1,22 @@
+/**
+ * ConvertTypeHandler class handles the conversion of JType to Type.
+ */
+export 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 } from './AbstractHandler.js';

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/types/core/handler/CreateClassInstanceHandler.d.ts

@@ -0,0 +1,5 @@
+export class CreateClassInstanceHandler extends AbstractHandler {
+    requiredParametersCount: number;
+    process(command: any): any;
+}
+import { AbstractHandler } from './AbstractHandler.js';

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/types/core/handler/DestructReferenceHandler.d.ts

@@ -0,0 +1,4 @@
+export class DestructReferenceHandler extends AbstractHandler {
+    process(command: any): number;
+}
+import { AbstractHandler } from './AbstractHandler.js';

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/types/core/handler/EnableNamespaceHandler.d.ts

@@ -0,0 +1,5 @@
+export class EnableNamespaceHandler extends AbstractHandler {
+    requiredParametersCount: number;
+    process(command: any): number;
+}
+import { AbstractHandler } from './AbstractHandler.js';

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/types/core/handler/EnableTypeHandler.d.ts

@@ -0,0 +1,5 @@
+export class EnableTypeHandler extends AbstractHandler {
+    requiredParametersCount: number;
+    process(command: any): number;
+}
+import { AbstractHandler } from './AbstractHandler.js';

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/types/core/handler/GetGlobalStaticFieldHandler.d.ts

@@ -0,0 +1,5 @@
+export class GetGlobalStaticFieldHandler extends AbstractHandler {
+    requiredParametersCount: number;
+    process(command: any): any;
+}
+import { AbstractHandler } from './AbstractHandler.js';

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/types/core/handler/GetInstanceFieldHandler.d.ts

@@ -0,0 +1,5 @@
+export class GetInstanceFieldHandler extends AbstractHandler {
+    requiredParametersCount: number;
+    process(command: any): any;
+}
+import { AbstractHandler } from './AbstractHandler.js';

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/types/core/handler/GetInstanceMethodAsDelegateHandler.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Handles retrieving an instance method as a delegate.
+ */
+export 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 } from './AbstractHandler.js';

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/types/core/handler/GetStaticFieldHandler.d.ts

@@ -0,0 +1,5 @@
+export class GetStaticFieldHandler extends AbstractHandler {
+    requiredParametersCount: number;
+    process(command: any): any;
+}
+import { AbstractHandler } from './AbstractHandler.js';

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/types/core/handler/GetStaticMethodAsDelegateHandler.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Handles retrieving a static method as a delegate.
+ */
+export 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 } from './AbstractHandler.js';

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/types/core/handler/GetTypeHandler.d.ts

@@ -0,0 +1,16 @@
+export class GetTypeHandler extends AbstractHandler {
+    /** @type {number} */
+    requiredParametersCount: number;
+    /** @type {NamespaceCache | null} */
+    namespaceCache: NamespaceCache | null;
+    /** @type {TypeCache | null} */
+    typeCache: TypeCache | null;
+    /** @type {LoadLibraryHandler | null} */
+    loadLibaryHandler: LoadLibraryHandler | null;
+    process(command: any): any;
+    getAvailableTypes(): any[];
+}
+import { AbstractHandler } from './AbstractHandler.js';
+import { NamespaceCache } from '../namespaceCache/NamespaceCache.js';
+import { TypeCache } from '../typeCache/TypeCache.js';
+import { LoadLibraryHandler } from './LoadLibraryHandler.js';

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/types/core/handler/Handler.d.ts

@@ -0,0 +1,27 @@
+export class Handler {
+    /**
+     * @param {import('../interpreter/Interpreter.js').Interpreter} interpreter
+     */
+    constructor(interpreter: import("../interpreter/Interpreter.js").Interpreter);
+    interpreter: import("../interpreter/Interpreter.js").Interpreter;
+    /**
+     * @param {{ commandType: number; payload: any[]; runtimeName: number; }} command
+     */
+    handleCommand(command: {
+        commandType: number;
+        payload: any[];
+        runtimeName: number;
+    }): Command;
+    /**
+     * @param {any} response
+     * @param {number} runtimeName
+     * @returns {Command}
+     */
+    parseCommand(response: any, runtimeName: number): Command;
+}
+/**
+ * @type {Record<number, AbstractHandler>}
+ */
+export const handlers: Record<number, AbstractHandler>;
+import { Command } from '../../utils/Command.js';
+import { AbstractHandler } from './AbstractHandler.js';

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/types/core/handler/InvokeDelegateHandler.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Handles invoking a delegate by GUID.
+ */
+export 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 } from './AbstractHandler.js';

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/types/core/handler/InvokeGlobalFunctionHandler.d.ts

@@ -0,0 +1,5 @@
+export class InvokeGlobalFunctionHandler extends AbstractHandler {
+    requiredParametersCount: number;
+    process(command: any): any;
+}
+import { AbstractHandler } from './AbstractHandler.js';

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/types/core/handler/InvokeInstanceMethodHandler.d.ts

@@ -0,0 +1,5 @@
+export class InvokeInstanceMethodHandler extends AbstractHandler {
+    requiredParametersCount: number;
+    process(command: any): any;
+}
+import { AbstractHandler } from './AbstractHandler.js';

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/types/core/handler/InvokeStaticMethodHandler.d.ts

@@ -0,0 +1,5 @@
+export class InvokeStaticMethodHandler extends AbstractHandler {
+    requiredParametersCount: number;
+    process(command: any): any;
+}
+import { AbstractHandler } from './AbstractHandler.js';

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/types/core/handler/LoadLibraryHandler.d.ts

@@ -0,0 +1,7 @@
+export class LoadLibraryHandler extends AbstractHandler {
+    static loadedLibraries: any[];
+    requiredParametersCount: number;
+    process(command: any): number;
+    getLoadedLibraries(): any[];
+}
+import { AbstractHandler } from './AbstractHandler.js';

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/types/core/handler/PassDelegateHandler.d.ts

@@ -0,0 +1,104 @@
+export type Command = import("../../utils/Command.js").Command;
+export type Interpreter = import("../interpreter/Interpreter.js").Interpreter;
+/**
+ * @typedef {import('../../utils/Command.js').Command} Command
+ * @typedef {import('../interpreter/Interpreter.js').Interpreter} Interpreter
+ */
+/**
+ * PassDelegateHandler class responsible for processing a command to create a delegate.
+ */
+export class PassDelegateHandler extends AbstractHandler {
+    constructor(interpreter?: null);
+    /** @type {Interpreter | null | undefined} */
+    interpreter: Interpreter | null | undefined;
+    /**
+     * Minimum required parameters count for the command.
+     * @type {number}
+     */
+    requiredParametersCount: number;
+    /**S
+     * 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<any>} The extracted arguments.
+     */
+    getArguments(command: Command): Array<any>;
+    /**
+     * Extracts argument types from the arguments array.
+     * @param {Array<any>} args - The arguments array.
+     * @returns {Array<any>} The argument types.
+     */
+    getArgumentTypes(args: Array<any>): Array<any>;
+    /**
+     * Retrieves the return type from the arguments array.
+     * @param {Array<any>} args - The arguments array.
+     * @returns {Function} The return type.
+     */
+    getReturnType(args: Array<any>): Function;
+    /**
+     * Creates parameter expressions from argument types.
+     * @param {Array<any>} argsTypes - The argument types.
+     * @returns {Array<any>} The parameter expressions.
+     */
+    createParameters(argsTypes: Array<any>): Array<any>;
+    /**
+     * Creates an array of arguments for the delegate.
+     * @param {string} delegateGuid - The delegate identifier.
+     * @param {Array<any>} parameters - The parameter expressions.
+     * @returns {Array<any>} The arguments array.
+     */
+    createArgsArray(delegateGuid: string, parameters: Array<any>): Array<any>;
+    /**
+     * Creates a command expression.
+     * @param {string} callingRuntimeName - The runtime name.
+     * @param {Array<any>} payload - The arguments array.
+     * @returns {Object} The command object.
+     */
+    createCommand(callingRuntimeName: string, payload: Array<any>): Object;
+    /**
+     * Creates a method call to execute the command.
+     * @param {Command} command - The command object.
+     * @returns {any} The response object.
+     */
+    createExecuteCall(command: Command): any;
+    /**
+     * Retrieves the response payload from the execution call.
+     * @param {Object<string, any>} executeCall - Object containing the execution call.
+     * @returns {Array<any>} The response payload.
+     */
+    getResponse(executeCall: {
+        [x: string]: any;
+    }): Array<any>;
+    /**
+     * Converts the first element of the response to the return type.
+     * @param {Array<any>} response - The response payload.
+     * @param {Function} returnType - The return type.
+     * @returns {*} The converted first element.
+     */
+    convertFirstElement(response: Array<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<any>} parameters - The parameter expressions.
+     * @param {Function} returnType - The return type.
+     * @returns {Function} The delegate type.
+     */
+    createDelegateType(parameters: Array<any>, returnType: Function): Function;
+}
+import { AbstractHandler } from './AbstractHandler.js';

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/types/core/handler/ResolveReferenceHandler.d.ts

@@ -0,0 +1,12 @@
+export type Command = import("../../utils/Command.js").Command;
+/**
+ * @typedef {import('../../utils/Command.js').Command} Command
+ */
+export class ResolveReferenceHandler extends AbstractHandler {
+    /**
+     * @param {Command} command
+     * @returns {any}
+     */
+    process(command: Command): any;
+}
+import { AbstractHandler } from './AbstractHandler.js';

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/types/core/handler/SetGlobalStaticFieldHandler.d.ts

@@ -0,0 +1,4 @@
+export class SetGlobalStaticFieldHandler extends AbstractHandler {
+    requiredParametersCount: number;
+}
+import { AbstractHandler } from './AbstractHandler.js';

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/types/core/handler/SetInstanceFieldHandler.d.ts

@@ -0,0 +1,5 @@
+export class SetInstanceFieldHandler extends AbstractHandler {
+    requiredParametersCount: number;
+    process(command: any): number;
+}
+import { AbstractHandler } from './AbstractHandler.js';