export { ProtoCodec } from './codec.js';
import { DescService, DescMethod, DescMethodUnary, MessageShape, MessageInitShape, DescMethodServerStreaming, DescMethodClientStreaming, DescMethodBiDiStreaming, DescMessage } from '@bufbuild/protobuf';
import { TSchema, Static } from 'typebox';
import { C as ClientTransport } from '../client-C8pwDvTN.js';
import { A as SessionId, C as Connection, n as ClientHandshakeOptions, q as ConnectionExtras, r as ServerHandshakeOptions } from '../transport-DF2T202E.js';
import { T as TransportClientId, C as CustomHandshakeErrorCodeSchema, j as HandshakeErrorCustomHandlerFatalResponseCodes, k as CustomHandshakeErrorCode, O as OpaqueTransportMessage } from '../message-C2qDAau6.js';
import { a2 as ErrorPayload, C as CANCEL_CODE, g as INVALID_REQUEST_CODE, U as UNCAUGHT_ERROR_CODE, T as UNEXPECTED_DISCONNECT_CODE, f as ErrResult, x as Result, X as Writable, s as Readable } from '../services-DPANPmhb.js';
export { E as Err, O as Ok, h as OkResult, t as ReadableBrokenError, u as ReadableResult, y as ResultUnwrapErr, z as ResultUnwrapOk } from '../services-DPANPmhb.js';
import { Span } from '@opentelemetry/api';
import { TUint8Array } from '../customSchemas/index.js';
import { S as ServerTransport } from '../server-D88e2r09.js';
import '../types-BGGvYIJM.js';
import '../index-CIMpdW6z.js';
import '../adapter-K2HsfQLt.js';

/**
 * Canonical RPC error codes shared by gRPC and Connect.
 *
 * The protobuf router uses these codes for unary rejections and streamed error
 * messages so applications can reason about familiar transport-agnostic error
 * categories.
 */
declare enum RiverErrorCode {
    OK = "OK",
    CANCELED = "CANCELED",
    UNKNOWN = "UNKNOWN",
    INVALID_ARGUMENT = "INVALID_ARGUMENT",
    DEADLINE_EXCEEDED = "DEADLINE_EXCEEDED",
    NOT_FOUND = "NOT_FOUND",
    ALREADY_EXISTS = "ALREADY_EXISTS",
    PERMISSION_DENIED = "PERMISSION_DENIED",
    RESOURCE_EXHAUSTED = "RESOURCE_EXHAUSTED",
    FAILED_PRECONDITION = "FAILED_PRECONDITION",
    ABORTED = "ABORTED",
    OUT_OF_RANGE = "OUT_OF_RANGE",
    UNIMPLEMENTED = "UNIMPLEMENTED",
    INTERNAL = "INTERNAL",
    UNAVAILABLE = "UNAVAILABLE",
    DATA_LOSS = "DATA_LOSS",
    UNAUTHENTICATED = "UNAUTHENTICATED"
}
/**
 * Protocol-level error codes surfaced by River itself rather than user
 * handlers.
 */
type ProtocolErrorCode = typeof CANCEL_CODE | typeof INVALID_REQUEST_CODE | typeof UNCAUGHT_ERROR_CODE | typeof UNEXPECTED_DISCONNECT_CODE;
/**
 * Error codes visible from the protobuf client surface.
 */
type ClientErrorCode = RiverErrorCode | ProtocolErrorCode;
/**
 * A serialized protobuf error detail.
 *
 * The `typeName` identifies the protobuf message descriptor the client can use
 * to decode `value`.
 */
interface RiverErrorDetail {
    readonly typeName: string;
    readonly value: Uint8Array;
}
/**
 * A plain-object error payload used by the protobuf router.
 *
 * Handlers return these via `Err({ code, message, ... })`.
 */
interface ClientError extends ErrorPayload {
    readonly code: ClientErrorCode;
    readonly metadata?: Readonly<Record<string, string>>;
    readonly details?: ReadonlyArray<RiverErrorDetail>;
}
/**
 * A protocol error emitted by the River runtime.
 */
interface ProtocolError extends ClientError {
    readonly code: ProtocolErrorCode;
}
/**
 * Returns true when the given value matches the wire shape of a client error
 * with a canonical RPC error code.
 */
declare function isRiverError(value: unknown): value is ClientError;
/**
 * Returns true when the given value is a protocol error.
 */
declare function isProtocolError(value: unknown): value is ProtocolError;
/**
 * Returns true when the given value is any client-visible error.
 */
declare function isClientError(value: unknown): value is ClientError;
/**
 * Returns true when the given value matches the `Err(...)` wrapper used for
 * protobuf cancel payloads sent by the runtime or handlers.
 */
declare function isSerializedClientErrorResult(value: unknown): value is ErrResult<ClientError>;
/**
 * Returns true when the given value matches the protocol-only cancel payloads
 * sent by clients.
 */
declare function isSerializedProtocolErrorResult(value: unknown): value is ErrResult<ProtocolError>;

/**
 * Context passed to protobuf handler invocations.
 *
 * User-provided `Context` is spread into the type so handler authors can
 * access application dependencies directly (e.g. `ctx.db`). Per-service
 * `State` is available via `ctx.state`.
 */
type ProtobufHandlerContext<Context extends object = object, State extends object = object, ParsedMetadata extends object = object> = Context & {
    /**
     * Per-service state created by {@link ProtoService}'s `initializeState`.
     */
    readonly state: State;
    /**
     * The span for the current procedure call.
     */
    readonly span: Span;
    /**
     * Metadata parsed during the transport handshake.
     */
    readonly metadata: ParsedMetadata;
    /**
     * The session this invocation belongs to.
     */
    readonly sessionId: SessionId;
    /**
     * The remote transport client id that initiated the invocation.
     */
    readonly from: TransportClientId;
    /**
     * The protobuf service being invoked.
     */
    readonly service: DescService;
    /**
     * The protobuf method being invoked.
     */
    readonly method: DescMethod;
    /**
     * Register cleanup work that should run once the invocation finishes.
     */
    readonly deferCleanup: (fn: () => void | Promise<void>) => void;
    /**
     * Cancel the invocation and notify the client with a protocol-level cancel
     * error.
     */
    readonly cancel: (message?: string) => ErrResult<ProtocolError>;
    /**
     * Aborts when the invocation finishes for any reason.
     */
    readonly signal: AbortSignal;
};

type Awaitable<T> = T | PromiseLike<T>;
type HandlerResult<Method extends DescMethod> = Result<MessageInitShape<Method['output']>, ClientError>;
/**
 * Options shared by protobuf-router client calls.
 */
interface CallOptions {
    readonly signal?: AbortSignal;
}
/**
 * The client-side surface for a client-streaming method.
 */
interface ClientStreamingCall<Method extends DescMethodClientStreaming> {
    readonly reqWritable: Writable<MessageInitShape<Method['input']>>;
    readonly finalize: () => Promise<Result<MessageShape<Method['output']>, ClientError>>;
}
/**
 * The client-side surface for a bidi-streaming method.
 */
interface BiDiStreamingCall<Method extends DescMethodBiDiStreaming> {
    readonly reqWritable: Writable<MessageInitShape<Method['input']>>;
    readonly resReadable: Readable<MessageShape<Method['output']>, ClientError>;
}
/**
 * A protobuf-router unary handler.
 */
type UnaryImpl<Method extends DescMethodUnary, Context extends object = object, State extends object = object, ParsedMetadata extends object = object> = (request: MessageShape<Method['input']>, ctx: ProtobufHandlerContext<Context, State, ParsedMetadata>) => Awaitable<HandlerResult<Method>>;
/**
 * A protobuf-router server-streaming handler.
 */
type ServerStreamingImpl<Method extends DescMethodServerStreaming, Context extends object = object, State extends object = object, ParsedMetadata extends object = object> = (param: {
    readonly request: MessageShape<Method['input']>;
    readonly ctx: ProtobufHandlerContext<Context, State, ParsedMetadata>;
    readonly resWritable: Writable<HandlerResult<Method>>;
}) => Awaitable<void>;
/**
 * A protobuf-router client-streaming handler.
 */
type ClientStreamingImpl<Method extends DescMethodClientStreaming, Context extends object = object, State extends object = object, ParsedMetadata extends object = object> = (param: {
    readonly ctx: ProtobufHandlerContext<Context, State, ParsedMetadata>;
    readonly reqReadable: Readable<MessageShape<Method['input']>, ProtocolError>;
}) => Awaitable<HandlerResult<Method>>;
/**
 * A protobuf-router bidi-streaming handler.
 */
type BiDiStreamingImpl<Method extends DescMethodBiDiStreaming, Context extends object = object, State extends object = object, ParsedMetadata extends object = object> = (param: {
    readonly ctx: ProtobufHandlerContext<Context, State, ParsedMetadata>;
    readonly reqReadable: Readable<MessageShape<Method['input']>, ProtocolError>;
    readonly resWritable: Writable<HandlerResult<Method>>;
}) => Awaitable<void>;
/**
 * The handler type for an arbitrary protobuf method descriptor.
 */
type MethodImpl<Method extends DescMethod, Context extends object = object, State extends object = object, ParsedMetadata extends object = object> = Method extends DescMethodUnary ? UnaryImpl<Method, Context, State, ParsedMetadata> : Method extends DescMethodServerStreaming ? ServerStreamingImpl<Method, Context, State, ParsedMetadata> : Method extends DescMethodClientStreaming ? ClientStreamingImpl<Method, Context, State, ParsedMetadata> : Method extends DescMethodBiDiStreaming ? BiDiStreamingImpl<Method, Context, State, ParsedMetadata> : never;
type RawMethodImpl<Method extends DescMethod, Request, HandlerContext> = Method extends DescMethodUnary ? (request: Request, ctx: HandlerContext) => Awaitable<Result<Uint8Array, ClientError>> : Method extends DescMethodServerStreaming ? (param: {
    readonly request: Request;
    readonly ctx: HandlerContext;
    readonly resWritable: Writable<Result<Uint8Array, ClientError>>;
}) => Awaitable<void> : Method extends DescMethodClientStreaming ? (param: {
    readonly ctx: HandlerContext;
    readonly reqReadable: Readable<Request, ProtocolError>;
}) => Awaitable<Result<Uint8Array, ClientError>> : Method extends DescMethodBiDiStreaming ? (param: {
    readonly ctx: HandlerContext;
    readonly reqReadable: Readable<Request, ProtocolError>;
    readonly resWritable: Writable<Result<Uint8Array, ClientError>>;
}) => Awaitable<void> : never;
/** A raw handler owns protobuf-body validation; River still validates the envelope. */
type RawHandler<Method extends DescMethod, Context extends object = object, State extends object = object, ParsedMetadata extends object = object> = {
    readonly raw: 'both';
    readonly handler: RawMethodImpl<Method, Uint8Array, ProtobufHandlerContext<Context, State, ParsedMetadata>>;
} | {
    readonly raw: 'output';
    readonly handler: RawMethodImpl<Method, MessageShape<Method['input']>, ProtobufHandlerContext<Context, State, ParsedMetadata>>;
};
/**
 * Partial implementation shape for a protobuf service.
 *
 * All methods are optional -- missing methods return UNIMPLEMENTED at runtime.
 */
type ServiceImpl<Service extends DescService, Context extends object = object, State extends object = object, ParsedMetadata extends object = object> = {
    [MethodName in keyof Service['method']]?: MethodImpl<Service['method'][MethodName] & DescMethod, Context, State, ParsedMetadata>;
};
type ServiceImplWithRawHandlers<Service extends DescService, Context extends object = object, State extends object = object, ParsedMetadata extends object = object> = {
    [MethodName in keyof Service['method']]?: ServiceImpl<Service, Context, State, ParsedMetadata>[MethodName] | RawHandler<Service['method'][MethodName] & DescMethod, Context, State, ParsedMetadata>;
};
/**
 * The client surface for an arbitrary protobuf method descriptor.
 */
type ClientMethod<Method extends DescMethod> = Method extends DescMethodUnary ? (request: MessageInitShape<Method['input']>, options?: CallOptions) => Promise<Result<MessageShape<Method['output']>, ClientError>> : Method extends DescMethodServerStreaming ? (request: MessageInitShape<Method['input']>, options?: CallOptions) => Readable<MessageShape<Method['output']>, ClientError> : Method extends DescMethodClientStreaming ? (options?: CallOptions) => ClientStreamingCall<Method> : Method extends DescMethodBiDiStreaming ? (options?: CallOptions) => BiDiStreamingCall<Method> : never;
/**
 * The generated client shape for a protobuf service descriptor.
 */
type Client<Service extends DescService> = {
    [MethodName in keyof Service['method']]: Service['method'][MethodName] extends DescMethod ? ClientMethod<Service['method'][MethodName]> : never;
};

/**
 * Options for the protobuf client.
 */
interface ClientOptions {
    readonly connectOnInvoke: boolean;
    readonly eagerlyConnect: boolean;
}
/**
 * Creates a protobuf client for a single protobuf service descriptor.
 */
declare function createClient<Service extends DescService, RejectionCodeSchema extends CustomHandshakeErrorCodeSchema = never>(service: Service, transport: ClientTransport<Connection, RejectionCodeSchema>, serverId: TransportClientId, providedClientOptions?: Partial<ClientOptions & {
    handshakeOptions: ClientHandshakeOptions<TSchema, RejectionCodeSchema>;
}>): Client<Service>;

declare const HandshakeBytesSchema: TUint8Array;
type ProtobufHandshakeFailureCode = Static<typeof HandshakeErrorCustomHandlerFatalResponseCodes>;
type ConstructHandshake<Schema extends DescMessage> = () => MessageInitShape<Schema> | Promise<MessageInitShape<Schema>>;
type ValidateHandshake<Schema extends DescMessage, ParsedMetadata, RejectionCodeSchema extends CustomHandshakeErrorCodeSchema> = (metadata: MessageShape<Schema>, previousParsedMetadata?: ParsedMetadata, from?: TransportClientId, connectionExtras?: ConnectionExtras) => ParsedMetadata | ProtobufHandshakeFailureCode | CustomHandshakeErrorCode<RejectionCodeSchema> | Promise<ParsedMetadata | ProtobufHandshakeFailureCode | CustomHandshakeErrorCode<RejectionCodeSchema>>;
/**
 * Create client-side handshake options backed by a protobuf message type.
 */
declare function createClientHandshakeOptions<Schema extends DescMessage, RejectionCodeSchema extends CustomHandshakeErrorCodeSchema = never>(schema: Schema, construct: ConstructHandshake<Schema>, eager?: boolean, rejectionCodeSchema?: RejectionCodeSchema): ClientHandshakeOptions<typeof HandshakeBytesSchema, RejectionCodeSchema>;
/**
 * Create server-side handshake options backed by a protobuf message type.
 */
declare function createServerHandshakeOptions<Schema extends DescMessage, ParsedMetadata extends object = object, RejectionCodeSchema extends CustomHandshakeErrorCodeSchema = never>(schema: Schema, validate: ValidateHandshake<Schema, ParsedMetadata, NoInfer<RejectionCodeSchema>>, expiry?: (parsedMetadata: ParsedMetadata) => Date | undefined, rejectionCodeSchema?: RejectionCodeSchema): ServerHandshakeOptions<typeof HandshakeBytesSchema, ParsedMetadata, RejectionCodeSchema>;

/**
 * An object that may implement async or sync disposal.
 */
type MaybeDisposable<T extends object = Record<string, unknown>> = T & {
    [Symbol.asyncDispose]?: () => PromiseLike<void>;
    [Symbol.dispose]?: () => void;
};
/**
 * Stored registration for a single protobuf method handler.
 */
interface RegisteredMethod {
    readonly service: DescService;
    readonly method: DescMethod;
    readonly impl: MethodImpl<DescMethod, any, any, any>;
    readonly raw?: 'both' | 'output';
}
/**
 * An instantiated protobuf service with initialized state and a disposal hook.
 */
interface InstantiatedProtoService {
    readonly descriptor: DescService;
    readonly state: MaybeDisposable<object>;
    readonly methods: ReadonlyMap<string, RegisteredMethod>;
    [Symbol.asyncDispose]: () => PromiseLike<void>;
}
/**
 * Type-erased interface used by the server to interact with a
 * service definition without knowing its full generic signature.
 */
interface AnyProtoService {
    readonly descriptor: DescService;
    readonly methods: ReadonlyMap<string, RegisteredMethod>;
    instantiate(ctx: object): InstantiatedProtoService;
}
interface ServiceConfiguration<Context extends object, State extends object> {
    initializeState: (ctx: Context) => MaybeDisposable<State>;
}
/**
 * A scaffold for defining a protobuf service's handlers across multiple files.
 *
 * @see {@link ProtoServiceSchema.scaffold}
 */
declare class ProtoServiceScaffold<Service extends DescService, Context extends object, State extends object, ParsedMetadata extends object> {
    private readonly descriptor;
    private readonly config;
    constructor(descriptor: Service, config: ServiceConfiguration<Context, State>);
    /**
     * Type-check a partial set of handler implementations against this
     * service's types. Returns the input unchanged -- this is purely a
     * type-level helper for splitting handlers across files.
     *
     * @param handlers - A partial set of method implementations.
     */
    procedures(handlers: ServiceImpl<Service, Context, State, ParsedMetadata>): ServiceImpl<Service, Context, State, ParsedMetadata>;
    /**
     * Finalize the scaffold into a service definition. Provide all handlers
     * here (or spread in handler objects from {@link procedures}).
     *
     * @param handlers - Method implementations (missing methods return
     *   UNIMPLEMENTED at runtime).
     */
    finalize(handlers: ServiceImpl<Service, Context, State, ParsedMetadata>): {
        readonly descriptor: Service;
        readonly methods: ReadonlyMap<string, RegisteredMethod>;
        /** @internal */
        readonly initializeStateFn: ((ctx: Context) => MaybeDisposable<State>) | undefined;
        /**
         * Create a live service instance with initialized state.
         *
         * @param ctx - The user-provided context, passed to `initializeState`.
         */
        instantiate(ctx: Context): InstantiatedProtoService;
    };
}
/**
 * Creates a factory for defining protobuf services with typed context and
 * metadata.
 *
 * This mirrors {@link createServiceSchema} from the TypeBox router. The
 * factory binds the `Context` and `ParsedMetadata` types, then provides
 * `.define()` and `.scaffold()` methods for creating service definitions.
 *
 * @example
 * ```ts
 * const ProtoService = createProtoService<AppContext, ParsedMetadata>();
 *
 * // all-in-one (stateless)
 * const testSvc = ProtoService.define(TestService, {
 *   echo: (req, ctx) => Ok({ text: req.text }),
 * });
 *
 * // all-in-one (with state)
 * const testSvc = ProtoService.define(
 *   TestService,
 *   { initializeState: (ctx) => ({ counter: 0 }) },
 *   {
 *     echo: (req, ctx) => {
 *       ctx.state.counter++;
 *       return Ok({ text: req.text });
 *     },
 *   },
 * );
 *
 * // scaffold for file-splitting
 * const scaffold = ProtoService.scaffold(TestService, {
 *   initializeState: (ctx) => ({ counter: 0 }),
 * });
 * const echoHandlers = scaffold.procedures({
 *   echo: (req, ctx) => Ok({ text: req.text }),
 * });
 * const testSvc = scaffold.finalize({
 *   ...echoHandlers,
 * });
 *
 * const server = createServer(transport, [testSvc], {
 *   context: myAppContext,
 * });
 * ```
 */
declare function createProtoService<Context extends object = object, ParsedMetadata extends object = object>(): {
    new <Service extends DescService, State extends object>(descriptor: Service, initializeStateFn: ((ctx: Context) => MaybeDisposable<State>) | undefined, methods: Map<string, RegisteredMethod>): {
        readonly descriptor: Service;
        readonly methods: ReadonlyMap<string, RegisteredMethod>;
        /** @internal */
        readonly initializeStateFn: ((ctx: Context) => MaybeDisposable<State>) | undefined;
        /**
         * Create a live service instance with initialized state.
         *
         * @param ctx - The user-provided context, passed to `initializeState`.
         */
        instantiate(ctx: Context): InstantiatedProtoService;
    };
    define<S extends DescService>(descriptor: S, handlers: ServiceImplWithRawHandlers<S, Context, object, ParsedMetadata>): {
        readonly descriptor: S;
        readonly methods: ReadonlyMap<string, RegisteredMethod>;
        /** @internal */
        readonly initializeStateFn: ((ctx: Context) => MaybeDisposable<object>) | undefined;
        /**
         * Create a live service instance with initialized state.
         *
         * @param ctx - The user-provided context, passed to `initializeState`.
         */
        instantiate(ctx: Context): InstantiatedProtoService;
    };
    define<S_1 extends DescService, St extends object>(descriptor: S_1, config: ServiceConfiguration<Context, St>, handlers: ServiceImplWithRawHandlers<S_1, Context, St, ParsedMetadata>): {
        readonly descriptor: S_1;
        readonly methods: ReadonlyMap<string, RegisteredMethod>;
        /** @internal */
        readonly initializeStateFn: ((ctx: Context) => MaybeDisposable<St>) | undefined;
        /**
         * Create a live service instance with initialized state.
         *
         * @param ctx - The user-provided context, passed to `initializeState`.
         */
        instantiate(ctx: Context): InstantiatedProtoService;
    };
    define<S_2 extends DescService>(descriptor: S_2, handlers: ServiceImpl<S_2, Context, object, ParsedMetadata>): {
        readonly descriptor: S_2;
        readonly methods: ReadonlyMap<string, RegisteredMethod>;
        /** @internal */
        readonly initializeStateFn: ((ctx: Context) => MaybeDisposable<object>) | undefined;
        /**
         * Create a live service instance with initialized state.
         *
         * @param ctx - The user-provided context, passed to `initializeState`.
         */
        instantiate(ctx: Context): InstantiatedProtoService;
    };
    define<S_3 extends DescService, St_1 extends object>(descriptor: S_3, config: ServiceConfiguration<Context, St_1>, handlers: ServiceImpl<S_3, Context, St_1, ParsedMetadata>): {
        readonly descriptor: S_3;
        readonly methods: ReadonlyMap<string, RegisteredMethod>;
        /** @internal */
        readonly initializeStateFn: ((ctx: Context) => MaybeDisposable<St_1>) | undefined;
        /**
         * Create a live service instance with initialized state.
         *
         * @param ctx - The user-provided context, passed to `initializeState`.
         */
        instantiate(ctx: Context): InstantiatedProtoService;
    };
    /**
     * Create a scaffold for splitting handler implementations across files.
     *
     * @param descriptor - The generated protobuf service descriptor.
     * @param config - Service configuration including `initializeState`.
     */
    scaffold<S_4 extends DescService, St_2 extends object>(descriptor: S_4, config: ServiceConfiguration<Context, St_2>): ProtoServiceScaffold<S_4, Context, St_2, ParsedMetadata>;
};

type StreamId = string;
interface ProcStream {
    readonly streamId: StreamId;
    readonly from: TransportClientId;
    readonly service: DescService;
    readonly method: DescMethod;
    readonly handleMsg: (msg: OpaqueTransportMessage) => void;
    readonly handleSessionDisconnect: () => void;
}
/**
 * Server instance for the protobuf router.
 */
interface Server {
    readonly streams: Map<StreamId, ProcStream>;
    close(): Promise<void>;
}
/**
 * Context passed to protobuf middleware.
 */
type MiddlewareContext<ParsedMetadata extends object = object> = Readonly<Omit<ProtobufHandlerContext<object, object, ParsedMetadata>, 'cancel'>> & {
    readonly streamId: StreamId;
    readonly procedureName: string;
    readonly serviceName: string;
};
/**
 * Parameters passed to protobuf middleware.
 */
interface MiddlewareParam<ParsedMetadata extends object = object> {
    readonly ctx: MiddlewareContext<ParsedMetadata>;
    readonly reqInit: MessageShape<DescMethod['input']> | null;
    next: () => void;
}
/**
 * Middleware is a function that can inspect protobuf requests as they are
 * received.
 */
type Middleware<ParsedMetadata extends object = object> = (param: MiddlewareParam<ParsedMetadata>) => void;
/**
 * Options for creating a protobuf server.
 */
interface ServerOptions<MetadataSchema extends TSchema, ParsedMetadata extends object, RejectionCodeSchema extends CustomHandshakeErrorCodeSchema = never> {
    readonly extendedContext?: object;
    readonly handshakeOptions?: ServerHandshakeOptions<MetadataSchema, ParsedMetadata, RejectionCodeSchema>;
    readonly middlewares?: Array<Middleware<ParsedMetadata>>;
    readonly maxCancelledStreamTombstonesPerSession?: number;
}
/**
 * Creates a protobuf server that listens on an existing River transport.
 *
 * @param transport - The server transport to listen on.
 * @param services - Array of {@link ProtoService} definitions.
 * @param options - Server options including context, handshake, and middleware.
 */
declare function createServer<MetadataSchema extends TSchema, ParsedMetadata extends object, RejectionCodeSchema extends CustomHandshakeErrorCodeSchema = never>(transport: ServerTransport<Connection, MetadataSchema, ParsedMetadata, RejectionCodeSchema>, services: ReadonlyArray<AnyProtoService>, options?: ServerOptions<MetadataSchema, ParsedMetadata, RejectionCodeSchema>): Server;

export { type AnyProtoService, type BiDiStreamingCall, CANCEL_CODE, type CallOptions, type Client, type ClientError, type ClientErrorCode, type ClientMethod, type ClientStreamingCall, ErrResult, INVALID_REQUEST_CODE, type InstantiatedProtoService, type MaybeDisposable, type MethodImpl, type Middleware, type MiddlewareContext, type MiddlewareParam, type ClientOptions as ProtobufClientOptions, type ProtobufHandlerContext, type ServerOptions as ProtobufServerOptions, type ProtocolError, type ProtocolErrorCode, type RawHandler, Readable, Result, RiverErrorCode, type RiverErrorDetail, type Server, type ServiceImpl, type ServiceImplWithRawHandlers, UNCAUGHT_ERROR_CODE, UNEXPECTED_DISCONNECT_CODE, Writable, createClient, createClientHandshakeOptions, createProtoService, createServer, createServerHandshakeOptions, isClientError, isProtocolError, isRiverError, isSerializedClientErrorResult, isSerializedProtocolErrorResult };