@orpc/client 0.0.0-next.cc4cb21 → 0.0.0-next.cc8802c

package/README.md

@@ -1,5 +1,5 @@
 <div align="center">
-  <image align="center" src="https://orpc.unnoq.com/logo.webp" width=280 />
+  <image align="center" src="https://orpc.unnoq.com/logo.webp" width=280 alt="oRPC logo" />
 </div>
 
 <h1></h1>

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

@@ -0,0 +1,29 @@
+import { StandardRequest, StandardLazyResponse } from '@orpc/standard-server';
+import { ToFetchRequestOptions } from '@orpc/standard-server-fetch';
+import { C as ClientContext, a as ClientOptionsOut, b as ClientLink } from '../../shared/client.D_CzLDyB.mjs';
+import { StandardLinkClient, StandardLinkOptions, StandardRPCLinkCodecOptions } from '../standard/index.mjs';
+import '@orpc/shared';
+
+interface LinkFetchClientOptions<T extends ClientContext> extends ToFetchRequestOptions {
+    fetch?: (request: Request, init: Record<never, never>, options: ClientOptionsOut<T>, path: readonly string[], input: unknown) => Promise<Response>;
+}
+declare class LinkFetchClient<T extends ClientContext> implements StandardLinkClient<T> {
+    private readonly fetch;
+    private readonly toFetchRequestOptions;
+    constructor(options: LinkFetchClientOptions<T>);
+    call(request: StandardRequest, options: ClientOptionsOut<T>, path: readonly string[], input: unknown): Promise<StandardLazyResponse>;
+}
+
+interface RPCLinkOptions<T extends ClientContext> extends StandardLinkOptions<T>, StandardRPCLinkCodecOptions<T>, LinkFetchClientOptions<T> {
+}
+declare class RPCLink<T extends ClientContext> implements ClientLink<T> {
+    private readonly standardLink;
+    constructor(options: RPCLinkOptions<T>);
+    call(path: readonly string[], input: unknown, options: ClientOptionsOut<T>): Promise<unknown>;
+}
+
+interface FetchWithContext<TClientContext extends ClientContext> {
+    (url: URL, init: RequestInit, options: ClientOptionsOut<TClientContext>, path: readonly string[], input: unknown): Promise<Response>;
+}
+
+export { type FetchWithContext, LinkFetchClient, type LinkFetchClientOptions, RPCLink, type RPCLinkOptions };

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

@@ -0,0 +1,29 @@
+import { StandardRequest, StandardLazyResponse } from '@orpc/standard-server';
+import { ToFetchRequestOptions } from '@orpc/standard-server-fetch';
+import { C as ClientContext, a as ClientOptionsOut, b as ClientLink } from '../../shared/client.D_CzLDyB.js';
+import { StandardLinkClient, StandardLinkOptions, StandardRPCLinkCodecOptions } from '../standard/index.js';
+import '@orpc/shared';
+
+interface LinkFetchClientOptions<T extends ClientContext> extends ToFetchRequestOptions {
+    fetch?: (request: Request, init: Record<never, never>, options: ClientOptionsOut<T>, path: readonly string[], input: unknown) => Promise<Response>;
+}
+declare class LinkFetchClient<T extends ClientContext> implements StandardLinkClient<T> {
+    private readonly fetch;
+    private readonly toFetchRequestOptions;
+    constructor(options: LinkFetchClientOptions<T>);
+    call(request: StandardRequest, options: ClientOptionsOut<T>, path: readonly string[], input: unknown): Promise<StandardLazyResponse>;
+}
+
+interface RPCLinkOptions<T extends ClientContext> extends StandardLinkOptions<T>, StandardRPCLinkCodecOptions<T>, LinkFetchClientOptions<T> {
+}
+declare class RPCLink<T extends ClientContext> implements ClientLink<T> {
+    private readonly standardLink;
+    constructor(options: RPCLinkOptions<T>);
+    call(path: readonly string[], input: unknown, options: ClientOptionsOut<T>): Promise<unknown>;
+}
+
+interface FetchWithContext<TClientContext extends ClientContext> {
+    (url: URL, init: RequestInit, options: ClientOptionsOut<TClientContext>, path: readonly string[], input: unknown): Promise<Response>;
+}
+
+export { type FetchWithContext, LinkFetchClient, type LinkFetchClientOptions, RPCLink, type RPCLinkOptions };

package/dist/adapters/fetch/index.mjs

@@ -0,0 +1,35 @@
+import { toFetchRequest, toStandardLazyResponse } from '@orpc/standard-server-fetch';
+import { a as StandardRPCLinkCodec, b as RPCSerializer, S as StandardLink } from '../../shared/client.Df5pd75N.mjs';
+import '@orpc/shared';
+import '../../shared/client.XAn8cDTM.mjs';
+import '@orpc/standard-server';
+
+class LinkFetchClient {
+  fetch;
+  toFetchRequestOptions;
+  constructor(options) {
+    this.fetch = options?.fetch ?? globalThis.fetch.bind(globalThis);
+    this.toFetchRequestOptions = options;
+  }
+  async call(request, options, path, input) {
+    const fetchRequest = toFetchRequest(request, this.toFetchRequestOptions);
+    const fetchResponse = await this.fetch(fetchRequest, {}, options, path, input);
+    const lazyResponse = toStandardLazyResponse(fetchResponse);
+    return lazyResponse;
+  }
+}
+
+class RPCLink {
+  standardLink;
+  constructor(options) {
+    const serializer = new RPCSerializer();
+    const linkCodec = new StandardRPCLinkCodec(serializer, options);
+    const linkClient = new LinkFetchClient(options);
+    this.standardLink = new StandardLink(linkCodec, linkClient, options);
+  }
+  async call(path, input, options) {
+    return this.standardLink.call(path, input, options);
+  }
+}
+
+export { LinkFetchClient, RPCLink };

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

@@ -0,0 +1,148 @@
+import { Value, Interceptor, Segment } from '@orpc/shared';
+import { StandardRequest, StandardLazyResponse, StandardHeaders } from '@orpc/standard-server';
+import { C as ClientContext, a as ClientOptionsOut, E as EventIteratorReconnectOptions, b as ClientLink } from '../../shared/client.D_CzLDyB.mjs';
+
+interface StandardLinkCodec<T extends ClientContext> {
+    encode(path: readonly string[], input: unknown, options: ClientOptionsOut<any>): Promise<StandardRequest>;
+    decode(response: StandardLazyResponse, options: ClientOptionsOut<T>, path: readonly string[], input: unknown): Promise<unknown>;
+}
+interface StandardLinkClient<T extends ClientContext> {
+    call(request: StandardRequest, options: ClientOptionsOut<T>, path: readonly string[], input: unknown): Promise<StandardLazyResponse>;
+}
+
+declare class InvalidEventIteratorRetryResponse extends Error {
+}
+interface StandardLinkOptions<T extends ClientContext> {
+    /**
+     * Maximum number of retry attempts for event iterator errors before throwing.
+     *
+     * @default 5
+     */
+    eventIteratorMaxRetries?: Value<number, [
+        reconnectOptions: EventIteratorReconnectOptions,
+        options: ClientOptionsOut<T>,
+        path: readonly string[],
+        input: unknown
+    ]>;
+    /**
+     * Delay (in ms) before retrying an event iterator call.
+     *
+     * @default (o) => o.lastRetry ?? (1000 * 2 ** o.retryTimes)
+     */
+    eventIteratorRetryDelay?: Value<number, [
+        reconnectOptions: EventIteratorReconnectOptions,
+        options: ClientOptionsOut<T>,
+        path: readonly string[],
+        input: unknown
+    ]>;
+    /**
+     * Function to determine if an error is retryable.
+     *
+     * @default true
+     */
+    eventIteratorShouldRetry?: Value<boolean, [
+        reconnectOptions: EventIteratorReconnectOptions,
+        options: ClientOptionsOut<T>,
+        path: readonly string[],
+        input: unknown
+    ]>;
+    interceptors?: Interceptor<{
+        path: readonly string[];
+        input: unknown;
+        options: ClientOptionsOut<T>;
+    }, unknown, unknown>[];
+    clientInterceptors?: Interceptor<{
+        request: StandardRequest;
+    }, StandardLazyResponse, unknown>[];
+}
+declare class StandardLink<T extends ClientContext> implements ClientLink<T> {
+    #private;
+    readonly codec: StandardLinkCodec<T>;
+    readonly sender: StandardLinkClient<T>;
+    private readonly eventIteratorMaxRetries;
+    private readonly eventIteratorRetryDelay;
+    private readonly eventIteratorShouldRetry;
+    private readonly interceptors;
+    private readonly clientInterceptors;
+    constructor(codec: StandardLinkCodec<T>, sender: StandardLinkClient<T>, options: StandardLinkOptions<T>);
+    call(path: readonly string[], input: unknown, options: ClientOptionsOut<T>): Promise<unknown>;
+}
+
+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;
+}
+
+type HTTPMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
+interface StandardRPCLinkCodecOptions<T extends ClientContext> {
+    /**
+     * Base url for all requests.
+     */
+    url: Value<string | URL, [
+        options: ClientOptionsOut<T>,
+        path: readonly string[],
+        input: unknown
+    ]>;
+    /**
+     * The maximum length of the URL.
+     *
+     * @default 2083
+     */
+    maxUrlLength?: Value<number, [
+        options: ClientOptionsOut<T>,
+        path: readonly string[],
+        input: unknown
+    ]>;
+    /**
+     * The method used to make the request.
+     *
+     * @default 'POST'
+     */
+    method?: Value<HTTPMethod, [
+        options: ClientOptionsOut<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: ClientOptionsOut<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: RPCSerializer, options: StandardRPCLinkCodecOptions<T>);
+    encode(path: readonly string[], input: unknown, options: ClientOptionsOut<any>): Promise<StandardRequest>;
+    decode(response: StandardLazyResponse): Promise<unknown>;
+}
+
+export { InvalidEventIteratorRetryResponse, type RPCJsonSerialized, type RPCJsonSerializedMeta, RPCJsonSerializer, RPCSerializer, StandardLink, type StandardLinkClient, type StandardLinkCodec, type StandardLinkOptions, StandardRPCLinkCodec, type StandardRPCLinkCodecOptions };

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

@@ -0,0 +1,148 @@
+import { Value, Interceptor, Segment } from '@orpc/shared';
+import { StandardRequest, StandardLazyResponse, StandardHeaders } from '@orpc/standard-server';
+import { C as ClientContext, a as ClientOptionsOut, E as EventIteratorReconnectOptions, b as ClientLink } from '../../shared/client.D_CzLDyB.js';
+
+interface StandardLinkCodec<T extends ClientContext> {
+    encode(path: readonly string[], input: unknown, options: ClientOptionsOut<any>): Promise<StandardRequest>;
+    decode(response: StandardLazyResponse, options: ClientOptionsOut<T>, path: readonly string[], input: unknown): Promise<unknown>;
+}
+interface StandardLinkClient<T extends ClientContext> {
+    call(request: StandardRequest, options: ClientOptionsOut<T>, path: readonly string[], input: unknown): Promise<StandardLazyResponse>;
+}
+
+declare class InvalidEventIteratorRetryResponse extends Error {
+}
+interface StandardLinkOptions<T extends ClientContext> {
+    /**
+     * Maximum number of retry attempts for event iterator errors before throwing.
+     *
+     * @default 5
+     */
+    eventIteratorMaxRetries?: Value<number, [
+        reconnectOptions: EventIteratorReconnectOptions,
+        options: ClientOptionsOut<T>,
+        path: readonly string[],
+        input: unknown
+    ]>;
+    /**
+     * Delay (in ms) before retrying an event iterator call.
+     *
+     * @default (o) => o.lastRetry ?? (1000 * 2 ** o.retryTimes)
+     */
+    eventIteratorRetryDelay?: Value<number, [
+        reconnectOptions: EventIteratorReconnectOptions,
+        options: ClientOptionsOut<T>,
+        path: readonly string[],
+        input: unknown
+    ]>;
+    /**
+     * Function to determine if an error is retryable.
+     *
+     * @default true
+     */
+    eventIteratorShouldRetry?: Value<boolean, [
+        reconnectOptions: EventIteratorReconnectOptions,
+        options: ClientOptionsOut<T>,
+        path: readonly string[],
+        input: unknown
+    ]>;
+    interceptors?: Interceptor<{
+        path: readonly string[];
+        input: unknown;
+        options: ClientOptionsOut<T>;
+    }, unknown, unknown>[];
+    clientInterceptors?: Interceptor<{
+        request: StandardRequest;
+    }, StandardLazyResponse, unknown>[];
+}
+declare class StandardLink<T extends ClientContext> implements ClientLink<T> {
+    #private;
+    readonly codec: StandardLinkCodec<T>;
+    readonly sender: StandardLinkClient<T>;
+    private readonly eventIteratorMaxRetries;
+    private readonly eventIteratorRetryDelay;
+    private readonly eventIteratorShouldRetry;
+    private readonly interceptors;
+    private readonly clientInterceptors;
+    constructor(codec: StandardLinkCodec<T>, sender: StandardLinkClient<T>, options: StandardLinkOptions<T>);
+    call(path: readonly string[], input: unknown, options: ClientOptionsOut<T>): Promise<unknown>;
+}
+
+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;
+}
+
+type HTTPMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
+interface StandardRPCLinkCodecOptions<T extends ClientContext> {
+    /**
+     * Base url for all requests.
+     */
+    url: Value<string | URL, [
+        options: ClientOptionsOut<T>,
+        path: readonly string[],
+        input: unknown
+    ]>;
+    /**
+     * The maximum length of the URL.
+     *
+     * @default 2083
+     */
+    maxUrlLength?: Value<number, [
+        options: ClientOptionsOut<T>,
+        path: readonly string[],
+        input: unknown
+    ]>;
+    /**
+     * The method used to make the request.
+     *
+     * @default 'POST'
+     */
+    method?: Value<HTTPMethod, [
+        options: ClientOptionsOut<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: ClientOptionsOut<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: RPCSerializer, options: StandardRPCLinkCodecOptions<T>);
+    encode(path: readonly string[], input: unknown, options: ClientOptionsOut<any>): Promise<StandardRequest>;
+    decode(response: StandardLazyResponse): Promise<unknown>;
+}
+
+export { InvalidEventIteratorRetryResponse, type RPCJsonSerialized, type RPCJsonSerializedMeta, RPCJsonSerializer, RPCSerializer, StandardLink, type StandardLinkClient, type StandardLinkCodec, type StandardLinkOptions, StandardRPCLinkCodec, type StandardRPCLinkCodecOptions };

package/dist/adapters/standard/index.mjs

@@ -0,0 +1,4 @@
+export { I as InvalidEventIteratorRetryResponse, R as RPCJsonSerializer, b as RPCSerializer, S as StandardLink, a as StandardRPCLinkCodec } from '../../shared/client.Df5pd75N.mjs';
+import '@orpc/shared';
+import '../../shared/client.XAn8cDTM.mjs';
+import '@orpc/standard-server';

package/dist/index.d.mts

@@ -0,0 +1,155 @@
+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, options?: {
+    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 };