javonet-ruby-sdk 2.5.15 → 2.5.16

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

@@ -0,0 +1,207 @@
+/**
+ * InvocationContext is a class that represents a context for invoking commands.
+ * It implements several interfaces for different types of interactions.
+ * This class is used to construct chains of invocations, representing expressions of interaction that have not yet been executed.
+ * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/foundations/invocation-context)
+ * @class
+ */
+export class InvocationContext {
+    constructor(runtimeName: any, connectionData: any, command: any, isExecuted?: boolean);
+    get_current_command(): any;
+    /**
+     * Executes the current command.
+     * Because invocation context is building the intent of executing particular expression on target environment, we call the initial state of invocation context as non-materialized.
+     * The non-materialized context wraps either single command or chain of recursively nested commands.
+     * 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.
+     * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/foundations/execute-method)
+     * @method
+     */
+    execute(): InvocationContext;
+    /**
+     * Invokes a static method on the target runtime.
+     * @param {string} methodName - The name of the method to invoke.
+     * @param {...any} args - Method arguments.
+     * @returns {InvocationContext} A new InvocationContext instance that wraps the command to invoke the static method.
+     * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/calling-methods/invoking-static-method)
+     * @method
+     */
+    invokeStaticMethod(methodName: string, ...args: any[]): InvocationContext;
+    /**
+     * Retrieves the value of a static 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 static field.
+     * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/fields-and-properties/getting-and-setting-values-for-static-fields-and-properties)
+     * @method
+     */
+    getStaticField(fieldName: string): InvocationContext;
+    /**
+     * Sets the value of a static field in the target runtime.
+     * @param {string} fieldName - The name of the field to set.
+     * @param {any} value - The new value of the field.
+     * @returns {InvocationContext} A new InvocationContext instance that wraps the command to set the static field.
+     * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/fields-and-properties/getting-and-setting-values-for-static-fields-and-properties)
+     * @method
+     */
+    setStaticField(fieldName: string, value: any): InvocationContext;
+    /**
+     * Creates a new instance of a class in the target runtime.
+     * @param {...any} args - The arguments to pass to the class constructor
+     * @returns {InvocationContext} A new InvocationContext instance that wraps the command to create the instance.
+     * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/calling-methods/creating-instance-and-calling-instance-methods)
+     * @method
+     */
+    createInstance(...args: any[]): InvocationContext;
+    /**
+     * Retrieves the value of an instance 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 instance field.
+     * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/fields-and-properties/getting-and-setting-values-for-instance-fields-and-properties)
+     * @method
+     */
+    getInstanceField(fieldName: string): InvocationContext;
+    /**
+     * Sets the value of an instance field in the target runtime.
+     * @param {string} fieldName - The name of the field to set.
+     * @param {any} value - The new value of the field.
+     * @returns {InvocationContext} A new InvocationContext instance that wraps the command to set the instance field.
+     * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/fields-and-properties/getting-and-setting-values-for-instance-fields-and-properties)
+     * @method
+     */
+    setInstanceField(fieldName: string, value: any): InvocationContext;
+    /**
+     * Invokes an instance method on the target runtime.
+     * @param {string} methodName - The name of the method to invoke.
+     * @param {...any} args - Method arguments.
+     * @returns {InvocationContext} A new InvocationContext instance that wraps the command to invoke the instance method.
+     * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/calling-methods/invoking-instance-method)
+     * @method
+     */
+    invokeInstanceMethod(methodName: string, ...args: any[]): InvocationContext;
+    /**
+     * Retrieves the value at a specific index in an array from the target runtime.
+     * @param {...any} indexes - the arguments to pass to the array getter. The first argument should be the index.
+     * @returns {InvocationContext} A new InvocationContext instance that wraps the command to get the index.
+     * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/arrays-and-collections/one-dimensional-arrays)
+     * @method
+     */
+    getIndex(...indexes: any[]): InvocationContext;
+    /**
+     * Sets the value at a specific index in an array in the target runtime.
+     * @param {number[]} indexes - The index to set the value at.
+     * @param {any} value - The value to set at the index.
+     * @returns {InvocationContext} A new InvocationContext instance that wraps the command to set the index.
+     * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/arrays-and-collections/one-dimensional-arrays)
+     * @method
+     */
+    setIndex(indexes: number[], value: any): InvocationContext;
+    /**
+     * Retrieves the size of an array from the target runtime.
+     * @returns {InvocationContext} A new InvocationContext instance that wraps the command to get the size.
+     * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/arrays-and-collections/one-dimensional-arrays)
+     * @method
+     */
+    getSize(): InvocationContext;
+    /**
+     * Retrieves the rank of an array from the target runtime.
+     * @returns {InvocationContext} A new InvocationContext instance that wraps the command to get the rank.
+     * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/arrays-and-collections/one-dimensional-arrays)
+     * @method
+     */
+    getRank(): InvocationContext;
+    /**
+     * Invokes a generic static method on the target runtime.
+     * @param {string} methodName - The name of the method to invoke.
+     * @param {...any} args - Method arguments.
+     * @returns {InvocationContext} A new InvocationContext instance that wraps the command to invoke the generic static method.
+     * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/generics/calling-generic-static-method)
+     * @method
+     */
+    invokeGenericStaticMethod(methodName: string, ...args: any[]): InvocationContext;
+    /**
+     * Invokes a generic method on the target runtime.
+     * @param {string} methodName - The name of the method to invoke.
+     * @param {...any} args - Method arguments.
+     * @returns {InvocationContext} A new InvocationContext instance that wraps the command to invoke the generic method.
+     * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/generics/calling-generic-instance-method)
+     * @method
+     */
+    invokeGenericMethod(methodName: string, ...args: any[]): InvocationContext;
+    /**
+     * Retrieves the name of an enum from the target runtime.
+     * @returns {InvocationContext} A new InvocationContext instance that wraps the command to get the enum name.
+     * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/enums/using-enum-type)
+     * @method
+     */
+    getEnumName(): InvocationContext;
+    /**
+     * Retrieves the value of an enum from the target runtime.
+     * @returns {InvocationContext} A new InvocationContext instance that wraps the command to get the enum value.
+     * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/enums/using-enum-type)
+     * @method
+     */
+    getEnumValue(): InvocationContext;
+    /**
+     * Retrieves the value of a reference from the target runtime.
+     * @returns {InvocationContext} A new InvocationContext instance that wraps the command to get the ref value.
+     * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/methods-arguments/passing-arguments-by-reference-with-ref-keyword)
+     * @method
+     */
+    getRefValue(): InvocationContext;
+    /**
+     * Creates a null object of a specific type on the target runtime.
+     *
+     * @returns {InvocationContext} An InvocationContext instance with the command to create a null object.
+     * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/null-handling/create-null-object)
+     * @method
+     */
+    createNull(): InvocationContext;
+    /**
+     * Creates a null object of a specific type on the target runtime.
+     * @param {string} methodName - The name of the method to invoke.
+     * @param {...any} args - Method arguments.
+     * @returns {InvocationContext} An InvocationContext instance with the command to create a null object.
+     * TODO: connect documentation page url
+     * @see [Javonet Guides](https://www.javonet.com/guides/)
+     * @method
+     */
+    getStaticMethodAsDelegate(methodName: string, ...args: any[]): InvocationContext;
+    /**
+     * Creates a null object of a specific type on the target runtime.
+     * @param {string} methodName - The name of the method to invoke.
+     * @param {...any} args - Method arguments.
+     * @returns {InvocationContext} An InvocationContext instance with the command to create a null object.
+     * TODO: connect documentation page url
+     * @see [Javonet Guides](https://www.javonet.com/guides/)
+     * @method
+     */
+    getInstanceMethodAsDelegate(methodName: string, ...args: any[]): 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)
+     * @method
+     */
+    retrieveArray(): InvocationContext;
+    /**
+     * 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.
+     * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/foundations/execute-method)
+     * @method
+     */
+    getValue(): Command;
+    [Symbol.iterator]: () => {
+        next: () => {
+            value: any;
+            done: boolean;
+        };
+    };
+    #private;
+}
+export class InvocationWsContext extends InvocationContext {
+    #private;
+}
+import { Command } from '../utils/Command.js';

data/lib/javonet-ruby-sdk/Binaries/Nodejs/{lib/sdk/Javonet.js → dist/types/sdk/Javonet.d.ts}

@@ -1,105 +1,63 @@
-const { RuntimeFactory, InMemoryConnectionData, WsConnectionData } = require('../..')
-
-const Transmitter = require('../core/transmitter/Transmitter')
-const ConfigRuntimeFactory = require('./ConfigRuntimeFactory')
-const RuntimeLogger = require('../utils/RuntimeLogger')
-const TcpConnectionData = require('../utils/connectionData/TcpConnectionData')
-const { mkdirSync } = require('node:fs')
-
 /**
  * The Javonet class is a singleton class that serves as the entry point for interacting with Javonet.
  * It provides methods to activate and initialize the Javonet SDK.
  * It supports both in-memory and TCP connections.
  * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/foundations/javonet-static-class)
  */
-class Javonet {
-    // Static block to initialize the Transmitter
-    static {
-        //SDKExceptionHelper.sendExceptionToAppInsights("SdkMessage", "Javonet SDK initialized");
-    }
-
+export class Javonet {
     /**
      * Initializes Javonet using an in-memory channel on the same machine.
      * @returns {RuntimeFactory} A RuntimeFactory instance configured for an in-memory connection.
      * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/foundations/in-memory-channel)
      */
-    static inMemory() {
-        return new RuntimeFactory(new InMemoryConnectionData())
-    }
-
+    static inMemory(): RuntimeFactory;
     /**
      * Initializes Javonet with a TCP connection to a remote machine.
      * @param {TcpConnectionData} tcpConnectionData - The tcp connection data of the remote machine.
      * @returns {RuntimeFactory} A RuntimeFactory instance configured for a TCP connection.
      * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/foundations/tcp-channel)
      */
-    static tcp(tcpConnectionData) {
-        return new RuntimeFactory(tcpConnectionData)
-    }
-
+    static tcp(tcpConnectionData: TcpConnectionData): RuntimeFactory;
     /**
      * Initializes Javonet with a WebSocket connection to a remote machine.
      * @param {WsConnectionData} wsConnectionData - The WebSocket connection data of the remote machine.
      * @returns {RuntimeFactory} A RuntimeFactory instance configured for a WebSocket connection.
      * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/foundations/websocket-channel)
      */
-    static webSocket(wsConnectionData) {
-        return new RuntimeFactory(wsConnectionData)
-    }
-
+    static webSocket(wsConnectionData: WsConnectionData): RuntimeFactory;
     /**
      * Initializes Javonet with a custom configuration file taken from external source.
      * Currentyl supported: Configuration file in JSON format
-     * @param {string} configPath - Path to a configuration file.
+     * @param config - Path to a configuration file.
      * @returns {ConfigRuntimeFactory} A ConfigRuntimeFactory instance with configuration data.
      * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/foundations/configure-channel)
      */
-    static withConfig(configPath) {
-        return new ConfigRuntimeFactory(configPath)
-    }
-
+    static withConfig(config: any): ConfigRuntimeFactory;
     /**
      * Activates Javonet with the provided license key.
      * @param {string} licenseKey - The license key to activate Javonet.
      * @returns {number} The activation status code.
      * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/getting-started/activating-javonet)
      */
-    static activate(licenseKey) {
-        return Transmitter.activate(licenseKey)
-    }
-
-    static getRuntimeInfo() {
-        return RuntimeLogger.getRuntimeInfo()
-    }
-
+    static activate(licenseKey: string): number;
+    static getRuntimeInfo(): string;
     /**
      * Sets the configuration source for the Javonet SDK.
      *
      * @param {string} configSource - The configuration source.
      */
-    static setConfigSource(configSource) {
-        Transmitter.setConfigSource(configSource)
-    }
-
+    static setConfigSource(configSource: string): any;
     /**
      * Sets the working directory for the Javonet SDK.
      *
      * @param {string} path - The working directory.
      */
-    static setJavonetWorkingDirectory(path) {
-        path = path.replace(/\\/g, "/");
-        if (!path.endsWith("/")) {
-            path += "/";
-        }
-
-        mkdirSync(path, { recursive: true, mode: 0o700 });
-        Transmitter.setJavonetWorkingDirectory(path)
-    }
-
-}
-
-module.exports = {
-    Javonet,
-    TcpConnectionData,
-    WsConnectionData,
+    static setJavonetWorkingDirectory(path: string): void;
 }
+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 { RuntimeFactory } from './RuntimeFactory.js';
+import { ConfigRuntimeFactory } from './ConfigRuntimeFactory.js';
+export { TcpConnectionData, WsConnectionData, CommandSerializer, CommandDeserializer };

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

@@ -0,0 +1,103 @@
+/**
+ * Represents a single context which allows interaction with a selected technology.
+ * Refers to a single instance of the called runtime within a particular target OS process.
+ * This can be either the local currently running process (inMemory) or a particular remote process identified by the IP Address and PORT of the target Javonet instance.
+ * Multiple Runtime Contexts can be initialized within one process.
+ * Calling the same technology on inMemory communication channel will return the existing instance of runtime context.
+ * Calling the same technology on TCP channel but on different nodes will result in unique Runtime Contexts.
+ * Within the runtime context, any number of libraries can be loaded and any objects from the target technology can be interacted with, as they are aware of each other due to sharing the same memory space and same runtime instance.
+ * @see [Javonet Guides]{@link https://www.javonet.com/guides/v2/javascript/foundations/runtime-context}
+ * @class
+ */
+export class RuntimeContext {
+    static memoryRuntimeContexts: Map<any, any>;
+    static networkRuntimeContexts: Map<any, any>;
+    static webSocketRuntimeContexts: Map<any, any>;
+    static getInstance(runtimeName: any, connectionData: any): any;
+    constructor(runtimeName: any, connectionData: any);
+    runtimeName: any;
+    connectionData: any;
+    /**
+     * Executes the current command. The initial state of RuntimeContext is non-materialized,
+     * wrapping either a single command or a chain of recursively nested commands.
+     * Commands become nested through each invocation of methods on RuntimeContext.
+     * Each invocation triggers the creation of a new RuntimeContext instance wrapping the current command with a new parent command.
+     * The developer can decide at any moment of the materialization for the context, taking full control of the chunks of the expression being transferred and processed on the target runtime.
+     * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/foundations/execute-method)
+     * @method
+     */
+    execute(): void;
+    /**
+     * Adds a reference to a library. Javonet allows you to reference and use modules or packages written in various languages.
+     * This method allows you to use any library from all supported technologies. The necessary libraries need to be referenced.
+     * The argument is a relative or full path to the library. If the library has dependencies on other libraries, the latter needs to be added first.
+     * After referencing the library, any objects stored in this package can be used. Use static classes, create instances, call methods, use fields and properties, and much more.
+     * @param {string} libraryPath - The relative or full path to the library.
+     * @returns {RuntimeContext} RuntimeContext instance.
+     * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/getting-started/adding-references-to-libraries)
+     * @method
+     */
+    loadLibrary(libraryPath: string): RuntimeContext;
+    /**
+     * Retrieves a reference to a specific type. The type can be a class, interface or enum. The type can be retrieved from any referenced library.
+     * @param {string} typeName - The full name of the type.
+     * @param {...any} args - The arguments to be passed, if needed
+     * @returns {InvocationContext} InvocationContext instance, that wraps the command to get the type.
+     * @method
+     */
+    getType(typeName: string, ...args: any[]): InvocationContext;
+    /**
+     * Casts the provided value to a specific type. This method is used when invoking methods that require specific types of arguments.
+     * The arguments include the target type and the value to be cast. The target type must be retrieved from the called runtime using the getType method.
+     * After casting the value, it can be used as an argument when invoking methods.
+     * @param {...any} args - The target type and the value to be cast.
+     * @returns {InvocationContext} InvocationContext instance that wraps the command to cast the value.
+     * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/casting/casting)
+     * @method
+     */
+    cast(...args: any[]): InvocationContext;
+    /**
+     * Retrieves a specific item from an enum type. This method is used when working with enums from the called runtime.
+     * The arguments include the enum type and the name of the item. The enum type must be retrieved from the called runtime using the getType method.
+     * After retrieving the item, it can be used as an argument when invoking methods or for other operations.
+     * @param {...any} args - The enum type and the name of the item.
+     * @returns {InvocationContext} InvocationContext instance that wraps the command to get the enum item.
+     * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/enums/using-enum-type)
+     * @method
+     */
+    getEnumItem(...args: any[]): InvocationContext;
+    /**
+     * Creates a reference type argument that can be passed to a method with a ref parameter modifier. This method is used when working with methods from the called runtime that require arguments to be passed by reference.
+     * The arguments include the value and optionally the type of the reference. The type must be retrieved from the called runtime using the getType method.
+     * After creating the reference, it can be used as an argument when invoking methods.
+     * @param {...any} args - The value and optionally the type of the reference.
+     * @returns {InvocationContext} InvocationContext instance that wraps the command to create a reference as ref.
+     * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/methods-arguments/passing-arguments-by-reference-with-ref-keyword)
+     * @method
+     */
+    asRef(...args: any[]): InvocationContext;
+    /**
+     * Creates a reference type argument that can be passed to a method with an out parameter modifier. This method is used when working with methods from the called runtime that require arguments to be passed by reference.
+     * The arguments include the value and optionally the type of the reference. The type must be retrieved from the called runtime using the getType method.
+     * After creating the reference, it can be used as an argument when invoking methods.
+     * @param {...any} args - The value and optionally the type of the reference.
+     * @returns {InvocationContext} InvocationContext instance that wraps the command to create a reference as out.
+     * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/methods-arguments/passing-arguments-by-reference-with-out-keyword |Passing Arguments by Reference with out Keyword Guide)
+     * @method
+     */
+    asOut(...args: any[]): InvocationContext;
+    /**
+     * 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.
+     * After invoking the function, the result can be used for further operations.
+     * @param {string} functionName - The name of the function to invoke.
+     * @param {...any} args - The arguments to be passed to the function.
+     * @returns {InvocationContext} InvocationContext instance that wraps the command to invoke the function.
+     * @see [Invoking Functions Guide](https://www.javonet.com/guides/v2/csharp/functions/invoking-functions)
+     * @method
+     */
+    invokeGlobalFunction(functionName: string, ...args: any[]): InvocationContext;
+    healthCheck(): void;
+    #private;
+}
+import { InvocationContext } from './InvocationContext.js';

data/lib/javonet-ruby-sdk/Binaries/Nodejs/{lib/sdk/RuntimeFactory.js → dist/types/sdk/RuntimeFactory.d.ts}

@@ -1,87 +1,58 @@
-const Runtime = require('../utils/RuntimeName')
-const RuntimeContext = require('./RuntimeContext')
-
 /**
  * The RuntimeFactory class provides methods for creating runtime contexts.
  * Each method corresponds to a specific runtime (CLR, JVM, .NET Core, Perl, Ruby, Node.js, Python) and returns a RuntimeContext instance for that runtime.
  * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/foundations/runtime-context)
  */
-class RuntimeFactory {
-    constructor(connectionData) {
-        this.connectionData = connectionData
-    }
-
+export class RuntimeFactory {
+    constructor(connectionData: any);
+    connectionData: any;
     /**
      * Creates RuntimeContext instance to interact with the .NET Framework runtime.
      * @return {RuntimeContext} a RuntimeContext instance for the .NET Framework runtime
      * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/foundations/runtime-context)
      */
-    clr() {
-        return RuntimeContext.getInstance(Runtime.Clr, this.connectionData)
-    }
-
+    clr(): RuntimeContext;
     /**
      * Creates RuntimeContext instance to interact with the JVM runtime.
      * @return {RuntimeContext} a RuntimeContext instance for the JVM runtime
      * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/foundations/runtime-context)
      */
-    jvm() {
-        return RuntimeContext.getInstance(Runtime.Jvm, this.connectionData)
-    }
-
+    jvm(): RuntimeContext;
     /**
      * Creates RuntimeContext instance to interact with the .NET runtime.
      * @return {RuntimeContext} a RuntimeContext instance for the .NET runtime
      * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/foundations/runtime-context)
      */
-    netcore() {
-        return RuntimeContext.getInstance(Runtime.Netcore, this.connectionData)
-    }
-
+    netcore(): RuntimeContext;
     /**
      * Creates RuntimeContext instance to interact with the Perl runtime.
      * @return {RuntimeContext} a RuntimeContext instance for the Perl runtime
      * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/foundations/runtime-context)
      */
-    perl() {
-        return RuntimeContext.getInstance(Runtime.Perl, this.connectionData)
-    }
-
+    perl(): RuntimeContext;
     /**
      * Creates RuntimeContext instance to interact with the Python runtime.
      * @return {RuntimeContext} a RuntimeContext instance for the Python runtime
      * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/foundations/runtime-context)
      */
-    python() {
-        return RuntimeContext.getInstance(Runtime.Python, this.connectionData)
-    }
-
+    python(): RuntimeContext;
     /**
      * Creates RuntimeContext instance to interact with the Ruby runtime.
      * @return {RuntimeContext} a RuntimeContext instance for the Ruby runtime
      * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/foundations/runtime-context)
      */
-    ruby() {
-        return RuntimeContext.getInstance(Runtime.Ruby, this.connectionData)
-    }
-
+    ruby(): RuntimeContext;
     /**
      * Creates RuntimeContext instance to interact with Node.js runtime.
      * @return {RuntimeContext} a RuntimeContext instance for the Node.js runtime
      * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/foundations/runtime-context)
      */
-    nodejs() {
-        return RuntimeContext.getInstance(Runtime.Nodejs, this.connectionData)
-    }
-
+    nodejs(): RuntimeContext;
     /**
      * Creates RuntimeContext instance to interact with the Python runtime.
      * @return {RuntimeContext} a RuntimeContext instance for the Python runtime
      * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/foundations/runtime-context)
      */
-    python27() {
-        return RuntimeContext.getInstance(Runtime.Python27, this.connectionData)
-    }
+    python27(): RuntimeContext;
 }
-
-module.exports = RuntimeFactory
+import { RuntimeContext } from './RuntimeContext.js';

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/types/sdk/tools/browser/ConfigSourceResolver.d.ts

@@ -0,0 +1,46 @@
+export class ConfigSourceResolver {
+    /**
+     *
+     * @param {object | string} configSource
+     */
+    constructor(configSource: object | string);
+    jsonObject: any;
+    getLicenseKey(): any;
+    getRuntimes(): any;
+    /**
+     * @param {string} runtimeName
+     * @param {string} configName
+     * @returns {any}
+     */
+    getRuntime(runtimeName: string, configName: string): any;
+    /**
+     * @param {string} runtimeName
+     * @param {string} configName
+     * @returns {any}
+     */
+    getChannel(runtimeName: string, configName: string): any;
+    /**
+     * @param {string} runtimeName
+     * @param {string} configName
+     * @returns {any}
+     */
+    getChannelType(runtimeName: string, configName: string): any;
+    /**
+     * @param {string} runtimeName
+     * @param {string} configName
+     * @returns {any}
+     */
+    getChannelHost(runtimeName: string, configName: string): any;
+    /**
+     * @param {string} runtimeName
+     * @param {string} configName
+     * @returns {any}
+     */
+    getChannelPort(runtimeName: string, configName: string): any;
+    /**
+     * @param {string} runtimeName
+     * @param {string} configName
+     * @returns {any}
+     */
+    getModules(runtimeName: string, configName: string): any;
+}

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/types/sdk/tools/browser/SdkExceptionHelper.d.ts

@@ -0,0 +1,7 @@
+/**
+ *
+ * @param {any} e
+ * @param {string} licenseKey
+ * @returns {Promise<any>}
+ */
+export function sendExceptionToAppInsights(e: any, licenseKey: string): Promise<any>;

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/types/sdk/tools/nodejs/JsonFileResolver.d.ts

@@ -0,0 +1,13 @@
+export class JsonFileResolver {
+    constructor(path: any);
+    path: any;
+    jsonObject: any;
+    getLicenseKey(): any;
+    getRuntimes(): any;
+    getRuntime(runtimeName: any, configName: any): any;
+    getChannel(runtimeName: any, configName: any): any;
+    getChannelType(runtimeName: any, configName: any): any;
+    getChannelHost(runtimeName: any, configName: any): any;
+    getChannelPort(runtimeName: any, configName: any): any;
+    getModules(runtimeName: any, configName: any): any;
+}

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/types/sdk/tools/nodejs/SdkExceptionHelper.d.ts

@@ -0,0 +1,6 @@
+/**
+ *
+ * @param {any} e
+ * @param {string} licenseKey
+ */
+export function sendExceptionToAppInsights(e: any, licenseKey: string): Promise<any>;

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

@@ -0,0 +1,42 @@
+export class Command {
+    /**
+     * @param {any} [response]
+     * @param {number} runtimeName
+     */
+    static createResponse(response?: any, runtimeName: number): Command;
+    /**
+     * @param {any} [response]
+     * @param {number} runtimeName
+     * @method
+     */
+    static createReference(response?: any, runtimeName: number): Command;
+    /**
+     * @param {any} [response]
+     * @param {number} runtimeName
+     * @returns {Command}
+     * @method
+     */
+    static createArrayResponse(response?: any, runtimeName: number): Command;
+    /**
+     * Constructs a new Command instance.
+     * @param {number} runtimeName - The runtime name associated with the command.
+     * @param {number} commandType - The type of the command.
+     * @param {any} [payload] - The optional payload of the command.
+     * @method
+     */
+    constructor(runtimeName: number, commandType: number, payload?: any);
+    runtimeName: number;
+    commandType: number;
+    payload: any;
+    dropFirstPayloadArg(): Command;
+    /**
+     * @param {any} arg
+     * @returns {Command}
+     */
+    addArgToPayload(arg: any): Command;
+    /**
+     * @param {Command|null} current_command
+     * @returns {Command}
+     */
+    prependArgToPayload(current_command: Command | null): Command;
+}