silgi 0.0.13 → 0.1.0-beta.1

package/dist/broker/index.mjs

@@ -0,0 +1,153 @@
+import { SilgiError, toSilgiError } from "../core/error.mjs";
+import { ValidationError } from "../core/schema.mjs";
+import { compileRouter } from "../compile.mjs";
+//#region src/broker/index.ts
+/**
+* Message Broker adapter — driver-based RPC over any message broker.
+*
+* Pluggable driver pattern (like unstorage) — bring your own broker client.
+* Built-in memory driver for testing. NATS and Redis drivers available separately.
+*
+* @example
+* ```ts
+* // Server
+* import { silgiBroker, memoryBroker } from "silgi/broker"
+*
+* const driver = memoryBroker()
+* const dispose = await silgiBroker(appRouter, driver, {
+*   subject: "myapp.rpc",
+*   context: () => ({ db: getDB() }),
+* })
+*
+* // Client
+* import { BrokerLink } from "silgi/broker"
+* import { createClient } from "silgi/client"
+*
+* const client = createClient<AppRouter>(new BrokerLink(driver, { subject: "myapp.rpc" }))
+* const users = await client.users.list({ limit: 10 })
+* ```
+*/
+/**
+* Attach Silgi to a message broker (server side).
+*
+* Listens for RPC messages on the given subject, dispatches to the compiled
+* router, and replies with results or errors.
+*
+* Returns a cleanup function to stop listening.
+*/
+async function silgiBroker(router, driver, options = {}) {
+	const compiledRouter = compileRouter(router);
+	const subject = options.subject ?? "silgi";
+	const unsubscribe = await driver.subscribe(subject, (payload, reply) => {
+		let msg;
+		try {
+			msg = JSON.parse(payload);
+		} catch {
+			reply(JSON.stringify({ e: {
+				code: "BAD_REQUEST",
+				status: 400,
+				message: "Invalid payload"
+			} }));
+			return;
+		}
+		const match = compiledRouter("POST", "/" + msg.p);
+		if (!match) {
+			reply(JSON.stringify({ e: {
+				code: "NOT_FOUND",
+				status: 404,
+				message: "Procedure not found"
+			} }));
+			return;
+		}
+		const route = match.data;
+		(async () => {
+			try {
+				const ctx = Object.create(null);
+				if (match.params) ctx.params = match.params;
+				if (options.context) {
+					const baseCtx = await options.context();
+					const keys = Object.keys(baseCtx);
+					for (let i = 0; i < keys.length; i++) ctx[keys[i]] = baseCtx[keys[i]];
+				}
+				const signal = new AbortController().signal;
+				const res = { r: await route.handler(ctx, msg.i, signal) };
+				reply(JSON.stringify(res));
+			} catch (error) {
+				const res = { e: error instanceof ValidationError ? {
+					code: "BAD_REQUEST",
+					status: 400,
+					message: error.message,
+					data: { issues: error.issues }
+				} : error instanceof SilgiError ? error.toJSON() : toSilgiError(error).toJSON() };
+				reply(JSON.stringify(res));
+			}
+		})();
+	});
+	return typeof unsubscribe === "function" ? unsubscribe : () => {};
+}
+/**
+* Client-side broker link — sends RPC calls via a broker driver.
+*/
+var BrokerLink = class {
+	#driver;
+	#subject;
+	#timeout;
+	constructor(driver, options = {}) {
+		this.#driver = driver;
+		this.#subject = options.subject ?? "silgi";
+		this.#timeout = options.timeout ?? 1e4;
+	}
+	async call(path, input, _options) {
+		const req = {
+			p: path.join("/"),
+			i: input
+		};
+		const raw = await this.#driver.request(this.#subject, JSON.stringify(req), { timeout: this.#timeout });
+		const res = JSON.parse(raw);
+		if (res.e) throw new SilgiError(res.e.code, {
+			status: res.e.status,
+			message: res.e.message,
+			data: res.e.data
+		});
+		return res.r;
+	}
+};
+/**
+* In-memory broker driver — for testing and single-process development.
+* Simulates request-reply without any external broker.
+*/
+function memoryBroker() {
+	const subscribers = /* @__PURE__ */ new Map();
+	return {
+		subscribe(subject, handler) {
+			let set = subscribers.get(subject);
+			if (!set) {
+				set = /* @__PURE__ */ new Set();
+				subscribers.set(subject, set);
+			}
+			set.add(handler);
+			return () => {
+				set.delete(handler);
+				if (set.size === 0) subscribers.delete(subject);
+			};
+		},
+		request(subject, payload, opts) {
+			return new Promise((resolve, reject) => {
+				const handlers = subscribers.get(subject);
+				if (!handlers || handlers.size === 0) {
+					reject(/* @__PURE__ */ new Error(`No subscriber for subject "${subject}"`));
+					return;
+				}
+				const timeout = opts?.timeout ?? 1e4;
+				const timer = setTimeout(() => reject(/* @__PURE__ */ new Error(`Broker request timeout: ${subject}`)), timeout);
+				const handler = handlers.values().next().value;
+				handler(payload, (response) => {
+					clearTimeout(timer);
+					resolve(response);
+				});
+			});
+		}
+	};
+}
+//#endregion
+export { BrokerLink, memoryBroker, silgiBroker };

package/dist/broker/nats.d.mts

@@ -0,0 +1,33 @@
+import { BrokerDriver } from "./index.mjs";
+
+//#region src/broker/nats.d.ts
+interface NatsMsg {
+  data: Uint8Array;
+  respond(payload: Uint8Array): boolean;
+}
+interface NatsSub {
+  unsubscribe(): void;
+}
+interface NatsConnection {
+  subscribe(subject: string, opts?: {
+    callback?: (err: Error | null, msg: NatsMsg) => void;
+    queue?: string;
+  }): NatsSub;
+  request(subject: string, payload?: Uint8Array, opts?: {
+    timeout?: number;
+  }): Promise<NatsMsg>;
+}
+interface NatsBrokerOptions {
+  /** Queue group name for load-balanced consumption across instances */
+  queue?: string;
+}
+/**
+ * Create a NATS broker driver from a NatsConnection.
+ *
+ * Uses NATS native request-reply for zero-overhead correlation.
+ * Supports queue groups for horizontal scaling — only one instance
+ * in the group handles each request.
+ */
+declare function natsBroker(nc: NatsConnection, options?: NatsBrokerOptions): BrokerDriver;
+//#endregion
+export { NatsBrokerOptions, NatsConnection, NatsMsg, NatsSub, natsBroker };

package/dist/broker/nats.mjs

@@ -0,0 +1,31 @@
+//#region src/broker/nats.ts
+const encoder = /* @__PURE__ */ new TextEncoder();
+const decoder = /* @__PURE__ */ new TextDecoder();
+/**
+* Create a NATS broker driver from a NatsConnection.
+*
+* Uses NATS native request-reply for zero-overhead correlation.
+* Supports queue groups for horizontal scaling — only one instance
+* in the group handles each request.
+*/
+function natsBroker(nc, options = {}) {
+	return {
+		subscribe(subject, handler) {
+			const sub = nc.subscribe(subject, {
+				queue: options.queue,
+				callback: (_err, msg) => {
+					handler(decoder.decode(msg.data), (response) => {
+						msg.respond(encoder.encode(response));
+					});
+				}
+			});
+			return () => sub.unsubscribe();
+		},
+		async request(subject, payload, opts) {
+			const msg = await nc.request(subject, encoder.encode(payload), { timeout: opts?.timeout ?? 1e4 });
+			return decoder.decode(msg.data);
+		}
+	};
+}
+//#endregion
+export { natsBroker };

package/dist/broker/redis.d.mts

@@ -0,0 +1,51 @@
+import { BrokerDriver } from "./index.mjs";
+
+//#region src/broker/redis.d.ts
+/**
+ * Minimal pub/sub transport — implement this for your Redis client.
+ *
+ * `subscribe` returns a cleanup function to unsubscribe.
+ * Both sync and async returns are supported.
+ */
+interface RedisTransport {
+  publish(channel: string, message: string): unknown;
+  subscribe(channel: string, handler: (message: string) => void): (() => void) | Promise<() => void>;
+}
+/**
+ * Minimal ioredis-compatible interface.
+ * Works with `ioredis` and any client that matches this shape.
+ */
+interface IORedisLike {
+  publish(channel: string, message: string): Promise<number>;
+  subscribe(...channels: string[]): Promise<unknown>;
+  unsubscribe(...channels: string[]): Promise<unknown>;
+  on(event: 'message', listener: (channel: string, message: string) => void): void;
+}
+/**
+ * Create a RedisTransport from two ioredis connections.
+ *
+ * Redis requires separate connections for publishing and subscribing
+ * because `SUBSCRIBE` puts the connection into subscriber mode.
+ *
+ * @param pub - Publisher connection (regular Redis client)
+ * @param sub - Subscriber connection (dedicated for SUBSCRIBE)
+ */
+declare function ioredisTransport(pub: IORedisLike, sub: IORedisLike): RedisTransport;
+interface RedisBrokerOptions {
+  /** Unique prefix for inbox channels. Auto-generated if not provided. */
+  inbox?: string;
+}
+/**
+ * Create a Redis broker driver from a RedisTransport.
+ *
+ * Simulates request-reply using temporary inbox channels:
+ * 1. Client subscribes to a unique inbox channel
+ * 2. Client publishes request with inbox address embedded
+ * 3. Server processes request, publishes response to inbox
+ * 4. Client receives response, unsubscribes from inbox
+ *
+ * Wire format: `"inbox-channel\npayload"` (newline separator, no double-serialization)
+ */
+declare function redisBroker(transport: RedisTransport, options?: RedisBrokerOptions): BrokerDriver;
+//#endregion
+export { IORedisLike, RedisBrokerOptions, RedisTransport, ioredisTransport, redisBroker };

package/dist/broker/redis.mjs

@@ -0,0 +1,92 @@
+//#region src/broker/redis.ts
+/**
+* Create a RedisTransport from two ioredis connections.
+*
+* Redis requires separate connections for publishing and subscribing
+* because `SUBSCRIBE` puts the connection into subscriber mode.
+*
+* @param pub - Publisher connection (regular Redis client)
+* @param sub - Subscriber connection (dedicated for SUBSCRIBE)
+*/
+function ioredisTransport(pub, sub) {
+	const handlers = /* @__PURE__ */ new Map();
+	sub.on("message", (channel, message) => {
+		const set = handlers.get(channel);
+		if (set) for (const handler of set) handler(message);
+	});
+	return {
+		publish(channel, message) {
+			return pub.publish(channel, message);
+		},
+		async subscribe(channel, handler) {
+			let set = handlers.get(channel);
+			if (!set) {
+				set = /* @__PURE__ */ new Set();
+				handlers.set(channel, set);
+				await sub.subscribe(channel);
+			}
+			set.add(handler);
+			return () => {
+				set.delete(handler);
+				if (set.size === 0) {
+					handlers.delete(channel);
+					sub.unsubscribe(channel);
+				}
+			};
+		}
+	};
+}
+let globalSeq = 0;
+/**
+* Create a Redis broker driver from a RedisTransport.
+*
+* Simulates request-reply using temporary inbox channels:
+* 1. Client subscribes to a unique inbox channel
+* 2. Client publishes request with inbox address embedded
+* 3. Server processes request, publishes response to inbox
+* 4. Client receives response, unsubscribes from inbox
+*
+* Wire format: `"inbox-channel\npayload"` (newline separator, no double-serialization)
+*/
+function redisBroker(transport, options = {}) {
+	const inboxPrefix = options.inbox ?? `silgi:inbox:${Date.now().toString(36)}:${(++globalSeq).toString(36)}`;
+	let requestSeq = 0;
+	return {
+		async subscribe(subject, handler) {
+			return transport.subscribe(subject, (message) => {
+				const sep = message.indexOf("\n");
+				if (sep === -1) return;
+				const replyTo = message.slice(0, sep);
+				handler(message.slice(sep + 1), (response) => {
+					transport.publish(replyTo, response);
+				});
+			});
+		},
+		async request(subject, payload, opts) {
+			const inbox = `${inboxPrefix}:${++requestSeq}`;
+			const timeout = opts?.timeout ?? 1e4;
+			const { promise, resolve, reject } = Promise.withResolvers();
+			let cleanup;
+			const timer = setTimeout(() => {
+				cleanup?.();
+				reject(/* @__PURE__ */ new Error(`Broker request timeout: ${subject}`));
+			}, timeout);
+			try {
+				const unsub = await transport.subscribe(inbox, (message) => {
+					clearTimeout(timer);
+					cleanup?.();
+					resolve(message);
+				});
+				cleanup = typeof unsub === "function" ? unsub : void 0;
+				await transport.publish(subject, inbox + "\n" + payload);
+			} catch (err) {
+				clearTimeout(timer);
+				cleanup?.();
+				reject(err);
+			}
+			return promise;
+		}
+	};
+}
+//#endregion
+export { ioredisTransport, redisBroker };

package/dist/builder.d.mts

@@ -0,0 +1,36 @@
+import { AnySchema, InferSchemaInput, InferSchemaOutput } from "./core/schema.mjs";
+import { ErrorDef, Meta, MiddlewareDef, ProcedureDef, ProcedureType, ResolveContext, Route } from "./types.mjs";
+
+//#region src/builder.d.ts
+/** Initial builder — no input, no output, no errors yet */
+interface ProcedureBuilder<TType extends ProcedureType, TBaseCtx extends Record<string, unknown>, TCtx extends Record<string, unknown> = TBaseCtx, TInput = undefined, TErrors extends ErrorDef = {}> {
+  /** Add middleware (guards and wraps) */
+  $use<_TReturn extends Record<string, unknown> | void>(...middleware: readonly MiddlewareDef[]): ProcedureBuilder<TType, TBaseCtx, TCtx, TInput, TErrors>;
+  /** Set input schema */
+  $input<TSchema extends AnySchema>(schema: TSchema): ProcedureBuilder<TType, TBaseCtx, TCtx, InferSchemaOutput<TSchema>, TErrors>;
+  /** Set output schema — enables return type autocomplete */
+  $output<TSchema extends AnySchema>(schema: TSchema): ProcedureBuilderWithOutput<TType, TBaseCtx, TCtx, TInput, InferSchemaInput<TSchema>, TErrors>;
+  /** Set typed errors */
+  $errors<TNewErrors extends ErrorDef>(errors: TNewErrors): ProcedureBuilder<TType, TBaseCtx, TCtx, TInput, TNewErrors & TErrors>;
+  /** Set route metadata */
+  $route(route: Route): ProcedureBuilder<TType, TBaseCtx, TCtx, TInput, TErrors>;
+  /** Set custom metadata */
+  $meta(meta: Meta): ProcedureBuilder<TType, TBaseCtx, TCtx, TInput, TErrors>;
+  /** Resolve — freely inferred return type (no output schema) */
+  $resolve<TOutput>(fn: TType extends 'subscription' ? (opts: ResolveContext<TCtx, TInput, TErrors>) => AsyncIterableIterator<TOutput> : (opts: ResolveContext<TCtx, TInput, TErrors>) => Promise<TOutput> | TOutput): ProcedureDef<TType, TInput, TOutput, TErrors>;
+}
+/** Builder after .$output() — return type is constrained for autocomplete */
+interface ProcedureBuilderWithOutput<TType extends ProcedureType, TBaseCtx extends Record<string, unknown>, TCtx extends Record<string, unknown>, TInput, TOutputResolved, TErrors extends ErrorDef> {
+  /** Add middleware */
+  $use(...middleware: readonly MiddlewareDef[]): ProcedureBuilderWithOutput<TType, TBaseCtx, TCtx, TInput, TOutputResolved, TErrors>;
+  /** Set typed errors */
+  $errors<TNewErrors extends ErrorDef>(errors: TNewErrors): ProcedureBuilderWithOutput<TType, TBaseCtx, TCtx, TInput, TOutputResolved, TNewErrors & TErrors>;
+  /** Set route metadata */
+  $route(route: Route): ProcedureBuilderWithOutput<TType, TBaseCtx, TCtx, TInput, TOutputResolved, TErrors>;
+  /** Set custom metadata */
+  $meta(meta: Meta): ProcedureBuilderWithOutput<TType, TBaseCtx, TCtx, TInput, TOutputResolved, TErrors>;
+  /** Resolve — return type constrained to output schema (autocomplete works) */
+  $resolve(fn: TType extends 'subscription' ? (opts: ResolveContext<TCtx, TInput, TErrors>) => AsyncIterableIterator<TOutputResolved> : (opts: ResolveContext<TCtx, TInput, TErrors>) => Promise<TOutputResolved> | TOutputResolved): ProcedureDef<TType, TInput, TOutputResolved, TErrors>;
+}
+//#endregion
+export { ProcedureBuilder, ProcedureBuilderWithOutput };

package/dist/builder.mjs

@@ -0,0 +1,51 @@
+//#region src/builder.ts
+var ProcBuilder = class {
+	type;
+	input = null;
+	output = null;
+	errors = null;
+	use = null;
+	resolve = null;
+	route = null;
+	meta = null;
+	constructor(type) {
+		this.type = type;
+	}
+	$use(...middleware) {
+		if (this.use) this.use.push(...middleware);
+		else this.use = middleware;
+		return this;
+	}
+	$input(schema) {
+		this.input = schema;
+		return this;
+	}
+	$output(schema) {
+		this.output = schema;
+		return this;
+	}
+	$errors(errors) {
+		this.errors = this.errors ? {
+			...this.errors,
+			...errors
+		} : errors;
+		return this;
+	}
+	$route(route) {
+		this.route = route;
+		return this;
+	}
+	$meta(meta) {
+		this.meta = meta;
+		return this;
+	}
+	$resolve(fn) {
+		this.resolve = fn;
+		return this;
+	}
+};
+function createProcedureBuilder(type) {
+	return new ProcBuilder(type);
+}
+//#endregion
+export { createProcedureBuilder };

package/dist/callable.d.mts

@@ -0,0 +1,17 @@
+import { ErrorDef, ProcedureDef } from "./types.mjs";
+
+//#region src/callable.d.ts
+interface CallableOptions<TCtx extends Record<string, unknown>> {
+  /** Context factory — called on every invocation */
+  context: () => TCtx | Promise<TCtx>;
+}
+type CallableFn<TInput, TOutput> = undefined extends TInput ? (input?: TInput) => Promise<TOutput> : (input: TInput) => Promise<TOutput>;
+/**
+ * Convert a ProcedureDef into a directly callable async function.
+ *
+ * Compiles the full pipeline (guards, wraps, validation) once,
+ * then each call runs the compiled handler directly — no HTTP overhead.
+ */
+declare function callable<TInput, TOutput, TErrors extends ErrorDef, TCtx extends Record<string, unknown>>(procedure: ProcedureDef<any, TInput, TOutput, TErrors>, options: CallableOptions<TCtx>): CallableFn<TInput, TOutput>;
+//#endregion
+export { CallableOptions, callable };

package/dist/callable.mjs

@@ -0,0 +1,42 @@
+import { compileProcedure } from "./compile.mjs";
+//#region src/callable.ts
+/**
+* callable() — turn a procedure into a directly invocable function.
+*
+* Useful for server-side code where you want to call a procedure
+* without going through HTTP or the client proxy.
+*
+* @example
+* ```ts
+* const getUsers = k
+*   .$input(z.object({ limit: z.number() }))
+*   .$resolve(({ input, ctx }) => ctx.db.users.findMany({ take: input.limit }))
+*
+* const fn = callable(getUsers, {
+*   context: () => ({ db: getDB() }),
+* })
+*
+* // Call it directly — no HTTP, no serialization
+* const users = await fn({ limit: 10 })
+* ```
+*/
+/**
+* Convert a ProcedureDef into a directly callable async function.
+*
+* Compiles the full pipeline (guards, wraps, validation) once,
+* then each call runs the compiled handler directly — no HTTP overhead.
+*/
+function callable(procedure, options) {
+	const handler = compileProcedure(procedure);
+	const contextFactory = options.context;
+	const signal = new AbortController().signal;
+	return (async (input) => {
+		const ctx = await contextFactory();
+		const ctxObj = Object.create(null);
+		const keys = Object.keys(ctx);
+		for (let i = 0; i < keys.length; i++) ctxObj[keys[i]] = ctx[keys[i]];
+		return handler(ctxObj, input, signal);
+	});
+}
+//#endregion
+export { callable };

package/dist/client/adapters/fetch/index.d.mts

@@ -0,0 +1,17 @@
+import { ClientContext, ClientLink, ClientOptions } from "../../types.mjs";
+
+//#region src/client/adapters/fetch/index.d.ts
+interface RPCLinkOptions<TClientContext extends ClientContext = ClientContext> {
+  url: string | URL;
+  headers?: Record<string, string> | ((options: ClientOptions<TClientContext>) => Record<string, string>);
+  fetch?: typeof globalThis.fetch;
+  method?: 'GET' | 'POST';
+  maxUrlLength?: number;
+}
+declare class RPCLink<TClientContext extends ClientContext = ClientContext> implements ClientLink<TClientContext> {
+  #private;
+  constructor(options: RPCLinkOptions<TClientContext>);
+  call(path: readonly string[], input: unknown, options: ClientOptions<TClientContext>): Promise<unknown>;
+}
+//#endregion
+export { RPCLink, RPCLinkOptions };

package/dist/client/adapters/fetch/index.mjs

@@ -0,0 +1,61 @@
+import { SilgiError, fromSilgiErrorJSON, isErrorStatus, isSilgiErrorJSON } from "../../../core/error.mjs";
+import { parseEmptyableJSON, stringifyJSON } from "../../../core/utils.mjs";
+//#region src/client/adapters/fetch/index.ts
+/**
+* Fetch transport — HTTP client for browser and Node.js.
+*/
+var RPCLink = class {
+	#baseUrl;
+	#headers;
+	#fetch;
+	#method;
+	#maxUrlLength;
+	constructor(options) {
+		this.#baseUrl = typeof options.url === "string" ? options.url : options.url.href;
+		if (this.#baseUrl.endsWith("/")) this.#baseUrl = this.#baseUrl.slice(0, -1);
+		this.#headers = options.headers;
+		this.#fetch = options.fetch ?? globalThis.fetch.bind(globalThis);
+		this.#method = options.method ?? "POST";
+		this.#maxUrlLength = options.maxUrlLength ?? 2083;
+	}
+	async call(path, input, options) {
+		const urlPath = path.map(encodeURIComponent).join("/");
+		let url = `${this.#baseUrl}/${urlPath}`;
+		const headers = { ...typeof this.#headers === "function" ? this.#headers(options) : this.#headers };
+		let method = this.#method;
+		let body;
+		const hasInput = input !== void 0 && input !== null;
+		if (method === "GET" && hasInput) {
+			const data = stringifyJSON(input);
+			const candidateUrl = `${url}?data=${encodeURIComponent(data)}`;
+			if (candidateUrl.length <= this.#maxUrlLength) url = candidateUrl;
+			else {
+				method = "POST";
+				headers["content-type"] = "application/json";
+				body = data;
+			}
+		} else if (hasInput) {
+			headers["content-type"] = "application/json";
+			body = stringifyJSON(input);
+		}
+		const response = await this.#fetch(url, {
+			method,
+			headers,
+			body,
+			signal: options.signal
+		});
+		const responseText = await response.text();
+		const responseBody = responseText ? parseEmptyableJSON(responseText) : void 0;
+		if (isErrorStatus(response.status)) {
+			if (isSilgiErrorJSON(responseBody)) throw fromSilgiErrorJSON(responseBody);
+			throw new SilgiError("INTERNAL_SERVER_ERROR", {
+				status: response.status,
+				message: `HTTP ${response.status}`,
+				data: responseBody
+			});
+		}
+		return responseBody;
+	}
+};
+//#endregion
+export { RPCLink };

package/dist/client/adapters/ofetch/index.d.mts

@@ -0,0 +1,41 @@
+import { ClientContext, ClientLink, ClientOptions } from "../../types.mjs";
+import { FetchContext, FetchOptions } from "ofetch";
+
+//#region src/client/adapters/ofetch/index.d.ts
+interface SilgiLinkOptions<TClientContext extends ClientContext = ClientContext> {
+  /** Server base URL (e.g. "http://localhost:3000") */
+  url: string;
+  /** Static headers or dynamic header factory */
+  headers?: Record<string, string> | ((options: ClientOptions<TClientContext>) => Record<string, string>);
+  /** Retry count for failed requests (default: 1 for queries, 0 for mutations) */
+  retry?: number | false;
+  /** Retry delay in ms, or function for backoff (default: 0) */
+  retryDelay?: number | ((ctx: FetchContext) => number);
+  /** Timeout in ms (default: 30000) */
+  timeout?: number;
+  /** Use MessagePack binary protocol (2-4x faster, ~50% smaller payloads) */
+  binary?: boolean;
+  /** Use devalue protocol (preserves Date, Map, Set, BigInt, circular refs) */
+  devalue?: boolean;
+  /** ofetch interceptors */
+  onRequest?: FetchOptions['onRequest'];
+  onResponse?: FetchOptions['onResponse'];
+  onRequestError?: FetchOptions['onRequestError'];
+  onResponseError?: FetchOptions['onResponseError'];
+}
+/**
+ * Create a Silgi client link powered by ofetch.
+ *
+ * @example
+ * ```ts
+ * import { createClient } from "silgi/client"
+ * import { createLink } from "silgi/client/ofetch"
+ *
+ * const link = createLink({ url: "http://localhost:3000" })
+ * const client = createClient<AppRouter>(link)
+ * const users = await client.users.list({ limit: 10 })
+ * ```
+ */
+declare function createLink<TClientContext extends ClientContext = ClientContext>(options: SilgiLinkOptions<TClientContext>): ClientLink<TClientContext>;
+//#endregion
+export { SilgiLinkOptions, createLink };