@orpc/client 0.0.0-next.cd121e3 → 0.0.0-next.ce2f84d

package/dist/index.d.ts

@@ -1,6 +1,7 @@
-import { N as NestedClient, b as ClientLink, I as InferClientContext, C as ClientContext, a as ClientOptionsOut, c as ClientPromiseResult } from './shared/client.D_CzLDyB.js';
-export { g as Client, e as ClientOptions, f as ClientRest, E as EventIteratorReconnectOptions, d as createAutoRetryEventIterator, m as mapEventIterator } from './shared/client.D_CzLDyB.js';
-import { Promisable, MaybeOptionalOptions } from '@orpc/shared';
+import { N as NestedClient, C as ClientLink, I as InferClientContext, a as ClientContext, b as ClientOptions, c as ClientPromiseResult, F as FriendlyClientOptions } from './shared/client.C0lT7w02.js';
+export { f as Client, e as ClientRest, d as HTTPMethod, H as HTTPPath } from './shared/client.C0lT7w02.js';
+import { Promisable, MaybeOptionalOptions, ThrowableError } from '@orpc/shared';
+export { Registry, ThrowableError, onError, onFinish, onStart, onSuccess } from '@orpc/shared';
 export { ErrorEvent } from '@orpc/standard-server';
 
 interface createORPCClientOptions {
@@ -17,8 +18,8 @@ declare function createORPCClient<T extends NestedClient<any>>(link: ClientLink<
  */
 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>;
+    constructor(linkResolver: (options: ClientOptions<TClientContext>, path: readonly string[], input: unknown) => Promisable<ClientLink<TClientContext>>);
+    call(path: readonly string[], input: unknown, options: ClientOptions<TClientContext>): Promise<unknown>;
 }
 
 declare const COMMON_ORPC_ERROR_DEFS: {
@@ -125,29 +126,30 @@ declare class ORPCError<TCode extends ORPCErrorCode, TData> extends Error {
 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>;
+declare function isORPCErrorStatus(status: number): boolean;
 
-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;
+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>;
 
-type SafeResult<TOutput, TError extends Error> = [error: null, data: TOutput, isDefined: false] & {
+type SafeResult<TOutput, TError> = [error: null, data: TOutput, isDefined: false, isSuccess: true] & {
     error: null;
     data: TOutput;
     isDefined: false;
-} | [error: Exclude<TError, ORPCError<any, any>>, data: undefined, isDefined: false] & {
+    isSuccess: true;
+} | [error: Exclude<TError, ORPCError<any, any>>, data: undefined, isDefined: false, isSuccess: false] & {
     error: Exclude<TError, ORPCError<any, any>>;
     data: undefined;
     isDefined: false;
-} | [error: Extract<TError, ORPCError<any, any>>, data: undefined, isDefined: true] & {
+    isSuccess: false;
+} | [error: Extract<TError, ORPCError<any, any>>, data: undefined, isDefined: true, isSuccess: false] & {
     error: Extract<TError, ORPCError<any, any>>;
     data: undefined;
     isDefined: true;
+    isSuccess: false;
 };
-declare function safe<TOutput, TError extends Error>(promise: ClientPromiseResult<TOutput, TError>): Promise<SafeResult<TOutput, TError>>;
+declare function safe<TOutput, TError = ThrowableError>(promise: ClientPromiseResult<TOutput, TError>): Promise<SafeResult<TOutput, TError>>;
+declare function resolveFriendlyClientOptions<T extends ClientContext>(options: FriendlyClientOptions<T>): ClientOptions<T>;
 
-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 };
+export { COMMON_ORPC_ERROR_DEFS, ClientContext, ClientLink, ClientOptions, ClientPromiseResult, type CommonORPCErrorCode, DynamicLink, FriendlyClientOptions, InferClientContext, NestedClient, ORPCError, type ORPCErrorCode, type ORPCErrorJSON, type ORPCErrorOptions, type SafeResult, createORPCClient, type createORPCClientOptions, fallbackORPCErrorMessage, fallbackORPCErrorStatus, isDefinedError, isORPCErrorStatus, mapEventIterator, resolveFriendlyClientOptions, safe, toORPCError };

package/dist/index.mjs

@@ -1,17 +1,41 @@
-import { i as isDefinedError } from './shared/client.Ly4zGQrc.mjs';
-export { C as COMMON_ORPC_ERROR_DEFS, O as ORPCError, c as createAutoRetryEventIterator, a as fallbackORPCErrorMessage, f as fallbackORPCErrorStatus, m as mapEventIterator, o as onEventIteratorStatusChange, r as registerEventIteratorState, t as toORPCError, u as updateEventIteratorStatus } from './shared/client.Ly4zGQrc.mjs';
+import { i as isDefinedError } from './shared/client.jKEwIsRd.mjs';
+export { C as COMMON_ORPC_ERROR_DEFS, O as ORPCError, a as fallbackORPCErrorMessage, f as fallbackORPCErrorStatus, b as isORPCErrorStatus, m as mapEventIterator, t as toORPCError } from './shared/client.jKEwIsRd.mjs';
+export { onError, onFinish, onStart, onSuccess } from '@orpc/shared';
 export { ErrorEvent } from '@orpc/standard-server';
-import '@orpc/shared';
+
+async function safe(promise) {
+  try {
+    const output = await promise;
+    return Object.assign(
+      [null, output, false, true],
+      { error: null, data: output, isDefined: false, isSuccess: true }
+    );
+  } catch (e) {
+    const error = e;
+    if (isDefinedError(error)) {
+      return Object.assign(
+        [error, void 0, true, false],
+        { error, data: void 0, isDefined: true, isSuccess: false }
+      );
+    }
+    return Object.assign(
+      [error, void 0, false, false],
+      { error, data: void 0, isDefined: false, isSuccess: false }
+    );
+  }
+}
+function resolveFriendlyClientOptions(options) {
+  return {
+    ...options,
+    context: options?.context ?? {}
+    // Context only optional if all fields are optional
+  };
+}
 
 function createORPCClient(link, options) {
   const path = options?.path ?? [];
-  const procedureClient = async (...[input, options2]) => {
-    const optionsOut = {
-      ...options2,
-      context: options2?.context ?? {}
-      // options.context can be undefined when all field is optional
-    };
-    return await link.call(path, input, optionsOut);
+  const procedureClient = async (...[input, options2 = {}]) => {
+    return await link.call(path, input, resolveFriendlyClientOptions(options2));
   };
   const recursive = new Proxy(procedureClient, {
     get(target, key) {
@@ -38,26 +62,4 @@ class DynamicLink {
   }
 }
 
-async function safe(promise) {
-  try {
-    const output = await promise;
-    return Object.assign(
-      [null, output, false],
-      { error: null, data: output, isDefined: false }
-    );
-  } catch (e) {
-    const error = e;
-    if (isDefinedError(error)) {
-      return Object.assign(
-        [error, void 0, true],
-        { error, data: void 0, isDefined: true }
-      );
-    }
-    return Object.assign(
-      [error, void 0, false],
-      { error, data: void 0, isDefined: false }
-    );
-  }
-}
-
-export { DynamicLink, createORPCClient, isDefinedError, safe };
+export { DynamicLink, createORPCClient, isDefinedError, resolveFriendlyClientOptions, safe };

package/dist/plugins/index.d.mts

@@ -0,0 +1,65 @@
+import { Value } from '@orpc/shared';
+import { S as StandardLinkPlugin, a as StandardLinkOptions } from '../shared/client.5813Ufvs.mjs';
+import { b as ClientOptions } from '../shared/client.C0lT7w02.mjs';
+import '@orpc/standard-server';
+
+interface ClientRetryPluginAttemptOptions {
+    lastEventRetry: number | undefined;
+    lastEventId: string | undefined;
+    attemptIndex: number;
+    error: unknown;
+}
+interface ClientRetryPluginContext {
+    /**
+     * Maximum retry attempts before throwing
+     * Use `Number.POSITIVE_INFINITY` for infinite retries (e.g., when handling Server-Sent Events).
+     *
+     * @default 0
+     */
+    retry?: Value<number, [
+        clientOptions: ClientOptions<ClientRetryPluginContext>,
+        path: readonly string[],
+        input: unknown
+    ]>;
+    /**
+     * Delay (in ms) before retrying.
+     *
+     * @default (o) => o.lastEventRetry ?? 2000
+     */
+    retryDelay?: Value<number, [
+        attemptOptions: ClientRetryPluginAttemptOptions,
+        clientOptions: ClientOptions<ClientRetryPluginContext>,
+        path: readonly string[],
+        input: unknown
+    ]>;
+    /**
+     * Determine should retry or not.
+     *
+     * @default true
+     */
+    shouldRetry?: Value<boolean, [
+        attemptOptions: ClientRetryPluginAttemptOptions,
+        clientOptions: ClientOptions<ClientRetryPluginContext>,
+        path: readonly string[],
+        input: unknown
+    ]>;
+    /**
+     * The hook called when retrying, and return the unsubscribe function.
+     */
+    onRetry?: (options: ClientRetryPluginAttemptOptions, clientOptions: ClientOptions<ClientRetryPluginContext>, path: readonly string[], input: unknown) => void | (() => void);
+}
+declare class ClientRetryPluginInvalidEventIteratorRetryResponse extends Error {
+}
+interface ClientRetryPluginOptions {
+    default?: ClientRetryPluginContext;
+}
+declare class ClientRetryPlugin<T extends ClientRetryPluginContext> implements StandardLinkPlugin<T> {
+    private readonly defaultRetry;
+    private readonly defaultRetryDelay;
+    private readonly defaultShouldRetry;
+    private readonly defaultOnRetry;
+    constructor(options?: ClientRetryPluginOptions);
+    init(options: StandardLinkOptions<T>): void;
+}
+
+export { ClientRetryPlugin, type ClientRetryPluginAttemptOptions, type ClientRetryPluginContext, ClientRetryPluginInvalidEventIteratorRetryResponse, type ClientRetryPluginOptions };

package/dist/plugins/index.d.ts

@@ -0,0 +1,65 @@
+import { Value } from '@orpc/shared';
+import { S as StandardLinkPlugin, a as StandardLinkOptions } from '../shared/client.grRbC25r.js';
+import { b as ClientOptions } from '../shared/client.C0lT7w02.js';
+import '@orpc/standard-server';
+
+interface ClientRetryPluginAttemptOptions {
+    lastEventRetry: number | undefined;
+    lastEventId: string | undefined;
+    attemptIndex: number;
+    error: unknown;
+}
+interface ClientRetryPluginContext {
+    /**
+     * Maximum retry attempts before throwing
+     * Use `Number.POSITIVE_INFINITY` for infinite retries (e.g., when handling Server-Sent Events).
+     *
+     * @default 0
+     */
+    retry?: Value<number, [
+        clientOptions: ClientOptions<ClientRetryPluginContext>,
+        path: readonly string[],
+        input: unknown
+    ]>;
+    /**
+     * Delay (in ms) before retrying.
+     *
+     * @default (o) => o.lastEventRetry ?? 2000
+     */
+    retryDelay?: Value<number, [
+        attemptOptions: ClientRetryPluginAttemptOptions,
+        clientOptions: ClientOptions<ClientRetryPluginContext>,
+        path: readonly string[],
+        input: unknown
+    ]>;
+    /**
+     * Determine should retry or not.
+     *
+     * @default true
+     */
+    shouldRetry?: Value<boolean, [
+        attemptOptions: ClientRetryPluginAttemptOptions,
+        clientOptions: ClientOptions<ClientRetryPluginContext>,
+        path: readonly string[],
+        input: unknown
+    ]>;
+    /**
+     * The hook called when retrying, and return the unsubscribe function.
+     */
+    onRetry?: (options: ClientRetryPluginAttemptOptions, clientOptions: ClientOptions<ClientRetryPluginContext>, path: readonly string[], input: unknown) => void | (() => void);
+}
+declare class ClientRetryPluginInvalidEventIteratorRetryResponse extends Error {
+}
+interface ClientRetryPluginOptions {
+    default?: ClientRetryPluginContext;
+}
+declare class ClientRetryPlugin<T extends ClientRetryPluginContext> implements StandardLinkPlugin<T> {
+    private readonly defaultRetry;
+    private readonly defaultRetryDelay;
+    private readonly defaultShouldRetry;
+    private readonly defaultOnRetry;
+    constructor(options?: ClientRetryPluginOptions);
+    init(options: StandardLinkOptions<T>): void;
+}
+
+export { ClientRetryPlugin, type ClientRetryPluginAttemptOptions, type ClientRetryPluginContext, ClientRetryPluginInvalidEventIteratorRetryResponse, type ClientRetryPluginOptions };

package/dist/plugins/index.mjs

@@ -0,0 +1,131 @@
+import { value, isAsyncIteratorObject } from '@orpc/shared';
+import { getEventMeta } from '@orpc/standard-server';
+
+class ClientRetryPluginInvalidEventIteratorRetryResponse extends Error {
+}
+class ClientRetryPlugin {
+  defaultRetry;
+  defaultRetryDelay;
+  defaultShouldRetry;
+  defaultOnRetry;
+  constructor(options = {}) {
+    this.defaultRetry = options.default?.retry ?? 0;
+    this.defaultRetryDelay = options.default?.retryDelay ?? ((o) => o.lastEventRetry ?? 2e3);
+    this.defaultShouldRetry = options.default?.shouldRetry ?? true;
+    this.defaultOnRetry = options.default?.onRetry;
+  }
+  init(options) {
+    options.interceptors ??= [];
+    options.interceptors.push(async (interceptorOptions) => {
+      const maxAttempts = await value(
+        interceptorOptions.options.context.retry ?? this.defaultRetry,
+        interceptorOptions.options,
+        interceptorOptions.path,
+        interceptorOptions.input
+      );
+      const retryDelay = interceptorOptions.options.context.retryDelay ?? this.defaultRetryDelay;
+      const shouldRetry = interceptorOptions.options.context.shouldRetry ?? this.defaultShouldRetry;
+      const onRetry = interceptorOptions.options.context.onRetry ?? this.defaultOnRetry;
+      if (maxAttempts <= 0) {
+        return interceptorOptions.next();
+      }
+      let lastEventId = interceptorOptions.options.lastEventId;
+      let lastEventRetry;
+      let unsubscribe;
+      let attemptIndex = 0;
+      const next = async (initial) => {
+        let current = initial;
+        while (true) {
+          const newClientOptions = { ...interceptorOptions.options, lastEventId };
+          if (current) {
+            if (attemptIndex >= maxAttempts) {
+              throw current.error;
+            }
+            const attemptOptions = {
+              attemptIndex,
+              error: current.error,
+              lastEventId,
+              lastEventRetry
+            };
+            const shouldRetryBool = await value(
+              shouldRetry,
+              attemptOptions,
+              newClientOptions,
+              interceptorOptions.path,
+              interceptorOptions.input
+            );
+            if (!shouldRetryBool) {
+              throw current.error;
+            }
+            unsubscribe = onRetry?.(
+              attemptOptions,
+              newClientOptions,
+              interceptorOptions.path,
+              interceptorOptions.input
+            );
+            const retryDelayMs = await value(
+              retryDelay,
+              attemptOptions,
+              newClientOptions,
+              interceptorOptions.path,
+              interceptorOptions.input
+            );
+            await new Promise((resolve) => setTimeout(resolve, retryDelayMs));
+            attemptIndex++;
+          }
+          try {
+            const output2 = await interceptorOptions.next({
+              ...interceptorOptions,
+              options: newClientOptions
+            });
+            return output2;
+          } catch (error) {
+            if (newClientOptions.signal?.aborted === true) {
+              throw error;
+            }
+            current = { error };
+          } finally {
+            unsubscribe?.();
+            unsubscribe = void 0;
+          }
+        }
+      };
+      const output = await next();
+      if (!isAsyncIteratorObject(output)) {
+        return output;
+      }
+      return async function* () {
+        let current = output;
+        try {
+          while (true) {
+            try {
+              const item = await current.next();
+              const meta = getEventMeta(item.value);
+              lastEventId = meta?.id ?? lastEventId;
+              lastEventRetry = meta?.retry ?? lastEventRetry;
+              if (item.done) {
+                return item.value;
+              }
+              yield item.value;
+            } catch (error) {
+              const meta = getEventMeta(error);
+              lastEventId = meta?.id ?? lastEventId;
+              lastEventRetry = meta?.retry ?? lastEventRetry;
+              const maybeEventIterator = await next({ error });
+              if (!isAsyncIteratorObject(maybeEventIterator)) {
+                throw new ClientRetryPluginInvalidEventIteratorRetryResponse(
+                  "RetryPlugin: Expected an Event Iterator, got a non-Event Iterator"
+                );
+              }
+              current = maybeEventIterator;
+            }
+          }
+        } finally {
+          await current.return?.();
+        }
+      }();
+    });
+  }
+}
+
+export { ClientRetryPlugin, ClientRetryPluginInvalidEventIteratorRetryResponse };

package/dist/shared/client.5813Ufvs.d.mts

@@ -0,0 +1,39 @@
+import { Interceptor, ThrowableError } from '@orpc/shared';
+import { StandardRequest, StandardLazyResponse } from '@orpc/standard-server';
+import { a as ClientContext, b as ClientOptions, C as ClientLink } from './client.C0lT7w02.mjs';
+
+interface StandardLinkCodec<T extends ClientContext> {
+    encode(path: readonly string[], input: unknown, options: ClientOptions<T>): Promise<StandardRequest>;
+    decode(response: StandardLazyResponse, options: ClientOptions<T>, path: readonly string[], input: unknown): Promise<unknown>;
+}
+interface StandardLinkClient<T extends ClientContext> {
+    call(request: StandardRequest, options: ClientOptions<T>, path: readonly string[], input: unknown): Promise<StandardLazyResponse>;
+}
+
+declare class InvalidEventIteratorRetryResponse extends Error {
+}
+interface StandardLinkPlugin<T extends ClientContext> {
+    init?(options: StandardLinkOptions<T>): void;
+}
+interface StandardLinkOptions<T extends ClientContext> {
+    interceptors?: Interceptor<{
+        path: readonly string[];
+        input: unknown;
+        options: ClientOptions<T>;
+    }, unknown, ThrowableError>[];
+    clientInterceptors?: Interceptor<{
+        request: StandardRequest;
+    }, StandardLazyResponse, ThrowableError>[];
+    plugins?: StandardLinkPlugin<T>[];
+}
+declare class StandardLink<T extends ClientContext> implements ClientLink<T> {
+    #private;
+    readonly codec: StandardLinkCodec<T>;
+    readonly sender: StandardLinkClient<T>;
+    private readonly interceptors;
+    private readonly clientInterceptors;
+    constructor(codec: StandardLinkCodec<T>, sender: StandardLinkClient<T>, options?: StandardLinkOptions<T>);
+    call(path: readonly string[], input: unknown, options: ClientOptions<T>): Promise<unknown>;
+}
+
+export { InvalidEventIteratorRetryResponse as I, type StandardLinkPlugin as S, type StandardLinkOptions as a, StandardLink as b, type StandardLinkCodec as c, type StandardLinkClient as d };

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

@@ -0,0 +1,103 @@
+import { a as ClientContext, b as ClientOptions, d as HTTPMethod } from './client.C0lT7w02.mjs';
+import { c as StandardLinkCodec, a as StandardLinkOptions } from './client.5813Ufvs.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.C0lT7w02.d.mts

@@ -0,0 +1,30 @@
+import { PromiseWithError } from '@orpc/shared';
+
+type HTTPPath = `/${string}`;
+type HTTPMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
+type ClientContext = Record<PropertyKey, any>;
+type FriendlyClientOptions<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?: FriendlyClientOptions<TClientContext>] : [input: TInput, options?: FriendlyClientOptions<TClientContext>] : [input: TInput, options: FriendlyClientOptions<TClientContext>];
+type ClientPromiseResult<TOutput, TError> = PromiseWithError<TOutput, TError>;
+interface Client<TClientContext extends ClientContext, TInput, TOutput, TError> {
+    (...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 ClientOptions<TClientContext extends ClientContext> = FriendlyClientOptions<TClientContext> & {
+    context: TClientContext;
+};
+interface ClientLink<TClientContext extends ClientContext> {
+    call: (path: readonly string[], input: unknown, options: ClientOptions<TClientContext>) => Promise<unknown>;
+}
+
+export type { ClientLink as C, FriendlyClientOptions as F, HTTPPath as H, InferClientContext as I, NestedClient as N, ClientContext as a, ClientOptions as b, ClientPromiseResult as c, HTTPMethod as d, ClientRest as e, Client as f };

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

@@ -0,0 +1,30 @@
+import { PromiseWithError } from '@orpc/shared';
+
+type HTTPPath = `/${string}`;
+type HTTPMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
+type ClientContext = Record<PropertyKey, any>;
+type FriendlyClientOptions<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?: FriendlyClientOptions<TClientContext>] : [input: TInput, options?: FriendlyClientOptions<TClientContext>] : [input: TInput, options: FriendlyClientOptions<TClientContext>];
+type ClientPromiseResult<TOutput, TError> = PromiseWithError<TOutput, TError>;
+interface Client<TClientContext extends ClientContext, TInput, TOutput, TError> {
+    (...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 ClientOptions<TClientContext extends ClientContext> = FriendlyClientOptions<TClientContext> & {
+    context: TClientContext;
+};
+interface ClientLink<TClientContext extends ClientContext> {
+    call: (path: readonly string[], input: unknown, options: ClientOptions<TClientContext>) => Promise<unknown>;
+}
+
+export type { ClientLink as C, FriendlyClientOptions as F, HTTPPath as H, InferClientContext as I, NestedClient as N, ClientContext as a, ClientOptions as b, ClientPromiseResult as c, HTTPMethod as d, ClientRest as e, Client as f };