javonet-ruby-sdk 2.6.4 → 2.6.6

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/core/transmitter/TransmitterWebsocket.cjs

@@ -40,9 +40,9 @@ class TransmitterWebsocket {
   }
   /**
    * @async
-   * @param {Int8Array} messageByteArray
+   * @param {Uint8Array} messageByteArray
    * @param {IConnectionData} connectionData
-   * @returns {Promise<Int8Array>} responseByteArray
+   * @returns {Promise<Uint8Array>} responseByteArray
    */
   static sendCommand(messageByteArray, connectionData) {
     const { hostname } = connectionData;

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/core/transmitter/TransmitterWebsocketBrowser.cjs

@@ -35,9 +35,9 @@ class TransmitterWebsocketBrowser {
   }
   /**
    * @async
-   * @param {Int8Array} messageByteArray
+   * @param {Uint8Array} messageByteArray
    * @param {IConnectionData} connectionData
-   * @returns {Promise<Int8Array>} responseByteArray
+   * @returns {Promise<Uint8Array>} responseByteArray
    */
   static async sendCommand(messageByteArray, connectionData) {
     const { hostname } = connectionData;

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/core/transmitter/TransmitterWrapper.cjs

@@ -65,7 +65,8 @@ class TransmitterWrapper {
     return library.activate(licenseKey);
   }
   /**
-   * @param {Int8Array} messageArray
+   * @param {Uint8Array} messageArray
+   * @returns {Uint8Array}
    */
   static sendCommand(messageArray) {
     this.loadNativeLibrary();

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/core/webSocketClient/WebSocketClient.cjs

@@ -62,8 +62,8 @@ class WebSocketClient {
   /**
    * Sends messageArray through websocket connection with guaranteed order preservation
    * @async
-   * @param {Int8Array} messageArray
-   * @returns {Promise<Int8Array>}
+   * @param {Uint8Array} messageArray
+   * @returns {Promise<Uint8Array>}
    */
   send(messageArray) {
     return new Promise((resolve, reject) => {
@@ -104,8 +104,8 @@ class WebSocketClient {
    * Sends a single message through websocket connection
    * @private
    * @async
-   * @param {Int8Array} messageArray
-   * @returns {Promise<Int8Array>}
+   * @param {Uint8Array} messageArray
+   * @returns {Promise<Uint8Array>}
    */
   _send(messageArray) {
     return new Promise((resolve, reject) => {

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/core/webSocketClient/WebSocketClientBrowser.cjs

@@ -60,8 +60,8 @@ class WebSocketClientBrowser {
   /**
    * Sends messageArray through websocket connection with guaranteed order preservation
    * @async
-   * @param {Int8Array} messageArray
-   * @returns {Promise<Int8Array>}
+   * @param {Uint8Array} messageArray
+   * @returns {Promise<Uint8Array>}
    */
   send(messageArray) {
     return new Promise((resolve, reject) => {
@@ -102,8 +102,8 @@ class WebSocketClientBrowser {
    * Sends a single message through websocket connection
    * @private
    * @async
-   * @param {Int8Array} messageArray
-   * @returns {Promise<Int8Array>}
+   * @param {Uint8Array} messageArray
+   * @returns {Promise<Uint8Array>}
    */
   _sendSingle(messageArray) {
     return new Promise((resolve, reject) => {
@@ -162,8 +162,8 @@ class WebSocketClientBrowser {
    * Sends the data to the WebSocket server and listens for a response.
    * @private
    * @param {WebSocket} client
-   * @param {Int8Array} data
-   * @param {(value: Int8Array) => void} resolve
+   * @param {Uint8Array} data
+   * @param {(value: Uint8Array) => void} resolve
    * @param {(reason?: any) => void} reject
    */
   _sendMessage(client, data, resolve, reject) {
@@ -174,7 +174,7 @@ class WebSocketClientBrowser {
         if (!message?.data) {
           return reject(new Error("Invalid message received"));
         }
-        const byteArray = new Int8Array(message?.data);
+        const byteArray = new Uint8Array(message?.data);
         resolve(byteArray);
         if (this.isDisconnectedAfterMessage) {
           this.disconnect();

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

@@ -37,12 +37,10 @@ class InvocationContext {
   #connectionData;
   /** @type {Command | null} */
   #currentCommand = null;
-  /** @type {Command | null} */
+  /** @type {Command | Promise<Command> | null} */
   #responseCommand = null;
   /** @type {boolean} */
   #isExecuted = false;
-  /** @type {any | null} */
-  #resultValue = null;
   /** @type {Interpreter | null} */
   #interpreter = null;
   /**
@@ -59,7 +57,6 @@ class InvocationContext {
     this.#responseCommand = null;
     this.#isExecuted = isExecuted;
     this.#interpreter = null;
-    this.#resultValue = null;
   }
   /**
    * @param {Command} localCommand
@@ -100,7 +97,18 @@ class InvocationContext {
       throw new Error("Object is not iterable");
     }
     let position = -1;
-    const arraySize = Number(this.getSize().execute().getValue());
+    let arraySize = 0;
+    const sizeCtx = (
+      /** @type {any} */
+      this.getSize().execute()
+    );
+    if (sizeCtx instanceof Promise) {
+      sizeCtx.then((ctx) => {
+        arraySize = Number(ctx.getValue());
+      });
+    } else {
+      arraySize = Number(sizeCtx.getValue());
+    }
     return {
       next: () => ({
         value: this.getIndex(++position),
@@ -115,7 +123,7 @@ class InvocationContext {
    * Commands are becoming nested through each invocation of methods on Invocation Context.
    * Each invocation triggers the creation of new Invocation Context instance wrapping the current command with new parent command valid for invoked method.
    * Developer can decide on any moment of the materialization for the context taking full control of the chunks of the expression being transferred and processed on target runtime.
-   * @returns {InvocationContext} the InvocationContext after executing the command.
+   * @returns {Promise<InvocationContext> | InvocationContext} the InvocationContext after executing the command.
    * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/foundations/execute-method)
    * @method
    */
@@ -127,18 +135,25 @@ class InvocationContext {
       this.#interpreter = new import_Interpreter.Interpreter();
     }
     this.#responseCommand = this.#interpreter.execute(this.#currentCommand, this.#connectionData);
-    if (!this.#responseCommand) {
-      throw new Error("responseCommand is undefined in Invocation Context execute method");
-    }
-    if (this.#responseCommand?.commandType === import_CommandType.CommandType.Exception) {
-      throw import_ExceptionThrower.ExceptionThrower.throwException(this.#responseCommand);
-    }
-    if (this.#responseCommand?.commandType === import_CommandType.CommandType.CreateClassInstance) {
-      this.#currentCommand = this.#responseCommand;
-      this.#isExecuted = true;
-      return this;
+    const handleResponse = (resolvedResponse) => {
+      if (!resolvedResponse) {
+        throw new Error("responseCommand is undefined in Invocation Context execute method");
+      }
+      if (resolvedResponse.commandType === import_CommandType.CommandType.Exception) {
+        throw import_ExceptionThrower.ExceptionThrower.throwException(resolvedResponse);
+      }
+      if (resolvedResponse.commandType === import_CommandType.CommandType.CreateClassInstance) {
+        this.#currentCommand = resolvedResponse;
+        this.#isExecuted = true;
+        return this;
+      }
+      return new InvocationContext(this.#runtimeName, this.#connectionData, resolvedResponse, true);
+    };
+    if (this.#responseCommand instanceof Promise) {
+      return this.#responseCommand.then(handleResponse);
+    } else {
+      return handleResponse(this.#responseCommand);
     }
-    return new InvocationContext(this.#runtimeName, this.#connectionData, this.#responseCommand, true);
   }
   /**
    * Invokes a static method on the target runtime.
@@ -375,7 +390,7 @@ class InvocationContext {
   }
   /**
    * Retrieves the type of the object from the target runtime.
-   * @returns {string} The type of the object.
+   * @returns {Promise<string> | string} The type of the object.
    * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/type-handling/getting-object-type)
    * @method
    */
@@ -386,7 +401,11 @@ class InvocationContext {
       this.#connectionData,
       this.#buildCommand(localCommand)
     );
-    const result = invocationContext.execute().getValue();
+    const execCtx = (
+      /** @type {any} */
+      invocationContext.execute()
+    );
+    const result = execCtx.getValue();
     return (
       /** @type {string} */
       result
@@ -403,36 +422,31 @@ class InvocationContext {
   }
   /**
    * Retrieves an array from the target runtime.
-   * @returns {InvocationContext} A new InvocationContext instance that wraps the command to retrieve the array.
-   * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/arrays-and-collections/retrieve-array)
+   * @returns {Promise<any[]>}
    * @method
    */
   retrieveArray() {
-    let localCommand = new import_Command.Command(this.#runtimeName, import_CommandType.CommandType.RetrieveArray, []);
-    let localInvCtx = new InvocationContext(
+    const localCommand = new import_Command.Command(this.#runtimeName, import_CommandType.CommandType.RetrieveArray, []);
+    const localInvCtx = new InvocationContext(
       this.#runtimeName,
       this.#connectionData,
       this.#buildCommand(localCommand)
     );
     localInvCtx.execute();
-    if (localInvCtx.#responseCommand === null) {
-      throw new Error("responseCommand is undefined in Invocation Context execute method");
-    }
-    return localInvCtx.#responseCommand.payload;
+    const extract = (respCommand) => {
+      return respCommand.payload;
+    };
+    return localInvCtx.#responseCommand instanceof Promise ? localInvCtx.#responseCommand.then(extract) : localInvCtx.#responseCommand?.payload;
   }
   /**
    * Returns the primitive value from the target runtime. This could be any primitive type in JavaScript,
    * such as int, boolean, byte, char, long, double, float, etc.
-   * @returns {Command} The value of the current command.
+   * @returns {unknown} The value of the current command.
    * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/foundations/execute-method)
    * @method
    */
-  /**
-   * @returns {unknown}
-   */
   getValue() {
-    this.#resultValue = this.#currentCommand?.payload[0];
-    return this.#resultValue;
+    return this.#currentCommand?.payload[0];
   }
   /**
    * @param {Command} command
@@ -490,8 +504,6 @@ class InvocationWsContext extends InvocationContext {
   #interpreter;
   /** @type {boolean} */
   #isExecuted;
-  /** @type {any | null} */
-  #resultValue;
   /**
    * @param {RuntimeNameType} runtimeName
    * @param {IConnectionData} connectionData
@@ -506,7 +518,6 @@ class InvocationWsContext extends InvocationContext {
     this.#responseCommand = null;
     this.#isExecuted = isExecuted;
     this.#interpreter = null;
-    this.#resultValue = null;
   }
   /**
    * Executes the current command.
@@ -520,7 +531,6 @@ class InvocationWsContext extends InvocationContext {
    * @async
    * @method
    */
-  // @ts-expect-error
   async execute() {
     if (this.#currentCommand === null) {
       throw new Error("currentCommand is undefined in Invocation Context execute method");
@@ -552,7 +562,6 @@ class InvocationWsContext extends InvocationContext {
    * @async
    * @method
    */
-  // @ts-expect-error
   async getResultType() {
     const localCommand = new import_Command.Command(this.#runtimeName, import_CommandType.CommandType.GetResultType, []);
     const invocationContext = new InvocationWsContext(

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

@@ -23,6 +23,7 @@ __export(RuntimeFactory_exports, {
 module.exports = __toCommonJS(RuntimeFactory_exports);
 var import_RuntimeName = require("../utils/RuntimeName.cjs");
 var import_RuntimeContext = require("./RuntimeContext.cjs");
+var import_ConnectionType = require("../utils/ConnectionType.cjs");
 class RuntimeFactory {
   /**
    * @param {IConnectionData} connectionData
@@ -103,27 +104,24 @@ class RuntimeFactory {
     return import_RuntimeContext.RuntimeContext.getInstance(import_RuntimeName.RuntimeName.Python27, this.connectionData);
   }
   /**
-   * @param {{ runtime: import("../types.js").RuntimeName; connectionData: import("../utils/connectionData/IConnectionData.js").IConnectionData; modules: any; }} config
+   * @param {{ runtime: import("../types.js").RuntimeName; connectionData: import("../utils/connectionData/IConnectionData.js").IConnectionData; modules: string; }} config
    */
   static initializeRuntimeContext(config) {
     const rtmCtx = import_RuntimeContext.RuntimeContext.getInstance(config.runtime, config.connectionData);
-    const modules = (config.modules || "").split(",").map((m) => m.trim()).filter((m) => m !== "");
-    let pathModule = null;
-    try {
-      const _require = typeof require !== "undefined" ? require : eval("require");
-      pathModule = _require("path");
-    } catch (e) {
-      pathModule = null;
-    }
-    modules.forEach((module2) => {
-      const isAbsolute = pathModule ? pathModule.isAbsolute(module2) : module2.startsWith("/") || /^[A-Za-z]:\\/.test(module2);
-      if (isAbsolute) {
-        rtmCtx.loadLibrary(module2);
-      } else {
-        const resolved = pathModule ? pathModule.join(process.cwd(), module2) : `${process.cwd()}/${module2}`;
-        rtmCtx.loadLibrary(resolved);
+    if (config.connectionData.connectionType === import_ConnectionType.ConnectionType.IN_MEMORY) {
+      const modules = (config.modules || "").split(",").map((m) => m.trim()).filter((m) => m !== "");
+      let pathModule = null;
+      try {
+        const _require = typeof require !== "undefined" ? require : eval("require");
+        pathModule = _require("path");
+      } catch (e) {
+        pathModule = null;
       }
-    });
+      modules.forEach((module2) => {
+        const fullPath = pathModule ? pathModule.resolve(module2) : module2;
+        rtmCtx.loadLibrary(fullPath);
+      });
+    }
     return rtmCtx;
   }
 }

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

@@ -1,7 +1,9 @@
 "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)
@@ -15,6 +17,14 @@ var __copyProps = (to, from, except, desc) => {
   }
   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 ComplexTypeResolver_exports = {};
 __export(ComplexTypeResolver_exports, {
@@ -29,6 +39,7 @@ var import_JavaTypeParsingFunctions = require("./typeParsingFunctions/JavaTypePa
 var import_NetcoreTypeParsingFunctions = require("./typeParsingFunctions/NetcoreTypeParsingFunctions.cjs");
 var import_NodejsTypeParsingFunctions = require("./typeParsingFunctions/NodejsTypeParsingFunctions.cjs");
 var import_PythonTypeParsingFunctions = require("./typeParsingFunctions/PythonTypeParsingFunctions.cjs");
+var util = __toESM(require("node:util"), 1);
 const import_meta = {};
 const dynamicImport = (0, import_Runtime.getRequire)(import_meta.url);
 class ComplexTypeResolver {
@@ -56,19 +67,33 @@ class ComplexTypeResolver {
   /**
    * Convert InvocationContext result to appropriate JavaScript type
    * @param {InvocationContext} ic - The invocation context
-   * @returns {any} The converted result
+   * @returns {Promise<any> | 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);
+      let parsingFunc = null;
+      if (resultType instanceof Promise) {
+        parsingFunc = resultType.then((result) => {
+          parsingFunc = runtimeDict.get(result);
+        });
+      } else {
+        parsingFunc = runtimeDict.get(resultType);
+      }
       if (parsingFunc) {
         return parsingFunc(ic);
       }
     }
-    const activatorDetails = this.#typeMap.get(resultType);
+    let activatorDetails = null;
+    if (resultType instanceof Promise) {
+      activatorDetails = resultType.then((result) => {
+        activatorDetails = this.#typeMap.get(result);
+      });
+    } else {
+      activatorDetails = this.#typeMap.get(resultType);
+    }
     if (!activatorDetails) {
       throw new Error(`No type registered for key '${resultType}'.`);
     }

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

@@ -8,13 +8,13 @@ export class Handler {
     /**
      * @param {Command} command
      */
-    handleCommand(command: Command): Command;
+    handleCommand(command: Command): Command | Promise<Command>;
     /**
      * @param {any} response
      * @param {RuntimeName} runtimeName
-     * @returns {Command}
+     * @returns {Promise<Command> | Command}
      */
-    parseCommand(response: any, runtimeName: RuntimeName): Command;
+    parseCommand(response: any, runtimeName: RuntimeName): Promise<Command> | Command;
 }
 /**
  * @typedef {import('../../types.d.ts').RuntimeName} RuntimeName

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/types/core/interpreter/Interpreter.d.ts

@@ -19,10 +19,10 @@ export class Interpreter {
     execute(command: Command, connectionData: IConnectionData): Command | Promise<Command>;
     /**
      *
-     * @param {Int8Array} messageByteArray
-     * @returns {Command}
+     * @param {Uint8Array} messageByteArray
+     * @returns {Promise<Command> | Command}
      */
-    process(messageByteArray: Int8Array): Command;
+    process(messageByteArray: Uint8Array): Promise<Command> | Command;
 }
 export type IConnectionData = import("../../utils/connectionData/IConnectionData.js").IConnectionData;
 export type RuntimeNameType = typeof import("../../types.d.ts").RuntimeName;

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/types/core/protocol/CommandDeserializer.d.ts

@@ -1,9 +1,9 @@
 export class CommandDeserializer {
     /**
-     * @param {Int8Array} buffer
+     * @param {Uint8Array} byteArray
      */
-    constructor(buffer: Int8Array);
-    buffer: Int8Array<ArrayBufferLike>;
+    constructor(byteArray: Uint8Array);
+    buffer: Uint8Array<ArrayBufferLike>;
     command: Command;
     position: number;
     /**

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/types/core/protocol/CommandSerializer.d.ts

@@ -5,12 +5,12 @@ export type IConnectionData = import("../../utils/connectionData/IConnectionData
 export class CommandSerializer {
     /**
      * Serializes the root command with connection data and optional runtime version.
-     * @param {Command} rootCommand
+     * @param {Promise<Command> | Command} rootCommand
      * @param {IConnectionData} connectionData
      * @param {number} runtimeVersion
-     * @returns {Int8Array}
+     * @returns {Promise<Uint8Array> | Uint8Array}
      */
-    serialize(rootCommand: Command, connectionData: IConnectionData, runtimeVersion?: number): Int8Array;
+    serialize(rootCommand: Promise<Command> | Command, connectionData: IConnectionData, runtimeVersion?: number): Promise<Uint8Array> | Uint8Array;
     /**
      * Recursively serializes command payload.
      * @param {Command} command

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/types/core/protocol/TypeDeserializer.d.ts

@@ -1,50 +1,50 @@
 export class TypeDeserializer {
     /**
-     * @param {Int8Array} encodedCommand
+     * @param {Uint8Array} encodedCommand
      * @returns {Command}
      */
-    static deserializeCommand(encodedCommand: Int8Array): Command;
+    static deserializeCommand(encodedCommand: Uint8Array): Command;
     /**
      * @param {number} stringEncodingMode
-     * @param {Int8Array} encodedString
+     * @param {Uint8Array} encodedString
      */
-    static deserializeString(stringEncodingMode: number, encodedString: Int8Array): string;
+    static deserializeString(stringEncodingMode: number, encodedString: Uint8Array): string;
     /**
-     * @param {Int8Array} encodedInt
+     * @param {Uint8Array} encodedInt
      */
-    static deserializeInt(encodedInt: Int8Array): number;
+    static deserializeInt(encodedInt: Uint8Array): number;
     /**
-     * @param {Int8Array} encodedBool
+     * @param {Uint8Array} encodedBool
      */
-    static deserializeBool(encodedBool: Int8Array): boolean;
+    static deserializeBool(encodedBool: Uint8Array): boolean;
     /**
-     * @param {Int8Array} encodedFloat
+     * @param {Uint8Array} encodedFloat
      */
-    static deserializeFloat(encodedFloat: Int8Array): number;
+    static deserializeFloat(encodedFloat: Uint8Array): number;
     /**
-     * @param {Int8Array} encodedByte
+     * @param {Uint8Array} encodedByte
      */
-    static deserializeByte(encodedByte: Int8Array): number;
+    static deserializeByte(encodedByte: Uint8Array): number;
     /**
-     * @param {Int8Array} encodedChar
+     * @param {Uint8Array} encodedChar
      */
-    static deserializeChar(encodedChar: Int8Array): number;
+    static deserializeChar(encodedChar: Uint8Array): number;
     /**
-     * @param {Int8Array} encodedLongLong
+     * @param {Uint8Array} encodedLongLong
      */
-    static deserializeLongLong(encodedLongLong: Int8Array): bigint;
+    static deserializeLongLong(encodedLongLong: Uint8Array): bigint;
     /**
-     * @param {Int8Array} encodedDouble
+     * @param {Uint8Array} encodedDouble
      */
-    static deserializeDouble(encodedDouble: Int8Array): number;
+    static deserializeDouble(encodedDouble: Uint8Array): number;
     /**
-     * @param {Int8Array} encodedULLong
+     * @param {Uint8Array} encodedULLong
      */
-    static deserializeULLong(encodedULLong: Int8Array): bigint;
+    static deserializeULLong(encodedULLong: Uint8Array): bigint;
     /**
-     * @param {Int8Array} encodedUInt
+     * @param {Uint8Array} encodedUInt
      */
-    static deserializeUInt(encodedUInt: Int8Array): number;
+    static deserializeUInt(encodedUInt: Uint8Array): number;
     static deserializeNull(encodedNull?: null): null;
 }
 import { Command } from '../../utils/Command.js';

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/types/core/receiver/Receiver.d.ts

@@ -2,14 +2,15 @@ export class Receiver {
     static connectionData: InMemoryConnectionData;
     static getRuntimeInfo(): string;
     /**
-     * @param {Int8Array} messageByteArray
+     * @param {Uint8Array} messageByteArray
+     * @returns {Promise<Uint8Array> | Uint8Array}
      */
-    static sendCommand(messageByteArray: Int8Array): Int8Array<ArrayBufferLike>;
+    static sendCommand(messageByteArray: Uint8Array): Promise<Uint8Array> | Uint8Array;
     /**
-     * @param {Int8Array} messageByteArray
-     * @returns {Int8Array}
+     * @param {Uint8Array} messageByteArray
+     * @returns {Promise<Uint8Array> | Uint8Array}
      */
-    static heartBeat(messageByteArray: Int8Array): Int8Array;
+    static heartBeat(messageByteArray: Uint8Array): Promise<Uint8Array> | Uint8Array;
     Receiver(): void;
 }
 import { InMemoryConnectionData } from '../../utils/connectionData/InMemoryConnectionData.js';

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/types/core/receiver/ReceiverNative.d.ts

@@ -1,10 +1,12 @@
 export class ReceiverNative {
     /**
-     * @param {Int8Array} messageByteArray
+     * @param {Uint8Array} messageByteArray
+     * @returns {Promise<Uint8Array> | Uint8Array}
      */
-    static sendCommand(messageByteArray: Int8Array): Int8Array<ArrayBufferLike>;
+    static sendCommand(messageByteArray: Uint8Array): Promise<Uint8Array> | Uint8Array;
     /**
-     * @param {Int8Array} messageByteArray
+     * @param {Uint8Array} messageByteArray
+     * @returns {Uint8Array | Promise<Uint8Array>}
      */
-    static heartBeat(messageByteArray: Int8Array): Int8Array<ArrayBufferLike>;
+    static heartBeat(messageByteArray: Uint8Array): Uint8Array | Promise<Uint8Array>;
 }

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/types/core/transmitter/Transmitter.d.ts

@@ -1,9 +1,9 @@
 export class Transmitter {
     /**
-     * @param {Int8Array} messageArray
-     * @returns {Int8Array}
+     * @param {Uint8Array} messageArray
+     * @returns {Uint8Array}
      */
-    static sendCommand(messageArray: Int8Array): Int8Array;
+    static sendCommand(messageArray: Uint8Array): Uint8Array;
     /**
      * @param {string} licenseKey
      * @returns {void}

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/types/core/transmitter/TransmitterWebsocket.d.ts

@@ -16,10 +16,10 @@ export class TransmitterWebsocket {
     static activate(): void;
     /**
      * @async
-     * @param {Int8Array} messageByteArray
+     * @param {Uint8Array} messageByteArray
      * @param {IConnectionData} connectionData
-     * @returns {Promise<Int8Array>} responseByteArray
+     * @returns {Promise<Uint8Array>} responseByteArray
      */
-    static sendCommand(messageByteArray: Int8Array, connectionData: IConnectionData): Promise<Int8Array>;
+    static sendCommand(messageByteArray: Uint8Array, connectionData: IConnectionData): Promise<Uint8Array>;
 }
 export type IConnectionData = import("../../utils/connectionData/IConnectionData.js").IConnectionData;

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/types/core/transmitter/TransmitterWebsocketBrowser.d.ts

@@ -12,11 +12,11 @@ export class TransmitterWebsocketBrowser {
     static activate(): void;
     /**
      * @async
-     * @param {Int8Array} messageByteArray
+     * @param {Uint8Array} messageByteArray
      * @param {IConnectionData} connectionData
-     * @returns {Promise<Int8Array>} responseByteArray
+     * @returns {Promise<Uint8Array>} responseByteArray
      */
-    static sendCommand(messageByteArray: Int8Array, connectionData: IConnectionData): Promise<Int8Array>;
+    static sendCommand(messageByteArray: Uint8Array, connectionData: IConnectionData): Promise<Uint8Array>;
     /**
      * @async
      * @param {any} configSource

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/types/core/transmitter/TransmitterWrapper.d.ts

@@ -6,9 +6,10 @@ export class TransmitterWrapper {
      */
     static activate(licenseKey: string): any;
     /**
-     * @param {Int8Array} messageArray
+     * @param {Uint8Array} messageArray
+     * @returns {Uint8Array}
      */
-    static sendCommand(messageArray: Int8Array): any;
+    static sendCommand(messageArray: Uint8Array): Uint8Array;
     /**
      * @param {string} configSource
      */