@discordkit/core 3.1.0 → 4.0.0

package/dist/requests/DiscordSession.mjs

@@ -0,0 +1,202 @@
+import { sleep } from "../utils/sleep.mjs";
+//#region src/requests/DiscordSession.ts
+const endpoint = `https://discord.com/api/v10/`;
+/** @internal */
+var DiscordSession = class {
+	endpoint = endpoint;
+	maxRetries = 5;
+	#authToken = null;
+	#buckets = /* @__PURE__ */ new Map();
+	#globalReset = 0;
+	#requestQueue = [];
+	#processingQueue = false;
+	#globalLimit = 50;
+	#globalWindow = 1e3;
+	#globalRequestTimestamps = [];
+	#invalidRequests = {
+		count: 0,
+		windowStart: Date.now()
+	};
+	#invalidRequestLimit = 1e4;
+	#invalidRequestWindow = 600 * 1e3;
+	get ready() {
+		return Boolean(this.#authToken);
+	}
+	constructor(authToken) {
+		if (authToken) this.setToken(authToken);
+	}
+	/**
+	* Clears the current session details, then attempts to set
+	* new session values
+	*/
+	setToken = (token) => {
+		this.#authToken = null;
+		if (token.length === 0) throw new Error(`Must provide a non-empty string to set Auth Token`);
+		if (!token.startsWith(`Bot `) && !token.startsWith(`Bearer `)) throw new Error(`Token must begin with either "Bot " or "Bearer ", received: ${token}`);
+		this.#authToken = token;
+		return this;
+	};
+	clearSession = () => {
+		this.#authToken = null;
+		this.#buckets.clear();
+		this.#globalReset = 0;
+		this.#requestQueue = [];
+		this.#globalRequestTimestamps = [];
+		this.#invalidRequests = {
+			count: 0,
+			windowStart: Date.now()
+		};
+		return this;
+	};
+	getSession = () => {
+		const token = this.#authToken;
+		if (!token) throw new Error(`Auth Token must be set before requests can be made.`);
+		return token;
+	};
+	/**
+	* Queue a request to be processed with rate limiting
+	*/
+	queueRequest = async (resource, method, body, options) => {
+		return new Promise((resolve, reject) => {
+			this.#requestQueue.push({
+				resource,
+				method,
+				body,
+				options,
+				resolve,
+				reject
+			});
+			this.#processQueue();
+		});
+	};
+	/**
+	* Process the request queue with rate limiting
+	*/
+	#processQueue = async () => {
+		if (this.#processingQueue) return;
+		this.#processingQueue = true;
+		while (this.#requestQueue.length > 0) {
+			const now = Date.now();
+			if (this.#isTemporarilyBanned()) {
+				const waitTime = this.#invalidRequestWindow - (now - this.#invalidRequests.windowStart);
+				console.warn(`Temporarily banned from Discord API. Waiting ${Math.ceil(waitTime / 1e3)}s`);
+				await sleep(waitTime);
+				this.#resetInvalidRequestCounter();
+			}
+			await this.#enforceGlobalRateLimit();
+			if (this.#globalReset > now / 1e3) {
+				await sleep((this.#globalReset - now / 1e3) * 1e3);
+				continue;
+			}
+			const request = this.#requestQueue[0];
+			if (typeof request === `undefined`) break;
+			const bucket = this.#buckets.get(`${request.method}:${request.resource}`);
+			if (bucket?.remaining === 0) {
+				const resetTime = bucket.reset * 1e3;
+				if (resetTime > now) await sleep(resetTime - now);
+			}
+			this.#requestQueue.shift();
+			try {
+				const response = await this.#executeRequest(request);
+				request.resolve(response);
+			} catch (error) {
+				if (error instanceof Error) request.reject(error);
+			}
+		}
+		this.#processingQueue = false;
+		if (this.#requestQueue.length > 0) this.#processQueue();
+	};
+	/**
+	* Execute a single request and handle rate limit headers
+	*/
+	#executeRequest = async (request, retryCount = 0) => {
+		const now = Date.now();
+		this.#globalRequestTimestamps.push(now);
+		const headers = {};
+		if (!request.options?.anonymous) headers.Authorization = this.getSession();
+		if (request.options?.reason) headers[`X-Audit-Log-Reason`] = encodeURIComponent(request.options.reason);
+		if (request.body && !(request.body instanceof FormData)) headers[`Content-Type`] = `application/json`;
+		const response = await fetch(request.resource.toString(), {
+			method: request.method,
+			body: request.body,
+			headers
+		});
+		this.#updateRateLimits(response);
+		if (response.status === 429) {
+			if (retryCount >= this.maxRetries) {
+				console.error(`Max retries (${this.maxRetries}) exceeded for ${request.resource}`);
+				return response;
+			}
+			const retryAfter = response.headers.get(`Retry-After`) ?? `1`;
+			const isGlobal = response.headers.get(`X-RateLimit-Global`) === `true`;
+			const scope = response.headers.get(`X-RateLimit-Scope`);
+			if (isGlobal || scope === `global`) {
+				console.warn(`Hit global rate limit`);
+				this.#globalReset = now / 1e3 + parseFloat(retryAfter);
+			}
+			await sleep(parseFloat(retryAfter) * 1e3);
+			return this.#executeRequest(request, retryCount + 1);
+		}
+		if ([401, 403].includes(response.status) || response.status === 429 && response.headers.get(`X-RateLimit-Scope`) !== `shared`) this.#trackInvalidRequest();
+		return response;
+	};
+	/**
+	* Update rate limit buckets from response headers
+	*/
+	#updateRateLimits = (response) => {
+		const bucket = response.headers.get(`X-RateLimit-Bucket`);
+		const limit = response.headers.get(`X-RateLimit-Limit`);
+		const remaining = response.headers.get(`X-RateLimit-Remaining`);
+		const reset = response.headers.get(`X-RateLimit-Reset`);
+		const resetAfter = response.headers.get(`X-RateLimit-Reset-After`);
+		if (bucket && limit && remaining && reset && resetAfter) this.#buckets.set(bucket, {
+			limit: parseInt(limit, 10),
+			remaining: parseInt(remaining, 10),
+			reset: parseFloat(reset),
+			resetAfter: parseFloat(resetAfter)
+		});
+	};
+	/**
+	* Enforce global rate limit of 50 requests per second
+	*/
+	#enforceGlobalRateLimit = async () => {
+		const now = Date.now();
+		this.#globalRequestTimestamps = this.#globalRequestTimestamps.filter((timestamp) => now - timestamp < this.#globalWindow);
+		if (this.#globalRequestTimestamps.length >= this.#globalLimit) {
+			const oldestTimestamp = this.#globalRequestTimestamps[0];
+			const waitTime = this.#globalWindow - (now - oldestTimestamp);
+			if (waitTime > 0) await sleep(waitTime);
+		}
+	};
+	/**
+	* Track invalid requests for Cloudflare ban prevention
+	*/
+	#trackInvalidRequest = () => {
+		if (Date.now() - this.#invalidRequests.windowStart >= this.#invalidRequestWindow) this.#resetInvalidRequestCounter();
+		this.#invalidRequests.count++;
+		if (this.#invalidRequests.count >= this.#invalidRequestLimit) console.error(`Approaching invalid request limit! Bot may be temporarily banned.`);
+	};
+	/**
+	* Check if we're temporarily banned
+	*/
+	#isTemporarilyBanned = () => {
+		if (Date.now() - this.#invalidRequests.windowStart < this.#invalidRequestWindow) return this.#invalidRequests.count >= this.#invalidRequestLimit;
+		return false;
+	};
+	/**
+	* Reset invalid request counter
+	*/
+	#resetInvalidRequestCounter = () => {
+		this.#invalidRequests = {
+			count: 0,
+			windowStart: Date.now()
+		};
+	};
+	/**
+	* Get current queue size (useful for monitoring)
+	*/
+	getQueueSize = () => this.#requestQueue.length;
+};
+const discord = new DiscordSession();
+//#endregion
+export { DiscordSession, discord, endpoint };

package/dist/requests/addParams.d.mts

@@ -0,0 +1,15 @@
+//#region src/requests/addParams.d.ts
+type RequestParams = Partial<Record<string, number[] | string[] | boolean | number | string | null | undefined>>;
+/**
+ * Append a params object to a URL.
+ *
+ * Array values are emitted as repeated query keys (`?id=1&id=2`), which is
+ * how Discord's HTTP API documents array query strings. Scalars are
+ * stringified once. Keys are converted from camelCase to snake_case to
+ * match Discord's convention.
+ *
+ * @__NO_SIDE_EFFECTS__
+ */
+declare const addParams: (url: URL, params: RequestParams) => URL;
+//#endregion
+export { RequestParams, addParams };

package/dist/requests/addParams.mjs

@@ -0,0 +1,24 @@
+import { isNonNullable } from "../utils/isNonNullable.mjs";
+import { toSnakeCase } from "../utils/toSnakeCase.mjs";
+//#region src/requests/addParams.ts
+/**
+* Append a params object to a URL.
+*
+* Array values are emitted as repeated query keys (`?id=1&id=2`), which is
+* how Discord's HTTP API documents array query strings. Scalars are
+* stringified once. Keys are converted from camelCase to snake_case to
+* match Discord's convention.
+*
+* @__NO_SIDE_EFFECTS__
+*/
+const addParams = (url, params) => {
+	for (const [key, value] of Object.entries(params)) {
+		if (!isNonNullable(value)) continue;
+		const snake = toSnakeCase(key);
+		if (Array.isArray(value)) for (const item of value) url.searchParams.append(snake, String(item));
+		else url.searchParams.set(snake, String(value));
+	}
+	return url;
+};
+//#endregion
+export { addParams };

package/dist/requests/buildURL.d.mts

@@ -0,0 +1,7 @@
+import { RequestParams } from "./addParams.mjs";
+
+//#region src/requests/buildURL.d.ts
+/** @__NO_SIDE_EFFECTS__ */
+declare const buildURL: (resource: string, params?: RequestParams, base?: string) => URL;
+//#endregion
+export { buildURL };

package/dist/requests/buildURL.mjs

@@ -0,0 +1,7 @@
+import { endpoint } from "./DiscordSession.mjs";
+import { addParams } from "./addParams.mjs";
+//#region src/requests/buildURL.ts
+/** @__NO_SIDE_EFFECTS__ */
+const buildURL = (resource, params, base) => addParams(new URL(resource.replace(/^\//, ``), base ?? endpoint), params ?? {});
+//#endregion
+export { buildURL };

package/dist/requests/getAsset.d.mts

@@ -0,0 +1,7 @@
+import { buildURL } from "./buildURL.mjs";
+
+//#region src/requests/getAsset.d.ts
+/** @__NO_SIDE_EFFECTS__ */
+declare const getAsset: (resource: string, params?: Parameters<typeof buildURL>[1]) => string;
+//#endregion
+export { getAsset };

package/dist/requests/getAsset.mjs

@@ -0,0 +1,6 @@
+import { buildURL } from "./buildURL.mjs";
+//#region src/requests/getAsset.ts
+/** @__NO_SIDE_EFFECTS__ */
+const getAsset = (resource, params) => buildURL(resource, params, `https://cdn.discordapp.com/`).href;
+//#endregion
+export { getAsset };

package/dist/requests/index.d.mts

@@ -0,0 +1,9 @@
+import { discord, endpoint } from "./DiscordSession.mjs";
+import { buildURL } from "./buildURL.mjs";
+import { getAsset } from "./getAsset.mjs";
+import { Fetcher, FetcherCapabilities, RequestOptionsFor, get, patch, post, put, remove } from "./methods.mjs";
+import { toProcedure } from "./toProcedure.mjs";
+import { QueryFunction, toQuery } from "./toQuery.mjs";
+import { toValidated } from "./toValidated.mjs";
+import { verifyKey } from "./verifyKey.mjs";
+export { Fetcher, FetcherCapabilities, QueryFunction, RequestOptionsFor, buildURL, discord, endpoint, get, getAsset, patch, post, put, remove, toProcedure, toQuery, toValidated, verifyKey };

package/dist/requests/index.mjs

@@ -0,0 +1,9 @@
+import { discord, endpoint } from "./DiscordSession.mjs";
+import { buildURL } from "./buildURL.mjs";
+import { getAsset } from "./getAsset.mjs";
+import { get, patch, post, put, remove } from "./methods.mjs";
+import { toProcedure } from "./toProcedure.mjs";
+import { toQuery } from "./toQuery.mjs";
+import { toValidated } from "./toValidated.mjs";
+import { verifyKey } from "./verifyKey.mjs";
+export { buildURL, discord, endpoint, get, getAsset, patch, post, put, remove, toProcedure, toQuery, toValidated, verifyKey };

package/dist/requests/methods.d.mts

@@ -0,0 +1,63 @@
+import { RequestBody, RequestOptions } from "./request.mjs";
+import { RequestParams } from "./addParams.mjs";
+import { GenericSchema, GenericSchemaAsync, InferOutput } from "valibot";
+
+//#region src/requests/methods.d.ts
+/**
+ * Capability flags advertised by a {@link Fetcher}. Each flag describes a
+ * property of the underlying Discord endpoint — not a per-call preference.
+ *
+ * The flags drive both the `options` argument the fetcher accepts and the
+ * headers/auth the request layer emits at runtime.
+ */
+interface FetcherCapabilities {
+  /**
+   * `true` if the Discord endpoint MUST be called without an `Authorization`
+   * header. Forces callers to acknowledge the unauthenticated path via
+   * `{ anonymous: true }` and tells the request layer to skip the session token.
+   */
+  readonly anonymous?: boolean;
+  /**
+   * `true` if the Discord endpoint accepts the `X-Audit-Log-Reason` header.
+   * Allows callers to pass `{ reason: "…" }`; the header is URL-encoded and
+   * attached by the request layer.
+   */
+  readonly auditLogReason?: boolean;
+}
+/**
+ * The shape of the per-call `options` argument a {@link Fetcher} accepts,
+ * derived from the endpoint's {@link FetcherCapabilities}.
+ *
+ * - When `anonymous: true` is declared on the capability, the option is
+ *   *required* on every call. When omitted, `anonymous` is forbidden.
+ * - When `auditLogReason: true` is declared, `reason` is permitted; otherwise
+ *   it is forbidden.
+ */
+type RequestOptionsFor<C extends FetcherCapabilities> = (C extends {
+  anonymous: true;
+} ? {
+  anonymous: true;
+} : {
+  anonymous?: never;
+}) & (C extends {
+  auditLogReason: true;
+} ? {
+  reason?: string;
+} : {
+  reason?: never;
+});
+/**
+ * Decide whether the per-call `options` argument is required or optional
+ * based on whether any capability forces a value to be passed.
+ */
+type RequiresOptions<C extends FetcherCapabilities> = C extends {
+  anonymous: true;
+} ? true : false;
+type Fetcher< /** A schema to validate the input arguments of a fetch call */S extends GenericSchema | GenericSchemaAsync | null = null, /** The return value expected from the fetch call */R = void, /** Endpoint capabilities; shapes the `options` argument */C extends FetcherCapabilities = {}> = S extends null ? RequiresOptions<C> extends true ? (options: RequestOptionsFor<C>) => Promise<R> : (options?: RequestOptionsFor<C>) => Promise<R> : RequiresOptions<C> extends true ? (config: InferOutput<NonNullable<S>>, options: RequestOptionsFor<C>) => Promise<R> : (config: InferOutput<NonNullable<S>>, options?: RequestOptionsFor<C>) => Promise<R>;
+declare const get: <T>(url: string, params?: RequestParams, options?: RequestOptions) => Promise<T>;
+declare const post: <T>(url: string, body?: RequestBody, options?: RequestOptions) => Promise<T>;
+declare const put: <T>(url: string, body?: RequestBody, options?: RequestOptions) => Promise<T>;
+declare const patch: <T>(url: string, body?: RequestBody, options?: RequestOptions) => Promise<T>;
+declare const remove: <T = void>(url: string, options?: RequestOptions) => Promise<T>;
+//#endregion
+export { Fetcher, FetcherCapabilities, RequestOptionsFor, get, patch, post, put, remove };

package/dist/requests/methods.mjs

@@ -0,0 +1,10 @@
+import { buildURL } from "./buildURL.mjs";
+import { request } from "./request.mjs";
+//#region src/requests/methods.ts
+const get = async (url, params, options) => request(buildURL(url, params), `GET`, void 0, options);
+const post = async (url, body, options) => request(buildURL(url), `POST`, body, options);
+const put = async (url, body, options) => request(buildURL(url), `PUT`, body, options);
+const patch = async (url, body, options) => request(buildURL(url), `PATCH`, body, options);
+const remove = async (url, options) => request(buildURL(url), `DELETE`, void 0, options);
+//#endregion
+export { get, patch, post, put, remove };

package/dist/requests/request.d.mts

@@ -0,0 +1,27 @@
+//#region src/requests/request.d.ts
+type RequestBody = object | null | undefined;
+/**
+ * Per-call request options forwarded by the typed method helpers
+ * (`get`/`post`/`put`/`patch`/`remove`) into the request layer.
+ *
+ * Endpoints surface these via the `Fetcher` type so the call site is
+ * type-checked against the endpoint's declared capabilities.
+ */
+interface RequestOptions {
+  /**
+   * Skip the `Authorization` header for this request. Used by webhook
+   * and interaction endpoints whose path tokens act as authorization.
+   * When set, `discord.getSession()` is NOT consulted, so the session
+   * is allowed to be unset.
+   */
+  anonymous?: boolean;
+  /**
+   * Audit-log reason. Forwarded to Discord as the `X-Audit-Log-Reason`
+   * header. The value is URL-encoded by the request layer so non-ASCII
+   * characters survive transit.
+   */
+  reason?: string;
+}
+declare const request: <T>(resource: URL, method?: string, body?: RequestBody, options?: RequestOptions) => Promise<T>;
+//#endregion
+export { RequestBody, RequestOptions, request };

package/dist/requests/request.mjs

@@ -0,0 +1,29 @@
+import { discord } from "./DiscordSession.mjs";
+import { toCamelKeys } from "../utils/toCamelKeys.mjs";
+import { toSnakeKeys } from "../utils/toSnakeKeys.mjs";
+import { shouldSerializeAsMultipart, toMultipartBody } from "../validations/fileUpload.mjs";
+//#region src/requests/request.ts
+const request = async (resource, method = `GET`, body, options) => {
+	if (!options?.anonymous) discord.getSession();
+	/**
+	* Serialize the body. The `multipart()` schema wrapper stamps a
+	* sentinel on the parsed body when {@link FileUpload}s are present,
+	* which switches serialization from JSON to `multipart/form-data`.
+	*/
+	const serializeBody = () => {
+		if (!body) return body;
+		try {
+			if (shouldSerializeAsMultipart(body)) return toMultipartBody(body, toSnakeKeys);
+			return JSON.stringify(toSnakeKeys(body));
+		} catch (cause) {
+			console.error(`Received malformed request body:\n\n`, { body });
+			throw new Error(`Failed to serialize request body!`, { cause });
+		}
+	};
+	const res = await discord.queueRequest(resource, method, serializeBody(), options);
+	if (!res.ok) throw new Error(`Request to resource '${resource.toString()}' failed:\n\n${res.statusText}`);
+	if (res.status === 204) return;
+	return toCamelKeys(await res.json());
+};
+//#endregion
+export { request };

package/dist/requests/toProcedure.d.mts

@@ -0,0 +1,40 @@
+import { Fetcher } from "./methods.mjs";
+import * as v from "valibot";
+import { AnyProcedureBuilder, MutationProcedure, ProcedureType, QueryProcedure, SubscriptionProcedure } from "@trpc/server/unstable-core-do-not-import";
+
+//#region src/requests/toProcedure.d.ts
+type Result<T = void> = T extends v.GenericSchema | v.GenericSchemaAsync ? v.InferOutput<T> : T;
+type Schema = v.GenericSchema | v.GenericSchemaAsync;
+type ProvedureDef<I extends Schema | null = null, O extends Schema | null = null> = I extends Schema ? O extends Schema ? {
+  input: v.InferInput<I>;
+  output: v.InferOutput<O>;
+  meta: unknown;
+} : {
+  input: v.InferInput<I>;
+  output: undefined;
+  meta: unknown;
+} : O extends Schema ? {
+  input: undefined;
+  output: v.InferOutput<O>;
+  meta: unknown;
+} : {
+  input: undefined;
+  output: undefined;
+  meta: unknown;
+};
+type BaseProcedure<T extends ProcedureType, I extends Schema | null = null, O extends Schema | null = null> = T extends `query` ? QueryProcedure<ProvedureDef<I, O>> : T extends `mutation` ? MutationProcedure<ProvedureDef<I, O>> : SubscriptionProcedure<ProvedureDef<I, O>>;
+/**
+ * Given a {@link Fetcher | Fetcher} function and it's associated input and
+ * output Zod schemas, this produces a function which accepts a tRPC procedure
+ * builder of the given procedure type. This can then be used in a tRPC router
+ * to scaffold an API route to forward a request to Discord's API.
+ *
+ * Capability-free fetchers only — endpoints that require `{ anonymous: true }`
+ * or accept `{ reason: string }` cannot currently be wrapped via this helper,
+ * because tRPC has no natural channel for those per-call options.
+ *
+ * @__NO_SIDE_EFFECTS__
+ */
+declare const toProcedure: <T extends ProcedureType, I extends Schema | null = null, O extends Schema | null = null>(type: T, fn: Fetcher<I extends Schema ? I : null, Result<O>>, input?: I, output?: O) => (procedure: AnyProcedureBuilder, errorHandler?: (error: unknown) => void) => BaseProcedure<T, I, O>;
+//#endregion
+export { toProcedure };

package/dist/requests/toProcedure.mjs

@@ -0,0 +1,27 @@
+import { isNonNullable } from "../utils/isNonNullable.mjs";
+//#region src/requests/toProcedure.ts
+/**
+* Given a {@link Fetcher | Fetcher} function and it's associated input and
+* output Zod schemas, this produces a function which accepts a tRPC procedure
+* builder of the given procedure type. This can then be used in a tRPC router
+* to scaffold an API route to forward a request to Discord's API.
+*
+* Capability-free fetchers only — endpoints that require `{ anonymous: true }`
+* or accept `{ reason: string }` cannot currently be wrapped via this helper,
+* because tRPC has no natural channel for those per-call options.
+*
+* @__NO_SIDE_EFFECTS__
+*/
+const toProcedure = (type, fn, input, output) => (procedure, errorHandler) => {
+	try {
+		if (isNonNullable(input) && isNonNullable(output)) return procedure.input(input).output(output)[type](async (opts) => fn(opts.input));
+		if (isNonNullable(input) && !isNonNullable(output)) return procedure.input(input)[type](async (opts) => fn(opts.input));
+		if (!isNonNullable(input) && isNonNullable(output)) return procedure.output(output)[type](async () => fn());
+		return procedure[type](async () => fn());
+	} catch (error) {
+		if (typeof errorHandler === `function`) errorHandler(error);
+		throw new Error(`Unhandled Procedure Error!`, { cause: error });
+	}
+};
+//#endregion
+export { toProcedure };

package/dist/requests/toQuery.d.mts

@@ -0,0 +1,36 @@
+import { Fetcher } from "./methods.mjs";
+import { GenericSchema } from "valibot";
+
+//#region src/requests/toQuery.d.ts
+interface Register {}
+type QueryKey = readonly unknown[];
+type QueryMeta = Register extends {
+  queryMeta: infer TQueryMeta;
+} ? TQueryMeta extends Record<string, unknown> ? TQueryMeta : Record<string, unknown> : Record<string, unknown>;
+type FetchDirection = `backward` | `forward`;
+type QueryFunctionContext<TQueryKey extends QueryKey = QueryKey, TPageParam = never> = [TPageParam] extends [never] ? {
+  queryKey: TQueryKey;
+  signal: AbortSignal;
+  meta: QueryMeta | undefined;
+} : {
+  queryKey: TQueryKey;
+  signal: AbortSignal;
+  pageParam: TPageParam;
+  direction: FetchDirection;
+  meta: QueryMeta | undefined;
+};
+type QueryFunction<T = unknown, TQueryKey extends QueryKey = QueryKey, TPageParam = never> = (context: QueryFunctionContext<TQueryKey, TPageParam>) => Promise<T> | T;
+/**
+ * Given a {@link Fetcher | Fetcher} function, transforms it into a curried function
+ * which can then be used with React-Query as a query function without
+ * the need for any additional boilerplate.
+ *
+ * Capability-free fetchers only — endpoints that require `{ anonymous: true }`
+ * or accept `{ reason: string }` cannot currently be wrapped via this helper,
+ * because react-query has no natural channel for those per-call options.
+ *
+ * @__NO_SIDE_EFFECTS__
+ */
+declare const toQuery: <S extends GenericSchema | null, R, T extends Fetcher<S, R>>(fn: T) => Parameters<T>[`length`] extends 0 ? () => QueryFunction<Awaited<ReturnType<T>>> : (config: Parameters<T>[0]) => QueryFunction<Awaited<ReturnType<T>>>;
+//#endregion
+export { QueryFunction, toQuery };

package/dist/requests/toQuery.mjs

@@ -0,0 +1,17 @@
+//#region src/requests/toQuery.ts
+/**
+* Given a {@link Fetcher | Fetcher} function, transforms it into a curried function
+* which can then be used with React-Query as a query function without
+* the need for any additional boilerplate.
+*
+* Capability-free fetchers only — endpoints that require `{ anonymous: true }`
+* or accept `{ reason: string }` cannot currently be wrapped via this helper,
+* because react-query has no natural channel for those per-call options.
+*
+* @__NO_SIDE_EFFECTS__
+*/
+const toQuery = (fn) => (...config) => async () => {
+	return fn(...config);
+};
+//#endregion
+export { toQuery };

package/dist/requests/toValidated.d.mts

@@ -0,0 +1,16 @@
+import { Fetcher, FetcherCapabilities } from "./methods.mjs";
+import { GenericSchema, GenericSchemaAsync } from "valibot";
+
+//#region src/requests/toValidated.d.ts
+/**
+ * Given a {@link Fetcher | Fetcher} function and it's associated input
+ * and output Zod schemas, this returns a new validated {@link Fetcher | Fetcher} function which will validate it's input and result at runtime.
+ * This is useful in contexts where you want strong guarantees on runtime
+ * type-safety when dealing with raw user input in a framework agnostic
+ * environment.
+ *
+ * @__NO_SIDE_EFFECTS__
+ */
+declare const toValidated: <S extends GenericSchema | GenericSchemaAsync | null = null, R = void, C extends FetcherCapabilities = {}>(fn: Fetcher<S, R, C>, input?: S | null, output?: GenericSchema<unknown, R> | GenericSchemaAsync<unknown, R>) => Fetcher<S, R, C>;
+//#endregion
+export { toValidated };

package/dist/requests/toValidated.mjs

@@ -0,0 +1,25 @@
+import { isOfKind, safeParseAsync, summarize } from "valibot";
+//#region src/requests/toValidated.ts
+/**
+* Given a {@link Fetcher | Fetcher} function and it's associated input
+* and output Zod schemas, this returns a new validated {@link Fetcher | Fetcher} function which will validate it's input and result at runtime.
+* This is useful in contexts where you want strong guarantees on runtime
+* type-safety when dealing with raw user input in a framework agnostic
+* environment.
+*
+* @__NO_SIDE_EFFECTS__
+*/
+const toValidated = (fn, input, output) => new Proxy(fn, { async apply(target, _, [config, options]) {
+	if (input && isOfKind(`schema`, input)) {
+		const { issues } = await safeParseAsync(input, config);
+		if (issues) throw new Error(`Failed to parse input schema: ${input.reference.name}\n\n${summarize(issues)}`);
+	}
+	const result = await target(config, options);
+	if (output && isOfKind(`schema`, output)) {
+		const { issues } = await safeParseAsync(output, result);
+		if (issues) throw new Error(`Failed to parse input schema: ${output.reference.name}\n\n${summarize(issues)}`);
+	}
+	return result;
+} });
+//#endregion
+export { toValidated };

package/dist/requests/verifyKey.d.mts

@@ -0,0 +1,13 @@
+//#region src/requests/verifyKey.d.ts
+/**
+ * Validates a payload from Discord against its signature and key.
+ *
+ * @param rawBody - The raw payload data
+ * @param signature - The signature from the `X-Signature-Ed25519` header
+ * @param timestamp - The timestamp from the `X-Signature-Timestamp` header
+ * @param clientPublicKey - The public key from the Discord developer dashboard
+ * @returns Whether or not validation was successful
+ */
+declare function verifyKey(rawBody: Uint8Array | ArrayBuffer | Buffer | string, signature: string, timestamp: string, clientPublicKey: string | CryptoKey): Promise<boolean>;
+//#endregion
+export { verifyKey };