javonet-nodejs-sdk 2.6.7 → 2.6.8

package/dist/sdk/configuration/ConfigSourceResolver.cjs

@@ -1,9 +1,7 @@
 "use strict";
-var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -17,32 +15,39 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var ConfigSourceResolver_exports = {};
 __export(ConfigSourceResolver_exports, {
   ConfigSourceResolver: () => ConfigSourceResolver
 });
 module.exports = __toCommonJS(ConfigSourceResolver_exports);
-var import_fs = __toESM(require("fs"), 1);
-var import_process = __toESM(require("process"), 1);
 var import_ConfigsDictionary = require("./ConfigsDictionary.cjs");
 var import_JsonConfigResolver = require("./configResolvers/JsonConfigResolver.cjs");
 var import_YamlConfigResolver = require("./configResolvers/YamlConfigResolver.cjs");
 var import_ConnectionStringConfigResolver = require("./configResolvers/ConnectionStringConfigResolver.cjs");
+var import_Runtime = require("../../utils/Runtime.cjs");
+const import_meta = {};
+let fs = null;
+let process = null;
+const requireDynamic = (0, import_Runtime.getRequire)(import_meta.url);
 class ConfigSourceResolver {
+  /**
+   * @param {import('./ConfigPriority.js').ConfigPriority} priority
+   * @param {string | any} configSource
+   */
   static addConfigs(priority, configSource) {
     console.log(`Adding config from source: ${configSource} with priority '${priority}'`);
-    const configString = ConfigSourceResolver._getConfigSourceAsString(configSource);
-    ConfigSourceResolver._parseConfigsAndAddToCollection(priority, configString);
+    if (configSource && typeof configSource === "object") {
+      import_JsonConfigResolver.JsonConfigResolver.addConfigs(priority, configSource);
+    } else {
+      const configString = ConfigSourceResolver._getConfigSourceAsString(configSource);
+      ConfigSourceResolver._parseConfigsAndAddToCollection(priority, configString);
+    }
   }
+  /**
+   * @param {string} configName
+   * @returns {*}
+   */
   static getConfig(configName) {
     console.log(`Retrieving config ${configName}`);
     return import_ConfigsDictionary.ConfigsDictionary.getConfig(configName);
@@ -50,19 +55,36 @@ class ConfigSourceResolver {
   static clearConfigs() {
     import_ConfigsDictionary.ConfigsDictionary.clearConfigs();
   }
+  /**
+   * @param {string} configSource
+   * @returns {string}
+   */
   static _getConfigSourceAsString(configSource) {
     if (!configSource || configSource.trim() === "") {
       throw new Error("Config source cannot be null or whitespace.");
     }
-    const envValue = import_process.default.env[configSource];
-    if (envValue && envValue.trim() !== "") {
-      configSource = envValue;
-    }
-    if (import_fs.default.existsSync(configSource) && import_fs.default.statSync(configSource).isFile()) {
-      configSource = import_fs.default.readFileSync(configSource, { encoding: "utf-8" });
+    if ((0, import_Runtime.isNodejsRuntime)()) {
+      if (!process) {
+        process = requireDynamic("process");
+      }
+      if (!fs) {
+        fs = requireDynamic("fs");
+      }
+      const envValue = process?.env[configSource];
+      if (envValue && envValue.trim() !== "") {
+        configSource = envValue;
+      }
+      if (fs?.existsSync(configSource) && fs?.statSync(configSource).isFile()) {
+        configSource = fs.readFileSync(configSource, { encoding: "utf-8" });
+      }
     }
     return configSource.trim();
   }
+  /**
+   * @param {import('./ConfigPriority.js').ConfigPriority} priority
+   * @param {string} configString
+   * @returns
+   */
   static _parseConfigsAndAddToCollection(priority, configString) {
     try {
       const jsonObject = JSON.parse(configString);
@@ -78,7 +100,7 @@ class ConfigSourceResolver {
       import_YamlConfigResolver.YamlConfigResolver.addConfigs(priority, configString);
       return;
     } catch (ex) {
-      if (ex.name === "SyntaxError") {
+      if (ex?.name === "SyntaxError") {
       } else {
         console.log("Failed to parse config source as YAML: " + ex);
       }

package/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 = {

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

@@ -7,8 +7,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

package/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.

package/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

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 {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

package/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';

package/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;
+}

package/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[];
 }

package/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).

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 {Promise<InvocationContext> | InvocationContext} the InvocationContext after executing the command.
+     * @returns {Promise<InvocationContext>} the InvocationContext after executing the command.
      * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/foundations/execute-method)
      * @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.
@@ -196,11 +196,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 +210,7 @@ export class InvocationContext {
     getRuntimeName(): number;
     /**
      * Retrieves an array from the target runtime.
+     * @async
      * @returns {Promise<any[]>}
      * @method
      */
@@ -222,12 +223,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';

package/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 };

package/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.

package/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;
 }

package/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';

package/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>;