silgi 0.0.14 → 0.1.0-beta.10

package/dist/plugins/cookies.mjs

@@ -0,0 +1,48 @@
+import { parse, parseSetCookie, serialize, splitSetCookieString } from "cookie-es";
+//#region src/plugins/cookies.ts
+/**
+* Cookie helpers — thin wrapper over cookie-es (unjs).
+*
+* @example
+* ```ts
+* import { getCookie, setCookie, deleteCookie } from "silgi/cookies"
+*
+* const auth = k.guard((ctx) => {
+*   const token = getCookie(ctx.headers, "session")
+*   if (!token) throw new SilgiError("UNAUTHORIZED")
+*   return { sessionToken: token }
+* })
+* ```
+*/
+/** Parse a specific cookie value by name. */
+function getCookie(headers, name) {
+	const str = typeof headers === "string" ? headers : headers.cookie ?? headers.Cookie ?? "";
+	if (!str) return void 0;
+	return parse(str)[name];
+}
+/** Parse all cookies into a key-value object. */
+function parseCookies(headers) {
+	const str = typeof headers === "string" ? headers : headers.cookie ?? headers.Cookie ?? "";
+	if (!str) return {};
+	return parse(str);
+}
+/** Serialize a Set-Cookie header. Defaults: path="/", httpOnly, sameSite=lax. */
+function setCookie(name, value, options = {}) {
+	const merged = {
+		path: "/",
+		httpOnly: true,
+		sameSite: "lax",
+		...options
+	};
+	if (merged.sameSite === "none") merged.secure = true;
+	return serialize(name, value, merged);
+}
+/** Delete a cookie by setting maxAge=0. */
+function deleteCookie(name, options = {}) {
+	return setCookie(name, "", {
+		...options,
+		maxAge: 0
+	});
+}
+//#endregion
+export { deleteCookie, getCookie, parseCookies, parseSetCookie, setCookie, splitSetCookieString };

package/dist/plugins/cors.d.mts

@@ -0,0 +1,43 @@
+//#region src/plugins/cors.d.ts
+/**
+ * CORS plugin — response header helper.
+ *
+ * Returns CORS headers to merge into responses.
+ * Handles preflight OPTIONS requests automatically via the handler.
+ */
+interface CORSOptions {
+  origin?: string | string[] | ((origin: string) => boolean);
+  methods?: string[];
+  allowedHeaders?: string[];
+  exposedHeaders?: string[];
+  credentials?: boolean;
+  maxAge?: number;
+}
+/**
+ * Create CORS headers config for silgi().
+ *
+ * @example
+ * ```ts
+ * import { cors } from "silgi/cors"
+ *
+ * const k = silgi({
+ *   context: (req) => ({}),
+ *   hooks: cors({ origin: "https://app.example.com", credentials: true }),
+ * })
+ * ```
+ */
+declare function cors(options?: CORSOptions): {
+  headers: Record<string, string>;
+  options: CORSOptions;
+};
+/**
+ * CORS header map — use in custom serve() or middleware.
+ * Returns headers object to merge into responses.
+ *
+ * For dynamic origins (array/function), omits Access-Control-Allow-Origin
+ * entirely when the request origin is not allowed — this is the correct
+ * behavior per the CORS spec (browsers reject missing header).
+ */
+declare function corsHeaders(options?: CORSOptions, requestOrigin?: string): Record<string, string>;
+//#endregion
+export { CORSOptions, cors, corsHeaders };

package/dist/plugins/cors.mjs

@@ -0,0 +1,62 @@
+//#region src/plugins/cors.ts
+/**
+* Create CORS headers config for silgi().
+*
+* @example
+* ```ts
+* import { cors } from "silgi/cors"
+*
+* const k = silgi({
+*   context: (req) => ({}),
+*   hooks: cors({ origin: "https://app.example.com", credentials: true }),
+* })
+* ```
+*/
+function cors(options = {}) {
+	const origin = options.origin ?? "*";
+	if (options.credentials && typeof origin === "string" && origin === "*") throw new Error("[silgi/cors] Cannot use credentials: true with origin: \"*\". Set an explicit origin.");
+	return {
+		headers: corsHeaders(options),
+		options
+	};
+}
+/**
+* CORS header map — use in custom serve() or middleware.
+* Returns headers object to merge into responses.
+*
+* For dynamic origins (array/function), omits Access-Control-Allow-Origin
+* entirely when the request origin is not allowed — this is the correct
+* behavior per the CORS spec (browsers reject missing header).
+*/
+function corsHeaders(options = {}, requestOrigin) {
+	const origin = options.origin ?? "*";
+	const methods = options.methods ?? [
+		"GET",
+		"POST",
+		"PUT",
+		"PATCH",
+		"DELETE",
+		"OPTIONS"
+	];
+	const allowedHeaders = options.allowedHeaders ?? ["Content-Type", "Authorization"];
+	const headers = {
+		"access-control-allow-methods": methods.join(", "),
+		"access-control-allow-headers": allowedHeaders.join(", ")
+	};
+	if (typeof origin === "string") {
+		headers["access-control-allow-origin"] = origin;
+		if (origin !== "*") headers["vary"] = "Origin";
+	} else if (Array.isArray(origin)) {
+		if (requestOrigin && origin.includes(requestOrigin)) headers["access-control-allow-origin"] = requestOrigin;
+		headers["vary"] = "Origin";
+	} else if (typeof origin === "function") {
+		if (requestOrigin && origin(requestOrigin)) headers["access-control-allow-origin"] = requestOrigin;
+		headers["vary"] = "Origin";
+	}
+	if (options.credentials) headers["access-control-allow-credentials"] = "true";
+	if (options.maxAge !== void 0) headers["access-control-max-age"] = String(options.maxAge);
+	if (options.exposedHeaders) headers["access-control-expose-headers"] = options.exposedHeaders.join(", ");
+	return headers;
+}
+//#endregion
+export { cors, corsHeaders };

package/dist/plugins/file-upload.d.mts

@@ -0,0 +1,38 @@
+import { GuardDef } from "../types.mjs";
+
+//#region src/plugins/file-upload.d.ts
+interface FileGuardOptions {
+  /** Maximum file size in bytes. Default: 10MB */
+  maxFileSize?: number;
+  /** Allowed MIME types (supports wildcards like "image/*"). Default: all */
+  allowedTypes?: string[];
+  /** Maximum number of files. Default: 1 */
+  maxFiles?: number;
+  /** Form field name for the file. Default: "file" */
+  fieldName?: string;
+}
+interface UploadedFile {
+  name: string;
+  size: number;
+  type: string;
+  arrayBuffer(): Promise<ArrayBuffer>;
+  text(): Promise<string>;
+  stream(): ReadableStream<Uint8Array>;
+}
+/**
+ * Guard that parses multipart file uploads from the request.
+ *
+ * Adds `ctx.file` (single) or `ctx.files` (multiple) to the context.
+ * Validates file size and MIME type before the procedure runs.
+ */
+declare function fileGuard(options?: FileGuardOptions): GuardDef<Record<string, unknown>>;
+/**
+ * Parse multipart form data from a Request.
+ * Returns files and fields separately.
+ */
+declare function parseMultipart(request: Request): Promise<{
+  files: UploadedFile[];
+  fields: Record<string, string>;
+}>;
+//#endregion
+export { FileGuardOptions, UploadedFile, fileGuard, parseMultipart };

package/dist/plugins/file-upload.mjs

@@ -0,0 +1,102 @@
+import { SilgiError } from "../core/error.mjs";
+//#region src/plugins/file-upload.ts
+/**
+* File upload/download — type-safe File/Blob handling.
+*
+* Parse multipart/form-data requests and pass File objects
+* to procedure handlers. Works with serve() and handler().
+*
+* @example
+* ```ts
+* import { fileInput, fileGuard } from "silgi/plugins"
+*
+* const uploadAvatar = k
+*   .$use(fileGuard({ maxFileSize: 5 * 1024 * 1024, allowedTypes: ["image/*"] }))
+*   .$resolve(async ({ ctx }) => {
+*     const file = ctx.file
+*     const buffer = await file.arrayBuffer()
+*     return { name: file.name, size: file.size, type: file.type }
+*   })
+* ```
+*/
+/**
+* Guard that parses multipart file uploads from the request.
+*
+* Adds `ctx.file` (single) or `ctx.files` (multiple) to the context.
+* Validates file size and MIME type before the procedure runs.
+*/
+function fileGuard(options = {}) {
+	const { maxFileSize = 10 * 1024 * 1024, allowedTypes, maxFiles = 1, fieldName: _fieldName = "file" } = options;
+	return {
+		kind: "guard",
+		fn: (ctx) => {
+			const files = ctx.__files;
+			if (!files || files.length === 0) throw new SilgiError("BAD_REQUEST", {
+				status: 400,
+				message: "No file uploaded"
+			});
+			if (files.length > maxFiles) throw new SilgiError("BAD_REQUEST", {
+				status: 400,
+				message: `Too many files: ${files.length} (max ${maxFiles})`
+			});
+			for (const file of files) {
+				if (file.size > maxFileSize) throw new SilgiError("PAYLOAD_TOO_LARGE", {
+					status: 413,
+					message: `File too large: ${file.size} bytes (max ${maxFileSize})`,
+					data: {
+						maxFileSize,
+						actualSize: file.size,
+						fileName: file.name
+					}
+				});
+				if (allowedTypes && !matchesMimeType(file.type, allowedTypes)) throw new SilgiError("BAD_REQUEST", {
+					status: 400,
+					message: `File type not allowed: ${file.type}`,
+					data: {
+						allowedTypes,
+						actualType: file.type,
+						fileName: file.name
+					}
+				});
+			}
+			return maxFiles === 1 ? { file: files[0] } : { files };
+		}
+	};
+}
+/**
+* Parse multipart form data from a Request.
+* Returns files and fields separately.
+*/
+async function parseMultipart(request) {
+	const formData = await request.formData();
+	const files = [];
+	const fields = {};
+	for (const [key, value] of formData.entries()) if (typeof value !== "string") {
+		const file = value;
+		files.push({
+			name: file.name,
+			size: file.size,
+			type: file.type,
+			arrayBuffer: () => file.arrayBuffer(),
+			text: () => file.text(),
+			stream: () => file.stream()
+		});
+	} else fields[key] = value;
+	return {
+		files,
+		fields
+	};
+}
+function matchesMimeType(actual, patterns) {
+	for (const pattern of patterns) {
+		if (pattern === "*" || pattern === "*/*") return true;
+		if (pattern === actual) return true;
+		if (pattern.endsWith("/*")) {
+			const prefix = pattern.slice(0, -2);
+			if (actual.startsWith(prefix + "/")) return true;
+		}
+	}
+	return false;
+}
+//#endregion
+export { fileGuard, parseMultipart };

package/dist/plugins/index.d.mts

@@ -0,0 +1,14 @@
+import { AnalyticsCollector, AnalyticsOptions, AnalyticsSnapshot, ErrorEntry, ProcedureSnapshot, RequestTrace, TraceSpan, analyticsHTML, errorToMarkdown, trace } from "./analytics.mjs";
+import { Span, Tracer, otelWrap } from "./otel.mjs";
+import { CookieOptions, deleteCookie, getCookie, parseCookies, setCookie } from "./cookies.mjs";
+import { CORSOptions, cors, corsHeaders } from "./cors.mjs";
+import { Logger, LoggingOptions, loggingHooks } from "./pino.mjs";
+import { MemoryRateLimiter, MemoryRateLimiterOptions, RateLimitGuardOptions, RateLimitResult, RateLimiter, rateLimitGuard } from "./ratelimit.mjs";
+import { BodyLimitOptions, bodyLimitGuard } from "./body-limit.mjs";
+import { strictGetGuard } from "./strict-get.mjs";
+import { decrypt, encrypt, sign, unsign } from "./signing.mjs";
+import { coerceGuard, coerceObject, coerceValue } from "./coerce.mjs";
+import { BatchHandlerOptions, createBatchHandler } from "./batch-server.mjs";
+import { MemoryPubSub, PubSubBackend, Publisher, createPublisher } from "./pubsub.mjs";
+import { FileGuardOptions, UploadedFile, fileGuard, parseMultipart } from "./file-upload.mjs";
+export { AnalyticsCollector, type AnalyticsOptions, type AnalyticsSnapshot, type BatchHandlerOptions, type BodyLimitOptions, type CORSOptions, type CookieOptions, type ErrorEntry, type FileGuardOptions, type Logger, type LoggingOptions, MemoryPubSub, MemoryRateLimiter, type MemoryRateLimiterOptions, type ProcedureSnapshot, type PubSubBackend, type Publisher, type RateLimitGuardOptions, type RateLimitResult, type RateLimiter, RequestTrace, type Span, type TraceSpan, type Tracer, type UploadedFile, analyticsHTML, bodyLimitGuard, coerceGuard, coerceObject, coerceValue, cors, corsHeaders, createBatchHandler, createPublisher, decrypt, deleteCookie, encrypt, errorToMarkdown, fileGuard, getCookie, loggingHooks, otelWrap, parseCookies, parseMultipart, rateLimitGuard, setCookie, sign, strictGetGuard, trace, unsign };

package/dist/plugins/index.mjs

@@ -0,0 +1,14 @@
+import { AnalyticsCollector, RequestTrace, analyticsHTML, errorToMarkdown, trace } from "./analytics.mjs";
+import { cors, corsHeaders } from "./cors.mjs";
+import { otelWrap } from "./otel.mjs";
+import { loggingHooks } from "./pino.mjs";
+import { MemoryRateLimiter, rateLimitGuard } from "./ratelimit.mjs";
+import { bodyLimitGuard } from "./body-limit.mjs";
+import { strictGetGuard } from "./strict-get.mjs";
+import { deleteCookie, getCookie, parseCookies, setCookie } from "./cookies.mjs";
+import { decrypt, encrypt, sign, unsign } from "./signing.mjs";
+import { coerceGuard, coerceObject, coerceValue } from "./coerce.mjs";
+import { createBatchHandler } from "./batch-server.mjs";
+import { MemoryPubSub, createPublisher } from "./pubsub.mjs";
+import { fileGuard, parseMultipart } from "./file-upload.mjs";
+export { AnalyticsCollector, MemoryPubSub, MemoryRateLimiter, RequestTrace, analyticsHTML, bodyLimitGuard, coerceGuard, coerceObject, coerceValue, cors, corsHeaders, createBatchHandler, createPublisher, decrypt, deleteCookie, encrypt, errorToMarkdown, fileGuard, getCookie, loggingHooks, otelWrap, parseCookies, parseMultipart, rateLimitGuard, setCookie, sign, strictGetGuard, trace, unsign };

package/dist/plugins/otel.d.mts

@@ -0,0 +1,35 @@
+import { WrapDef } from "../types.mjs";
+
+//#region src/plugins/otel.d.ts
+interface Span {
+  setAttribute(key: string, value: string | number | boolean): void;
+  setStatus(status: {
+    code: number;
+    message?: string;
+  }): void;
+  addEvent(name: string, attributes?: Record<string, unknown>): void;
+  end(): void;
+}
+interface Tracer {
+  startSpan(name: string, options?: {
+    attributes?: Record<string, string | number | boolean>;
+  }): Span;
+}
+/**
+ * Create an OTel tracing wrap middleware.
+ *
+ * @example
+ * ```ts
+ * import { otelWrap } from "silgi/otel"
+ * import { trace } from "@opentelemetry/api"
+ *
+ * const tracing = otelWrap(trace.getTracer("my-service"))
+ *
+ * const proc = k
+ *   .$use(tracing)
+ *   .$resolve(({ ctx }) => ctx.db.find())
+ * ```
+ */
+declare function otelWrap(tracer: Tracer, spanName?: string): WrapDef;
+//#endregion
+export { Span, Tracer, otelWrap };

package/dist/plugins/otel.mjs

@@ -0,0 +1,40 @@
+//#region src/plugins/otel.ts
+/**
+* Create an OTel tracing wrap middleware.
+*
+* @example
+* ```ts
+* import { otelWrap } from "silgi/otel"
+* import { trace } from "@opentelemetry/api"
+*
+* const tracing = otelWrap(trace.getTracer("my-service"))
+*
+* const proc = k
+*   .$use(tracing)
+*   .$resolve(({ ctx }) => ctx.db.find())
+* ```
+*/
+function otelWrap(tracer, spanName = "rpc.call") {
+	return {
+		kind: "wrap",
+		fn: async (_ctx, next) => {
+			const span = tracer.startSpan(spanName, { attributes: { "rpc.system": "silgi" } });
+			try {
+				const result = await next();
+				span.setStatus({ code: 0 });
+				return result;
+			} catch (error) {
+				span.setStatus({
+					code: 2,
+					message: String(error)
+				});
+				span.addEvent("exception", { "exception.message": error instanceof Error ? error.message : String(error) });
+				throw error;
+			} finally {
+				span.end();
+			}
+		}
+	};
+}
+//#endregion
+export { otelWrap };

package/dist/plugins/pino.d.mts

@@ -0,0 +1,60 @@
+//#region src/plugins/pino.d.ts
+/**
+ * Pino logging plugin — v2 hook-based.
+ *
+ * Logs request lifecycle events via silgi hooks.
+ */
+interface Logger {
+  child(bindings: Record<string, unknown>): Logger;
+  info(obj: Record<string, unknown>, msg?: string): void;
+  error(obj: Record<string, unknown>, msg?: string): void;
+  warn(obj: Record<string, unknown>, msg?: string): void;
+  debug(obj: Record<string, unknown>, msg?: string): void;
+}
+interface LoggingOptions {
+  /** The root logger instance */
+  logger: Logger;
+  /** Log request received events (default: true) */
+  logRequests?: boolean;
+  /** Log response events (default: true) */
+  logResponses?: boolean;
+}
+/**
+ * Create logging hooks for silgi().
+ *
+ * @example
+ * ```ts
+ * import pino from "pino"
+ * import { loggingHooks } from "silgi/pino"
+ *
+ * const k = silgi({
+ *   context: (req) => ({}),
+ *   hooks: loggingHooks({ logger: pino() }),
+ * })
+ * ```
+ */
+declare function loggingHooks(options: LoggingOptions): {
+  error: ({
+    path,
+    error
+  }: {
+    path: string;
+    error: unknown;
+  }) => void;
+  response?: (({
+    path,
+    durationMs
+  }: {
+    path: string;
+    durationMs: number;
+  }) => void) | undefined;
+  request?: (({
+    path,
+    input
+  }: {
+    path: string;
+    input: unknown;
+  }) => void) | undefined;
+};
+//#endregion
+export { Logger, LoggingOptions, loggingHooks };

package/dist/plugins/pino.mjs

@@ -0,0 +1,42 @@
+//#region src/plugins/pino.ts
+/**
+* Create logging hooks for silgi().
+*
+* @example
+* ```ts
+* import pino from "pino"
+* import { loggingHooks } from "silgi/pino"
+*
+* const k = silgi({
+*   context: (req) => ({}),
+*   hooks: loggingHooks({ logger: pino() }),
+* })
+* ```
+*/
+function loggingHooks(options) {
+	const { logger } = options;
+	const logRequests = options.logRequests ?? true;
+	const logResponses = options.logResponses ?? true;
+	return {
+		...logRequests && { request: ({ path, input }) => {
+			logger.info({
+				path,
+				hasInput: input !== void 0
+			}, "request received");
+		} },
+		...logResponses && { response: ({ path, durationMs }) => {
+			logger.info({
+				path,
+				durationMs: Math.round(durationMs * 100) / 100
+			}, "response sent");
+		} },
+		error: ({ path, error }) => {
+			logger.error({
+				path,
+				error: error instanceof Error ? error.message : String(error)
+			}, "request error");
+		}
+	};
+}
+//#endregion
+export { loggingHooks };

package/dist/plugins/pubsub.d.mts

@@ -0,0 +1,50 @@
+//#region src/plugins/pubsub.d.ts
+/**
+ * Publisher/PubSub — event pub/sub with pluggable backends.
+ *
+ * Publish events from any procedure, subscribe from SSE/WebSocket.
+ * Built-in memory adapter. Redis/Upstash adapters plug in via interface.
+ *
+ * @example
+ * ```ts
+ * import { createPublisher, MemoryPubSub } from "silgi/plugins"
+ *
+ * const pubsub = createPublisher(new MemoryPubSub())
+ *
+ * // Publish from a mutation
+ * const createUser = k.$resolve(async ({ input, ctx }) => {
+ *   const user = await ctx.db.users.create(input)
+ *   await pubsub.publish("user:created", user)
+ *   return user
+ * })
+ *
+ * // Subscribe via SSE
+ * const onUserCreated = k.subscription(async function* () {
+ *   yield* pubsub.subscribe("user:created")
+ * })
+ * ```
+ */
+interface PubSubBackend {
+  publish(channel: string, data: unknown): Promise<void>;
+  subscribe(channel: string, callback: (data: unknown) => void): () => void;
+}
+declare class MemoryPubSub implements PubSubBackend {
+  #private;
+  publish(channel: string, data: unknown): Promise<void>;
+  subscribe(channel: string, callback: (data: unknown) => void): () => void;
+}
+interface Publisher {
+  /** Publish an event to a channel */
+  publish(channel: string, data: unknown): Promise<void>;
+  /** Subscribe to a channel — returns an async iterable for use in subscriptions */
+  subscribe<T = unknown>(channel: string): AsyncGenerator<T, void, unknown>;
+}
+/**
+ * Create a publisher from a PubSub backend.
+ *
+ * The publisher exposes `publish()` for mutations and `subscribe()`
+ * as an async generator for SSE/WebSocket subscriptions.
+ */
+declare function createPublisher(backend: PubSubBackend): Publisher;
+//#endregion
+export { MemoryPubSub, PubSubBackend, Publisher, createPublisher };

package/dist/plugins/pubsub.mjs

@@ -0,0 +1,53 @@
+//#region src/plugins/pubsub.ts
+var MemoryPubSub = class {
+	#listeners = /* @__PURE__ */ new Map();
+	async publish(channel, data) {
+		const listeners = this.#listeners.get(channel);
+		if (!listeners) return;
+		for (const cb of listeners) cb(data);
+	}
+	subscribe(channel, callback) {
+		let set = this.#listeners.get(channel);
+		if (!set) {
+			set = /* @__PURE__ */ new Set();
+			this.#listeners.set(channel, set);
+		}
+		set.add(callback);
+		return () => {
+			set.delete(callback);
+			if (set.size === 0) this.#listeners.delete(channel);
+		};
+	}
+};
+/**
+* Create a publisher from a PubSub backend.
+*
+* The publisher exposes `publish()` for mutations and `subscribe()`
+* as an async generator for SSE/WebSocket subscriptions.
+*/
+function createPublisher(backend) {
+	return {
+		publish: (channel, data) => backend.publish(channel, data),
+		async *subscribe(channel) {
+			const queue = [];
+			let resolve = null;
+			const unsubscribe = backend.subscribe(channel, (data) => {
+				queue.push(data);
+				if (resolve) {
+					resolve();
+					resolve = null;
+				}
+			});
+			try {
+				while (true) if (queue.length > 0) yield queue.shift();
+				else await new Promise((r) => {
+					resolve = r;
+				});
+			} finally {
+				unsubscribe();
+			}
+		}
+	};
+}
+//#endregion
+export { MemoryPubSub, createPublisher };

package/dist/plugins/ratelimit.d.mts

@@ -0,0 +1,53 @@
+import { GuardDef } from "../types.mjs";
+
+//#region src/plugins/ratelimit.d.ts
+interface RateLimitResult {
+  success: boolean;
+  limit: number;
+  remaining: number;
+  reset: number;
+}
+interface RateLimiter {
+  limit(key: string): Promise<RateLimitResult>;
+}
+interface MemoryRateLimiterOptions {
+  /** Maximum requests per window */
+  limit: number;
+  /** Window duration in milliseconds */
+  windowMs: number;
+}
+declare class MemoryRateLimiter implements RateLimiter {
+  #private;
+  constructor(options: MemoryRateLimiterOptions);
+  limit(key: string): Promise<RateLimitResult>;
+  /** Remove entries with no active timestamps to prevent unbounded Map growth */
+  evict(): void;
+}
+interface RateLimitGuardOptions {
+  /** The rate limiter instance */
+  limiter: RateLimiter;
+  /** Extract rate limit key from context */
+  keyFn: (ctx: Record<string, unknown>) => string | Promise<string>;
+  /** Custom error message */
+  message?: string;
+}
+/**
+ * Create a rate limiting guard.
+ *
+ * @example
+ * ```ts
+ * import { rateLimitGuard, MemoryRateLimiter } from "silgi/ratelimit"
+ *
+ * const rateLimit = rateLimitGuard({
+ *   limiter: new MemoryRateLimiter({ limit: 100, windowMs: 60_000 }),
+ *   keyFn: (ctx) => (ctx as any).ip ?? "anonymous",
+ * })
+ *
+ * const proc = k
+ *   .$use(rateLimit)
+ *   .$resolve(() => ({ ok: true }))
+ * ```
+ */
+declare function rateLimitGuard(options: RateLimitGuardOptions): GuardDef<any, any>;
+//#endregion
+export { MemoryRateLimiter, MemoryRateLimiterOptions, RateLimitGuardOptions, RateLimitResult, RateLimiter, rateLimitGuard };