javonet-ruby-sdk 2.5.16 → 2.5.18

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

@@ -1,4 +1,12 @@
+export type Command = import("../../utils/Command.js").Command;
+/**
+ * @typedef {import('../../utils/Command.js').Command} Command
+ */
 export class ValueHandler extends AbstractHandler {
-    process(command: any): any;
+    /**
+     * @param {Command} command
+     * @returns {unknown}
+     */
+    process(command: Command): unknown;
 }
 import { AbstractHandler } from './AbstractHandler.js';

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

@@ -1,5 +1,6 @@
 export class Interpreter {
-    handler: any;
+    /** @type {Handler | null} */
+    handler: Handler | null;
     /**
      *
      * @param {Command} command
@@ -10,18 +11,18 @@ export class Interpreter {
     /**
      *
      * @param {Command} command
-     * @param {WsConnectionData} connectionData
-     * @returns {Promise<Command>}
+     * @param {IConnectionData} connectionData
+     * @returns {Command | Promise<Command>}
      */
-    execute(command: Command, connectionData: WsConnectionData): Promise<Command>;
+    execute(command: Command, connectionData: IConnectionData): Command | Promise<Command>;
     /**
      *
-     * @param {number[]} messageByteArray
+     * @param {Int8Array} messageByteArray
      * @returns {Command}
      */
-    process(messageByteArray: number[]): Command;
+    process(messageByteArray: Int8Array): Command;
 }
-export type Receiver = import("../receiver/Receiver.js").Receiver;
-export type Transmitter = import("../transmitter/Transmitter.js").Transmitter;
-export type TransmitterWebsocket = import("../transmitter/TransmitterWebsocket.js").TransmitterWebsocket;
-export type TransmitterWebsocketBrowser = import("../transmitter/TransmitterWebsocketBrowser.js").TransmitterWebsocketBrowser;
+export type IConnectionData = import("../../utils/connectionData/IConnectionData.js").IConnectionData;
+export type RuntimeNameType = typeof import("../../types.d.ts").RuntimeName;
+export type Command = import("../../utils/Command.js").Command;
+import { Handler } from '../handler/Handler.js';

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/types/core/namespaceCache/NamespaceCache.d.ts

@@ -1,9 +1,21 @@
 export class NamespaceCache {
-    static _instance: null;
-    namespaceCache: any[];
-    cacheNamespace(namespaceRegex: any): void;
+    /** @type {NamespaceCache | null} */
+    static _instance: NamespaceCache | null;
+    /** @type {string[]} */
+    namespaceCache: string[];
+    /**
+     * @param {string} namespaceRegex
+     */
+    cacheNamespace(namespaceRegex: string): void;
+    /**
+     * @returns {boolean}
+     */
     isNamespaceCacheEmpty(): boolean;
-    isTypeAllowed(typeToCheck: any): boolean;
-    getCachedNamespaces(): any[];
+    /**
+     * @param {string} typeToCheck
+     * @returns {boolean}
+     */
+    isTypeAllowed(typeToCheck: string): boolean;
+    getCachedNamespaces(): string[];
     clearCache(): number;
 }

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

@@ -1,6 +1,9 @@
 export class CommandDeserializer {
-    constructor(buffer: any);
-    buffer: any;
+    /**
+     * @param {Int8Array} buffer
+     */
+    constructor(buffer: Int8Array);
+    buffer: Int8Array<ArrayBufferLike>;
     command: Command;
     position: number;
     /**
@@ -8,7 +11,11 @@ export class CommandDeserializer {
      */
     deserialize(): Command;
     isAtEnd(): boolean;
-    readObject(typeNum: any): string | number | bigint | boolean | Command | (() => bigint) | null;
+    /**
+     * @param {number} typeNum
+     * @returns {any}
+     */
+    readObject(typeNum: number): any;
     readCommand(): Command;
     readString(): string;
     readInt(): number;

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

@@ -1,4 +1,21 @@
+export type IConnectionData = import("../../utils/connectionData/IConnectionData.js").IConnectionData;
+/**
+ * @typedef {import('../../utils/connectionData/IConnectionData.js').IConnectionData} IConnectionData
+ */
 export class CommandSerializer {
-    serialize(rootCommand: any, connectionData: any): Uint8Array<any>;
-    serializeRecursively(command: any, buffers: any): void;
+    /**
+     * Serializes the root command with connection data and optional runtime version.
+     * @param {Command} rootCommand
+     * @param {IConnectionData} connectionData
+     * @param {number} runtimeVersion
+     * @returns {Int8Array}
+     */
+    serialize(rootCommand: Command, connectionData: IConnectionData, runtimeVersion?: number): Int8Array;
+    /**
+     * Recursively serializes command payload.
+     * @param {Command} command
+     * @param {Array<Uint8Array>} buffers
+     */
+    serializeRecursively(command: Command, buffers: Array<Uint8Array>): void;
 }
+import { Command } from '../../utils/Command.js';

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

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

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

@@ -1,17 +1,57 @@
 export class TypeSerializer {
-    static serializePrimitive(payload_item: any): Buffer<ArrayBuffer>;
-    static serializeCommand(command: any): Buffer<ArrayBuffer>;
-    static serializeString(string_value: any): Buffer<ArrayBuffer>;
-    static serializeInt(int_value: any): Buffer<ArrayBuffer>;
-    static serializeBool(bool_value: any): Buffer<ArrayBuffer>;
-    static serializeFloat(float_value: any): Buffer<ArrayBuffer>;
-    static serializeByte(byte_value: any): Buffer<ArrayBuffer>;
-    static serializeChar(char_value: any): Buffer<ArrayBuffer>;
-    static serializeLongLong(longlong_value: any): Buffer<ArrayBuffer>;
-    static serializeDouble(double_value: any): Buffer<ArrayBuffer>;
-    static serializeULLong(ullong_value: any): Buffer<ArrayBuffer>;
-    static serializeUInt(uint_value: any): Buffer<ArrayBuffer>;
+    /**
+     * @param {unknown} payload_item
+     */
+    static serializePrimitive(payload_item: unknown): Buffer<ArrayBuffer>;
+    /**
+     * @param {Command} command
+     */
+    static serializeCommand(command: Command): Buffer<ArrayBuffer>;
+    /**
+     * @param {string} string_value
+     */
+    static serializeString(string_value: string): Buffer<ArrayBuffer>;
+    /**
+     * @param {number} int_value
+     */
+    static serializeInt(int_value: number): Buffer<ArrayBuffer>;
+    /**
+     * @param {boolean} bool_value
+     */
+    static serializeBool(bool_value: boolean): Buffer<ArrayBuffer>;
+    /**
+     * @param {number} float_value
+     */
+    static serializeFloat(float_value: number): Buffer<ArrayBuffer>;
+    /**
+     * @param {number} byte_value
+     */
+    static serializeByte(byte_value: number): Buffer<ArrayBuffer>;
+    /**
+     * @param {number} char_value
+     */
+    static serializeChar(char_value: number): Buffer<ArrayBuffer>;
+    /**
+     * @param {number} longlong_value
+     */
+    static serializeLongLong(longlong_value: number): Buffer<ArrayBuffer>;
+    /**
+     * @param {number} double_value
+     */
+    static serializeDouble(double_value: number): Buffer<ArrayBuffer>;
+    /**
+     * @param {bigint} ullong_value
+     */
+    static serializeULLong(ullong_value: bigint): Buffer<ArrayBuffer>;
+    /**
+     * @param {number} uint_value
+     */
+    static serializeUInt(uint_value: number): Buffer<ArrayBuffer>;
     static serializeNull(): Buffer<ArrayBuffer>;
-    static serializeIntValue(int_value: any): Buffer<ArrayBuffer>;
+    /**
+     * @param {number} int_value
+     */
+    static serializeIntValue(int_value: number): Buffer<ArrayBuffer>;
 }
 import { Buffer } from 'buffer';
+import { Command } from '../../utils/Command.js';

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

@@ -1,9 +1,9 @@
 export class Receiver {
     static connectionData: InMemoryConnectionData;
     /**
-     * @param {number[]} messageByteArray
+     * @param {Int8Array} messageByteArray
      */
-    static sendCommand(messageByteArray: number[]): Uint8Array<any>;
+    static sendCommand(messageByteArray: Int8Array): Int8Array<ArrayBufferLike>;
     /**
      * @param {Int8Array} messageByteArray
      * @returns {Int8Array}

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

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

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

@@ -1,6 +1,22 @@
 export class Transmitter {
-    static sendCommand(messageArray: any): any;
-    static activate: (licenseKey: any) => any;
-    static setConfigSource(configSource: any): any;
-    static setJavonetWorkingDirectory(workingDirectory: any): void;
+    /**
+     * @param {Int8Array} messageArray
+     * @returns {Int8Array}
+     */
+    static sendCommand(messageArray: Int8Array): Int8Array;
+    /**
+     * @param {string} licenseKey
+     * @returns {void}
+     */
+    static activate(licenseKey: string): void;
+    /**
+     * @param {string} configSource
+     * @returns {void}
+    */
+    static setConfigSource(configSource: string): void;
+    /**
+     * @param {string} workingDirectory
+     * @returns
+     */
+    static setJavonetWorkingDirectory(workingDirectory: string): void;
 }

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

@@ -1,3 +1,6 @@
+/**
+ * @typedef {import('../../utils/connectionData/IConnectionData.js').IConnectionData} IConnectionData
+ */
 export class TransmitterWebsocket {
     /**
      * @returns {void}
@@ -13,9 +16,10 @@ export class TransmitterWebsocket {
     static activate(): void;
     /**
      * @async
-     * @param {number[]} messageByteArray
-     * @param {WsConnectionData} connectionData
-     * @returns {Promise<number[]>} responseByteArray
+     * @param {Int8Array} messageByteArray
+     * @param {IConnectionData} connectionData
+     * @returns {Promise<Int8Array>} responseByteArray
      */
-    static sendCommand(messageByteArray: number[], connectionData: WsConnectionData): Promise<number[]>;
+    static sendCommand(messageByteArray: Int8Array, connectionData: IConnectionData): Promise<Int8Array>;
 }
+export type IConnectionData = import("../../utils/connectionData/IConnectionData.js").IConnectionData;

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

@@ -1,6 +1,5 @@
 /**
- * @typedef {object} ConnectionData
- * @property {string} hostname
+ * @typedef {import('../../utils/connectionData/IConnectionData.js').IConnectionData} IConnectionData
  */
 export class TransmitterWebsocketBrowser {
     /**
@@ -14,10 +13,10 @@ export class TransmitterWebsocketBrowser {
     /**
      * @async
      * @param {Int8Array} messageByteArray
-     * @param {ConnectionData} connectionData
+     * @param {IConnectionData} connectionData
      * @returns {Promise<Int8Array>} responseByteArray
      */
-    static sendCommand(messageByteArray: Int8Array, connectionData: ConnectionData): Promise<Int8Array>;
+    static sendCommand(messageByteArray: Int8Array, connectionData: IConnectionData): Promise<Int8Array>;
     /**
      * @async
      * @param {any} configSource
@@ -25,6 +24,4 @@ export class TransmitterWebsocketBrowser {
      */
     static setConfigSource(configSource: any): void;
 }
-export type ConnectionData = {
-    hostname: string;
-};
+export type IConnectionData = import("../../utils/connectionData/IConnectionData.js").IConnectionData;

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

@@ -5,7 +5,16 @@ export class TransmitterWrapper {
      * @param {string} licenseKey
      */
     static activate(licenseKey: string): any;
-    static sendCommand(messageArray: any): any;
-    static setConfigSource(configSource: any): any;
-    static setJavonetWorkingDirectory(path: any): void;
+    /**
+     * @param {Int8Array} messageArray
+     */
+    static sendCommand(messageArray: Int8Array): any;
+    /**
+     * @param {string} configSource
+     */
+    static setConfigSource(configSource: string): any;
+    /**
+     * @param {string} path
+     */
+    static setJavonetWorkingDirectory(path: string): void;
 }

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/types/core/typeCache/TypeCache.d.ts

@@ -1,9 +1,19 @@
 export class TypeCache {
-    static _instance: null;
-    typeCache: any[];
-    cacheType(typRegex: any): void;
+    /** @type {TypeCache | null} */
+    static _instance: TypeCache | null;
+    /** @type {string[]} */
+    typeCache: string[];
+    /**
+     * @param {string} typRegex
+     */
+    cacheType(typRegex: string): void;
     isTypeCacheEmpty(): boolean;
-    isTypeAllowed(typeToCheck: any): boolean;
-    getCachedTypes(): any[];
+    /**
+     * @param {{ name: string }} typeToCheck
+     */
+    isTypeAllowed(typeToCheck: {
+        name: string;
+    }): boolean;
+    getCachedTypes(): string[];
     clearCache(): number;
 }

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

@@ -1,41 +1,37 @@
+export type wsClient = import("ws").WebSocket;
+export type WebSocketClass = typeof import("ws").WebSocket;
 /**
  * WebSocketClient class that handles WebSocket connection, message sending, and automatic disconnection.
  */
 export class WebSocketClient {
     /**
      * @param {string} url
-     * @param {object} options
-     */
-    constructor(url: string, options: object);
-    /**
-     * @type {string}
+     * @param {{ isDisconnectedAfterMessage: boolean }} options
      */
+    constructor(url: string, options: {
+        isDisconnectedAfterMessage: boolean;
+    });
+    /** @type {string} */
     url: string;
-    /**
-     * @type {WebSocket | null}
-     */
-    instance: WebSocket | null;
-    /**
-     * @type {boolean} isConnected indicates whether the WebSocket is connected.
-     */
+    /** @type {wsClient | null} */
+    instance: wsClient | null;
+    /** @type {boolean} */
     isConnected: boolean;
-    /**
-     * @type {boolean}
-     */
+    /** @type {boolean} */
     isDisconnectedAfterMessage: boolean;
     /**
      * Connects to the WebSocket server.
      * @async
-     * @returns {Promise<WebSocket>} - A promise that resolves when the connection is established.
+     * @returns {Promise<wsClient>} - A promise that resolves when the connection is established.
      */
-    connect(): Promise<WebSocket>;
+    connect(): Promise<wsClient>;
     /**
      * Sends messageArray through websocket connection
      * @async
-     * @param {Buffer|ArrayBuffer|Buffer[]} messageArray
-     * @returns {Promise<Buffer|ArrayBuffer|Buffer[]>}
+     * @param {Int8Array} messageArray
+     * @returns {Promise<Int8Array>}
      */
-    send(messageArray: Buffer | ArrayBuffer | Buffer[]): Promise<Buffer | ArrayBuffer | Buffer[]>;
+    send(messageArray: Int8Array): Promise<Int8Array>;
     /**
      * Disconnects the WebSocket by terminating the connection.
      */
@@ -44,7 +40,7 @@ export class WebSocketClient {
      * Connects to the WebSocket server.
      * @private
      * @async
-     * @returns {Promise<WebSocket>} - A promise that resolves when the connection is established.
+     * @returns {Promise<wsClient>} - A promise that resolves when the connection is established.
      */
     private _connect;
 }

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

@@ -1,3 +1,7 @@
+/**
+ * @typedef {import('../types.d.ts').ConfigSource} ConfigSource
+ * @typedef {import('../types.d.ts').RuntimeName} RuntimeNameType
+ */
 /**
  * The ConfigRuntimeFactory 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.
@@ -5,13 +9,10 @@
  */
 export class ConfigRuntimeFactory {
     /**
-     * @param {object | string} configSource
-     * @param {import('../core/transmitter/Transmitter.js') | null} transmitter
+     * @param {ConfigSource | string} configSource
      */
-    constructor(configSource: object | string, transmitter?: typeof import("../core/transmitter/Transmitter.js") | null);
-    /** @type {import('../core/transmitter/Transmitter.js') | null} */
-    transmitter: typeof import("../core/transmitter/Transmitter.js") | null;
-    configSource: string | object;
+    constructor(configSource: ConfigSource | string);
+    configSource: string | import("../types.d.ts").ConfigSource;
     /**
      * Creates RuntimeContext instance to interact with the .NET Framework runtime.
      * @param {string} [configName="default"] - The name of the configuration to use (optional).
@@ -70,4 +71,6 @@ export class ConfigRuntimeFactory {
     python27(configName?: string): RuntimeContext;
     #private;
 }
+export type ConfigSource = import("../types.d.ts").ConfigSource;
+export type RuntimeNameType = import("../types.d.ts").RuntimeName;
 import { RuntimeContext } from './RuntimeContext.js';

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

@@ -1,3 +1,9 @@
+export type RuntimeNameType = import("../types.d.ts").RuntimeName;
+export type IConnectionData = import("../utils/connectionData/IConnectionData.js").IConnectionData;
+/**
+ * @typedef {import('../types.d.ts').RuntimeName} RuntimeNameType
+ * @typedef {import('../utils/connectionData/IConnectionData.js').IConnectionData} IConnectionData
+ */
 /**
  * InvocationContext is a class that represents a context for invoking commands.
  * It implements several interfaces for different types of interactions.
@@ -6,8 +12,18 @@
  * @class
  */
 export class InvocationContext {
-    constructor(runtimeName: any, connectionData: any, command: any, isExecuted?: boolean);
-    get_current_command(): any;
+    /**
+     *
+     * @param {RuntimeNameType} runtimeName
+     * @param {IConnectionData} connectionData
+     * @param {Command} command
+     * @param {boolean} isExecuted
+     */
+    constructor(runtimeName: RuntimeNameType, connectionData: IConnectionData, command: Command, isExecuted?: boolean);
+    /**
+     * @returns {Command|null}
+     */
+    get_current_command(): Command | null;
     /**
      * 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.
@@ -172,12 +188,12 @@ export class 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.
+     * @returns {InvocationContext|InvocationWsContext} 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;
+    getInstanceMethodAsDelegate(methodName: string, ...args: any[]): InvocationContext | InvocationWsContext;
     /**
      * Retrieves an array from the target runtime.
      * @returns {InvocationContext} A new InvocationContext instance that wraps the command to retrieve the array.
@@ -192,16 +208,32 @@ export class InvocationContext {
      * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/foundations/execute-method)
      * @method
      */
-    getValue(): Command;
+    /**
+     * @returns {unknown}
+     */
+    getValue(): unknown;
     [Symbol.iterator]: () => {
         next: () => {
-            value: any;
+            value: InvocationContext;
             done: boolean;
         };
     };
     #private;
 }
 export class InvocationWsContext extends InvocationContext {
+    /**
+     * 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 {Promise<InvocationWsContext>} the InvocationContext after executing the command.
+     * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/foundations/execute-method)
+     * @async
+     * @method
+     */
+    execute(): Promise<InvocationWsContext>;
     #private;
 }
 import { Command } from '../utils/Command.js';

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

@@ -1,3 +1,4 @@
+export type ConfigSource = import("../types.d.ts").ConfigSource;
 /**
  * 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.
@@ -28,29 +29,33 @@ export class Javonet {
     /**
      * 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.
+     * @param {string|ConfigSource} 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: any): ConfigRuntimeFactory;
+    static withConfig(config: string | ConfigSource): ConfigRuntimeFactory;
     /**
      * Activates Javonet with the provided license key.
      * @param {string} licenseKey - The license key to activate Javonet.
-     * @returns {number} The activation status code.
+     * @returns {void} The activation status code.
      * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/getting-started/activating-javonet)
      */
-    static activate(licenseKey: string): number;
+    static activate(licenseKey: string): void;
+    /**
+     * Gets the runtime information.
+     * @returns {string} The runtime information.
+     */
     static getRuntimeInfo(): string;
     /**
      * Sets the configuration source for the Javonet SDK.
-     *
      * @param {string} configSource - The configuration source.
+     * @returns {void}
      */
-    static setConfigSource(configSource: string): any;
+    static setConfigSource(configSource: string): void;
     /**
      * Sets the working directory for the Javonet SDK.
-     *
      * @param {string} path - The working directory.
+     * @returns {void}
      */
     static setJavonetWorkingDirectory(path: string): void;
 }