@orpc/client 0.0.0-next.e7b4f63 → 0.0.0-next.e7ee5a9

package/README.md

@@ -0,0 +1,88 @@
+<div align="center">
+  <image align="center" src="https://orpc.unnoq.com/logo.webp" width=280 alt="oRPC logo" />
+</div>
+
+<h1></h1>
+
+<div align="center">
+  <a href="https://codecov.io/gh/unnoq/orpc">
+    <img alt="codecov" src="https://codecov.io/gh/unnoq/orpc/branch/main/graph/badge.svg">
+  </a>
+  <a href="https://www.npmjs.com/package/@orpc/client">
+    <img alt="weekly downloads" src="https://img.shields.io/npm/dw/%40orpc%2Fclient?logo=npm" />
+  </a>
+  <a href="https://github.com/unnoq/orpc/blob/main/LICENSE">
+    <img alt="MIT License" src="https://img.shields.io/github/license/unnoq/orpc?logo=open-source-initiative" />
+  </a>
+  <a href="https://discord.gg/TXEbwRBvQn">
+    <img alt="Discord" src="https://img.shields.io/discord/1308966753044398161?color=7389D8&label&logo=discord&logoColor=ffffff" />
+  </a>
+</div>
+
+<h3 align="center">Typesafe APIs Made Simple 🪄</h3>
+
+**oRPC is a powerful combination of RPC and OpenAPI**, makes it easy to build APIs that are end-to-end type-safe and adhere to OpenAPI standards, ensuring a smooth and enjoyable developer experience.
+
+---
+
+## Highlights
+
+- **End-to-End Type Safety 🔒**: Ensure complete type safety from inputs to outputs and errors, bridging server and client seamlessly.
+- **First-Class OpenAPI 📄**: Adheres to the OpenAPI standard out of the box, ensuring seamless integration and comprehensive API documentation.
+- **Contract-First Development 📜**: (Optional) Define your API contract upfront and implement it with confidence.
+- **Exceptional Developer Experience ✨**: Enjoy a streamlined workflow with robust typing and clear, in-code documentation.
+- **Multi-Runtime Support 🌍**: Run your code seamlessly on Cloudflare, Deno, Bun, Node.js, and more.
+- **Framework Integrations 🧩**: Supports Tanstack Query (React, Vue), Pinia Colada, and more.
+- **Server Actions ⚡️**: Fully compatible with React Server Actions on Next.js, TanStack Start, and more.
+- **Standard Schema Support 🗂️**: Effortlessly work with Zod, Valibot, ArkType, and others right out of the box.
+- **Fast & Lightweight 💨**: Built on native APIs across all runtimes – optimized for speed and efficiency.
+- **Native Types 📦**: Enjoy built-in support for Date, File, Blob, BigInt, URL and more with no extra setup.
+- **Lazy Router ⏱️**: Improve cold start times with our lazy routing feature.
+- **SSE & Streaming 📡**: Provides SSE and streaming features – perfect for real-time notifications and AI-powered streaming responses.
+- **Reusability 🔄**: Write once and reuse your code across multiple purposes effortlessly.
+- **Extendability 🔌**: Easily enhance oRPC with plugins, middleware, and interceptors.
+- **Reliability 🛡️**: Well-tested, fully TypeScript, production-ready, and MIT licensed for peace of mind.
+- **Simplicity 💡**: Enjoy straightforward, clean code with no hidden magic.
+
+## Documentation
+
+You can find the full documentation [here](https://orpc.unnoq.com).
+
+## Packages
+
+- [@orpc/contract](https://www.npmjs.com/package/@orpc/contract): Build your API contract.
+- [@orpc/server](https://www.npmjs.com/package/@orpc/server): Build your API or implement API contract.
+- [@orpc/client](https://www.npmjs.com/package/@orpc/client): Consume your API on the client with type-safety.
+- [@orpc/react-query](https://www.npmjs.com/package/@orpc/react-query): Integration with [React Query](https://tanstack.com/query/latest/docs/framework/react/overview).
+- [@orpc/vue-query](https://www.npmjs.com/package/@orpc/vue-query): Integration with [Vue Query](https://tanstack.com/query/latest/docs/framework/vue/overview).
+- [@orpc/vue-colada](https://www.npmjs.com/package/@orpc/vue-colada): Integration with [Pinia Colada](https://pinia-colada.esm.dev/).
+- [@orpc/openapi](https://www.npmjs.com/package/@orpc/openapi): Generate OpenAPI specs and handle OpenAPI requests.
+- [@orpc/zod](https://www.npmjs.com/package/@orpc/zod): More schemas that [Zod](https://zod.dev/) doesn't support yet.
+
+## `@orpc/client`
+
+Consume your API on the client with type-safety. Read the [documentation](https://orpc.unnoq.com/docs/client/client-side) for more information.
+
+```ts
+import { createORPCClient } from '@orpc/client'
+import { RPCLink } from '@orpc/client/fetch'
+import { ContractRouterClient } from '@orpc/contract'
+import { RouterClient } from '@orpc/server'
+
+const link = new RPCLink({
+  url: 'http://localhost:3000/rpc',
+  headers: () => ({
+    authorization: 'Bearer token',
+  }),
+  // fetch: <-- provide fetch polyfill fetch if needed
+})
+
+// Create a client for your router
+const client: RouterClient<typeof router> = createORPCClient(link)
+// Or, create a client using a contract
+const client: ContractRouterClient<typeof contract> = createORPCClient(link)
+```
+
+## License
+
+Distributed under the MIT License. See [LICENSE](https://github.com/unnoq/orpc/blob/main/LICENSE) for more information.

package/dist/adapters/fetch/index.d.mts

@@ -0,0 +1,103 @@
+import { Value } from '@orpc/shared';
+import { ToFetchBodyOptions } from '@orpc/standard-server-fetch';
+import { C as ClientContext, a as ClientOptionsOut, E as EventIteratorReconnectOptions, b as ClientLink } from '../../shared/client.D_CzLDyB.mjs';
+import { RPCSerializer } from '../standard/index.mjs';
+
+interface FetchWithContext<TClientContext extends ClientContext> {
+    (url: URL, init: RequestInit, options: ClientOptionsOut<TClientContext>, path: readonly string[], input: unknown): Promise<Response>;
+}
+
+type HTTPMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
+declare class InvalidEventSourceRetryResponse extends Error {
+}
+interface RPCLinkOptions<TClientContext extends ClientContext> extends ToFetchBodyOptions {
+    /**
+     * 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?: Value<HTTPMethod, [
+        options: ClientOptionsOut<TClientContext>,
+        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<[string, string][] | Record<string, string> | Headers, [
+        options: ClientOptionsOut<TClientContext>,
+        path: readonly string[],
+        input: unknown
+    ]>;
+    /**
+     * Custom fetch implementation.
+     *
+     * @default globalThis.fetch.bind(globalThis)
+     */
+    fetch?: FetchWithContext<TClientContext>;
+    rpcSerializer?: RPCSerializer;
+    /**
+     * Maximum number of retry attempts for EventSource errors before throwing.
+     *
+     * @default 5
+     */
+    eventSourceMaxNumberOfRetries?: number;
+    /**
+     * Delay (in ms) before retrying an EventSource call.
+     *
+     * @default ({retryTimes, lastRetry}) => lastRetry ?? (1000 * 2 ** retryTimes)
+     */
+    eventSourceRetryDelay?: Value<number, [
+        reconnectOptions: EventIteratorReconnectOptions,
+        options: ClientOptionsOut<TClientContext>,
+        path: readonly string[],
+        input: unknown
+    ]>;
+    /**
+     * Function to determine if an error is retryable.
+     *
+     * @default true
+     */
+    eventSourceRetry?: Value<boolean, [
+        reconnectOptions: EventIteratorReconnectOptions,
+        options: ClientOptionsOut<TClientContext>,
+        path: readonly string[],
+        input: unknown
+    ]>;
+}
+declare class RPCLink<TClientContext extends ClientContext> implements ClientLink<TClientContext> {
+    private readonly fetch;
+    private readonly rpcSerializer;
+    private readonly maxUrlLength;
+    private readonly fallbackMethod;
+    private readonly method;
+    private readonly headers;
+    private readonly url;
+    private readonly eventSourceMaxNumberOfRetries;
+    private readonly eventSourceRetryDelay;
+    private readonly eventSourceRetry;
+    private readonly toFetchBodyOptions;
+    constructor(options: RPCLinkOptions<TClientContext>);
+    call(path: readonly string[], input: unknown, options: ClientOptionsOut<TClientContext>): Promise<unknown>;
+    private performCall;
+    private encodeRequest;
+}
+
+export { type FetchWithContext, InvalidEventSourceRetryResponse, RPCLink, type RPCLinkOptions };

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

@@ -0,0 +1,103 @@
+import { Value } from '@orpc/shared';
+import { ToFetchBodyOptions } from '@orpc/standard-server-fetch';
+import { C as ClientContext, a as ClientOptionsOut, E as EventIteratorReconnectOptions, b as ClientLink } from '../../shared/client.D_CzLDyB.js';
+import { RPCSerializer } from '../standard/index.js';
+
+interface FetchWithContext<TClientContext extends ClientContext> {
+    (url: URL, init: RequestInit, options: ClientOptionsOut<TClientContext>, path: readonly string[], input: unknown): Promise<Response>;
+}
+
+type HTTPMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
+declare class InvalidEventSourceRetryResponse extends Error {
+}
+interface RPCLinkOptions<TClientContext extends ClientContext> extends ToFetchBodyOptions {
+    /**
+     * 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?: Value<HTTPMethod, [
+        options: ClientOptionsOut<TClientContext>,
+        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<[string, string][] | Record<string, string> | Headers, [
+        options: ClientOptionsOut<TClientContext>,
+        path: readonly string[],
+        input: unknown
+    ]>;
+    /**
+     * Custom fetch implementation.
+     *
+     * @default globalThis.fetch.bind(globalThis)
+     */
+    fetch?: FetchWithContext<TClientContext>;
+    rpcSerializer?: RPCSerializer;
+    /**
+     * Maximum number of retry attempts for EventSource errors before throwing.
+     *
+     * @default 5
+     */
+    eventSourceMaxNumberOfRetries?: number;
+    /**
+     * Delay (in ms) before retrying an EventSource call.
+     *
+     * @default ({retryTimes, lastRetry}) => lastRetry ?? (1000 * 2 ** retryTimes)
+     */
+    eventSourceRetryDelay?: Value<number, [
+        reconnectOptions: EventIteratorReconnectOptions,
+        options: ClientOptionsOut<TClientContext>,
+        path: readonly string[],
+        input: unknown
+    ]>;
+    /**
+     * Function to determine if an error is retryable.
+     *
+     * @default true
+     */
+    eventSourceRetry?: Value<boolean, [
+        reconnectOptions: EventIteratorReconnectOptions,
+        options: ClientOptionsOut<TClientContext>,
+        path: readonly string[],
+        input: unknown
+    ]>;
+}
+declare class RPCLink<TClientContext extends ClientContext> implements ClientLink<TClientContext> {
+    private readonly fetch;
+    private readonly rpcSerializer;
+    private readonly maxUrlLength;
+    private readonly fallbackMethod;
+    private readonly method;
+    private readonly headers;
+    private readonly url;
+    private readonly eventSourceMaxNumberOfRetries;
+    private readonly eventSourceRetryDelay;
+    private readonly eventSourceRetry;
+    private readonly toFetchBodyOptions;
+    constructor(options: RPCLinkOptions<TClientContext>);
+    call(path: readonly string[], input: unknown, options: ClientOptionsOut<TClientContext>): Promise<unknown>;
+    private performCall;
+    private encodeRequest;
+}
+
+export { type FetchWithContext, InvalidEventSourceRetryResponse, RPCLink, type RPCLinkOptions };

package/dist/adapters/fetch/index.mjs

@@ -0,0 +1,121 @@
+import { isAsyncIteratorObject, value, trim, stringifyJSON } from '@orpc/shared';
+import { toFetchBody, toStandardBody } from '@orpc/standard-server-fetch';
+import { c as createAutoRetryEventIterator, O as ORPCError } from '../../shared/client.Ly4zGQrc.mjs';
+import { a as RPCSerializer } from '../../shared/client.DHJ8vRIG.mjs';
+import '@orpc/standard-server';
+
+class InvalidEventSourceRetryResponse extends Error {
+}
+class RPCLink {
+  fetch;
+  rpcSerializer;
+  maxUrlLength;
+  fallbackMethod;
+  method;
+  headers;
+  url;
+  eventSourceMaxNumberOfRetries;
+  eventSourceRetryDelay;
+  eventSourceRetry;
+  toFetchBodyOptions;
+  constructor(options) {
+    this.fetch = options.fetch ?? globalThis.fetch.bind(globalThis);
+    this.rpcSerializer = options.rpcSerializer ?? new RPCSerializer();
+    this.maxUrlLength = options.maxUrlLength ?? 2083;
+    this.fallbackMethod = options.fallbackMethod ?? "POST";
+    this.url = options.url;
+    this.eventSourceMaxNumberOfRetries = options.eventSourceMaxNumberOfRetries ?? 5;
+    this.method = options.method ?? this.fallbackMethod;
+    this.headers = options.headers ?? {};
+    this.eventSourceRetry = options.eventSourceRetry ?? true;
+    this.eventSourceRetryDelay = options.eventSourceRetryDelay ?? (({ retryTimes, lastRetry }) => lastRetry ?? 1e3 * 2 ** retryTimes);
+    this.toFetchBodyOptions = options;
+  }
+  async call(path, input, options) {
+    const output = await this.performCall(path, input, options);
+    if (!isAsyncIteratorObject(output)) {
+      return output;
+    }
+    return createAutoRetryEventIterator(output, async (reconnectOptions) => {
+      if (options.signal?.aborted || reconnectOptions.retryTimes > this.eventSourceMaxNumberOfRetries) {
+        return null;
+      }
+      if (!await value(this.eventSourceRetry, reconnectOptions, options, path, input)) {
+        return null;
+      }
+      const delay = await value(this.eventSourceRetryDelay, reconnectOptions, options, path, input);
+      await new Promise((resolve) => setTimeout(resolve, delay));
+      const updatedOptions = { ...options, lastEventId: reconnectOptions.lastEventId };
+      const maybeIterator = await this.performCall(path, input, updatedOptions);
+      if (!isAsyncIteratorObject(maybeIterator)) {
+        throw new InvalidEventSourceRetryResponse("Invalid EventSource retry response");
+      }
+      return maybeIterator;
+    }, void 0);
+  }
+  async performCall(path, input, options) {
+    const encoded = await this.encodeRequest(path, input, options);
+    const fetchBody = toFetchBody(encoded.body, encoded.headers, this.toFetchBodyOptions);
+    if (options.lastEventId !== void 0) {
+      encoded.headers.set("last-event-id", options.lastEventId);
+    }
+    const response = await this.fetch(encoded.url, {
+      method: encoded.method,
+      headers: encoded.headers,
+      body: fetchBody,
+      signal: options.signal
+    }, options, path, input);
+    const body = await toStandardBody(response);
+    const deserialized = (() => {
+      try {
+        return this.rpcSerializer.deserialize(body);
+      } catch (error) {
+        if (response.ok) {
+          throw new ORPCError("INTERNAL_SERVER_ERROR", {
+            message: "Invalid RPC response",
+            cause: error
+          });
+        }
+        throw new ORPCError(response.status.toString(), {
+          message: response.statusText
+        });
+      }
+    })();
+    if (!response.ok) {
+      if (ORPCError.isValidJSON(deserialized)) {
+        throw ORPCError.fromJSON(deserialized);
+      }
+      throw new ORPCError("INTERNAL_SERVER_ERROR", {
+        message: "Invalid RPC error response",
+        cause: deserialized
+      });
+    }
+    return deserialized;
+  }
+  async encodeRequest(path, input, options) {
+    const expectedMethod = await value(this.method, options, path, input);
+    const headers = new Headers(await value(this.headers, options, path, input));
+    const url = new URL(`${trim(this.url, "/")}/${path.map(encodeURIComponent).join("/")}`);
+    const serialized = this.rpcSerializer.serialize(input);
+    if (expectedMethod === "GET" && !(serialized instanceof FormData) && !(serialized instanceof Blob) && !isAsyncIteratorObject(serialized)) {
+      const getUrl = new URL(url);
+      getUrl.searchParams.append("data", stringifyJSON(serialized) ?? "");
+      if (getUrl.toString().length <= this.maxUrlLength) {
+        return {
+          body: void 0,
+          method: expectedMethod,
+          headers,
+          url: getUrl
+        };
+      }
+    }
+    return {
+      url,
+      method: expectedMethod === "GET" ? this.fallbackMethod : expectedMethod,
+      headers,
+      body: serialized
+    };
+  }
+}
+
+export { InvalidEventSourceRetryResponse, RPCLink };

package/dist/adapters/standard/index.d.mts

@@ -0,0 +1,22 @@
+import { Segment } from '@orpc/shared';
+
+type RPCJsonSerializedMeta = [
+    0 | 1 | 2 | 3 | 4 | 5 | 6 | 7,
+    Segment[]
+][];
+type RPCJsonSerialized = [json: unknown, meta: RPCJsonSerializedMeta, maps: Segment[][], blobs: Blob[]];
+declare class RPCJsonSerializer {
+    serialize(data: unknown, segments?: Segment[], meta?: RPCJsonSerializedMeta, maps?: Segment[][], blobs?: Blob[]): RPCJsonSerialized;
+    deserialize(json: unknown, meta: RPCJsonSerializedMeta): unknown;
+    deserialize(json: unknown, meta: RPCJsonSerializedMeta, maps: Segment[][], getBlob: (index: number) => Blob): unknown;
+}
+
+declare class RPCSerializer {
+    #private;
+    private readonly jsonSerializer;
+    constructor(jsonSerializer?: RPCJsonSerializer);
+    serialize(data: unknown): unknown;
+    deserialize(data: unknown): unknown;
+}
+
+export { type RPCJsonSerialized, type RPCJsonSerializedMeta, RPCJsonSerializer, RPCSerializer };

package/dist/adapters/standard/index.d.ts

@@ -0,0 +1,22 @@
+import { Segment } from '@orpc/shared';
+
+type RPCJsonSerializedMeta = [
+    0 | 1 | 2 | 3 | 4 | 5 | 6 | 7,
+    Segment[]
+][];
+type RPCJsonSerialized = [json: unknown, meta: RPCJsonSerializedMeta, maps: Segment[][], blobs: Blob[]];
+declare class RPCJsonSerializer {
+    serialize(data: unknown, segments?: Segment[], meta?: RPCJsonSerializedMeta, maps?: Segment[][], blobs?: Blob[]): RPCJsonSerialized;
+    deserialize(json: unknown, meta: RPCJsonSerializedMeta): unknown;
+    deserialize(json: unknown, meta: RPCJsonSerializedMeta, maps: Segment[][], getBlob: (index: number) => Blob): unknown;
+}
+
+declare class RPCSerializer {
+    #private;
+    private readonly jsonSerializer;
+    constructor(jsonSerializer?: RPCJsonSerializer);
+    serialize(data: unknown): unknown;
+    deserialize(data: unknown): unknown;
+}
+
+export { type RPCJsonSerialized, type RPCJsonSerializedMeta, RPCJsonSerializer, RPCSerializer };

package/dist/adapters/standard/index.mjs

@@ -0,0 +1,4 @@
+export { R as RPCJsonSerializer, a as RPCSerializer } from '../../shared/client.DHJ8vRIG.mjs';
+import '@orpc/shared';
+import '@orpc/standard-server';
+import '../../shared/client.Ly4zGQrc.mjs';

package/dist/index.d.mts

@@ -0,0 +1,153 @@
+import { N as NestedClient, b as ClientLink, I as InferClientContext, C as ClientContext, a as ClientOptionsOut, c as ClientPromiseResult } from './shared/client.D_CzLDyB.mjs';
+export { g as Client, e as ClientOptions, f as ClientRest, E as EventIteratorReconnectOptions, d as createAutoRetryEventIterator, m as mapEventIterator } from './shared/client.D_CzLDyB.mjs';
+import { Promisable, MaybeOptionalOptions } from '@orpc/shared';
+export { ErrorEvent } from '@orpc/standard-server';
+
+interface createORPCClientOptions {
+    /**
+     * Use as base path for all procedure, useful when you only want to call a subset of the procedure.
+     */
+    path?: string[];
+}
+declare function createORPCClient<T extends NestedClient<any>>(link: ClientLink<InferClientContext<T>>, options?: createORPCClientOptions): T;
+
+/**
+ * DynamicLink provides a way to dynamically resolve and delegate calls to other ClientLinks
+ * based on the request path, input, and context.
+ */
+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>;
+}
+
+declare const COMMON_ORPC_ERROR_DEFS: {
+    readonly BAD_REQUEST: {
+        readonly status: 400;
+        readonly message: "Bad Request";
+    };
+    readonly UNAUTHORIZED: {
+        readonly status: 401;
+        readonly message: "Unauthorized";
+    };
+    readonly FORBIDDEN: {
+        readonly status: 403;
+        readonly message: "Forbidden";
+    };
+    readonly NOT_FOUND: {
+        readonly status: 404;
+        readonly message: "Not Found";
+    };
+    readonly METHOD_NOT_SUPPORTED: {
+        readonly status: 405;
+        readonly message: "Method Not Supported";
+    };
+    readonly NOT_ACCEPTABLE: {
+        readonly status: 406;
+        readonly message: "Not Acceptable";
+    };
+    readonly TIMEOUT: {
+        readonly status: 408;
+        readonly message: "Request Timeout";
+    };
+    readonly CONFLICT: {
+        readonly status: 409;
+        readonly message: "Conflict";
+    };
+    readonly PRECONDITION_FAILED: {
+        readonly status: 412;
+        readonly message: "Precondition Failed";
+    };
+    readonly PAYLOAD_TOO_LARGE: {
+        readonly status: 413;
+        readonly message: "Payload Too Large";
+    };
+    readonly UNSUPPORTED_MEDIA_TYPE: {
+        readonly status: 415;
+        readonly message: "Unsupported Media Type";
+    };
+    readonly UNPROCESSABLE_CONTENT: {
+        readonly status: 422;
+        readonly message: "Unprocessable Content";
+    };
+    readonly TOO_MANY_REQUESTS: {
+        readonly status: 429;
+        readonly message: "Too Many Requests";
+    };
+    readonly CLIENT_CLOSED_REQUEST: {
+        readonly status: 499;
+        readonly message: "Client Closed Request";
+    };
+    readonly INTERNAL_SERVER_ERROR: {
+        readonly status: 500;
+        readonly message: "Internal Server Error";
+    };
+    readonly NOT_IMPLEMENTED: {
+        readonly status: 501;
+        readonly message: "Not Implemented";
+    };
+    readonly BAD_GATEWAY: {
+        readonly status: 502;
+        readonly message: "Bad Gateway";
+    };
+    readonly SERVICE_UNAVAILABLE: {
+        readonly status: 503;
+        readonly message: "Service Unavailable";
+    };
+    readonly GATEWAY_TIMEOUT: {
+        readonly status: 504;
+        readonly message: "Gateway Timeout";
+    };
+};
+type CommonORPCErrorCode = keyof typeof COMMON_ORPC_ERROR_DEFS;
+type ORPCErrorCode = CommonORPCErrorCode | (string & {});
+declare function fallbackORPCErrorStatus(code: ORPCErrorCode, status: number | undefined): number;
+declare function fallbackORPCErrorMessage(code: ORPCErrorCode, message: string | undefined): string;
+type ORPCErrorOptions<TData> = ErrorOptions & {
+    defined?: boolean;
+    status?: number;
+    message?: string;
+} & (undefined extends TData ? {
+    data?: TData;
+} : {
+    data: TData;
+});
+declare class ORPCError<TCode extends ORPCErrorCode, TData> extends Error {
+    readonly defined: boolean;
+    readonly code: TCode;
+    readonly status: number;
+    readonly data: TData;
+    constructor(code: TCode, ...[options]: MaybeOptionalOptions<ORPCErrorOptions<TData>>);
+    toJSON(): ORPCErrorJSON<TCode, TData>;
+    static fromJSON<TCode extends ORPCErrorCode, TData>(json: ORPCErrorJSON<TCode, TData>, options?: ErrorOptions): ORPCError<TCode, TData>;
+    static isValidJSON(json: unknown): json is ORPCErrorJSON<ORPCErrorCode, unknown>;
+}
+type ORPCErrorJSON<TCode extends string, TData> = Pick<ORPCError<TCode, TData>, 'defined' | 'code' | 'status' | 'message' | 'data'>;
+declare function isDefinedError<T>(error: T): error is Extract<T, ORPCError<any, any>>;
+declare function toORPCError(error: unknown): ORPCError<any, any>;
+
+type ConnectionStatus = 'reconnecting' | 'connected' | 'closed';
+interface EventIteratorState {
+    status: ConnectionStatus;
+    listeners: Array<(newStatus: ConnectionStatus) => void>;
+}
+declare function registerEventIteratorState(iterator: AsyncIteratorObject<unknown, unknown, void>, state: EventIteratorState): void;
+declare function updateEventIteratorStatus(state: EventIteratorState, status: ConnectionStatus): void;
+declare function onEventIteratorStatusChange(iterator: AsyncIteratorObject<unknown, unknown, void>, callback: (status: ConnectionStatus) => void, notifyImmediately?: boolean): () => void;
+
+type SafeResult<TOutput, TError extends Error> = [error: null, data: TOutput, isDefined: false] & {
+    error: null;
+    data: TOutput;
+    isDefined: false;
+} | [error: Exclude<TError, ORPCError<any, any>>, data: undefined, isDefined: false] & {
+    error: Exclude<TError, ORPCError<any, any>>;
+    data: undefined;
+    isDefined: false;
+} | [error: Extract<TError, ORPCError<any, any>>, data: undefined, isDefined: true] & {
+    error: Extract<TError, ORPCError<any, any>>;
+    data: undefined;
+    isDefined: true;
+};
+declare function safe<TOutput, TError extends Error>(promise: ClientPromiseResult<TOutput, TError>): Promise<SafeResult<TOutput, TError>>;
+
+export { COMMON_ORPC_ERROR_DEFS, ClientContext, ClientLink, ClientOptionsOut, ClientPromiseResult, type CommonORPCErrorCode, type ConnectionStatus, DynamicLink, type EventIteratorState, InferClientContext, NestedClient, ORPCError, type ORPCErrorCode, type ORPCErrorJSON, type ORPCErrorOptions, type SafeResult, createORPCClient, type createORPCClientOptions, fallbackORPCErrorMessage, fallbackORPCErrorStatus, isDefinedError, onEventIteratorStatusChange, registerEventIteratorState, safe, toORPCError, updateEventIteratorStatus };