javonet-ruby-sdk 2.6.2 → 2.6.4

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/sdk/configuration/configResolvers/YamlConfigResolver.cjs

@@ -0,0 +1,125 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var YamlConfigResolver_exports = {};
+__export(YamlConfigResolver_exports, {
+  YamlConfigResolver: () => YamlConfigResolver
+});
+module.exports = __toCommonJS(YamlConfigResolver_exports);
+var import_js_yaml = __toESM(require("js-yaml"), 1);
+var import_Config = require("../Config.cjs");
+var import_ConfigsDictionary = require("../ConfigsDictionary.cjs");
+var import_ConfigResolver = require("./ConfigResolver.cjs");
+var import_ActivationHelper = require("../../tools/ActivationHelper.cjs");
+class YamlConfigResolver extends import_ConfigResolver.ConfigResolver {
+  /**
+   * Parse YAML string and add configurations.
+   * @param {any} priority
+   * @param {string} yamlString
+   */
+  static addConfigs(priority, yamlString) {
+    if (!yamlString || String(yamlString).trim() === "") {
+      throw new Error("YAML string cannot be null or empty.");
+    }
+    let data;
+    try {
+      data = import_js_yaml.default.load(String(yamlString));
+    } catch (ex) {
+      throw new SyntaxError(`Failed to parse YAML: ${ex}`);
+    }
+    if (typeof data !== "object" || data == null || Array.isArray(data)) {
+      throw new SyntaxError("Root YAML node must be a mapping.");
+    }
+    const root = (
+      /** @type {RootYaml} */
+      data
+    );
+    const licenseKey = root.licenseKey;
+    if (typeof licenseKey === "string") {
+      import_ActivationHelper.ActivationHelper.temporaryLicenseKey = licenseKey.trim();
+    }
+    const configs = root.configurations;
+    if (typeof configs !== "object" || configs == null || Array.isArray(configs)) {
+      throw new Error("YAML must contain 'configurations' mapping.");
+    }
+    for (const [configName, cfg] of Object.entries(configs)) {
+      if (typeof configName !== "string" || configName.trim() === "") {
+        console.log("Skipping entry with empty config name.");
+        continue;
+      }
+      if (typeof cfg !== "object" || cfg == null || Array.isArray(cfg)) {
+        console.log(`Skipping '${configName}': value is not a mapping.`);
+        continue;
+      }
+      try {
+        const runtimeValue = YamlConfigResolver._getRequiredString(cfg, "runtime");
+        const runtimeName = import_ConfigResolver.ConfigResolver.tryParseRuntime(runtimeValue);
+        const host = YamlConfigResolver._getOptionalString(cfg, "host");
+        const connectionData = import_ConfigResolver.ConfigResolver.buildConnectionData(host);
+        const plugins = YamlConfigResolver._getOptionalString(cfg, "plugins");
+        const modules = YamlConfigResolver._getOptionalString(cfg, "modules");
+        const config = new import_Config.Config(runtimeName, connectionData, plugins, modules);
+        import_ConfigsDictionary.ConfigsDictionary.addConfig(configName, priority, config);
+      } catch (ex) {
+        console.log(`Failed to add config '${configName}': ${ex}`);
+      }
+    }
+  }
+  /**
+   * Get required string from mapping, trimmed. Throws if missing/invalid.
+   * @param {Record<string, unknown>} mapping
+   * @param {string} key
+   * @returns {string}
+   * @private
+   */
+  static _getRequiredString(mapping, key) {
+    const value = mapping[key];
+    if (typeof value !== "string" || value.trim() === "") {
+      throw new Error(`Missing or invalid '${key}' property.`);
+    }
+    return value.trim();
+  }
+  /**
+   * Get optional string from mapping, or empty string if missing/not a string.
+   * @param {Record<string, unknown>} mapping
+   * @param {string} key
+   * @returns {string}
+   * @private
+   */
+  static _getOptionalString(mapping, key) {
+    const value = mapping[key];
+    if (typeof value === "string") {
+      return value;
+    }
+    return "";
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  YamlConfigResolver
+});

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

@@ -0,0 +1,114 @@
+"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 ComplexTypeResolver_exports = {};
+__export(ComplexTypeResolver_exports, {
+  ComplexTypeResolver: () => ComplexTypeResolver
+});
+module.exports = __toCommonJS(ComplexTypeResolver_exports);
+var import_Runtime = require("../../utils/Runtime.cjs");
+var import_RuntimeName = require("../../utils/RuntimeName.cjs");
+var import_ActivatorDetails = require("../ActivatorDetails.cjs");
+var import_InvocationContext = require("../InvocationContext.cjs");
+var import_JavaTypeParsingFunctions = require("./typeParsingFunctions/JavaTypeParsingFunctions.cjs");
+var import_NetcoreTypeParsingFunctions = require("./typeParsingFunctions/NetcoreTypeParsingFunctions.cjs");
+var import_NodejsTypeParsingFunctions = require("./typeParsingFunctions/NodejsTypeParsingFunctions.cjs");
+var import_PythonTypeParsingFunctions = require("./typeParsingFunctions/PythonTypeParsingFunctions.cjs");
+const import_meta = {};
+const dynamicImport = (0, import_Runtime.getRequire)(import_meta.url);
+class ComplexTypeResolver {
+  /** @type {Map<string, ActivatorDetails>} */
+  #typeMap = /* @__PURE__ */ new Map();
+  /** @type {Map<number, Map<string, Function>>} */
+  #typeParsingFunctions = /* @__PURE__ */ new Map([
+    [import_RuntimeName.RuntimeName.Netcore, import_NetcoreTypeParsingFunctions.NetcoreTypeParsingFunctions],
+    [import_RuntimeName.RuntimeName.Jvm, import_JavaTypeParsingFunctions.JavaTypeParsingFunctions],
+    [import_RuntimeName.RuntimeName.Nodejs, import_NodejsTypeParsingFunctions.NodejsTypeParsingFunctions],
+    [import_RuntimeName.RuntimeName.Python, import_PythonTypeParsingFunctions.PythonTypeParsingFunctions],
+    [import_RuntimeName.RuntimeName.Python27, import_PythonTypeParsingFunctions.PythonTypeParsingFunctions]
+  ]);
+  /**
+   * Register a custom type mapping
+   * @param {string} resultType - The type name from the target runtime
+   * @param {Function} type - The JavaScript constructor function
+   * @param {any[]} [args] - Default arguments for the constructor
+   */
+  register(resultType, type, args) {
+    if (!this.#typeMap.has(resultType)) {
+      this.#typeMap.set(resultType, new import_ActivatorDetails.ActivatorDetails(type, args));
+    }
+  }
+  /**
+   * Convert InvocationContext result to appropriate JavaScript type
+   * @param {InvocationContext} ic - The invocation context
+   * @returns {any} The converted result
+   */
+  convertResult(ic) {
+    const runtimeName = ic.getRuntimeName();
+    const resultType = ic.getResultType();
+    const runtimeDict = this.#typeParsingFunctions.get(runtimeName);
+    if (runtimeDict) {
+      const parsingFunc = runtimeDict.get(resultType);
+      if (parsingFunc) {
+        return parsingFunc(ic);
+      }
+    }
+    const activatorDetails = this.#typeMap.get(resultType);
+    if (!activatorDetails) {
+      throw new Error(`No type registered for key '${resultType}'.`);
+    }
+    return new /** @type {any} */
+    activatorDetails.type(...activatorDetails.arguments);
+  }
+  /**
+   * Resolve type from string name and optional module
+   * @param {string} typeName - Name of the type to resolve
+   * @param {string} [moduleName] - Optional module name to import from
+   * @returns {Function} The resolved type/constructor function
+   */
+  static resolveType(typeName, moduleName) {
+    if (moduleName) {
+      try {
+        const module2 = dynamicImport(moduleName);
+        const typeObj2 = module2[typeName];
+        if (!typeObj2) {
+          throw new Error(`Type '${typeName}' not found in module '${moduleName}'`);
+        }
+        return typeObj2;
+      } catch (error) {
+        throw new Error(
+          `Failed to resolve type '${typeName}' from module '${moduleName}': ${/** @type {Error} */
+          error.message}`
+        );
+      }
+    }
+    const globalScope = typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : {};
+    const typeObj = (
+      /** @type {Record<string, any>} */
+      globalScope[typeName]
+    );
+    if (!typeObj) {
+      throw new Error(`Type '${typeName}' not found in global scope`);
+    }
+    return typeObj;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ComplexTypeResolver
+});

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

@@ -42,8 +42,10 @@ let fs = null;
 class JsonResolver {
   /** @type {ConfigSource} */
   jsonObject;
-  /** @type {string | ConfigSource} */
+  /** @type {string} */
   configSource;
+  /** @type {boolean} */
+  isConfigSourcePath = false;
   /**
    * @param {string | ConfigSource} configSource
    */
@@ -149,6 +151,7 @@ class JsonResolver {
         fs = requireDynamic("fs");
       }
       if (fs?.existsSync(configSource)) {
+        this.isConfigSourcePath = true;
         const jsonText = fs.readFileSync(configSource, "utf8");
         if (isValidJson(jsonText)) {
           const parsedFromFile = JSON.parse(jsonText);

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/sdk/tools/typeParsingFunctions/JavaTypeParsingFunctions.cjs

@@ -0,0 +1,44 @@
+"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 JavaTypeParsingFunctions_exports = {};
+__export(JavaTypeParsingFunctions_exports, {
+  JavaTypeParsingFunctions: () => JavaTypeParsingFunctions,
+  parseDate: () => parseDate
+});
+module.exports = __toCommonJS(JavaTypeParsingFunctions_exports);
+var import_TypeParsingUtils = require("./TypeParsingUtils.cjs");
+function parseDate(invocationContext) {
+  const result = invocationContext.getInstanceField("epochMilli").execute();
+  const action = (timestamp) => {
+    if (!timestamp) {
+      throw new Error("getTime.getValue() returned null");
+    }
+    return new Date(
+      /** @type {number} */
+      timestamp * 1e4
+    );
+  };
+  return (0, import_TypeParsingUtils.handleResultWithAction)(result, action);
+}
+const JavaTypeParsingFunctions = /* @__PURE__ */ new Map([["System.DateTime", parseDate]]);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  JavaTypeParsingFunctions,
+  parseDate
+});

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/sdk/tools/typeParsingFunctions/NetcoreTypeParsingFunctions.cjs

@@ -0,0 +1,44 @@
+"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 NetcoreTypeParsingFunctions_exports = {};
+__export(NetcoreTypeParsingFunctions_exports, {
+  NetcoreTypeParsingFunctions: () => NetcoreTypeParsingFunctions,
+  parseDate: () => parseDate
+});
+module.exports = __toCommonJS(NetcoreTypeParsingFunctions_exports);
+var import_TypeParsingUtils = require("./TypeParsingUtils.cjs");
+function parseDate(invocationContext) {
+  const result = invocationContext.getInstanceField("Ticks").execute();
+  const action = (timestamp) => {
+    if (!timestamp) {
+      throw new Error("getTime.getValue() returned null");
+    }
+    return new Date(
+      /** @type {number} */
+      timestamp
+    );
+  };
+  return (0, import_TypeParsingUtils.handleResultWithAction)(result, action);
+}
+const NetcoreTypeParsingFunctions = /* @__PURE__ */ new Map([["System.DateTime", parseDate]]);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  NetcoreTypeParsingFunctions,
+  parseDate
+});

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/sdk/tools/typeParsingFunctions/NodejsTypeParsingFunctions.cjs

@@ -0,0 +1,44 @@
+"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 NodejsTypeParsingFunctions_exports = {};
+__export(NodejsTypeParsingFunctions_exports, {
+  NodejsTypeParsingFunctions: () => NodejsTypeParsingFunctions,
+  parseDate: () => parseDate
+});
+module.exports = __toCommonJS(NodejsTypeParsingFunctions_exports);
+var import_TypeParsingUtils = require("./TypeParsingUtils.cjs");
+function parseDate(invocationContext) {
+  const result = invocationContext.invokeInstanceMethod("getTime").execute();
+  const action = (timestamp) => {
+    if (!timestamp) {
+      throw new Error("getTime.getValue() returned null");
+    }
+    return new Date(
+      /** @type {number} */
+      timestamp
+    );
+  };
+  return (0, import_TypeParsingUtils.handleResultWithAction)(result, action);
+}
+const NodejsTypeParsingFunctions = /* @__PURE__ */ new Map([["Date", parseDate]]);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  NodejsTypeParsingFunctions,
+  parseDate
+});

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/sdk/tools/typeParsingFunctions/PythonTypeParsingFunctions.cjs

@@ -0,0 +1,44 @@
+"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 PythonTypeParsingFunctions_exports = {};
+__export(PythonTypeParsingFunctions_exports, {
+  PythonTypeParsingFunctions: () => PythonTypeParsingFunctions,
+  parseDatetime: () => parseDatetime
+});
+module.exports = __toCommonJS(PythonTypeParsingFunctions_exports);
+var import_TypeParsingUtils = require("./TypeParsingUtils.cjs");
+function parseDatetime(invocationContext) {
+  const result = invocationContext.invokeInstanceMethod("timestamp").execute();
+  const action = (timestamp) => {
+    if (!timestamp) {
+      throw new Error("timestamp returned null");
+    }
+    return new Date(
+      /** @type {number} */
+      timestamp
+    );
+  };
+  return (0, import_TypeParsingUtils.handleResultWithAction)(result, action);
+}
+const PythonTypeParsingFunctions = /* @__PURE__ */ new Map([["datetime.datetime", parseDatetime]]);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PythonTypeParsingFunctions,
+  parseDatetime
+});

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/sdk/tools/typeParsingFunctions/TypeParsingUtils.cjs

@@ -0,0 +1,34 @@
+"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 TypeParsingUtils_exports = {};
+__export(TypeParsingUtils_exports, {
+  handleResultWithAction: () => handleResultWithAction
+});
+module.exports = __toCommonJS(TypeParsingUtils_exports);
+var import_IsThenable = require("../../../utils/IsThenable.cjs");
+const handleResultWithAction = (result, action) => {
+  if ((0, import_IsThenable.isThenable)(result)) {
+    return result.then((result2) => action(result2.getValue()));
+  }
+  return action(result.getValue());
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  handleResultWithAction
+});

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,13 @@
+export type Command = import("../../utils/Command.js").Command;
+/**
+ * @typedef {import('../../utils/Command.js').Command} Command
+ */
+export class GetGlobalFieldHandler extends AbstractHandler {
+    requiredParametersCount: number;
+    /**
+     * @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/GetModuleHandler.d.ts

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

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

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

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

@@ -0,0 +1,18 @@
+export type Command = import("../../utils/Command.js").Command;
+/**
+ * @typedef {import('../../utils/Command.js').Command} Command
+ */
+/**
+ * GetResultTypeHandler class handles the conversion of JType to Type.
+ */
+export class GetResultTypeHandler extends AbstractHandler {
+    /** @type {number} */
+    requiredParametersCount: number;
+    /**
+     * Processes the given command to convert JType to Type.
+     * @param {Command} command - The command to process.
+     * @returns {any} The converted type.
+     */
+    process(command: Command): any;
+}
+import { AbstractHandler } from './AbstractHandler.js';

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

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

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

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

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

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