javonet-ruby-sdk 2.5.15 → 2.5.17

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

@@ -0,0 +1,15 @@
+/**
+ * Handles invoking a delegate by GUID.
+ */
+export class InvokeDelegateHandler extends AbstractHandler {
+    /** @type {number} */
+    requiredParametersCount: number;
+    /**
+     * Processes a command to invoke a delegate.
+     * @param {Command} command - The command containing payload data.
+     * @returns {*} The result of the delegate invocation.
+     * @throws {Error} If the parameters mismatch or the delegate cannot be found.
+     */
+    process(command: Command): any;
+}
+import { AbstractHandler } from './AbstractHandler.js';

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

@@ -0,0 +1,5 @@
+export class InvokeGlobalFunctionHandler extends AbstractHandler {
+    requiredParametersCount: number;
+    process(command: any): any;
+}
+import { AbstractHandler } from './AbstractHandler.js';

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

@@ -0,0 +1,5 @@
+export class InvokeInstanceMethodHandler extends AbstractHandler {
+    requiredParametersCount: number;
+    process(command: any): any;
+}
+import { AbstractHandler } from './AbstractHandler.js';

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

@@ -0,0 +1,5 @@
+export class InvokeStaticMethodHandler extends AbstractHandler {
+    requiredParametersCount: number;
+    process(command: any): any;
+}
+import { AbstractHandler } from './AbstractHandler.js';

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

@@ -0,0 +1,7 @@
+export class LoadLibraryHandler extends AbstractHandler {
+    static loadedLibraries: any[];
+    requiredParametersCount: number;
+    process(command: any): number;
+    getLoadedLibraries(): any[];
+}
+import { AbstractHandler } from './AbstractHandler.js';

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

@@ -0,0 +1,104 @@
+export type Command = import("../../utils/Command.js").Command;
+export type Interpreter = import("../interpreter/Interpreter.js").Interpreter;
+/**
+ * @typedef {import('../../utils/Command.js').Command} Command
+ * @typedef {import('../interpreter/Interpreter.js').Interpreter} Interpreter
+ */
+/**
+ * PassDelegateHandler class responsible for processing a command to create a delegate.
+ */
+export class PassDelegateHandler extends AbstractHandler {
+    constructor(interpreter?: null);
+    /** @type {Interpreter | null | undefined} */
+    interpreter: Interpreter | null | undefined;
+    /**
+     * Minimum required parameters count for the command.
+     * @type {number}
+     */
+    requiredParametersCount: number;
+    /**S
+     * Processes the given command to create and compile a delegate.
+     * @param {Command} command - The command to process.
+     * @returns {Function} The compiled delegate function.
+     */
+    process(command: Command): Function;
+    /**
+     * Validates the command to ensure it has enough parameters.
+     * @param {Command} command - The command to validate.
+     */
+    validateCommand(command: Command): void;
+    /**
+     * Retrieves the arguments from the command payload.
+     * @param {Command} command - The command containing the payload.
+     * @returns {Array<any>} The extracted arguments.
+     */
+    getArguments(command: Command): Array<any>;
+    /**
+     * Extracts argument types from the arguments array.
+     * @param {Array<any>} args - The arguments array.
+     * @returns {Array<any>} The argument types.
+     */
+    getArgumentTypes(args: Array<any>): Array<any>;
+    /**
+     * Retrieves the return type from the arguments array.
+     * @param {Array<any>} args - The arguments array.
+     * @returns {Function} The return type.
+     */
+    getReturnType(args: Array<any>): Function;
+    /**
+     * Creates parameter expressions from argument types.
+     * @param {Array<any>} argsTypes - The argument types.
+     * @returns {Array<any>} The parameter expressions.
+     */
+    createParameters(argsTypes: Array<any>): Array<any>;
+    /**
+     * Creates an array of arguments for the delegate.
+     * @param {string} delegateGuid - The delegate identifier.
+     * @param {Array<any>} parameters - The parameter expressions.
+     * @returns {Array<any>} The arguments array.
+     */
+    createArgsArray(delegateGuid: string, parameters: Array<any>): Array<any>;
+    /**
+     * Creates a command expression.
+     * @param {string} callingRuntimeName - The runtime name.
+     * @param {Array<any>} payload - The arguments array.
+     * @returns {Object} The command object.
+     */
+    createCommand(callingRuntimeName: string, payload: Array<any>): Object;
+    /**
+     * Creates a method call to execute the command.
+     * @param {Command} command - The command object.
+     * @returns {any} The response object.
+     */
+    createExecuteCall(command: Command): any;
+    /**
+     * Retrieves the response payload from the execution call.
+     * @param {Object<string, any>} executeCall - Object containing the execution call.
+     * @returns {Array<any>} The response payload.
+     */
+    getResponse(executeCall: {
+        [x: string]: any;
+    }): Array<any>;
+    /**
+     * Converts the first element of the response to the return type.
+     * @param {Array<any>} response - The response payload.
+     * @param {Function} returnType - The return type.
+     * @returns {*} The converted first element.
+     */
+    convertFirstElement(response: Array<any>, returnType: Function): any;
+    /**
+     * Creates a block of expressions for the delegate.
+     * @param {Function} returnType - The return type.
+     * @param {*} convertedFirstElement - The converted first element.
+     * @returns {Object} The block expression.
+     */
+    createBlock(returnType: Function, convertedFirstElement: any): Object;
+    /**
+     * Creates a delegate type.
+     * @param {Array<any>} parameters - The parameter expressions.
+     * @param {Function} returnType - The return type.
+     * @returns {Function} The delegate type.
+     */
+    createDelegateType(parameters: Array<any>, returnType: Function): Function;
+}
+import { AbstractHandler } from './AbstractHandler.js';

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

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

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

@@ -0,0 +1,4 @@
+export class SetGlobalStaticFieldHandler extends AbstractHandler {
+    requiredParametersCount: number;
+}
+import { AbstractHandler } from './AbstractHandler.js';

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

@@ -0,0 +1,5 @@
+export class SetInstanceFieldHandler extends AbstractHandler {
+    requiredParametersCount: number;
+    process(command: any): number;
+}
+import { AbstractHandler } from './AbstractHandler.js';

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

@@ -0,0 +1,5 @@
+export class SetStaticFieldHandler extends AbstractHandler {
+    requiredParametersCount: number;
+    process(command: any): number;
+}
+import { AbstractHandler } from './AbstractHandler.js';

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

@@ -0,0 +1,4 @@
+export class ValueHandler extends AbstractHandler {
+    process(command: any): any;
+}
+import { AbstractHandler } from './AbstractHandler.js';

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

@@ -0,0 +1,27 @@
+export class Interpreter {
+    handler: any;
+    /**
+     *
+     * @param {Command} command
+     * @param {IConnectionData} connectionData
+     * @returns
+     */
+    executeAsync(command: Command, connectionData: IConnectionData): Promise<import("../../utils/Command.js").Command>;
+    /**
+     *
+     * @param {Command} command
+     * @param {WsConnectionData} connectionData
+     * @returns {Promise<Command>}
+     */
+    execute(command: Command, connectionData: WsConnectionData): Promise<Command>;
+    /**
+     *
+     * @param {number[]} messageByteArray
+     * @returns {Command}
+     */
+    process(messageByteArray: number[]): 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;

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

@@ -0,0 +1,9 @@
+export class NamespaceCache {
+    static _instance: null;
+    namespaceCache: any[];
+    cacheNamespace(namespaceRegex: any): void;
+    isNamespaceCacheEmpty(): boolean;
+    isTypeAllowed(typeToCheck: any): boolean;
+    getCachedNamespaces(): any[];
+    clearCache(): number;
+}

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

@@ -0,0 +1,25 @@
+export class CommandDeserializer {
+    constructor(buffer: any);
+    buffer: any;
+    command: Command;
+    position: number;
+    /**
+     * @returns {Command}
+     */
+    deserialize(): Command;
+    isAtEnd(): boolean;
+    readObject(typeNum: any): string | number | bigint | boolean | Command | (() => bigint) | null;
+    readCommand(): Command;
+    readString(): string;
+    readInt(): number;
+    readBool(): boolean;
+    readFloat(): number;
+    readByte(): number;
+    readChar(): number;
+    readLongLong(): bigint;
+    readDouble(): number;
+    readUllong(): bigint;
+    readUInt(): number;
+    readNull(): null;
+}
+import { Command } from '../../utils/Command.js';

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

@@ -0,0 +1,4 @@
+export class CommandSerializer {
+    serialize(rootCommand: any, connectionData: any): Uint8Array<any>;
+    serializeRecursively(command: any, buffers: any): void;
+}

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

@@ -0,0 +1,15 @@
+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;
+    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

@@ -0,0 +1,17 @@
+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>;
+    static serializeNull(): Buffer<ArrayBuffer>;
+    static serializeIntValue(int_value: any): Buffer<ArrayBuffer>;
+}
+import { Buffer } from 'buffer';

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

@@ -0,0 +1,14 @@
+export class Receiver {
+    static connectionData: InMemoryConnectionData;
+    /**
+     * @param {number[]} messageByteArray
+     */
+    static sendCommand(messageByteArray: number[]): Uint8Array<any>;
+    /**
+     * @param {Int8Array} messageByteArray
+     * @returns {Int8Array}
+     */
+    static heartBeat(messageByteArray: Int8Array): Int8Array;
+    Receiver(): void;
+}
+import { InMemoryConnectionData } from '../../utils/connectionData/InMemoryConnectionData.js';

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

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

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/types/core/referenceCache/ReferencesCache.d.ts

@@ -0,0 +1,24 @@
+export type Cache = {
+    [x: string]: any;
+};
+export class ReferencesCache {
+    /**
+     * @returns {ReferencesCache}
+     */
+    static getInstance(): ReferencesCache;
+    /**
+     * @param {any} reference
+     * @returns {string}
+     */
+    cacheReference(reference: any): string;
+    /**
+     * @param {string} id
+     * @returns {any}
+     */
+    resolveReference(id: string): any;
+    /**
+     * @param {string} id
+     * @returns {number}
+     */
+    deleteReference(id: string): number;
+}

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

@@ -0,0 +1,6 @@
+export class Transmitter {
+    static sendCommand(messageArray: any): any;
+    static activate: (licenseKey: any) => any;
+    static setConfigSource(configSource: any): any;
+    static setJavonetWorkingDirectory(workingDirectory: any): void;
+}

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

@@ -0,0 +1,21 @@
+export class TransmitterWebsocket {
+    /**
+     * @returns {void}
+     */
+    static initialize(): void;
+    /**
+     * @returns {void}
+     */
+    static setConfigSource(): void;
+    /**
+     * @returns {void}
+     */
+    static activate(): void;
+    /**
+     * @async
+     * @param {number[]} messageByteArray
+     * @param {WsConnectionData} connectionData
+     * @returns {Promise<number[]>} responseByteArray
+     */
+    static sendCommand(messageByteArray: number[], connectionData: WsConnectionData): Promise<number[]>;
+}

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

@@ -0,0 +1,30 @@
+/**
+ * @typedef {object} ConnectionData
+ * @property {string} hostname
+ */
+export class TransmitterWebsocketBrowser {
+    /**
+     * @returns {void}
+     */
+    static initialize(): void;
+    /**
+     * @returns {void}
+     */
+    static activate(): void;
+    /**
+     * @async
+     * @param {Int8Array} messageByteArray
+     * @param {ConnectionData} connectionData
+     * @returns {Promise<Int8Array>} responseByteArray
+     */
+    static sendCommand(messageByteArray: Int8Array, connectionData: ConnectionData): Promise<Int8Array>;
+    /**
+     * @async
+     * @param {any} configSource
+     * @returns {void}
+     */
+    static setConfigSource(configSource: any): void;
+}
+export type ConnectionData = {
+    hostname: string;
+};

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

@@ -0,0 +1,11 @@
+export class TransmitterWrapper {
+    static isNativeLibraryLoaded(): boolean;
+    static loadNativeLibrary(): void;
+    /**
+     * @param {string} licenseKey
+     */
+    static activate(licenseKey: string): any;
+    static sendCommand(messageArray: any): any;
+    static setConfigSource(configSource: any): any;
+    static setJavonetWorkingDirectory(path: any): void;
+}

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

@@ -0,0 +1,9 @@
+export class TypeCache {
+    static _instance: null;
+    typeCache: any[];
+    cacheType(typRegex: any): void;
+    isTypeCacheEmpty(): boolean;
+    isTypeAllowed(typeToCheck: any): boolean;
+    getCachedTypes(): any[];
+    clearCache(): number;
+}

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

@@ -0,0 +1,50 @@
+/**
+ * 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}
+     */
+    url: string;
+    /**
+     * @type {WebSocket | null}
+     */
+    instance: WebSocket | null;
+    /**
+     * @type {boolean} isConnected indicates whether the WebSocket is connected.
+     */
+    isConnected: boolean;
+    /**
+     * @type {boolean}
+     */
+    isDisconnectedAfterMessage: boolean;
+    /**
+     * Connects to the WebSocket server.
+     * @async
+     * @returns {Promise<WebSocket>} - A promise that resolves when the connection is established.
+     */
+    connect(): Promise<WebSocket>;
+    /**
+     * Sends messageArray through websocket connection
+     * @async
+     * @param {Buffer|ArrayBuffer|Buffer[]} messageArray
+     * @returns {Promise<Buffer|ArrayBuffer|Buffer[]>}
+     */
+    send(messageArray: Buffer | ArrayBuffer | Buffer[]): Promise<Buffer | ArrayBuffer | Buffer[]>;
+    /**
+     * Disconnects the WebSocket by terminating the connection.
+     */
+    disconnect(): void;
+    /**
+     * Connects to the WebSocket server.
+     * @private
+     * @async
+     * @returns {Promise<WebSocket>} - A promise that resolves when the connection is established.
+     */
+    private _connect;
+}

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

@@ -0,0 +1,63 @@
+export type Options = {
+    isDisconnectedAfterMessage: boolean;
+};
+/**
+ * @typedef {object} Options
+ * @property {boolean} isDisconnectedAfterMessage
+ */
+/**
+ * WebSocketClient class that handles WebSocket connection, message sending, and automatic disconnection.
+ */
+export class WebSocketClientBrowser {
+    /**
+     * @param {string} url
+     * @param {Options} [options]
+     */
+    constructor(url: string, options?: Options);
+    /**
+     * @type {string}
+     */
+    url: string;
+    /**
+     * @type {WebSocket | null}
+     */
+    instance: WebSocket | null;
+    /**
+     * @type {boolean} isConnected indicates whether the WebSocket is connected.
+     */
+    isConnected: boolean;
+    /**
+     * @type {boolean}
+     */
+    isDisconnectedAfterMessage: boolean;
+    /**
+     * Sends messageArray through websocket connection
+     * @async
+     * @param {Int8Array} messageArray
+     * @returns {Promise<Int8Array>}
+     */
+    send(messageArray: Int8Array): Promise<Int8Array>;
+    /**
+     * Disconnects the WebSocket by terminating the connection.
+     * @returns {void}
+     *
+     */
+    disconnect(): void;
+    /**
+     * Connects to the WebSocket server.
+     * @private
+     * @async
+     * @returns {Promise<void>} - A promise that resolves when the connection is established.
+     */
+    private _connect;
+    /**
+     * Sends the data to the WebSocket server and listens for a response.
+     * @private
+     * @async
+     * @param {Int8Array} data - The data to send.
+     * @param {Function} resolve - The resolve function for the Promise.
+     * @param {Function} reject - The reject function for the Promise.
+     * @returns {void}
+     */
+    private _sendMessage;
+}