javonet-ruby-sdk 2.5.14 → 2.5.16

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 ws(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,78 +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(): 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;
+}

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

@@ -0,0 +1,44 @@
+export namespace CommandType {
+    let Value: 0;
+    let LoadLibrary: 1;
+    let InvokeStaticMethod: 2;
+    let GetStaticField: 3;
+    let SetStaticField: 4;
+    let CreateClassInstance: 5;
+    let GetType: 6;
+    let Reference: 7;
+    let GetModule: 8;
+    let InvokeInstanceMethod: 9;
+    let Exception: 10;
+    let HeartBeat: 11;
+    let Cast: 12;
+    let GetInstanceField: 13;
+    let Optimize: 14;
+    let GenerateLib: 15;
+    let InvokeGlobalFunction: 16;
+    let DestructReference: 17;
+    let ArrayReference: 18;
+    let ArrayGetItem: 19;
+    let ArrayGetSize: 20;
+    let ArrayGetRank: 21;
+    let ArraySetItem: 22;
+    let Array: 23;
+    let RetrieveArray: 24;
+    let SetInstanceField: 25;
+    let InvokeGenericStaticMethod: 26;
+    let InvokeGenericMethod: 27;
+    let GetEnumItem: 28;
+    let GetEnumName: 29;
+    let GetEnumValue: 30;
+    let AsRef: 31;
+    let AsOut: 32;
+    let GetRefValue: 33;
+    let EnableNamespace: 34;
+    let EnableType: 35;
+    let CreateNull: 36;
+    let GetStaticMethodAsDelegate: 37;
+    let GetInstanceMethodAsDelegate: 38;
+    let PassDelegate: 39;
+    let InvokeDelegate: 40;
+    let ConvertType: 41;
+}

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

@@ -0,0 +1,5 @@
+export namespace ConnectionType {
+    let IN_MEMORY: 0;
+    let TCP: 1;
+    let WEB_SOCKET: 2;
+}

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

@@ -0,0 +1,3 @@
+export class CustomError extends Error {
+    constructor(message: any, cause: any);
+}

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

@@ -0,0 +1,10 @@
+export namespace ExceptionType {
+    let EXCEPTION: 0;
+    let IO_EXCEPTION: 1;
+    let FILE_NOT_FOUND_EXCEPTION: 2;
+    let RUNTIME_EXCEPTION: 3;
+    let ARITHMETIC_EXCEPTION: 4;
+    let ILLEGAL_ARGUMENT_EXCEPTION: 5;
+    let INDEX_OUT_OF_BOUNDS_EXCEPTION: 6;
+    let NULL_POINTER_EXCEPTION: 7;
+}

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

@@ -0,0 +1,24 @@
+/**
+ * Validate if the runtime is Node.js
+ * @returns {boolean}
+ */
+export function isNodejsRuntime(): boolean;
+/**
+ * Validate if the runtime is Browser
+ * @returns {boolean}
+ */
+export function isBrowserRuntime(): boolean;
+/**
+ * Validate if the runtime is ESM
+ * @returns {boolean}
+ */
+export function isEsmRuntime(): boolean;
+/**
+ * Get the runtime extension
+ * @returns {string}
+ */
+export function getRuntimeExtension(): string;
+export function getRequire(callerPath: string): typeof createRequire;
+export function getDirname(): string;
+export function getDependency(dependencyName: string, callerPathOrUrl: string): string;
+import { createRequire } from 'module';

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

@@ -0,0 +1,5 @@
+export class RuntimeLogger {
+    static notLoggedYet: boolean;
+    static getRuntimeInfo(): string;
+    static printRuntimeInfo(): void;
+}

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

@@ -0,0 +1,15 @@
+export class RuntimeLoggerBrowser {
+    static notLoggedYet: boolean;
+    /**
+     * Gets runtime information in a browser environment.
+     * @method
+     * @returns {string}
+     */
+    static getRuntimeInfo(): string;
+    /**
+     * Prints runtime information to the console.
+     * @method
+     * @returns {void}
+     */
+    static printRuntimeInfo(): void;
+}

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

@@ -0,0 +1,13 @@
+export namespace RuntimeName {
+    let Clr: 0;
+    let Go: 1;
+    let Jvm: 2;
+    let Netcore: 3;
+    let Perl: 4;
+    let Python: 5;
+    let Ruby: 6;
+    let Nodejs: 7;
+    let Cpp: 8;
+    let Php: 9;
+    let Python27: 10;
+}

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

@@ -0,0 +1,7 @@
+export class RuntimeNameHandler {
+    /**
+     * @param {number} runtimeName
+     * @returns {string}
+     */
+    static getName(runtimeName: number): string;
+}

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

@@ -0,0 +1,6 @@
+export namespace StringEncodingMode {
+    let ASCII: 0;
+    let UTF8: 1;
+    let UTF16: 2;
+    let UTF32: 3;
+}

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

@@ -0,0 +1,14 @@
+export namespace Type {
+    let JAVONET_COMMAND: 0;
+    let JAVONET_STRING: 1;
+    let JAVONET_INTEGER: 2;
+    let JAVONET_BOOLEAN: 3;
+    let JAVONET_FLOAT: 4;
+    let JAVONET_BYTE: 5;
+    let JAVONET_CHAR: 6;
+    let JAVONET_LONG_LONG: 7;
+    let JAVONET_DOUBLE: 8;
+    let JAVONET_UNSIGNED_LONG_LONG: 9;
+    let JAVONET_UNSIGNED_INTEGER: 10;
+    let JAVONET_NULL: 11;
+}

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

@@ -0,0 +1,5 @@
+export class IConnectionData {
+    get connectionType(): void;
+    get hostname(): void;
+    serializeConnectionData(): void;
+}

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

@@ -0,0 +1,16 @@
+/**
+ * @extends IConnectionData
+ */
+export class InMemoryConnectionData extends IConnectionData {
+    _connectionType: 0;
+    _hostname: string;
+    get connectionType(): 0;
+    get hostname(): string;
+    serializeConnectionData(): number[];
+    /**
+     * @param {InMemoryConnectionData} other
+     * @returns {boolean}
+     */
+    equals(other: InMemoryConnectionData): boolean;
+}
+import { IConnectionData } from './IConnectionData.js';

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

@@ -0,0 +1,31 @@
+/**
+ * Represents WebSocket connection data.
+ * @extends IConnectionData
+ */
+export class WsConnectionData extends IConnectionData {
+    /**
+     * @param {string} hostname - The hostname of the connection.
+     */
+    constructor(hostname: string);
+    /** @private @type {string} */
+    private _hostname;
+    /** @private @type {ConnectionType} */
+    private _connectionType;
+    /** @type {ConnectionType} */
+    get connectionType(): {
+        readonly IN_MEMORY: 0;
+        readonly TCP: 1;
+        readonly WEB_SOCKET: 2;
+    };
+    /** @type {string} */
+    set hostname(value: string);
+    /** @type {string} */
+    get hostname(): string;
+    /**
+     * Serializes the connection data.
+     * @returns {number[]} An array of connection data values.
+     */
+    serializeConnectionData(): number[];
+    equals(other: any): boolean;
+}
+import { IConnectionData } from './IConnectionData.js';