@discordkit/core 3.2.0 → 4.0.0

package/dist/requests/verifyKey.mjs

@@ -0,0 +1,63 @@
+//#region src/requests/verifyKey.ts
+/**
+* Get the SubtleCrypto interface for the current environment
+*/
+const getSubtleCrypto = () => {
+	if (typeof globalThis.crypto !== `undefined`) return globalThis.crypto.subtle;
+	if (typeof global !== `undefined` && global.crypto?.subtle) return global.crypto.subtle;
+	if (typeof window !== `undefined` && window.crypto?.subtle) return window.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 };

package/dist/utils/isBetween.d.mts

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

package/dist/utils/isBetween.mjs

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

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,6 @@
  * }
  * ```
  */
-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 };

package/dist/utils/isNonNullable.mjs

@@ -0,0 +1,22 @@
+//#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 };

package/dist/utils/isNumericString.d.mts

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

package/dist/utils/isNumericString.mjs

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

package/dist/utils/isObject.d.mts

@@ -0,0 +1,4 @@
+//#region src/utils/isObject.d.ts
+declare const isObject: (val: unknown) => val is object;
+//#endregion
+export { isObject };

package/dist/utils/isObject.mjs

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

package/dist/utils/sleep.d.mts

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

package/dist/utils/sleep.mjs

@@ -0,0 +1,7 @@
+//#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 };

package/dist/utils/toCamelCase.d.mts

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

package/dist/utils/toCamelCase.mjs

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

package/dist/utils/toCamelKeys.d.mts

@@ -0,0 +1,6 @@
+import { CamelCasedPropertiesDeep } from "type-fest";
+
+//#region src/utils/toCamelKeys.d.ts
+declare const toCamelKeys: <T extends object>(o: T) => CamelCasedPropertiesDeep<T>;
+//#endregion
+export { toCamelKeys };

package/dist/utils/toCamelKeys.mjs

@@ -0,0 +1,13 @@
+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 };

package/dist/utils/toSnakeCase.d.mts

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

package/dist/utils/toSnakeCase.mjs

@@ -0,0 +1,4 @@
+//#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 };

package/dist/utils/toSnakeKeys.d.mts

@@ -0,0 +1,6 @@
+import { SnakeCasedPropertiesDeep } from "type-fest";
+
+//#region src/utils/toSnakeKeys.d.ts
+declare const toSnakeKeys: <T extends object>(o: T) => SnakeCasedPropertiesDeep<T>;
+//#endregion
+export { toSnakeKeys };

package/dist/utils/toSnakeKeys.mjs

@@ -0,0 +1,13 @@
+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 };

package/dist/validations/asDigits.d.mts

@@ -0,0 +1,12 @@
+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 };

package/dist/validations/asDigits.mjs

@@ -0,0 +1,10 @@
+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 };

package/dist/validations/asInteger.d.mts

@@ -0,0 +1,12 @@
+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 };

package/dist/validations/asInteger.mjs

@@ -0,0 +1,10 @@
+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 };

package/dist/validations/bitfield.d.mts

@@ -0,0 +1,23 @@
+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 };

package/dist/validations/bitfield.mjs

@@ -0,0 +1,20 @@
+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 };

package/dist/validations/boundedArray.d.mts

@@ -0,0 +1,13 @@
+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 };

package/dist/validations/boundedArray.mjs

@@ -0,0 +1,9 @@
+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 };

package/dist/validations/boundedInteger.d.mts

@@ -0,0 +1,13 @@
+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 };

package/dist/validations/boundedInteger.mjs

@@ -0,0 +1,9 @@
+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 };

package/dist/validations/boundedString.d.mts

@@ -0,0 +1,14 @@
+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 };

package/dist/validations/boundedString.mjs

@@ -0,0 +1,10 @@
+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 };

package/dist/validations/datauri.d.mts

@@ -0,0 +1,24 @@
+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 };

package/dist/validations/datauri.mjs

@@ -0,0 +1,17 @@
+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 };

package/dist/validations/fileUpload.d.mts

@@ -0,0 +1,129 @@
+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 };