@discordkit/core 3.2.0 → 4.0.1

package/dist/requests/toProcedure.d.mts

@@ -0,0 +1,41 @@
+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 };
+//# sourceMappingURL=toProcedure.d.mts.map

package/dist/requests/toProcedure.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toProcedure.d.mts","names":[],"sources":["../../src/requests/toProcedure.ts"],"mappings":";;;;;KAWK,MAAA,aAAmB,CAAA,SAAU,CAAA,CAAE,aAAA,GAAgB,CAAA,CAAE,kBAAA,GAClD,CAAA,CAAE,WAAA,CAAY,CAAA,IACd,CAAA;AAAA,KAEC,MAAA,GAAS,CAAA,CAAE,aAAA,GAAgB,CAAA,CAAE,kBAAkB;AAAA,KAE/C,YAAA,WACO,MAAA,0BACA,MAAA,kBACR,CAAA,SAAU,MAAA,GACV,CAAA,SAAU,MAAA;EAEN,KAAA,EAAO,CAAA,CAAE,UAAA,CAAW,CAAA;EACpB,MAAA,EAAQ,CAAA,CAAE,WAAA,CAAY,CAAA;EACtB,IAAA;AAAA;EAEA,KAAA,EAAO,CAAA,CAAE,UAAA,CAAW,CAAA;EAAI,MAAA;EAAmB,IAAA;AAAA,IAC/C,CAAA,SAAU,MAAA;EACN,KAAA;EAAkB,MAAA,EAAQ,CAAA,CAAE,WAAA,CAAY,CAAA;EAAI,IAAA;AAAA;EAE5C,KAAA;EACA,MAAA;EACA,IAAA;AAAA;AAAA,KAGH,aAAA,WACO,aAAA,YACA,MAAA,0BACA,MAAA,kBACR,CAAA,mBACA,cAAA,CAAe,YAAA,CAAa,CAAA,EAAG,CAAA,KAC/B,CAAA,sBACE,iBAAA,CAAkB,YAAA,CAAa,CAAA,EAAG,CAAA,KAClC,qBAAA,CAAsB,YAAA,CAAa,CAAA,EAAG,CAAA;;;;;AA/BvC;AAAA;;;;;;;cA6CQ,WAAA,aAEC,aAAA,YACA,MAAA,0BACA,MAAA,gBAEV,IAAA,EAAM,CAAA,EACN,EAAA,EAAI,OAAA,CAAQ,CAAA,SAAU,MAAA,GAAS,CAAA,SAAU,MAAA,CAAO,CAAA,IAChD,KAAA,GAAQ,CAAA,EACR,MAAA,GAAS,CAAA,MAGT,SAAA,EAAW,mBAAA,EACX,YAAA,IAAgB,KAAA,uBACf,aAAA,CAAc,CAAA,EAAG,CAAA,EAAG,CAAA"}

package/dist/requests/toProcedure.mjs

@@ -0,0 +1,29 @@
+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 };
+
+//# sourceMappingURL=toProcedure.mjs.map

package/dist/requests/toProcedure.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"toProcedure.mjs","names":[],"sources":["../../src/requests/toProcedure.ts"],"sourcesContent":["import type * as v from \"valibot\";\nimport type {\n  AnyProcedureBuilder,\n  MutationProcedure,\n  ProcedureType,\n  QueryProcedure,\n  SubscriptionProcedure\n} from \"@trpc/server/unstable-core-do-not-import\";\nimport { isNonNullable } from \"../utils/isNonNullable.js\";\nimport type { Fetcher } from \"./methods.js\";\n\ntype Result<T = void> = T extends v.GenericSchema | v.GenericSchemaAsync\n  ? v.InferOutput<T>\n  : T;\n\ntype Schema = v.GenericSchema | v.GenericSchemaAsync;\n\ntype ProvedureDef<\n  I extends Schema | null = null,\n  O extends Schema | null = null\n> = I extends Schema\n  ? O extends Schema\n    ? {\n        input: v.InferInput<I>;\n        output: v.InferOutput<O>;\n        meta: unknown;\n      }\n    : { input: v.InferInput<I>; output: undefined; meta: unknown }\n  : O extends Schema\n    ? { input: undefined; output: v.InferOutput<O>; meta: unknown }\n    : {\n        input: undefined;\n        output: undefined;\n        meta: unknown;\n      };\n\ntype BaseProcedure<\n  T extends ProcedureType,\n  I extends Schema | null = null,\n  O extends Schema | null = null\n> = T extends `query`\n  ? QueryProcedure<ProvedureDef<I, O>>\n  : T extends `mutation`\n    ? MutationProcedure<ProvedureDef<I, O>>\n    : SubscriptionProcedure<ProvedureDef<I, O>>;\n\n/**\n * Given a {@link Fetcher | Fetcher} function and it's associated input and\n * output Zod schemas, this produces a function which accepts a tRPC procedure\n * builder of the given procedure type. This can then be used in a tRPC router\n * to scaffold an API route to forward a request to Discord's API.\n *\n * Capability-free fetchers only — endpoints that require `{ anonymous: true }`\n * or accept `{ reason: string }` cannot currently be wrapped via this helper,\n * because tRPC has no natural channel for those per-call options.\n *\n * @__NO_SIDE_EFFECTS__\n */\nexport const toProcedure =\n  <\n    T extends ProcedureType,\n    I extends Schema | null = null,\n    O extends Schema | null = null\n  >(\n    type: T,\n    fn: Fetcher<I extends Schema ? I : null, Result<O>>,\n    input?: I,\n    output?: O\n  ) =>\n  (\n    procedure: AnyProcedureBuilder,\n    errorHandler?: (error: unknown) => void\n  ): BaseProcedure<T, I, O> => {\n    try {\n      if (isNonNullable(input) && isNonNullable(output)) {\n        // @ts-expect-error\n        return procedure\n          .input(input)\n          .output(output)\n          [type](\n            // oxlint-disable-next-line @typescript-eslint/no-unsafe-argument\n            async (opts: { input: unknown }) => fn(opts.input as never)\n          );\n      }\n      if (isNonNullable(input) && !isNonNullable(output)) {\n        // @ts-expect-error\n        return procedure.input(input)[type](\n          // oxlint-disable-next-line @typescript-eslint/no-unsafe-argument\n          async (opts: { input: unknown }) => fn(opts.input as never)\n        );\n      }\n      if (!isNonNullable(input) && isNonNullable(output)) {\n        // @ts-expect-error\n        return procedure\n          .output(output)\n          [type](async () => (fn as () => Promise<Result<O>>)());\n      }\n      // @ts-expect-error\n      return procedure[type](async () => (fn as () => Promise<Result<O>>)());\n    } catch (error: unknown) {\n      if (typeof errorHandler === `function`) {\n        errorHandler(error);\n      }\n      throw new Error(`Unhandled Procedure Error!`, {\n        cause: error\n      });\n    }\n  };\n"],"mappings":";;;;;;;;;;;;;;AA0DA,MAAa,eAMT,MACA,IACA,OACA,YAGA,WACA,iBAC2B;CAC3B,IAAI;EACF,IAAI,cAAc,KAAK,KAAK,cAAc,MAAM,GAE9C,OAAO,UACJ,MAAM,KAAK,EACX,OAAO,MAAM,EACb,MAEC,OAAO,SAA6B,GAAG,KAAK,KAAc,CAC5D;EAEJ,IAAI,cAAc,KAAK,KAAK,CAAC,cAAc,MAAM,GAE/C,OAAO,UAAU,MAAM,KAAK,EAAE,MAE5B,OAAO,SAA6B,GAAG,KAAK,KAAc,CAC5D;EAEF,IAAI,CAAC,cAAc,KAAK,KAAK,cAAc,MAAM,GAE/C,OAAO,UACJ,OAAO,MAAM,EACb,MAAM,YAAa,GAAgC,CAAC;EAGzD,OAAO,UAAU,MAAM,YAAa,GAAgC,CAAC;CACvE,SAAS,OAAgB;EACvB,IAAI,OAAO,iBAAiB,YAC1B,aAAa,KAAK;EAEpB,MAAM,IAAI,MAAM,8BAA8B,EAC5C,OAAO,MACT,CAAC;CACH;AACF"}

package/dist/requests/toQuery.d.mts

@@ -0,0 +1,37 @@
+import { Fetcher } from "./methods.mjs";
+
+//#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 function toQuery<R>(fn: Fetcher<null, R>): () => QueryFunction<R>;
+declare function toQuery<TConfig, R>(fn: (config: TConfig, options?: never) => Promise<R>): (config: TConfig) => QueryFunction<R>;
+//#endregion
+export { QueryFunction, toQuery };
+//# sourceMappingURL=toQuery.d.mts.map

package/dist/requests/toQuery.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toQuery.d.mts","names":[],"sources":["../../src/requests/toQuery.ts"],"mappings":";;;UAMU,QAAA;AAAA,KACL,QAAA;AAAA,KACA,SAAA,GAAY,QAAA;EACf,SAAA;AAAA,IAEE,UAAA,SAAmB,MAAA,oBACjB,UAAA,GACA,MAAA,oBACF,MAAA;AAAA,KACC,cAAA;AAAA,KACA,oBAAA,mBACe,QAAA,GAAW,QAAA,yBAE1B,UAAA;EAEC,QAAA,EAAU,SAAA;EACV,MAAA,EAAQ,WAAA;EACR,IAAA,EAAM,SAAA;AAAA;EAGN,QAAA,EAAU,SAAA;EACV,MAAA,EAAQ,WAAA;EACR,SAAA,EAAW,UAAA;EACX,SAAA,EAAW,cAAA;EACX,IAAA,EAAM,SAAA;AAAA;AAAA,KAEA,aAAA,gCAEQ,QAAA,GAAW,QAAA,yBAE1B,OAAA,EAAS,oBAAA,CAAqB,SAAA,EAAW,UAAA,MAAgB,OAAA,CAAQ,CAAA,IAAK,CAAA;;;;;;;;;;;;iBA4B3D,OAAA,IAAW,EAAA,EAAI,OAAA,OAAc,CAAA,UAAW,aAAA,CAAc,CAAA;AAAA,iBACtD,OAAA,aACd,EAAA,GAAK,MAAA,EAAQ,OAAA,EAAS,OAAA,aAAoB,OAAA,CAAQ,CAAA,KAChD,MAAA,EAAQ,OAAA,KAAY,aAAA,CAAc,CAAA"}

package/dist/requests/toQuery.mjs

@@ -0,0 +1,10 @@
+//#region src/requests/toQuery.ts
+function toQuery(fn) {
+	return (...config) => async () => {
+		return fn(...config);
+	};
+}
+//#endregion
+export { toQuery };
+
+//# sourceMappingURL=toQuery.mjs.map

package/dist/requests/toQuery.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"toQuery.mjs","names":["call"],"sources":["../../src/requests/toQuery.ts"],"sourcesContent":["import type { Fetcher } from \"./methods.js\";\n\n/* Lifted from @tanstack/react-query */\n// Intentional declaration-merging surface: consumers extend `Register`\n// to override `queryMeta` and other framework-wide types.\n// oxlint-disable-next-line typescript/no-empty-object-type\ninterface Register {}\ntype QueryKey = readonly unknown[];\ntype QueryMeta = Register extends {\n  queryMeta: infer TQueryMeta;\n}\n  ? TQueryMeta extends Record<string, unknown>\n    ? TQueryMeta\n    : Record<string, unknown>\n  : Record<string, unknown>;\ntype FetchDirection = `backward` | `forward`;\ntype QueryFunctionContext<\n  TQueryKey extends QueryKey = QueryKey,\n  TPageParam = never\n> = [TPageParam] extends [never]\n  ? {\n      queryKey: TQueryKey;\n      signal: AbortSignal;\n      meta: QueryMeta | undefined;\n    }\n  : {\n      queryKey: TQueryKey;\n      signal: AbortSignal;\n      pageParam: TPageParam;\n      direction: FetchDirection;\n      meta: QueryMeta | undefined;\n    };\nexport type QueryFunction<\n  T = unknown,\n  TQueryKey extends QueryKey = QueryKey,\n  TPageParam = never\n> = (context: QueryFunctionContext<TQueryKey, TPageParam>) => Promise<T> | T;\n\n/**\n * Given a {@link Fetcher | Fetcher} function, transforms it into a curried function\n * which can then be used with React-Query as a query function without\n * the need for any additional boilerplate.\n *\n * Capability-free fetchers only — endpoints that require `{ anonymous: true }`\n * or accept `{ reason: string }` cannot currently be wrapped via this helper,\n * because react-query has no natural channel for those per-call options.\n *\n * @__NO_SIDE_EFFECTS__\n */\n// Two overloads disambiguate the no-input vs input-accepting Fetcher\n// shapes. Under strict mode, a single signature with a conditional return\n// type forces TS to check the argument against the union of both branches\n// at the call site, which fails on contravariant param positions.\n// Overloads let inference pick one branch at a time.\n//\n// The second overload uses a structural shape `(config: TConfig, options?:\n// unknown) => Promise<R>` rather than `Fetcher<S, R>` so TS can infer\n// `TConfig` directly from the supplied callback's first parameter — going\n// through `Fetcher<S, R>` would require TS to first invert the conditional\n// type `S extends null ? ... : ...` to recover `S`, which it gives up on.\n// The runtime check is unchanged (the implementation casts internally), so\n// the looser structural type doesn't widen what consumers can pass in any\n// meaningful way — every endpoint Fetcher in the codebase is shaped this\n// way already.\nexport function toQuery<R>(fn: Fetcher<null, R>): () => QueryFunction<R>;\nexport function toQuery<TConfig, R>(\n  fn: (config: TConfig, options?: never) => Promise<R>\n): (config: TConfig) => QueryFunction<R>;\nexport function toQuery<R>(\n  fn: (...args: never[]) => Promise<R>\n): (...config: [unknown]) => QueryFunction<R> {\n  return (...config: [unknown]) =>\n    async () => {\n      const call = fn as unknown as (...args: unknown[]) => Promise<R>;\n      return call(...config);\n    };\n}\n"],"mappings":";AAoEA,SAAgB,QACd,IAC4C;CAC5C,QAAQ,GAAG,WACT,YAAY;EAEV,OAAOA,GAAK,GAAG,MAAM;CACvB;AACJ"}

package/dist/requests/toValidated.d.mts

@@ -0,0 +1,17 @@
+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 };
+//# sourceMappingURL=toValidated.d.mts.map

package/dist/requests/toValidated.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toValidated.d.mts","names":[],"sources":["../../src/requests/toValidated.ts"],"mappings":";;;;;;AAkBA;;;;;;;cAAa,WAAA,aACD,aAAA,GAAgB,kBAAA,oCAGhB,mBAAA,OAEV,EAAA,EAAI,OAAA,CAAQ,CAAA,EAAG,CAAA,EAAG,CAAA,GAClB,KAAA,GAAQ,CAAA,SACR,MAAA,GAAS,aAAA,UAAuB,CAAA,IAAK,kBAAA,UAA4B,CAAA,MAChE,OAAA,CAAQ,CAAA,EAAG,CAAA,EAAG,CAAA"}

package/dist/requests/toValidated.mjs

@@ -0,0 +1,27 @@
+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 };
+
+//# sourceMappingURL=toValidated.mjs.map

package/dist/requests/toValidated.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"toValidated.mjs","names":["call"],"sources":["../../src/requests/toValidated.ts"],"sourcesContent":["import {\n  type GenericSchema,\n  type GenericSchemaAsync,\n  isOfKind,\n  safeParseAsync,\n  summarize\n} from \"valibot\";\nimport type { Fetcher, FetcherCapabilities } from \"./methods.js\";\n\n/**\n * Given a {@link Fetcher | Fetcher} function and it's associated input\n * and output Zod schemas, this returns a new validated {@link Fetcher | Fetcher} function which will validate it's input and result at runtime.\n * This is useful in contexts where you want strong guarantees on runtime\n * type-safety when dealing with raw user input in a framework agnostic\n * environment.\n *\n * @__NO_SIDE_EFFECTS__\n */\nexport const toValidated = <\n  S extends GenericSchema | GenericSchemaAsync | null = null,\n  R = void,\n  // oxlint-disable-next-line typescript/no-empty-object-type\n  C extends FetcherCapabilities = {}\n>(\n  fn: Fetcher<S, R, C>,\n  input?: S | null,\n  output?: GenericSchema<unknown, R> | GenericSchemaAsync<unknown, R>\n): Fetcher<S, R, C> =>\n  new Proxy<Fetcher<S, R, C>>(fn, {\n    async apply(target, _, [config, options]): Promise<R> {\n      // Validate the fetcher args before fetching\n      if (input && isOfKind(`schema`, input)) {\n        const { issues } = await safeParseAsync(input, config);\n        if (issues) {\n          throw new Error(\n            `Failed to parse input schema: ${input.reference.name}\\n\\n${summarize(issues)}`\n          );\n        }\n      }\n\n      // Forward the per-call options (anonymous, reason) to the underlying\n      // fetcher. The proxy was previously dropping the second argument.\n      const call = target as unknown as (\n        ...args: unknown[]\n      ) => Promise<unknown>;\n      const result = (await call(config, options)) as R;\n\n      // Validate the result of the fetch call before returning\n      if (output && isOfKind(`schema`, output)) {\n        const { issues } = await safeParseAsync(output, result);\n        if (issues) {\n          throw new Error(\n            `Failed to parse input schema: ${output.reference.name}\\n\\n${summarize(issues)}`\n          );\n        }\n      }\n\n      return result;\n    }\n  });\n"],"mappings":";;;;;;;;;;;AAkBA,MAAa,eAMX,IACA,OACA,WAEA,IAAI,MAAwB,IAAI,EAC9B,MAAM,MAAM,QAAQ,GAAG,CAAC,QAAQ,UAAsB;CAEpD,IAAI,SAAS,SAAS,UAAU,KAAK,GAAG;EACtC,MAAM,EAAE,WAAW,MAAM,eAAe,OAAO,MAAM;EACrD,IAAI,QACF,MAAM,IAAI,MACR,iCAAiC,MAAM,UAAU,KAAK,MAAM,UAAU,MAAM,GAC9E;CAEJ;CAOA,MAAM,SAAU,MAAMA,OAAK,QAAQ,OAAO;CAG1C,IAAI,UAAU,SAAS,UAAU,MAAM,GAAG;EACxC,MAAM,EAAE,WAAW,MAAM,eAAe,QAAQ,MAAM;EACtD,IAAI,QACF,MAAM,IAAI,MACR,iCAAiC,OAAO,UAAU,KAAK,MAAM,UAAU,MAAM,GAC/E;CAEJ;CAEA,OAAO;AACT,EACF,CAAC"}

package/dist/requests/{verifyKey.d.ts → verifyKey.d.mts}

@@ -1,3 +1,4 @@
+//#region src/requests/verifyKey.d.ts
 /**
  * Validates a payload from Discord against its signature and key.
  *
@@ -7,4 +8,7 @@
  * @param clientPublicKey - The public key from the Discord developer dashboard
  * @returns Whether or not validation was successful
  */
-export declare function verifyKey(rawBody: Uint8Array | ArrayBuffer | Buffer | string, signature: string, timestamp: string, clientPublicKey: string | CryptoKey): Promise<boolean>;
+declare function verifyKey(rawBody: Uint8Array | ArrayBuffer | Buffer | string, signature: string, timestamp: string, clientPublicKey: string | CryptoKey): Promise<boolean>;
+//#endregion
+export { verifyKey };
+//# sourceMappingURL=verifyKey.d.mts.map

package/dist/requests/verifyKey.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"verifyKey.d.mts","names":[],"sources":["../../src/requests/verifyKey.ts"],"mappings":";;AAqGA;;;;;;;;iBAAsB,SAAA,CACpB,OAAA,EAAS,UAAA,GAAa,WAAA,GAAc,MAAA,WACpC,SAAA,UACA,SAAA,UACA,eAAA,WAA0B,SAAA,GACzB,OAAA"}

package/dist/requests/verifyKey.mjs

@@ -0,0 +1,64 @@
+//#region src/requests/verifyKey.ts
+const getSubtleCrypto = () => {
+	if (typeof globalThis.crypto !== `undefined`) return globalThis.crypto.subtle;
+	const maybeGlobal = typeof global !== `undefined` ? global : void 0;
+	if (maybeGlobal?.crypto?.subtle) return maybeGlobal.crypto.subtle;
+	const maybeWindow = typeof window !== `undefined` ? window : void 0;
+	if (maybeWindow?.crypto?.subtle) return maybeWindow.crypto.subtle;
+	throw new Error(`SubtleCrypto is not available in this environment`);
+};
+const subtleCrypto = getSubtleCrypto();
+/**
+* Convert various input types to Uint8Array
+*/
+function valueToUint8Array(value, encoding) {
+	if (value instanceof Uint8Array) return value;
+	if (value instanceof ArrayBuffer) return new Uint8Array(value);
+	if (typeof Buffer !== `undefined` && Buffer.isBuffer(value)) return new Uint8Array(value);
+	if (typeof value === `string`) {
+		if (encoding === `hex`) {
+			const matches = value.match(/.{1,2}/g);
+			if (!matches) throw new Error(`Invalid hex string`);
+			return new Uint8Array(matches.map((byte) => parseInt(byte, 16)));
+		}
+		return new TextEncoder().encode(value);
+	}
+	throw new Error(`Unsupported value type`);
+}
+/**
+* Concatenate multiple Uint8Arrays into a single Uint8Array
+*/
+function concatUint8Arrays(...arrays) {
+	const totalLength = arrays.reduce((sum, arr) => sum + arr.length, 0);
+	const result = new Uint8Array(totalLength);
+	let offset = 0;
+	for (const arr of arrays) {
+		result.set(arr, offset);
+		offset += arr.length;
+	}
+	return result;
+}
+/**
+* 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
+*/
+async function verifyKey(rawBody, signature, timestamp, clientPublicKey) {
+	try {
+		return await subtleCrypto.verify({ name: `ed25519` }, typeof clientPublicKey === `string` ? await subtleCrypto.importKey(`raw`, Buffer.from(valueToUint8Array(clientPublicKey, `hex`)), {
+			name: `ed25519`,
+			namedCurve: `ed25519`
+		}, false, [`verify`]) : clientPublicKey, Buffer.from(valueToUint8Array(signature, `hex`)), Buffer.from(concatUint8Arrays(valueToUint8Array(timestamp), valueToUint8Array(rawBody))));
+	} catch (err) {
+		console.error(`Signature verification failed:`, err);
+		return false;
+	}
+}
+//#endregion
+export { verifyKey };
+
+//# sourceMappingURL=verifyKey.mjs.map

package/dist/requests/verifyKey.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"verifyKey.mjs","names":[],"sources":["../../src/requests/verifyKey.ts"],"sourcesContent":["/**\n * Get the SubtleCrypto interface for the current environment.\n * Modern Node and browsers both expose `globalThis.crypto.subtle`;\n * the older Node fallback and the browser-specific `window.crypto`\n * branches handle environments where that's not the case.\n */\ninterface MaybeCrypto {\n  crypto?: { subtle?: SubtleCrypto };\n}\n\nconst getSubtleCrypto = (): SubtleCrypto => {\n  // Modern Node.js / browsers / workers\n  if (typeof globalThis.crypto !== `undefined`) {\n    return globalThis.crypto.subtle;\n  }\n\n  // Older Node.js versions where `crypto` lives on `global`, not `globalThis`.\n  const maybeGlobal: MaybeCrypto | undefined =\n    typeof global !== `undefined` ? (global as MaybeCrypto) : undefined;\n  if (maybeGlobal?.crypto?.subtle) {\n    return maybeGlobal.crypto.subtle;\n  }\n\n  // Browser environment where `window.crypto` is the only path.\n  const maybeWindow: MaybeCrypto | undefined =\n    typeof window !== `undefined` ? (window as MaybeCrypto) : undefined;\n  if (maybeWindow?.crypto?.subtle) {\n    return maybeWindow.crypto.subtle;\n  }\n\n  throw new Error(`SubtleCrypto is not available in this environment`);\n};\n\nconst subtleCrypto = getSubtleCrypto();\n\n/**\n * Convert various input types to Uint8Array\n */\nfunction valueToUint8Array(\n  value: Uint8Array | ArrayBuffer | Buffer | string,\n  encoding?: `hex` | `utf-8`\n): Uint8Array {\n  // Already a Uint8Array\n  if (value instanceof Uint8Array) {\n    return value;\n  }\n\n  // ArrayBuffer\n  if (value instanceof ArrayBuffer) {\n    return new Uint8Array(value);\n  }\n\n  // Buffer (Node.js)\n  if (typeof Buffer !== `undefined` && Buffer.isBuffer(value)) {\n    return new Uint8Array(value);\n  }\n\n  // String\n  if (typeof value === `string`) {\n    if (encoding === `hex`) {\n      // Convert hex string to Uint8Array\n      const matches = value.match(/.{1,2}/g);\n      if (!matches) {\n        throw new Error(`Invalid hex string`);\n      }\n      return new Uint8Array(matches.map((byte) => parseInt(byte, 16)));\n    }\n\n    // Default to UTF-8 encoding\n    const encoder = new TextEncoder();\n    return encoder.encode(value);\n  }\n\n  throw new Error(`Unsupported value type`);\n}\n\n/**\n * Concatenate multiple Uint8Arrays into a single Uint8Array\n */\nfunction concatUint8Arrays(...arrays: Uint8Array[]): Uint8Array {\n  const totalLength = arrays.reduce((sum, arr) => sum + arr.length, 0);\n  const result = new Uint8Array(totalLength);\n\n  let offset = 0;\n  for (const arr of arrays) {\n    result.set(arr, offset);\n    offset += arr.length;\n  }\n\n  return result;\n}\n\n/**\n * Validates a payload from Discord against its signature and key.\n *\n * @param rawBody - The raw payload data\n * @param signature - The signature from the `X-Signature-Ed25519` header\n * @param timestamp - The timestamp from the `X-Signature-Timestamp` header\n * @param clientPublicKey - The public key from the Discord developer dashboard\n * @returns Whether or not validation was successful\n */\nexport async function verifyKey(\n  rawBody: Uint8Array | ArrayBuffer | Buffer | string,\n  signature: string,\n  timestamp: string,\n  clientPublicKey: string | CryptoKey\n): Promise<boolean> {\n  try {\n    return await subtleCrypto.verify(\n      {\n        name: `ed25519`\n      } as AlgorithmIdentifier,\n      typeof clientPublicKey === `string`\n        ? await subtleCrypto.importKey(\n            `raw`,\n            Buffer.from(valueToUint8Array(clientPublicKey, `hex`)),\n            {\n              name: `ed25519`,\n              namedCurve: `ed25519`\n            } as EcKeyImportParams, // Type assertion for Ed25519\n            false,\n            [`verify`]\n          )\n        : clientPublicKey,\n      Buffer.from(valueToUint8Array(signature, `hex`)),\n      Buffer.from(\n        concatUint8Arrays(\n          valueToUint8Array(timestamp),\n          valueToUint8Array(rawBody)\n        )\n      )\n    );\n  } catch (err) {\n    console.error(`Signature verification failed:`, err);\n    return false;\n  }\n}\n"],"mappings":";AAUA,MAAM,wBAAsC;CAE1C,IAAI,OAAO,WAAW,WAAW,aAC/B,OAAO,WAAW,OAAO;CAI3B,MAAM,cACJ,OAAO,WAAW,cAAe,SAAyB,KAAA;CAC5D,IAAI,aAAa,QAAQ,QACvB,OAAO,YAAY,OAAO;CAI5B,MAAM,cACJ,OAAO,WAAW,cAAe,SAAyB,KAAA;CAC5D,IAAI,aAAa,QAAQ,QACvB,OAAO,YAAY,OAAO;CAG5B,MAAM,IAAI,MAAM,mDAAmD;AACrE;AAEA,MAAM,eAAe,gBAAgB;;;;AAKrC,SAAS,kBACP,OACA,UACY;CAEZ,IAAI,iBAAiB,YACnB,OAAO;CAIT,IAAI,iBAAiB,aACnB,OAAO,IAAI,WAAW,KAAK;CAI7B,IAAI,OAAO,WAAW,eAAe,OAAO,SAAS,KAAK,GACxD,OAAO,IAAI,WAAW,KAAK;CAI7B,IAAI,OAAO,UAAU,UAAU;EAC7B,IAAI,aAAa,OAAO;GAEtB,MAAM,UAAU,MAAM,MAAM,SAAS;GACrC,IAAI,CAAC,SACH,MAAM,IAAI,MAAM,oBAAoB;GAEtC,OAAO,IAAI,WAAW,QAAQ,KAAK,SAAS,SAAS,MAAM,EAAE,CAAC,CAAC;EACjE;EAIA,OAAO,IADa,YACP,EAAE,OAAO,KAAK;CAC7B;CAEA,MAAM,IAAI,MAAM,wBAAwB;AAC1C;;;;AAKA,SAAS,kBAAkB,GAAG,QAAkC;CAC9D,MAAM,cAAc,OAAO,QAAQ,KAAK,QAAQ,MAAM,IAAI,QAAQ,CAAC;CACnE,MAAM,SAAS,IAAI,WAAW,WAAW;CAEzC,IAAI,SAAS;CACb,KAAK,MAAM,OAAO,QAAQ;EACxB,OAAO,IAAI,KAAK,MAAM;EACtB,UAAU,IAAI;CAChB;CAEA,OAAO;AACT;;;;;;;;;;AAWA,eAAsB,UACpB,SACA,WACA,WACA,iBACkB;CAClB,IAAI;EACF,OAAO,MAAM,aAAa,OACxB,EACE,MAAM,UACR,GACA,OAAO,oBAAoB,WACvB,MAAM,aAAa,UACjB,OACA,OAAO,KAAK,kBAAkB,iBAAiB,KAAK,CAAC,GACrD;GACE,MAAM;GACN,YAAY;EACd,GACA,OACA,CAAC,QAAQ,CACX,IACA,iBACJ,OAAO,KAAK,kBAAkB,WAAW,KAAK,CAAC,GAC/C,OAAO,KACL,kBACE,kBAAkB,SAAS,GAC3B,kBAAkB,OAAO,CAC3B,CACF,CACF;CACF,SAAS,KAAK;EACZ,QAAQ,MAAM,kCAAkC,GAAG;EACnD,OAAO;CACT;AACF"}

package/dist/utils/isBetween.d.mts

@@ -0,0 +1,5 @@
+//#region src/utils/isBetween.d.ts
+declare const isBetween: (val: number, min: number, max: number) => boolean;
+//#endregion
+export { isBetween };
+//# sourceMappingURL=isBetween.d.mts.map

package/dist/utils/isBetween.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isBetween.d.mts","names":[],"sources":["../../src/utils/isBetween.ts"],"mappings":";cAAa,SAAA,GAAa,GAAA,UAAa,GAAA,UAAa,GAAA"}

package/dist/utils/isBetween.mjs

@@ -0,0 +1,6 @@
+//#region src/utils/isBetween.ts
+const isBetween = (val, min, max) => val >= min && val <= max;
+//#endregion
+export { isBetween };
+
+//# sourceMappingURL=isBetween.mjs.map

package/dist/utils/isBetween.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"isBetween.mjs","names":[],"sources":["../../src/utils/isBetween.ts"],"sourcesContent":["export const isBetween = (val: number, min: number, max: number): boolean =>\n  val >= min && val <= max;\n"],"mappings":";AAAA,MAAa,aAAa,KAAa,KAAa,QAClD,OAAO,OAAO,OAAO"}

package/dist/utils/{isNonNullable.js → isNonNullable.d.mts}

@@ -1,3 +1,5 @@
+//#region src/utils/isNonNullable.d.ts
+type Maybe<T> = T | null | undefined;
 /**
  * Used to test whether a `Maybe` typed value is `null` or `undefined`.
  *
@@ -16,5 +18,7 @@
  * }
  * ```
  */
-export const isNonNullable = (val) => typeof val !== `undefined` && val !== null;
-//# sourceMappingURL=isNonNullable.js.map
+declare const isNonNullable: <T extends Maybe<unknown>>(val?: T) => val is NonNullable<T>;
+//#endregion
+export { Maybe, isNonNullable };
+//# sourceMappingURL=isNonNullable.d.mts.map

package/dist/utils/isNonNullable.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isNonNullable.d.mts","names":[],"sources":["../../src/utils/isNonNullable.ts"],"mappings":";KAAY,KAAA,MAAW,CAAC;AAAxB;;;;AAAwB;AAoBxB;;;;;;;;;;;;;AApBA,cAoBa,aAAA,aAA2B,KAAA,WACtC,GAAA,GAAM,CAAA,KACL,GAAA,IAAO,WAAA,CAAY,CAAA"}

package/dist/utils/isNonNullable.mjs

@@ -0,0 +1,24 @@
+//#region src/utils/isNonNullable.ts
+/**
+* Used to test whether a `Maybe` typed value is `null` or `undefined`.
+*
+* When called, the given value's type is narrowed to `NonNullable<T>`.
+*
+* ### Example Usage:
+*
+* ```ts
+* const fn = (str: Maybe<string>) => {
+*   if (!isNonNullable(str)) {
+*     // typeof str = null | undefined
+*     // ...
+*   }
+*   // typeof str = string
+*   // ...
+* }
+* ```
+*/
+const isNonNullable = (val) => typeof val !== `undefined` && val !== null;
+//#endregion
+export { isNonNullable };
+
+//# sourceMappingURL=isNonNullable.mjs.map

package/dist/utils/isNonNullable.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"isNonNullable.mjs","names":[],"sources":["../../src/utils/isNonNullable.ts"],"sourcesContent":["export type Maybe<T> = T | null | undefined;\n\n/**\n * Used to test whether a `Maybe` typed value is `null` or `undefined`.\n *\n * When called, the given value's type is narrowed to `NonNullable<T>`.\n *\n * ### Example Usage:\n *\n * ```ts\n * const fn = (str: Maybe<string>) => {\n *   if (!isNonNullable(str)) {\n *     // typeof str = null | undefined\n *     // ...\n *   }\n *   // typeof str = string\n *   // ...\n * }\n * ```\n */\nexport const isNonNullable = <T extends Maybe<unknown>>(\n  val?: T\n): val is NonNullable<T> => typeof val !== `undefined` && val !== null;\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAoBA,MAAa,iBACX,QAC0B,OAAO,QAAQ,eAAe,QAAQ"}

package/dist/utils/isNumericString.d.mts

@@ -0,0 +1,5 @@
+//#region src/utils/isNumericString.d.ts
+declare const isNumericString: (val: unknown) => val is string;
+//#endregion
+export { isNumericString };
+//# sourceMappingURL=isNumericString.d.mts.map

package/dist/utils/isNumericString.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isNumericString.d.mts","names":[],"sources":["../../src/utils/isNumericString.ts"],"mappings":";cAAa,eAAA,GAAmB,GAAA,cAAe,GAAG"}

package/dist/utils/isNumericString.mjs

@@ -0,0 +1,6 @@
+//#region src/utils/isNumericString.ts
+const isNumericString = (val) => typeof val === `string` && /^\d+$/.test(val);
+//#endregion
+export { isNumericString };
+
+//# sourceMappingURL=isNumericString.mjs.map

package/dist/utils/isNumericString.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"isNumericString.mjs","names":[],"sources":["../../src/utils/isNumericString.ts"],"sourcesContent":["export const isNumericString = (val: unknown): val is string =>\n  typeof val === `string` && /^\\d+$/.test(val);\n"],"mappings":";AAAA,MAAa,mBAAmB,QAC9B,OAAO,QAAQ,YAAY,QAAQ,KAAK,GAAG"}

package/dist/utils/isObject.d.mts

@@ -0,0 +1,5 @@
+//#region src/utils/isObject.d.ts
+declare const isObject: (val: unknown) => val is Record<string, unknown>;
+//#endregion
+export { isObject };
+//# sourceMappingURL=isObject.d.mts.map

package/dist/utils/isObject.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isObject.d.mts","names":[],"sources":["../../src/utils/isObject.ts"],"mappings":";cAAa,QAAA,GAAY,GAAA,cAAe,GAAA,IAAO,MAAM"}

package/dist/utils/isObject.mjs

@@ -0,0 +1,6 @@
+//#region src/utils/isObject.ts
+const isObject = (val) => Boolean(val) && typeof val === `object` && !Array.isArray(val);
+//#endregion
+export { isObject };
+
+//# sourceMappingURL=isObject.mjs.map

package/dist/utils/isObject.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"isObject.mjs","names":[],"sources":["../../src/utils/isObject.ts"],"sourcesContent":["export const isObject = (val: unknown): val is Record<string, unknown> =>\n  Boolean(val) && typeof val === `object` && !Array.isArray(val);\n"],"mappings":";AAAA,MAAa,YAAY,QACvB,QAAQ,GAAG,KAAK,OAAO,QAAQ,YAAY,CAAC,MAAM,QAAQ,GAAG"}

package/dist/utils/sleep.d.mts

@@ -0,0 +1,8 @@
+//#region src/utils/sleep.d.ts
+/**
+ * Sleep for a given number of milliseconds
+ */
+declare const sleep: (ms: number) => Promise<void>;
+//#endregion
+export { sleep };
+//# sourceMappingURL=sleep.d.mts.map

package/dist/utils/sleep.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sleep.d.mts","names":[],"sources":["../../src/utils/sleep.ts"],"mappings":";;AAGA;;cAAa,KAAA,GAAe,EAAA,aAAa,OAAO"}

package/dist/utils/sleep.mjs

@@ -0,0 +1,9 @@
+//#region src/utils/sleep.ts
+/**
+* Sleep for a given number of milliseconds
+*/
+const sleep = async (ms) => new Promise((resolve) => setTimeout(resolve, Math.max(0, ms)));
+//#endregion
+export { sleep };
+
+//# sourceMappingURL=sleep.mjs.map

package/dist/utils/sleep.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"sleep.mjs","names":[],"sources":["../../src/utils/sleep.ts"],"sourcesContent":["/**\n * Sleep for a given number of milliseconds\n */\nexport const sleep = async (ms: number): Promise<void> =>\n  new Promise((resolve) => setTimeout(resolve, Math.max(0, ms)));\n"],"mappings":";;;;AAGA,MAAa,QAAQ,OAAO,OAC1B,IAAI,SAAS,YAAY,WAAW,SAAS,KAAK,IAAI,GAAG,EAAE,CAAC,CAAC"}

package/dist/utils/toCamelCase.d.mts

@@ -0,0 +1,5 @@
+//#region src/utils/toCamelCase.d.ts
+declare const toCamelCase: (str: string) => string;
+//#endregion
+export { toCamelCase };
+//# sourceMappingURL=toCamelCase.d.mts.map

package/dist/utils/toCamelCase.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toCamelCase.d.mts","names":[],"sources":["../../src/utils/toCamelCase.ts"],"mappings":";cAAa,WAAA,GAAe,GAAW"}

package/dist/utils/toCamelCase.mjs

@@ -0,0 +1,6 @@
+//#region src/utils/toCamelCase.ts
+const toCamelCase = (str) => str.replace(/_(?<char>[a-zA-Z])/g, (g) => g[1].toUpperCase());
+//#endregion
+export { toCamelCase };
+
+//# sourceMappingURL=toCamelCase.mjs.map

package/dist/utils/toCamelCase.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"toCamelCase.mjs","names":[],"sources":["../../src/utils/toCamelCase.ts"],"sourcesContent":["export const toCamelCase = (str: string): string =>\n  str.replace(/_(?<char>[a-zA-Z])/g, (g) => g[1].toUpperCase());\n"],"mappings":";AAAA,MAAa,eAAe,QAC1B,IAAI,QAAQ,wBAAwB,MAAM,EAAE,GAAG,YAAY,CAAC"}

package/dist/utils/toCamelKeys.d.mts

@@ -0,0 +1,20 @@
+//#region src/utils/toCamelKeys.d.ts
+/**
+ * Convert a `snake_case` string-literal type to `camelCase`, matching exactly
+ * what {@link toCamelCase} does at runtime: each `_x` becomes `X`. Self-contained
+ * (no general word-splitting); we only ever convert underscore-delimited Discord
+ * API keys, so this is all the casing we need.
+ */
+type CamelCase<S extends string> = S extends `${infer Head}_${infer Tail}` ? `${Head}${CamelCase<Capitalize<Tail>>}` : S;
+/**
+ * Recursively camel-case the keys of an object/array type. Mirrors
+ * {@link toCamelKeys}'s runtime: arrays map element-wise, plain objects remap
+ * their keys, and leaf values pass through unchanged. Replaces type-fest's
+ * `CamelCasedPropertiesDeep` — narrower (no Set/tuple/options handling) because
+ * the only inputs are plain nested Discord API JSON.
+ */
+type CamelKeys<T> = T extends ReadonlyArray<infer U> ? Array<CamelKeys<U>> : T extends object ? { [K in keyof T as K extends string ? CamelCase<K> : K]: CamelKeys<T[K]> } : T;
+declare const toCamelKeys: <T extends object>(o: T) => CamelKeys<T>;
+//#endregion
+export { CamelKeys, toCamelKeys };
+//# sourceMappingURL=toCamelKeys.d.mts.map

package/dist/utils/toCamelKeys.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toCamelKeys.d.mts","names":[],"sources":["../../src/utils/toCamelKeys.ts"],"mappings":";;;;;;;KASK,SAAA,qBAA8B,CAAA,4CAC5B,IAAA,GAAO,SAAA,CAAU,UAAA,CAAW,IAAA,OAC/B,CAAA;;;;;;;;KASQ,SAAA,MACV,CAAA,SAAU,aAAA,YACN,KAAA,CAAM,SAAA,CAAU,CAAA,KAChB,CAAA,gCAEgB,CAAA,IAAK,CAAA,kBAAmB,SAAA,CAAU,CAAA,IAAK,CAAA,GAAI,SAAA,CACrD,CAAA,CAAE,CAAA,OAGN,CAAA;AAAA,cAEK,WAAA,qBAAiC,CAAA,EAAG,CAAA,KAAI,SAAA,CAAU,CAAA"}

package/dist/utils/toCamelKeys.mjs

@@ -0,0 +1,15 @@
+import { isObject } from "./isObject.mjs";
+import { toCamelCase } from "./toCamelCase.mjs";
+//#region src/utils/toCamelKeys.ts
+const toCamelKeys = (o) => {
+	if (Array.isArray(o)) return o.map(toCamelKeys);
+	else if (isObject(o)) return Object.entries(o).reduce((acc, [key, value]) => {
+		acc[toCamelCase(key)] = toCamelKeys(value);
+		return acc;
+	}, {});
+	return o;
+};
+//#endregion
+export { toCamelKeys };
+
+//# sourceMappingURL=toCamelKeys.mjs.map

package/dist/utils/toCamelKeys.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"toCamelKeys.mjs","names":[],"sources":["../../src/utils/toCamelKeys.ts"],"sourcesContent":["import { isObject } from \"./isObject.js\";\nimport { toCamelCase } from \"./toCamelCase.js\";\n\n/**\n * Convert a `snake_case` string-literal type to `camelCase`, matching exactly\n * what {@link toCamelCase} does at runtime: each `_x` becomes `X`. Self-contained\n * (no general word-splitting); we only ever convert underscore-delimited Discord\n * API keys, so this is all the casing we need.\n */\ntype CamelCase<S extends string> = S extends `${infer Head}_${infer Tail}`\n  ? `${Head}${CamelCase<Capitalize<Tail>>}`\n  : S;\n\n/**\n * Recursively camel-case the keys of an object/array type. Mirrors\n * {@link toCamelKeys}'s runtime: arrays map element-wise, plain objects remap\n * their keys, and leaf values pass through unchanged. Replaces type-fest's\n * `CamelCasedPropertiesDeep` — narrower (no Set/tuple/options handling) because\n * the only inputs are plain nested Discord API JSON.\n */\nexport type CamelKeys<T> =\n  T extends ReadonlyArray<infer U>\n    ? Array<CamelKeys<U>>\n    : T extends object\n      ? {\n          [K in keyof T as K extends string ? CamelCase<K> : K]: CamelKeys<\n            T[K]\n          >;\n        }\n      : T;\n\nexport const toCamelKeys = <T extends object>(o: T): CamelKeys<T> => {\n  if (Array.isArray(o)) {\n    return o.map(toCamelKeys) as CamelKeys<T>;\n  } else if (isObject(o)) {\n    return Object.entries(o).reduce((acc, [key, value]) => {\n      // @ts-expect-error\n      acc[toCamelCase(key)] = toCamelKeys(value);\n      return acc;\n    }, {}) as CamelKeys<T>;\n  }\n\n  return o as CamelKeys<T>;\n};\n"],"mappings":";;;AA+BA,MAAa,eAAiC,MAAuB;CACnE,IAAI,MAAM,QAAQ,CAAC,GACjB,OAAO,EAAE,IAAI,WAAW;MACnB,IAAI,SAAS,CAAC,GACnB,OAAO,OAAO,QAAQ,CAAC,EAAE,QAAQ,KAAK,CAAC,KAAK,WAAW;EAErD,IAAI,YAAY,GAAG,KAAK,YAAY,KAAK;EACzC,OAAO;CACT,GAAG,CAAC,CAAC;CAGP,OAAO;AACT"}

package/dist/utils/toSnakeCase.d.mts

@@ -0,0 +1,5 @@
+//#region src/utils/toSnakeCase.d.ts
+declare const toSnakeCase: (str: string) => string;
+//#endregion
+export { toSnakeCase };
+//# sourceMappingURL=toSnakeCase.d.mts.map

package/dist/utils/toSnakeCase.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toSnakeCase.d.mts","names":[],"sources":["../../src/utils/toSnakeCase.ts"],"mappings":";cAAa,WAAA,GAAe,GAAW"}

package/dist/utils/toSnakeCase.mjs

@@ -0,0 +1,6 @@
+//#region src/utils/toSnakeCase.ts
+const toSnakeCase = (str) => str.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`).substring(str.slice(0, 1).match(/(?<char>[A-Z])/g) ? 1 : 0);
+//#endregion
+export { toSnakeCase };
+
+//# sourceMappingURL=toSnakeCase.mjs.map

package/dist/utils/toSnakeCase.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"toSnakeCase.mjs","names":[],"sources":["../../src/utils/toSnakeCase.ts"],"sourcesContent":["export const toSnakeCase = (str: string): string =>\n  str\n    .replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`)\n    .substring(str.slice(0, 1).match(/(?<char>[A-Z])/g) ? 1 : 0);\n"],"mappings":";AAAA,MAAa,eAAe,QAC1B,IACG,QAAQ,WAAW,WAAW,IAAI,OAAO,YAAY,GAAG,EACxD,UAAU,IAAI,MAAM,GAAG,CAAC,EAAE,MAAM,iBAAiB,IAAI,IAAI,CAAC"}

package/dist/utils/toSnakeKeys.d.mts

@@ -0,0 +1,24 @@
+//#region src/utils/toSnakeKeys.d.ts
+/** The uppercase ASCII letters, for the camel→snake split. */
+type Upper = `A` | `B` | `C` | `D` | `E` | `F` | `G` | `H` | `I` | `J` | `K` | `L` | `M` | `N` | `O` | `P` | `Q` | `R` | `S` | `T` | `U` | `V` | `W` | `X` | `Y` | `Z`;
+/**
+ * Walk a `camelCase` literal, inserting `_` before each uppercase letter and
+ * lowercasing it — matching {@link toSnakeCase}'s runtime. `Started` tracks
+ * whether we've emitted any character yet, so a leading capital (e.g. `Foo`)
+ * doesn't get a leading underscore (→ `foo`, not `_foo`).
+ */
+type SnakeWalk<S extends string, Started extends boolean = false> = S extends `${infer Head}${infer Tail}` ? Head extends Upper ? `${Started extends true ? `_` : ``}${Lowercase<Head>}${SnakeWalk<Tail, true>}` : `${Head}${SnakeWalk<Tail, true>}` : S;
+/** Convert a `camelCase` string-literal type to `snake_case`. Self-contained;
+ * mirrors {@link toSnakeCase} (the only transform we apply to API keys). */
+type SnakeCase<S extends string> = SnakeWalk<S>;
+/**
+ * Recursively snake-case the keys of an object/array type. Mirrors
+ * {@link toSnakeKeys}'s runtime. Replaces type-fest's `SnakeCasedPropertiesDeep`
+ * — narrower (no Set/tuple/options handling) because the only inputs are plain
+ * nested Discord API JSON.
+ */
+type SnakeKeys<T> = T extends ReadonlyArray<infer U> ? Array<SnakeKeys<U>> : T extends object ? { [K in keyof T as K extends string ? SnakeCase<K> : K]: SnakeKeys<T[K]> } : T;
+declare const toSnakeKeys: <T extends object>(o: T) => SnakeKeys<T>;
+//#endregion
+export { SnakeKeys, toSnakeKeys };
+//# sourceMappingURL=toSnakeKeys.d.mts.map

package/dist/utils/toSnakeKeys.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toSnakeKeys.d.mts","names":[],"sources":["../../src/utils/toSnakeKeys.ts"],"mappings":";;KAIK,KAAA;;;;AAAK;AAAA;;KAkCL,SAAA,sDAGD,CAAA,wCACA,IAAA,SAAa,KAAA,MACR,OAAA,2BAAkC,SAAA,CAAU,IAAA,IAAQ,SAAA,CAAU,IAAA,eAC9D,IAAA,GAAO,SAAA,CAAU,IAAA,YACtB,CAAA;;;KAIC,SAAA,qBAA8B,SAAS,CAAC,CAAA;;;;;;;KAQjC,SAAA,MACV,CAAA,SAAU,aAAA,YACN,KAAA,CAAM,SAAA,CAAU,CAAA,KAChB,CAAA,gCAEgB,CAAA,IAAK,CAAA,kBAAmB,SAAA,CAAU,CAAA,IAAK,CAAA,GAAI,SAAA,CACrD,CAAA,CAAE,CAAA,OAGN,CAAA;AAAA,cAEK,WAAA,qBAAiC,CAAA,EAAG,CAAA,KAAI,SAAA,CAAU,CAAA"}

package/dist/utils/toSnakeKeys.mjs

@@ -0,0 +1,15 @@
+import { toSnakeCase } from "./toSnakeCase.mjs";
+import { isObject } from "./isObject.mjs";
+//#region src/utils/toSnakeKeys.ts
+const toSnakeKeys = (o) => {
+	if (Array.isArray(o)) return o.map(toSnakeKeys);
+	else if (isObject(o)) return Object.entries(o).reduce((acc, [key, value]) => {
+		acc[toSnakeCase(key)] = toSnakeKeys(value);
+		return acc;
+	}, {});
+	return o;
+};
+//#endregion
+export { toSnakeKeys };
+
+//# sourceMappingURL=toSnakeKeys.mjs.map

package/dist/utils/toSnakeKeys.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"toSnakeKeys.mjs","names":[],"sources":["../../src/utils/toSnakeKeys.ts"],"sourcesContent":["import { isObject } from \"./isObject.js\";\nimport { toSnakeCase } from \"./toSnakeCase.js\";\n\n/** The uppercase ASCII letters, for the camel→snake split. */\ntype Upper =\n  | `A`\n  | `B`\n  | `C`\n  | `D`\n  | `E`\n  | `F`\n  | `G`\n  | `H`\n  | `I`\n  | `J`\n  | `K`\n  | `L`\n  | `M`\n  | `N`\n  | `O`\n  | `P`\n  | `Q`\n  | `R`\n  | `S`\n  | `T`\n  | `U`\n  | `V`\n  | `W`\n  | `X`\n  | `Y`\n  | `Z`;\n\n/**\n * Walk a `camelCase` literal, inserting `_` before each uppercase letter and\n * lowercasing it — matching {@link toSnakeCase}'s runtime. `Started` tracks\n * whether we've emitted any character yet, so a leading capital (e.g. `Foo`)\n * doesn't get a leading underscore (→ `foo`, not `_foo`).\n */\ntype SnakeWalk<\n  S extends string,\n  Started extends boolean = false\n> = S extends `${infer Head}${infer Tail}`\n  ? Head extends Upper\n    ? `${Started extends true ? `_` : ``}${Lowercase<Head>}${SnakeWalk<Tail, true>}`\n    : `${Head}${SnakeWalk<Tail, true>}`\n  : S;\n\n/** Convert a `camelCase` string-literal type to `snake_case`. Self-contained;\n * mirrors {@link toSnakeCase} (the only transform we apply to API keys). */\ntype SnakeCase<S extends string> = SnakeWalk<S>;\n\n/**\n * Recursively snake-case the keys of an object/array type. Mirrors\n * {@link toSnakeKeys}'s runtime. Replaces type-fest's `SnakeCasedPropertiesDeep`\n * — narrower (no Set/tuple/options handling) because the only inputs are plain\n * nested Discord API JSON.\n */\nexport type SnakeKeys<T> =\n  T extends ReadonlyArray<infer U>\n    ? Array<SnakeKeys<U>>\n    : T extends object\n      ? {\n          [K in keyof T as K extends string ? SnakeCase<K> : K]: SnakeKeys<\n            T[K]\n          >;\n        }\n      : T;\n\nexport const toSnakeKeys = <T extends object>(o: T): SnakeKeys<T> => {\n  if (Array.isArray(o)) {\n    return o.map(toSnakeKeys) as SnakeKeys<T>;\n  } else if (isObject(o)) {\n    return Object.entries(o).reduce((acc, [key, value]) => {\n      // @ts-expect-error\n      acc[toSnakeCase(key)] = toSnakeKeys(value);\n      return acc;\n    }, {}) as SnakeKeys<T>;\n  }\n\n  return o as SnakeKeys<T>;\n};\n"],"mappings":";;;AAoEA,MAAa,eAAiC,MAAuB;CACnE,IAAI,MAAM,QAAQ,CAAC,GACjB,OAAO,EAAE,IAAI,WAAW;MACnB,IAAI,SAAS,CAAC,GACnB,OAAO,OAAO,QAAQ,CAAC,EAAE,QAAQ,KAAK,CAAC,KAAK,WAAW;EAErD,IAAI,YAAY,GAAG,KAAK,YAAY,KAAK;EACzC,OAAO;CACT,GAAG,CAAC,CAAC;CAGP,OAAO;AACT"}