javonet-ruby-sdk 2.6.2 → 2.6.3

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

@@ -0,0 +1,37 @@
+"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 ActivatorDetails_exports = {};
+__export(ActivatorDetails_exports, {
+  ActivatorDetails: () => ActivatorDetails
+});
+module.exports = __toCommonJS(ActivatorDetails_exports);
+class ActivatorDetails {
+  /**
+   * @param {Function} type - The constructor function/class
+   * @param {any[]} [args] - Arguments to pass to constructor
+   */
+  constructor(type, args = []) {
+    this.type = type;
+    this.arguments = args;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ActivatorDetails
+});

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

@@ -373,6 +373,30 @@ class InvocationContext {
     ]);
     return this.#createInstanceContext(localCommand);
   }
+  /**
+   * Retrieves the type of the object from the target runtime.
+   * @returns {string} The type of the object.
+   * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/type-handling/getting-object-type)
+   * @method
+   */
+  getResultType() {
+    const localCommand = new import_Command.Command(this.#runtimeName, import_CommandType.CommandType.GetResultType, []);
+    const invocationContext = new InvocationContext(this.#runtimeName, this.#connectionData, this.#buildCommand(localCommand));
+    const result = invocationContext.execute().getValue();
+    return (
+      /** @type {string} */
+      result
+    );
+  }
+  /**
+   * Retrieves the name of the runtime where the command is executed.
+   * @returns {number} The name of the runtime.
+   * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/runtime-name)
+   * @method
+   */
+  getRuntimeName() {
+    return this.#runtimeName;
+  }
   /**
    * Retrieves an array from the target runtime.
    * @returns {InvocationContext} A new InvocationContext instance that wraps the command to retrieve the array.
@@ -517,6 +541,65 @@ class InvocationWsContext extends InvocationContext {
     }
     return new InvocationWsContext(this.#runtimeName, this.#connectionData, this.#responseCommand, true);
   }
+  /**
+   * Retrieves the type of the object from the target runtime.
+   * @returns {Promise<string>} The type of the object.
+   * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/type-handling/getting-object-type)
+   * @async
+   * @method
+   */
+  // @ts-expect-error
+  async getResultType() {
+    const localCommand = new import_Command.Command(this.#runtimeName, import_CommandType.CommandType.GetResultType, []);
+    const invocationContext = new InvocationWsContext(this.#runtimeName, this.#connectionData, this.#buildCommand(localCommand));
+    const result = await invocationContext.execute();
+    return (
+      /** @type {string} */
+      result.getValue()
+    );
+  }
+  /**
+   * @param {Command} command
+   * @returns {Command}
+   */
+  #buildCommand(command) {
+    for (let i = 0; i < command.payload.length; i++) {
+      command.payload[i] = this.#encapsulatePayloadItem(command.payload[i]);
+    }
+    return command.prependArgToPayload(this.#currentCommand);
+  }
+  /**
+   * @param {unknown} payloadItem
+   * @returns {Command|null}
+   */
+  #encapsulatePayloadItem(payloadItem) {
+    if (payloadItem instanceof import_Command.Command) {
+      for (let i = 0; i < payloadItem.payload.length; i++) {
+        payloadItem.payload[i] = this.#encapsulatePayloadItem(payloadItem.payload[i]);
+      }
+      return payloadItem;
+    } else if (payloadItem instanceof InvocationContext || payloadItem instanceof InvocationWsContext) {
+      return payloadItem.get_current_command();
+    } else if (payloadItem instanceof Array) {
+      const copiedArray = payloadItem.map((item) => this.#encapsulatePayloadItem(item));
+      return new import_Command.Command(this.#runtimeName, import_CommandType.CommandType.Array, copiedArray);
+    } else if (typeof payloadItem === "function") {
+      let newArray = new Array(payloadItem.length + 1);
+      for (let i = 0; i < newArray.length; i++) {
+        newArray[i] = typeof Object;
+      }
+      const args = [import_DelegatesCache.delegatesCacheInstance.addDelegate(payloadItem), import_RuntimeName.RuntimeName.Nodejs].push(
+        ...newArray
+      );
+      return new import_Command.Command(this.#runtimeName, import_CommandType.CommandType.PassDelegate, args);
+    } else if (import_TypesHandler.TypesHandler.isPrimitiveOrNullOrUndefined(payloadItem)) {
+      return new import_Command.Command(this.#runtimeName, import_CommandType.CommandType.Value, [payloadItem]);
+    } else {
+      throw Error(
+        "Unsupported payload item type: " + (payloadItem?.constructor?.name || typeof payloadItem) + " for payload item: " + payloadItem
+      );
+    }
+  }
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

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

@@ -34,7 +34,6 @@ var import_CommandDeserializer = require("../core/protocol/CommandDeserializer.c
 var import_RuntimeLogger = require("../utils/RuntimeLogger.cjs");
 var import_TcpConnectionData = require("../utils/nodejs/connectionData/TcpConnectionData.cjs");
 var import_WsConnectionData = require("../utils/connectionData/WsConnectionData.cjs");
-var import_ActivationHelper = require("./tools/ActivationHelper.cjs");
 var import_UtilsConst = require("../utils/UtilsConst.cjs");
 const import_meta = {};
 const requireDynamic = (0, import_Runtime.getRequire)(import_meta.url);

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

@@ -264,6 +264,25 @@ class RuntimeContext {
     }
     return new import_InvocationContext.InvocationContext(this.runtimeName, this.connectionData, this.#buildCommand(localCommand));
   }
+  /**
+   * Retrieves the value of an global field from the target runtime.
+   * @param {string} fieldName - The name of the field to get.
+   * @returns {InvocationContext} A new InvocationContext instance that wraps the command to get the global field.
+   * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/fields-and-properties/getting-values-for-global-fields)
+   * @method
+   */
+  getGlobalField(fieldName) {
+    let localCommand = new import_Command.Command(this.runtimeName, import_CommandType.CommandType.GetGlobalField, [fieldName]);
+    this.#currentCommand = null;
+    if (this.connectionData.connectionType === import_ConnectionType.ConnectionType.WEB_SOCKET) {
+      return new import_InvocationContext.InvocationWsContext(
+        this.runtimeName,
+        this.connectionData,
+        this.#buildCommand(localCommand)
+      );
+    }
+    return new import_InvocationContext.InvocationContext(this.runtimeName, this.connectionData, this.#buildCommand(localCommand));
+  }
   /**
    * Invokes a function from the called runtime. This method is used when working with functions from the called runtime.
    * The arguments include the function name and the arguments to be passed to the function.

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/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';