@orpc/client 1.14.10 → 1.14.11

package/dist/shared/client.8f4DNmdE.d.mts

@@ -0,0 +1,96 @@
+import { Promisable, OrderablePlugin, Interceptor } from '@orpc/shared';
+import { StandardRequest, StandardLazyResponse } from '@standardserver/core';
+import { C as ClientContext, a as ClientOptions, A as AnyORPCError, b as ClientLink } from './client.BBZBQID8.mjs';
+
+type StandardLinkCodecDecodedResponse = {
+    kind: 'output';
+    output: unknown;
+} | {
+    kind: 'error';
+    error: AnyORPCError;
+};
+interface StandardLinkCodec<T extends ClientContext> {
+    encodeInput(input: unknown, path: string[], options: ClientOptions<T>): Promisable<StandardRequest>;
+    decodeResponse(response: StandardLazyResponse, path: string[], options: ClientOptions<T>): Promisable<StandardLinkCodecDecodedResponse>;
+}
+
+interface StandardLinkPlugin<T extends ClientContext> extends OrderablePlugin {
+    /**
+     * Initializes the plugin and returns new link options.
+     * Called once per plugin instance during composition.
+     *
+     * This method allows plugins to wrap, extend, or transform link options
+     * such as interceptors, or configuration.
+     *
+     * @param options - The current link options from previous plugins or base configuration
+     * @returns Transformed link options with plugin's modifications applied
+     *
+     * @example
+     * ```ts
+     * init(options) {
+     *   return {
+     *     ...options,
+     *     interceptors: [...(options.interceptors || []), myInterceptor]
+     *   }
+     * }
+     * ```
+     */
+    init?(options: StandardLinkOptions<T>): StandardLinkOptions<T>;
+}
+declare class CompositeStandardLinkPlugin<T extends ClientContext> implements StandardLinkPlugin<T> {
+    name: string;
+    protected readonly plugins: StandardLinkPlugin<T>[];
+    constructor(plugins?: StandardLinkPlugin<T>[]);
+    init(options: StandardLinkOptions<T>): StandardLinkOptions<T>;
+}
+
+/**
+ * Handles the transport layer for sending requests and receiving responses.
+ *
+ * Implementations are responsible for the actual network communication,
+ * such as HTTP fetch, WebSocket, or other transport mechanisms.
+ */
+interface StandardLinkTransport<T extends ClientContext> {
+    /**
+     * @throws Transport-level errors (network failures, timeouts, etc.)
+     */
+    send(request: StandardRequest, path: string[], options: ClientOptions<T>): Promise<StandardLazyResponse>;
+}
+
+interface StandardLinkInterceptorOptions<T extends ClientContext> extends ClientOptions<T> {
+    path: string[];
+    input: unknown;
+}
+type StandardLinkInterceptor<T extends ClientContext> = Interceptor<StandardLinkInterceptorOptions<T>, Promise<unknown>>;
+interface StandardLinkTransportInterceptorOptions<T extends ClientContext> extends ClientOptions<T> {
+    path: string[];
+    request: StandardRequest;
+}
+type StandardLinkTransportInterceptor<T extends ClientContext> = Interceptor<StandardLinkTransportInterceptorOptions<T>, Promise<StandardLazyResponse>>;
+interface StandardLinkOptions<T extends ClientContext> {
+    /**
+     * Interceptors that execute around the entire call, including transport and codec.
+     * Useful for error handling, logging, metrics, ...
+     */
+    interceptors?: StandardLinkInterceptor<T>[];
+    /**
+     * Interceptors that execute around the transport layer, after encoding and before decoding.
+     * Useful for modifying the request or response, adding transport-level logging, ...
+     */
+    transportInterceptors?: StandardLinkTransportInterceptor<T>[];
+    plugins?: StandardLinkPlugin<T>[];
+}
+declare class StandardLink<T extends ClientContext> implements ClientLink<T> {
+    private readonly codec;
+    private readonly transport;
+    private readonly interceptors;
+    private readonly transportInterceptors;
+    constructor(codec: StandardLinkCodec<T>, transport: StandardLinkTransport<T>, options?: StandardLinkOptions<T>);
+    /**
+     * @throws ORPCError, transport-level errors (network failures, timeouts, etc.)
+     */
+    call(path: string[], input: unknown, options: ClientOptions<T>): Promise<unknown>;
+}
+
+export { CompositeStandardLinkPlugin as C, StandardLink as a };
+export type { StandardLinkTransport as S, StandardLinkOptions as b, StandardLinkPlugin as c, StandardLinkTransportInterceptorOptions as d, StandardLinkInterceptorOptions as e, StandardLinkCodec as f, StandardLinkCodecDecodedResponse as g, StandardLinkInterceptor as h, StandardLinkTransportInterceptor as i };

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

@@ -0,0 +1,167 @@
+import { PromiseWithError, Registry, MaybeOptionalOptions } from '@orpc/shared';
+
+interface ClientContext {
+    [key: PropertyKey]: any;
+}
+interface ClientOptions<T extends ClientContext> {
+    signal?: AbortSignal | undefined;
+    lastEventId?: string | undefined;
+    context: T;
+}
+type FriendlyClientOptions<T extends ClientContext> = Omit<ClientOptions<T>, 'context'> & (object extends T ? {
+    context?: T;
+} : {
+    context: T;
+});
+type ClientRest<TClientContext extends ClientContext, TInput> = object extends TClientContext ? undefined extends TInput ? [input?: TInput, options?: FriendlyClientOptions<TClientContext>] : [input: TInput, options?: FriendlyClientOptions<TClientContext>] : [input: TInput, options: FriendlyClientOptions<TClientContext>];
+interface Client<TClientContext extends ClientContext, TInput, TOutput, TError> {
+    (...rest: ClientRest<TClientContext, TInput>): PromiseWithError<TOutput, TError>;
+}
+type NestedClient<TClientContext extends ClientContext> = Client<TClientContext, any, any, any> | {
+    [k: string]: NestedClient<TClientContext>;
+};
+type AnyNestedClient = NestedClient<any>;
+type InferClientContext<T extends AnyNestedClient> = T extends NestedClient<infer U> ? U : never;
+interface ClientLink<TClientContext extends ClientContext> {
+    call: (path: string[], input: unknown, options: ClientOptions<TClientContext>) => Promise<unknown>;
+}
+/**
+ * Recursively infers the **input types** from a client.
+ *
+ * Produces a nested map where each endpoint's input type is preserved.
+ */
+type InferClientInputs<T extends AnyNestedClient> = T extends Client<any, infer U, any, any> ? U : {
+    [K in keyof T]: T[K] extends AnyNestedClient ? InferClientInputs<T[K]> : never;
+};
+/**
+ * Recursively infers the **body input types** from a client.
+ *
+ * If an endpoint's input includes `{ body: ... }`, only the `body` portion is extracted.
+ * Produces a nested map of body input types.
+ */
+type InferClientBodyInputs<T extends AnyNestedClient> = T extends Client<any, infer U, any, any> ? U extends {
+    body: infer UBody;
+} ? UBody : U : {
+    [K in keyof T]: T[K] extends AnyNestedClient ? InferClientBodyInputs<T[K]> : never;
+};
+/**
+ * Recursively infers the **output types** from a client.
+ *
+ * Produces a nested map where each endpoint's output type is preserved.
+ */
+type InferClientOutputs<T extends AnyNestedClient> = T extends Client<any, any, infer U, any> ? U : {
+    [K in keyof T]: T[K] extends AnyNestedClient ? InferClientOutputs<T[K]> : never;
+};
+/**
+ * Recursively infers the **body output types** from a client.
+ *
+ * If an endpoint's output includes `{ body: ... }`, only the `body` portion is extracted.
+ * Produces a nested map of body output types.
+ */
+type InferClientBodyOutputs<T extends AnyNestedClient> = T extends Client<any, any, infer U, any> ? U extends {
+    body: infer UBody;
+} ? UBody : U : {
+    [K in keyof T]: T[K] extends AnyNestedClient ? InferClientBodyOutputs<T[K]> : never;
+};
+/**
+ * Recursively infers the **error types** from a client when you use [type-safe errors](https://orpc.dev/docs/error-handling#type‐safe-error-handling).
+ *
+ * Produces a nested map where each endpoint's error type is preserved.
+ */
+type InferClientErrors<T extends AnyNestedClient> = T extends Client<any, any, any, infer U> ? U : {
+    [K in keyof T]: T[K] extends AnyNestedClient ? InferClientErrors<T[K]> : never;
+};
+/**
+ * Recursively infers a **union of all error types** from a client when you use [type-safe errors](https://orpc.dev/docs/error-handling#type‐safe-error-handling).
+ *
+ * Useful when you want to handle all possible errors from any endpoint at once.
+ */
+type InferClientError<T extends AnyNestedClient> = T extends Client<any, any, any, infer U> ? U : {
+    [K in keyof T]: T[K] extends AnyNestedClient ? InferClientError<T[K]> : never;
+}[keyof T];
+
+declare const COMMON_ERROR_STATUS_MAP: {
+    BAD_REQUEST: number;
+    UNAUTHORIZED: number;
+    PAYMENT_REQUIRED: number;
+    FORBIDDEN: number;
+    NOT_FOUND: number;
+    METHOD_NOT_SUPPORTED: number;
+    NOT_ACCEPTABLE: number;
+    TIMEOUT: number;
+    CONFLICT: number;
+    GONE: number;
+    PRECONDITION_FAILED: number;
+    PAYLOAD_TOO_LARGE: number;
+    UNSUPPORTED_MEDIA_TYPE: number;
+    UNPROCESSABLE_CONTENT: number;
+    PRECONDITION_REQUIRED: number;
+    TOO_MANY_REQUESTS: number;
+    CLIENT_CLOSED_REQUEST: number;
+    INTERNAL_SERVER_ERROR: number;
+    NOT_IMPLEMENTED: number;
+    BAD_GATEWAY: number;
+    SERVICE_UNAVAILABLE: number;
+    GATEWAY_TIMEOUT: number;
+};
+type ORPCErrorCode = Registry extends {
+    ORPCErrorCode: infer T extends string;
+} ? T : (keyof typeof COMMON_ERROR_STATUS_MAP) | (string & {});
+type ORPCErrorOptions<TData> = ErrorOptions & {
+    message?: string;
+} & (undefined extends TData ? {
+    data?: TData;
+} : {
+    data: TData;
+});
+declare class ORPCError<TCode extends ORPCErrorCode, TData> extends Error {
+    /**
+     * @info
+     * The `__branch` property is used for type branding, helping TypeScript distinguish
+     * an `ORPCError` instance from plain objects with a similar structure.
+     */
+    readonly name: "ORPCError" & {
+        __branch: "ORPCError";
+    };
+    /**
+     * Indicates whether the error matches a definition in the procedure's `.errors` map.
+     */
+    readonly defined: boolean;
+    /**
+     * Indicates whether the error's type is inferable at the TypeScript level.
+     * This is typically true when the error is explicitly defined or returned within a handler.
+     */
+    readonly inferable: boolean;
+    code: TCode;
+    data: TData;
+    constructor(code: TCode, ...rest: MaybeOptionalOptions<ORPCErrorOptions<TData>>);
+    toJSON(): ORPCErrorJSON<TCode, TData>;
+    /**
+     * Workaround for Next.js where different contexts use separate
+     * dependency graphs, causing multiple ORPCError constructors existing and breaking
+     * `instanceof` checks across contexts.
+     *
+     * This is particularly problematic with "Optimized SSR", where orpc-client
+     * executes in one context but is invoked from another. When an error is thrown
+     * in the execution context, `instanceof ORPCError` checks fail in the
+     * invocation context due to separate class constructors.
+     *
+     * @todo Remove this and related code if Next.js resolves the multiple dependency graph issue.
+     */
+    static [Symbol.hasInstance](instance: unknown): boolean;
+}
+interface ORPCErrorJSON<TCode extends string, TData> extends Pick<ORPCError<TCode, TData>, 'code' | 'message' | 'data'> {
+    /**
+     * remove readonly
+     */
+    defined: boolean;
+    /**
+     * remove readonly
+     */
+    inferable: boolean;
+}
+type AnyORPCError = ORPCError<any, any>;
+type AnyORPCErrorJSON = ORPCErrorJSON<any, any>;
+
+export { ORPCError as g, COMMON_ERROR_STATUS_MAP as j };
+export type { AnyORPCError as A, ClientContext as C, FriendlyClientOptions as F, InferClientContext as I, NestedClient as N, ORPCErrorCode as O, ClientOptions as a, ClientLink as b, AnyNestedClient as c, InferClientError as d, Client as e, ClientRest as f, ORPCErrorJSON as h, AnyORPCErrorJSON as i, InferClientBodyInputs as k, InferClientBodyOutputs as l, InferClientErrors as m, InferClientInputs as n, InferClientOutputs as o, ORPCErrorOptions as p };

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

@@ -0,0 +1,167 @@
+import { PromiseWithError, Registry, MaybeOptionalOptions } from '@orpc/shared';
+
+interface ClientContext {
+    [key: PropertyKey]: any;
+}
+interface ClientOptions<T extends ClientContext> {
+    signal?: AbortSignal | undefined;
+    lastEventId?: string | undefined;
+    context: T;
+}
+type FriendlyClientOptions<T extends ClientContext> = Omit<ClientOptions<T>, 'context'> & (object extends T ? {
+    context?: T;
+} : {
+    context: T;
+});
+type ClientRest<TClientContext extends ClientContext, TInput> = object extends TClientContext ? undefined extends TInput ? [input?: TInput, options?: FriendlyClientOptions<TClientContext>] : [input: TInput, options?: FriendlyClientOptions<TClientContext>] : [input: TInput, options: FriendlyClientOptions<TClientContext>];
+interface Client<TClientContext extends ClientContext, TInput, TOutput, TError> {
+    (...rest: ClientRest<TClientContext, TInput>): PromiseWithError<TOutput, TError>;
+}
+type NestedClient<TClientContext extends ClientContext> = Client<TClientContext, any, any, any> | {
+    [k: string]: NestedClient<TClientContext>;
+};
+type AnyNestedClient = NestedClient<any>;
+type InferClientContext<T extends AnyNestedClient> = T extends NestedClient<infer U> ? U : never;
+interface ClientLink<TClientContext extends ClientContext> {
+    call: (path: string[], input: unknown, options: ClientOptions<TClientContext>) => Promise<unknown>;
+}
+/**
+ * Recursively infers the **input types** from a client.
+ *
+ * Produces a nested map where each endpoint's input type is preserved.
+ */
+type InferClientInputs<T extends AnyNestedClient> = T extends Client<any, infer U, any, any> ? U : {
+    [K in keyof T]: T[K] extends AnyNestedClient ? InferClientInputs<T[K]> : never;
+};
+/**
+ * Recursively infers the **body input types** from a client.
+ *
+ * If an endpoint's input includes `{ body: ... }`, only the `body` portion is extracted.
+ * Produces a nested map of body input types.
+ */
+type InferClientBodyInputs<T extends AnyNestedClient> = T extends Client<any, infer U, any, any> ? U extends {
+    body: infer UBody;
+} ? UBody : U : {
+    [K in keyof T]: T[K] extends AnyNestedClient ? InferClientBodyInputs<T[K]> : never;
+};
+/**
+ * Recursively infers the **output types** from a client.
+ *
+ * Produces a nested map where each endpoint's output type is preserved.
+ */
+type InferClientOutputs<T extends AnyNestedClient> = T extends Client<any, any, infer U, any> ? U : {
+    [K in keyof T]: T[K] extends AnyNestedClient ? InferClientOutputs<T[K]> : never;
+};
+/**
+ * Recursively infers the **body output types** from a client.
+ *
+ * If an endpoint's output includes `{ body: ... }`, only the `body` portion is extracted.
+ * Produces a nested map of body output types.
+ */
+type InferClientBodyOutputs<T extends AnyNestedClient> = T extends Client<any, any, infer U, any> ? U extends {
+    body: infer UBody;
+} ? UBody : U : {
+    [K in keyof T]: T[K] extends AnyNestedClient ? InferClientBodyOutputs<T[K]> : never;
+};
+/**
+ * Recursively infers the **error types** from a client when you use [type-safe errors](https://orpc.dev/docs/error-handling#type‐safe-error-handling).
+ *
+ * Produces a nested map where each endpoint's error type is preserved.
+ */
+type InferClientErrors<T extends AnyNestedClient> = T extends Client<any, any, any, infer U> ? U : {
+    [K in keyof T]: T[K] extends AnyNestedClient ? InferClientErrors<T[K]> : never;
+};
+/**
+ * Recursively infers a **union of all error types** from a client when you use [type-safe errors](https://orpc.dev/docs/error-handling#type‐safe-error-handling).
+ *
+ * Useful when you want to handle all possible errors from any endpoint at once.
+ */
+type InferClientError<T extends AnyNestedClient> = T extends Client<any, any, any, infer U> ? U : {
+    [K in keyof T]: T[K] extends AnyNestedClient ? InferClientError<T[K]> : never;
+}[keyof T];
+
+declare const COMMON_ERROR_STATUS_MAP: {
+    BAD_REQUEST: number;
+    UNAUTHORIZED: number;
+    PAYMENT_REQUIRED: number;
+    FORBIDDEN: number;
+    NOT_FOUND: number;
+    METHOD_NOT_SUPPORTED: number;
+    NOT_ACCEPTABLE: number;
+    TIMEOUT: number;
+    CONFLICT: number;
+    GONE: number;
+    PRECONDITION_FAILED: number;
+    PAYLOAD_TOO_LARGE: number;
+    UNSUPPORTED_MEDIA_TYPE: number;
+    UNPROCESSABLE_CONTENT: number;
+    PRECONDITION_REQUIRED: number;
+    TOO_MANY_REQUESTS: number;
+    CLIENT_CLOSED_REQUEST: number;
+    INTERNAL_SERVER_ERROR: number;
+    NOT_IMPLEMENTED: number;
+    BAD_GATEWAY: number;
+    SERVICE_UNAVAILABLE: number;
+    GATEWAY_TIMEOUT: number;
+};
+type ORPCErrorCode = Registry extends {
+    ORPCErrorCode: infer T extends string;
+} ? T : (keyof typeof COMMON_ERROR_STATUS_MAP) | (string & {});
+type ORPCErrorOptions<TData> = ErrorOptions & {
+    message?: string;
+} & (undefined extends TData ? {
+    data?: TData;
+} : {
+    data: TData;
+});
+declare class ORPCError<TCode extends ORPCErrorCode, TData> extends Error {
+    /**
+     * @info
+     * The `__branch` property is used for type branding, helping TypeScript distinguish
+     * an `ORPCError` instance from plain objects with a similar structure.
+     */
+    readonly name: "ORPCError" & {
+        __branch: "ORPCError";
+    };
+    /**
+     * Indicates whether the error matches a definition in the procedure's `.errors` map.
+     */
+    readonly defined: boolean;
+    /**
+     * Indicates whether the error's type is inferable at the TypeScript level.
+     * This is typically true when the error is explicitly defined or returned within a handler.
+     */
+    readonly inferable: boolean;
+    code: TCode;
+    data: TData;
+    constructor(code: TCode, ...rest: MaybeOptionalOptions<ORPCErrorOptions<TData>>);
+    toJSON(): ORPCErrorJSON<TCode, TData>;
+    /**
+     * Workaround for Next.js where different contexts use separate
+     * dependency graphs, causing multiple ORPCError constructors existing and breaking
+     * `instanceof` checks across contexts.
+     *
+     * This is particularly problematic with "Optimized SSR", where orpc-client
+     * executes in one context but is invoked from another. When an error is thrown
+     * in the execution context, `instanceof ORPCError` checks fail in the
+     * invocation context due to separate class constructors.
+     *
+     * @todo Remove this and related code if Next.js resolves the multiple dependency graph issue.
+     */
+    static [Symbol.hasInstance](instance: unknown): boolean;
+}
+interface ORPCErrorJSON<TCode extends string, TData> extends Pick<ORPCError<TCode, TData>, 'code' | 'message' | 'data'> {
+    /**
+     * remove readonly
+     */
+    defined: boolean;
+    /**
+     * remove readonly
+     */
+    inferable: boolean;
+}
+type AnyORPCError = ORPCError<any, any>;
+type AnyORPCErrorJSON = ORPCErrorJSON<any, any>;
+
+export { ORPCError as g, COMMON_ERROR_STATUS_MAP as j };
+export type { AnyORPCError as A, ClientContext as C, FriendlyClientOptions as F, InferClientContext as I, NestedClient as N, ORPCErrorCode as O, ClientOptions as a, ClientLink as b, AnyNestedClient as c, InferClientError as d, Client as e, ClientRest as f, ORPCErrorJSON as h, AnyORPCErrorJSON as i, InferClientBodyInputs as k, InferClientBodyOutputs as l, InferClientErrors as m, InferClientInputs as n, InferClientOutputs as o, ORPCErrorOptions as p };

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

@@ -0,0 +1,96 @@
+import { Promisable, OrderablePlugin, Interceptor } from '@orpc/shared';
+import { StandardRequest, StandardLazyResponse } from '@standardserver/core';
+import { C as ClientContext, a as ClientOptions, A as AnyORPCError, b as ClientLink } from './client.BBZBQID8.js';
+
+type StandardLinkCodecDecodedResponse = {
+    kind: 'output';
+    output: unknown;
+} | {
+    kind: 'error';
+    error: AnyORPCError;
+};
+interface StandardLinkCodec<T extends ClientContext> {
+    encodeInput(input: unknown, path: string[], options: ClientOptions<T>): Promisable<StandardRequest>;
+    decodeResponse(response: StandardLazyResponse, path: string[], options: ClientOptions<T>): Promisable<StandardLinkCodecDecodedResponse>;
+}
+
+interface StandardLinkPlugin<T extends ClientContext> extends OrderablePlugin {
+    /**
+     * Initializes the plugin and returns new link options.
+     * Called once per plugin instance during composition.
+     *
+     * This method allows plugins to wrap, extend, or transform link options
+     * such as interceptors, or configuration.
+     *
+     * @param options - The current link options from previous plugins or base configuration
+     * @returns Transformed link options with plugin's modifications applied
+     *
+     * @example
+     * ```ts
+     * init(options) {
+     *   return {
+     *     ...options,
+     *     interceptors: [...(options.interceptors || []), myInterceptor]
+     *   }
+     * }
+     * ```
+     */
+    init?(options: StandardLinkOptions<T>): StandardLinkOptions<T>;
+}
+declare class CompositeStandardLinkPlugin<T extends ClientContext> implements StandardLinkPlugin<T> {
+    name: string;
+    protected readonly plugins: StandardLinkPlugin<T>[];
+    constructor(plugins?: StandardLinkPlugin<T>[]);
+    init(options: StandardLinkOptions<T>): StandardLinkOptions<T>;
+}
+
+/**
+ * Handles the transport layer for sending requests and receiving responses.
+ *
+ * Implementations are responsible for the actual network communication,
+ * such as HTTP fetch, WebSocket, or other transport mechanisms.
+ */
+interface StandardLinkTransport<T extends ClientContext> {
+    /**
+     * @throws Transport-level errors (network failures, timeouts, etc.)
+     */
+    send(request: StandardRequest, path: string[], options: ClientOptions<T>): Promise<StandardLazyResponse>;
+}
+
+interface StandardLinkInterceptorOptions<T extends ClientContext> extends ClientOptions<T> {
+    path: string[];
+    input: unknown;
+}
+type StandardLinkInterceptor<T extends ClientContext> = Interceptor<StandardLinkInterceptorOptions<T>, Promise<unknown>>;
+interface StandardLinkTransportInterceptorOptions<T extends ClientContext> extends ClientOptions<T> {
+    path: string[];
+    request: StandardRequest;
+}
+type StandardLinkTransportInterceptor<T extends ClientContext> = Interceptor<StandardLinkTransportInterceptorOptions<T>, Promise<StandardLazyResponse>>;
+interface StandardLinkOptions<T extends ClientContext> {
+    /**
+     * Interceptors that execute around the entire call, including transport and codec.
+     * Useful for error handling, logging, metrics, ...
+     */
+    interceptors?: StandardLinkInterceptor<T>[];
+    /**
+     * Interceptors that execute around the transport layer, after encoding and before decoding.
+     * Useful for modifying the request or response, adding transport-level logging, ...
+     */
+    transportInterceptors?: StandardLinkTransportInterceptor<T>[];
+    plugins?: StandardLinkPlugin<T>[];
+}
+declare class StandardLink<T extends ClientContext> implements ClientLink<T> {
+    private readonly codec;
+    private readonly transport;
+    private readonly interceptors;
+    private readonly transportInterceptors;
+    constructor(codec: StandardLinkCodec<T>, transport: StandardLinkTransport<T>, options?: StandardLinkOptions<T>);
+    /**
+     * @throws ORPCError, transport-level errors (network failures, timeouts, etc.)
+     */
+    call(path: string[], input: unknown, options: ClientOptions<T>): Promise<unknown>;
+}
+
+export { CompositeStandardLinkPlugin as C, StandardLink as a };
+export type { StandardLinkTransport as S, StandardLinkOptions as b, StandardLinkPlugin as c, StandardLinkTransportInterceptorOptions as d, StandardLinkInterceptorOptions as e, StandardLinkCodec as f, StandardLinkCodecDecodedResponse as g, StandardLinkInterceptor as h, StandardLinkTransportInterceptor as i };