@spikard/node 0.12.0 → 0.13.0

package/README.md

@@ -1,18 +1,37 @@
-# Spikard for Node.js
+<!-- GENERATED FILE — DO NOT EDIT DIRECTLY. Run: task readme:generate -->
 
-[![Documentation](https://img.shields.io/badge/docs-spikard.dev-blue)](https://spikard.dev)
-[![Crates.io](https://img.shields.io/crates/v/spikard.svg?color=blue)](https://crates.io/crates/spikard)
-[![PyPI](https://img.shields.io/pypi/v/spikard.svg?color=blue)](https://pypi.org/project/spikard/)
-[![npm](https://img.shields.io/npm/v/@spikard/node.svg?color=blue)](https://www.npmjs.com/package/@spikard/node)
-[![Gem](https://img.shields.io/gem/v/spikard.svg?color=blue)](https://rubygems.org/gems/spikard)
-[![Packagist](https://img.shields.io/packagist/v/spikard/spikard.svg?color=blue)](https://packagist.org/packages/spikard/spikard)
-[![Hex.pm](https://img.shields.io/hexpm/v/spikard.svg?color=blue)](https://hex.pm/packages/spikard)
-[![License](https://img.shields.io/badge/license-MIT-blue.svg)](../../LICENSE)
+# Spikard for Node.js
 
-High-performance HTTP framework for Node.js powered by a Rust core. Provides type-safe routing, validation, middleware, and testing via **napi-rs** bindings with zero-copy JSON conversion.
+<div align="center" style="display: flex; flex-wrap: wrap; gap: 8px; justify-content: center; margin: 20px 0;">
+  <a href="https://spikard.dev">
+    <img src="https://img.shields.io/badge/docs-spikard.dev-007ec6" alt="Documentation">
+  </a>
+  <a href="https://crates.io/crates/spikard">
+    <img src="https://img.shields.io/crates/v/spikard.svg?color=007ec6" alt="Crates.io">
+  </a>
+  <a href="https://pypi.org/project/spikard/">
+    <img src="https://img.shields.io/pypi/v/spikard.svg?color=007ec6" alt="PyPI">
+  </a>
+  <a href="https://www.npmjs.com/package/@spikard/node">
+    <img src="https://img.shields.io/npm/v/@spikard/node.svg?color=007ec6" alt="npm">
+  </a>
+  <a href="https://rubygems.org/gems/spikard">
+    <img src="https://img.shields.io/gem/v/spikard.svg?color=007ec6" alt="RubyGems">
+  </a>
+  <a href="https://packagist.org/packages/spikard/spikard">
+    <img src="https://img.shields.io/packagist/v/spikard/spikard.svg?color=007ec6" alt="Packagist">
+  </a>
+  <a href="https://hex.pm/packages/spikard">
+    <img src="https://img.shields.io/hexpm/v/spikard.svg?color=007ec6" alt="Hex.pm">
+  </a>
+  <a href="https://github.com/Goldziher/spikard/blob/main/LICENSE">
+    <img src="https://img.shields.io/badge/license-MIT-007ec6" alt="License">
+  </a>
+</div>
+
+High-performance HTTP framework for Node.js powered by a Rust core. Provides type-safe routing, validation, middleware, and testing via napi-rs bindings with zero-copy JSON conversion.
 
 ## Features
-
 - **Rust-Powered Performance**: Native speed via Tokio with dedicated thread pool
 - **Full TypeScript Support**: Auto-generated types from napi-rs FFI bindings
 - **Zero-Copy JSON**: Direct conversion without serialization overhead
@@ -77,7 +96,6 @@ app.addRoute(
 
 app.run({ port: 8000 });
 ```
-
 ## Routing & Schemas
 
 Routes support Zod validation (recommended) or raw JSON Schema:
@@ -215,6 +233,28 @@ app.onResponse(async (response) => {
 });
 ```
 
+## Performance
+
+Benchmarked across 34 workloads at 100 concurrency ([methodology](../../docs/benchmarks/methodology.md)):
+
+| Framework | Avg RPS | P50 (ms) | P99 (ms) |
+|-----------|--------:|----------:|----------:|
+| **spikard (Bun)** | 49,460 | 2.18 | 4.21 |
+| **spikard (Node)** | 46,160 | 2.18 | 3.35 |
+| elysia | 44,326 | 2.41 | 4.68 |
+| kito | 36,958 | 4.94 | 12.86 |
+| fastify | 19,167 | 6.74 | 14.76 |
+| morojs | 14,196 | 6.44 | 12.61 |
+| hono | 10,928 | 10.91 | 18.62 |
+
+Spikard is **1.2x faster than Kito and 2.4x faster than Fastify**.
+
+Key optimizations:
+- **napi-rs** zero-copy FFI bindings
+- **Dedicated Tokio runtime** without blocking Node event loop
+- **Zero-copy JSON** conversion (30-40% faster than JSON.parse)
+- **ThreadsafeFunction** for async JavaScript callbacks
+
 ## Testing
 
 Use TestClient for HTTP, WebSocket, and SSE testing:
@@ -237,48 +277,22 @@ await ws.sendJson({ message: "hello" });
 const sse = await client.get("/events");
 ```
 
-## Performance
-
-Benchmarked across 34 workloads at 100 concurrency ([methodology](../../docs/benchmarks/methodology.md)):
-
-| Framework | Avg RPS | P50 (ms) | P99 (ms) |
-|-----------|--------:|----------:|----------:|
-| **spikard (Bun)** | 49,460 | 2.18 | 4.21 |
-| **spikard (Node)** | 46,160 | 2.18 | 3.35 |
-| elysia | 44,326 | 2.41 | 4.68 |
-| kito | 36,958 | 4.94 | 12.86 |
-| fastify | 19,167 | 6.74 | 14.76 |
-| morojs | 14,196 | 6.44 | 12.61 |
-| hono | 10,928 | 10.91 | 18.62 |
-
-Spikard Node is **1.2x faster** than Kito and **2.4x faster** than Fastify.
-
-Key optimizations:
-- **napi-rs** zero-copy FFI bindings
-- **Dedicated Tokio runtime** without blocking Node event loop
-- **Zero-copy JSON** conversion (30-40% faster than JSON.parse)
-- **ThreadsafeFunction** for async JavaScript callbacks
-
 ## Examples
 
-See [examples/](../../examples/) for runnable projects. Code generation is supported for OpenAPI, GraphQL, AsyncAPI, and JSON-RPC specifications.
+See [examples/](../../examples/) for runnable projects. Code generation is supported for OpenAPI, GraphQL, AsyncAPI, OpenRPC/JSON-RPC, and Protobuf/gRPC specifications.
 
 ## Documentation
 
 Full documentation at [spikard.dev](https://spikard.dev). See also [CONTRIBUTING.md](../../CONTRIBUTING.md).
 
-## Ecosystem
-
-Spikard is available across multiple languages:
+## Other Languages
 
-| Platform | Package | Status |
-|----------|---------|--------|
-| **Node.js** | [@spikard/node](https://www.npmjs.com/package/@spikard/node) | Stable |
-| **Python** | [spikard](https://pypi.org/project/spikard/) | Stable |
-| **Rust** | [spikard](https://crates.io/crates/spikard) | Stable |
-| **Ruby** | [spikard](https://rubygems.org/gems/spikard) | Stable |
-| **PHP** | [spikard/spikard](https://packagist.org/packages/spikard/spikard) | Stable |
-| **Elixir** | [spikard](https://hex.pm/packages/spikard) | Stable |
+- **Rust:** [Crates.io](https://crates.io/crates/spikard)
+- **Python:** [PyPI](https://pypi.org/project/spikard/)
+- **TypeScript:** [npm (@spikard/node)](https://www.npmjs.com/package/@spikard/node)
+- **Ruby:** [RubyGems](https://rubygems.org/gems/spikard)
+- **PHP:** [Packagist](https://packagist.org/packages/spikard/spikard)
+- **Elixir:** [Hex.pm](https://hex.pm/packages/spikard)
 
 ## License
 

package/dist/index.d.mts

@@ -1,67 +1,3 @@
-interface StreamingResponseInit {
-    statusCode?: number;
-    headers?: Record<string, string>;
-}
-declare const STREAM_HANDLE_PROP: "__spikard_stream_handle";
-type StreamChunk = JsonValue | string | Buffer | Uint8Array | ArrayBuffer | ArrayBufferView | null | undefined;
-type ChunkIterator = AsyncIterator<StreamChunk> & AsyncIterable<StreamChunk>;
-type StreamingHandle = {
-    kind: "native";
-    handle: number;
-    init: StreamingResponseInit;
-} | {
-    kind: "js";
-    iterator: ChunkIterator;
-    init: StreamingResponseInit;
-};
-declare class StreamingResponse {
-    readonly [STREAM_HANDLE_PROP]: StreamingHandle;
-    constructor(stream: AsyncIterable<StreamChunk> | AsyncIterator<StreamChunk>, init?: StreamingResponseInit);
-}
-
-type JsonPrimitive = string | number | boolean | null;
-type JsonValue = JsonPrimitive | JsonValue[] | {
-    [Key in string]: JsonValue;
-};
-type JsonRecord = Record<string, JsonValue>;
-type MaybePromise<T> = T | Promise<T>;
-interface Base64EncodedBody {
-    __spikard_base64__: string;
-}
-type HandlerBody = JsonValue | Base64EncodedBody | null;
-interface StructuredHandlerResponse {
-    status?: number;
-    statusCode?: number;
-    headers?: Record<string, string>;
-    body?: HandlerBody;
-}
-type HandlerResult = StructuredHandlerResponse | JsonValue | StreamingResponse | undefined;
-type HandlerFunction<TReturn extends HandlerResult = HandlerResult> = (request: Request) => MaybePromise<TReturn>;
-type NativeHandlerFunction<TReturn extends HandlerResult = HandlerResult> = (requestJson: string) => MaybePromise<TReturn | string>;
-type WebSocketHandler = (message: unknown) => MaybePromise<unknown>;
-interface WebSocketOptions {
-    onConnect?: () => MaybePromise<void>;
-    onDisconnect?: () => MaybePromise<void>;
-    messageSchema?: unknown;
-    responseSchema?: unknown;
-    handlerName?: string;
-}
-
-interface Request {
-    method: string;
-    path: string;
-    params: Record<string, string>;
-    pathParams: Record<string, string>;
-    query: Record<string, string>;
-    queryParams: Record<string, string>;
-    headers: Record<string, string>;
-    cookies: Record<string, string>;
-    body: Buffer | null;
-    dependencies: Record<string, unknown> | undefined;
-    json<T = JsonValue>(): T;
-    form(): Record<string, string>;
-}
-
 interface CompressionConfig {
     gzip?: boolean;
     brotli?: boolean;
@@ -147,62 +83,6 @@ interface ServerConfig {
     jsonrpc?: JsonRpcConfig | null;
 }
 
-interface ServerOptions {
-    host?: string;
-    port?: number;
-}
-declare function runServer(app: SpikardApp, config?: ServerConfig | ServerOptions): void;
-
-type DependencyValue = unknown;
-type DependencyFactory = (dependencies: Record<string, DependencyValue>) => MaybePromise<DependencyValue>;
-interface DependencyOptions {
-    dependsOn?: string[];
-    singleton?: boolean;
-    cacheable?: boolean;
-}
-interface DependencyDescriptor {
-    isFactory: boolean;
-    value?: DependencyValue | undefined;
-    factory?: DependencyFactory | undefined;
-    dependsOn: string[];
-    singleton: boolean;
-    cacheable: boolean;
-}
-type LifecycleHookPayload = Request | StructuredHandlerResponse;
-type LifecycleHookFunction = (payload: LifecycleHookPayload) => MaybePromise<LifecycleHookPayload>;
-interface LifecycleHooks {
-    onRequest: LifecycleHookFunction[];
-    preValidation: LifecycleHookFunction[];
-    preHandler: LifecycleHookFunction[];
-    onResponse: LifecycleHookFunction[];
-    onError: LifecycleHookFunction[];
-}
-declare class Spikard implements SpikardApp {
-    routes: RouteMetadata[];
-    handlers: Record<string, HandlerFunction | NativeHandlerFunction>;
-    websocketRoutes: RouteMetadata[];
-    websocketHandlers: Record<string, Record<string, unknown>>;
-    lifecycleHooks: LifecycleHooks;
-    dependencies: Record<string, DependencyDescriptor>;
-    addRoute(metadata: RouteMetadata, handler: HandlerFunction | NativeHandlerFunction): void;
-    websocket(path: string, handler: WebSocketHandler, options?: WebSocketOptions): void;
-    run(options?: ServerOptions): void;
-    onRequest(hook: LifecycleHookFunction): LifecycleHookFunction;
-    preValidation(hook: LifecycleHookFunction): LifecycleHookFunction;
-    preHandler(hook: LifecycleHookFunction): LifecycleHookFunction;
-    onResponse(hook: LifecycleHookFunction): LifecycleHookFunction;
-    onError(hook: LifecycleHookFunction): LifecycleHookFunction;
-    provide(key: string, valueOrFactory: DependencyValue | DependencyFactory, options?: DependencyOptions): this;
-    getLifecycleHooks(): LifecycleHooks;
-}
-
-declare function run(work: () => void | Promise<void>): void;
-
-declare const background_run: typeof run;
-declare namespace background {
-  export { background_run as run };
-}
-
 type GrpcMetadata = Record<string, string>;
 interface GrpcRequest {
     serviceName: string;
@@ -214,9 +94,37 @@ interface GrpcResponse {
     payload: Buffer;
     metadata?: GrpcMetadata;
 }
+interface GrpcClientStreamRequest {
+    serviceName: string;
+    methodName: string;
+    metadata: GrpcMetadata;
+    messages: Buffer[];
+}
+interface GrpcServerStreamResponse {
+    messages: Buffer[];
+}
+interface GrpcBidiStreamRequest {
+    serviceName: string;
+    methodName: string;
+    metadata: GrpcMetadata;
+    messages: Buffer[];
+}
+interface GrpcBidiStreamResponse {
+    messages: Buffer[];
+    metadata?: GrpcMetadata;
+}
 interface GrpcHandler {
     handleRequest(request: GrpcRequest): Promise<GrpcResponse>;
 }
+interface GrpcServerStreamingHandler {
+    handleServerStream(request: GrpcRequest): Promise<GrpcServerStreamResponse>;
+}
+interface GrpcClientStreamingHandler {
+    handleClientStream(request: GrpcClientStreamRequest): Promise<GrpcResponse>;
+}
+interface GrpcBidirectionalStreamingHandler {
+    handleBidiStream(request: GrpcBidiStreamRequest): Promise<GrpcBidiStreamResponse>;
+}
 declare enum GrpcStatusCode {
     OK = 0,
     CANCELLED = 1,
@@ -240,9 +148,29 @@ declare class GrpcError extends Error {
     readonly code: GrpcStatusCode;
     constructor(code: GrpcStatusCode, message: string);
 }
-interface GrpcServiceConfig {
+type GrpcRpcMode = "unary" | "serverStreaming" | "clientStreaming" | "bidirectionalStreaming";
+type GrpcMethodHandler = GrpcHandler | GrpcServerStreamingHandler | GrpcClientStreamingHandler | GrpcBidirectionalStreamingHandler;
+interface GrpcMethodConfig {
     serviceName: string;
-    handler: GrpcHandler;
+    methodName: string;
+    rpcMode: GrpcRpcMode;
+    handler: GrpcMethodHandler;
+}
+declare class GrpcService {
+    private readonly methods;
+    private methodKey;
+    private registerMethod;
+    registerUnary(serviceName: string, methodName: string, handler: GrpcHandler): this;
+    registerServerStreaming(serviceName: string, methodName: string, handler: GrpcServerStreamingHandler): this;
+    registerClientStreaming(serviceName: string, methodName: string, handler: GrpcClientStreamingHandler): this;
+    registerBidirectionalStreaming(serviceName: string, methodName: string, handler: GrpcBidirectionalStreamingHandler): this;
+    unregister(serviceName: string, methodName: string): void;
+    getMethod(serviceName: string, methodName: string): GrpcMethodConfig | undefined;
+    serviceNames(): string[];
+    methodNames(serviceName: string): string[];
+    hasMethod(serviceName: string, methodName: string): boolean;
+    entries(): GrpcMethodConfig[];
+    handleRequest(request: GrpcRequest): Promise<GrpcResponse>;
 }
 type UnaryHandlerResult<TResponse> = TResponse | {
     response: TResponse;
@@ -257,6 +185,128 @@ declare function createUnaryHandler<TRequest, TResponse>(methodName: string, han
 }): GrpcHandler;
 declare function createServiceHandler(methods: Record<string, GrpcHandler>): GrpcHandler;
 
+interface StreamingResponseInit {
+    statusCode?: number;
+    headers?: Record<string, string>;
+}
+declare const STREAM_HANDLE_PROP: "__spikard_stream_handle";
+type StreamChunk = JsonValue | string | Buffer | Uint8Array | ArrayBuffer | ArrayBufferView | null | undefined;
+type ChunkIterator = AsyncIterator<StreamChunk> & AsyncIterable<StreamChunk>;
+type StreamingHandle = {
+    kind: "native";
+    handle: number;
+    init: StreamingResponseInit;
+} | {
+    kind: "js";
+    iterator: ChunkIterator;
+    init: StreamingResponseInit;
+};
+declare class StreamingResponse {
+    readonly [STREAM_HANDLE_PROP]: StreamingHandle;
+    constructor(stream: AsyncIterable<StreamChunk> | AsyncIterator<StreamChunk>, init?: StreamingResponseInit);
+}
+
+type JsonPrimitive = string | number | boolean | null;
+type JsonValue = JsonPrimitive | JsonValue[] | {
+    [Key in string]: JsonValue;
+};
+type JsonRecord = Record<string, JsonValue>;
+type MaybePromise<T> = T | Promise<T>;
+interface Base64EncodedBody {
+    __spikard_base64__: string;
+}
+type HandlerBody = JsonValue | Base64EncodedBody | null;
+interface StructuredHandlerResponse {
+    status?: number;
+    statusCode?: number;
+    headers?: Record<string, string>;
+    body?: HandlerBody;
+}
+type HandlerResult = StructuredHandlerResponse | JsonValue | StreamingResponse | undefined;
+type HandlerFunction<TReturn extends HandlerResult = HandlerResult> = (request: Request) => MaybePromise<TReturn>;
+type NativeHandlerFunction<TReturn extends HandlerResult = HandlerResult> = (requestJson: string) => MaybePromise<TReturn | string>;
+type WebSocketHandler = (message: unknown) => MaybePromise<unknown>;
+interface WebSocketOptions {
+    onConnect?: () => MaybePromise<void>;
+    onDisconnect?: () => MaybePromise<void>;
+    messageSchema?: unknown;
+    responseSchema?: unknown;
+    handlerName?: string;
+}
+
+interface Request {
+    method: string;
+    path: string;
+    params: Record<string, string>;
+    pathParams: Record<string, string>;
+    query: Record<string, string>;
+    queryParams: Record<string, string>;
+    headers: Record<string, string>;
+    cookies: Record<string, string>;
+    body: Buffer | null;
+    dependencies: Record<string, unknown> | undefined;
+    json<T = JsonValue>(): T;
+    form(): Record<string, string>;
+}
+
+type DependencyValue = unknown;
+type DependencyFactory = (dependencies: Record<string, DependencyValue>) => MaybePromise<DependencyValue>;
+interface DependencyOptions {
+    dependsOn?: string[];
+    singleton?: boolean;
+    cacheable?: boolean;
+}
+interface DependencyDescriptor {
+    isFactory: boolean;
+    value?: DependencyValue | undefined;
+    factory?: DependencyFactory | undefined;
+    dependsOn: string[];
+    singleton: boolean;
+    cacheable: boolean;
+}
+type LifecycleHookPayload = Request | StructuredHandlerResponse;
+type LifecycleHookFunction = (payload: LifecycleHookPayload) => MaybePromise<LifecycleHookPayload>;
+interface LifecycleHooks {
+    onRequest: LifecycleHookFunction[];
+    preValidation: LifecycleHookFunction[];
+    preHandler: LifecycleHookFunction[];
+    onResponse: LifecycleHookFunction[];
+    onError: LifecycleHookFunction[];
+}
+declare class Spikard implements SpikardApp {
+    routes: RouteMetadata[];
+    handlers: Record<string, HandlerFunction | NativeHandlerFunction>;
+    websocketRoutes: RouteMetadata[];
+    websocketHandlers: Record<string, Record<string, unknown>>;
+    grpcMethods: GrpcMethodRegistration[];
+    grpcHandlers: Record<string, Record<string, unknown>>;
+    lifecycleHooks: LifecycleHooks;
+    dependencies: Record<string, DependencyDescriptor>;
+    addRoute(metadata: RouteMetadata, handler: HandlerFunction | NativeHandlerFunction): void;
+    websocket(path: string, handler: WebSocketHandler, options?: WebSocketOptions): void;
+    addGrpcUnary(serviceName: string, methodName: string, handler: GrpcHandler): this;
+    addGrpcServerStreaming(serviceName: string, methodName: string, handler: GrpcServerStreamingHandler): this;
+    addGrpcClientStreaming(serviceName: string, methodName: string, handler: GrpcClientStreamingHandler): this;
+    addGrpcBidirectionalStreaming(serviceName: string, methodName: string, handler: GrpcBidirectionalStreamingHandler): this;
+    private registerGrpcMethod;
+    useGrpc(service: GrpcService): this;
+    run(config?: ServerConfig): void;
+    onRequest(hook: LifecycleHookFunction): LifecycleHookFunction;
+    preValidation(hook: LifecycleHookFunction): LifecycleHookFunction;
+    preHandler(hook: LifecycleHookFunction): LifecycleHookFunction;
+    onResponse(hook: LifecycleHookFunction): LifecycleHookFunction;
+    onError(hook: LifecycleHookFunction): LifecycleHookFunction;
+    provide(key: string, valueOrFactory: DependencyValue | DependencyFactory, options?: DependencyOptions): this;
+    getLifecycleHooks(): LifecycleHooks;
+}
+
+declare function run(work: () => void | Promise<void>): void;
+
+declare const background_run: typeof run;
+declare namespace background {
+  export { background_run as run };
+}
+
 declare function wrapHandler(handler: HandlerFunction): NativeHandlerFunction;
 declare function wrapBodyHandler<TBody = unknown>(handler: (body: TBody, request: Request) => MaybePromise<HandlerResult>): NativeHandlerFunction;
 
@@ -280,6 +330,8 @@ declare function put(path: string, options?: Omit<RouteOptions, "methods">): (ha
 declare function del(path: string, options?: Omit<RouteOptions, "methods">): (handler: RouteHandler) => RouteHandler;
 declare function patch(path: string, options?: Omit<RouteOptions, "methods">): (handler: RouteHandler) => RouteHandler;
 
+declare function runServer(app: SpikardApp, config?: ServerConfig): void;
+
 interface NativeTestResponse {
     statusCode: number;
     headers(): Record<string, string>;
@@ -402,14 +454,22 @@ interface RouteMetadata {
     is_async: boolean;
     cors?: CorsConfig | undefined;
 }
+interface GrpcMethodRegistration {
+    serviceName: string;
+    methodName: string;
+    rpcMode: GrpcRpcMode;
+    handlerName: string;
+}
 interface SpikardApp {
     routes: RouteMetadata[];
     handlers: Record<string, HandlerFunction | NativeHandlerFunction>;
     websocketRoutes?: RouteMetadata[];
     websocketHandlers?: Record<string, Record<string, unknown>>;
+    grpcMethods?: GrpcMethodRegistration[];
+    grpcHandlers?: Record<string, Record<string, unknown>>;
     config?: ServerConfig;
     lifecycleHooks?: Partial<LifecycleHooks>;
     dependencies?: Record<string, unknown>;
 }
 
-export { type ApiKeyConfig, type Base64EncodedBody, type Body, type CompressionConfig, type ContactInfo, type CorsConfig, type DependencyFactory, type DependencyOptions, type DependencyValue, type FileParam, GrpcError, type GrpcHandler, type GrpcMetadata, type GrpcRequest, type GrpcResponse, type GrpcServiceConfig, GrpcStatusCode, type HandlerFunction, type HandlerResult, type JsonPrimitive, type JsonRecord, type JsonRpcConfig, type JsonSchema, type JsonValue, type JwtConfig, type LicenseInfo, type LifecycleHookFunction, type LifecycleHooks, type MaybePromise, type NativeHandlerFunction, type OpenApiConfig, type Path, type Query, QueryDefault, type RateLimitConfig, type Request, type RouteMetadata, type RouteOptions, type SecuritySchemeInfo, type ServerConfig, type ServerInfo, type ServerOptions, Spikard, type SpikardApp, type StaticFilesConfig, StreamingResponse, type StreamingResponseInit, type StructuredHandlerResponse, TestClient, type TestResponse, UploadFile, type WebSocketHandler, type WebSocketOptions, background, createServiceHandler, createUnaryHandler, del, get, patch, post, put, route, runServer, wrapBodyHandler, wrapHandler };
+export { type ApiKeyConfig, type Base64EncodedBody, type Body, type CompressionConfig, type ContactInfo, type CorsConfig, type DependencyFactory, type DependencyOptions, type DependencyValue, type FileParam, type GrpcBidiStreamRequest, type GrpcBidiStreamResponse, type GrpcBidirectionalStreamingHandler, type GrpcClientStreamRequest, type GrpcClientStreamingHandler, GrpcError, type GrpcHandler, type GrpcMetadata, type GrpcMethodConfig, type GrpcMethodHandler, type GrpcMethodRegistration, type GrpcRequest, type GrpcResponse, type GrpcRpcMode, type GrpcServerStreamResponse, type GrpcServerStreamingHandler, GrpcService, GrpcStatusCode, type HandlerFunction, type HandlerResult, type JsonPrimitive, type JsonRecord, type JsonRpcConfig, type JsonSchema, type JsonValue, type JwtConfig, type LicenseInfo, type LifecycleHookFunction, type LifecycleHooks, type MaybePromise, type NativeHandlerFunction, type OpenApiConfig, type Path, type Query, QueryDefault, type RateLimitConfig, type Request, type RouteMetadata, type RouteOptions, type SecuritySchemeInfo, type ServerConfig, type ServerInfo, Spikard, type SpikardApp, type StaticFilesConfig, StreamingResponse, type StreamingResponseInit, type StructuredHandlerResponse, TestClient, type TestResponse, UploadFile, type WebSocketHandler, type WebSocketOptions, background, createServiceHandler, createUnaryHandler, del, get, patch, post, put, route, runServer, wrapBodyHandler, wrapHandler };