@orpc/shared 2.0.0-beta.4 → 2.0.0-beta.41

package/dist/index.d.ts

@@ -1,8 +1,7 @@
-import { Promisable } from 'type-fest';
-export { IsEqual, PartialDeep, Promisable, Writable } from 'type-fest';
-import { Tracer, TraceAPI, ContextAPI, PropagationAPI, SpanOptions, Context, Span, AttributeValue, Exception } from '@opentelemetry/api';
-import { AsyncIteratorClass } from '@standardserver/shared';
-export { AbortError, AsyncCleanupFn, AsyncIteratorClass, AsyncIteratorClassNextFn, SequentialIdGenerator, getOrBind, isAsyncIteratorObject, isTypescriptObject, parseEmptyableJSON, sleep, stringifyJSON, toArray } from '@standardserver/shared';
+import { Arrayable, Promisable } from 'type-fest';
+export { Arrayable, IsEqual, PartialDeep, Promisable, Writable } from 'type-fest';
+import { AsyncIteratorClass } from '@standard-server/shared';
+export { AbortError, AsyncCleanupFn, AsyncIteratorClass, AsyncIteratorClassNextFn, SequentialIdGenerator, getOrBind, isAsyncIteratorObject, isTypescriptObject, parseEmptyableJSON, safeDecodeURIComponent, safeEncodeURIComponent, sequential, sleep, stringifyJSON, throwIfAborted, toArray } from '@standard-server/shared';
 
 type MaybeOptionalOptions<TOptions> = object extends TOptions ? [options?: TOptions] : [options: TOptions];
 declare function resolveMaybeOptionalOptions<T>(rest: MaybeOptionalOptions<T>): T;
@@ -14,13 +13,13 @@ declare function splitInHalf<T>(arr: readonly T[]): [T[], T[]];
  *
  * Prefers the newer `.bytes` method when available as it more efficient but not widely supported yet.
  */
-declare function loadBytes(source: Pick<Blob, 'arrayBuffer' | 'bytes'>): Promise<Uint8Array<ArrayBuffer>>;
+declare function loadBytes(source: Pick<Blob, 'arrayBuffer' | 'bytes'>): ReturnType<Blob['bytes']>;
 /**
  * Normalize text or binary-like inputs to either:
  * - the original string value, or
  * - a Uint8Array view over the source bytes.
  */
-declare function toStringOrBytes(source: string | ArrayBuffer | Blob | Exclude<ConstructorParameters<typeof Blob>[0], undefined>[0][] | Pick<Uint8Array<ArrayBuffer>, 'buffer' | 'byteOffset' | 'byteLength'>): Promise<string | Uint8Array<ArrayBuffer>>;
+declare function toStringOrBytes(source: Arrayable<string | ArrayBuffer | Pick<Uint8Array<ArrayBuffer>, 'buffer' | 'byteOffset' | 'byteLength'>>): string | Awaited<ReturnType<Blob['bytes']>>;
 
 declare function isDeepEqual(a: unknown, b: unknown): boolean;
 
@@ -29,11 +28,16 @@ declare const ORPC_NAME = "orpc";
 declare function isAbortError(error: unknown): error is Error;
 
 type AnyFunction = (...args: any[]) => any;
+/**
+ * Checks whether a value is an async generator function (`async function*`).
+ */
+declare function isAsyncGeneratorFunction(value: unknown): value is (...args: any[]) => AsyncGenerator;
 declare function once<T>(fn: () => T): () => T;
 /**
- * Executes the callback function after the current call stack has been cleared.
+ * Executes the callback function after the current call stack has been cleared,
+ * waiting at least `delay` ms when `setTimeout` is available.
  */
-declare function defer(callback: () => void): void;
+declare function defer(callback: () => void, delay?: number): void;
 declare function tryOrUndefined<T>(fn: () => T): undefined | T;
 
 declare function pathToHttpPath(path: readonly string[]): `/${string}`;
@@ -41,6 +45,30 @@ declare function normalizeHttpPath(path: string): `/${string}`;
 declare function mergeHttpPath(a: `/${string}`, b: `/${string}`): `/${string}`;
 declare function matchesHttpPathPrefix(url: `/${string}`, prefix: `/${string}`): boolean;
 declare function matchesHttpPath(url: `/${string}`, path: `/${string}`): boolean;
+/**
+ * Parse Accept-Encoding into each coding's q-value, where `0` means the coding is explicitly
+ * unacceptable. The `*` wildcard is kept under its own key; use {@link isAcceptableEncoding}
+ * to decide whether a coding is acceptable.
+ *
+ * @see https://www.rfc-editor.org/rfc/rfc9110.html#name-accept-encoding
+ */
+declare function parseAcceptEncodingQualities(header: string | undefined): Map<string, number>;
+/**
+ * Whether the client accepts a coding, given qualities from {@link parseAcceptEncodingQualities}.
+ * An explicit q-value takes precedence over the `*` wildcard, so `gzip;q=0, *` never accepts gzip.
+ *
+ * @see https://www.rfc-editor.org/rfc/rfc9110.html#name-accept-encoding
+ */
+declare function isAcceptableEncoding(qualities: Map<string, number>, coding: string): boolean;
+/**
+ * Add `accept-encoding` to a Vary header value. The encoding is chosen from the request, so a
+ * shared cache must key on it or it will hand a compressed body to a client that cannot decode it.
+ *
+ * @see https://www.rfc-editor.org/rfc/rfc9110.html#name-vary
+ */
+declare function varyByAcceptEncoding(vary: string | undefined): string;
+declare function isNoTransformCacheControl(cacheControl: string | undefined): boolean;
+declare function isCompressibleContentType(contentType: string | null | undefined): boolean;
 
 /**
  * Compares two sequential IDs.
@@ -52,6 +80,12 @@ declare function matchesHttpPath(url: `/${string}`, path: `/${string}`): boolean
 declare function compareSequentialIds(a: string, b: string): number;
 
 type IntersectPick<T, U> = Pick<T, keyof T & keyof U>;
+/**
+ * Like `Omit`, but distributes over unions and keeps known keys beside index signatures.
+ */
+type DistributiveOmit<T, K extends PropertyKey> = {
+    [P in keyof T as P extends K ? never : P]: T[P];
+};
 /**
  * Remove protected/private properties/methods
  */
@@ -90,7 +124,10 @@ declare function onSuccess<T, TOptions extends {
     next: () => any;
 }, TRest extends any[]>(callback: NoInfer<(result: Awaited<ReturnType<TOptions['next']>>, options: TOptions, ...rest: TRest) => Promisable<void>>): (options: TOptions, ...rest: TRest) => T | Promise<Awaited<ReturnType<TOptions['next']>>>;
 /**
- * Can used for interceptors or middlewares
+ * Creates an interceptor or middleware that invokes a callback whenever an error
+ * is thrown. The error is rethrown after the callback completes.
+ *
+ * @see {@link https://orpc.dev/docs/adapters/fetch-api | Fetch API Adapter}
  */
 declare function onError<T, TOptions extends {
     next: () => any;
@@ -102,42 +139,104 @@ type OnFinishState<TResult, TError> = [error: TError, data: undefined, isSuccess
 declare function onFinish<T, TOptions extends {
     next: () => any;
 }, TRest extends any[]>(callback: NoInfer<(state: OnFinishState<Awaited<ReturnType<TOptions['next']>>, ReturnType<TOptions['next']> extends PromiseWithError<any, infer E> ? E : ThrowableError>, options: TOptions, ...rest: TRest) => Promisable<void>>): (options: TOptions, ...rest: TRest) => T | Promise<Awaited<ReturnType<TOptions['next']>>>;
+/**
+ * Creates a middleware or interceptor that invokes a callback when the returned async
+ * iterator object throws an error while being consumed.
+ *
+ * This does not replace the `onError`. `onError` only fires on the
+ * initial call (before the interceptor returns the iterator), whereas this
+ * callback only fires while consuming the iterator. Use both together to
+ * catch all possible errors.
+ */
+declare function onAsyncIteratorObjectError<T, TOptions extends {
+    next: () => any;
+}, TRest extends any[]>(callback: NoInfer<(error: ThrowableError | (ReturnType<TOptions['next']> extends PromiseWithError<any, infer E> ? E : ThrowableError), options: TOptions, ...rest: TRest) => Promisable<void>>): (options: TOptions, ...rest: TRest) => T | Promise<Awaited<ReturnType<TOptions['next']>>>;
+/**
+ * Creates an interceptor that invokes a callback when the returned readable
+ * stream errors while being consumed.
+ *
+ * This does not replace the `onError`. `onError` only fires on the
+ * initial call (before the interceptor returns the stream), whereas this
+ * callback only fires while consuming the stream. Use both together to catch
+ * all possible errors.
+ */
+declare function onReadableStreamError<T, TOptions extends {
+    next: () => any;
+}, TRest extends any[]>(callback: NoInfer<(error: ThrowableError | (ReturnType<TOptions['next']> extends PromiseWithError<any, infer E> ? E : ThrowableError), options: TOptions, ...rest: TRest) => Promisable<void>>): (options: TOptions, ...rest: TRest) => T | Promise<Awaited<ReturnType<TOptions['next']>>>;
 declare function intercept<TOptions extends InterceptableOptions, TResult>(interceptors: undefined | Interceptor<TOptions, TResult>[], options: NoInfer<TOptions>, main: NoInfer<(options: TOptions) => TResult>): TResult;
 
+type TracingAttributeValue = string | number | boolean | string[] | number[] | boolean[];
+interface TracingException {
+    name?: string;
+    message: string;
+    stack?: string;
+    code?: string | number;
+}
+type TracingHeaders = Record<string, string | string[] | undefined>;
+type TracingExceptionLevel = 'error' | 'info';
+interface TracingSpan {
+    setAttribute(key: string, value: TracingAttributeValue): void;
+    /**
+     * Renames the span. Backends that cannot rename spans ignore it.
+     */
+    updateName(name: string): void;
+    /**
+     * Adds an event to the span. Backends without span events ignore it.
+     */
+    addEvent(name: string): void;
+    /**
+     * Records an exception on the span. The `error` level also marks the span as failed.
+     */
+    recordException(level: TracingExceptionLevel, exception: TracingException): void;
+    end(): void;
+}
 /**
- * Only import types from @opentelemetry/api to avoid runtime dependencies.
+ * The tracing backend oRPC records spans with, see `@orpc/opentelemetry` and `@orpc/cloudflare`.
+ *
+ * A `parent` defaults to the active span of the backend when omitted.
  */
-
-interface OpenTelemetryConfig {
-    tracer: Tracer;
-    trace: TraceAPI;
-    context: ContextAPI;
+interface Tracer {
+    /**
+     * Starts a span without making it active. The caller must end it.
+     */
+    startSpan(name: string, parent?: TracingSpan): TracingSpan;
     /**
-     * propagation is optional, can reduce bundle size in some cases.
+     * Starts a span, makes it active while `fn` runs, and passes it to `fn`. The caller must end it.
      */
-    propagation?: PropagationAPI | undefined;
+    startActiveSpan<T>(name: string, parent: TracingSpan | undefined, fn: (span: TracingSpan) => Promise<T>): Promise<T>;
+    getActiveSpan(): TracingSpan | undefined;
+    /**
+     * Runs `fn` with `span` as the active span. Backends that cannot activate a span run `fn` directly.
+     */
+    withActiveSpan<T>(span: TracingSpan, fn: () => Promisable<T>): Promisable<T>;
+    /**
+     * Writes the trace context of `span` into `headers`. Absent when the backend does not propagate context.
+     */
+    inject?(span: TracingSpan, headers: TracingHeaders): void;
+    /**
+     * Reads the remote parent from `headers`. Absent when the backend does not propagate context.
+     */
+    extract?(headers: TracingHeaders): TracingSpan | undefined;
 }
-declare function setOpenTelemetryConfig(config: OpenTelemetryConfig | undefined): void;
-declare function getOpenTelemetryConfig(): OpenTelemetryConfig | undefined;
-interface StartSpanOptions extends SpanOptions {
+declare function setTracer(tracer: Tracer | undefined): void;
+declare function getTracer(): Tracer | undefined;
+interface StartSpanOptions {
     /**
      * The name of the span to create.
      */
     name: string;
     /**
-     * Context to use for the created span.
+     * The span to use as parent. Defaults to the active span of the backend.
      */
-    context?: Context;
+    parent?: TracingSpan | undefined;
 }
-declare function startSpan(options: StartSpanOptions | string): Span | undefined;
-declare function recordSpanError(span: Span | undefined, error: unknown): void;
-declare function setSpanAttributeIfDefined(span: Span | undefined, key: string, value: AttributeValue | undefined): void;
-declare function toOtelException(error: unknown): Exclude<Exception, string>;
+declare function startSpan(options: StartSpanOptions | string): TracingSpan | undefined;
+declare function recordSpanError(span: TracingSpan | undefined, error: unknown): void;
+declare function setSpanAttributeIfDefined(span: TracingSpan | undefined, key: string, value: TracingAttributeValue | undefined): void;
+declare function toTracingException(error: unknown): TracingException;
 declare function toSpanAttributeValue(data: unknown): string;
-interface RunWithSpanOptions extends StartSpanOptions {
-}
-declare function runWithSpan<T>(options: string | RunWithSpanOptions, fn: (span?: Span) => Promisable<T>): Promise<T>;
-declare function runInSpanContext<T>(span: Span | undefined, fn: () => Promisable<T>): Promise<T>;
+declare function runWithSpan<T>(options: string | StartSpanOptions, fn: (span?: TracingSpan) => Promisable<T>): Promise<T>;
+declare function runInSpanContext<T>(span: TracingSpan | undefined, fn: () => Promisable<T>): Promisable<T>;
 
 interface WrapAsyncIteratorOptions<TYield, TReturn, TMappedYield, TMappedReturn> {
     /**
@@ -145,10 +244,10 @@ interface WrapAsyncIteratorOptions<TYield, TReturn, TMappedYield, TMappedReturn>
      * Useful when you want execution to happen within a specific context,
      * such as AsyncLocalStorage.
      */
-    runWith?: <T>(run: () => Promise<T>) => Promise<T>;
+    runWith?: <T>(run: () => Promise<T>) => Promisable<T>;
     mapResult?: (result: IteratorResult<TYield, TReturn>) => Promisable<IteratorResult<TMappedYield, TMappedReturn>>;
-    mapError?: (error: unknown) => Promisable<unknown>;
-    onError?: (error: unknown) => Promisable<void>;
+    mapError?: (error: ThrowableError) => Promisable<ThrowableError>;
+    onError?: (error: ThrowableError) => Promisable<void>;
     /**
      * Execute after the stream finishes or is cancelled.
      */
@@ -157,6 +256,40 @@ interface WrapAsyncIteratorOptions<TYield, TReturn, TMappedYield, TMappedReturn>
 declare function wrapAsyncIterator<TYield, TReturn, TMappedYield = TYield, TMappedReturn = TReturn>(iterator: AsyncIterator<TYield, TReturn>, { runWith, mapResult, mapError, onError, onFinish }: WrapAsyncIteratorOptions<TYield, TReturn, TMappedYield, TMappedReturn>): NoInfer<AsyncIteratorClass<TMappedYield, TMappedReturn>>;
 declare function traceAsyncIterator<T, TReturn, TNext>(options: StartSpanOptions | string, iterator: AsyncIterator<T, TReturn, TNext>): AsyncIteratorClass<T, TReturn, TNext>;
 declare function replicateAsyncIterator<T, TReturn, TNext>(source: AsyncIterator<T, TReturn, TNext>, count: number): (AsyncIteratorClass<T, TReturn, TNext>)[];
+interface ConsumeAsyncIteratorOptions<T, TReturn, TError> {
+    /**
+     * Called on each event
+     */
+    onEvent: (event: T) => void;
+    /**
+     * Called once error happens
+     */
+    onError?: (error: TError) => void;
+    /**
+     * Called once AsyncIteratorObject is done
+     *
+     * @remarks
+     * **Note**: If iterator is canceled, `undefined` can be passed on success
+     */
+    onSuccess?: (value: TReturn | undefined) => void;
+    /**
+     * Called once after onError or onSuccess
+     *
+     * @remarks
+     * **Note**: If iterator is canceled, `undefined` can be passed on success
+     */
+    onFinish?: (state: [error: TError, data: undefined, isSuccess: false] | [error: null, data: TReturn | undefined, isSuccess: true]) => void;
+}
+/**
+ * Consumes an AsyncIteratorObject with lifecycle callbacks.
+ *
+ * @remarks
+ * **Warning**: If no `onError` or `onFinish` is provided, errors are thrown into the unhandled rejection channel.
+ *
+ * @returns An unsubscribe callback that stops consuming and cleans up the iterator.
+ * @see {@link https://orpc.dev/docs/client/async-iterator-object#using-consumeasynciterator | AsyncIteratorObject in Client - Using consumeAsyncIterator}
+ */
+declare function consumeAsyncIterator<T, TReturn, TError = ThrowableError>(iterator: AsyncIterator<T, TReturn> | PromiseWithError<AsyncIterator<T, TReturn>, TError>, options: ConsumeAsyncIteratorOptions<T, TReturn, TError | ThrowableError>): () => Promise<void>;
 
 type Segment = string | number;
 declare function findDeepMatches(check: (value: unknown) => boolean, payload: unknown, segments?: Segment[], maps?: Segment[][], values?: unknown[]): {
@@ -168,18 +301,39 @@ declare function findDeepMatches(check: (value: unknown) => boolean, payload: un
  *
  */
 declare function getConstructor(value: unknown): Function | null | undefined;
+declare function getConstructors(value: unknown): Generator<Function>;
 /**
  * Checks whether a value is a plain object, including objects created with
  * `Object.create(null)`.
  */
 declare function isPlainObject(value: unknown): value is Record<PropertyKey, unknown>;
+/**
+ * Returns `object[key]` only when it is an own property, so keys like
+ * `toString` do not resolve through the prototype chain.
+ */
+declare function getOwn<T extends object>(object: T, key: PropertyKey): T[keyof T] | undefined;
 declare function get(object: unknown, path: readonly PropertyKey[]): unknown;
 /**
  * Sets a value at the given path, creating plain objects for intermediate keys as needed.
  */
 declare function set(root: object, path: [PropertyKey, ...PropertyKey[]] | [...PropertyKey[], PropertyKey], value: unknown): void;
+/**
+ * Sets `object[key]`, defining `__proto__` as an own property instead of re-parenting the object.
+ */
+declare function setOwn(object: object, key: PropertyKey, value: unknown): void;
+/**
+ * Merges two values by copying the second over the first, repeating the merge one level deeper for
+ * nested plain objects. Anything that is not a pair of plain objects is replaced by the second one.
+ */
+declare function mergeTwoLevels(first: unknown, second: unknown): unknown;
 declare function omit<T extends object, K extends keyof T>(obj: T, keys: readonly K[]): Omit<T, K>;
+declare function pick<T extends object, K extends keyof T>(obj: T, keys: readonly K[]): Pick<T, K>;
+/**
+ * Deep clones arrays and plain objects, leaving every other value as is.
+ * Circular and shared references are preserved in the copy.
+ */
 declare function clone<T>(value: T): T;
+declare function copyOnWrite(parent: object, key: PropertyKey, original: unknown): unknown;
 declare function isPropertyKey(value: unknown): value is PropertyKey;
 declare const NullProtoObj: ({
     new <T extends Record<PropertyKey, unknown>>(): T;
@@ -191,7 +345,9 @@ declare const NullProtoObj: ({
  * Methods are collected from both the object itself and its prototype chain
  * (excluding `Object.prototype` and the `constructor` property).
  */
-declare function bindMethods<T extends object>(obj: T): Pick<T, {
+declare function bindMethods<T extends object>(obj: T, options?: {
+    unbound?: (keyof T)[];
+}): Pick<T, {
     [K in keyof T]: T[K] extends AnyFunction ? K : never;
 }[keyof T]>;
 
@@ -220,6 +376,11 @@ declare function promiseWithResolvers<T>(): {
     resolve: (v: T) => void;
     reject: (reason: unknown) => void;
 };
+/**
+ * Captures the current async context (such as AsyncLocalStorage) through a promise reaction, so no runtime API is needed.
+ * The returned function runs a callback inside it once; later calls reject.
+ */
+declare function captureAsyncContext(): <T>(callback: () => Promise<T>) => Promise<T>;
 
 type Value<T, TArgs extends any[] = []> = T | ((...args: TArgs) => T);
 declare function value<T, TArgs extends any[]>(value: Value<T, TArgs>, ...args: NoInfer<TArgs>): T extends Value<infer U, any> ? U : never;
@@ -257,6 +418,14 @@ declare class AsyncIdQueue<T> {
  * Returns a signal that aborts only after all provided signals are aborted.
  */
 declare function allAbortSignal(signals: readonly (AbortSignal | undefined)[]): AbortSignal | undefined;
+/**
+ * Returns a signal that aborts as soon as any of the provided signals aborts,
+ * with the same abort reason.
+ *
+ * Prefers the native `AbortSignal.any` when available, and falls back to a manual
+ * implementation otherwise, including in runtimes without the `AbortSignal` global.
+ */
+declare function anyAbortSignal(signals: readonly (AbortSignal | undefined)[]): AbortSignal | undefined;
 declare function runWithSignal<T>(signal: AbortSignal | undefined, fn: () => Promise<T>): Promise<T>;
 
 declare function replicateReadableStream<T>(stream: ReadableStream<T>, count: number): ReadableStream<T>[];
@@ -265,7 +434,7 @@ type ReadableStreamReadResult<T> = {
     value: T;
 } | {
     done: true;
-    value: undefined | T;
+    value?: undefined | T;
 };
 interface WrapReadableStreamOptions<T, TMapped> {
     /**
@@ -273,10 +442,10 @@ interface WrapReadableStreamOptions<T, TMapped> {
      * Useful when you want execution to happen within a specific context,
      * such as AsyncLocalStorage.
      */
-    runWith?: <T>(run: () => Promise<T>) => Promise<T>;
+    runWith?: <T>(run: () => Promise<T>) => Promisable<T>;
     mapResult?: (result: ReadableStreamReadResult<T>) => Promisable<ReadableStreamReadResult<TMapped>>;
-    mapError?: (error: unknown) => Promisable<unknown>;
-    onError?: (error: unknown) => Promisable<void>;
+    mapError?: (error: ThrowableError) => Promisable<ThrowableError>;
+    onError?: (error: ThrowableError) => Promisable<void>;
     /**
      * Guaranteed to execute exactly once after the stream finishes or is cancelled.
      */
@@ -285,9 +454,11 @@ interface WrapReadableStreamOptions<T, TMapped> {
 declare function wrapReadableStream<T, TMapped = T>(stream: ReadableStream<T>, { runWith, mapResult, mapError, onError, onFinish }: WrapReadableStreamOptions<T, TMapped>): NoInfer<ReadableStream<TMapped>>;
 declare function traceReadableStream<T>(options: StartSpanOptions | string, stream: ReadableStream<T>): ReadableStream<T>;
 /**
- * Converts a `ReadableStream` into an `AsyncIteratorClass`.
+ * Converts a {@link ReadableStream} into an {@link AsyncIteratorClass}.
+ *
+ * @see {@link https://orpc.dev/docs/integrations/ai-sdk | AI SDK Integration}
  */
-declare function streamToAsyncIteratorClass<T>(stream: ReadableStream<T>, { signal }?: {
+declare function streamToAsyncIteratorObject<T>(stream: ReadableStream<T>, { signal }?: {
     signal?: undefined | AbortSignal;
 }): AsyncIteratorClass<T>;
 /**
@@ -297,10 +468,10 @@ declare function asyncIteratorToStream<T>(iterator: AsyncIterator<T>): ReadableS
 /**
  * Converts an `AsyncIterator` into a `ReadableStream`, ensuring that
  * all emitted object values are *unproxied* before enqueuing.
+ *
+ * @see {@link https://orpc.dev/docs/integrations/ai-sdk | AI SDK Integration}
  */
 declare function asyncIteratorToUnproxiedDataStream<T>(iterator: AsyncIterator<T>): ReadableStream<T>;
 
-declare function tryDecodeURIComponent(value: string): string;
-
-export { AsyncIdQueue, NullProtoObj, ORPC_NAME, allAbortSignal, asyncIteratorToStream, asyncIteratorToUnproxiedDataStream, bindMethods, clone, compareSequentialIds, defer, findDeepMatches, get, getConstructor, getOpenTelemetryConfig, intercept, isAbortError, isDeepEqual, isPlainObject, isPropertyKey, loadBytes, matchesHttpPath, matchesHttpPathPrefix, mergeHttpPath, normalizeHttpPath, omit, onError, onFinish, onStart, onSuccess, once, override, pathToHttpPath, promiseWithResolvers, recordSpanError, replicateAsyncIterator, replicateReadableStream, resolveMaybeOptionalOptions, runInSpanContext, runWithSignal, runWithSpan, set, setOpenTelemetryConfig, setSpanAttributeIfDefined, sortPlugins, splitInHalf, startSpan, streamToAsyncIteratorClass, toOtelException, toSpanAttributeValue, toStringOrBytes, traceAsyncIterator, traceReadableStream, tryDecodeURIComponent, tryOrUndefined, value, wrapAsyncIterator, wrapReadableStream };
-export type { AnyFunction, AsyncIdQueueCloseOptions, InterceptableOptions, Interceptor, InterceptorOptions, IntersectPick, MaybeOptionalOptions, OnFinishState, OpenTelemetryConfig, OrderablePlugin, PromiseWithError, Public, ReadableStreamReadResult, Registry, RunWithSpanOptions, Segment, StartSpanOptions, ThrowableError, Value, WrapAsyncIteratorOptions, WrapReadableStreamOptions };
+export { AsyncIdQueue, NullProtoObj, ORPC_NAME, allAbortSignal, anyAbortSignal, asyncIteratorToStream, asyncIteratorToUnproxiedDataStream, bindMethods, captureAsyncContext, clone, compareSequentialIds, consumeAsyncIterator, copyOnWrite, defer, findDeepMatches, get, getConstructor, getConstructors, getOwn, getTracer, intercept, isAbortError, isAcceptableEncoding, isAsyncGeneratorFunction, isCompressibleContentType, isDeepEqual, isNoTransformCacheControl, isPlainObject, isPropertyKey, loadBytes, matchesHttpPath, matchesHttpPathPrefix, mergeHttpPath, mergeTwoLevels, normalizeHttpPath, omit, onAsyncIteratorObjectError, onError, onFinish, onReadableStreamError, onStart, onSuccess, once, override, parseAcceptEncodingQualities, pathToHttpPath, pick, promiseWithResolvers, recordSpanError, replicateAsyncIterator, replicateReadableStream, resolveMaybeOptionalOptions, runInSpanContext, runWithSignal, runWithSpan, set, setOwn, setSpanAttributeIfDefined, setTracer, sortPlugins, splitInHalf, startSpan, streamToAsyncIteratorObject, toSpanAttributeValue, toStringOrBytes, toTracingException, traceAsyncIterator, traceReadableStream, tryOrUndefined, value, varyByAcceptEncoding, wrapAsyncIterator, wrapReadableStream };
+export type { AnyFunction, AsyncIdQueueCloseOptions, ConsumeAsyncIteratorOptions, DistributiveOmit, InterceptableOptions, Interceptor, InterceptorOptions, IntersectPick, MaybeOptionalOptions, OnFinishState, OrderablePlugin, PromiseWithError, Public, ReadableStreamReadResult, Registry, Segment, StartSpanOptions, ThrowableError, Tracer, TracingAttributeValue, TracingException, TracingExceptionLevel, TracingHeaders, TracingSpan, Value, WrapAsyncIteratorOptions, WrapReadableStreamOptions };