lunibee 0.2.2 → 0.2.4

package/dist/managers/member.d.ts

@@ -2,6 +2,8 @@ import { REST } from "@lunibee/rest";
 import { GuildMember, type ResourceContext } from "@lunibee/structures";
 import { ResourceManager } from "./base.js";
 export interface MemberEditOptions {
+    /** Audit-log reason. */
+    reason?: string;
     nick?: string | null;
     roles?: string[];
     mute?: boolean;
@@ -23,9 +25,9 @@ export declare class GuildMemberManager extends ResourceManager<string, GuildMem
     kick(userId: string, reason?: string): Promise<void>;
     /** Bans a user from the guild. */
     ban(userId: string, options?: BanOptions): Promise<void>;
-    /** Unbans a user from the guild. */
-    unban(userId: string): Promise<void>;
-    /** Edits a guild member (nickname, roles, timeout, mute, deaf). @param reason Audit-log reason. */
+    /** Unbans a user from the guild. @param reason Audit-log reason. */
+    unban(userId: string, reason?: string): Promise<void>;
+    /** Edits a guild member (nickname, roles, timeout, mute, deaf). Put the audit-log reason in `options.reason`. @param reason Deprecated: use `options.reason`. Removed in 0.3.0. */
     edit(userId: string, options: MemberEditOptions, reason?: string): Promise<GuildMember>;
     /** Adds a role to a member. @param reason Audit-log reason. */
     addRole(userId: string, roleId: string, reason?: string): Promise<void>;

package/dist/managers/message.d.ts

@@ -7,7 +7,8 @@ export interface MessageCacheOptions {
     /** Sliding TTL in ms. Omit for no expiry. */
     ttl?: number;
 }
-import { REST } from "@lunibee/rest";
+import { REST, type RESTFileAttachment } from "@lunibee/rest";
+import type { AllowedMentions } from "@lunibee/types";
 import { Message, type ResourceContext } from "@lunibee/structures";
 /** A file to upload with a message. */
 export interface MessageFile {
@@ -26,12 +27,15 @@ export type MessageEditOptions = MessageCreateOptions;
  * data as UTF-8. `allowedMentions` is the client's default, applied only when
  * the payload has no `allowed_mentions` of its own.
  */
-export declare function toRequest(options: MessageCreateOptions, allowedMentions?: unknown): unknown;
+export declare function toRequest(options: MessageCreateOptions, allowedMentions?: AllowedMentions): Omit<MessageCreateOptions, "files"> | {
+    body: Omit<MessageCreateOptions, "files">;
+    files: RESTFileAttachment[];
+};
 export declare class MessageManager {
     #private;
     /** Cached messages; always empty unless a message cache is configured. */
     readonly cache: Collection<string, Message>;
-    constructor(rest: REST, context: ResourceContext, channelId: string, cache?: MessageCacheOptions, allowedMentions?: unknown);
+    constructor(rest: REST, context: ResourceContext, channelId: string, cache?: MessageCacheOptions, allowedMentions?: AllowedMentions);
     resolve(messageId: string): Promise<Message>;
     send(options: MessageCreateOptions): Promise<Message>;
     fetch(messageId: string): Promise<Message>;

package/dist/managers/role.d.ts

@@ -29,6 +29,18 @@ export declare class RoleManager extends ResourceManager<string, Role> {
     create(options: RoleCreateOptions): Promise<Role>;
     /** Edits an existing role. */
     edit(roleId: string, options: RoleEditOptions): Promise<Role>;
-    /** Deletes a role from the guild. */
+    /** Deletes a role. @param reason Audit-log reason. */
+    remove(roleId: string, reason?: string): Promise<void>;
+    /**
+     * Moves roles in the hierarchy. Discord shifts the other roles around them.
+     * @param positions Each role's ID and its new position.
+     * @param reason Audit-log reason.
+     * @returns Every role in the guild, in their new order.
+     */
+    setPositions(positions: readonly {
+        id: string;
+        position: number;
+    }[], reason?: string): Promise<Role[]>;
+    /** @deprecated Use {@link RoleManager.remove}, which also takes an audit-log reason. Removed in 0.3.0. */
     deleteRole(roleId: string): Promise<void>;
 }

package/dist/rest/error-codes.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Discord JSON error codes that bots commonly handle, by name, for comparing
+ * with `RESTError.code`: `if (error.code === RESTErrorCode.UnknownMessage) …`.
+ *
+ * Values are from Discord's "JSON Error Codes" table
+ * (discord/discord-api-docs, developers/topics/opcodes-and-status-codes.mdx,
+ * checked at commit 86f0a46). Any other code is still available as a number
+ * on `RESTError.code`.
+ */
+export declare const RESTErrorCode: {
+    readonly UnknownAccount: 10001;
+    readonly UnknownChannel: 10003;
+    readonly UnknownGuild: 10004;
+    readonly UnknownInvite: 10006;
+    readonly UnknownMember: 10007;
+    readonly UnknownMessage: 10008;
+    readonly UnknownPermissionOverwrite: 10009;
+    readonly UnknownRole: 10011;
+    readonly UnknownUser: 10013;
+    readonly UnknownEmoji: 10014;
+    readonly UnknownWebhook: 10015;
+    readonly UnknownBan: 10026;
+    readonly UnknownSticker: 10060;
+    readonly UnknownInteraction: 10062;
+    readonly UnknownScheduledEvent: 10070;
+    readonly BotsCannotUseEndpoint: 20001;
+    readonly MaxGuilds: 30001;
+    readonly MaxPins: 30003;
+    readonly MaxRoles: 30005;
+    readonly MaxWebhooks: 30007;
+    readonly MaxEmojis: 30008;
+    readonly MaxReactions: 30010;
+    readonly MaxChannels: 30013;
+    readonly InteractionAlreadyAcknowledged: 40060;
+    readonly MissingAccess: 50001;
+    readonly CannotExecuteInDM: 50003;
+    readonly CannotEditOthersMessage: 50005;
+    readonly CannotSendEmptyMessage: 50006;
+    readonly CannotSendMessagesToUser: 50007;
+    readonly MissingPermissions: 50013;
+    readonly InvalidToken: 50014;
+    readonly MessageTooOldToBulkDelete: 50034;
+    readonly InvalidFormBody: 50035;
+    readonly ThreadArchived: 50083;
+    readonly CannotReplyWithoutReadHistory: 160002;
+};
+/** One {@link RESTErrorCode} value, usable as a type. */
+export type RESTErrorCode = (typeof RESTErrorCode)[keyof typeof RESTErrorCode];

package/dist/rest/errors.d.ts

@@ -28,12 +28,20 @@ export type RESTErrorKind =
 export declare function redactPath(path: string): string;
 /** Error thrown when Discord rejects a REST request. */
 export declare class RESTError extends Error {
-    /** Failure category. */ readonly kind: RESTErrorKind;
-    /** HTTP status returned by Discord. */ readonly status: number;
-    /** Discord API error code, when provided. */ readonly code?: number;
-    /** Raw Discord validation/error payload. */ readonly errors?: unknown;
-    /** HTTP method used for the failed request. */ readonly method?: string;
-    /** API path used for the failed request. */ readonly path?: string;
+    /** Failure category. */
+    readonly kind: RESTErrorKind;
+    /** HTTP status returned by Discord. */
+    readonly status: number;
+    /** Discord API error code, when provided. */
+    readonly code?: number;
+    /** Raw Discord validation/error payload. */
+    readonly errors?: unknown;
+    /** HTTP method used for the failed request. */
+    readonly method?: string;
+    /** API path used for the failed request. */
+    readonly path?: string;
+    /** What to check next, for errors with a common cause (missing access or permissions). */
+    readonly hint?: string;
     /** Creates a REST error with request context. @param message Error message. @param status HTTP status. @param code Discord error code. @param errors Raw error payload. @param options Request context and cause. */
     constructor(message: string, status: number, code?: number, errors?: unknown, options?: {
         method?: string;

package/dist/rest/index.d.ts

@@ -16,11 +16,16 @@ export interface RESTFileAttachment {
  * `reason`, `auth`) additively without changing that positional default.
  */
 export interface RESTRequestOptions {
-    /** Abort signal used to cancel the request and any queued wait. */ signal?: AbortSignal;
-    /** Query-string appended to the path (`URLSearchParams`, a record, or a raw string). */ query?: RESTQuery;
-    /** Extra request headers merged in (library headers such as `Authorization` win). */ headers?: Record<string, string>;
-    /** Audit-log reason, sent as the `X-Audit-Log-Reason` header. */ reason?: string;
-    /** Set `false` to omit the `Authorization` header for this request. Defaults to `true`. */ auth?: boolean;
+    /** Abort signal used to cancel the request and any queued wait. */
+    signal?: AbortSignal;
+    /** Query-string appended to the path (`URLSearchParams`, a record, or a raw string). */
+    query?: RESTQuery;
+    /** Extra request headers merged in (library headers such as `Authorization` win). */
+    headers?: Record<string, string>;
+    /** Audit-log reason, sent as the `X-Audit-Log-Reason` header. */
+    reason?: string;
+    /** Set `false` to omit the `Authorization` header for this request. Defaults to `true`. */
+    auth?: boolean;
 }
 /**
  * Discord.js-familiar request payload. Superset of {@link RESTRequestOptions} that also
@@ -28,8 +33,10 @@ export interface RESTRequestOptions {
  * additive `method(path, { body })` overloads without breaking the positional signature.
  */
 export interface RequestData extends RESTRequestOptions {
-    /** Request body. Encoded as JSON unless `files` are present (then multipart). */ body?: unknown;
-    /** File attachments; presence upgrades the request to `multipart/form-data`. */ files?: RESTFileAttachment[];
+    /** Request body. Encoded as JSON unless `files` are present (then multipart). */
+    body?: unknown;
+    /** File attachments; presence upgrades the request to `multipart/form-data`. */
+    files?: RESTFileAttachment[];
 }
 /** Context passed to `RESTHooks.onRequest`. */
 export interface RESTRequestContext {
@@ -81,9 +88,12 @@ export interface RESTHooks {
 }
 /** Configures which REST failures may be retried. */
 export interface RetryPolicy {
-    /** Maximum retry attempts. */ maxRetries: number;
-    /** Determines whether a request may be retried. @param method HTTP method. @param status HTTP status, or zero for transport errors. @returns True when retrying is safe under the policy. */ shouldRetry(method: string, status: number): boolean;
-    /** Calculates delay before the next attempt. @param attempt Zero-based retry number. @param retryAfter Server-provided delay, when available. @returns Delay in milliseconds. */ getDelay(attempt: number, retryAfter?: number): number;
+    /** Maximum retry attempts. */
+    maxRetries: number;
+    /** Determines whether a request may be retried. @param method HTTP method. @param status HTTP status, or zero for transport errors. @returns True when retrying is safe under the policy. */
+    shouldRetry(method: string, status: number): boolean;
+    /** Calculates delay before the next attempt. @param attempt Zero-based retry number. @param retryAfter Server-provided delay, when available. @returns Delay in milliseconds. */
+    getDelay(attempt: number, retryAfter?: number): number;
 }
 /** Creates the default conservative REST retry policy. @param maxRetries Maximum retries. @returns Retry policy that retries rate limits and idempotent transient failures. @throws {TypeError} If maxRetries is negative or not finite. */
 export declare function createRetryPolicy(maxRetries?: number): RetryPolicy;
@@ -126,7 +136,8 @@ export declare class REST {
      * @throws {RESTError} If Discord or transport rejects the request.
      */
     request<T>(method: string, path: string, body?: unknown, options?: RequestData): Promise<T>;
-    /** Sends a GET request. @param path API path. @param options Request options (`query`, `headers`, `signal`, …). @returns Decoded response. @throws {RESTError} When the request fails. */ get<T>(path: string, options?: RequestData): Promise<T>;
+    /** Sends a GET request. @param path API path. @param options Request options (`query`, `headers`, `signal`, …). @returns Decoded response. @throws {RESTError} When the request fails. */
+    get<T>(path: string, options?: RequestData): Promise<T>;
     /** Sends a POST request. Accepts a raw body (`post(path, body)`) or a Discord.js-familiar `post(path, { body })`. @param path API path. @param body Optional JSON body, or a `RequestData` wrapper. @param options Request options. @returns Decoded response. @throws {RESTError} When the request fails. */
     post<T>(path: string, options: RequestData): Promise<T>;
     post<T>(path: string, body?: unknown, options?: RequestData): Promise<T>;
@@ -136,7 +147,8 @@ export declare class REST {
     /** Sends a PUT request. Accepts a raw body (`put(path, body)`) or a Discord.js-familiar `put(path, { body })`. @param path API path. @param body Optional JSON body, or a `RequestData` wrapper. @param options Request options. @returns Decoded response. @throws {RESTError} When the request fails. */
     put<T>(path: string, options: RequestData): Promise<T>;
     put<T>(path: string, body?: unknown, options?: RequestData): Promise<T>;
-    /** Sends a DELETE request. @param path API path. @param options Request options (`reason`, `headers`, `signal`, …). @returns Decoded response. @throws {RESTError} When the request fails. */ delete<T>(path: string, options?: RequestData): Promise<T>;
+    /** Sends a DELETE request. @param path API path. @param options Request options (`reason`, `headers`, `signal`, …). @returns Decoded response. @throws {RESTError} When the request fails. */
+    delete<T>(path: string, options?: RequestData): Promise<T>;
     /**
      * Sends a multipart/form-data POST request for file uploads.
      * Attaches a JSON payload as `payload_json` and files as additional fields.
@@ -161,6 +173,7 @@ export declare class REST {
 }
 export { Routes } from "./routes.js";
 export { RESTError, abortError, redactPath, type RESTErrorKind, } from "./errors.js";
+export { RESTErrorCode } from "./error-codes.js";
 export { createRouteKey, normalizeRoutePath, majorParameter, scopeBucket, serializeQuery, type RouteKey, type RESTQuery, } from "./route.js";
 export { RequestScheduler } from "./scheduler.js";
 export { RateLimiter } from "./limiter.js";

package/dist/rest/index.js

@@ -2,12 +2,15 @@
 // packages/rest/package.json
 var package_default = {
   name: "@lunibee/rest",
-  version: "0.2.2",
+  version: "0.2.4",
   type: "module",
   module: "./src/index.ts",
   types: "./src/index.ts",
   exports: {
     ".": "./src/index.ts"
+  },
+  dependencies: {
+    "@lunibee/types": "workspace:*"
   }
 };
 
@@ -80,8 +83,12 @@ function kindFromStatus(status) {
   return "client";
 }
 function redactPath(path) {
-  return path.replace(/^(\/webhooks\/[^/?]+\/)[^/?]+/, "$1:token").replace(/^(\/interactions\/[^/?]+\/)[^/?]+/, "$1:token");
+  return path.replace(/^(\/webhooks\/[^/?]+\/)[^/?]+/i, "$1:token").replace(/^(\/interactions\/[^/?]+\/)[^/?]+/i, "$1:token");
 }
+var HINTS = {
+  50001: "The bot cannot see this resource: check that it is in the guild and has View Channel there.",
+  50013: "The bot lacks a permission for this action, or the target role or member is at or above the bot's highest role."
+};
 
 class RESTError extends Error {
   kind;
@@ -90,12 +97,14 @@ class RESTError extends Error {
   errors;
   method;
   path;
+  hint;
   constructor(message, status, code, errors, options = {}) {
     super(message, options.cause === undefined ? undefined : { cause: options.cause });
     this.name = "RESTError";
     this.status = status;
     this.kind = options.kind ?? kindFromStatus(status);
     this.code = code;
+    this.hint = code === undefined ? undefined : HINTS[code];
     this.errors = errors;
     this.method = options.method;
     this.path = options.path === undefined ? undefined : redactPath(options.path);
@@ -133,19 +142,23 @@ async function abortable(promise, signal, path) {
 }
 
 // packages/rest/src/route.ts
+import { createHash } from "crypto";
 function normalizeRoutePath(path) {
   const queryIndex = path.indexOf("?");
   const routePath = queryIndex === -1 ? path : path.slice(0, queryIndex);
-  return routePath.replace(/\/\d+(?=\/|$)/g, "/:id");
+  return redactPath(routePath).replace(/\/\d+(?=\/|$)/g, "/:id");
 }
 function majorParameter(path) {
-  const match = /^\/(channels|guilds|webhooks)\/(\d+)(?:\/([^/?]+))?/.exec(path);
+  const match = /^\/(channels|guilds|webhooks)\/(\d+)(?:\/([^/?]+))?/i.exec(path);
   if (!match)
     return "@none";
-  if (match[1] === "webhooks" && match[3] !== undefined)
-    return `${match[2]}:${match[3]}`;
+  if (match[1].toLowerCase() === "webhooks" && match[3] !== undefined)
+    return `${match[2]}:${tokenDigest(match[3])}`;
   return match[2];
 }
+function tokenDigest(token) {
+  return createHash("sha256").update(token).digest("hex").slice(0, 16);
+}
 function scopeBucket(hashOrRoute, major) {
   return `${hashOrRoute}|${major}`;
 }
@@ -387,6 +400,9 @@ var Routes = {
   user: () => "/users/@me",
   userById: (userId) => `/users/${snowflake(userId, "User ID")}`,
   guild: (guildId) => `/guilds/${snowflake(guildId, "Guild ID")}`,
+  currentUserGuild: (guildId) => `/users/@me/guilds/${snowflake(guildId, "Guild ID")}`,
+  sticker: (stickerId) => `/stickers/${snowflake(stickerId, "Sticker ID")}`,
+  messageReactionUser: (channelId, messageId, emoji, userId) => `${Routes.messageReactions(channelId, messageId, emoji)}/${snowflake(userId, "User ID")}`,
   guildPreview: (guildId) => `/guilds/${snowflake(guildId, "Guild ID")}/preview`,
   guildActiveThreads: (guildId) => `/guilds/${snowflake(guildId, "Guild ID")}/threads/active`,
   guildWebhooks: (guildId) => `/guilds/${snowflake(guildId, "Guild ID")}/webhooks`,
@@ -404,6 +420,8 @@ var Routes = {
   crosspostMessage: (channelId, messageId) => `${Routes.message(channelId, messageId)}/crosspost`,
   messageReactions: (channelId, messageId, emoji) => `${Routes.message(channelId, messageId)}/reactions/${encodeURIComponent(emoji)}`,
   messageReactionsAll: (channelId, messageId) => `${Routes.message(channelId, messageId)}/reactions`,
+  channelMessagesPins: (channelId) => `/channels/${snowflake(channelId, "Channel ID")}/messages/pins`,
+  channelMessagesPin: (channelId, messageId) => `/channels/${snowflake(channelId, "Channel ID")}/messages/pins/${snowflake(messageId, "Message ID")}`,
   channelPins: (channelId) => `/channels/${snowflake(channelId, "Channel ID")}/pins`,
   channelPin: (channelId, messageId) => `/channels/${snowflake(channelId, "Channel ID")}/pins/${snowflake(messageId, "Message ID")}`,
   messageThread: (channelId, messageId) => `${Routes.message(channelId, messageId)}/threads`,
@@ -462,6 +480,44 @@ function snowflake(value, field) {
     throw new TypeError(`${field} must be a valid Discord snowflake.`);
   return value;
 }
+// packages/rest/src/error-codes.ts
+var RESTErrorCode = {
+  UnknownAccount: 10001,
+  UnknownChannel: 10003,
+  UnknownGuild: 10004,
+  UnknownInvite: 10006,
+  UnknownMember: 10007,
+  UnknownMessage: 10008,
+  UnknownPermissionOverwrite: 10009,
+  UnknownRole: 10011,
+  UnknownUser: 10013,
+  UnknownEmoji: 10014,
+  UnknownWebhook: 10015,
+  UnknownBan: 10026,
+  UnknownSticker: 10060,
+  UnknownInteraction: 10062,
+  UnknownScheduledEvent: 10070,
+  BotsCannotUseEndpoint: 20001,
+  MaxGuilds: 30001,
+  MaxPins: 30003,
+  MaxRoles: 30005,
+  MaxWebhooks: 30007,
+  MaxEmojis: 30008,
+  MaxReactions: 30010,
+  MaxChannels: 30013,
+  InteractionAlreadyAcknowledged: 40060,
+  MissingAccess: 50001,
+  CannotExecuteInDM: 50003,
+  CannotEditOthersMessage: 50005,
+  CannotSendEmptyMessage: 50006,
+  CannotSendMessagesToUser: 50007,
+  MissingPermissions: 50013,
+  InvalidToken: 50014,
+  MessageTooOldToBulkDelete: 50034,
+  InvalidFormBody: 50035,
+  ThreadArchived: 50083,
+  CannotReplyWithoutReadHistory: 160002
+};
 // packages/rest/src/redis.ts
 var RESERVE_SCRIPT = `
 local raw = redis.call('GET', KEYS[1])
@@ -608,7 +664,7 @@ class WebhookClient {
   #rest;
   constructor(options, restOptions) {
     if (options.url) {
-      const match = options.url.match(/discord(?:app)?.com\/api\/webhooks\/(\d+)\/([A-Za-z0-9_-]+)/);
+      const match = options.url.match(/^https:\/\/(?:(?:ptb|canary)\.)?discord(?:app)?\.com\/api(?:\/v\d+)?\/webhooks\/(\d{1,20})\/([A-Za-z0-9_-]+)\/?(?:[?#].*)?$/);
       if (!match)
         throw new Error("Invalid Discord webhook URL format.");
       this.id = match[1];
@@ -623,13 +679,20 @@ class WebhookClient {
   }
   async send(options) {
     const payload = typeof options === "string" ? { content: options } : options;
-    const { thread_id, ...body } = payload;
-    const query = thread_id ? `?thread_id=${thread_id}&wait=true` : `?wait=true`;
+    const { thread_id, files, ...body } = payload;
+    const params = new URLSearchParams({ wait: "true" });
+    if (thread_id)
+      params.set("thread_id", String(thread_id));
+    const query = `?${params}`;
     const formattedEmbeds = body.embeds?.map((e) => ("toJSON" in e) ? e.toJSON() : e);
-    return this.#rest.post(`${Routes.webhook(this.id, this.token)}${query}`, {
+    const formattedComponents = body.components?.map((c) => ("toJSON" in c) ? c.toJSON() : c);
+    const path = `${Routes.webhook(this.id, this.token)}${query}`;
+    const json = {
       ...body,
-      embeds: formattedEmbeds
-    });
+      embeds: formattedEmbeds,
+      components: formattedComponents
+    };
+    return files?.length ? this.#rest.postWithFiles(path, json, files) : this.#rest.post(path, json);
   }
   async editMessage(messageId, options) {
     const payload = typeof options === "string" ? { content: options } : options;
@@ -643,7 +706,23 @@ class WebhookClient {
 // packages/rest/src/index.ts
 var LIBRARY_VERSION = package_default.version;
 var LIBRARY_URL = "https://github.com/Ekretos/lunibee";
-var USER_AGENT = `DiscordBot (${LIBRARY_URL}, ${package_default.version})`;
+var USER_AGENT = `DiscordBot (${LIBRARY_URL}, ${LIBRARY_VERSION})`;
+function assertSafePath(path) {
+  const end = path.search(/[?#]/);
+  const pathname = end === -1 ? path : path.slice(0, end);
+  if (pathname.includes("\\"))
+    throw new TypeError("REST paths must not contain backslashes.");
+  for (const segment of pathname.split("/")) {
+    let decoded;
+    try {
+      decoded = decodeURIComponent(segment);
+    } catch {
+      throw new TypeError("REST path has malformed percent-encoding.");
+    }
+    if (decoded === "." || decoded === "..")
+      throw new TypeError("REST paths must not contain '.' or '..' segments.");
+  }
+}
 var REQUEST_DATA_KEYS = new Set([
   "body",
   "files",
@@ -728,6 +807,7 @@ class REST {
       throw new TypeError("REST method is required.");
     if (!path.startsWith("/"))
       throw new TypeError("REST paths must start with '/'.");
+    assertSafePath(path);
     const route = createRouteKey(method, path);
     const files = options.files;
     if (files && files.length > 0 && !(body instanceof FormData))
@@ -815,13 +895,19 @@ class REST {
   #headers(body, options) {
     const isFormData = typeof FormData !== "undefined" && body instanceof FormData;
     const headers = { ...options.headers };
+    const set = (name, value) => {
+      for (const key of Object.keys(headers))
+        if (key.toLowerCase() === name.toLowerCase())
+          delete headers[key];
+      headers[name] = value;
+    };
     if (options.auth !== false && this.#token)
-      headers["Authorization"] = `Bot ${this.#token}`;
-    headers["User-Agent"] = USER_AGENT;
+      set("Authorization", `Bot ${this.#token}`);
+    set("User-Agent", USER_AGENT);
     if (options.reason !== undefined)
-      headers["X-Audit-Log-Reason"] = encodeURIComponent(options.reason);
+      set("X-Audit-Log-Reason", encodeURIComponent(options.reason));
     if (!isFormData)
-      headers["Content-Type"] = "application/json";
+      set("Content-Type", "application/json");
     return headers;
   }
   #encodeBody(body) {
@@ -882,6 +968,7 @@ export {
   MemoryRateLimitStore,
   REST,
   RESTError,
+  RESTErrorCode,
   RateLimiter,
   RedisRateLimitStore,
   RequestScheduler,
@@ -899,4 +986,4 @@ export {
   serializeQuery
 };
 
-//# debugId=F0FC46139368BF7D64756E2164756E21
+//# debugId=51D994350F46554C64756E2164756E21