javonet-ruby-sdk 2.6.7 → 2.6.10

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

@@ -21,8 +21,10 @@ __export(ComplexTypeResolver_exports, {
   ComplexTypeResolver: () => ComplexTypeResolver
 });
 module.exports = __toCommonJS(ComplexTypeResolver_exports);
+var import_Primitives = require("../../utils/Primitives.cjs");
 var import_Runtime = require("../../utils/Runtime.cjs");
 var import_RuntimeName = require("../../utils/RuntimeName.cjs");
+var import_Activator = require("../Activator.cjs");
 var import_ActivatorDetails = require("../ActivatorDetails.cjs");
 var import_InvocationContext = require("../InvocationContext.cjs");
 var import_JavaTypeParsingFunctions = require("./typeParsingFunctions/JavaTypeParsingFunctions.cjs");
@@ -31,17 +33,19 @@ var import_NodejsTypeParsingFunctions = require("./typeParsingFunctions/NodejsTy
 var import_PythonTypeParsingFunctions = require("./typeParsingFunctions/PythonTypeParsingFunctions.cjs");
 const import_meta = {};
 const dynamicImport = (0, import_Runtime.getRequire)(import_meta.url);
+const typeParsingFunctions = /* @__PURE__ */ new Map([
+  [import_RuntimeName.RuntimeName.Netcore, import_NetcoreTypeParsingFunctions.NetcoreTypeParsingFunctions],
+  [import_RuntimeName.RuntimeName.Jvm, import_JavaTypeParsingFunctions.JavaTypeParsingFunctions],
+  [import_RuntimeName.RuntimeName.Nodejs, import_NodejsTypeParsingFunctions.NodejsTypeParsingFunctions],
+  [import_RuntimeName.RuntimeName.Python, import_PythonTypeParsingFunctions.PythonTypeParsingFunctions],
+  [import_RuntimeName.RuntimeName.Python27, import_PythonTypeParsingFunctions.PythonTypeParsingFunctions]
+]);
 class ComplexTypeResolver {
   /** @type {Map<string, ActivatorDetails>} */
-  #typeMap = /* @__PURE__ */ new Map();
-  /** @type {Map<number, Map<string, Function>>} */
-  #typeParsingFunctions = /* @__PURE__ */ new Map([
-    [import_RuntimeName.RuntimeName.Netcore, import_NetcoreTypeParsingFunctions.NetcoreTypeParsingFunctions],
-    [import_RuntimeName.RuntimeName.Jvm, import_JavaTypeParsingFunctions.JavaTypeParsingFunctions],
-    [import_RuntimeName.RuntimeName.Nodejs, import_NodejsTypeParsingFunctions.NodejsTypeParsingFunctions],
-    [import_RuntimeName.RuntimeName.Python, import_PythonTypeParsingFunctions.PythonTypeParsingFunctions],
-    [import_RuntimeName.RuntimeName.Python27, import_PythonTypeParsingFunctions.PythonTypeParsingFunctions]
-  ]);
+  #typeMap;
+  constructor() {
+    this.#typeMap = /* @__PURE__ */ new Map();
+  }
   /**
    * Register a custom type mapping
    * @param {string} resultType - The type name from the target runtime
@@ -56,38 +60,40 @@ class ComplexTypeResolver {
   /**
    * Convert InvocationContext result to appropriate JavaScript type
    * @param {InvocationContext} ic - The invocation context
-   * @returns {Promise<any> | any} The converted result
+   * @returns {Promise<any>} The converted result
    */
-  convertResult(ic) {
+  async convertResult(ic) {
     const runtimeName = ic.getRuntimeName();
-    const resultType = ic.getResultType();
-    const runtimeDict = this.#typeParsingFunctions.get(runtimeName);
-    if (runtimeDict) {
-      let parsingFunc = null;
-      if (resultType instanceof Promise) {
-        parsingFunc = resultType.then((result) => {
-          parsingFunc = runtimeDict.get(result);
-        });
-      } else {
-        parsingFunc = runtimeDict.get(resultType);
-      }
-      if (parsingFunc) {
-        return parsingFunc(ic);
-      }
+    const resultType = await ic.getResultType();
+    if (!resultType) {
+      throw new Error("resultType is not valid");
     }
-    let activatorDetails = null;
-    if (resultType instanceof Promise) {
-      activatorDetails = resultType.then((result) => {
-        activatorDetails = this.#typeMap.get(result);
-      });
-    } else {
-      activatorDetails = this.#typeMap.get(resultType);
+    let underlyingType = ComplexTypeResolver.tryGetUnderlyingArrayType(resultType);
+    if (underlyingType !== null) {
+      const { Type } = (
+        /** @type {ActivatorDetails} */
+        this.#typeMap.get(underlyingType)
+      );
+      const complexTypesArray = await ic.retrieveArray();
+      return complexTypesArray.map((item) => import_Activator.Activator.createInstance(Type, item));
     }
+    const parsingFunction = ComplexTypeResolver.tryGetTypeParsingFunction(runtimeName, resultType);
+    if (parsingFunction) {
+      return parsingFunction(ic);
+    }
+    const activatorDetails = this.tryGetValueFromTypeMap(resultType);
     if (!activatorDetails) {
       throw new Error(`No type registered for key '${resultType}'.`);
     }
-    return new /** @type {any} */
-    activatorDetails.type(...activatorDetails.arguments);
+    if (runtimeName === import_RuntimeName.RuntimeName.Nodejs) {
+      const value = await ic.getValue();
+      if (value) {
+        if (value instanceof activatorDetails.Type) {
+          return value;
+        }
+      }
+    }
+    return import_Activator.Activator.createInstance(activatorDetails.Type, activatorDetails.arguments ?? null);
   }
   /**
    * Resolve type from string name and optional module
@@ -121,6 +127,50 @@ class ComplexTypeResolver {
     }
     return typeObj;
   }
+  /**
+   * Attempts to extract the underlying element type from an array type string
+   * @param {string} type - The type string to parse (e.g., "MyType[]")
+   * @returns {string | null} Object indicating success and the element type
+   * @throws {Error} If the array element type is a primitive type
+   */
+  static tryGetUnderlyingArrayType(type) {
+    if (typeof type !== "string" || !type.includes("[")) {
+      return null;
+    }
+    let trimmedType = type.trim();
+    if (!trimmedType) return null;
+    const commaIndex = trimmedType.indexOf(",");
+    if (commaIndex > 0) {
+      trimmedType = trimmedType.substring(0, commaIndex).trim();
+    }
+    const bracketIndex = trimmedType.indexOf("[");
+    if (bracketIndex > 0) {
+      trimmedType = trimmedType.substring(0, bracketIndex).trim();
+    }
+    if (import_Primitives.PrimitiveSet.has(trimmedType)) {
+      throw new Error("Primitive array element types are not supported.");
+    }
+    return trimmedType;
+  }
+  /**
+   * @param {RuntimeName} runtimeName
+   * @param {string} resultType
+   * @returns {any}
+   */
+  static tryGetTypeParsingFunction(runtimeName, resultType) {
+    const runtimeDict = typeParsingFunctions.get(runtimeName);
+    return runtimeDict ? runtimeDict.get(resultType) ?? null : null;
+  }
+  /**
+   * @param {string} resultType
+   * @returns {ActivatorDetails | null}
+   */
+  tryGetValueFromTypeMap(resultType) {
+    if (!resultType) {
+      throw new Error("resultType is not valid");
+    }
+    return this.#typeMap.get(resultType) ?? null;
+  }
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

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

@@ -1,5 +1,12 @@
 export type RuntimeName = import("../../types.d.ts").RuntimeName;
 export class Handler {
+    /**
+     * Prefer innerException (or cause) when available.
+     * @param {any} error
+     * @param {Command} command
+     * @returns {Command}
+     */
+    static resolveException(error: any, command: Command): Command;
     /**
      * @param {import('../interpreter/Interpreter.js').Interpreter} interpreter
      */
@@ -7,8 +14,9 @@ export class Handler {
     interpreter: import("../interpreter/Interpreter.js").Interpreter;
     /**
      * @param {Command} command
+     * @returns {Promise<Command> | Command}
      */
-    handleCommand(command: Command): Command | Promise<Command>;
+    handleCommand(command: Command): Promise<Command> | Command;
     /**
      * @param {any} response
      * @param {RuntimeName} runtimeName

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

@@ -68,9 +68,9 @@ export class PassDelegateHandler extends AbstractHandler {
     /**
      * Creates a method call to execute the command.
      * @param {Command} command - The command object.
-     * @returns {any} The response object.
+     * @returns {Promise<any>} The response object.
      */
-    createExecuteCall(command: Command): any;
+    createExecuteCall(command: Command): Promise<any>;
     /**
      * Retrieves the response payload from the execution call.
      * @param {Object<string, any>} executeCall - Object containing the execution call.

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

@@ -0,0 +1,17 @@
+export class RegisterForUpdateHandler extends AbstractHandler {
+    static _invocationContexts: {
+        Value: Map<any, any>;
+    };
+    /**
+     * Ensure context map exists and return it.
+     * @returns {Map<string, any>}
+     */
+    static getOrCreateContextMap(): Map<string, any>;
+    requiredParametersCount: number;
+    /**
+     * @param {any} command
+     * @returns {any}
+     */
+    process(command: any): any;
+}
+import { AbstractHandler } from './AbstractHandler.js';

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

@@ -0,0 +1,7 @@
+export class ValueForUpdateHandler extends AbstractHandler {
+    /**
+     * @param {any} command
+     */
+    process(command: any): void;
+}
+import { AbstractHandler } from './AbstractHandler.js';

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

@@ -7,9 +7,9 @@ export class Interpreter {
      *
      * @param {Command} command
      * @param {IConnectionData} connectionData
-     * @returns {Command | Promise<Command>}
+     * @returns {Promise<Command>}
      */
-    execute(command: Command, connectionData: IConnectionData): Command | Promise<Command>;
+    execute(command: Command, connectionData: IConnectionData): Promise<Command>;
     /**
      *
      * @param {Uint8Array} messageByteArray

data/lib/javonet-ruby-sdk/Binaries/Nodejs/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 {Promise<Command> | Command} rootCommand
+     * @param {Command} rootCommand
      * @param {IConnectionData} connectionData
      * @param {number} runtimeVersion
-     * @returns {Promise<Uint8Array> | Uint8Array}
+     * @returns {Uint8Array}
      */
-    serialize(rootCommand: Promise<Command> | Command, connectionData: IConnectionData, runtimeVersion?: number): Promise<Uint8Array> | Uint8Array;
+    serialize(rootCommand: Command, connectionData: IConnectionData, runtimeVersion?: number): Uint8Array;
     /**
      * Recursively serializes command payload.
      * @param {Command} command

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

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

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

@@ -0,0 +1,12 @@
+/**
+ * Details for activating a type with constructor arguments
+ */
+export class Activator {
+    /**
+     * Create a new instance of a type
+     * @param {Function} Type - The constructor function/class
+     * @param {any[] | any} args - The arguments to pass to the constructor
+     * @returns {any} The new instance
+     */
+    static createInstance(Type: Function, args: any[] | any): any;
+}

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

@@ -4,9 +4,11 @@
 export class ActivatorDetails {
     /**
      * @param {Function} type - The constructor function/class
-     * @param {any[]} [args] - Arguments to pass to constructor
+     * @param {any[]|any} [args] - Arguments to pass to constructor (array or single value)
      */
-    constructor(type: Function, args?: any[]);
-    type: Function;
+    constructor(type: Function, args?: any[] | any);
+    /** @type {Function} */
+    Type: Function;
+    /** @type {any[]} */
     arguments: any[];
 }

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

@@ -65,6 +65,13 @@ export class ConfigRuntimeFactory {
      * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/foundations/runtime-context)
      */
     nodejs(configName?: string): RuntimeContext;
+    /**
+     * Creates RuntimeContext instance to interact with the Php runtime.
+     * @param {string} [configName="default"] - The name of the configuration to use (optional).
+     * @return {RuntimeContext} a RuntimeContext instance for the Php runtime
+     * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/foundations/runtime-context)
+     */
+    php(configName?: string): RuntimeContext;
     /**
      * Creates RuntimeContext instance to interact with the Python 2.7 runtime.
      * @param {string} [configName="default"] - The name of the configuration to use (optional).

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

@@ -1,9 +1,5 @@
 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.
@@ -12,6 +8,7 @@ export type IConnectionData = import("../utils/connectionData/IConnectionData.js
  * @class
  */
 export class InvocationContext {
+    static _invocationContexts: Map<any, any>;
     /**
      *
      * @param {RuntimeNameType} runtimeName
@@ -20,22 +17,21 @@ export class InvocationContext {
      * @param {boolean} isExecuted
      */
     constructor(runtimeName: RuntimeNameType, connectionData: IConnectionData, command: Command, isExecuted?: boolean);
+    /**
+     * @returns {string} guid of this InvocationContext
+     */
+    getGuid(): string;
     /**
      * @returns {Command|null}
      */
-    get_current_command(): Command | null;
+    getCurrentCommand(): 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.
-     * 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<InvocationContext> | InvocationContext} the InvocationContext after executing the command.
-     * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/foundations/execute-method)
+     * Returns the InvocationContext after executing the command.
+     * @returns {Promise<InvocationContext>}
      * @method
      */
-    execute(): Promise<InvocationContext> | InvocationContext;
+    execute(): Promise<InvocationContext>;
     /**
      * Invokes a static method on the target runtime.
      * @param {string} methodName - The name of the method to invoke.
@@ -64,9 +60,10 @@ export class InvocationContext {
     setStaticField(fieldName: string, value: any): InvocationContext;
     /**
      * Creates a new instance of a class in the target runtime.
+     * Adds the newly created context to the static invocation contexts map and
+     * includes the context GUID as the first argument of CreateClassInstance command payload.
      * @param {...any} args - The arguments to pass to the class constructor
      * @returns {InvocationContext} A new InvocationContext instance that wraps the command to create the instance.
-     * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/calling-methods/creating-instance-and-calling-instance-methods)
      * @method
      */
     createInstance(...args: any[]): InvocationContext;
@@ -196,11 +193,11 @@ export class InvocationContext {
     getInstanceMethodAsDelegate(methodName: string, ...args: any[]): InvocationContext;
     /**
      * Retrieves the type of the object from the target runtime.
-     * @returns {Promise<string> | string} The type of the object.
+     * @returns {Promise<string>} The type of the object.
      * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/type-handling/getting-object-type)
      * @method
      */
-    getResultType(): Promise<string> | string;
+    getResultType(): Promise<string>;
     /**
      * Retrieves the name of the runtime where the command is executed.
      * @returns {number} The name of the runtime.
@@ -210,6 +207,7 @@ export class InvocationContext {
     getRuntimeName(): number;
     /**
      * Retrieves an array from the target runtime.
+     * @async
      * @returns {Promise<any[]>}
      * @method
      */
@@ -222,12 +220,12 @@ export class InvocationContext {
      * @method
      */
     getValue(): unknown;
-    [Symbol.iterator]: () => {
-        next: () => {
-            value: InvocationContext;
-            done: boolean;
-        };
-    };
+    /**
+     * Async iterator for InvocationContext arrays
+     * Use: for await (const item of invocationContext) { ... }
+     * @returns {AsyncGenerator<InvocationContext, void, unknown>}
+     */
+    [Symbol.asyncIterator](): AsyncGenerator<InvocationContext, void, unknown>;
     #private;
 }
 import { Command } from '../utils/Command.js';

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

@@ -77,7 +77,8 @@ 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 { ComplexTypeResolver } from './tools/ComplexTypeResolver.js';
 import { RuntimeFactory } from './RuntimeFactory.js';
 import { ConfigRuntimeFactory } from './ConfigRuntimeFactory.js';
 import { RuntimeContext } from './RuntimeContext.js';
-export { TcpConnectionData, WsConnectionData, CommandSerializer, CommandDeserializer, ConfigPriority };
+export { TcpConnectionData, WsConnectionData, CommandSerializer, CommandDeserializer, ConfigPriority, ComplexTypeResolver };

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

@@ -40,20 +40,21 @@ export class 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)
+     * @returns {Promise<void>}
      * @method
      */
-    execute(): void;
+    execute(): Promise<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.
+     * @returns {Promise<RuntimeContext>} RuntimeContext instance.
      * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/getting-started/adding-references-to-libraries)
      * @method
      */
-    loadLibrary(libraryPath: string): RuntimeContext;
+    loadLibrary(libraryPath: string): Promise<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.

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

@@ -1,7 +1,24 @@
 export class ConfigSourceResolver {
-    static addConfigs(priority: any, configSource: any): void;
-    static getConfig(configName: any): any;
+    /**
+     * @param {import('./ConfigPriority.js').ConfigPriority} priority
+     * @param {string | any} configSource
+     */
+    static addConfigs(priority: any, configSource: string | any): void;
+    /**
+     * @param {string} configName
+     * @returns {*}
+     */
+    static getConfig(configName: string): any;
     static clearConfigs(): void;
-    static _getConfigSourceAsString(configSource: any): any;
-    static _parseConfigsAndAddToCollection(priority: any, configString: any): void;
+    /**
+     * @param {string} configSource
+     * @returns {string}
+     */
+    static _getConfigSourceAsString(configSource: string): string;
+    /**
+     * @param {import('./ConfigPriority.js').ConfigPriority} priority
+     * @param {string} configString
+     * @returns
+     */
+    static _parseConfigsAndAddToCollection(priority: any, configString: string): void;
 }

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

@@ -1,7 +1,4 @@
 export type RuntimeName = import("../../types.d.ts").RuntimeName;
-/**
- * @typedef {import('../../types.d.ts').RuntimeName} RuntimeName
- */
 export class ComplexTypeResolver {
     /**
      * Resolve type from string name and optional module
@@ -10,6 +7,19 @@ export class ComplexTypeResolver {
      * @returns {Function} The resolved type/constructor function
      */
     static resolveType(typeName: string, moduleName?: string): Function;
+    /**
+     * Attempts to extract the underlying element type from an array type string
+     * @param {string} type - The type string to parse (e.g., "MyType[]")
+     * @returns {string | null} Object indicating success and the element type
+     * @throws {Error} If the array element type is a primitive type
+     */
+    static tryGetUnderlyingArrayType(type: string): string | null;
+    /**
+     * @param {RuntimeName} runtimeName
+     * @param {string} resultType
+     * @returns {any}
+     */
+    static tryGetTypeParsingFunction(runtimeName: RuntimeName, resultType: string): any;
     /**
      * Register a custom type mapping
      * @param {string} resultType - The type name from the target runtime
@@ -20,9 +30,15 @@ export class ComplexTypeResolver {
     /**
      * Convert InvocationContext result to appropriate JavaScript type
      * @param {InvocationContext} ic - The invocation context
-     * @returns {Promise<any> | any} The converted result
+     * @returns {Promise<any>} The converted result
+     */
+    convertResult(ic: InvocationContext): Promise<any>;
+    /**
+     * @param {string} resultType
+     * @returns {ActivatorDetails | null}
      */
-    convertResult(ic: InvocationContext): Promise<any> | any;
+    tryGetValueFromTypeMap(resultType: string): ActivatorDetails | null;
     #private;
 }
 import { InvocationContext } from '../InvocationContext.js';
+import { ActivatorDetails } from '../ActivatorDetails.js';

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

@@ -47,4 +47,6 @@ export namespace CommandType {
     let AsKwargs: 45;
     let GetResultType: 46;
     let GetGlobalField: 47;
+    let RegisterForUpdate: 48;
+    let ValueForUpdate: 49;
 }

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

@@ -0,0 +1,5 @@
+/**
+ * Set of primitive type names that are not supported as array element types
+ * @type {Set<string>}
+ */
+export const PrimitiveSet: Set<string>;

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

@@ -71,7 +71,9 @@ const CommandType = (
     GetAsyncOperationResult: 44,
     AsKwargs: 45,
     GetResultType: 46,
-    GetGlobalField: 47
+    GetGlobalField: 47,
+    RegisterForUpdate: 48,
+    ValueForUpdate: 49
   }
 );
 // Annotate the CommonJS export names for ESM import in node: