@orpc/client 0.43.0 → 0.44.0

package/dist/{chunk-4HZVK3GJ.js → shared/client.DHJ8vRIG.mjs}

@@ -1,12 +1,8 @@
-import {
-  ORPCError,
-  mapEventIterator,
-  toORPCError
-} from "./chunk-X34KXUAJ.js";
+import { isObject, isAsyncIteratorObject, stringifyJSON } from '@orpc/shared';
+import { ErrorEvent } from '@orpc/standard-server';
+import { m as mapEventIterator, t as toORPCError, O as ORPCError } from './client.Ly4zGQrc.mjs';
 
-// src/rpc/json-serializer.ts
-import { isObject } from "@orpc/shared";
-var RPCJsonSerializer = class {
+class RPCJsonSerializer {
   serialize(data, segments = [], meta = [], maps = [], blobs = []) {
     if (data instanceof Blob) {
       maps.push(segments);
@@ -112,19 +108,13 @@ var RPCJsonSerializer = class {
         case 7:
           currentRef[preSegment] = new Map(currentRef[preSegment]);
           break;
-        /* v8 ignore next 3 */
-        default: {
-          const _expected = type;
-        }
       }
     }
     return ref.data;
   }
-};
+}
 
-// src/rpc/serializer.ts
-import { ErrorEvent, isAsyncIteratorObject } from "@orpc/standard-server";
-var RPCSerializer = class {
+class RPCSerializer {
   constructor(jsonSerializer = new RPCJsonSerializer()) {
     this.jsonSerializer = jsonSerializer;
   }
@@ -133,12 +123,6 @@ var RPCSerializer = class {
       return mapEventIterator(data, {
         value: async (value) => this.#serialize(value, false),
         error: async (e) => {
-          if (e instanceof ErrorEvent) {
-            return new ErrorEvent({
-              data: this.#serialize(e.data, false),
-              cause: e
-            });
-          }
           return new ErrorEvent({
             data: this.#serialize(toORPCError(e).toJSON(), false),
             cause: e
@@ -161,7 +145,7 @@ var RPCSerializer = class {
       };
     }
     const form = new FormData();
-    form.set("data", JSON.stringify({ json, meta, maps }));
+    form.set("data", stringifyJSON({ json, meta, maps }));
     blobs.forEach((blob, i) => {
       form.set(i.toString(), blob);
     });
@@ -203,10 +187,6 @@ var RPCSerializer = class {
       (i) => data.get(i.toString())
     );
   }
-};
+}
 
-export {
-  RPCJsonSerializer,
-  RPCSerializer
-};
-//# sourceMappingURL=chunk-4HZVK3GJ.js.map
+export { RPCJsonSerializer as R, RPCSerializer as a };

package/dist/shared/client.D_CzLDyB.d.mts

@@ -0,0 +1,42 @@
+type ClientContext = Record<string, any>;
+type ClientOptions<TClientContext extends ClientContext> = {
+    signal?: AbortSignal;
+    lastEventId?: string | undefined;
+} & (Record<never, never> extends TClientContext ? {
+    context?: TClientContext;
+} : {
+    context: TClientContext;
+});
+type ClientRest<TClientContext extends ClientContext, TInput> = Record<never, never> extends TClientContext ? undefined extends TInput ? [input?: TInput, options?: ClientOptions<TClientContext>] : [input: TInput, options?: ClientOptions<TClientContext>] : [input: TInput, options: ClientOptions<TClientContext>];
+type ClientPromiseResult<TOutput, TError extends Error> = Promise<TOutput> & {
+    __error?: {
+        type: TError;
+    };
+};
+interface Client<TClientContext extends ClientContext, TInput, TOutput, TError extends Error> {
+    (...rest: ClientRest<TClientContext, TInput>): ClientPromiseResult<TOutput, TError>;
+}
+type NestedClient<TClientContext extends ClientContext> = Client<TClientContext, any, any, any> | {
+    [k: string]: NestedClient<TClientContext>;
+};
+type InferClientContext<T extends NestedClient<any>> = T extends NestedClient<infer U> ? U : never;
+type ClientOptionsOut<TClientContext extends ClientContext> = ClientOptions<TClientContext> & {
+    context: TClientContext;
+};
+interface ClientLink<TClientContext extends ClientContext> {
+    call: (path: readonly string[], input: unknown, options: ClientOptionsOut<TClientContext>) => Promise<unknown>;
+}
+
+declare function mapEventIterator<TYield, TReturn, TNext, TMap = TYield | TReturn>(iterator: AsyncIterator<TYield, TReturn, TNext>, maps: {
+    value: (value: NoInfer<TYield | TReturn>, done: boolean | undefined) => Promise<TMap>;
+    error: (error: unknown) => Promise<unknown>;
+}): AsyncGenerator<TMap, TMap, TNext>;
+interface EventIteratorReconnectOptions {
+    lastRetry: number | undefined;
+    lastEventId: string | undefined;
+    retryTimes: number;
+    error: unknown;
+}
+declare function createAutoRetryEventIterator<TYield, TReturn>(initial: AsyncIterator<TYield, TReturn, void>, reconnect: (options: EventIteratorReconnectOptions) => Promise<AsyncIterator<TYield, TReturn, void> | null>, initialLastEventId: string | undefined): AsyncGenerator<TYield, TReturn, void>;
+
+export { type ClientContext as C, type EventIteratorReconnectOptions as E, type InferClientContext as I, type NestedClient as N, type ClientOptionsOut as a, type ClientLink as b, type ClientPromiseResult as c, createAutoRetryEventIterator as d, type ClientOptions as e, type ClientRest as f, type Client as g, mapEventIterator as m };

package/dist/shared/client.D_CzLDyB.d.ts

@@ -0,0 +1,42 @@
+type ClientContext = Record<string, any>;
+type ClientOptions<TClientContext extends ClientContext> = {
+    signal?: AbortSignal;
+    lastEventId?: string | undefined;
+} & (Record<never, never> extends TClientContext ? {
+    context?: TClientContext;
+} : {
+    context: TClientContext;
+});
+type ClientRest<TClientContext extends ClientContext, TInput> = Record<never, never> extends TClientContext ? undefined extends TInput ? [input?: TInput, options?: ClientOptions<TClientContext>] : [input: TInput, options?: ClientOptions<TClientContext>] : [input: TInput, options: ClientOptions<TClientContext>];
+type ClientPromiseResult<TOutput, TError extends Error> = Promise<TOutput> & {
+    __error?: {
+        type: TError;
+    };
+};
+interface Client<TClientContext extends ClientContext, TInput, TOutput, TError extends Error> {
+    (...rest: ClientRest<TClientContext, TInput>): ClientPromiseResult<TOutput, TError>;
+}
+type NestedClient<TClientContext extends ClientContext> = Client<TClientContext, any, any, any> | {
+    [k: string]: NestedClient<TClientContext>;
+};
+type InferClientContext<T extends NestedClient<any>> = T extends NestedClient<infer U> ? U : never;
+type ClientOptionsOut<TClientContext extends ClientContext> = ClientOptions<TClientContext> & {
+    context: TClientContext;
+};
+interface ClientLink<TClientContext extends ClientContext> {
+    call: (path: readonly string[], input: unknown, options: ClientOptionsOut<TClientContext>) => Promise<unknown>;
+}
+
+declare function mapEventIterator<TYield, TReturn, TNext, TMap = TYield | TReturn>(iterator: AsyncIterator<TYield, TReturn, TNext>, maps: {
+    value: (value: NoInfer<TYield | TReturn>, done: boolean | undefined) => Promise<TMap>;
+    error: (error: unknown) => Promise<unknown>;
+}): AsyncGenerator<TMap, TMap, TNext>;
+interface EventIteratorReconnectOptions {
+    lastRetry: number | undefined;
+    lastEventId: string | undefined;
+    retryTimes: number;
+    error: unknown;
+}
+declare function createAutoRetryEventIterator<TYield, TReturn>(initial: AsyncIterator<TYield, TReturn, void>, reconnect: (options: EventIteratorReconnectOptions) => Promise<AsyncIterator<TYield, TReturn, void> | null>, initialLastEventId: string | undefined): AsyncGenerator<TYield, TReturn, void>;
+
+export { type ClientContext as C, type EventIteratorReconnectOptions as E, type InferClientContext as I, type NestedClient as N, type ClientOptionsOut as a, type ClientLink as b, type ClientPromiseResult as c, createAutoRetryEventIterator as d, type ClientOptions as e, type ClientRest as f, type Client as g, mapEventIterator as m };

package/dist/{chunk-X34KXUAJ.js → shared/client.Ly4zGQrc.mjs}

@@ -1,6 +1,7 @@
-// src/error.ts
-import { isObject } from "@orpc/shared";
-var COMMON_ORPC_ERROR_DEFS = {
+import { isObject, isTypescriptObject, retry } from '@orpc/shared';
+import { getEventMeta, withEventMeta } from '@orpc/standard-server';
+
+const COMMON_ORPC_ERROR_DEFS = {
   BAD_REQUEST: {
     status: 400,
     message: "Bad Request"
@@ -84,7 +85,7 @@ function fallbackORPCErrorStatus(code, status) {
 function fallbackORPCErrorMessage(code, message) {
   return message || COMMON_ORPC_ERROR_DEFS[code]?.message || code;
 }
-var ORPCError = class _ORPCError extends Error {
+class ORPCError extends Error {
   defined;
   code;
   status;
@@ -110,7 +111,7 @@ var ORPCError = class _ORPCError extends Error {
     };
   }
   static fromJSON(json, options) {
-    return new _ORPCError(json.code, {
+    return new ORPCError(json.code, {
       ...options,
       ...json
     });
@@ -125,7 +126,7 @@ var ORPCError = class _ORPCError extends Error {
     }
     return "defined" in json && typeof json.defined === "boolean" && "code" in json && typeof json.code === "string" && "status" in json && typeof json.status === "number" && "message" in json && typeof json.message === "string";
   }
-};
+}
 function isDefinedError(error) {
   return error instanceof ORPCError && error.defined;
 }
@@ -136,8 +137,7 @@ function toORPCError(error) {
   });
 }
 
-// src/event-iterator-state.ts
-var iteratorStates = /* @__PURE__ */ new WeakMap();
+const iteratorStates = /* @__PURE__ */ new WeakMap();
 function registerEventIteratorState(iterator, state) {
   iteratorStates.set(iterator, state);
 }
@@ -164,9 +164,6 @@ function onEventIteratorStatusChange(iterator, callback, notifyImmediately = tru
   };
 }
 
-// src/event-iterator.ts
-import { retry } from "@orpc/shared";
-import { getEventMeta, isEventMetaContainer, withEventMeta } from "@orpc/standard-server";
 function mapEventIterator(iterator, maps) {
   return async function* () {
     try {
@@ -175,7 +172,7 @@ function mapEventIterator(iterator, maps) {
         let mappedValue = await maps.value(value, done);
         if (mappedValue !== value) {
           const meta = getEventMeta(value);
-          if (meta && isEventMetaContainer(mappedValue)) {
+          if (meta && isTypescriptObject(mappedValue)) {
             mappedValue = withEventMeta(mappedValue, meta);
           }
         }
@@ -188,7 +185,7 @@ function mapEventIterator(iterator, maps) {
       let mappedError = await maps.error(error);
       if (mappedError !== error) {
         const meta = getEventMeta(error);
-        if (meta && isEventMetaContainer(mappedError)) {
+        if (meta && isTypescriptObject(mappedError)) {
           mappedError = withEventMeta(mappedError, meta);
         }
       }
@@ -198,7 +195,7 @@ function mapEventIterator(iterator, maps) {
     }
   }();
 }
-var MAX_ALLOWED_RETRY_TIMES = 99;
+const MAX_ALLOWED_RETRY_TIMES = 99;
 function createAutoRetryEventIterator(initial, reconnect, initialLastEventId) {
   const state = {
     status: "connected",
@@ -265,17 +262,4 @@ function createAutoRetryEventIterator(initial, reconnect, initialLastEventId) {
   return iterator;
 }
 
-export {
-  COMMON_ORPC_ERROR_DEFS,
-  fallbackORPCErrorStatus,
-  fallbackORPCErrorMessage,
-  ORPCError,
-  isDefinedError,
-  toORPCError,
-  registerEventIteratorState,
-  updateEventIteratorStatus,
-  onEventIteratorStatusChange,
-  mapEventIterator,
-  createAutoRetryEventIterator
-};
-//# sourceMappingURL=chunk-X34KXUAJ.js.map
+export { COMMON_ORPC_ERROR_DEFS as C, ORPCError as O, fallbackORPCErrorMessage as a, createAutoRetryEventIterator as c, fallbackORPCErrorStatus as f, isDefinedError as i, mapEventIterator as m, onEventIteratorStatusChange as o, registerEventIteratorState as r, toORPCError as t, updateEventIteratorStatus as u };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@orpc/client",
   "type": "module",
-  "version": "0.43.0",
+  "version": "0.44.0",
   "license": "MIT",
   "homepage": "https://orpc.unnoq.com",
   "repository": {
@@ -15,44 +15,34 @@
   ],
   "exports": {
     ".": {
-      "types": "./dist/src/index.d.ts",
-      "import": "./dist/index.js",
-      "default": "./dist/index.js"
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs",
+      "default": "./dist/index.mjs"
     },
-    "./openapi": {
-      "types": "./dist/src/openapi/index.d.ts",
-      "import": "./dist/openapi.js",
-      "default": "./dist/openapi.js"
-    },
-    "./rpc": {
-      "types": "./dist/src/rpc/index.d.ts",
-      "import": "./dist/rpc.js",
-      "default": "./dist/rpc.js"
+    "./standard": {
+      "types": "./dist/adapters/standard/index.d.mts",
+      "import": "./dist/adapters/standard/index.mjs",
+      "default": "./dist/adapters/standard/index.mjs"
     },
     "./fetch": {
-      "types": "./dist/src/adapters/fetch/index.d.ts",
-      "import": "./dist/fetch.js",
-      "default": "./dist/fetch.js"
-    },
-    "./🔒/*": {
-      "types": "./dist/src/*.d.ts"
+      "types": "./dist/adapters/fetch/index.d.mts",
+      "import": "./dist/adapters/fetch/index.mjs",
+      "default": "./dist/adapters/fetch/index.mjs"
     }
   },
   "files": [
-    "!**/*.map",
-    "!**/*.tsbuildinfo",
     "dist"
   ],
   "dependencies": {
-    "@orpc/shared": "0.43.0",
-    "@orpc/standard-server-fetch": "0.43.0",
-    "@orpc/standard-server": "0.43.0"
+    "@orpc/standard-server": "0.44.0",
+    "@orpc/standard-server-fetch": "0.44.0",
+    "@orpc/shared": "0.44.0"
   },
   "devDependencies": {
     "zod": "^3.24.1"
   },
   "scripts": {
-    "build": "tsup --onSuccess='tsc -b --noCheck'",
+    "build": "unbuild",
     "build:watch": "pnpm run build --watch",
     "type:check": "tsc -b"
   }

package/dist/openapi.js

@@ -1,231 +0,0 @@
-import {
-  ORPCError,
-  mapEventIterator,
-  toORPCError
-} from "./chunk-X34KXUAJ.js";
-
-// src/openapi/bracket-notation.ts
-import { isObject } from "@orpc/shared";
-var BracketNotationSerializer = class {
-  serialize(data, segments = [], result = []) {
-    if (Array.isArray(data)) {
-      data.forEach((item, i) => {
-        this.serialize(item, [...segments, i], result);
-      });
-    } else if (isObject(data)) {
-      for (const key in data) {
-        this.serialize(data[key], [...segments, key], result);
-      }
-    } else {
-      result.push([this.stringifyPath(segments), data]);
-    }
-    return result;
-  }
-  deserialize(serialized) {
-    const arrayPushStyles = /* @__PURE__ */ new WeakSet();
-    const ref = { value: [] };
-    for (const [path, value] of serialized) {
-      const segments = this.parsePath(path);
-      let currentRef = ref;
-      let nextSegment = "value";
-      segments.forEach((segment, i) => {
-        if (!Array.isArray(currentRef[nextSegment]) && !isObject(currentRef[nextSegment])) {
-          currentRef[nextSegment] = [];
-        }
-        if (i !== segments.length - 1) {
-          if (Array.isArray(currentRef[nextSegment]) && !isValidArrayIndex(segment)) {
-            currentRef[nextSegment] = { ...currentRef[nextSegment] };
-          }
-        } else {
-          if (Array.isArray(currentRef[nextSegment])) {
-            if (segment === "") {
-              if (currentRef[nextSegment].length && !arrayPushStyles.has(currentRef[nextSegment])) {
-                currentRef[nextSegment] = { ...currentRef[nextSegment] };
-              }
-            } else {
-              if (arrayPushStyles.has(currentRef[nextSegment])) {
-                currentRef[nextSegment] = { "": currentRef[nextSegment].at(-1) };
-              } else if (!isValidArrayIndex(segment)) {
-                currentRef[nextSegment] = { ...currentRef[nextSegment] };
-              }
-            }
-          }
-        }
-        currentRef = currentRef[nextSegment];
-        nextSegment = segment;
-      });
-      if (Array.isArray(currentRef)) {
-        if (nextSegment === "") {
-          arrayPushStyles.add(currentRef);
-          currentRef.push(value);
-        } else {
-          currentRef[Number(nextSegment)] = value;
-        }
-      } else {
-        currentRef[nextSegment] = value;
-      }
-    }
-    return ref.value;
-  }
-  stringifyPath(segments) {
-    return segments.map((segment) => {
-      return segment.toString().replace(/[\\[\]]/g, (match) => {
-        switch (match) {
-          case "\\":
-            return "\\\\";
-          case "[":
-            return "\\[";
-          case "]":
-            return "\\]";
-          /* v8 ignore next 2 */
-          default:
-            return match;
-        }
-      });
-    }).reduce((result, segment, i) => {
-      if (i === 0) {
-        return segment;
-      }
-      return `${result}[${segment}]`;
-    }, "");
-  }
-  parsePath(path) {
-    const segments = [];
-    let inBrackets = false;
-    let currentSegment = "";
-    let backslashCount = 0;
-    for (let i = 0; i < path.length; i++) {
-      const char = path[i];
-      const nextChar = path[i + 1];
-      if (inBrackets && char === "]" && (nextChar === void 0 || nextChar === "[") && backslashCount % 2 === 0) {
-        if (nextChar === void 0) {
-          inBrackets = false;
-        }
-        segments.push(currentSegment);
-        currentSegment = "";
-        i++;
-      } else if (segments.length === 0 && char === "[" && backslashCount % 2 === 0) {
-        inBrackets = true;
-        segments.push(currentSegment);
-        currentSegment = "";
-      } else if (char === "\\") {
-        backslashCount++;
-      } else {
-        currentSegment += "\\".repeat(backslashCount / 2) + char;
-        backslashCount = 0;
-      }
-    }
-    return inBrackets || segments.length === 0 ? [path] : segments;
-  }
-};
-function isValidArrayIndex(value) {
-  return /^0$|^[1-9]\d*$/.test(value);
-}
-
-// src/openapi/json-serializer.ts
-import { isObject as isObject2 } from "@orpc/shared";
-var OpenAPIJsonSerializer = class {
-  serialize(data, hasBlobRef = { value: false }) {
-    if (data instanceof Blob) {
-      hasBlobRef.value = true;
-      return [data, hasBlobRef.value];
-    }
-    if (data instanceof Set) {
-      return this.serialize(Array.from(data), hasBlobRef);
-    }
-    if (data instanceof Map) {
-      return this.serialize(Array.from(data.entries()), hasBlobRef);
-    }
-    if (Array.isArray(data)) {
-      const json = data.map((v) => v === void 0 ? null : this.serialize(v, hasBlobRef)[0]);
-      return [json, hasBlobRef.value];
-    }
-    if (isObject2(data)) {
-      const json = {};
-      for (const k in data) {
-        json[k] = this.serialize(data[k], hasBlobRef)[0];
-      }
-      return [json, hasBlobRef.value];
-    }
-    if (typeof data === "bigint" || data instanceof RegExp || data instanceof URL) {
-      return [data.toString(), hasBlobRef.value];
-    }
-    if (data instanceof Date) {
-      return [Number.isNaN(data.getTime()) ? null : data.toISOString(), hasBlobRef.value];
-    }
-    if (Number.isNaN(data)) {
-      return [null, hasBlobRef.value];
-    }
-    return [data, hasBlobRef.value];
-  }
-};
-
-// src/openapi/serializer.ts
-import { ErrorEvent, isAsyncIteratorObject } from "@orpc/standard-server";
-var OpenAPISerializer = class {
-  constructor(jsonSerializer = new OpenAPIJsonSerializer(), bracketNotation = new BracketNotationSerializer()) {
-    this.jsonSerializer = jsonSerializer;
-    this.bracketNotation = bracketNotation;
-  }
-  serialize(data) {
-    if (isAsyncIteratorObject(data)) {
-      return mapEventIterator(data, {
-        value: async (value) => this.#serialize(value, false),
-        error: async (e) => {
-          if (e instanceof ErrorEvent) {
-            return new ErrorEvent({
-              data: this.#serialize(e.data, false),
-              cause: e
-            });
-          }
-          return new ErrorEvent({
-            data: this.#serialize(toORPCError(e).toJSON(), false),
-            cause: e
-          });
-        }
-      });
-    }
-    return this.#serialize(data, true);
-  }
-  #serialize(data, enableFormData) {
-    if (data instanceof Blob || data === void 0) {
-      return data;
-    }
-    const [json, hasBlob] = this.jsonSerializer.serialize(data);
-    if (!enableFormData || !hasBlob) {
-      return json;
-    }
-    const form = new FormData();
-    for (const [path, value] of this.bracketNotation.serialize(json)) {
-      if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
-        form.append(path, value.toString());
-      } else if (value instanceof Blob) {
-        form.append(path, value);
-      }
-    }
-    return form;
-  }
-  deserialize(data) {
-    if (data instanceof URLSearchParams || data instanceof FormData) {
-      return this.bracketNotation.deserialize(Array.from(data.entries()));
-    }
-    if (isAsyncIteratorObject(data)) {
-      return mapEventIterator(data, {
-        value: async (value) => value,
-        error: async (e) => {
-          if (e instanceof ErrorEvent && ORPCError.isValidJSON(e.data)) {
-            return ORPCError.fromJSON(e.data, { cause: e });
-          }
-          return e;
-        }
-      });
-    }
-    return data;
-  }
-};
-export {
-  BracketNotationSerializer,
-  OpenAPIJsonSerializer,
-  OpenAPISerializer
-};
-//# sourceMappingURL=openapi.js.map

package/dist/rpc.js

@@ -1,10 +0,0 @@
-import {
-  RPCJsonSerializer,
-  RPCSerializer
-} from "./chunk-4HZVK3GJ.js";
-import "./chunk-X34KXUAJ.js";
-export {
-  RPCJsonSerializer,
-  RPCSerializer
-};
-//# sourceMappingURL=rpc.js.map

package/dist/src/adapters/fetch/index.d.ts

@@ -1,3 +0,0 @@
-export * from './rpc-link';
-export * from './types';
-//# sourceMappingURL=index.d.ts.map

package/dist/src/adapters/fetch/types.d.ts

@@ -1,5 +0,0 @@
-import type { ClientContext, ClientOptionsOut } from '../../types';
-export interface FetchWithContext<TClientContext extends ClientContext> {
-    (url: URL, init: RequestInit, options: ClientOptionsOut<TClientContext>, path: readonly string[], input: unknown): Promise<Response>;
-}
-//# sourceMappingURL=types.d.ts.map

package/dist/src/client.d.ts

@@ -1,9 +0,0 @@
-import type { ClientLink, InferClientContext, NestedClient } from './types';
-export interface createORPCClientOptions {
-    /**
-     * Use as base path for all procedure, useful when you only want to call a subset of the procedure.
-     */
-    path?: string[];
-}
-export declare function createORPCClient<T extends NestedClient<any>>(link: ClientLink<InferClientContext<T>>, options?: createORPCClientOptions): T;
-//# sourceMappingURL=client.d.ts.map

package/dist/src/dynamic-link.d.ts

@@ -1,12 +0,0 @@
-import type { Promisable } from '@orpc/shared';
-import type { ClientContext, ClientLink, ClientOptionsOut } from './types';
-/**
- * DynamicLink provides a way to dynamically resolve and delegate calls to other ClientLinks
- * based on the request path, input, and context.
- */
-export declare class DynamicLink<TClientContext extends ClientContext> implements ClientLink<TClientContext> {
-    private readonly linkResolver;
-    constructor(linkResolver: (options: ClientOptionsOut<TClientContext>, path: readonly string[], input: unknown) => Promisable<ClientLink<TClientContext>>);
-    call(path: readonly string[], input: unknown, options: ClientOptionsOut<TClientContext>): Promise<unknown>;
-}
-//# sourceMappingURL=dynamic-link.d.ts.map