@discordkit/core 3.2.0 → 4.0.1

package/dist/validations/asDigits.d.mts

@@ -0,0 +1,13 @@
+import { bitfield } from "./bitfield.mjs";
+import * as v from "valibot";
+
+//#region src/validations/asDigits.d.ts
+/**
+ * Transforms a `bitfield` schema into a numeric string
+ *
+ * @__NO_SIDE_EFFECTS__
+ */
+declare const asDigits: (schema: ReturnType<typeof bitfield>) => v.GenericSchema<string>;
+//#endregion
+export { asDigits };
+//# sourceMappingURL=asDigits.d.mts.map

package/dist/validations/asDigits.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"asDigits.d.mts","names":[],"sources":["../../src/validations/asDigits.ts"],"mappings":";;;;;;AAQA;;;cAAa,QAAA,GACX,MAAA,EAAQ,UAAA,QAAkB,QAAA,MACzB,CAAA,CAAE,aAAA"}

package/dist/validations/asDigits.mjs

@@ -0,0 +1,12 @@
+import * as v from "valibot";
+//#region src/validations/asDigits.ts
+/**
+* Transforms a `bitfield` schema into a numeric string
+*
+* @__NO_SIDE_EFFECTS__
+*/
+const asDigits = (schema) => v.pipe(schema, v.transform((val) => val.toString()), v.digits());
+//#endregion
+export { asDigits };
+
+//# sourceMappingURL=asDigits.mjs.map

package/dist/validations/asDigits.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"asDigits.mjs","names":[],"sources":["../../src/validations/asDigits.ts"],"sourcesContent":["import * as v from \"valibot\";\nimport type { bitfield } from \"./bitfield.js\";\n\n/**\n * Transforms a `bitfield` schema into a numeric string\n *\n * @__NO_SIDE_EFFECTS__\n */\nexport const asDigits = (\n  schema: ReturnType<typeof bitfield>\n): v.GenericSchema<string> =>\n  v.pipe(\n    schema,\n    v.transform((val) => val.toString()),\n    v.digits()\n  ) as v.GenericSchema<string>;\n"],"mappings":";;;;;;;AAQA,MAAa,YACX,WAEA,EAAE,KACA,QACA,EAAE,WAAW,QAAQ,IAAI,SAAS,CAAC,GACnC,EAAE,OAAO,CACX"}

package/dist/validations/asInteger.d.mts

@@ -0,0 +1,13 @@
+import { bitfield } from "./bitfield.mjs";
+import * as v from "valibot";
+
+//#region src/validations/asInteger.d.ts
+/**
+ * Transforms a `bitfield` schema into an integer
+ *
+ * @__NO_SIDE_EFFECTS__
+ */
+declare const asInteger: (schema: ReturnType<typeof bitfield>) => v.GenericSchema<number>;
+//#endregion
+export { asInteger };
+//# sourceMappingURL=asInteger.d.mts.map

package/dist/validations/asInteger.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"asInteger.d.mts","names":[],"sources":["../../src/validations/asInteger.ts"],"mappings":";;;;;;AAQA;;;cAAa,SAAA,GACX,MAAA,EAAQ,UAAA,QAAkB,QAAA,MACzB,CAAA,CAAE,aAAA"}

package/dist/validations/asInteger.mjs

@@ -0,0 +1,12 @@
+import * as v from "valibot";
+//#region src/validations/asInteger.ts
+/**
+* Transforms a `bitfield` schema into an integer
+*
+* @__NO_SIDE_EFFECTS__
+*/
+const asInteger = (schema) => v.pipe(schema, v.transform((val) => parseInt(val.toString(), 10)), v.integer());
+//#endregion
+export { asInteger };
+
+//# sourceMappingURL=asInteger.mjs.map

package/dist/validations/asInteger.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"asInteger.mjs","names":[],"sources":["../../src/validations/asInteger.ts"],"sourcesContent":["import * as v from \"valibot\";\nimport type { bitfield } from \"./bitfield.js\";\n\n/**\n * Transforms a `bitfield` schema into an integer\n *\n * @__NO_SIDE_EFFECTS__\n */\nexport const asInteger = (\n  schema: ReturnType<typeof bitfield>\n): v.GenericSchema<number> =>\n  v.pipe(\n    schema,\n    v.transform((val) => parseInt(val.toString(), 10)),\n    v.integer()\n  ) as v.GenericSchema<number>;\n"],"mappings":";;;;;;;AAQA,MAAa,aACX,WAEA,EAAE,KACA,QACA,EAAE,WAAW,QAAQ,SAAS,IAAI,SAAS,GAAG,EAAE,CAAC,GACjD,EAAE,QAAQ,CACZ"}

package/dist/validations/bitfield.d.mts

@@ -0,0 +1,24 @@
+import { CustomSchema, SchemaWithPipe, TitleAction } from "valibot";
+
+//#region src/validations/bitfield.d.ts
+interface Flags {
+  [key: string]: number | bigint | string;
+}
+/**
+ * Given an enum of bitwise flags, creates a new schema that
+ * can validate a [bitfield](https://en.wikipedia.org/wiki/Bit_field)
+ * numeric value (a data structure for efficiently serializing a
+ * group of boolean values).
+ *
+ * @__NO_SIDE_EFFECTS__
+ */
+declare const bitfield: <TName extends string>(/** A name to differentiate this custom schema */
+
+name: TName, /** An enum of bitwise flags */
+
+flags: Flags, /** An optional error message to display in the event an invalid value is parsed */
+
+message?: string) => SchemaWithPipe<readonly [CustomSchema<string | number | bigint, string>, TitleAction<string | number | bigint, TName>]>;
+//#endregion
+export { Flags, bitfield };
+//# sourceMappingURL=bitfield.d.mts.map

package/dist/validations/bitfield.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bitfield.d.mts","names":[],"sources":["../../src/validations/bitfield.ts"],"mappings":";;;UAWiB,KAAA;EAAA,CACd,GAAW;AAAA;;;;AAAA;AAWd;;;;cAAa,QAAA;;AAEX,IAAA,EAAM,KAAA;;AAEN,KAAA,EAAO,KAAA;;AAEP,OAAA,cACC,cAAA,WAEC,YAAA,oCACA,WAAA,2BAAsC,KAAA"}

package/dist/validations/bitfield.mjs

@@ -0,0 +1,22 @@
+import { isNonNullable } from "../utils/isNonNullable.mjs";
+import { isNumericString } from "../utils/isNumericString.mjs";
+import { custom, pipe, title } from "valibot";
+//#region src/validations/bitfield.ts
+/**
+* Given an enum of bitwise flags, creates a new schema that
+* can validate a [bitfield](https://en.wikipedia.org/wiki/Bit_field)
+* numeric value (a data structure for efficiently serializing a
+* group of boolean values).
+*
+* @__NO_SIDE_EFFECTS__
+*/
+const bitfield = (name, flags, message = `Invalid Bitfield`) => {
+	const flagValues = Object.values(flags).filter((flag) => !isNaN(Number(flag)));
+	if (!flagValues.every((flag) => typeof flag === typeof flagValues[0])) throw new Error(`Provided Flags enum must contain values of the same type`);
+	const mask = flagValues.reduce((total, flag) => total | BigInt(flag), 0n);
+	return pipe(custom((val) => isNonNullable(val) && (typeof val === `number` || typeof val === `bigint` || isNumericString(val)) ? (BigInt(val) & mask) === BigInt(val) : false, message), title(name));
+};
+//#endregion
+export { bitfield };
+
+//# sourceMappingURL=bitfield.mjs.map

package/dist/validations/bitfield.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"bitfield.mjs","names":[],"sources":["../../src/validations/bitfield.ts"],"sourcesContent":["import {\n  custom,\n  pipe,\n  title,\n  type SchemaWithPipe,\n  type TitleAction,\n  type CustomSchema\n} from \"valibot\";\nimport { isNonNullable } from \"../utils/isNonNullable.js\";\nimport { isNumericString } from \"../utils/isNumericString.js\";\n\nexport interface Flags {\n  [key: string]: number | bigint | string;\n}\n\n/**\n * Given an enum of bitwise flags, creates a new schema that\n * can validate a [bitfield](https://en.wikipedia.org/wiki/Bit_field)\n * numeric value (a data structure for efficiently serializing a\n * group of boolean values).\n *\n * @__NO_SIDE_EFFECTS__\n */\nexport const bitfield = <TName extends string>(\n  /** A name to differentiate this custom schema */\n  name: TName,\n  /** An enum of bitwise flags */\n  flags: Flags,\n  /** An optional error message to display in the event an invalid value is parsed */\n  message: string = `Invalid Bitfield`\n): SchemaWithPipe<\n  readonly [\n    CustomSchema<string | number | bigint, string>,\n    TitleAction<string | number | bigint, TName>\n  ]\n> => {\n  // because enums are bidirectionally indexed, pick only the numerical values\n  const flagValues = Object.values(flags).filter(\n    // flag enums have numerical values, so remove all the key name strings\n    (flag) => !isNaN(Number(flag))\n  );\n  if (!flagValues.every((flag) => typeof flag === typeof flagValues[0])) {\n    throw new Error(`Provided Flags enum must contain values of the same type`);\n  }\n  // combine the flags to create a validation mask\n  const mask = flagValues.reduce<bigint>(\n    (total, flag) => total | BigInt(flag),\n    0n\n  );\n  return pipe(\n    custom<number | bigint | string, typeof message>(\n      (val) =>\n        // short-circuit on null + undefined\n        isNonNullable(val) &&\n        // only work on supported types\n        (typeof val === `number` ||\n          typeof val === `bigint` ||\n          isNumericString(val))\n          ? // validate the value against the given flags\n            (BigInt(val) & mask) === BigInt(val)\n          : false,\n      message\n    ),\n    title(name)\n  );\n};\n"],"mappings":";;;;;;;;;;;;AAuBA,MAAa,YAEX,MAEA,OAEA,UAAkB,uBAMf;CAEH,MAAM,aAAa,OAAO,OAAO,KAAK,EAAE,QAErC,SAAS,CAAC,MAAM,OAAO,IAAI,CAAC,CAC/B;CACA,IAAI,CAAC,WAAW,OAAO,SAAS,OAAO,SAAS,OAAO,WAAW,EAAE,GAClE,MAAM,IAAI,MAAM,0DAA0D;CAG5E,MAAM,OAAO,WAAW,QACrB,OAAO,SAAS,QAAQ,OAAO,IAAI,GACpC,EACF;CACA,OAAO,KACL,QACG,QAEC,cAAc,GAAG,MAEhB,OAAO,QAAQ,YACd,OAAO,QAAQ,YACf,gBAAgB,GAAG,MAEhB,OAAO,GAAG,IAAI,UAAU,OAAO,GAAG,IACnC,OACN,OACF,GACA,MAAM,IAAI,CACZ;AACF"}

package/dist/validations/boundedArray.d.mts

@@ -0,0 +1,14 @@
+import * as v from "valibot";
+
+//#region src/validations/boundedArray.d.ts
+/** A non-empty array with a length within the given bounds
+ *
+ * @__NO_SIDE_EFFECTS__
+ */
+declare const boundedArray: <TItem>(items: v.GenericSchema<TItem>, req?: number | {
+  min?: number;
+  max?: number;
+}) => v.GenericSchema<TItem[]>;
+//#endregion
+export { boundedArray };
+//# sourceMappingURL=boundedArray.d.mts.map

package/dist/validations/boundedArray.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"boundedArray.d.mts","names":[],"sources":["../../src/validations/boundedArray.ts"],"mappings":";;;;;AAMA;;cAAa,YAAA,UACX,KAAA,EAAO,CAAA,CAAE,aAAA,CAAc,KAAA,GACvB,GAAA;EAAgB,GAAA;EAAc,GAAA;AAAA,MAC7B,CAAA,CAAE,aAAA,CAAc,KAAA"}

package/dist/validations/boundedArray.mjs

@@ -0,0 +1,11 @@
+import * as v from "valibot";
+//#region src/validations/boundedArray.ts
+/** A non-empty array with a length within the given bounds
+*
+* @__NO_SIDE_EFFECTS__
+*/
+const boundedArray = (items, req = {}) => v.message(typeof req === `number` ? v.pipe(v.array(items), v.length(req)) : typeof req.max === `number` ? v.pipe(v.array(items), v.minLength(req.min ?? 1), v.maxLength(req.max)) : v.pipe(v.array(items), v.minLength(req.min ?? 1)), (issue) => `Expected an array with a legnth ${typeof req === `number` ? req : `>= ${req.min ?? 0}${req.max ? `&& <= ${req.max}` : ``}`}, received has length: ${issue.received.length}`);
+//#endregion
+export { boundedArray };
+
+//# sourceMappingURL=boundedArray.mjs.map

package/dist/validations/boundedArray.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"boundedArray.mjs","names":[],"sources":["../../src/validations/boundedArray.ts"],"sourcesContent":["import * as v from \"valibot\";\n\n/** A non-empty array with a length within the given bounds\n *\n * @__NO_SIDE_EFFECTS__\n */\nexport const boundedArray = <TItem>(\n  items: v.GenericSchema<TItem>,\n  req: number | { min?: number; max?: number } = {}\n): v.GenericSchema<TItem[]> =>\n  v.message<v.GenericSchema<TItem[]>>(\n    typeof req === `number`\n      ? v.pipe(v.array(items), v.length(req))\n      : typeof req.max === `number`\n        ? v.pipe(\n            v.array(items),\n            v.minLength(req.min ?? 1),\n            v.maxLength(req.max)\n          )\n        : v.pipe(v.array(items), v.minLength(req.min ?? 1)),\n    (issue) =>\n      `Expected an array with a legnth ${typeof req === `number` ? req : `>= ${req.min ?? 0}${req.max ? `&& <= ${req.max}` : ``}`}, received has length: ${issue.received.length}`\n  );\n"],"mappings":";;;;;;AAMA,MAAa,gBACX,OACA,MAA+C,CAAC,MAEhD,EAAE,QACA,OAAO,QAAQ,WACX,EAAE,KAAK,EAAE,MAAM,KAAK,GAAG,EAAE,OAAO,GAAG,CAAC,IACpC,OAAO,IAAI,QAAQ,WACjB,EAAE,KACA,EAAE,MAAM,KAAK,GACb,EAAE,UAAU,IAAI,OAAO,CAAC,GACxB,EAAE,UAAU,IAAI,GAAG,CACrB,IACA,EAAE,KAAK,EAAE,MAAM,KAAK,GAAG,EAAE,UAAU,IAAI,OAAO,CAAC,CAAC,IACrD,UACC,mCAAmC,OAAO,QAAQ,WAAW,MAAM,MAAM,IAAI,OAAO,IAAI,IAAI,MAAM,SAAS,IAAI,QAAQ,KAAK,yBAAyB,MAAM,SAAS,QACxK"}

package/dist/validations/boundedInteger.d.mts

@@ -0,0 +1,14 @@
+import * as v from "valibot";
+
+//#region src/validations/boundedInteger.d.ts
+/** An integer with a value within the given bounds
+ *
+ * @__NO_SIDE_EFFECTS__
+ */
+declare const boundedInteger: (req?: number | {
+  min?: number;
+  max?: number;
+}) => v.GenericSchema<number>;
+//#endregion
+export { boundedInteger };
+//# sourceMappingURL=boundedInteger.d.mts.map

package/dist/validations/boundedInteger.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"boundedInteger.d.mts","names":[],"sources":["../../src/validations/boundedInteger.ts"],"mappings":";;;;;AAMA;;cAAa,cAAA,GACX,GAAA;EAAgB,GAAA;EAAc,GAAA;AAAA,MAC7B,CAAA,CAAE,aAAa"}

package/dist/validations/boundedInteger.mjs

@@ -0,0 +1,11 @@
+import * as v from "valibot";
+//#region src/validations/boundedInteger.ts
+/** An integer with a value within the given bounds
+*
+* @__NO_SIDE_EFFECTS__
+*/
+const boundedInteger = (req = {}) => v.message(typeof req === `number` ? v.pipe(v.number(), v.integer(), v.value(req)) : typeof req.max === `number` ? v.pipe(v.number(), v.integer(), v.minValue(req.min ?? 0), v.maxValue(req.max)) : v.pipe(v.number(), v.integer(), v.minValue(req.min ?? 0)), (issue) => `Expected an integer with a value ${typeof req === `number` ? `of ${req}` : `>= ${req.min ?? 0}${req.max ? `&& <= ${req.max}` : ``}`}, received has value: ${issue.received.length}`);
+//#endregion
+export { boundedInteger };
+
+//# sourceMappingURL=boundedInteger.mjs.map

package/dist/validations/boundedInteger.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"boundedInteger.mjs","names":[],"sources":["../../src/validations/boundedInteger.ts"],"sourcesContent":["import * as v from \"valibot\";\n\n/** An integer with a value within the given bounds\n *\n * @__NO_SIDE_EFFECTS__\n */\nexport const boundedInteger = (\n  req: number | { min?: number; max?: number } = {}\n): v.GenericSchema<number> =>\n  v.message<v.GenericSchema<number>>(\n    typeof req === `number`\n      ? v.pipe(v.number(), v.integer(), v.value(req))\n      : typeof req.max === `number`\n        ? v.pipe(\n            v.number(),\n            v.integer(),\n            v.minValue(req.min ?? 0),\n            v.maxValue(req.max)\n          )\n        : v.pipe(v.number(), v.integer(), v.minValue(req.min ?? 0)),\n    (issue) =>\n      `Expected an integer with a value ${typeof req === `number` ? `of ${req}` : `>= ${req.min ?? 0}${req.max ? `&& <= ${req.max}` : ``}`}, received has value: ${issue.received.length}`\n  );\n"],"mappings":";;;;;;AAMA,MAAa,kBACX,MAA+C,CAAC,MAEhD,EAAE,QACA,OAAO,QAAQ,WACX,EAAE,KAAK,EAAE,OAAO,GAAG,EAAE,QAAQ,GAAG,EAAE,MAAM,GAAG,CAAC,IAC5C,OAAO,IAAI,QAAQ,WACjB,EAAE,KACA,EAAE,OAAO,GACT,EAAE,QAAQ,GACV,EAAE,SAAS,IAAI,OAAO,CAAC,GACvB,EAAE,SAAS,IAAI,GAAG,CACpB,IACA,EAAE,KAAK,EAAE,OAAO,GAAG,EAAE,QAAQ,GAAG,EAAE,SAAS,IAAI,OAAO,CAAC,CAAC,IAC7D,UACC,oCAAoC,OAAO,QAAQ,WAAW,MAAM,QAAQ,MAAM,IAAI,OAAO,IAAI,IAAI,MAAM,SAAS,IAAI,QAAQ,KAAK,wBAAwB,MAAM,SAAS,QAChL"}

package/dist/validations/boundedString.d.mts

@@ -0,0 +1,15 @@
+import * as v from "valibot";
+
+//#region src/validations/boundedString.d.ts
+/**
+ * A non-empty string with a length within the given bounds.
+ *
+ * @__NO_SIDE_EFFECTS__
+ */
+declare const boundedString: (req?: number | {
+  min?: number;
+  max?: number;
+}) => v.GenericSchema<string>;
+//#endregion
+export { boundedString };
+//# sourceMappingURL=boundedString.d.mts.map

package/dist/validations/boundedString.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"boundedString.d.mts","names":[],"sources":["../../src/validations/boundedString.ts"],"mappings":";;;;;AAOA;;;cAAa,aAAA,GACX,GAAA;EAAgB,GAAA;EAAc,GAAA;AAAA,MAC7B,CAAA,CAAE,aAAa"}

package/dist/validations/boundedString.mjs

@@ -0,0 +1,12 @@
+import * as v from "valibot";
+//#region src/validations/boundedString.ts
+/**
+* A non-empty string with a length within the given bounds.
+*
+* @__NO_SIDE_EFFECTS__
+*/
+const boundedString = (req = {}) => v.message(typeof req === `number` ? v.pipe(v.string(), v.length(req)) : typeof req.max === `number` ? v.pipe(v.string(), v.minLength(req.min ?? 1), v.maxLength(req.max)) : v.pipe(v.string(), v.minLength(req.min ?? 1)), (issue) => `Expected a string with a legnth ${typeof req === `number` ? req : `>= ${req.min ?? 0}${req.max ? `&& <= ${req.max}` : ``}`}, received has length: ${issue.received.length}`);
+//#endregion
+export { boundedString };
+
+//# sourceMappingURL=boundedString.mjs.map

package/dist/validations/boundedString.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"boundedString.mjs","names":[],"sources":["../../src/validations/boundedString.ts"],"sourcesContent":["import * as v from \"valibot\";\n\n/**\n * A non-empty string with a length within the given bounds.\n *\n * @__NO_SIDE_EFFECTS__\n */\nexport const boundedString = (\n  req: number | { min?: number; max?: number } = {}\n): v.GenericSchema<string> =>\n  v.message<v.GenericSchema<string>>(\n    typeof req === `number`\n      ? v.pipe(v.string(), v.length(req))\n      : typeof req.max === `number`\n        ? v.pipe(v.string(), v.minLength(req.min ?? 1), v.maxLength(req.max))\n        : v.pipe(v.string(), v.minLength(req.min ?? 1)),\n    (issue) =>\n      `Expected a string with a legnth ${typeof req === `number` ? req : `>= ${req.min ?? 0}${req.max ? `&& <= ${req.max}` : ``}`}, received has length: ${issue.received.length}`\n  );\n"],"mappings":";;;;;;;AAOA,MAAa,iBACX,MAA+C,CAAC,MAEhD,EAAE,QACA,OAAO,QAAQ,WACX,EAAE,KAAK,EAAE,OAAO,GAAG,EAAE,OAAO,GAAG,CAAC,IAChC,OAAO,IAAI,QAAQ,WACjB,EAAE,KAAK,EAAE,OAAO,GAAG,EAAE,UAAU,IAAI,OAAO,CAAC,GAAG,EAAE,UAAU,IAAI,GAAG,CAAC,IAClE,EAAE,KAAK,EAAE,OAAO,GAAG,EAAE,UAAU,IAAI,OAAO,CAAC,CAAC,IACjD,UACC,mCAAmC,OAAO,QAAQ,WAAW,MAAM,MAAM,IAAI,OAAO,IAAI,IAAI,MAAM,SAAS,IAAI,QAAQ,KAAK,yBAAyB,MAAM,SAAS,QACxK"}

package/dist/validations/datauri.d.mts

@@ -0,0 +1,25 @@
+import * as v from "valibot";
+
+//#region src/validations/datauri.d.ts
+declare const datauriRegex: RegExp;
+/**
+ * Extracts metadata from a given Data URI such as it's
+ * MIME type, params, and encoding
+ *
+ * Returns an empty object when given an invalid Data URI
+ */
+declare const extractDataURIMetadata: (val: string) => Partial<{
+  mediaType: string;
+  mimeType: `${string}/${string}`;
+  params: string;
+  encoding: string;
+  data: string;
+}>;
+declare const toBase64: (data: string) => string;
+/**
+ * Validates that a string is a [data URI scheme](https://en.wikipedia.org/wiki/Data_URI_scheme)
+ */
+declare const datauri: v.GenericSchema<string>;
+//#endregion
+export { datauri, datauriRegex, extractDataURIMetadata, toBase64 };
+//# sourceMappingURL=datauri.d.mts.map

package/dist/validations/datauri.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"datauri.d.mts","names":[],"sources":["../../src/validations/datauri.ts"],"mappings":";;;cAEa,YAAA,EAAY,MACsK;;AAD/L;;;;AAC+L;cAQlL,sBAAA,GACX,GAAA,aACC,OAAO;EACR,SAAA;EACA,QAAA;EACA,MAAA;EACA,QAAA;EACA,IAAA;AAAA;AAAA,cAGW,QAAA,GAAY,IAAY;;;;cAaxB,OAAA,EAAS,CAAA,CAAE,aAAa"}

package/dist/validations/datauri.mjs

@@ -0,0 +1,19 @@
+import * as v from "valibot";
+//#region src/validations/datauri.ts
+const datauriRegex = /^data:((?<mediaType>(?<mimeType>[a-z]+\/[a-z0-9-+.]+)(?<params>;[a-z0-9-.!#$%*+.{}|~`]+=[a-z0-9-.!#$%*+.{}()_|~`]+)*))?(?<encoding>;base64)?,(?<data>[a-z0-9!$&',()*+;=\-._~:@/?%\s<>]*?)$/i;
+/**
+* Extracts metadata from a given Data URI such as it's
+* MIME type, params, and encoding
+*
+* Returns an empty object when given an invalid Data URI
+*/
+const extractDataURIMetadata = (val) => datauriRegex.exec(val)?.groups ?? {};
+const toBase64 = (data) => typeof Buffer !== `undefined` ? Buffer.from(data, `base64`).toString() : atob(btoa(String.fromCharCode(...new TextEncoder().encode(data))).replace(/\+/g, `-`).replace(/\//g, `_`).replace(/=/g, ``));
+/**
+* Validates that a string is a [data URI scheme](https://en.wikipedia.org/wiki/Data_URI_scheme)
+*/
+const datauri = v.pipe(v.custom((val) => typeof val === `string` && val.length > 0 && datauriRegex.test(val), `Invalid Data URI`), v.title(`datauri`));
+//#endregion
+export { datauri, datauriRegex, extractDataURIMetadata, toBase64 };
+
+//# sourceMappingURL=datauri.mjs.map

package/dist/validations/datauri.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"datauri.mjs","names":[],"sources":["../../src/validations/datauri.ts"],"sourcesContent":["import * as v from \"valibot\";\n\nexport const datauriRegex =\n  /^data:((?<mediaType>(?<mimeType>[a-z]+\\/[a-z0-9-+.]+)(?<params>;[a-z0-9-.!#$%*+.{}|~`]+=[a-z0-9-.!#$%*+.{}()_|~`]+)*))?(?<encoding>;base64)?,(?<data>[a-z0-9!$&',()*+;=\\-._~:@/?%\\s<>]*?)$/i;\n\n/**\n * Extracts metadata from a given Data URI such as it's\n * MIME type, params, and encoding\n *\n * Returns an empty object when given an invalid Data URI\n */\nexport const extractDataURIMetadata = (\n  val: string\n): Partial<{\n  mediaType: string;\n  mimeType: `${string}/${string}`;\n  params: string;\n  encoding: string;\n  data: string;\n}> => datauriRegex.exec(val)?.groups ?? {};\n\nexport const toBase64 = (data: string): string =>\n  typeof Buffer !== `undefined`\n    ? Buffer.from(data, `base64`).toString()\n    : atob(\n        btoa(String.fromCharCode(...new TextEncoder().encode(data)))\n          .replace(/\\+/g, `-`)\n          .replace(/\\//g, `_`)\n          .replace(/=/g, ``)\n      );\n\n/**\n * Validates that a string is a [data URI scheme](https://en.wikipedia.org/wiki/Data_URI_scheme)\n */\nexport const datauri: v.GenericSchema<string> = v.pipe(\n  v.custom<string>(\n    (val) =>\n      typeof val === `string` && val.length > 0 && datauriRegex.test(val),\n    `Invalid Data URI`\n  ),\n  v.title(`datauri`)\n);\n"],"mappings":";;AAEA,MAAa,eACX;;;;;;;AAQF,MAAa,0BACX,QAOI,aAAa,KAAK,GAAG,GAAG,UAAU,CAAC;AAEzC,MAAa,YAAY,SACvB,OAAO,WAAW,cACd,OAAO,KAAK,MAAM,QAAQ,EAAE,SAAS,IACrC,KACE,KAAK,OAAO,aAAa,GAAG,IAAI,YAAY,EAAE,OAAO,IAAI,CAAC,CAAC,EACxD,QAAQ,OAAO,GAAG,EAClB,QAAQ,OAAO,GAAG,EAClB,QAAQ,MAAM,EAAE,CACrB;;;;AAKN,MAAa,UAAmC,EAAE,KAChD,EAAE,QACC,QACC,OAAO,QAAQ,YAAY,IAAI,SAAS,KAAK,aAAa,KAAK,GAAG,GACpE,kBACF,GACA,EAAE,MAAM,SAAS,CACnB"}

package/dist/validations/fileUpload.d.mts

@@ -0,0 +1,130 @@
+import * as v from "valibot";
+
+//#region src/validations/fileUpload.d.ts
+/**
+ * The shape of a single file upload — used wherever a Discord endpoint
+ * accepts an attached file via `multipart/form-data`.
+ *
+ * @example
+ * ```ts
+ * await executeWebhook({
+ *   webhook: "...",
+ *   token: "...",
+ *   body: {
+ *     content: "Look at this!",
+ *     files: [
+ *       { filename: "photo.png", content: new Blob([bytes], { type: "image/png" }) }
+ *     ]
+ *   }
+ * });
+ * ```
+ */
+interface FileUpload {
+  /** Filename including extension. Required for the multipart `Content-Disposition` header. */
+  filename: string;
+  /** The binary content. Accepts a web-standard `Blob` or `File`. */
+  content: Blob;
+  /** Optional MIME type. If omitted, taken from the `Blob`'s `type` property. */
+  contentType?: string;
+}
+/** Type guard — true if `val` looks like a {@link FileUpload}. */
+declare const isFileUpload: (val: unknown) => val is FileUpload;
+/**
+ * Valibot schema for a single file upload. Validates the shape and
+ * surfaces a clean TypeScript type to consumers.
+ */
+declare const fileUpload: v.GenericSchema<FileUpload>;
+/**
+ * Walks a value and returns all {@link FileUpload}s within it, along
+ * with the path each one occupies.
+ */
+declare const collectFileUploads: (val: unknown, path?: ReadonlyArray<string | number>) => ReadonlyArray<{
+  readonly path: ReadonlyArray<string | number>;
+  readonly file: FileUpload;
+}>;
+/**
+ * Given a body that contains one or more {@link FileUpload}s, produce
+ * a `FormData` payload Discord can consume.
+ *
+ * Files are appended as `files[n]` parts; the rest of the body is
+ * snake_cased and JSON-stringified into a `payload_json` part.
+ *
+ * Each FileUpload in the body is replaced by its attachment placeholder
+ * `{ id: n }` so that an `attachments` array (if present) can reference
+ * uploads by index. Discord matches these placeholders to the
+ * corresponding `files[n]` parts.
+ */
+declare const toMultipartBody: (body: unknown, toSnakeKeys: (val: object) => unknown) => FormData;
+/**
+ * Sentinel symbol used to mark a validated body as multipart-eligible.
+ * Read by the request layer at serialization time.
+ *
+ * The marker is attached as a non-enumerable property on the parsed
+ * body so it doesn't leak into JSON serialization or the TypeScript
+ * output type.
+ */
+declare const MULTIPART_MARKER: unique symbol;
+/**
+ * Returns true if `body` should be serialized as `multipart/form-data`.
+ *
+ * Two signals trigger multipart serialization:
+ *
+ * 1. **Schema-tagged** — the body was parsed by a {@link multipart}-wrapped
+ *    schema and at least one {@link FileUpload} was present. The wrapper
+ *    stamps a non-enumerable {@link MULTIPART_MARKER} on the parsed value.
+ *    This is the fast path for the validated flow (e.g., `toValidated`).
+ *
+ * 2. **Value-detected** — the body contains a {@link FileUpload} anywhere
+ *    in its shape, regardless of whether it was validated. This safety net
+ *    keeps consumers who bypass validation from silently dropping their
+ *    files into a JSON body where `Blob` would serialize as `{}`.
+ *
+ * Either signal switches the request to multipart.
+ */
+declare const shouldSerializeAsMultipart: (body: unknown) => boolean;
+/**
+ * Wraps an object schema to mark its body as a potential multipart payload.
+ *
+ * Use {@link multipart} instead of `v.object` whenever an endpoint's body
+ * may contain one or more {@link fileUpload} fields (or arrays of them,
+ * or optional uploads). The wrapper validates the same shape as
+ * `v.object(entries)`. At validation time, the wrapper inspects the
+ * parsed body for {@link FileUpload}s. If any are present, it stamps a
+ * non-enumerable {@link MULTIPART_MARKER} on the result; the request
+ * layer reads that marker at serialization time to choose between
+ * `multipart/form-data` (marker present) and `application/json`
+ * (marker absent).
+ *
+ * Pass `{ partial: true }` for endpoints where every field is optional —
+ * the wrapper applies `v.partial(...)` to the inner object before piping
+ * the transform. `v.partial` itself can't wrap the piped result (it only
+ * accepts plain object schemas), so the option lives here.
+ *
+ * @example
+ * ```ts
+ * import { multipart, fileUpload } from "@discordkit/core";
+ * import * as v from "valibot";
+ *
+ * export const updateAvatarSchema = v.object({
+ *   body: multipart({
+ *     avatar: v.exactOptional(fileUpload),
+ *     bio: v.exactOptional(v.string())
+ *   })
+ * });
+ *
+ * // Every field optional:
+ * export const editMessageSchema = v.object({
+ *   body: multipart(
+ *     { content: v.string(), files: v.array(fileUpload) },
+ *     { partial: true }
+ *   )
+ * });
+ * ```
+ */
+declare function multipart<TEntries extends v.ObjectEntries>(entries: TEntries): v.GenericSchema<v.InferOutput<v.ObjectSchema<TEntries, undefined>>>;
+declare function multipart<TEntries extends v.ObjectEntries>(entries: TEntries, options: {
+  partial: true;
+}): v.GenericSchema<v.InferOutput<v.SchemaWithPartial<v.ObjectSchema<TEntries, undefined>, undefined>>>;
+//#endregion
+export { FileUpload, MULTIPART_MARKER, collectFileUploads, fileUpload, isFileUpload, multipart, shouldSerializeAsMultipart, toMultipartBody };
+//# sourceMappingURL=fileUpload.d.mts.map

package/dist/validations/fileUpload.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fileUpload.d.mts","names":[],"sources":["../../src/validations/fileUpload.ts"],"mappings":";;;;;AAqBA;;;;;;;;;AAMa;AAIb;;;;;;UAViB,UAAA;EAoBhB;EAlBC,QAAA;EAwBW;EAtBX,OAAA,EAAS,IAAI;;EAEb,WAAA;AAAA;;cAIW,YAAA,GAAgB,GAAA,cAAe,GAAA,IAAO,UAUlD;;AAMkD;AASnD;;cATa,UAAA,EAAY,CAAA,CAAE,aAAa,CAAC,UAAA;;;;;cAS5B,kBAAA,GACX,GAAA,WACA,IAAA,GAAM,aAAA,sBACL,aAAA;EAAA,SACQ,IAAA,EAAM,aAAA;EAAA,SACN,IAAA,EAAM,UAAA;AAAA;;;;;;;;AAAU;AAqD3B;;;;cAAa,eAAA,GACX,IAAA,WAIA,WAAA,GAAc,GAAA,yBACb,QAiCF;;;;;AAAA;AAUD;;;cAAa,gBAAA;AAA2D;AAmBxE;;;;AAAwD;AA6CxD;;;;;;;;;;;AAhEwE,cAmB3D,0BAAA,GAA8B,IAAa;;;;;;;;;;;;;AA+CA;AACxD;;;;;;;;;;;;;;;;;;;;;;;;;;iBAHgB,SAAA,kBAA2B,CAAA,CAAE,aAAA,EAC3C,OAAA,EAAS,QAAA,GACR,CAAA,CAAE,aAAA,CAAc,CAAA,CAAE,WAAA,CAAY,CAAA,CAAE,YAAA,CAAa,QAAA;AAAA,iBAChC,SAAA,kBAA2B,CAAA,CAAE,aAAA,EAC3C,OAAA,EAAS,QAAA,EACT,OAAA;EAAW,OAAA;AAAA,IACV,CAAA,CAAE,aAAA,CACH,CAAA,CAAE,WAAA,CACA,CAAA,CAAE,iBAAA,CAAkB,CAAA,CAAE,YAAA,CAAa,QAAA"}

package/dist/validations/fileUpload.mjs

@@ -0,0 +1,116 @@
+import { isObject } from "../utils/isObject.mjs";
+import * as v from "valibot";
+//#region src/validations/fileUpload.ts
+/** Type guard — true if `val` looks like a {@link FileUpload}. */
+const isFileUpload = (val) => {
+	if (!isObject(val)) return false;
+	const content = val.content;
+	return typeof val.filename === `string` && typeof content?.arrayBuffer === `function`;
+};
+/**
+* Valibot schema for a single file upload. Validates the shape and
+* surfaces a clean TypeScript type to consumers.
+*/
+const fileUpload = v.pipe(v.custom(isFileUpload, `Expected a FileUpload object`), v.title(`fileUpload`));
+/**
+* Walks a value and returns all {@link FileUpload}s within it, along
+* with the path each one occupies.
+*/
+const collectFileUploads = (val, path = []) => {
+	if (isFileUpload(val)) return [{
+		path,
+		file: val
+	}];
+	if (Array.isArray(val)) return val.flatMap((item, i) => collectFileUploads(item, [...path, i]));
+	if (isObject(val)) return Object.entries(val).flatMap(([key, item]) => collectFileUploads(item, [...path, key]));
+	return [];
+};
+/**
+* Returns a deep copy of `body` with the value at `path` replaced by
+* `replacement`. Pure: never mutates `body` or any of its children.
+*/
+const replaceAtPath = (body, path, replacement) => {
+	if (path.length === 0) return replacement;
+	const [head, ...rest] = path;
+	if (Array.isArray(body)) return body.map((item, index) => index === head ? replaceAtPath(item, rest, replacement) : item);
+	if (isObject(body)) return Object.fromEntries(Object.entries(body).map(([key, item]) => [key, key === head ? replaceAtPath(item, rest, replacement) : item]));
+	return body;
+};
+/**
+* Given a body that contains one or more {@link FileUpload}s, produce
+* a `FormData` payload Discord can consume.
+*
+* Files are appended as `files[n]` parts; the rest of the body is
+* snake_cased and JSON-stringified into a `payload_json` part.
+*
+* Each FileUpload in the body is replaced by its attachment placeholder
+* `{ id: n }` so that an `attachments` array (if present) can reference
+* uploads by index. Discord matches these placeholders to the
+* corresponding `files[n]` parts.
+*/
+const toMultipartBody = (body, toSnakeKeys) => {
+	const uploads = collectFileUploads(body);
+	if (uploads.length === 0) throw new Error(`toMultipartBody called with a body containing no FileUploads`);
+	const payload = uploads.reduce((acc, { path }, index) => replaceAtPath(acc, path, { id: index }), body);
+	const fileEntries = uploads.map(({ file }, index) => {
+		const blob = file.contentType && file.content.type !== file.contentType ? new Blob([file.content], { type: file.contentType }) : file.content;
+		return [
+			`files[${index}]`,
+			blob,
+			file.filename
+		];
+	});
+	const payloadJson = new Blob([JSON.stringify(toSnakeKeys(payload))], { type: `application/json` });
+	const form = new FormData();
+	fileEntries.forEach(([name, blob, filename]) => form.append(name, blob, filename));
+	form.append(`payload_json`, payloadJson);
+	return form;
+};
+/**
+* Sentinel symbol used to mark a validated body as multipart-eligible.
+* Read by the request layer at serialization time.
+*
+* The marker is attached as a non-enumerable property on the parsed
+* body so it doesn't leak into JSON serialization or the TypeScript
+* output type.
+*/
+const MULTIPART_MARKER = Symbol.for(`@discordkit/core/multipart`);
+/**
+* Returns true if `body` should be serialized as `multipart/form-data`.
+*
+* Two signals trigger multipart serialization:
+*
+* 1. **Schema-tagged** — the body was parsed by a {@link multipart}-wrapped
+*    schema and at least one {@link FileUpload} was present. The wrapper
+*    stamps a non-enumerable {@link MULTIPART_MARKER} on the parsed value.
+*    This is the fast path for the validated flow (e.g., `toValidated`).
+*
+* 2. **Value-detected** — the body contains a {@link FileUpload} anywhere
+*    in its shape, regardless of whether it was validated. This safety net
+*    keeps consumers who bypass validation from silently dropping their
+*    files into a JSON body where `Blob` would serialize as `{}`.
+*
+* Either signal switches the request to multipart.
+*/
+const shouldSerializeAsMultipart = (body) => {
+	if (typeof body !== `object` || body === null) return false;
+	if (body[MULTIPART_MARKER] === true) return true;
+	return collectFileUploads(body).length > 0;
+};
+function multipart(entries, options) {
+	const base = v.object(entries);
+	const inner = options?.partial ? v.partial(base) : base;
+	return v.pipe(inner, v.transform((parsed) => {
+		if (!(collectFileUploads(parsed).length > 0)) return parsed;
+		return Object.defineProperty(parsed, MULTIPART_MARKER, {
+			value: true,
+			enumerable: false,
+			configurable: false,
+			writable: false
+		});
+	}));
+}
+//#endregion
+export { MULTIPART_MARKER, collectFileUploads, fileUpload, isFileUpload, multipart, shouldSerializeAsMultipart, toMultipartBody };
+
+//# sourceMappingURL=fileUpload.mjs.map

package/dist/validations/fileUpload.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"fileUpload.mjs","names":[],"sources":["../../src/validations/fileUpload.ts"],"sourcesContent":["import * as v from \"valibot\";\nimport { isObject } from \"../utils/isObject.js\";\n\n/**\n * The shape of a single file upload — used wherever a Discord endpoint\n * accepts an attached file via `multipart/form-data`.\n *\n * @example\n * ```ts\n * await executeWebhook({\n *   webhook: \"...\",\n *   token: \"...\",\n *   body: {\n *     content: \"Look at this!\",\n *     files: [\n *       { filename: \"photo.png\", content: new Blob([bytes], { type: \"image/png\" }) }\n *     ]\n *   }\n * });\n * ```\n */\nexport interface FileUpload {\n  /** Filename including extension. Required for the multipart `Content-Disposition` header. */\n  filename: string;\n  /** The binary content. Accepts a web-standard `Blob` or `File`. */\n  content: Blob;\n  /** Optional MIME type. If omitted, taken from the `Blob`'s `type` property. */\n  contentType?: string;\n}\n\n/** Type guard — true if `val` looks like a {@link FileUpload}. */\nexport const isFileUpload = (val: unknown): val is FileUpload => {\n  if (!isObject(val)) return false;\n  // Blob is a global in Node 18+, the browser, and all current runtimes.\n  // We test via duck-typing on `arrayBuffer` to avoid the `instanceof`\n  // cross-realm pitfall.\n  const content = val.content as { arrayBuffer?: unknown } | undefined;\n  return (\n    typeof val.filename === `string` &&\n    typeof content?.arrayBuffer === `function`\n  );\n};\n\n/**\n * Valibot schema for a single file upload. Validates the shape and\n * surfaces a clean TypeScript type to consumers.\n */\nexport const fileUpload: v.GenericSchema<FileUpload> = v.pipe(\n  v.custom<FileUpload>(isFileUpload, `Expected a FileUpload object`),\n  v.title(`fileUpload`)\n);\n\n/**\n * Walks a value and returns all {@link FileUpload}s within it, along\n * with the path each one occupies.\n */\nexport const collectFileUploads = (\n  val: unknown,\n  path: ReadonlyArray<string | number> = []\n): ReadonlyArray<{\n  readonly path: ReadonlyArray<string | number>;\n  readonly file: FileUpload;\n}> => {\n  if (isFileUpload(val)) return [{ path, file: val }];\n  if (Array.isArray(val)) {\n    return val.flatMap((item, i) => collectFileUploads(item, [...path, i]));\n  }\n  if (isObject(val)) {\n    return Object.entries(val).flatMap(([key, item]) =>\n      collectFileUploads(item, [...path, key])\n    );\n  }\n  return [];\n};\n\n/**\n * Returns a deep copy of `body` with the value at `path` replaced by\n * `replacement`. Pure: never mutates `body` or any of its children.\n */\nconst replaceAtPath = (\n  body: unknown,\n  path: ReadonlyArray<string | number>,\n  replacement: unknown\n): unknown => {\n  if (path.length === 0) return replacement;\n  const [head, ...rest] = path;\n  if (Array.isArray(body)) {\n    return body.map((item, index) =>\n      index === head ? replaceAtPath(item, rest, replacement) : item\n    );\n  }\n  if (isObject(body)) {\n    return Object.fromEntries(\n      Object.entries(body).map(([key, item]) => [\n        key,\n        key === head ? replaceAtPath(item, rest, replacement) : item\n      ])\n    );\n  }\n  return body;\n};\n\n/**\n * Given a body that contains one or more {@link FileUpload}s, produce\n * a `FormData` payload Discord can consume.\n *\n * Files are appended as `files[n]` parts; the rest of the body is\n * snake_cased and JSON-stringified into a `payload_json` part.\n *\n * Each FileUpload in the body is replaced by its attachment placeholder\n * `{ id: n }` so that an `attachments` array (if present) can reference\n * uploads by index. Discord matches these placeholders to the\n * corresponding `files[n]` parts.\n */\nexport const toMultipartBody = (\n  body: unknown,\n  // Loose enough to accept the real `toSnakeKeys` signature\n  // (`<T extends object>(o: T) => SnakeKeys<T>`).\n  // We cast at the call site since the payload is structurally an object.\n  toSnakeKeys: (val: object) => unknown\n): FormData => {\n  const uploads = collectFileUploads(body);\n  if (uploads.length === 0) {\n    throw new Error(\n      `toMultipartBody called with a body containing no FileUploads`\n    );\n  }\n  // Build the payload immutably: fold each upload's placeholder into the body.\n  const payload = uploads.reduce<unknown>(\n    (acc, { path }, index) => replaceAtPath(acc, path, { id: index }),\n    body\n  );\n  // Compose the FormData parts.\n  const fileEntries = uploads.map(({ file }, index) => {\n    const blob =\n      file.contentType && file.content.type !== file.contentType\n        ? new Blob([file.content], { type: file.contentType })\n        : file.content;\n    return [`files[${index}]`, blob, file.filename] as const;\n  });\n  // `payload` is `unknown` from the reduce; structurally it's always\n  // the same shape as `body`, which must be an object to contain uploads.\n  const payloadJson = new Blob(\n    [JSON.stringify(toSnakeKeys(payload as object))],\n    { type: `application/json` }\n  );\n  // The single side-effect: append parts to the FormData sink.\n  const form = new FormData();\n  fileEntries.forEach(([name, blob, filename]) =>\n    form.append(name, blob, filename)\n  );\n  form.append(`payload_json`, payloadJson);\n  return form;\n};\n\n/**\n * Sentinel symbol used to mark a validated body as multipart-eligible.\n * Read by the request layer at serialization time.\n *\n * The marker is attached as a non-enumerable property on the parsed\n * body so it doesn't leak into JSON serialization or the TypeScript\n * output type.\n */\nexport const MULTIPART_MARKER = Symbol.for(`@discordkit/core/multipart`);\n\n/**\n * Returns true if `body` should be serialized as `multipart/form-data`.\n *\n * Two signals trigger multipart serialization:\n *\n * 1. **Schema-tagged** — the body was parsed by a {@link multipart}-wrapped\n *    schema and at least one {@link FileUpload} was present. The wrapper\n *    stamps a non-enumerable {@link MULTIPART_MARKER} on the parsed value.\n *    This is the fast path for the validated flow (e.g., `toValidated`).\n *\n * 2. **Value-detected** — the body contains a {@link FileUpload} anywhere\n *    in its shape, regardless of whether it was validated. This safety net\n *    keeps consumers who bypass validation from silently dropping their\n *    files into a JSON body where `Blob` would serialize as `{}`.\n *\n * Either signal switches the request to multipart.\n */\nexport const shouldSerializeAsMultipart = (body: unknown): boolean => {\n  if (typeof body !== `object` || body === null) return false;\n  if ((body as Record<symbol, unknown>)[MULTIPART_MARKER] === true) return true;\n  return collectFileUploads(body).length > 0;\n};\n\n/**\n * Wraps an object schema to mark its body as a potential multipart payload.\n *\n * Use {@link multipart} instead of `v.object` whenever an endpoint's body\n * may contain one or more {@link fileUpload} fields (or arrays of them,\n * or optional uploads). The wrapper validates the same shape as\n * `v.object(entries)`. At validation time, the wrapper inspects the\n * parsed body for {@link FileUpload}s. If any are present, it stamps a\n * non-enumerable {@link MULTIPART_MARKER} on the result; the request\n * layer reads that marker at serialization time to choose between\n * `multipart/form-data` (marker present) and `application/json`\n * (marker absent).\n *\n * Pass `{ partial: true }` for endpoints where every field is optional —\n * the wrapper applies `v.partial(...)` to the inner object before piping\n * the transform. `v.partial` itself can't wrap the piped result (it only\n * accepts plain object schemas), so the option lives here.\n *\n * @example\n * ```ts\n * import { multipart, fileUpload } from \"@discordkit/core\";\n * import * as v from \"valibot\";\n *\n * export const updateAvatarSchema = v.object({\n *   body: multipart({\n *     avatar: v.exactOptional(fileUpload),\n *     bio: v.exactOptional(v.string())\n *   })\n * });\n *\n * // Every field optional:\n * export const editMessageSchema = v.object({\n *   body: multipart(\n *     { content: v.string(), files: v.array(fileUpload) },\n *     { partial: true }\n *   )\n * });\n * ```\n */\nexport function multipart<TEntries extends v.ObjectEntries>(\n  entries: TEntries\n): v.GenericSchema<v.InferOutput<v.ObjectSchema<TEntries, undefined>>>;\nexport function multipart<TEntries extends v.ObjectEntries>(\n  entries: TEntries,\n  options: { partial: true }\n): v.GenericSchema<\n  v.InferOutput<\n    v.SchemaWithPartial<v.ObjectSchema<TEntries, undefined>, undefined>\n  >\n>;\nexport function multipart<TEntries extends v.ObjectEntries>(\n  entries: TEntries,\n  options?: { partial?: boolean }\n): v.GenericSchema {\n  const base = v.object(entries);\n  const inner = options?.partial ? v.partial(base) : base;\n  // Wrap with a transform that stamps the marker if any FileUploads are present.\n  return v.pipe(\n    inner,\n    v.transform((parsed) => {\n      const hasFiles = collectFileUploads(parsed).length > 0;\n      if (!hasFiles) return parsed;\n      return Object.defineProperty(parsed, MULTIPART_MARKER, {\n        value: true,\n        enumerable: false,\n        configurable: false,\n        writable: false\n      });\n    })\n  );\n}\n"],"mappings":"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"}

package/dist/validations/hasMimeType.d.mts

@@ -0,0 +1,17 @@
+import { CheckAction } from "valibot";
+
+//#region src/validations/hasMimeType.d.ts
+/**
+ * Validation action to check if the given `datauri` string
+ * has one of the provided [MIME types](https://en.wikipedia.org/wiki/Media_type)
+ *
+ * @__NO_SIDE_EFFECTS__
+ */
+declare const hasMimeType: (/** an array of MIME types to validate against */
+
+requirement: Array<`${string}/${string}`>, /** an optional error message on failed validation */
+
+message?: "Received badly formatted Data URI") => CheckAction<string, typeof message>;
+//#endregion
+export { hasMimeType };
+//# sourceMappingURL=hasMimeType.d.mts.map

package/dist/validations/hasMimeType.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hasMimeType.d.mts","names":[],"sources":["../../src/validations/hasMimeType.ts"],"mappings":";;;;;AASA;;;;cAAa,WAAA;;AAEX,WAAA,EAAa,KAAA;;AAEb,OAAA,2CACC,WAAA,gBAA2B,OAAA"}

package/dist/validations/hasMimeType.mjs

@@ -0,0 +1,18 @@
+import { extractDataURIMetadata } from "./datauri.mjs";
+import { check } from "valibot";
+//#region src/validations/hasMimeType.ts
+/**
+* Validation action to check if the given `datauri` string
+* has one of the provided [MIME types](https://en.wikipedia.org/wiki/Media_type)
+*
+* @__NO_SIDE_EFFECTS__
+*/
+const hasMimeType = (requirement, message = `Received badly formatted Data URI`) => check((input) => {
+	const { mimeType } = extractDataURIMetadata(input);
+	if (typeof mimeType === `undefined`) return false;
+	return requirement.includes(mimeType);
+}, message);
+//#endregion
+export { hasMimeType };
+
+//# sourceMappingURL=hasMimeType.mjs.map

package/dist/validations/hasMimeType.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"hasMimeType.mjs","names":[],"sources":["../../src/validations/hasMimeType.ts"],"sourcesContent":["import { check, type CheckAction } from \"valibot\";\nimport { extractDataURIMetadata } from \"./datauri.js\";\n\n/**\n * Validation action to check if the given `datauri` string\n * has one of the provided [MIME types](https://en.wikipedia.org/wiki/Media_type)\n *\n * @__NO_SIDE_EFFECTS__\n */\nexport const hasMimeType = (\n  /** an array of MIME types to validate against */\n  requirement: Array<`${string}/${string}`>,\n  /** an optional error message on failed validation */\n  message = `Received badly formatted Data URI` as const\n): CheckAction<string, typeof message> =>\n  check((input: string) => {\n    const { mimeType } = extractDataURIMetadata(input);\n    if (typeof mimeType === `undefined`) {\n      return false;\n    }\n    return requirement.includes(mimeType);\n  }, message);\n"],"mappings":";;;;;;;;;AASA,MAAa,eAEX,aAEA,UAAU,wCAEV,OAAO,UAAkB;CACvB,MAAM,EAAE,aAAa,uBAAuB,KAAK;CACjD,IAAI,OAAO,aAAa,aACtB,OAAO;CAET,OAAO,YAAY,SAAS,QAAQ;AACtC,GAAG,OAAO"}