javonet-ruby-sdk 2.6.2 → 2.6.3

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/core/handler/GetEnumItemHandler.cjs

@@ -0,0 +1,36 @@
+"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 GetEnumItemHandler_exports = {};
+__export(GetEnumItemHandler_exports, {
+  GetEnumItemHandler: () => GetEnumItemHandler
+});
+module.exports = __toCommonJS(GetEnumItemHandler_exports);
+var import_AbstractHandler = require("./AbstractHandler.cjs");
+class GetEnumItemHandler extends import_AbstractHandler.AbstractHandler {
+  /**
+   * @param {any} command
+   */
+  handleCommand(command) {
+    throw new Error(`${this.constructor.name} is not implemented in Node.js`);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  GetEnumItemHandler
+});

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/core/handler/GetEnumNameHandler.cjs

@@ -0,0 +1,36 @@
+"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 GetEnumNameHandler_exports = {};
+__export(GetEnumNameHandler_exports, {
+  GetEnumNameHandler: () => GetEnumNameHandler
+});
+module.exports = __toCommonJS(GetEnumNameHandler_exports);
+var import_AbstractHandler = require("./AbstractHandler.cjs");
+class GetEnumNameHandler extends import_AbstractHandler.AbstractHandler {
+  /**
+   * @param {any} command
+   */
+  handleCommand(command) {
+    throw new Error(`${this.constructor.name} is not implemented in Node.js`);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  GetEnumNameHandler
+});

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/core/handler/GetEnumValueHandler.cjs

@@ -0,0 +1,36 @@
+"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 GetEnumValueHandler_exports = {};
+__export(GetEnumValueHandler_exports, {
+  GetEnumValueHandler: () => GetEnumValueHandler
+});
+module.exports = __toCommonJS(GetEnumValueHandler_exports);
+var import_AbstractHandler = require("./AbstractHandler.cjs");
+class GetEnumValueHandler extends import_AbstractHandler.AbstractHandler {
+  /**
+   * @param {any} command
+   */
+  handleCommand(command) {
+    throw new Error(`${this.constructor.name} is not implemented in Node.js`);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  GetEnumValueHandler
+});

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/core/handler/GetGlobalFieldHandler.cjs

@@ -0,0 +1,63 @@
+"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 GetGlobalFieldHandler_exports = {};
+__export(GetGlobalFieldHandler_exports, {
+  GetGlobalFieldHandler: () => GetGlobalFieldHandler
+});
+module.exports = __toCommonJS(GetGlobalFieldHandler_exports);
+var import_AbstractHandler = require("./AbstractHandler.cjs");
+class GetGlobalFieldHandler extends import_AbstractHandler.AbstractHandler {
+  requiredParametersCount = 1;
+  constructor() {
+    super();
+  }
+  /**
+   * @param {Command} command
+   * @returns {any}
+   */
+  process(command) {
+    try {
+      if (command.payload.length < this.requiredParametersCount) {
+        throw new Error("Invoke Global Field parameters mismatch");
+      }
+      const { payload } = command;
+      const fieldName = payload[0];
+      if (fieldName in global && typeof global[fieldName] !== "function") {
+        return global[fieldName];
+      } else {
+        const fields = Object.getOwnPropertyNames(global).filter(
+          (property) => typeof global[property] !== "function"
+        );
+        let message = `Field ${fieldName} not found in global. Available fields:
+`;
+        fields.forEach((field) => {
+          message += `${field}
+`;
+        });
+        throw new Error(message);
+      }
+    } catch (error) {
+      throw this.process_stack_trace(error, this.constructor.name);
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  GetGlobalFieldHandler
+});

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/core/handler/GetModuleHandler.cjs

@@ -0,0 +1,36 @@
+"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 GetModuleHandler_exports = {};
+__export(GetModuleHandler_exports, {
+  GetModuleHandler: () => GetModuleHandler
+});
+module.exports = __toCommonJS(GetModuleHandler_exports);
+var import_AbstractHandler = require("./AbstractHandler.cjs");
+class GetModuleHandler extends import_AbstractHandler.AbstractHandler {
+  /**
+   * @param {any} command
+   */
+  handleCommand(command) {
+    throw new Error(`${this.constructor.name} is not implemented in Node.js`);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  GetModuleHandler
+});

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/core/handler/GetRefValueHandler.cjs

@@ -0,0 +1,36 @@
+"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 GetRefValueHandler_exports = {};
+__export(GetRefValueHandler_exports, {
+  GetRefValueHandler: () => GetRefValueHandler
+});
+module.exports = __toCommonJS(GetRefValueHandler_exports);
+var import_AbstractHandler = require("./AbstractHandler.cjs");
+class GetRefValueHandler extends import_AbstractHandler.AbstractHandler {
+  /**
+   * @param {any} command
+   */
+  handleCommand(command) {
+    throw new Error(`${this.constructor.name} is not implemented in Node.js`);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  GetRefValueHandler
+});

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/core/handler/GetResultTypeHandler.cjs

@@ -0,0 +1,43 @@
+"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 GetResultTypeHandler_exports = {};
+__export(GetResultTypeHandler_exports, {
+  GetResultTypeHandler: () => GetResultTypeHandler
+});
+module.exports = __toCommonJS(GetResultTypeHandler_exports);
+var import_TypesHandler = require("../../utils/TypesHandler.cjs");
+var import_AbstractHandler = require("./AbstractHandler.cjs");
+class GetResultTypeHandler extends import_AbstractHandler.AbstractHandler {
+  constructor() {
+    super();
+    this.requiredParametersCount = 1;
+  }
+  /**
+   * Processes the given command to convert JType to Type.
+   * @param {Command} command - The command to process.
+   * @returns {any} The converted type.
+   */
+  process(command) {
+    return command.payload[0].constructor.name;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  GetResultTypeHandler
+});

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/core/handler/Handler.cjs

@@ -25,62 +25,106 @@ module.exports = __toCommonJS(Handler_exports);
 var import_ReferencesCache = require("../referenceCache/ReferencesCache.cjs");
 var import_ValueHandler = require("./ValueHandler.cjs");
 var import_LoadLibraryHandler = require("./LoadLibraryHandler.cjs");
-var import_GetTypeHandler = require("./GetTypeHandler.cjs");
 var import_InvokeStaticMethodHandler = require("./InvokeStaticMethodHandler.cjs");
 var import_GetStaticFieldHandler = require("./GetStaticFieldHandler.cjs");
 var import_SetStaticFieldHandler = require("./SetStaticFieldHandler.cjs");
-var import_ResolveReferenceHandler = require("./ResolveReferenceHandler.cjs");
 var import_CreateClassInstanceHandler = require("./CreateClassInstanceHandler.cjs");
-var import_GetInstanceFieldHandler = require("./GetInstanceFieldHandler.cjs");
-var import_SetInstanceFieldHandler = require("./SetInstanceFieldHandler.cjs");
+var import_GetTypeHandler = require("./GetTypeHandler.cjs");
+var import_ResolveReferenceHandler = require("./ResolveReferenceHandler.cjs");
+var import_GetModuleHandler = require("./GetModuleHandler.cjs");
 var import_InvokeInstanceMethodHandler = require("./InvokeInstanceMethodHandler.cjs");
-var import_DestructReferenceHandler = require("./DestructReferenceHandler.cjs");
+var import_ExceptionHandler = require("./ExceptionHandler.cjs");
+var import_HeartBeatHandler = require("./HeartBeatHandler.cjs");
 var import_CastingHandler = require("./CastingHandler.cjs");
+var import_GetInstanceFieldHandler = require("./GetInstanceFieldHandler.cjs");
+var import_OptimizeHandler = require("./OptimizeHandler.cjs");
+var import_GenerateLibHandler = require("./GenerateLibHandler.cjs");
+var import_InvokeGlobalFunctionHandler = require("./InvokeGlobalFunctionHandler.cjs");
+var import_DestructReferenceHandler = require("./DestructReferenceHandler.cjs");
+var import_ArrayReferenceHandler = require("./ArrayReferenceHandler.cjs");
 var import_ArrayGetItemHandler = require("./ArrayGetItemHandler.cjs");
 var import_ArrayGetSizeHandler = require("./ArrayGetSizeHandler.cjs");
 var import_ArrayGetRankHandler = require("./ArrayGetRankHandler.cjs");
 var import_ArraySetItemHandler = require("./ArraySetItemHandler.cjs");
 var import_ArrayHandler = require("./ArrayHandler.cjs");
+var import_RetrieveArrayHandler = require("./RetrieveArrayHandler.cjs");
+var import_SetInstanceFieldHandler = require("./SetInstanceFieldHandler.cjs");
+var import_InvokeGenericStaticMethodHandler = require("./InvokeGenericStaticMethodHandler.cjs");
+var import_InvokeGenericMethodHandler = require("./InvokeGenericMethodHandler.cjs");
+var import_GetEnumItemHandler = require("./GetEnumItemHandler.cjs");
+var import_GetEnumNameHandler = require("./GetEnumNameHandler.cjs");
+var import_GetEnumValueHandler = require("./GetEnumValueHandler.cjs");
+var import_AsRefHandler = require("./AsRefHandler.cjs");
+var import_AsOutHandler = require("./AsOutHandler.cjs");
+var import_GetRefValueHandler = require("./GetRefValueHandler.cjs");
 var import_EnableNamespaceHandler = require("./EnableNamespaceHandler.cjs");
 var import_EnableTypeHandler = require("./EnableTypeHandler.cjs");
+var import_CreateNullHandler = require("./CreateNullHandler.cjs");
 var import_GetStaticMethodAsDelegateHandler = require("./GetStaticMethodAsDelegateHandler.cjs");
 var import_GetInstanceMethodAsDelegateHandler = require("./GetInstanceMethodAsDelegateHandler.cjs");
 var import_PassDelegateHandler = require("./PassDelegateHandler.cjs");
 var import_InvokeDelegateHandler = require("./InvokeDelegateHandler.cjs");
-var import_InvokeGlobalFunctionHandler = require("./InvokeGlobalFunctionHandler.cjs");
+var import_ConvertTypeHandler = require("./ConvertTypeHandler.cjs");
+var import_AddEventListenerHandler = require("./AddEventListenerHandler.cjs");
+var import_PluginWrapperHandler = require("./PluginWrapperHandler.cjs");
+var import_GetAsyncOperationResultHandler = require("./GetAsyncOperationResultHandler.cjs");
+var import_AsKwargsHandler = require("./AsKwargsHandler.cjs");
+var import_GetResultTypeHandler = require("./GetResultTypeHandler.cjs");
+var import_GetGlobalFieldHandler = require("./GetGlobalFieldHandler.cjs");
 var import_CommandType = require("../../utils/CommandType.cjs");
 var import_Command = require("../../utils/Command.cjs");
 var import_TypesHandler = require("../../utils/TypesHandler.cjs");
 var import_ExceptionSerializer = require("../../utils/exception/ExceptionSerializer.cjs");
-var import_ConvertTypeHandler = require("./ConvertTypeHandler.cjs");
 var import_AbstractHandler = require("./AbstractHandler.cjs");
 const handlers = {
   [import_CommandType.CommandType.Value]: new import_ValueHandler.ValueHandler(),
   [import_CommandType.CommandType.LoadLibrary]: new import_LoadLibraryHandler.LoadLibraryHandler(),
   [import_CommandType.CommandType.InvokeStaticMethod]: new import_InvokeStaticMethodHandler.InvokeStaticMethodHandler(),
-  [import_CommandType.CommandType.GetType]: new import_GetTypeHandler.GetTypeHandler(),
   [import_CommandType.CommandType.GetStaticField]: new import_GetStaticFieldHandler.GetStaticFieldHandler(),
   [import_CommandType.CommandType.SetStaticField]: new import_SetStaticFieldHandler.SetStaticFieldHandler(),
   [import_CommandType.CommandType.CreateClassInstance]: new import_CreateClassInstanceHandler.CreateClassInstanceHandler(),
+  [import_CommandType.CommandType.GetType]: new import_GetTypeHandler.GetTypeHandler(),
   [import_CommandType.CommandType.Reference]: new import_ResolveReferenceHandler.ResolveReferenceHandler(),
+  [import_CommandType.CommandType.GetModule]: new import_GetModuleHandler.GetModuleHandler(),
+  [import_CommandType.CommandType.InvokeInstanceMethod]: new import_InvokeInstanceMethodHandler.InvokeInstanceMethodHandler(),
+  [import_CommandType.CommandType.Exception]: new import_ExceptionHandler.ExceptionHandler(),
+  [import_CommandType.CommandType.HeartBeat]: new import_HeartBeatHandler.HeartBeatHandler(),
   [import_CommandType.CommandType.Cast]: new import_CastingHandler.CastingHandler(),
   [import_CommandType.CommandType.GetInstanceField]: new import_GetInstanceFieldHandler.GetInstanceFieldHandler(),
-  [import_CommandType.CommandType.SetInstanceField]: new import_SetInstanceFieldHandler.SetInstanceFieldHandler(),
-  [import_CommandType.CommandType.InvokeInstanceMethod]: new import_InvokeInstanceMethodHandler.InvokeInstanceMethodHandler(),
+  [import_CommandType.CommandType.Optimize]: new import_OptimizeHandler.OptimizeHandler(),
+  [import_CommandType.CommandType.GenerateLib]: new import_GenerateLibHandler.GenerateLibHandler(),
+  [import_CommandType.CommandType.InvokeGlobalFunction]: new import_InvokeGlobalFunctionHandler.InvokeGlobalFunctionHandler(),
   [import_CommandType.CommandType.DestructReference]: new import_DestructReferenceHandler.DestructReferenceHandler(),
+  [import_CommandType.CommandType.ArrayReference]: new import_ArrayReferenceHandler.ArrayReferenceHandler(),
   [import_CommandType.CommandType.ArrayGetItem]: new import_ArrayGetItemHandler.ArrayGetItemHandler(),
   [import_CommandType.CommandType.ArrayGetSize]: new import_ArrayGetSizeHandler.ArrayGetSizeHandler(),
   [import_CommandType.CommandType.ArrayGetRank]: new import_ArrayGetRankHandler.ArrayGetRankHandler(),
   [import_CommandType.CommandType.ArraySetItem]: new import_ArraySetItemHandler.ArraySetItemHandler(),
   [import_CommandType.CommandType.Array]: new import_ArrayHandler.ArrayHandler(),
+  [import_CommandType.CommandType.RetrieveArray]: new import_RetrieveArrayHandler.RetrieveArrayHandler(),
+  [import_CommandType.CommandType.SetInstanceField]: new import_SetInstanceFieldHandler.SetInstanceFieldHandler(),
+  [import_CommandType.CommandType.InvokeGenericStaticMethod]: new import_InvokeGenericStaticMethodHandler.InvokeGenericStaticMethodHandler(),
+  [import_CommandType.CommandType.InvokeGenericMethod]: new import_InvokeGenericMethodHandler.InvokeGenericMethodHandler(),
+  [import_CommandType.CommandType.GetEnumItem]: new import_GetEnumItemHandler.GetEnumItemHandler(),
+  [import_CommandType.CommandType.GetEnumName]: new import_GetEnumNameHandler.GetEnumNameHandler(),
+  [import_CommandType.CommandType.GetEnumValue]: new import_GetEnumValueHandler.GetEnumValueHandler(),
+  [import_CommandType.CommandType.AsRef]: new import_AsRefHandler.AsRefHandler(),
+  [import_CommandType.CommandType.AsOut]: new import_AsOutHandler.AsOutHandler(),
+  [import_CommandType.CommandType.GetRefValue]: new import_GetRefValueHandler.GetRefValueHandler(),
   [import_CommandType.CommandType.EnableNamespace]: new import_EnableNamespaceHandler.EnableNamespaceHandler(),
   [import_CommandType.CommandType.EnableType]: new import_EnableTypeHandler.EnableTypeHandler(),
+  [import_CommandType.CommandType.CreateNull]: new import_CreateNullHandler.CreateNullHandler(),
   [import_CommandType.CommandType.GetStaticMethodAsDelegate]: new import_GetStaticMethodAsDelegateHandler.GetStaticMethodAsDelegateHandler(),
   [import_CommandType.CommandType.GetInstanceMethodAsDelegate]: new import_GetInstanceMethodAsDelegateHandler.GetInstanceMethodAsDelegateHandler(),
   [import_CommandType.CommandType.PassDelegate]: new import_PassDelegateHandler.PassDelegateHandler(),
   [import_CommandType.CommandType.InvokeDelegate]: new import_InvokeDelegateHandler.InvokeDelegateHandler(),
   [import_CommandType.CommandType.ConvertType]: new import_ConvertTypeHandler.ConvertTypeHandler(),
-  [import_CommandType.CommandType.InvokeGlobalFunction]: new import_InvokeGlobalFunctionHandler.InvokeGlobalFunctionHandler()
+  [import_CommandType.CommandType.AddEventListener]: new import_AddEventListenerHandler.AddEventListenerHandler(),
+  [import_CommandType.CommandType.PluginWrapper]: new import_PluginWrapperHandler.PluginWrapperHandler(),
+  [import_CommandType.CommandType.GetAsyncOperationResult]: new import_GetAsyncOperationResultHandler.GetAsyncOperationResultHandler(),
+  [import_CommandType.CommandType.AsKwargs]: new import_AsKwargsHandler.AsKwargsHandler(),
+  [import_CommandType.CommandType.GetResultType]: new import_GetResultTypeHandler.GetResultTypeHandler(),
+  [import_CommandType.CommandType.GetGlobalField]: new import_GetGlobalFieldHandler.GetGlobalFieldHandler()
 };
 class Handler {
   /**

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/core/handler/HeartBeatHandler.cjs

@@ -0,0 +1,36 @@
+"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 HeartBeatHandler_exports = {};
+__export(HeartBeatHandler_exports, {
+  HeartBeatHandler: () => HeartBeatHandler
+});
+module.exports = __toCommonJS(HeartBeatHandler_exports);
+var import_AbstractHandler = require("./AbstractHandler.cjs");
+class HeartBeatHandler extends import_AbstractHandler.AbstractHandler {
+  /**
+   * @param {any} command
+   */
+  handleCommand(command) {
+    throw new Error(`${this.constructor.name} is not implemented in Node.js`);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  HeartBeatHandler
+});

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/core/handler/InvokeGenericMethodHandler.cjs

@@ -0,0 +1,36 @@
+"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 InvokeGenericMethodHandler_exports = {};
+__export(InvokeGenericMethodHandler_exports, {
+  InvokeGenericMethodHandler: () => InvokeGenericMethodHandler
+});
+module.exports = __toCommonJS(InvokeGenericMethodHandler_exports);
+var import_AbstractHandler = require("./AbstractHandler.cjs");
+class InvokeGenericMethodHandler extends import_AbstractHandler.AbstractHandler {
+  /**
+   * @param {any} command
+   */
+  handleCommand(command) {
+    throw new Error(`${this.constructor.name} is not implemented in Node.js`);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  InvokeGenericMethodHandler
+});

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/core/handler/InvokeGenericStaticMethodHandler.cjs

@@ -0,0 +1,36 @@
+"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 InvokeGenericStaticMethodHandler_exports = {};
+__export(InvokeGenericStaticMethodHandler_exports, {
+  InvokeGenericStaticMethodHandler: () => InvokeGenericStaticMethodHandler
+});
+module.exports = __toCommonJS(InvokeGenericStaticMethodHandler_exports);
+var import_AbstractHandler = require("./AbstractHandler.cjs");
+class InvokeGenericStaticMethodHandler extends import_AbstractHandler.AbstractHandler {
+  /**
+   * @param {any} command
+   */
+  handleCommand(command) {
+    throw new Error(`${this.constructor.name} is not implemented in Node.js`);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  InvokeGenericStaticMethodHandler
+});

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/core/handler/OptimizeHandler.cjs

@@ -0,0 +1,36 @@
+"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 OptimizeHandler_exports = {};
+__export(OptimizeHandler_exports, {
+  OptimizeHandler: () => OptimizeHandler
+});
+module.exports = __toCommonJS(OptimizeHandler_exports);
+var import_AbstractHandler = require("./AbstractHandler.cjs");
+class OptimizeHandler extends import_AbstractHandler.AbstractHandler {
+  /**
+   * @param {any} command
+   */
+  handleCommand(command) {
+    throw new Error(`${this.constructor.name} is not implemented in Node.js`);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  OptimizeHandler
+});

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/core/handler/PluginWrapperHandler.cjs

@@ -0,0 +1,36 @@
+"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 PluginWrapperHandler_exports = {};
+__export(PluginWrapperHandler_exports, {
+  PluginWrapperHandler: () => PluginWrapperHandler
+});
+module.exports = __toCommonJS(PluginWrapperHandler_exports);
+var import_AbstractHandler = require("./AbstractHandler.cjs");
+class PluginWrapperHandler extends import_AbstractHandler.AbstractHandler {
+  /**
+   * @param {any} command
+   */
+  handleCommand(command) {
+    throw new Error(`${this.constructor.name} is not implemented in Node.js`);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PluginWrapperHandler
+});

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/core/handler/RetrieveArrayHandler.cjs

@@ -0,0 +1,36 @@
+"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 RetrieveArrayHandler_exports = {};
+__export(RetrieveArrayHandler_exports, {
+  RetrieveArrayHandler: () => RetrieveArrayHandler
+});
+module.exports = __toCommonJS(RetrieveArrayHandler_exports);
+var import_AbstractHandler = require("./AbstractHandler.cjs");
+class RetrieveArrayHandler extends import_AbstractHandler.AbstractHandler {
+  /**
+   * @param {any} command
+   */
+  handleCommand(command) {
+    throw new Error(`${this.constructor.name} is not implemented in Node.js`);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RetrieveArrayHandler
+});