javonet-ruby-sdk 2.6.3 → 2.6.5

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

@@ -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/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/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}
@@ -12,7 +12,7 @@ export class Transmitter {
     /**
      * @param {string} configSource
      * @returns {void}
-    */
+     */
     static setConfigSource(configSource: string): void;
     /**
      * @param {string} workingDirectory

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
      */

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/types/core/webSocketClient/WebSocketClient.d.ts

@@ -1,10 +1,10 @@
 /** @type {Record<string, wsClient>} */
 export const clients: Record<string, wsClient>;
-/** @type {Record<string, Array<{resolve: Function, reject: Function, messageArray: Int8Array}>>} */
+/** @type {Record<string, Array<{resolve: Function, reject: Function, messageArray: Uint8Array}>>} */
 export const messageQueue: Record<string, Array<{
     resolve: Function;
     reject: Function;
-    messageArray: Int8Array;
+    messageArray: Uint8Array;
 }>>;
 /** @type {Record<string, boolean>} */
 export const processingQueues: Record<string, boolean>;
@@ -31,10 +31,10 @@ export 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: Int8Array): Promise<Int8Array>;
+    send(messageArray: Uint8Array): Promise<Uint8Array>;
     /**
      * Processes message queue sequentially to maintain order
      * @private
@@ -45,8 +45,8 @@ export class WebSocketClient {
      * Sends a single message through websocket connection
      * @private
      * @async
-     * @param {Int8Array} messageArray
-     * @returns {Promise<Int8Array>}
+     * @param {Uint8Array} messageArray
+     * @returns {Promise<Uint8Array>}
      */
     private _send;
     /**

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/types/core/webSocketClient/WebSocketClientBrowser.d.ts

@@ -4,11 +4,11 @@
  */
 /** @type {Record<string, WebSocket>} */
 export const clients: Record<string, WebSocket>;
-/** @type {Record<string, Array<{resolve: Function, reject: Function, messageArray: Int8Array}>>} */
+/** @type {Record<string, Array<{resolve: Function, reject: Function, messageArray: Uint8Array}>>} */
 export const messageQueue: Record<string, Array<{
     resolve: Function;
     reject: Function;
-    messageArray: Int8Array;
+    messageArray: Uint8Array;
 }>>;
 /** @type {Record<string, boolean>} */
 export const processingQueues: Record<string, boolean>;
@@ -34,10 +34,10 @@ export 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: Int8Array): Promise<Int8Array>;
+    send(messageArray: Uint8Array): Promise<Uint8Array>;
     /**
      * Processes message queue sequentially to maintain order
      * @private
@@ -48,8 +48,8 @@ export class WebSocketClientBrowser {
      * Sends a single message through websocket connection
      * @private
      * @async
-     * @param {Int8Array} messageArray
-     * @returns {Promise<Int8Array>}
+     * @param {Uint8Array} messageArray
+     * @returns {Promise<Uint8Array>}
      */
     private _sendSingle;
     /**
@@ -67,8 +67,8 @@ export 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
      */
     private _sendMessage;

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/types/sdk/ConfigRuntimeFactory.d.ts

@@ -8,6 +8,9 @@
  * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/foundations/runtime-context)
  */
 export class ConfigRuntimeFactory {
+    static _IN_MEMORY_CONNECTION_TYPES: string[];
+    static _WEB_SOCKET_CONNECTION_TYPES: string[];
+    static _TCP_CONNECTION_TYPES: string[];
     /**
      * @param {ConfigSource | string} configSource
      */

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/types/sdk/InvocationContext.d.ts

@@ -31,11 +31,11 @@ export 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
      */
-    execute(): InvocationContext;
+    execute(): Promise<InvocationContext> | InvocationContext;
     /**
      * Invokes a static method on the target runtime.
      * @param {string} methodName - The name of the method to invoke.
@@ -196,11 +196,11 @@ export class InvocationContext {
     getInstanceMethodAsDelegate(methodName: string, ...args: any[]): InvocationContext | InvocationWsContext;
     /**
      * 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
      */
-    getResultType(): string;
+    getResultType(): Promise<string> | string;
     /**
      * Retrieves the name of the runtime where the command is executed.
      * @returns {number} The name of the runtime.
@@ -210,21 +210,17 @@ export class InvocationContext {
     getRuntimeName(): number;
     /**
      * 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(): InvocationContext;
+    retrieveArray(): Promise<any[]>;
     /**
      * 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(): unknown;
     [Symbol.iterator]: () => {
         next: () => {

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/types/sdk/Javonet.d.ts

@@ -58,11 +58,25 @@ export class Javonet {
      * @returns {void}
      */
     static setJavonetWorkingDirectory(path: string): void;
+    /**
+     * Adds a configuration to the ConfigSourceResolver with the specified priority and source.
+     * @param {number} priority - The priority of the configuration.
+     * @param {string} configSource - The configuration source.
+     */
+    static addConfig(priority: number, configSource: string): void;
+    /**
+     * Initializes a RuntimeContext instance based on the specified configuration name.
+     * @param {string} configName - The name of the configuration to use.
+     * @returns {RuntimeContext}  A RuntimeContext instance initialized with the specified configuration.
+     */
+    static initializeRc(configName: string): RuntimeContext;
 }
 import { TcpConnectionData } from '../utils/nodejs/connectionData/TcpConnectionData.js';
 import { WsConnectionData } from '../utils/connectionData/WsConnectionData.js';
 import { CommandSerializer } from '../core/protocol/CommandSerializer.js';
 import { CommandDeserializer } from '../core/protocol/CommandDeserializer.js';
+import { ConfigPriority } from './configuration/ConfigPriority.js';
 import { RuntimeFactory } from './RuntimeFactory.js';
 import { ConfigRuntimeFactory } from './ConfigRuntimeFactory.js';
-export { TcpConnectionData, WsConnectionData, CommandSerializer, CommandDeserializer };
+import { RuntimeContext } from './RuntimeContext.js';
+export { TcpConnectionData, WsConnectionData, CommandSerializer, CommandDeserializer, ConfigPriority };