@mionjs/client 0.8.0-alpha.0

package/.dist/esm/_virtual/jit-fns.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"jit-fns.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/.dist/esm/_virtual/pure-fns.js

@@ -0,0 +1,109 @@
+const pureFnsCache = { mion: { asJSONString: { namespace: "mion", paramNames: [], code: `if (typeof Bun !== "undefined") return JSON.stringify;
+  const STR_ESCAPE = /[\\u0000-\\u001f\\u0022\\u005c\\ud800-\\udfff]/;
+  const MAX_SCAPE_TEST_LENGTH = 1e3;
+  return function _asJSONStringRegexOnly(str) {
+    if (str.length < MAX_SCAPE_TEST_LENGTH && STR_ESCAPE.test(str) === false) {
+      return '"' + str + '"';
+    } else {
+      return JSON.stringify(str);
+    }
+  };`, fnName: "asJSONString", bodyHash: "4WYkR03dXOzAUe", pureFnDependencies: [], createPureFn: function() {
+  if (typeof Bun < "u") return JSON.stringify;
+  const STR_ESCAPE = /[\u0000-\u001f\u0022\u005c\ud800-\udfff]/, MAX_SCAPE_TEST_LENGTH = 1e3;
+  return function(str) {
+    return str.length < MAX_SCAPE_TEST_LENGTH && STR_ESCAPE.test(str) === !1 ? '"' + str + '"' : JSON.stringify(str);
+  };
+}, fn: void 0 }, getUnknownKeysFromArray: { namespace: "mion", paramNames: [], code: `const MAX_UNKNOWN_KEYS = 10;
+  return function _getUnknownKeysFromArray(obj, keys) {
+    const unknownKeys = [];
+    for (const prop in obj) {
+      let found = false;
+      for (let j = 0; j < keys.length; j++) {
+        if (keys[j] === prop) {
+          found = true;
+          break;
+        }
+      }
+      if (!found) {
+        unknownKeys.push(prop);
+        if (unknownKeys.length >= MAX_UNKNOWN_KEYS) throw new Error("Too many unknown keys");
+      }
+    }
+    return unknownKeys;
+  };`, fnName: "getUnknownKeysFromArray", bodyHash: "D2CDXI8OoGLGyW", pureFnDependencies: [], createPureFn: function() {
+  return function(obj, keys) {
+    const unknownKeys = [];
+    for (const prop in obj) {
+      let found = !1;
+      for (let j = 0; j < keys.length; j++)
+        if (keys[j] === prop) {
+          found = !0;
+          break;
+        }
+      if (!found && (unknownKeys.push(prop), unknownKeys.length >= 10))
+        throw new Error("Too many unknown keys");
+    }
+    return unknownKeys;
+  };
+}, fn: void 0 }, hasUnknownKeysFromArray: { namespace: "mion", paramNames: [], code: `return function _hasUnknownKeysFromArray(obj, keys) {
+    for (const prop in obj) {
+      let found = false;
+      for (let j = 0; j < keys.length; j++) {
+        if (keys[j] === prop) {
+          found = true;
+          break;
+        }
+      }
+      if (!found) return true;
+    }
+    return false;
+  };`, fnName: "hasUnknownKeysFromArray", bodyHash: "K7uzDGNnPwcqQ9", pureFnDependencies: [], createPureFn: function() {
+  return function(obj, keys) {
+    for (const prop in obj) {
+      let found = !1;
+      for (let j = 0; j < keys.length; j++)
+        if (keys[j] === prop) {
+          found = !0;
+          break;
+        }
+      if (!found) return !0;
+    }
+    return !1;
+  };
+}, fn: void 0 }, newRunTypeErr: { namespace: "mion", paramNames: [], code: `return function _err(p\\u03BBth, \\u03B5rr, expected, accessPath) {
+    const path = accessPath?.length ? [...p\\u03BBth, ...accessPath] : [...p\\u03BBth];
+    const runTypeErr = { expected, path };
+    \\u03B5rr.push(runTypeErr);
+  };`, fnName: "newRunTypeErr", bodyHash: "eCwDrS1nuSv7ge", pureFnDependencies: [], createPureFn: function() {
+  return function(pλth, εrr, expected, accessPath) {
+    const path = accessPath?.length ? [...pλth, ...accessPath] : [...pλth], runTypeErr = { expected, path };
+    εrr.push(runTypeErr);
+  };
+}, fn: void 0 }, formatErr: { namespace: "mion", paramNames: [], code: `return function _formatErr(p\\u03BBth, \\u03B5rr, expected, fmtName, paramName, paramVal, fmtPath, accessPath, fmtAccessPath) {
+    const path = accessPath?.length ? [...p\\u03BBth, ...accessPath] : [...p\\u03BBth];
+    const formatPath = fmtAccessPath?.length ? [...fmtPath, ...fmtAccessPath, paramName] : [...fmtPath, paramName];
+    const format = { name: fmtName, formatPath, val: paramVal };
+    const runTypeErr = { expected, path, format };
+    \\u03B5rr.push(runTypeErr);
+  };`, fnName: "formatErr", bodyHash: "2isPiuLWPtohVR", pureFnDependencies: [], createPureFn: function() {
+  return function(pλth, εrr, expected, fmtName, paramName, paramVal, fmtPath, accessPath, fmtAccessPath) {
+    const path = accessPath?.length ? [...pλth, ...accessPath] : [...pλth], formatPath = fmtAccessPath?.length ? [...fmtPath, ...fmtAccessPath, paramName] : [...fmtPath, paramName], runTypeErr = { expected, path, format: { name: fmtName, formatPath, val: paramVal } };
+    εrr.push(runTypeErr);
+  };
+}, fn: void 0 }, safeIterableKey: { namespace: "mion", paramNames: [], code: `return function _safeKey(value) {
+    if (value === void 0) return null;
+    if (value === null) return null;
+    const type = typeof value;
+    if (type === "number" || type === "string" || type === "boolean") return value;
+    return null;
+  };`, fnName: "safeIterableKey", bodyHash: "BrjL47E-GRjUpQ", pureFnDependencies: [], createPureFn: function() {
+  return function(value) {
+    if (value === void 0 || value === null) return null;
+    const type = typeof value;
+    return type === "number" || type === "string" || type === "boolean" ? value : null;
+  };
+}, fn: void 0 } } };
+export {
+  pureFnsCache
+};
+//# sourceMappingURL=pure-fns.js.map

package/.dist/esm/_virtual/pure-fns.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pure-fns.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/.dist/esm/_virtual/router-cache.js

@@ -0,0 +1,5 @@
+const routerCache = { "@thrownErrors": { paramNames: [], type: 1, id: "@thrownErrors", isAsync: !1, hasReturnData: !0, paramsJitHash: "", returnJitHash: "cm6MsK", pointer: ["@thrownErrors"], nestLevel: 0, options: { runOnError: !1, validateParams: !0, validateReturn: !1, serializer: "json" } }, "mion@notFound": { paramNames: [], type: 1, id: "mion@notFound", isAsync: !1, hasReturnData: !0, paramsJitHash: "", returnJitHash: "a8UQwC", pointer: ["mion@notFound"], nestLevel: 0, options: { runOnError: !1, validateParams: !0, validateReturn: !1, serializer: "json" } }, "mion@platformError": { paramNames: [], type: 1, id: "mion@platformError", isAsync: !1, hasReturnData: !0, paramsJitHash: "", returnJitHash: "zxRrbt", pointer: ["mion@platformError"], nestLevel: 0, options: { runOnError: !1, validateParams: !0, validateReturn: !1, serializer: "json" } }, "mion@methodsMetadataById": { paramNames: ["methodsIds", "getAllRemoteMethods"], type: 1, id: "mion@methodsMetadataById", isAsync: !1, hasReturnData: !0, paramsJitHash: "JtnVhp", returnJitHash: "rFrbJx", pointer: ["mion@methodsMetadataById"], nestLevel: 0, options: { runOnError: !1, validateParams: !0, validateReturn: !1, serializer: "stringifyJson" } }, "mion@methodsMetadataByPath": { paramNames: ["path", "getAllRemoteMethods"], type: 1, id: "mion@methodsMetadataByPath", isAsync: !1, hasReturnData: !0, paramsJitHash: "hZzD9z", returnJitHash: "rFrbJx", pointer: ["mion@methodsMetadataByPath"], nestLevel: 0, options: { runOnError: !1, validateParams: !0, validateReturn: !1, serializer: "stringifyJson" } }, "mion@mionEmptyMiddleFn": { paramNames: [], type: 2, id: "mion@mionEmptyMiddleFn", isAsync: !1, hasReturnData: !1, paramsJitHash: "", returnJitHash: "", pointer: ["mion@mionEmptyMiddleFn"], nestLevel: 0, options: { runOnError: !1, validateParams: !0, validateReturn: !1 } } };
+export {
+  routerCache
+};
+//# sourceMappingURL=router-cache.js.map

package/.dist/esm/_virtual/router-cache.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"router-cache.js","sources":[],"sourcesContent":[],"names":[],"mappings":";"}

package/.dist/esm/index.d.ts

@@ -0,0 +1,11 @@
+export * from './src/types.ts';
+export * from './src/constants.ts';
+export * from './src/storage.ts';
+export * from './src/validation.ts';
+export * from './src/serializer.ts';
+export * from './src/clientMethodsMetadata.ts';
+export * from './src/request.ts';
+export * from './src/client.ts';
+export * from './src/typedEvent.ts';
+export * from './src/handlersRegistry.ts';
+export * from './src/routesFlow.ts';

package/.dist/esm/index.js

@@ -0,0 +1,80 @@
+import { __ΩCallWithMiddleFnsResult, __ΩCleaned, __ΩClientMiddleFns, __ΩClientOptions, __ΩClientRoutes, __ΩErrorHandler, __ΩFailResponse, __ΩFailResponses, __ΩHSubRequest, __ΩHandlerErrors, __ΩHandlerFailResponse, __ΩHandlerResponse, __ΩHandlerSuccessResponse, __ΩHeadersParamsType, __ΩInitClientOptions, __ΩMiddleFnError, __ΩMiddleFnSuccess, __ΩNonClientMiddleFn, __ΩNonClientRoute, __ΩPrefilledMiddleFnsCache, __ΩRSubRequest, __ΩRequestBody, __ΩRequestErrors, __ΩRequestHeaders, __ΩResult, __ΩRouteParamType, __ΩRouteParamsType, __ΩRouteReturnType, __ΩSubRequest, __ΩSuccessClientResponse, __ΩSuccessHandler, __ΩSuccessResponse, __ΩSuccessResponses, __ΩUnknownErrorHandler, __ΩWorkflowResult, __ΩWorkflowRouteErrors, __ΩWorkflowRouteResults } from "./src/types.js";
+import { DEFAULT_PREFILL_OPTIONS, MAX_GET_URL_LENGTH, ROUTES_FLOW_KEY, ROUTES_FLOW_PATH, STORAGE_KEY } from "./src/constants.js";
+import { MemoryStorage, getStorage, resetStorageInstance } from "./src/storage.js";
+import { validateSubRequest, validateSubRequests } from "./src/validation.js";
+import { __ΩContentType, __ΩSerializedBody, __ΩSerializedRequest, deserializeResponseBody, serializeRequestBody } from "./src/serializer.js";
+import { fetchRemoteMethodsMetadata, getAOTCaches, restoreAllDependencies, storeDependencies, storeMethodsMetadata } from "./src/clientMethodsMetadata.js";
+import { MionClientRequest } from "./src/request.js";
+import { MionClient, initClient } from "./src/client.js";
+import { TypedEvent } from "./src/typedEvent.js";
+import { HandlersRegistry } from "./src/handlersRegistry.js";
+import { isMapFromRef, mapFrom, mapFromSymbol, routesFlow } from "./src/routesFlow.js";
+export {
+  DEFAULT_PREFILL_OPTIONS,
+  HandlersRegistry,
+  MAX_GET_URL_LENGTH,
+  MemoryStorage,
+  MionClient,
+  MionClientRequest,
+  ROUTES_FLOW_KEY,
+  ROUTES_FLOW_PATH,
+  STORAGE_KEY,
+  TypedEvent,
+  __ΩCallWithMiddleFnsResult,
+  __ΩCleaned,
+  __ΩClientMiddleFns,
+  __ΩClientOptions,
+  __ΩClientRoutes,
+  __ΩContentType,
+  __ΩErrorHandler,
+  __ΩFailResponse,
+  __ΩFailResponses,
+  __ΩHSubRequest,
+  __ΩHandlerErrors,
+  __ΩHandlerFailResponse,
+  __ΩHandlerResponse,
+  __ΩHandlerSuccessResponse,
+  __ΩHeadersParamsType,
+  __ΩInitClientOptions,
+  __ΩMiddleFnError,
+  __ΩMiddleFnSuccess,
+  __ΩNonClientMiddleFn,
+  __ΩNonClientRoute,
+  __ΩPrefilledMiddleFnsCache,
+  __ΩRSubRequest,
+  __ΩRequestBody,
+  __ΩRequestErrors,
+  __ΩRequestHeaders,
+  __ΩResult,
+  __ΩRouteParamType,
+  __ΩRouteParamsType,
+  __ΩRouteReturnType,
+  __ΩSerializedBody,
+  __ΩSerializedRequest,
+  __ΩSubRequest,
+  __ΩSuccessClientResponse,
+  __ΩSuccessHandler,
+  __ΩSuccessResponse,
+  __ΩSuccessResponses,
+  __ΩUnknownErrorHandler,
+  __ΩWorkflowResult,
+  __ΩWorkflowRouteErrors,
+  __ΩWorkflowRouteResults,
+  deserializeResponseBody,
+  fetchRemoteMethodsMetadata,
+  getAOTCaches,
+  getStorage,
+  initClient,
+  isMapFromRef,
+  mapFrom,
+  mapFromSymbol,
+  resetStorageInstance,
+  restoreAllDependencies,
+  routesFlow,
+  serializeRequestBody,
+  storeDependencies,
+  storeMethodsMetadata,
+  validateSubRequest,
+  validateSubRequests
+};
+//# sourceMappingURL=index.js.map

package/.dist/esm/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;"}

package/.dist/esm/src/aot/loadClientAOTCaches.d.ts

@@ -0,0 +1,8 @@
+import { InitClientOptions } from '../types.ts';
+import { RemoteApi } from '@mionjs/router';
+export declare function loadClientAotCaches(): void;
+export declare function initAOTClient<RM extends RemoteApi>(options: InitClientOptions): {
+    client: import('../client.ts').MionClient;
+    routes: { [Property in keyof RM as RM[Property] extends import('../types.ts').NonClientRoute ? never : Property]: RM[Property] extends import('@mionjs/router').PublicRoute<any> ? (...params: Parameters<RM[Property]["handler"]>) => import('../types.ts').RSubRequest<RM[Property]["handler"]> : RM[Property] extends RemoteApi ? (RM[Property] extends infer T_2 extends RemoteApi ? { [Property_2 in keyof T_2 as RM[Property][Property_2] extends import('../types.ts').NonClientRoute ? never : Property_2]: T_2[Property_2] extends import('@mionjs/router').PublicRoute<any> ? (...params: Parameters<T_2[Property_2]["handler"]>) => import('../types.ts').RSubRequest<T_2[Property_2]["handler"]> : T_2[Property_2] extends RemoteApi ? (T_2[Property_2] extends infer T_4 extends RemoteApi ? { [Property_3 in keyof T_4 as T_2[Property_2][Property_3] extends import('../types.ts').NonClientRoute ? never : Property_3]: T_4[Property_3] extends import('@mionjs/router').PublicRoute<any> ? (...params: Parameters<T_4[Property_3]["handler"]>) => import('../types.ts').RSubRequest<T_4[Property_3]["handler"]> : T_4[Property_3] extends RemoteApi ? (T_4[Property_3] extends infer T_6 extends RemoteApi ? { [Property_4 in keyof T_6 as T_4[Property_3][Property_4] extends import('../types.ts').NonClientRoute ? never : Property_4]: T_6[Property_4] extends import('@mionjs/router').PublicRoute<any> ? (...params: Parameters<T_6[Property_4]["handler"]>) => import('../types.ts').RSubRequest<T_6[Property_4]["handler"]> : T_6[Property_4] extends RemoteApi ? (T_6[Property_4] extends infer T_8 extends RemoteApi ? { [Property_5 in keyof T_8 as T_6[Property_4][Property_5] extends import('../types.ts').NonClientRoute ? never : Property_5]: T_8[Property_5] extends import('@mionjs/router').PublicRoute<any> ? (...params: Parameters<T_8[Property_5]["handler"]>) => import('../types.ts').RSubRequest<T_8[Property_5]["handler"]> : T_8[Property_5] extends RemoteApi ? (T_8[Property_5] extends infer T_10 extends RemoteApi ? { [Property_6 in keyof T_10 as T_8[Property_5][Property_6] extends import('../types.ts').NonClientRoute ? never : Property_6]: T_10[Property_6] extends import('@mionjs/router').PublicRoute<any> ? (...params: Parameters<T_10[Property_6]["handler"]>) => import('../types.ts').RSubRequest<T_10[Property_6]["handler"]> : T_10[Property_6] extends RemoteApi ? (T_10[Property_6] extends infer T_12 extends RemoteApi ? { [Property_7 in keyof T_12 as T_10[Property_6][Property_7] extends import('../types.ts').NonClientRoute ? never : Property_7]: T_12[Property_7] extends import('@mionjs/router').PublicRoute<any> ? (...params: Parameters<T_12[Property_7]["handler"]>) => import('../types.ts').RSubRequest<T_12[Property_7]["handler"]> : T_12[Property_7] extends RemoteApi ? (T_12[Property_7] extends infer T_14 extends RemoteApi ? { [Property_8 in keyof T_14 as T_12[Property_7][Property_8] extends import('../types.ts').NonClientRoute ? never : Property_8]: T_14[Property_8] extends import('@mionjs/router').PublicRoute<any> ? (...params: Parameters<T_14[Property_8]["handler"]>) => import('../types.ts').RSubRequest<T_14[Property_8]["handler"]> : T_14[Property_8] extends RemoteApi ? (T_14[Property_8] extends infer T_16 extends RemoteApi ? { [Property_9 in keyof T_16 as T_14[Property_8][Property_9] extends import('../types.ts').NonClientRoute ? never : Property_9]: T_16[Property_9] extends import('@mionjs/router').PublicRoute<any> ? (...params: Parameters<T_16[Property_9]["handler"]>) => import('../types.ts').RSubRequest<T_16[Property_9]["handler"]> : T_16[Property_9] extends RemoteApi ? (T_16[Property_9] extends infer T_18 extends RemoteApi ? { [Property_10 in keyof T_18 as T_16[Property_9][Property_10] extends import('../types.ts').NonClientRoute ? never : Property_10]: T_18[Property_10] extends import('@mionjs/router').PublicRoute<any> ? (...params: Parameters<T_18[Property_10]["handler"]>) => import('../types.ts').RSubRequest<T_18[Property_10]["handler"]> : T_18[Property_10] extends RemoteApi ? (T_18[Property_10] extends infer T_20 extends RemoteApi ? { [Property_11 in keyof T_20 as T_18[Property_10][Property_11] extends import('../types.ts').NonClientRoute ? never : Property_11]: T_20[Property_11] extends import('@mionjs/router').PublicRoute<any> ? (...params: Parameters<T_20[Property_11]["handler"]>) => import('../types.ts').RSubRequest<T_20[Property_11]["handler"]> : T_20[Property_11] extends RemoteApi ? any : never; } : never) extends infer T_19 ? { [P_10 in keyof T_19]: T_19[P_10]; } : never : never; } : never) extends infer T_17 ? { [P_9 in keyof T_17]: T_17[P_9]; } : never : never; } : never) extends infer T_15 ? { [P_8 in keyof T_15]: T_15[P_8]; } : never : never; } : never) extends infer T_13 ? { [P_7 in keyof T_13]: T_13[P_7]; } : never : never; } : never) extends infer T_11 ? { [P_6 in keyof T_11]: T_11[P_6]; } : never : never; } : never) extends infer T_9 ? { [P_5 in keyof T_9]: T_9[P_5]; } : never : never; } : never) extends infer T_7 ? { [P_4 in keyof T_7]: T_7[P_4]; } : never : never; } : never) extends infer T_5 ? { [P_3 in keyof T_5]: T_5[P_3]; } : never : never; } : never) extends infer T_3 ? { [P_2 in keyof T_3]: T_3[P_2]; } : never : never; } : never) extends infer T_1 ? { [P_1 in keyof T_1]: T_1[P_1]; } : never : never; } extends infer T ? { [P in keyof T]: T[P]; } : never;
+    middleFns: { [Property_1 in keyof RM as RM[Property_1] extends import('../types.ts').NonClientMiddleFn ? never : Property_1]: RM[Property_1] extends import('@mionjs/router').PublicMiddleFn<any> | import('@mionjs/router').PublicHeadersFn<any> ? (...params: Parameters<RM[Property_1]["handler"]>) => import('../types.ts').HSubRequest<RM[Property_1]["handler"]> : RM[Property_1] extends RemoteApi ? (RM[Property_1] extends infer T_3 extends RemoteApi ? { [Property_3 in keyof T_3 as RM[Property_1][Property_3] extends import('../types.ts').NonClientMiddleFn ? never : Property_3]: T_3[Property_3] extends import('@mionjs/router').PublicMiddleFn<any> | import('@mionjs/router').PublicHeadersFn<any> ? (...params: Parameters<T_3[Property_3]["handler"]>) => import('../types.ts').HSubRequest<T_3[Property_3]["handler"]> : T_3[Property_3] extends RemoteApi ? (T_3[Property_3] extends infer T_5 extends RemoteApi ? { [Property_4 in keyof T_5 as T_3[Property_3][Property_4] extends import('../types.ts').NonClientMiddleFn ? never : Property_4]: T_5[Property_4] extends import('@mionjs/router').PublicMiddleFn<any> | import('@mionjs/router').PublicHeadersFn<any> ? (...params: Parameters<T_5[Property_4]["handler"]>) => import('../types.ts').HSubRequest<T_5[Property_4]["handler"]> : T_5[Property_4] extends RemoteApi ? (T_5[Property_4] extends infer T_7 extends RemoteApi ? { [Property_5 in keyof T_7 as T_5[Property_4][Property_5] extends import('../types.ts').NonClientMiddleFn ? never : Property_5]: T_7[Property_5] extends import('@mionjs/router').PublicMiddleFn<any> | import('@mionjs/router').PublicHeadersFn<any> ? (...params: Parameters<T_7[Property_5]["handler"]>) => import('../types.ts').HSubRequest<T_7[Property_5]["handler"]> : T_7[Property_5] extends RemoteApi ? (T_7[Property_5] extends infer T_9 extends RemoteApi ? { [Property_6 in keyof T_9 as T_7[Property_5][Property_6] extends import('../types.ts').NonClientMiddleFn ? never : Property_6]: T_9[Property_6] extends import('@mionjs/router').PublicMiddleFn<any> | import('@mionjs/router').PublicHeadersFn<any> ? (...params: Parameters<T_9[Property_6]["handler"]>) => import('../types.ts').HSubRequest<T_9[Property_6]["handler"]> : T_9[Property_6] extends RemoteApi ? (T_9[Property_6] extends infer T_11 extends RemoteApi ? { [Property_7 in keyof T_11 as T_9[Property_6][Property_7] extends import('../types.ts').NonClientMiddleFn ? never : Property_7]: T_11[Property_7] extends import('@mionjs/router').PublicMiddleFn<any> | import('@mionjs/router').PublicHeadersFn<any> ? (...params: Parameters<T_11[Property_7]["handler"]>) => import('../types.ts').HSubRequest<T_11[Property_7]["handler"]> : T_11[Property_7] extends RemoteApi ? (T_11[Property_7] extends infer T_13 extends RemoteApi ? { [Property_8 in keyof T_13 as T_11[Property_7][Property_8] extends import('../types.ts').NonClientMiddleFn ? never : Property_8]: T_13[Property_8] extends import('@mionjs/router').PublicMiddleFn<any> | import('@mionjs/router').PublicHeadersFn<any> ? (...params: Parameters<T_13[Property_8]["handler"]>) => import('../types.ts').HSubRequest<T_13[Property_8]["handler"]> : T_13[Property_8] extends RemoteApi ? (T_13[Property_8] extends infer T_15 extends RemoteApi ? { [Property_9 in keyof T_15 as T_13[Property_8][Property_9] extends import('../types.ts').NonClientMiddleFn ? never : Property_9]: T_15[Property_9] extends import('@mionjs/router').PublicMiddleFn<any> | import('@mionjs/router').PublicHeadersFn<any> ? (...params: Parameters<T_15[Property_9]["handler"]>) => import('../types.ts').HSubRequest<T_15[Property_9]["handler"]> : T_15[Property_9] extends RemoteApi ? (T_15[Property_9] extends infer T_17 extends RemoteApi ? { [Property_10 in keyof T_17 as T_15[Property_9][Property_10] extends import('../types.ts').NonClientMiddleFn ? never : Property_10]: T_17[Property_10] extends import('@mionjs/router').PublicMiddleFn<any> | import('@mionjs/router').PublicHeadersFn<any> ? (...params: Parameters<T_17[Property_10]["handler"]>) => import('../types.ts').HSubRequest<T_17[Property_10]["handler"]> : T_17[Property_10] extends RemoteApi ? (T_17[Property_10] extends infer T_19 extends RemoteApi ? { [Property_11 in keyof T_19 as T_17[Property_10][Property_11] extends import('../types.ts').NonClientMiddleFn ? never : Property_11]: T_19[Property_11] extends import('@mionjs/router').PublicMiddleFn<any> | import('@mionjs/router').PublicHeadersFn<any> ? (...params: Parameters<T_19[Property_11]["handler"]>) => import('../types.ts').HSubRequest<T_19[Property_11]["handler"]> : T_19[Property_11] extends RemoteApi ? (T_19[Property_11] extends infer T_21 extends RemoteApi ? { [Property_12 in keyof T_21 as T_19[Property_11][Property_12] extends import('../types.ts').NonClientMiddleFn ? never : Property_12]: T_21[Property_12] extends import('@mionjs/router').PublicMiddleFn<any> | import('@mionjs/router').PublicHeadersFn<any> ? (...params: Parameters<T_21[Property_12]["handler"]>) => import('../types.ts').HSubRequest<T_21[Property_12]["handler"]> : T_21[Property_12] extends RemoteApi ? any : never; } : never) extends infer T_20 ? { [P_11 in keyof T_20]: T_20[P_11]; } : never : never; } : never) extends infer T_18 ? { [P_10 in keyof T_18]: T_18[P_10]; } : never : never; } : never) extends infer T_16 ? { [P_9 in keyof T_16]: T_16[P_9]; } : never : never; } : never) extends infer T_14 ? { [P_8 in keyof T_14]: T_14[P_8]; } : never : never; } : never) extends infer T_12 ? { [P_7 in keyof T_12]: T_12[P_7]; } : never : never; } : never) extends infer T_10 ? { [P_6 in keyof T_10]: T_10[P_6]; } : never : never; } : never) extends infer T_8 ? { [P_5 in keyof T_8]: T_8[P_5]; } : never : never; } : never) extends infer T_6 ? { [P_4 in keyof T_6]: T_6[P_4]; } : never : never; } : never) extends infer T_4 ? { [P_3 in keyof T_4]: T_4[P_3]; } : never : never; } : never) extends infer T_2 ? { [P_2 in keyof T_2]: T_2[P_2]; } : never : never; } extends infer T_1 ? { [P_1 in keyof T_1]: T_1[P_1]; } : never;
+};

package/.dist/esm/src/aot/loadClientAOTCaches.js

@@ -0,0 +1,19 @@
+import { addAOTCaches, addRoutesToCache } from "@mionjs/core";
+import { jitFnsCache } from "../../_virtual/jit-fns.js";
+import { pureFnsCache } from "../../_virtual/pure-fns.js";
+import { routerCache } from "../../_virtual/router-cache.js";
+import { initClient } from "../client.js";
+import { __ΩInitClientOptions as ___InitClientOptions } from "../types.js";
+function loadClientAotCaches() {
+  addAOTCaches(jitFnsCache, pureFnsCache), addRoutesToCache(routerCache);
+}
+loadClientAotCaches.__type = ["loadClientAotCaches", 'P"/!'];
+function initAOTClient(options) {
+  return loadClientAotCaches(), initClient.Ω = [["RemoteApi", '"w!']], initClient(options);
+}
+initAOTClient.__type = [() => ___InitClientOptions, "options", "initAOTClient", 'Pn!2""/#'];
+export {
+  initAOTClient,
+  loadClientAotCaches
+};
+//# sourceMappingURL=loadClientAOTCaches.js.map

package/.dist/esm/src/aot/loadClientAOTCaches.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"loadClientAOTCaches.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;"}

package/.dist/esm/src/client.d.ts

@@ -0,0 +1,28 @@
+import { CallWithMiddleFnsResult, ClientOptions, HSubRequest, InitClientOptions, RSubRequest, SubRequest, ClientRoutes, ClientMiddleFns, Result, WorkflowResult } from './types.ts';
+import { RemoteApi } from '@mionjs/router';
+import { RunTypeError } from '@mionjs/core';
+import { HandlersRegistry } from './handlersRegistry.ts';
+export declare function initClient<RM extends RemoteApi>(options: InitClientOptions): {
+    client: MionClient;
+    routes: ClientRoutes<RM>;
+    middleFns: ClientMiddleFns<RM>;
+};
+export declare class MionClient {
+    private clientOptions;
+    readonly handlersRegistry: HandlersRegistry;
+    readonly prefilledMiddleFnsCache: Map<string, SubRequest<any>>;
+    private pendingPrefills;
+    constructor(clientOptions: ClientOptions);
+    executeCall<RR extends RSubRequest<any>>(routeSubRequest: RR): Promise<Result<any, any>>;
+    executeCallWithMiddleFns<H extends Record<string, HSubRequest<any>>>(routeSubRequest: RSubRequest<any>, middleFnsRecord: H): Promise<CallWithMiddleFnsResult<any, any, H>>;
+    executeCallWithWorkflow<Routes extends RSubRequest<any>[], H extends Record<string, HSubRequest<any>>>(workflowSubRequests: Routes, middleFnsRecord: H): Promise<WorkflowResult<Routes, H>>;
+    private executeRequest;
+    private getRouteIds;
+    private getAllMiddleFnsFromRequest;
+    private processMiddleFnsResponses;
+    private buildResult;
+    typeErrors<List extends SubRequest<any>[]>(...subRequest: List): Promise<RunTypeError[]>;
+    prefill<List extends HSubRequest<any>[]>(...subRequest: List): Promise<void>;
+    removePrefill<List extends HSubRequest<any>[]>(...subRequest: List): Promise<void>;
+    destroy(): void;
+}

package/.dist/esm/src/client.js

@@ -0,0 +1,185 @@
+import { DEFAULT_PREFILL_OPTIONS } from "./constants.js";
+import { __ΩSubRequest as ___SubRequest, __ΩClientOptions as ___ClientOptions, __ΩResult as ___Result, __ΩRSubRequest as ___RSubRequest, __ΩCallWithMiddleFnsResult as ___CallWithMiddleFnsResult, __ΩWorkflowResult as ___WorkflowResult, __ΩHSubRequest as ___HSubRequest, __ΩRequestErrors as ___RequestErrors, __ΩInitClientOptions as ___InitClientOptions, __ΩClientRoutes as ___ClientRoutes, __ΩClientMiddleFns as ___ClientMiddleFns } from "./types.js";
+import { registerErrorDeserializers, getRouterItemId } from "@mionjs/core";
+import { MionClientRequest } from "./request.js";
+import { HandlersRegistry } from "./handlersRegistry.js";
+import { findSubRequestError, MionSubRequest } from "./subRequest.js";
+const __ΩRecord = ["K", "T", "Record", `l'e#"Rb!b"Pde"!N#!w#y`];
+function __assignType(fn, args) {
+  return fn.__type = args, fn;
+}
+function initClient(options) {
+  registerErrorDeserializers();
+  const clientOptions = {
+    ...DEFAULT_PREFILL_OPTIONS,
+    ...options
+  }, client = new MionClient(clientOptions), rootProxy = new MethodProxy([], client, clientOptions);
+  return {
+    client,
+    routes: rootProxy.proxy,
+    middleFns: rootProxy.proxy
+  };
+}
+initClient.__type = [() => ___InitClientOptions, "options", () => MionClient, "client", () => ___ClientRoutes, "routes", () => ___ClientMiddleFns, "middleFns", "initClient", `Pn!2"PP7#4$"o%"4&"o'"4(M/)`];
+class MionClient {
+  clientOptions;
+  /** Shared registry for persistent middleFn error handlers */
+  handlersRegistry = new HandlersRegistry();
+  /** In-memory cache for prefilled middleFn subrequests (keyed by baseURL:middleFnId) */
+  prefilledMiddleFnsCache = (Map.Ω = [["&"], [() => ___SubRequest, '"o!"']], /* @__PURE__ */ new Map());
+  /** Tracks in-flight prefill operations to avoid race conditions */
+  pendingPrefills = [];
+  constructor(clientOptions) {
+    this.clientOptions = clientOptions;
+  }
+  /** Executes a route call and returns a Result 4-tuple */
+  executeCall(routeSubRequest) {
+    return this.executeRequest(routeSubRequest, void 0, void 0);
+  }
+  /** Executes a route call with middleFns and returns a typed result object */
+  executeCallWithMiddleFns(routeSubRequest, middleFnsRecord) {
+    return this.executeRequest(routeSubRequest, void 0, middleFnsRecord);
+  }
+  /** Executes a routesFlow call with multiple routes and optional middleFns */
+  executeCallWithWorkflow(workflowSubRequests, middleFnsRecord) {
+    return this.executeRequest(void 0, workflowSubRequests, middleFnsRecord);
+  }
+  async executeRequest(routeSubRequest, workflowSubRequests, middleFnsRecord) {
+    this.pendingPrefills.length > 0 && await Promise.allSettled([...this.pendingPrefills]);
+    const middleFnSubRequests = middleFnsRecord ? Object.values(middleFnsRecord) : [], request = new MionClientRequest(this.clientOptions, this.prefilledMiddleFnsCache, routeSubRequest, middleFnSubRequests, workflowSubRequests);
+    try {
+      await request.call();
+      const routeIds = this.getRouteIds(routeSubRequest, workflowSubRequests), allMiddleFns = this.getAllMiddleFnsFromRequest(request, routeIds);
+      return this.processMiddleFnsResponses(allMiddleFns, void 0), this.buildResult(routeSubRequest, workflowSubRequests, middleFnsRecord || allMiddleFns, void 0);
+    } catch (errors) {
+      const routeIds = this.getRouteIds(routeSubRequest, workflowSubRequests), allMiddleFns = this.getAllMiddleFnsFromRequest(request, routeIds);
+      return this.processMiddleFnsResponses(allMiddleFns, errors), this.buildResult(routeSubRequest, workflowSubRequests, middleFnsRecord || allMiddleFns, errors);
+    }
+  }
+  /** Get route IDs from single route or routesFlow routes */
+  getRouteIds(routeSubRequest, workflowSubRequests) {
+    const routeIds = (Set.Ω = [["&"]], /* @__PURE__ */ new Set());
+    return routeSubRequest && routeIds.add(routeSubRequest.id), workflowSubRequests && workflowSubRequests.forEach(__assignType((sr) => routeIds.add(sr.id), ["sr", "", 'P"2!"/"'])), routeIds;
+  }
+  /** Get all middleFns from the request's subRequestList, excluding the route(s) */
+  getAllMiddleFnsFromRequest(request, excludedIds) {
+    return Object.entries(request.subRequestList).filter(__assignType(([id]) => !excludedIds.has(id), ["param0", "", 'P"2!"/"'])).map(__assignType(([, subRequest]) => subRequest, ["param0", "", 'P"2!"/"']));
+  }
+  /** Process all middleFn responses - call success or error handlers for each middleFn individually */
+  processMiddleFnsResponses(middleFnSubRequests, errors) {
+    for (const middleFn of middleFnSubRequests) {
+      const middleFnError = errors?.get(middleFn.id);
+      middleFnError ? this.handlersRegistry.executeHandler(middleFn.id, middleFnError) : middleFn.resolvedValue !== void 0 && this.handlersRegistry.executeSuccessHandler(middleFn.id, middleFn.resolvedValue);
+    }
+  }
+  /** Build the result 4-tuple from the request results. middleFns can be a named record or an array of subrequests */
+  buildResult(routeSubRequest, workflowSubRequests, middleFns, errors) {
+    const middleFnsResults = {}, middleFnsErrors = {}, processedIds = (Set.Ω = [["&"]], /* @__PURE__ */ new Set());
+    let routeResultPart, routeErrorPart;
+    if (routeSubRequest) {
+      processedIds.add(routeSubRequest.id);
+      const routeError = errors?.get(routeSubRequest.id) || (errors ? findSubRequestError(routeSubRequest, errors) : void 0);
+      routeResultPart = routeError ? void 0 : routeSubRequest.resolvedValue, routeErrorPart = routeError;
+    } else if (workflowSubRequests) {
+      const routeResults = [], routeErrors = [];
+      for (const routeSubRequest2 of workflowSubRequests) {
+        processedIds.add(routeSubRequest2.id);
+        const routeError = errors?.get(routeSubRequest2.id);
+        routeError ? (routeResults.push(void 0), routeErrors.push(routeError)) : (routeResults.push(routeSubRequest2.resolvedValue), routeErrors.push(void 0));
+      }
+      const hasAnyResult = routeResults.some(__assignType((r) => r !== void 0, ["r", "", 'P"2!"/"'])), hasAnyError = routeErrors.some(__assignType((e) => e !== void 0, ["e", "", 'P"2!"/"']));
+      routeResultPart = hasAnyResult ? routeResults : void 0, routeErrorPart = hasAnyError ? routeErrors : void 0;
+    }
+    if (Array.isArray(middleFns))
+      for (const middleFn of middleFns) {
+        processedIds.add(middleFn.id);
+        const middleFnError = errors?.get(middleFn.id);
+        middleFnError ? middleFnsErrors[middleFn.id] = middleFnError : middleFn.resolvedValue !== void 0 && (middleFnsResults[middleFn.id] = middleFn.resolvedValue);
+      }
+    else
+      for (const [name, middleFn] of Object.entries(middleFns)) {
+        processedIds.add(middleFn.id);
+        const middleFnError = errors?.get(middleFn.id);
+        middleFnError ? middleFnsErrors[name] = middleFnError : middleFn.resolvedValue !== void 0 && (middleFnsResults[name] = middleFn.resolvedValue);
+      }
+    if (errors)
+      for (const [id, error] of errors)
+        processedIds.has(id) || (middleFnsErrors[id] = error);
+    return [routeResultPart, routeErrorPart, middleFnsResults, middleFnsErrors];
+  }
+  typeErrors(...subRequest) {
+    return new MionClientRequest(this.clientOptions, this.prefilledMiddleFnsCache).validateParams(subRequest);
+  }
+  prefill(...subRequest) {
+    const promise = new MionClientRequest(this.clientOptions, this.prefilledMiddleFnsCache).prefill(subRequest);
+    return this.pendingPrefills.push(promise), promise.finally(() => {
+      const index = this.pendingPrefills.indexOf(promise);
+      index >= 0 && this.pendingPrefills.splice(index, 1);
+    }), promise;
+  }
+  removePrefill(...subRequest) {
+    return new MionClientRequest(this.clientOptions, this.prefilledMiddleFnsCache).removePrefill(subRequest);
+  }
+  /** Clear all error handlers from the registry */
+  destroy() {
+    this.handlersRegistry.clearAll();
+  }
+  static __type = ["handlersRegistry", function() {
+    return new HandlersRegistry();
+  }, "prefilledMiddleFnsCache", function() {
+    return Map.Ω = [["&"], [() => ___SubRequest, '"o!"']], /* @__PURE__ */ new Map();
+  }, "pendingPrefills", function() {
+    return [];
+  }, () => ___ClientOptions, "clientOptions", "constructor", "routeSubRequest", () => ___Result, "executeCall", () => ___RSubRequest, "middleFnsRecord", () => ___CallWithMiddleFnsResult, "executeCallWithMiddleFns", "workflowSubRequests", () => ___WorkflowResult, "executeCallWithWorkflow", () => ___RSubRequest, "executeRequest", () => ___RSubRequest, () => ___RSubRequest, "getRouteIds", () => MionClientRequest, "request", "excludedIds", () => ___HSubRequest, "getAllMiddleFnsFromRequest", () => ___HSubRequest, "middleFnSubRequests", () => ___RequestErrors, "errors", "processMiddleFnsResponses", () => ___RSubRequest, () => ___HSubRequest, "middleFns", () => ___RequestErrors, () => ___CallWithMiddleFnsResult, () => ___WorkflowResult, () => ___Result, "buildResult", "subRequest", "RunTypeError", "typeErrors", "prefill", "removePrefill", "destroy", "MionClient", '!3!9>"!3#9>$$`F3%;>&Pn\'2(;"0)P"2*""o+#`0,P"o-"2*"2."""o/$`00P"21"2.""o2#`03PP"o4"-J2*P"-J21P"-J2."`05;PP"o6"-J2*P"o7"F-J21&D08;PP""792:&D2;"o<"F0=;P"o>"F2?Pn@-J2A$0B;PP"oC"-J2*P"-J21P""oD"FJ2EPnF-J2AP"""oG$""oH#""oI#J0J;P"@2K"wLF`0MP"@2K$`0NP"@2K$`0OP$0P5wQ'];
+}
+class MethodProxy {
+  parentProps;
+  client;
+  clientOptions;
+  propsProxies = {};
+  handler = {
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    apply: __assignType((_target, _thisArg, argArray) => {
+      const handlerId = getRouterItemId(this.parentProps);
+      return new MionSubRequest(this.parentProps, handlerId, argArray, this.client);
+    }, ["_target", "_thisArg", "argArray", () => ___RSubRequest, () => ___HSubRequest, "", 'P"2!"2""2#8P"o$""o%"K/&']),
+    get: __assignType((_target, prop) => {
+      const existing = this.propsProxies[prop];
+      if (existing)
+        return existing.proxy;
+      const newMethodProxy = new MethodProxy([...this.parentProps, prop], this.client, this.clientOptions);
+      return this.propsProxies[prop] = newMethodProxy, newMethodProxy.proxy;
+    }, ["_target", "prop", () => Proxy, "", 'P"2!&2"i#/$'])
+  };
+  proxy;
+  constructor(parentProps, client, clientOptions) {
+    this.parentProps = parentProps, this.client = client, this.clientOptions = clientOptions;
+    const target = () => null;
+    this.proxy = new Proxy(target, this.handler);
+  }
+  static __type = [() => __ΩRecord, () => MethodProxy, "propsProxies", function() {
+    return {};
+  }, "handler", function() {
+    return {
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      apply: __assignType((_target, _thisArg, argArray) => {
+        const handlerId = getRouterItemId(this.parentProps);
+        return new MionSubRequest(this.parentProps, handlerId, argArray, this.client);
+      }, ["_target", "_thisArg", "argArray", () => ___RSubRequest, () => ___HSubRequest, "", 'P"2!"2""2#8P"o$""o%"K/&']),
+      get: __assignType((_target, prop) => {
+        const existing = this.propsProxies[prop];
+        if (existing)
+          return existing.proxy;
+        const newMethodProxy = new MethodProxy([...this.parentProps, prop], this.client, this.clientOptions);
+        return this.propsProxies[prop] = newMethodProxy, newMethodProxy.proxy;
+      }, ["_target", "prop", () => Proxy, "", 'P"2!&2"i#/$'])
+    };
+  }, () => Proxy, "proxy", "parentProps", () => MionClient, "client", () => ___ClientOptions, "clientOptions", "constructor", "MethodProxy", `&P7"o!#3#>$!3%>&i'3(P&F2):P7*2+;n,2-;"0.5w/`];
+}
+export {
+  MionClient,
+  initClient
+};
+//# sourceMappingURL=client.js.map

package/.dist/esm/src/client.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/.dist/esm/src/clientMethodsMetadata.d.ts

@@ -0,0 +1,10 @@
+import { ClientOptions } from './types.ts';
+import { JitCompiledFnData, MethodsCache, PureFnsDataCache } from '@mionjs/core';
+export declare function fetchRemoteMethodsMetadata(methodIds: string[], options: ClientOptions): Promise<void>;
+export declare function storeDependencies(deps: Record<string, JitCompiledFnData>, pureFnDeps: PureFnsDataCache, options: ClientOptions): void;
+export declare function storeMethodsMetadata(methods: MethodsCache, options: ClientOptions): void;
+export declare function restoreAllDependencies(options: ClientOptions): void;
+export declare function getAOTCaches(): {
+    jitFnsCache: Record<string, any>;
+    pureFnsCache: Record<string, Record<string, any>>;
+};