javonet-nodejs-sdk 2.6.3 → 2.6.5

package/dist/sdk/tools/JsonResolver.cjs

@@ -42,8 +42,10 @@ let fs = null;
 class JsonResolver {
   /** @type {ConfigSource} */
   jsonObject;
-  /** @type {string | ConfigSource} */
+  /** @type {string} */
   configSource;
+  /** @type {boolean} */
+  isConfigSourcePath = false;
   /**
    * @param {string | ConfigSource} configSource
    */
@@ -149,6 +151,7 @@ class JsonResolver {
         fs = requireDynamic("fs");
       }
       if (fs?.existsSync(configSource)) {
+        this.isConfigSourcePath = true;
         const jsonText = fs.readFileSync(configSource, "utf8");
         if (isValidJson(jsonText)) {
           const parsedFromFile = JSON.parse(jsonText);

package/dist/types/core/handler/Handler.d.ts

@@ -8,13 +8,13 @@ export class Handler {
     /**
      * @param {Command} command
      */
-    handleCommand(command: Command): Command;
+    handleCommand(command: Command): Command | Promise<Command>;
     /**
      * @param {any} response
      * @param {RuntimeName} runtimeName
-     * @returns {Command}
+     * @returns {Promise<Command> | Command}
      */
-    parseCommand(response: any, runtimeName: RuntimeName): Command;
+    parseCommand(response: any, runtimeName: RuntimeName): Promise<Command> | Command;
 }
 /**
  * @typedef {import('../../types.d.ts').RuntimeName} RuntimeName

package/dist/types/core/interpreter/Interpreter.d.ts

@@ -19,10 +19,10 @@ export class Interpreter {
     execute(command: Command, connectionData: IConnectionData): Command | Promise<Command>;
     /**
      *
-     * @param {Int8Array} messageByteArray
-     * @returns {Command}
+     * @param {Uint8Array} messageByteArray
+     * @returns {Promise<Command> | Command}
      */
-    process(messageByteArray: Int8Array): Command;
+    process(messageByteArray: Uint8Array): Promise<Command> | Command;
 }
 export type IConnectionData = import("../../utils/connectionData/IConnectionData.js").IConnectionData;
 export type RuntimeNameType = typeof import("../../types.d.ts").RuntimeName;

package/dist/types/core/protocol/CommandDeserializer.d.ts

@@ -1,9 +1,9 @@
 export class CommandDeserializer {
     /**
-     * @param {Int8Array} buffer
+     * @param {Uint8Array} byteArray
      */
-    constructor(buffer: Int8Array);
-    buffer: Int8Array<ArrayBufferLike>;
+    constructor(byteArray: Uint8Array);
+    buffer: Uint8Array<ArrayBufferLike>;
     command: Command;
     position: number;
     /**

package/dist/types/core/protocol/CommandSerializer.d.ts

@@ -5,12 +5,12 @@ export type IConnectionData = import("../../utils/connectionData/IConnectionData
 export class CommandSerializer {
     /**
      * Serializes the root command with connection data and optional runtime version.
-     * @param {Command} rootCommand
+     * @param {Promise<Command> | Command} rootCommand
      * @param {IConnectionData} connectionData
      * @param {number} runtimeVersion
-     * @returns {Int8Array}
+     * @returns {Promise<Uint8Array> | Uint8Array}
      */
-    serialize(rootCommand: Command, connectionData: IConnectionData, runtimeVersion?: number): Int8Array;
+    serialize(rootCommand: Promise<Command> | Command, connectionData: IConnectionData, runtimeVersion?: number): Promise<Uint8Array> | Uint8Array;
     /**
      * Recursively serializes command payload.
      * @param {Command} command

package/dist/types/core/protocol/TypeDeserializer.d.ts

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

package/dist/types/core/receiver/Receiver.d.ts

@@ -2,14 +2,15 @@ export class Receiver {
     static connectionData: InMemoryConnectionData;
     static getRuntimeInfo(): string;
     /**
-     * @param {Int8Array} messageByteArray
+     * @param {Uint8Array} messageByteArray
+     * @returns {Promise<Uint8Array> | Uint8Array}
      */
-    static sendCommand(messageByteArray: Int8Array): Int8Array<ArrayBufferLike>;
+    static sendCommand(messageByteArray: Uint8Array): Promise<Uint8Array> | Uint8Array;
     /**
-     * @param {Int8Array} messageByteArray
-     * @returns {Int8Array}
+     * @param {Uint8Array} messageByteArray
+     * @returns {Promise<Uint8Array> | Uint8Array}
      */
-    static heartBeat(messageByteArray: Int8Array): Int8Array;
+    static heartBeat(messageByteArray: Uint8Array): Promise<Uint8Array> | Uint8Array;
     Receiver(): void;
 }
 import { InMemoryConnectionData } from '../../utils/connectionData/InMemoryConnectionData.js';

package/dist/types/core/receiver/ReceiverNative.d.ts

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

package/dist/types/core/transmitter/Transmitter.d.ts

@@ -1,9 +1,9 @@
 export class Transmitter {
     /**
-     * @param {Int8Array} messageArray
-     * @returns {Int8Array}
+     * @param {Uint8Array} messageArray
+     * @returns {Uint8Array}
      */
-    static sendCommand(messageArray: Int8Array): Int8Array;
+    static sendCommand(messageArray: Uint8Array): Uint8Array;
     /**
      * @param {string} licenseKey
      * @returns {void}
@@ -12,7 +12,7 @@ export class Transmitter {
     /**
      * @param {string} configSource
      * @returns {void}
-    */
+     */
     static setConfigSource(configSource: string): void;
     /**
      * @param {string} workingDirectory

package/dist/types/core/transmitter/TransmitterWebsocket.d.ts

@@ -16,10 +16,10 @@ export class TransmitterWebsocket {
     static activate(): void;
     /**
      * @async
-     * @param {Int8Array} messageByteArray
+     * @param {Uint8Array} messageByteArray
      * @param {IConnectionData} connectionData
-     * @returns {Promise<Int8Array>} responseByteArray
+     * @returns {Promise<Uint8Array>} responseByteArray
      */
-    static sendCommand(messageByteArray: Int8Array, connectionData: IConnectionData): Promise<Int8Array>;
+    static sendCommand(messageByteArray: Uint8Array, connectionData: IConnectionData): Promise<Uint8Array>;
 }
 export type IConnectionData = import("../../utils/connectionData/IConnectionData.js").IConnectionData;

package/dist/types/core/transmitter/TransmitterWebsocketBrowser.d.ts

@@ -12,11 +12,11 @@ export class TransmitterWebsocketBrowser {
     static activate(): void;
     /**
      * @async
-     * @param {Int8Array} messageByteArray
+     * @param {Uint8Array} messageByteArray
      * @param {IConnectionData} connectionData
-     * @returns {Promise<Int8Array>} responseByteArray
+     * @returns {Promise<Uint8Array>} responseByteArray
      */
-    static sendCommand(messageByteArray: Int8Array, connectionData: IConnectionData): Promise<Int8Array>;
+    static sendCommand(messageByteArray: Uint8Array, connectionData: IConnectionData): Promise<Uint8Array>;
     /**
      * @async
      * @param {any} configSource

package/dist/types/core/transmitter/TransmitterWrapper.d.ts

@@ -6,9 +6,10 @@ export class TransmitterWrapper {
      */
     static activate(licenseKey: string): any;
     /**
-     * @param {Int8Array} messageArray
+     * @param {Uint8Array} messageArray
+     * @returns {Uint8Array}
      */
-    static sendCommand(messageArray: Int8Array): any;
+    static sendCommand(messageArray: Uint8Array): Uint8Array;
     /**
      * @param {string} configSource
      */

package/dist/types/core/webSocketClient/WebSocketClient.d.ts

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

package/dist/types/core/webSocketClient/WebSocketClientBrowser.d.ts

@@ -4,11 +4,11 @@
  */
 /** @type {Record<string, WebSocket>} */
 export const clients: Record<string, WebSocket>;
-/** @type {Record<string, Array<{resolve: Function, reject: Function, messageArray: Int8Array}>>} */
+/** @type {Record<string, Array<{resolve: Function, reject: Function, messageArray: Uint8Array}>>} */
 export const messageQueue: Record<string, Array<{
     resolve: Function;
     reject: Function;
-    messageArray: Int8Array;
+    messageArray: Uint8Array;
 }>>;
 /** @type {Record<string, boolean>} */
 export const processingQueues: Record<string, boolean>;
@@ -34,10 +34,10 @@ export class WebSocketClientBrowser {
     /**
      * Sends messageArray through websocket connection with guaranteed order preservation
      * @async
-     * @param {Int8Array} messageArray
-     * @returns {Promise<Int8Array>}
+     * @param {Uint8Array} messageArray
+     * @returns {Promise<Uint8Array>}
      */
-    send(messageArray: Int8Array): Promise<Int8Array>;
+    send(messageArray: Uint8Array): Promise<Uint8Array>;
     /**
      * Processes message queue sequentially to maintain order
      * @private
@@ -48,8 +48,8 @@ export class WebSocketClientBrowser {
      * Sends a single message through websocket connection
      * @private
      * @async
-     * @param {Int8Array} messageArray
-     * @returns {Promise<Int8Array>}
+     * @param {Uint8Array} messageArray
+     * @returns {Promise<Uint8Array>}
      */
     private _sendSingle;
     /**
@@ -67,8 +67,8 @@ export class WebSocketClientBrowser {
      * Sends the data to the WebSocket server and listens for a response.
      * @private
      * @param {WebSocket} client
-     * @param {Int8Array} data
-     * @param {(value: Int8Array) => void} resolve
+     * @param {Uint8Array} data
+     * @param {(value: Uint8Array) => void} resolve
      * @param {(reason?: any) => void} reject
      */
     private _sendMessage;

package/dist/types/sdk/ConfigRuntimeFactory.d.ts

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

package/dist/types/sdk/InvocationContext.d.ts

@@ -31,11 +31,11 @@ export class InvocationContext {
      * Commands are becoming nested through each invocation of methods on Invocation Context.
      * Each invocation triggers the creation of new Invocation Context instance wrapping the current command with new parent command valid for invoked method.
      * Developer can decide on any moment of the materialization for the context taking full control of the chunks of the expression being transferred and processed on target runtime.
-     * @returns {InvocationContext} the InvocationContext after executing the command.
+     * @returns {Promise<InvocationContext> | InvocationContext} the InvocationContext after executing the command.
      * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/foundations/execute-method)
      * @method
      */
-    execute(): InvocationContext;
+    execute(): Promise<InvocationContext> | InvocationContext;
     /**
      * Invokes a static method on the target runtime.
      * @param {string} methodName - The name of the method to invoke.
@@ -196,11 +196,11 @@ export class InvocationContext {
     getInstanceMethodAsDelegate(methodName: string, ...args: any[]): InvocationContext | InvocationWsContext;
     /**
      * Retrieves the type of the object from the target runtime.
-     * @returns {string} The type of the object.
+     * @returns {Promise<string> | string} The type of the object.
      * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/type-handling/getting-object-type)
      * @method
      */
-    getResultType(): string;
+    getResultType(): Promise<string> | string;
     /**
      * Retrieves the name of the runtime where the command is executed.
      * @returns {number} The name of the runtime.
@@ -210,21 +210,17 @@ export class InvocationContext {
     getRuntimeName(): number;
     /**
      * Retrieves an array from the target runtime.
-     * @returns {InvocationContext} A new InvocationContext instance that wraps the command to retrieve the array.
-     * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/arrays-and-collections/retrieve-array)
+     * @returns {Promise<any[]>}
      * @method
      */
-    retrieveArray(): InvocationContext;
+    retrieveArray(): Promise<any[]>;
     /**
      * Returns the primitive value from the target runtime. This could be any primitive type in JavaScript,
      * such as int, boolean, byte, char, long, double, float, etc.
-     * @returns {Command} The value of the current command.
+     * @returns {unknown} The value of the current command.
      * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/foundations/execute-method)
      * @method
      */
-    /**
-     * @returns {unknown}
-     */
     getValue(): unknown;
     [Symbol.iterator]: () => {
         next: () => {

package/dist/types/sdk/Javonet.d.ts

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

package/dist/types/sdk/RuntimeFactory.d.ts

@@ -7,6 +7,14 @@
  * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/foundations/runtime-context)
  */
 export class RuntimeFactory {
+    /**
+     * @param {{ runtime: import("../types.js").RuntimeName; connectionData: import("../utils/connectionData/IConnectionData.js").IConnectionData; modules: any; }} config
+     */
+    static initializeRuntimeContext(config: {
+        runtime: import("../types.js").RuntimeName;
+        connectionData: import("../utils/connectionData/IConnectionData.js").IConnectionData;
+        modules: any;
+    }): RuntimeContext;
     /**
      * @param {IConnectionData} connectionData
      */
@@ -54,6 +62,12 @@ export class RuntimeFactory {
      * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/foundations/runtime-context)
      */
     nodejs(): RuntimeContext;
+    /**
+     * Creates RuntimeContext instance to interact with the PHP runtime.
+     * @return {RuntimeContext} a RuntimeContext instance for the PHP runtime
+     * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/foundations/runtime-context)
+     */
+    php(): RuntimeContext;
     /**
      * Creates RuntimeContext instance to interact with the Python runtime.
      * @return {RuntimeContext} a RuntimeContext instance for the Python runtime

package/dist/types/sdk/configuration/Config.d.ts

@@ -0,0 +1,14 @@
+export class Config {
+    /**
+     * @param {*} runtime
+     * @param {*} connectionData
+     * @param {string} [plugins=""]
+     * @param {string} [modules=""]
+     */
+    constructor(runtime: any, connectionData: any, plugins?: string, modules?: string);
+    runtime: any;
+    connectionData: any;
+    plugins: string;
+    modules: string;
+    toString(): string;
+}

package/dist/types/sdk/configuration/ConfigPriority.d.ts

@@ -0,0 +1,8 @@
+export namespace ConfigPriority {
+    let RuntimeSpecificEnv: 1;
+    let GlobalEnv: 2;
+    let RuntimeSpecificFile: 3;
+    let GlobalFile: 4;
+    let User: 5;
+    let DefaultLibrary: 6;
+}

package/dist/types/sdk/configuration/ConfigSourceResolver.d.ts

@@ -0,0 +1,7 @@
+export class ConfigSourceResolver {
+    static addConfigs(priority: any, configSource: any): void;
+    static getConfig(configName: any): any;
+    static clearConfigs(): void;
+    static _getConfigSourceAsString(configSource: any): any;
+    static _parseConfigsAndAddToCollection(priority: any, configString: any): void;
+}

package/dist/types/sdk/configuration/ConfigsDictionary.d.ts

@@ -0,0 +1,30 @@
+export class ConfigsDictionary {
+    /** @type {Map<string, Map<number, any>>} */
+    static _configurations_collection: Map<string, Map<number, any>>;
+    /**
+     * Normalize priority to a numeric value.
+     * Accepts either a number or an object with a numeric `value` property.
+     * @param {any} priority
+     * @returns {number|undefined}
+     */
+    static _normalizePriority(priority: any): number | undefined;
+    /**
+     * Add a configuration for a given name and priority.
+     * If the same name+priority already exists, it will not be overwritten.
+     * @param {string} name
+     * @param {number|{value:number}} priority
+     * @param {*} config
+     */
+    static addConfig(name: string, priority: number | {
+        value: number;
+    }, config: any): void;
+    /**
+     * Retrieve the configuration with the numerically smallest priority for the given name.
+     * Throws if name is invalid or no configuration is found.
+     * @param {string} name
+     * @returns {*}
+     */
+    static getConfig(name: string): any;
+    /** Clear all stored configurations. */
+    static clearConfigs(): void;
+}

package/dist/types/sdk/configuration/configResolvers/ConfigResolver.d.ts

@@ -0,0 +1,30 @@
+export class ConfigResolver {
+    /**
+     * Parse a runtime string into the runtime enum/name using RuntimeNameHandler.
+     * @param {string} runtime
+     * @returns {*}
+     */
+    static tryParseRuntime(runtime: string): any;
+    /**
+     * Build appropriate connection data object from a host string.
+     * - empty / null => InMemoryConnectionData
+     * - "inmemory" or "in-memory" => InMemoryConnectionData
+     * - ws:// or wss:// => WsConnectionData(fullAddress)
+     * - tcp://... => parsed by parseTcp
+     * - host:port or host:port/... => TcpConnectionData(host, port) if valid, otherwise InMemoryConnectionData
+     * @param {string} hostValue
+     * @returns {InMemoryConnectionData|WsConnectionData|TcpConnectionData}
+     */
+    static buildConnectionData(hostValue: string): InMemoryConnectionData | WsConnectionData | TcpConnectionData;
+    /**
+     * Parse tcp address portion (after tcp://) into TcpConnectionData.
+     * Expected formats: host:port or host:port/...
+     * Throws Error on invalid format or port.
+     * @param {string} address
+     * @returns {TcpConnectionData}
+     */
+    static parseTcp(address: string): TcpConnectionData;
+}
+import { InMemoryConnectionData } from '../../../utils/connectionData/InMemoryConnectionData.js';
+import { WsConnectionData } from '../../../utils/connectionData/WsConnectionData.js';
+import { TcpConnectionData } from '../../../utils/nodejs/connectionData/TcpConnectionData.js';

package/dist/types/sdk/configuration/configResolvers/ConnectionStringConfigResolver.d.ts

@@ -0,0 +1,23 @@
+export class ConnectionStringConfigResolver extends ConfigResolver {
+    /**
+     * Parse and add multiple configuration lines from a connection string source.
+     * @param {any} priority
+     * @param {string} connectionStringSource
+     */
+    static addConfigs(priority: any, connectionStringSource: string): void;
+    /**
+     * Extract and set temporary license key from a line like "licensekey=VALUE;..."
+     * @param {string} line
+     * @private
+     */
+    private static _setLicenseKey;
+    /**
+     * Parse semicolon-separated key=value tokens into an object.
+     * Ignores malformed tokens and logs them.
+     * @param {string} line
+     * @returns {Record<string, string>}
+     * @private
+     */
+    private static _parseKeyValues;
+}
+import { ConfigResolver } from './ConfigResolver.js';

package/dist/types/sdk/configuration/configResolvers/JsonConfigResolver.d.ts

@@ -0,0 +1,26 @@
+export class JsonConfigResolver extends ConfigResolver {
+    /**
+     * Parse and add configurations from a JSON object.
+     * @param {any} priority
+     * @param {Record<string, unknown>} jsonObject
+     */
+    static addConfigs(priority: any, jsonObject: Record<string, unknown>): void;
+    /**
+     * Get a required string property from an object, trimmed.
+     * Throws if missing or empty.
+     * @param {Record<string, unknown>} obj
+     * @param {string} property
+     * @returns {string}
+     * @private
+     */
+    private static _getRequiredString;
+    /**
+     * Get an optional string property; return empty string when missing or not a string.
+     * @param {Record<string, unknown>} obj
+     * @param {string} property
+     * @returns {string}
+     * @private
+     */
+    private static _getOptionalString;
+}
+import { ConfigResolver } from './ConfigResolver.js';