@orpc/client 0.0.0-next.aa72097 → 0.0.0-next.aac73c2

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

@@ -0,0 +1,103 @@
+import { a as ClientContext, b as ClientOptions, d as HTTPMethod } from './client.Bnaxb-CE.js';
+import { c as StandardLinkCodec, a as StandardLinkOptions } from './client.BZZMKcrk.js';
+import { Segment, Value } from '@orpc/shared';
+import { StandardHeaders, StandardRequest, StandardLazyResponse } from '@orpc/standard-server';
+
+declare const STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES: {
+    readonly BIGINT: 0;
+    readonly DATE: 1;
+    readonly NAN: 2;
+    readonly UNDEFINED: 3;
+    readonly URL: 4;
+    readonly REGEXP: 5;
+    readonly SET: 6;
+    readonly MAP: 7;
+};
+type StandardRPCJsonSerializedMetaItem = readonly [type: number, ...path: Segment[]];
+type StandardRPCJsonSerialized = [json: unknown, meta: StandardRPCJsonSerializedMetaItem[], maps: Segment[][], blobs: Blob[]];
+interface StandardRPCCustomJsonSerializer {
+    type: number;
+    condition(data: unknown): boolean;
+    serialize(data: any): unknown;
+    deserialize(serialized: any): unknown;
+}
+interface StandardRPCJsonSerializerOptions {
+    customJsonSerializers?: readonly StandardRPCCustomJsonSerializer[];
+}
+declare class StandardRPCJsonSerializer {
+    private readonly customSerializers;
+    constructor(options?: StandardRPCJsonSerializerOptions);
+    serialize(data: unknown, segments?: Segment[], meta?: StandardRPCJsonSerializedMetaItem[], maps?: Segment[][], blobs?: Blob[]): StandardRPCJsonSerialized;
+    deserialize(json: unknown, meta: readonly StandardRPCJsonSerializedMetaItem[]): unknown;
+    deserialize(json: unknown, meta: readonly StandardRPCJsonSerializedMetaItem[], maps: readonly Segment[][], getBlob: (index: number) => Blob): unknown;
+}
+
+declare class StandardRPCSerializer {
+    #private;
+    private readonly jsonSerializer;
+    constructor(jsonSerializer: StandardRPCJsonSerializer);
+    serialize(data: unknown): object;
+    deserialize(data: unknown): unknown;
+}
+
+interface StandardRPCLinkCodecOptions<T extends ClientContext> {
+    /**
+     * Base url for all requests.
+     */
+    url: Value<string | URL, [
+        options: ClientOptions<T>,
+        path: readonly string[],
+        input: unknown
+    ]>;
+    /**
+     * The maximum length of the URL.
+     *
+     * @default 2083
+     */
+    maxUrlLength?: Value<number, [
+        options: ClientOptions<T>,
+        path: readonly string[],
+        input: unknown
+    ]>;
+    /**
+     * The method used to make the request.
+     *
+     * @default 'POST'
+     */
+    method?: Value<HTTPMethod, [
+        options: ClientOptions<T>,
+        path: readonly string[],
+        input: unknown
+    ]>;
+    /**
+     * The method to use when the payload cannot safely pass to the server with method return from method function.
+     * GET is not allowed, it's very dangerous.
+     *
+     * @default 'POST'
+     */
+    fallbackMethod?: Exclude<HTTPMethod, 'GET'>;
+    /**
+     * Inject headers to the request.
+     */
+    headers?: Value<StandardHeaders, [
+        options: ClientOptions<T>,
+        path: readonly string[],
+        input: unknown
+    ]>;
+}
+declare class StandardRPCLinkCodec<T extends ClientContext> implements StandardLinkCodec<T> {
+    private readonly serializer;
+    private readonly baseUrl;
+    private readonly maxUrlLength;
+    private readonly fallbackMethod;
+    private readonly expectedMethod;
+    private readonly headers;
+    constructor(serializer: StandardRPCSerializer, options: StandardRPCLinkCodecOptions<T>);
+    encode(path: readonly string[], input: unknown, options: ClientOptions<T>): Promise<StandardRequest>;
+    decode(response: StandardLazyResponse): Promise<unknown>;
+}
+
+interface StandardRPCLinkOptions<T extends ClientContext> extends StandardLinkOptions<T>, StandardRPCLinkCodecOptions<T>, StandardRPCJsonSerializerOptions {
+}
+
+export { STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES as S, type StandardRPCJsonSerializedMetaItem as a, type StandardRPCJsonSerialized as b, type StandardRPCCustomJsonSerializer as c, type StandardRPCJsonSerializerOptions as d, StandardRPCJsonSerializer as e, type StandardRPCLinkOptions as f, type StandardRPCLinkCodecOptions as g, StandardRPCLinkCodec as h, StandardRPCSerializer as i };

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

@@ -0,0 +1,103 @@
+import { a as ClientContext, b as ClientOptions, d as HTTPMethod } from './client.Bnaxb-CE.mjs';
+import { c as StandardLinkCodec, a as StandardLinkOptions } from './client.D_TnaeH1.mjs';
+import { Segment, Value } from '@orpc/shared';
+import { StandardHeaders, StandardRequest, StandardLazyResponse } from '@orpc/standard-server';
+
+declare const STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES: {
+    readonly BIGINT: 0;
+    readonly DATE: 1;
+    readonly NAN: 2;
+    readonly UNDEFINED: 3;
+    readonly URL: 4;
+    readonly REGEXP: 5;
+    readonly SET: 6;
+    readonly MAP: 7;
+};
+type StandardRPCJsonSerializedMetaItem = readonly [type: number, ...path: Segment[]];
+type StandardRPCJsonSerialized = [json: unknown, meta: StandardRPCJsonSerializedMetaItem[], maps: Segment[][], blobs: Blob[]];
+interface StandardRPCCustomJsonSerializer {
+    type: number;
+    condition(data: unknown): boolean;
+    serialize(data: any): unknown;
+    deserialize(serialized: any): unknown;
+}
+interface StandardRPCJsonSerializerOptions {
+    customJsonSerializers?: readonly StandardRPCCustomJsonSerializer[];
+}
+declare class StandardRPCJsonSerializer {
+    private readonly customSerializers;
+    constructor(options?: StandardRPCJsonSerializerOptions);
+    serialize(data: unknown, segments?: Segment[], meta?: StandardRPCJsonSerializedMetaItem[], maps?: Segment[][], blobs?: Blob[]): StandardRPCJsonSerialized;
+    deserialize(json: unknown, meta: readonly StandardRPCJsonSerializedMetaItem[]): unknown;
+    deserialize(json: unknown, meta: readonly StandardRPCJsonSerializedMetaItem[], maps: readonly Segment[][], getBlob: (index: number) => Blob): unknown;
+}
+
+declare class StandardRPCSerializer {
+    #private;
+    private readonly jsonSerializer;
+    constructor(jsonSerializer: StandardRPCJsonSerializer);
+    serialize(data: unknown): object;
+    deserialize(data: unknown): unknown;
+}
+
+interface StandardRPCLinkCodecOptions<T extends ClientContext> {
+    /**
+     * Base url for all requests.
+     */
+    url: Value<string | URL, [
+        options: ClientOptions<T>,
+        path: readonly string[],
+        input: unknown
+    ]>;
+    /**
+     * The maximum length of the URL.
+     *
+     * @default 2083
+     */
+    maxUrlLength?: Value<number, [
+        options: ClientOptions<T>,
+        path: readonly string[],
+        input: unknown
+    ]>;
+    /**
+     * The method used to make the request.
+     *
+     * @default 'POST'
+     */
+    method?: Value<HTTPMethod, [
+        options: ClientOptions<T>,
+        path: readonly string[],
+        input: unknown
+    ]>;
+    /**
+     * The method to use when the payload cannot safely pass to the server with method return from method function.
+     * GET is not allowed, it's very dangerous.
+     *
+     * @default 'POST'
+     */
+    fallbackMethod?: Exclude<HTTPMethod, 'GET'>;
+    /**
+     * Inject headers to the request.
+     */
+    headers?: Value<StandardHeaders, [
+        options: ClientOptions<T>,
+        path: readonly string[],
+        input: unknown
+    ]>;
+}
+declare class StandardRPCLinkCodec<T extends ClientContext> implements StandardLinkCodec<T> {
+    private readonly serializer;
+    private readonly baseUrl;
+    private readonly maxUrlLength;
+    private readonly fallbackMethod;
+    private readonly expectedMethod;
+    private readonly headers;
+    constructor(serializer: StandardRPCSerializer, options: StandardRPCLinkCodecOptions<T>);
+    encode(path: readonly string[], input: unknown, options: ClientOptions<T>): Promise<StandardRequest>;
+    decode(response: StandardLazyResponse): Promise<unknown>;
+}
+
+interface StandardRPCLinkOptions<T extends ClientContext> extends StandardLinkOptions<T>, StandardRPCLinkCodecOptions<T>, StandardRPCJsonSerializerOptions {
+}
+
+export { STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES as S, type StandardRPCJsonSerializedMetaItem as a, type StandardRPCJsonSerialized as b, type StandardRPCCustomJsonSerializer as c, type StandardRPCJsonSerializerOptions as d, StandardRPCJsonSerializer as e, type StandardRPCLinkOptions as f, type StandardRPCLinkCodecOptions as g, StandardRPCLinkCodec as h, StandardRPCSerializer as i };

package/dist/shared/client.jKEwIsRd.mjs

@@ -0,0 +1,175 @@
+import { isObject, isTypescriptObject } from '@orpc/shared';
+import { getEventMeta, withEventMeta } from '@orpc/standard-server';
+
+const COMMON_ORPC_ERROR_DEFS = {
+  BAD_REQUEST: {
+    status: 400,
+    message: "Bad Request"
+  },
+  UNAUTHORIZED: {
+    status: 401,
+    message: "Unauthorized"
+  },
+  FORBIDDEN: {
+    status: 403,
+    message: "Forbidden"
+  },
+  NOT_FOUND: {
+    status: 404,
+    message: "Not Found"
+  },
+  METHOD_NOT_SUPPORTED: {
+    status: 405,
+    message: "Method Not Supported"
+  },
+  NOT_ACCEPTABLE: {
+    status: 406,
+    message: "Not Acceptable"
+  },
+  TIMEOUT: {
+    status: 408,
+    message: "Request Timeout"
+  },
+  CONFLICT: {
+    status: 409,
+    message: "Conflict"
+  },
+  PRECONDITION_FAILED: {
+    status: 412,
+    message: "Precondition Failed"
+  },
+  PAYLOAD_TOO_LARGE: {
+    status: 413,
+    message: "Payload Too Large"
+  },
+  UNSUPPORTED_MEDIA_TYPE: {
+    status: 415,
+    message: "Unsupported Media Type"
+  },
+  UNPROCESSABLE_CONTENT: {
+    status: 422,
+    message: "Unprocessable Content"
+  },
+  TOO_MANY_REQUESTS: {
+    status: 429,
+    message: "Too Many Requests"
+  },
+  CLIENT_CLOSED_REQUEST: {
+    status: 499,
+    message: "Client Closed Request"
+  },
+  INTERNAL_SERVER_ERROR: {
+    status: 500,
+    message: "Internal Server Error"
+  },
+  NOT_IMPLEMENTED: {
+    status: 501,
+    message: "Not Implemented"
+  },
+  BAD_GATEWAY: {
+    status: 502,
+    message: "Bad Gateway"
+  },
+  SERVICE_UNAVAILABLE: {
+    status: 503,
+    message: "Service Unavailable"
+  },
+  GATEWAY_TIMEOUT: {
+    status: 504,
+    message: "Gateway Timeout"
+  }
+};
+function fallbackORPCErrorStatus(code, status) {
+  return status ?? COMMON_ORPC_ERROR_DEFS[code]?.status ?? 500;
+}
+function fallbackORPCErrorMessage(code, message) {
+  return message || COMMON_ORPC_ERROR_DEFS[code]?.message || code;
+}
+class ORPCError extends Error {
+  defined;
+  code;
+  status;
+  data;
+  constructor(code, ...[options]) {
+    if (options?.status && !isORPCErrorStatus(options.status)) {
+      throw new Error("[ORPCError] Invalid error status code.");
+    }
+    const message = fallbackORPCErrorMessage(code, options?.message);
+    super(message, options);
+    this.code = code;
+    this.status = fallbackORPCErrorStatus(code, options?.status);
+    this.defined = options?.defined ?? false;
+    this.data = options?.data;
+  }
+  toJSON() {
+    return {
+      defined: this.defined,
+      code: this.code,
+      status: this.status,
+      message: this.message,
+      data: this.data
+    };
+  }
+  static fromJSON(json, options) {
+    return new ORPCError(json.code, {
+      ...options,
+      ...json
+    });
+  }
+  static isValidJSON(json) {
+    if (!isObject(json)) {
+      return false;
+    }
+    const validKeys = ["defined", "code", "status", "message", "data"];
+    if (Object.keys(json).some((k) => !validKeys.includes(k))) {
+      return false;
+    }
+    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;
+}
+function toORPCError(error) {
+  return error instanceof ORPCError ? error : new ORPCError("INTERNAL_SERVER_ERROR", {
+    message: "Internal server error",
+    cause: error
+  });
+}
+function isORPCErrorStatus(status) {
+  return status < 200 || status >= 400;
+}
+
+function mapEventIterator(iterator, maps) {
+  return async function* () {
+    try {
+      while (true) {
+        const { done, value } = await iterator.next();
+        let mappedValue = await maps.value(value, done);
+        if (mappedValue !== value) {
+          const meta = getEventMeta(value);
+          if (meta && isTypescriptObject(mappedValue)) {
+            mappedValue = withEventMeta(mappedValue, meta);
+          }
+        }
+        if (done) {
+          return mappedValue;
+        }
+        yield mappedValue;
+      }
+    } catch (error) {
+      let mappedError = await maps.error(error);
+      if (mappedError !== error) {
+        const meta = getEventMeta(error);
+        if (meta && isTypescriptObject(mappedError)) {
+          mappedError = withEventMeta(mappedError, meta);
+        }
+      }
+      throw mappedError;
+    } finally {
+      await iterator.return?.();
+    }
+  }();
+}
+
+export { COMMON_ORPC_ERROR_DEFS as C, ORPCError as O, fallbackORPCErrorMessage as a, isORPCErrorStatus as b, fallbackORPCErrorStatus as f, isDefinedError as i, mapEventIterator as m, toORPCError as t };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@orpc/client",
   "type": "module",
-  "version": "0.0.0-next.aa72097",
+  "version": "0.0.0-next.aac73c2",
   "license": "MIT",
   "homepage": "https://orpc.unnoq.com",
   "repository": {
@@ -15,37 +15,39 @@
   ],
   "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"
     },
-    "./fetch": {
-      "types": "./dist/src/adapters/fetch/index.d.ts",
-      "import": "./dist/fetch.js",
-      "default": "./dist/fetch.js"
+    "./plugins": {
+      "types": "./dist/plugins/index.d.mts",
+      "import": "./dist/plugins/index.mjs",
+      "default": "./dist/plugins/index.mjs"
+    },
+    "./standard": {
+      "types": "./dist/adapters/standard/index.d.mts",
+      "import": "./dist/adapters/standard/index.mjs",
+      "default": "./dist/adapters/standard/index.mjs"
     },
-    "./🔒/*": {
-      "types": "./dist/src/*.d.ts"
+    "./fetch": {
+      "types": "./dist/adapters/fetch/index.d.mts",
+      "import": "./dist/adapters/fetch/index.mjs",
+      "default": "./dist/adapters/fetch/index.mjs"
     }
   },
   "files": [
-    "!**/*.map",
-    "!**/*.tsbuildinfo",
     "dist"
   ],
-  "peerDependencies": {
-    "@orpc/contract": "0.0.0-next.aa72097"
-  },
   "dependencies": {
-    "@orpc/server": "0.0.0-next.aa72097",
-    "@orpc/shared": "0.0.0-next.aa72097"
+    "@orpc/shared": "0.0.0-next.aac73c2",
+    "@orpc/standard-server": "0.0.0-next.aac73c2",
+    "@orpc/standard-server-fetch": "0.0.0-next.aac73c2"
   },
   "devDependencies": {
-    "zod": "^3.24.1",
-    "@orpc/openapi": "0.0.0-next.aa72097"
+    "zod": "^3.24.2"
   },
   "scripts": {
-    "build": "tsup --clean --sourcemap --entry.index=src/index.ts --entry.fetch=src/adapters/fetch/index.ts --format=esm --onSuccess='tsc -b --noCheck'",
+    "build": "unbuild",
     "build:watch": "pnpm run build --watch",
     "type:check": "tsc -b"
   }

package/dist/fetch.js

@@ -1,87 +0,0 @@
-// src/adapters/fetch/orpc-link.ts
-import { ORPCPayloadCodec } from "@orpc/server/fetch";
-import { ORPC_HANDLER_HEADER, ORPC_HANDLER_VALUE, trim } from "@orpc/shared";
-import { ORPCError } from "@orpc/shared/error";
-var ORPCLink = class {
-  fetch;
-  payloadCodec;
-  maxURLLength;
-  fallbackMethod;
-  getMethod;
-  getHeaders;
-  url;
-  constructor(options) {
-    this.fetch = options.fetch ?? globalThis.fetch.bind(globalThis);
-    this.payloadCodec = options.payloadCodec ?? new ORPCPayloadCodec();
-    this.maxURLLength = options.maxURLLength ?? 2083;
-    this.fallbackMethod = options.fallbackMethod ?? "POST";
-    this.url = options.url;
-    this.getMethod = async (path, input, context) => {
-      return await options.method?.(path, input, context) ?? this.fallbackMethod;
-    };
-    this.getHeaders = async (path, input, context) => {
-      return new Headers(await options.headers?.(path, input, context));
-    };
-  }
-  async call(path, input, options) {
-    const clientContext = options.context;
-    const encoded = await this.encode(path, input, options);
-    const response = await this.fetch(encoded.url, {
-      method: encoded.method,
-      headers: encoded.headers,
-      body: encoded.body,
-      signal: options.signal
-    }, clientContext);
-    const decoded = await this.payloadCodec.decode(response);
-    if (!response.ok) {
-      const error = ORPCError.fromJSON(decoded) ?? new ORPCError({
-        status: response.status,
-        code: "INTERNAL_SERVER_ERROR",
-        message: "Internal server error",
-        cause: decoded
-      });
-      throw error;
-    }
-    return decoded;
-  }
-  async encode(path, input, options) {
-    const clientContext = options.context;
-    const expectMethod = await this.getMethod(path, input, clientContext);
-    const methods = /* @__PURE__ */ new Set([expectMethod, this.fallbackMethod]);
-    const baseHeaders = await this.getHeaders(path, input, clientContext);
-    const baseUrl = new URL(`${trim(this.url, "/")}/${path.map(encodeURIComponent).join("/")}`);
-    baseHeaders.append(ORPC_HANDLER_HEADER, ORPC_HANDLER_VALUE);
-    for (const method of methods) {
-      const url = new URL(baseUrl);
-      const headers = new Headers(baseHeaders);
-      const encoded = this.payloadCodec.encode(input, method, this.fallbackMethod);
-      if (encoded.query) {
-        for (const [key, value] of encoded.query.entries()) {
-          url.searchParams.append(key, value);
-        }
-      }
-      if (url.toString().length > this.maxURLLength) {
-        continue;
-      }
-      if (encoded.headers) {
-        for (const [key, value] of encoded.headers.entries()) {
-          headers.append(key, value);
-        }
-      }
-      return {
-        url,
-        headers,
-        method: encoded.method,
-        body: encoded.body
-      };
-    }
-    throw new ORPCError({
-      code: "BAD_REQUEST",
-      message: "Cannot encode the request, please check the url length or payload."
-    });
-  }
-};
-export {
-  ORPCLink
-};
-//# sourceMappingURL=fetch.js.map

package/dist/index.js

@@ -1,39 +0,0 @@
-// src/client.ts
-function createORPCClient(link, options) {
-  const path = options?.path ?? [];
-  const procedureClient = async (...[input, options2]) => {
-    return await link.call(path, input, options2 ?? {});
-  };
-  const recursive = new Proxy(procedureClient, {
-    get(target, key) {
-      if (typeof key !== "string") {
-        return Reflect.get(target, key);
-      }
-      return createORPCClient(link, {
-        ...options,
-        path: [...path, key]
-      });
-    }
-  });
-  return recursive;
-}
-
-// src/dynamic-link.ts
-var DynamicLink = class {
-  constructor(linkResolver) {
-    this.linkResolver = linkResolver;
-  }
-  async call(path, input, options) {
-    const resolvedLink = await this.linkResolver(path, input, options.context);
-    const output = await resolvedLink.call(path, input, options);
-    return output;
-  }
-};
-
-// src/index.ts
-export * from "@orpc/shared/error";
-export {
-  DynamicLink,
-  createORPCClient
-};
-//# sourceMappingURL=index.js.map

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

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

package/dist/src/adapters/fetch/orpc-link.d.ts

@@ -1,47 +0,0 @@
-import type { HTTPMethod } from '@orpc/contract';
-import type { ProcedureClientOptions } from '@orpc/server';
-import type { Promisable } from '@orpc/shared';
-import type { ClientLink } from '../../types';
-import type { FetchWithContext } from './types';
-import { type PublicORPCPayloadCodec } from '@orpc/server/fetch';
-export interface ORPCLinkOptions<TClientContext> {
-    /**
-     * Base url for all requests.
-     */
-    url: string;
-    /**
-     * The maximum length of the URL.
-     *
-     * @default 2083
-     */
-    maxURLLength?: number;
-    /**
-     * The method used to make the request.
-     *
-     * @default 'POST'
-     */
-    method?: (path: readonly string[], input: unknown, context: TClientContext) => Promisable<HTTPMethod | undefined>;
-    /**
-     * The method to use when the payload cannot safely pass to the server with method return from method function.
-     * Do not use GET as fallback method, it's very dangerous.
-     *
-     * @default 'POST'
-     */
-    fallbackMethod?: HTTPMethod;
-    headers?: (path: readonly string[], input: unknown, context: TClientContext) => Promisable<Headers | Record<string, string>>;
-    fetch?: FetchWithContext<TClientContext>;
-    payloadCodec?: PublicORPCPayloadCodec;
-}
-export declare class ORPCLink<TClientContext> implements ClientLink<TClientContext> {
-    private readonly fetch;
-    private readonly payloadCodec;
-    private readonly maxURLLength;
-    private readonly fallbackMethod;
-    private readonly getMethod;
-    private readonly getHeaders;
-    private readonly url;
-    constructor(options: ORPCLinkOptions<TClientContext>);
-    call(path: readonly string[], input: unknown, options: ProcedureClientOptions<TClientContext>): Promise<unknown>;
-    private encode;
-}
-//# sourceMappingURL=orpc-link.d.ts.map

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

@@ -1,4 +0,0 @@
-export interface FetchWithContext<TClientContext> {
-    (input: RequestInfo | URL, init: RequestInit | undefined, context: TClientContext): Promise<Response>;
-}
-//# sourceMappingURL=types.d.ts.map

package/dist/src/client.d.ts

@@ -1,11 +0,0 @@
-import type { ContractRouter } from '@orpc/contract';
-import type { ANY_ROUTER, RouterClient } from '@orpc/server';
-import type { ClientLink } 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<TRouter extends ANY_ROUTER | ContractRouter, TClientContext = unknown>(link: ClientLink<TClientContext>, options?: createORPCClientOptions): RouterClient<TRouter, TClientContext>;
-//# sourceMappingURL=client.d.ts.map

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

@@ -1,13 +0,0 @@
-import type { ProcedureClientOptions } from '@orpc/server';
-import type { Promisable } from '@orpc/shared';
-import type { ClientLink } 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> implements ClientLink<TClientContext> {
-    private readonly linkResolver;
-    constructor(linkResolver: (path: readonly string[], input: unknown, context: TClientContext) => Promisable<ClientLink<TClientContext>>);
-    call(path: readonly string[], input: unknown, options: ProcedureClientOptions<TClientContext>): Promise<unknown>;
-}
-//# sourceMappingURL=dynamic-link.d.ts.map

package/dist/src/index.d.ts

@@ -1,6 +0,0 @@
-/** unnoq */
-export * from './client';
-export * from './dynamic-link';
-export * from './types';
-export * from '@orpc/shared/error';
-//# sourceMappingURL=index.d.ts.map

package/dist/src/types.d.ts

@@ -1,5 +0,0 @@
-import type { ProcedureClientOptions } from '@orpc/server';
-export interface ClientLink<TClientContext> {
-    call: (path: readonly string[], input: unknown, options: ProcedureClientOptions<TClientContext>) => Promise<unknown>;
-}
-//# sourceMappingURL=types.d.ts.map