javonet-ruby-sdk 2.5.15 → 2.5.17

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

@@ -0,0 +1,150 @@
+"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 Javonet_exports = {};
+__export(Javonet_exports, {
+  CommandDeserializer: () => import_CommandDeserializer.CommandDeserializer,
+  CommandSerializer: () => import_CommandSerializer.CommandSerializer,
+  Javonet: () => Javonet,
+  TcpConnectionData: () => import_TcpConnectionData.TcpConnectionData,
+  WsConnectionData: () => import_WsConnectionData.WsConnectionData
+});
+module.exports = __toCommonJS(Javonet_exports);
+var import_ConfigRuntimeFactory = require("./ConfigRuntimeFactory.cjs");
+var import_RuntimeFactory = require("./RuntimeFactory.cjs");
+var import_InMemoryConnectionData = require("../utils/connectionData/InMemoryConnectionData.cjs");
+var import_Runtime = require("../utils/Runtime.cjs");
+var import_CommandSerializer = require("../core/protocol/CommandSerializer.cjs");
+var import_CommandDeserializer = require("../core/protocol/CommandDeserializer.cjs");
+var import_RuntimeLogger = require("../utils/RuntimeLogger.cjs");
+var import_TcpConnectionData = require("../utils/nodejs/connectionData/TcpConnectionData.cjs");
+var import_WsConnectionData = require("../utils/connectionData/WsConnectionData.cjs");
+const import_meta = {};
+const requireDynamic = (0, import_Runtime.getRequire)(import_meta.url);
+let _Transmitter = null;
+if ((0, import_Runtime.isNodejsRuntime)()) {
+  try {
+    const { Transmitter } = require("../core/transmitter/Transmitter.cjs");
+    _Transmitter = Transmitter;
+  } catch (error) {
+    throw error;
+  }
+}
+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 import_RuntimeFactory.RuntimeFactory(new import_InMemoryConnectionData.InMemoryConnectionData());
+  }
+  /**
+   * 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 import_RuntimeFactory.RuntimeFactory(tcpConnectionData);
+  }
+  /**
+   * 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 import_RuntimeFactory.RuntimeFactory(wsConnectionData);
+  }
+  /**
+   * Initializes Javonet with a custom configuration file taken from external source.
+   * Currentyl supported: Configuration file in JSON format
+   * @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(config) {
+    return new import_ConfigRuntimeFactory.ConfigRuntimeFactory(config, _Transmitter);
+  }
+  /**
+   * 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) {
+    if ((0, import_Runtime.isNodejsRuntime)()) {
+      return _Transmitter?.activate(licenseKey);
+    } else {
+      throw new Error("Javonet.activate is allowed only to run in nodejs runtime");
+    }
+  }
+  static getRuntimeInfo() {
+    if ((0, import_Runtime.isNodejsRuntime)()) {
+      return import_RuntimeLogger.RuntimeLogger.getRuntimeInfo();
+    } else {
+      throw new Error("Javonet.getRuntimeInfo is allowed only to run in nodejs runtime");
+    }
+  }
+  /**
+   * Sets the configuration source for the Javonet SDK.
+   *
+   * @param {string} configSource - The configuration source.
+   */
+  static setConfigSource(configSource) {
+    if ((0, import_Runtime.isNodejsRuntime)()) {
+      return _Transmitter?.setConfigSource(configSource);
+    } else {
+      throw new Error("Javonet.setConfigSource is allowed only to run in nodejs runtime");
+    }
+  }
+  /**
+   * Sets the working directory for the Javonet SDK.
+   *
+   * @param {string} path - The working directory.
+   */
+  static setJavonetWorkingDirectory(path) {
+    try {
+      if ((0, import_Runtime.isNodejsRuntime)()) {
+        const { mkdirSync } = requireDynamic("fs");
+        path = path.replace(/\\/g, "/");
+        if (!path.endsWith("/")) {
+          path += "/";
+        }
+        mkdirSync(path, { recursive: true, mode: 448 });
+        _Transmitter?.setJavonetWorkingDirectory(path);
+      } else {
+        throw new Error("Javonet.setJavonetWorkingDirectory is allowed only to run in nodejs runtime");
+      }
+    } catch (error) {
+      if (error.code === "MODULE_NOT_FOUND") {
+        throw new Error("fs module not found. Please install it using npm install fs");
+      }
+      throw error;
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CommandDeserializer,
+  CommandSerializer,
+  Javonet,
+  TcpConnectionData,
+  WsConnectionData
+});

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

@@ -0,0 +1,288 @@
+"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 RuntimeContext_exports = {};
+__export(RuntimeContext_exports, {
+  RuntimeContext: () => RuntimeContext
+});
+module.exports = __toCommonJS(RuntimeContext_exports);
+var import_Command = require("../utils/Command.cjs");
+var import_CommandType = require("../utils/CommandType.cjs");
+var import_InvocationContext = require("./InvocationContext.cjs");
+var import_ConnectionType = require("../utils/ConnectionType.cjs");
+var import_ExceptionThrower = require("../utils/exception/ExceptionThrower.cjs");
+var import_RuntimeName = require("../utils/RuntimeName.cjs");
+var import_Interpreter = require("../core/interpreter/Interpreter.cjs");
+var import_DelegatesCache = require("../core/delegatesCache/DelegatesCache.cjs");
+class RuntimeContext {
+  static memoryRuntimeContexts = /* @__PURE__ */ new Map();
+  static networkRuntimeContexts = /* @__PURE__ */ new Map();
+  static webSocketRuntimeContexts = /* @__PURE__ */ new Map();
+  #currentCommand;
+  #responseCommand;
+  #interpreter;
+  constructor(runtimeName, connectionData) {
+    this.runtimeName = runtimeName;
+    this.connectionData = connectionData;
+    this.#currentCommand = null;
+    this.#responseCommand = null;
+    this.#interpreter = new import_Interpreter.Interpreter();
+  }
+  static getInstance(runtimeName, connectionData) {
+    switch (connectionData.connectionType) {
+      case import_ConnectionType.ConnectionType.IN_MEMORY:
+        if (runtimeName in RuntimeContext.memoryRuntimeContexts) {
+          let runtimeCtx = RuntimeContext.memoryRuntimeContexts[runtimeName];
+          runtimeCtx.currentCommand = null;
+          return runtimeCtx;
+        } else {
+          let runtimeCtx = new RuntimeContext(runtimeName, connectionData);
+          RuntimeContext.memoryRuntimeContexts[runtimeName] = runtimeCtx;
+          return runtimeCtx;
+        }
+      case import_ConnectionType.ConnectionType.TCP: {
+        let key1 = runtimeName + JSON.stringify(connectionData);
+        if (key1 in RuntimeContext.networkRuntimeContexts) {
+          let runtimeCtx = RuntimeContext.networkRuntimeContexts[key1];
+          runtimeCtx.currentCommand = null;
+          return runtimeCtx;
+        } else {
+          let runtimeCtx = new RuntimeContext(runtimeName, connectionData);
+          RuntimeContext.networkRuntimeContexts[key1] = runtimeCtx;
+          return runtimeCtx;
+        }
+      }
+      case import_ConnectionType.ConnectionType.WEB_SOCKET: {
+        let key2 = runtimeName + JSON.stringify(connectionData);
+        if (key2 in RuntimeContext.webSocketRuntimeContexts) {
+          let runtimeCtx = RuntimeContext.webSocketRuntimeContexts[key2];
+          runtimeCtx.currentCommand = null;
+          return runtimeCtx;
+        } else {
+          let runtimeCtx = new RuntimeContext(runtimeName, connectionData);
+          RuntimeContext.webSocketRuntimeContexts[key2] = runtimeCtx;
+          return runtimeCtx;
+        }
+      }
+      default:
+        throw new Error("Invalid connection type");
+    }
+  }
+  /**
+   * 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() {
+    this.#responseCommand = this.#interpreter.execute(this.#currentCommand, this.connectionData);
+    this.#currentCommand = null;
+    if (this.#responseCommand === void 0) {
+      throw new Error("responseCommand is undefined in Runtime Context execute method");
+    }
+    if (this.#responseCommand.commandType === import_CommandType.CommandType.Exception) {
+      throw import_ExceptionThrower.ExceptionThrower.throwException(this.#responseCommand);
+    }
+  }
+  /**
+   * 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) {
+    let localCommand = new import_Command.Command(this.runtimeName, import_CommandType.CommandType.LoadLibrary, [libraryPath]);
+    this.#currentCommand = this.#buildCommand(localCommand);
+    this.execute();
+    return this;
+  }
+  /**
+   * 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, ...args) {
+    let localCommand = new import_Command.Command(this.runtimeName, import_CommandType.CommandType.GetType, [typeName, ...args]);
+    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));
+  }
+  /**
+   * 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) {
+    let localCommand = new import_Command.Command(this.runtimeName, import_CommandType.CommandType.Cast, args);
+    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));
+  }
+  /**
+   * 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) {
+    let localCommand = new import_Command.Command(this.runtimeName, import_CommandType.CommandType.GetEnumItem, args);
+    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));
+  }
+  /**
+   * 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) {
+    let localCommand = new import_Command.Command(this.runtimeName, import_CommandType.CommandType.AsRef, args);
+    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));
+  }
+  /**
+   * 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) {
+    let localCommand = new import_Command.Command(this.runtimeName, import_CommandType.CommandType.AsOut, args);
+    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.
+   * 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, ...args) {
+    let localCommand = new import_Command.Command(this.runtimeName, import_CommandType.CommandType.InvokeGlobalFunction, [
+      functionName,
+      ...args
+    ]);
+    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));
+  }
+  #buildCommand = function(command) {
+    for (let i = 0; i < command.payload.length; i++) {
+      command.payload[i] = this.#encapsulatePayloadItem(command.payload[i]);
+    }
+    return command.prependArgToPayload(this.#currentCommand);
+  };
+  #encapsulatePayloadItem = function(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 import_InvocationContext.InvocationContext) {
+      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] = "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 {
+      return new import_Command.Command(this.runtimeName, import_CommandType.CommandType.Value, [payloadItem]);
+    }
+  };
+  healthCheck() {
+    let localCommand = new import_Command.Command(this.runtimeName, import_CommandType.CommandType.Value, ["health_check"]);
+    this.#currentCommand = this.#buildCommand(localCommand);
+    this.execute();
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RuntimeContext
+});

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

@@ -0,0 +1,98 @@
+"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 RuntimeFactory_exports = {};
+__export(RuntimeFactory_exports, {
+  RuntimeFactory: () => RuntimeFactory
+});
+module.exports = __toCommonJS(RuntimeFactory_exports);
+var import_RuntimeName = require("../utils/RuntimeName.cjs");
+var import_RuntimeContext = require("./RuntimeContext.cjs");
+class RuntimeFactory {
+  constructor(connectionData) {
+    this.connectionData = connectionData;
+  }
+  /**
+   * 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 import_RuntimeContext.RuntimeContext.getInstance(import_RuntimeName.RuntimeName.Clr, this.connectionData);
+  }
+  /**
+   * 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 import_RuntimeContext.RuntimeContext.getInstance(import_RuntimeName.RuntimeName.Jvm, this.connectionData);
+  }
+  /**
+   * 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 import_RuntimeContext.RuntimeContext.getInstance(import_RuntimeName.RuntimeName.Netcore, this.connectionData);
+  }
+  /**
+   * 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 import_RuntimeContext.RuntimeContext.getInstance(import_RuntimeName.RuntimeName.Perl, this.connectionData);
+  }
+  /**
+   * 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 import_RuntimeContext.RuntimeContext.getInstance(import_RuntimeName.RuntimeName.Python, this.connectionData);
+  }
+  /**
+   * 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 import_RuntimeContext.RuntimeContext.getInstance(import_RuntimeName.RuntimeName.Ruby, this.connectionData);
+  }
+  /**
+   * 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 import_RuntimeContext.RuntimeContext.getInstance(import_RuntimeName.RuntimeName.Nodejs, this.connectionData);
+  }
+  /**
+   * 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 import_RuntimeContext.RuntimeContext.getInstance(import_RuntimeName.RuntimeName.Python27, this.connectionData);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RuntimeFactory
+});