mlform 0.1.7 → 0.1.8

package/dist/types/src/transport/internal.d.ts

@@ -1,110 +1,6 @@
-import { TransportError } from './errors';
-import { CapabilityRequirement, MaybePromise, SubmitRequest, Transport, TransportCapabilities, TransportCollection, TransportResponse, TransportSession, TransportSessionEvent, TransportStreamEvent } from './types';
-export type TransportEntry = {
-    id: string | undefined;
-    index: number;
-    label: string;
-    transport: Transport;
-};
-export type StreamFactory = (request: SubmitRequest) => AsyncIterable<TransportStreamEvent> | PromiseLike<AsyncIterable<TransportStreamEvent>>;
-type SessionFactory = (request: SubmitRequest) => TransportSession | PromiseLike<TransportSession>;
-export type AsyncQueue<T> = {
-    push(value: T): void;
-    close(): void;
-    [Symbol.asyncIterator](): AsyncIterator<T>;
-};
-export declare const isRecord: (value: unknown) => value is Record<string, unknown>;
-export declare const isAbortError: (error: unknown) => boolean;
-export declare const createTransport: (submit: Transport["submit"], stream?: StreamFactory, options?: {
-    openSession?: SessionFactory;
-    capabilities?: TransportCapabilities;
-}) => Transport;
-export declare const createAsyncQueue: <T>() => AsyncQueue<T>;
-export declare const resolveStream: (transport: Transport, request: SubmitRequest) => Promise<AsyncIterable<TransportStreamEvent>>;
-export declare const mergeHeaders: (baseHeaders: HeadersInit | undefined, extraHeaders: HeadersInit | undefined) => Headers;
-export declare const resolveRequestCredentials: (optionsCredentials: RequestCredentials | undefined, request: SubmitRequest) => RequestCredentials | undefined;
-export declare const withRequestTransportContext: (request: SubmitRequest, context: NonNullable<SubmitRequest["transport"]>) => SubmitRequest;
-export declare const ensureRequestPolicyContext: (request: SubmitRequest) => SubmitRequest;
-export declare const withCapabilityRequirement: (request: SubmitRequest, requirement: CapabilityRequirement | undefined, transport: Transport, context: string) => SubmitRequest;
-export declare const normalizeRequest: (request: SubmitRequest, transport: Transport, context: string) => SubmitRequest;
-export declare const getTransportScope: (request: SubmitRequest, fallback: string) => string;
-export declare const withRequestPolicyScope: (request: SubmitRequest, scope: string, extras?: {
-    source?: string;
-    backend?: string;
-    requestId?: string;
-}) => SubmitRequest;
-export declare const getErrorMessage: (error: unknown) => string;
-export declare const toTransportError: (error: unknown, defaults?: {
-    source?: string;
-    status?: number;
-    code?: string;
-    retryable?: boolean;
-    response?: unknown;
-    details?: unknown;
-}) => TransportError;
-export declare const assertRetrySafe: (transport: Transport, allowUnsafeRetry?: boolean) => void;
-export declare const assertCacheSafe: (transport: Transport, allowUnsafeCache?: boolean) => void;
-export declare const assertHedgingSafe: (transport: Transport, allowUnsafeHedging?: boolean) => void;
-export declare const defaultDedupKey: (request: SubmitRequest) => string;
-export declare const normalizeTransportResponse: (response: unknown) => TransportResponse;
-export declare const normalizeStreamEvent: (event: unknown) => TransportStreamEvent;
-export declare const resolveTransportEntries: (transports: TransportCollection, factoryName: string) => readonly TransportEntry[];
-export declare const createAggregateFailure: (message: string, failures: readonly {
-    label: string;
-    error: unknown;
-}[]) => TransportError;
-export declare const combineSignals: (signals: (AbortSignal | undefined)[]) => {
-    signal: AbortSignal;
-    cleanup: () => void;
-};
-export declare const waitForDelay: (ms: number, signal?: AbortSignal) => Promise<void>;
-export declare const withEventMeta: (event: TransportStreamEvent, meta: Record<string, unknown>) => TransportStreamEvent;
-export declare const toSessionStreamEvent: (event: TransportSessionEvent) => TransportStreamEvent | null;
-export declare const createSubmitBackedStream: (transport: Transport, request: SubmitRequest) => AsyncIterable<TransportStreamEvent>;
-export declare const resolveStreamOrSubmit: (transport: Transport, request: SubmitRequest) => AsyncIterable<TransportStreamEvent> | PromiseLike<AsyncIterable<TransportStreamEvent>>;
-export declare const resolveGraphqlValue: <TValue>(value: TValue | ((request: SubmitRequest) => MaybePromise<TValue>), request: SubmitRequest) => Promise<TValue>;
-export declare const parseSseBlocks: (stream: ReadableStream<Uint8Array>) => AsyncIterable<{
-    id?: string;
-    event?: string;
-    data: string;
-    retry?: number;
-}>;
-export declare const defaultDecodeSseEvent: (event: {
-    id?: string;
-    event?: string;
-    data: string;
-    retry?: number;
-}) => Promise<TransportStreamEvent>;
-export declare const defaultBody: (request: Parameters<Transport["submit"]>[0]) => {
-    inputs: Record<string, unknown>;
-};
-export declare const defaultParse: (response: Response) => Promise<unknown>;
-export declare const resolveErrorMessage: (status: number, statusText: string, payload: unknown) => string;
-export declare const resolveErrorCode: (payload: unknown) => string | undefined;
-export declare const resolveMethod: (method: string | undefined) => "POST" | "PUT" | "PATCH" | "DELETE";
-export declare const resolveSecret: (value: string | (() => MaybePromise<string>)) => Promise<string>;
-export declare const chooseWeightedTransport: <TTransportId extends string>(request: SubmitRequest, transportIds: readonly TTransportId[], weights: Partial<Record<TTransportId, number>> | ((request: SubmitRequest, transportId: TTransportId) => MaybePromise<number>), filter?: (transportId: TTransportId, request: SubmitRequest) => MaybePromise<boolean>) => Promise<TTransportId>;
-export declare const toFanoutMeta: (results: readonly {
-    id: string | undefined;
-    index: number;
-    response: TransportResponse;
-}[], failures: readonly {
-    id: string | undefined;
-    index: number;
-    error: unknown;
-}[]) => Record<string, unknown>;
-export declare const toFanoutRaw: (results: readonly {
-    id: string | undefined;
-    index: number;
-    response: TransportResponse;
-}[]) => unknown;
-export declare const mergeFanoutResponses: (results: readonly {
-    id: string | undefined;
-    index: number;
-    response: TransportResponse;
-}[], failures: readonly {
-    id: string | undefined;
-    index: number;
-    error: unknown;
-}[]) => TransportResponse;
-export {};
+export * from './internal-core';
+export * from './internal-request';
+export * from './internal-errors';
+export * from './internal-stream';
+export * from './internal-sse';
+export * from './internal-routing';

package/dist/types/src/transport/types/options-http.d.ts

@@ -0,0 +1,85 @@
+import { TransportCapabilities } from './capabilities';
+import { MaybePromise, SubmitRequest } from './core';
+import { TransportStreamEvent } from './events';
+import { TransportSession, TransportSessionMessage } from './session';
+export type JsonTransportMethod = "POST" | "PUT" | "PATCH" | "DELETE";
+export interface JsonTransportOptions {
+    endpoint: string | URL;
+    source?: string;
+    fetch?: typeof globalThis.fetch;
+    method?: JsonTransportMethod;
+    headers?: HeadersInit | (() => MaybePromise<HeadersInit>);
+    credentials?: RequestCredentials;
+    body?: (request: SubmitRequest) => BodyInit | null | undefined;
+    parse?: (response: Response) => Promise<unknown>;
+    stream?: (response: Response, request: SubmitRequest) => MaybePromise<AsyncIterable<TransportStreamEvent>>;
+}
+export interface GraphqlTransportOptions {
+    endpoint: string | URL;
+    source?: string;
+    fetch?: typeof globalThis.fetch;
+    query: string | ((request: SubmitRequest) => MaybePromise<string>);
+    operationName?: string | ((request: SubmitRequest) => MaybePromise<string | undefined>);
+    variables?: (request: SubmitRequest) => MaybePromise<Record<string, unknown>>;
+    headers?: HeadersInit | (() => MaybePromise<HeadersInit>);
+    credentials?: RequestCredentials;
+    parse?: (response: Response) => Promise<unknown>;
+    resultPath?: "data" | `data.${string}`;
+    resolveResult?: (payload: unknown, request: SubmitRequest) => MaybePromise<unknown>;
+}
+export interface SseTransportOptions {
+    endpoint: string | URL;
+    source?: string;
+    fetch?: typeof globalThis.fetch;
+    method?: "POST" | "PUT" | "PATCH";
+    headers?: HeadersInit | (() => MaybePromise<HeadersInit>);
+    credentials?: RequestCredentials;
+    body?: (request: SubmitRequest) => BodyInit | null | undefined;
+    decodeEvent?: (event: {
+        id?: string;
+        event?: string;
+        data: string;
+        retry?: number;
+    }, request: SubmitRequest) => MaybePromise<TransportStreamEvent>;
+    resultEvent?: string | ((event: {
+        id?: string;
+        event?: string;
+        data: string;
+        retry?: number;
+    }) => boolean);
+    maxPayloadBytes?: number;
+}
+export interface WebSocketSessionTransportOptions {
+    url: string | URL | ((request: SubmitRequest) => MaybePromise<string | URL>);
+    source?: string;
+    WebSocket?: typeof globalThis.WebSocket;
+    protocols?: string | string[] | ((request: SubmitRequest) => MaybePromise<string | string[]>);
+    serializeMessage?: (message: unknown) => string | ArrayBuffer | Blob | Uint8Array;
+    deserializeMessage?: (data: string | ArrayBuffer | Blob) => MaybePromise<unknown>;
+    sessionInit?: TransportSessionMessage | ((request: SubmitRequest) => MaybePromise<TransportSessionMessage | undefined>);
+    closeTimeoutMs?: number;
+    maxBufferedMessages?: number;
+    bufferOverflow?: "close" | "drop-oldest" | "drop-newest" | "error";
+}
+export interface GrpcUnaryTransportOptions {
+    source?: string;
+    unary?: (request: SubmitRequest) => MaybePromise<unknown>;
+    capabilities?: TransportCapabilities;
+}
+export interface GrpcStreamTransportOptions {
+    source?: string;
+    stream: (request: SubmitRequest) => MaybePromise<AsyncIterable<TransportStreamEvent>>;
+    capabilities?: TransportCapabilities;
+}
+export interface GrpcSessionTransportOptions {
+    source?: string;
+    session: (request: SubmitRequest) => MaybePromise<TransportSession>;
+    capabilities?: TransportCapabilities;
+}
+export interface GrpcTransportOptions {
+    source?: string;
+    unary?: (request: SubmitRequest) => MaybePromise<unknown>;
+    stream?: (request: SubmitRequest) => MaybePromise<AsyncIterable<TransportStreamEvent>>;
+    session?: (request: SubmitRequest) => MaybePromise<TransportSession>;
+    capabilities?: TransportCapabilities;
+}

package/dist/types/src/transport/types/options-middleware.d.ts

@@ -0,0 +1,96 @@
+import { MaybePromise, SubmitRequest, Transport, TransportPolicyContext } from './core';
+import { TransportStreamEvent } from './events';
+import { CircuitBreakerSharedState, SharedRateLimiter, TransportCacheStore } from './state';
+export interface SessionTransportOptions {
+    submit?: Transport["submit"];
+    stream?: Transport["stream"];
+    openSession: NonNullable<Transport["openSession"]>;
+    capabilities?: import('./capabilities').TransportCapabilities;
+}
+export interface RetryOptions {
+    attempts: number;
+    backoff?: "exponential" | "linear" | number[] | ((attempt: number) => number);
+    baseDelay?: number;
+    maxDelay?: number;
+    jitter?: boolean;
+    allowUnsafeRetry?: boolean;
+    retryOn?: (error: unknown, attempt: number) => boolean;
+}
+export interface ApiKeyAuthOptions {
+    type: "api-key";
+    key: string | (() => MaybePromise<string>);
+    header?: string;
+    prefix?: string;
+}
+export interface BearerAuthOptions {
+    type: "bearer";
+    token: string | (() => MaybePromise<string>);
+    header?: string;
+    prefix?: string;
+}
+export interface CustomAuthOptions {
+    type: "custom";
+    apply: (request: SubmitRequest) => MaybePromise<SubmitRequest>;
+}
+export interface TransportContextAuthOptions {
+    type: "transport-context";
+    context: NonNullable<SubmitRequest["transport"]> | (() => MaybePromise<NonNullable<SubmitRequest["transport"]>>);
+}
+export type AuthOptions = ApiKeyAuthOptions | BearerAuthOptions | CustomAuthOptions | TransportContextAuthOptions;
+export interface CircuitBreakerOptions {
+    failureThreshold: number;
+    resetTimeout: number;
+    halfOpenMaxRequests?: number;
+    key?: string;
+    scope?: string;
+    sharedState?: CircuitBreakerSharedState;
+    tripOn?: (error: unknown) => boolean;
+    onStateChange?: (state: "closed" | "open" | "half-open") => void;
+}
+export interface RateLimitOptions {
+    maxConcurrent?: number;
+    perSecond?: number;
+    queueLimit?: number;
+    key?: string;
+    scope?: string;
+    limiter?: SharedRateLimiter;
+}
+export interface DedupOptions {
+    key?: (request: SubmitRequest) => string;
+}
+export interface CacheOptions {
+    key: (request: SubmitRequest) => string;
+    ttl: number;
+    maxEntries?: number;
+    scope?: string;
+    store?: TransportCacheStore;
+    allowUnsafeCache?: boolean;
+    shouldCache?: (response: unknown, request: SubmitRequest) => boolean;
+}
+export interface TransportTraceOptions {
+    traceparent?: string | ((request: SubmitRequest) => MaybePromise<string | undefined>);
+    baggage?: string | ((request: SubmitRequest) => MaybePromise<string | undefined>);
+    attributes?: (request: SubmitRequest) => MaybePromise<Record<string, unknown> | undefined>;
+    preserveExistingHeaders?: boolean;
+    requestId?: string | ((request: SubmitRequest) => MaybePromise<string | undefined>);
+    scope?: string | ((request: SubmitRequest) => MaybePromise<string | undefined>);
+}
+export interface TransportTelemetryEvent {
+    kind: "request-start" | "request-success" | "request-error" | "stream-event" | "session-open" | "session-close" | "capability-reject" | "policy-block";
+    source?: string;
+    scope?: string;
+    durationMs?: number;
+    error?: unknown;
+    request: SubmitRequest;
+    meta?: Record<string, unknown>;
+}
+export interface TransportMetricsOptions {
+    emit(event: TransportTelemetryEvent): void;
+}
+export interface TransportLogOptions {
+    onRequest?: (request: SubmitRequest) => void;
+    onResponse?: (response: unknown, request: SubmitRequest, durationMs: number) => void;
+    onError?: (error: unknown, request: SubmitRequest, durationMs: number) => void;
+    onStreamEvent?: (event: TransportStreamEvent, request: SubmitRequest) => void;
+}
+export type TransportContextPolicy = TransportPolicyContext;

package/dist/types/src/transport/types/options-routing.d.ts

@@ -0,0 +1,82 @@
+import { CapabilityRequirement } from './capabilities';
+import { MaybePromise, SubmitRequest, Transport, TransportResponse } from './core';
+import { TransportCollection } from './middleware';
+import { TransportHealthState } from './state';
+export interface RoutingTransportOptions<TTransportId extends string = string> {
+    transports: Record<TTransportId, Transport>;
+    requiredCapabilities?: CapabilityRequirement;
+    selectTransport: (request: SubmitRequest, context: {
+        transportIds: readonly TTransportId[];
+    }) => MaybePromise<TTransportId>;
+}
+export interface WeightedRoutingTransportOptions<TTransportId extends string = string> {
+    transports: Record<TTransportId, Transport>;
+    requiredCapabilities?: CapabilityRequirement;
+    weights: Partial<Record<TTransportId, number>> | ((request: SubmitRequest, transportId: TTransportId) => MaybePromise<number>);
+    filter?: (transportId: TTransportId, request: SubmitRequest) => MaybePromise<boolean>;
+}
+export interface FanoutTransportResult<TTransportId extends string = string> {
+    id: TTransportId | undefined;
+    index: number;
+    response: TransportResponse;
+}
+export interface FanoutTransportFailure<TTransportId extends string = string> {
+    id: TTransportId | undefined;
+    index: number;
+    error: unknown;
+}
+export interface FanoutTransportOptions<TTransportId extends string = string> {
+    transports: TransportCollection<TTransportId>;
+    requiredCapabilities?: CapabilityRequirement;
+    filter?: (transportId: string, request: SubmitRequest) => MaybePromise<boolean>;
+    transformRequest?: (transportId: string, request: SubmitRequest) => MaybePromise<SubmitRequest>;
+    failurePolicy?: "fail-all" | "partial-success";
+    abortPolicy?: "wait-all" | "abort-pending-on-first-failure" | "abort-pending-on-first-success";
+    merge?: (context: {
+        request: SubmitRequest;
+        results: readonly FanoutTransportResult<TTransportId>[];
+        failures: readonly FanoutTransportFailure<TTransportId>[];
+    }) => MaybePromise<unknown>;
+}
+export interface FallbackTransportFailure<TTransportId extends string = string> {
+    id: TTransportId | undefined;
+    index: number;
+    error: unknown;
+}
+export interface FallbackTransportOptions<TTransportId extends string = string> {
+    transports: TransportCollection<TTransportId>;
+    shouldFallback?: (error: unknown, context: {
+        request: SubmitRequest;
+        id: TTransportId | undefined;
+        index: number;
+        failures: readonly FallbackTransportFailure<TTransportId>[];
+    }) => MaybePromise<boolean>;
+}
+export interface PipelineStage {
+    id?: string;
+    transport: Transport;
+    mapToNext?: (response: unknown, originalRequest: SubmitRequest) => MaybePromise<SubmitRequest>;
+    nextStageRequirements?: CapabilityRequirement;
+}
+export interface PipelineTransportOptions {
+    stages: readonly PipelineStage[];
+}
+export interface RacingTransportOptions {
+    transports: TransportCollection;
+}
+export interface HedgedTransportOptions<TTransportId extends string = string> {
+    transports: Record<TTransportId, Transport>;
+    hedgeDelayMs: number;
+    maxAttempts?: number;
+    allowUnsafeHedging?: boolean;
+}
+export interface QuorumFanoutTransportOptions<TTransportId extends string = string> extends FanoutTransportOptions<TTransportId> {
+    quorum: number;
+}
+export interface LoadBalancingTransportOptions<TTransportId extends string = string> {
+    transports: Record<TTransportId, Transport>;
+    requiredCapabilities?: CapabilityRequirement;
+    strategy?: "round-robin" | "least-loaded" | "random" | "weighted" | "health-weighted";
+    weights: Partial<Record<TTransportId, number>> | ((request: SubmitRequest, transportId: TTransportId) => MaybePromise<number>);
+    healthState?: TransportHealthState<TTransportId>;
+}

package/dist/types/src/transport/types/options.d.ts

@@ -1,258 +1,3 @@
-import { TransportCapabilities, CapabilityRequirement } from './capabilities';
-import { MaybePromise, SubmitRequest, Transport, TransportPolicyContext, TransportResponse } from './core';
-import { TransportStreamEvent } from './events';
-import { TransportSession, TransportSessionMessage } from './session';
-import { CircuitBreakerSharedState, SharedRateLimiter, TransportCacheStore, TransportHealthState } from './state';
-import { TransportCollection } from './middleware';
-export type JsonTransportMethod = "POST" | "PUT" | "PATCH" | "DELETE";
-export interface JsonTransportOptions {
-    endpoint: string | URL;
-    source?: string;
-    fetch?: typeof globalThis.fetch;
-    method?: JsonTransportMethod;
-    headers?: HeadersInit | (() => MaybePromise<HeadersInit>);
-    credentials?: RequestCredentials;
-    body?: (request: SubmitRequest) => BodyInit | null | undefined;
-    parse?: (response: Response) => Promise<unknown>;
-    stream?: (response: Response, request: SubmitRequest) => MaybePromise<AsyncIterable<TransportStreamEvent>>;
-}
-export interface GraphqlTransportOptions {
-    endpoint: string | URL;
-    source?: string;
-    fetch?: typeof globalThis.fetch;
-    query: string | ((request: SubmitRequest) => MaybePromise<string>);
-    operationName?: string | ((request: SubmitRequest) => MaybePromise<string | undefined>);
-    variables?: (request: SubmitRequest) => MaybePromise<Record<string, unknown>>;
-    headers?: HeadersInit | (() => MaybePromise<HeadersInit>);
-    credentials?: RequestCredentials;
-    parse?: (response: Response) => Promise<unknown>;
-    resultPath?: "data" | `data.${string}`;
-    resolveResult?: (payload: unknown, request: SubmitRequest) => MaybePromise<unknown>;
-}
-export interface SseTransportOptions {
-    endpoint: string | URL;
-    source?: string;
-    fetch?: typeof globalThis.fetch;
-    method?: "POST" | "PUT" | "PATCH";
-    headers?: HeadersInit | (() => MaybePromise<HeadersInit>);
-    credentials?: RequestCredentials;
-    body?: (request: SubmitRequest) => BodyInit | null | undefined;
-    decodeEvent?: (event: {
-        id?: string;
-        event?: string;
-        data: string;
-        retry?: number;
-    }, request: SubmitRequest) => MaybePromise<TransportStreamEvent>;
-    resultEvent?: string | ((event: {
-        id?: string;
-        event?: string;
-        data: string;
-        retry?: number;
-    }) => boolean);
-    maxPayloadBytes?: number;
-}
-export interface WebSocketSessionTransportOptions {
-    url: string | URL | ((request: SubmitRequest) => MaybePromise<string | URL>);
-    source?: string;
-    WebSocket?: typeof globalThis.WebSocket;
-    protocols?: string | string[] | ((request: SubmitRequest) => MaybePromise<string | string[]>);
-    serializeMessage?: (message: unknown) => string | ArrayBuffer | Blob | Uint8Array;
-    deserializeMessage?: (data: string | ArrayBuffer | Blob) => MaybePromise<unknown>;
-    sessionInit?: TransportSessionMessage | ((request: SubmitRequest) => MaybePromise<TransportSessionMessage | undefined>);
-    closeTimeoutMs?: number;
-    maxBufferedMessages?: number;
-    bufferOverflow?: "close" | "drop-oldest" | "drop-newest" | "error";
-}
-export interface GrpcUnaryTransportOptions {
-    source?: string;
-    unary?: (request: SubmitRequest) => MaybePromise<unknown>;
-    capabilities?: TransportCapabilities;
-}
-export interface GrpcStreamTransportOptions {
-    source?: string;
-    stream: (request: SubmitRequest) => MaybePromise<AsyncIterable<TransportStreamEvent>>;
-    capabilities?: TransportCapabilities;
-}
-export interface GrpcSessionTransportOptions {
-    source?: string;
-    session: (request: SubmitRequest) => MaybePromise<TransportSession>;
-    capabilities?: TransportCapabilities;
-}
-export interface GrpcTransportOptions {
-    source?: string;
-    unary?: (request: SubmitRequest) => MaybePromise<unknown>;
-    stream?: (request: SubmitRequest) => MaybePromise<AsyncIterable<TransportStreamEvent>>;
-    session?: (request: SubmitRequest) => MaybePromise<TransportSession>;
-    capabilities?: TransportCapabilities;
-}
-export interface SessionTransportOptions {
-    submit?: Transport["submit"];
-    stream?: Transport["stream"];
-    openSession: NonNullable<Transport["openSession"]>;
-    capabilities?: TransportCapabilities;
-}
-export interface RoutingTransportOptions<TTransportId extends string = string> {
-    transports: Record<TTransportId, Transport>;
-    requiredCapabilities?: CapabilityRequirement;
-    selectTransport: (request: SubmitRequest, context: {
-        transportIds: readonly TTransportId[];
-    }) => MaybePromise<TTransportId>;
-}
-export interface WeightedRoutingTransportOptions<TTransportId extends string = string> {
-    transports: Record<TTransportId, Transport>;
-    requiredCapabilities?: CapabilityRequirement;
-    weights: Partial<Record<TTransportId, number>> | ((request: SubmitRequest, transportId: TTransportId) => MaybePromise<number>);
-    filter?: (transportId: TTransportId, request: SubmitRequest) => MaybePromise<boolean>;
-}
-export interface FanoutTransportResult<TTransportId extends string = string> {
-    id: TTransportId | undefined;
-    index: number;
-    response: TransportResponse;
-}
-export interface FanoutTransportFailure<TTransportId extends string = string> {
-    id: TTransportId | undefined;
-    index: number;
-    error: unknown;
-}
-export interface FanoutTransportOptions<TTransportId extends string = string> {
-    transports: TransportCollection<TTransportId>;
-    requiredCapabilities?: CapabilityRequirement;
-    filter?: (transportId: string, request: SubmitRequest) => MaybePromise<boolean>;
-    transformRequest?: (transportId: string, request: SubmitRequest) => MaybePromise<SubmitRequest>;
-    failurePolicy?: "fail-all" | "partial-success";
-    abortPolicy?: "wait-all" | "abort-pending-on-first-failure" | "abort-pending-on-first-success";
-    merge?: (context: {
-        request: SubmitRequest;
-        results: readonly FanoutTransportResult<TTransportId>[];
-        failures: readonly FanoutTransportFailure<TTransportId>[];
-    }) => MaybePromise<unknown>;
-}
-export interface FallbackTransportFailure<TTransportId extends string = string> {
-    id: TTransportId | undefined;
-    index: number;
-    error: unknown;
-}
-export interface FallbackTransportOptions<TTransportId extends string = string> {
-    transports: TransportCollection<TTransportId>;
-    shouldFallback?: (error: unknown, context: {
-        request: SubmitRequest;
-        id: TTransportId | undefined;
-        index: number;
-        failures: readonly FallbackTransportFailure<TTransportId>[];
-    }) => MaybePromise<boolean>;
-}
-export interface PipelineStage {
-    id?: string;
-    transport: Transport;
-    mapToNext?: (response: unknown, originalRequest: SubmitRequest) => MaybePromise<SubmitRequest>;
-    nextStageRequirements?: CapabilityRequirement;
-}
-export interface PipelineTransportOptions {
-    stages: readonly PipelineStage[];
-}
-export interface RacingTransportOptions {
-    transports: TransportCollection;
-}
-export interface HedgedTransportOptions<TTransportId extends string = string> {
-    transports: Record<TTransportId, Transport>;
-    hedgeDelayMs: number;
-    maxAttempts?: number;
-    allowUnsafeHedging?: boolean;
-}
-export interface QuorumFanoutTransportOptions<TTransportId extends string = string> extends FanoutTransportOptions<TTransportId> {
-    quorum: number;
-}
-export interface LoadBalancingTransportOptions<TTransportId extends string = string> {
-    transports: Record<TTransportId, Transport>;
-    requiredCapabilities?: CapabilityRequirement;
-    strategy?: "round-robin" | "least-loaded" | "random" | "weighted" | "health-weighted";
-    weights?: Partial<Record<TTransportId, number>> | ((request: SubmitRequest, transportId: TTransportId) => MaybePromise<number>);
-    healthState?: TransportHealthState<TTransportId>;
-}
-export interface RetryOptions {
-    attempts: number;
-    backoff?: "exponential" | "linear" | number[] | ((attempt: number) => number);
-    baseDelay?: number;
-    maxDelay?: number;
-    jitter?: boolean;
-    allowUnsafeRetry?: boolean;
-    retryOn?: (error: unknown, attempt: number) => boolean;
-}
-export interface ApiKeyAuthOptions {
-    type: "api-key";
-    key: string | (() => MaybePromise<string>);
-    header?: string;
-    prefix?: string;
-}
-export interface BearerAuthOptions {
-    type: "bearer";
-    token: string | (() => MaybePromise<string>);
-    header?: string;
-    prefix?: string;
-}
-export interface CustomAuthOptions {
-    type: "custom";
-    apply: (request: SubmitRequest) => MaybePromise<SubmitRequest>;
-}
-export interface TransportContextAuthOptions {
-    type: "transport-context";
-    context: NonNullable<SubmitRequest["transport"]> | (() => MaybePromise<NonNullable<SubmitRequest["transport"]>>);
-}
-export type AuthOptions = ApiKeyAuthOptions | BearerAuthOptions | CustomAuthOptions | TransportContextAuthOptions;
-export interface CircuitBreakerOptions {
-    failureThreshold: number;
-    resetTimeout: number;
-    halfOpenMaxRequests?: number;
-    key?: string;
-    scope?: string;
-    sharedState?: CircuitBreakerSharedState;
-    tripOn?: (error: unknown) => boolean;
-    onStateChange?: (state: "closed" | "open" | "half-open") => void;
-}
-export interface RateLimitOptions {
-    maxConcurrent?: number;
-    perSecond?: number;
-    queueLimit?: number;
-    key?: string;
-    scope?: string;
-    limiter?: SharedRateLimiter;
-}
-export interface DedupOptions {
-    key?: (request: SubmitRequest) => string;
-}
-export interface CacheOptions {
-    key: (request: SubmitRequest) => string;
-    ttl: number;
-    maxEntries?: number;
-    scope?: string;
-    store?: TransportCacheStore;
-    allowUnsafeCache?: boolean;
-    shouldCache?: (response: unknown, request: SubmitRequest) => boolean;
-}
-export interface TransportTraceOptions {
-    traceparent?: string | ((request: SubmitRequest) => MaybePromise<string | undefined>);
-    baggage?: string | ((request: SubmitRequest) => MaybePromise<string | undefined>);
-    attributes?: (request: SubmitRequest) => MaybePromise<Record<string, unknown> | undefined>;
-    preserveExistingHeaders?: boolean;
-    requestId?: string | ((request: SubmitRequest) => MaybePromise<string | undefined>);
-    scope?: string | ((request: SubmitRequest) => MaybePromise<string | undefined>);
-}
-export interface TransportTelemetryEvent {
-    kind: "request-start" | "request-success" | "request-error" | "stream-event" | "session-open" | "session-close" | "capability-reject" | "policy-block";
-    source?: string;
-    scope?: string;
-    durationMs?: number;
-    error?: unknown;
-    request: SubmitRequest;
-    meta?: Record<string, unknown>;
-}
-export interface TransportMetricsOptions {
-    emit(event: TransportTelemetryEvent): void;
-}
-export interface TransportLogOptions {
-    onRequest?: (request: SubmitRequest) => void;
-    onResponse?: (response: unknown, request: SubmitRequest, durationMs: number) => void;
-    onError?: (error: unknown, request: SubmitRequest, durationMs: number) => void;
-    onStreamEvent?: (event: TransportStreamEvent, request: SubmitRequest) => void;
-}
-export type TransportContextPolicy = TransportPolicyContext;
+export type { JsonTransportMethod, JsonTransportOptions, GraphqlTransportOptions, SseTransportOptions, WebSocketSessionTransportOptions, GrpcUnaryTransportOptions, GrpcStreamTransportOptions, GrpcSessionTransportOptions, GrpcTransportOptions, } from './options-http';
+export type { RoutingTransportOptions, WeightedRoutingTransportOptions, FanoutTransportResult, FanoutTransportFailure, FanoutTransportOptions, FallbackTransportFailure, FallbackTransportOptions, PipelineStage, PipelineTransportOptions, RacingTransportOptions, HedgedTransportOptions, QuorumFanoutTransportOptions, LoadBalancingTransportOptions, } from './options-routing';
+export type { SessionTransportOptions, RetryOptions, ApiKeyAuthOptions, BearerAuthOptions, CustomAuthOptions, TransportContextAuthOptions, AuthOptions, CircuitBreakerOptions, RateLimitOptions, DedupOptions, CacheOptions, TransportTraceOptions, TransportTelemetryEvent, TransportMetricsOptions, TransportLogOptions, TransportContextPolicy, } from './options-middleware';