@discordjs/rest 1.7.0-dev.1679918672-b8b852e.0 → 1.7.0

package/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 All notable changes to this project will be documented in this file.
 
+# [@discordjs/rest@1.7.0](https://github.com/discordjs/discord.js/compare/@discordjs/rest@1.6.0...@discordjs/rest@1.7.0) - (2023-04-01)
+
+## Bug Fixes
+
+- **handlers:** Create burst handler for interaction callbacks (#8996) ([db8df10](https://github.com/discordjs/discord.js/commit/db8df104c5e70a12f35b54e5f3f7c897068dde6f))
+- **scripts:** Accessing tsComment ([d8d5f31](https://github.com/discordjs/discord.js/commit/d8d5f31d3927fd1de62f1fa3a1a6e454243ad87b))
+- **rest:** Remove `const enum`s in favour of regular enums (#9243) ([229ad07](https://github.com/discordjs/discord.js/commit/229ad077ff52d8706d68ed4d31983619a32eba45))
+
+## Features
+
+- **website:** Render syntax and mdx on the server (#9086) ([ee5169e](https://github.com/discordjs/discord.js/commit/ee5169e0aadd7bbfcd752aae614ec0f69602b68b))
+
 # [@discordjs/rest@1.6.0](https://github.com/discordjs/discord.js/compare/@discordjs/rest@1.5.0...@discordjs/rest@1.6.0) - (2023-03-12)
 
 ## Bug Fixes

package/README.md

@@ -16,6 +16,10 @@
 	</p>
 </div>
 
+## About
+
+`@discord.js/rest` is a module that allows you to easily make REST requests to the Discord API.
+
 ## Installation
 
 **Node.js 16.9.0 or newer is required.**
@@ -80,7 +84,7 @@ try {
 - [Website][website] ([source][website-source])
 - [Documentation][documentation]
 - [Guide][guide] ([source][guide-source])
-  See also the [Update Guide][guide-update], including updated and removed items in the library.
+  Also see the v13 to v14 [Update Guide][guide-update], which includes updated and removed items from the library.
 - [discord.js Discord server][discord]
 - [Discord API Discord server][discord-api]
 - [GitHub][source]
@@ -95,12 +99,11 @@ See [the contribution guide][contributing] if you'd like to submit a PR.
 
 ## Help
 
-If you don't understand something in the documentation, you are experiencing problems, or you just need a gentle
-nudge in the right direction, please don't hesitate to join our official [discord.js Server][discord].
+If you don't understand something in the documentation, you are experiencing problems, or you just need a gentle nudge in the right direction, please don't hesitate to join our official [discord.js Server][discord].
 
-[website]: https://discord.js.org/
+[website]: https://discord.js.org
 [website-source]: https://github.com/discordjs/discord.js/tree/main/apps/website
-[documentation]: https://discord.js.org/#/docs/rest
+[documentation]: https://discord.js.org/docs/packages/rest/stable
 [guide]: https://discordjs.guide/
 [guide-source]: https://github.com/discordjs/guide
 [guide-update]: https://discordjs.guide/additional-info/changes-in-v14.html

package/dist/index.d.ts

@@ -5,6 +5,10 @@ import { URLSearchParams } from 'node:url';
 import { Collection } from '@discordjs/collection';
 
 declare const DefaultUserAgent: `DiscordBot (https://discord.js.org, ${string})`;
+/**
+ * The default string to append onto the user agent.
+ */
+declare const DefaultUserAgentAppendix: string;
 declare const DefaultRestOptions: {
     readonly agent: Agent;
     readonly api: "https://discord.com/api";
@@ -17,7 +21,7 @@ declare const DefaultRestOptions: {
     readonly rejectOnRateLimit: null;
     readonly retries: 3;
     readonly timeout: 15000;
-    readonly userAgentAppendix: `Node.js ${string}`;
+    readonly userAgentAppendix: string;
     readonly version: "10";
     readonly hashSweepInterval: 14400000;
     readonly hashLifetime: 86400000;
@@ -43,6 +47,7 @@ type ImageSize = (typeof ALLOWED_SIZES)[number];
 declare const OverwrittenMimeTypes: {
     readonly 'image/apng': "image/png";
 };
+declare const BurstHandlerMajorIdKey = "burst";
 
 /**
  * The options used for image URLs
@@ -360,7 +365,7 @@ interface RESTOptions {
     /**
      * Extra information to add to the user agent
      *
-     * @defaultValue `Node.js ${process.version}`
+     * @defaultValue DefaultUserAgentAppendix
      */
     userAgentAppendix: string;
     /**
@@ -867,4 +872,4 @@ declare function parseResponse(res: Dispatcher.ResponseData): Promise<unknown>;
  */
 declare const version: string;
 
-export { ALLOWED_EXTENSIONS, ALLOWED_SIZES, ALLOWED_STICKER_EXTENSIONS, APIRequest, BaseImageURLOptions, CDN, DefaultRestOptions, DefaultUserAgent, DiscordAPIError, DiscordErrorData, HTTPError, HandlerRequestData, HashData, ImageExtension, ImageSize, ImageURLOptions, InternalRequest, InvalidRequestWarningData, MakeURLOptions, OAuthErrorData, OverwrittenMimeTypes, REST, RESTEvents, RESTOptions, RateLimitData, RateLimitError, RateLimitQueueFilter, RawFile, RequestBody, RequestData, RequestHeaders, RequestManager, RequestMethod, RequestOptions, RestEvents, RouteData, RouteLike, StickerExtension, makeURLSearchParams, parseResponse, version };
+export { ALLOWED_EXTENSIONS, ALLOWED_SIZES, ALLOWED_STICKER_EXTENSIONS, APIRequest, BaseImageURLOptions, BurstHandlerMajorIdKey, CDN, DefaultRestOptions, DefaultUserAgent, DefaultUserAgentAppendix, DiscordAPIError, DiscordErrorData, HTTPError, HandlerRequestData, HashData, ImageExtension, ImageSize, ImageURLOptions, InternalRequest, InvalidRequestWarningData, MakeURLOptions, OAuthErrorData, OverwrittenMimeTypes, REST, RESTEvents, RESTOptions, RateLimitData, RateLimitError, RateLimitQueueFilter, RawFile, RequestBody, RequestData, RequestHeaders, RequestManager, RequestMethod, RequestOptions, RestEvents, RouteData, RouteLike, StickerExtension, makeURLSearchParams, parseResponse, version };

package/dist/index.js

@@ -34,9 +34,11 @@ __export(src_exports, {
   ALLOWED_EXTENSIONS: () => ALLOWED_EXTENSIONS,
   ALLOWED_SIZES: () => ALLOWED_SIZES,
   ALLOWED_STICKER_EXTENSIONS: () => ALLOWED_STICKER_EXTENSIONS,
+  BurstHandlerMajorIdKey: () => BurstHandlerMajorIdKey,
   CDN: () => CDN,
   DefaultRestOptions: () => DefaultRestOptions,
   DefaultUserAgent: () => DefaultUserAgent,
+  DefaultUserAgentAppendix: () => DefaultUserAgentAppendix,
   DiscordAPIError: () => DiscordAPIError,
   HTTPError: () => HTTPError,
   OverwrittenMimeTypes: () => OverwrittenMimeTypes,
@@ -58,7 +60,8 @@ var import_node_url = require("url");
 var import_node_process = __toESM(require("process"));
 var import_v10 = require("discord-api-types/v10");
 var import_undici = require("undici");
-var DefaultUserAgent = `DiscordBot (https://discord.js.org, 1.7.0-dev.1679918672-b8b852e.0)`;
+var DefaultUserAgent = `DiscordBot (https://discord.js.org, 1.7.0)`;
+var DefaultUserAgentAppendix = import_node_process.default.release?.name === "node" ? `Node.js/${import_node_process.default.version}` : "";
 var DefaultRestOptions = {
   get agent() {
     return new import_undici.Agent({
@@ -77,7 +80,7 @@ var DefaultRestOptions = {
   rejectOnRateLimit: null,
   retries: 3,
   timeout: 15e3,
-  userAgentAppendix: `Node.js ${import_node_process.default.version}`,
+  userAgentAppendix: DefaultUserAgentAppendix,
   version: import_v10.APIVersion,
   hashSweepInterval: 144e5,
   // 4 Hours
@@ -102,6 +105,7 @@ var OverwrittenMimeTypes = {
   // https://github.com/discordjs/discord.js/issues/8557
   "image/apng": "image/png"
 };
+var BurstHandlerMajorIdKey = "burst";
 
 // src/lib/CDN.ts
 var CDN = class {
@@ -437,11 +441,8 @@ var import_util = require("@discordjs/util");
 var import_snowflake = require("@sapphire/snowflake");
 var import_undici4 = require("undici");
 
-// src/lib/handlers/SequentialHandler.ts
-var import_node_timers = require("timers");
+// src/lib/handlers/BurstHandler.ts
 var import_promises = require("timers/promises");
-var import_async_queue = require("@sapphire/async-queue");
-var import_undici3 = require("undici");
 
 // src/lib/utils/utils.ts
 var import_node_buffer = require("buffer");
@@ -552,10 +553,199 @@ function shouldRetry(error) {
   return "code" in error && error.code === "ECONNRESET" || error.message.includes("ECONNRESET");
 }
 __name(shouldRetry, "shouldRetry");
+async function onRateLimit(manager, rateLimitData) {
+  const { options } = manager;
+  if (!options.rejectOnRateLimit)
+    return;
+  const shouldThrow = typeof options.rejectOnRateLimit === "function" ? await options.rejectOnRateLimit(rateLimitData) : options.rejectOnRateLimit.some((route) => rateLimitData.route.startsWith(route.toLowerCase()));
+  if (shouldThrow) {
+    throw new RateLimitError(rateLimitData);
+  }
+}
+__name(onRateLimit, "onRateLimit");
 
-// src/lib/handlers/SequentialHandler.ts
+// src/lib/handlers/Shared.ts
+var import_node_timers = require("timers");
+var import_undici3 = require("undici");
 var invalidCount = 0;
 var invalidCountResetTime = null;
+function incrementInvalidCount(manager) {
+  if (!invalidCountResetTime || invalidCountResetTime < Date.now()) {
+    invalidCountResetTime = Date.now() + 1e3 * 60 * 10;
+    invalidCount = 0;
+  }
+  invalidCount++;
+  const emitInvalid = manager.options.invalidRequestWarningInterval > 0 && invalidCount % manager.options.invalidRequestWarningInterval === 0;
+  if (emitInvalid) {
+    manager.emit("invalidRequestWarning" /* InvalidRequestWarning */, {
+      count: invalidCount,
+      remainingTime: invalidCountResetTime - Date.now()
+    });
+  }
+}
+__name(incrementInvalidCount, "incrementInvalidCount");
+async function makeNetworkRequest(manager, routeId, url, options, requestData, retries) {
+  const controller = new AbortController();
+  const timeout = (0, import_node_timers.setTimeout)(() => controller.abort(), manager.options.timeout).unref();
+  if (requestData.signal) {
+    const signal = requestData.signal;
+    if (signal.aborted)
+      controller.abort();
+    else
+      signal.addEventListener("abort", () => controller.abort());
+  }
+  let res;
+  try {
+    res = await (0, import_undici3.request)(url, { ...options, signal: controller.signal });
+  } catch (error) {
+    if (!(error instanceof Error))
+      throw error;
+    if (shouldRetry(error) && retries !== manager.options.retries) {
+      return null;
+    }
+    throw error;
+  } finally {
+    (0, import_node_timers.clearTimeout)(timeout);
+  }
+  if (manager.listenerCount("response" /* Response */)) {
+    manager.emit(
+      "response" /* Response */,
+      {
+        method: options.method ?? "get",
+        path: routeId.original,
+        route: routeId.bucketRoute,
+        options,
+        data: requestData,
+        retries
+      },
+      { ...res }
+    );
+  }
+  return res;
+}
+__name(makeNetworkRequest, "makeNetworkRequest");
+async function handleErrors(manager, res, method, url, requestData, retries) {
+  const status = res.statusCode;
+  if (status >= 500 && status < 600) {
+    if (retries !== manager.options.retries) {
+      return null;
+    }
+    throw new HTTPError(status, method, url, requestData);
+  } else {
+    if (status >= 400 && status < 500) {
+      if (status === 401 && requestData.auth) {
+        manager.setToken(null);
+      }
+      const data = await parseResponse(res);
+      throw new DiscordAPIError(data, "code" in data ? data.code : data.error, status, method, url, requestData);
+    }
+    return res;
+  }
+}
+__name(handleErrors, "handleErrors");
+
+// src/lib/handlers/BurstHandler.ts
+var BurstHandler = class {
+  /**
+   * @param manager - The request manager
+   * @param hash - The hash that this RequestHandler handles
+   * @param majorParameter - The major parameter for this handler
+   */
+  constructor(manager, hash, majorParameter) {
+    this.manager = manager;
+    this.hash = hash;
+    this.majorParameter = majorParameter;
+    this.id = `${hash}:${majorParameter}`;
+  }
+  /**
+   * {@inheritdoc IHandler.id}
+   */
+  id;
+  /**
+   * {@inheritDoc IHandler.inactive}
+   */
+  inactive = false;
+  /**
+   * Emits a debug message
+   *
+   * @param message - The message to debug
+   */
+  debug(message) {
+    this.manager.emit("restDebug" /* Debug */, `[REST ${this.id}] ${message}`);
+  }
+  /**
+   * {@inheritDoc IHandler.queueRequest}
+   */
+  async queueRequest(routeId, url, options, requestData) {
+    return this.runRequest(routeId, url, options, requestData);
+  }
+  /**
+   * The method that actually makes the request to the API, and updates info about the bucket accordingly
+   *
+   * @param routeId - The generalized API route with literal ids for major parameters
+   * @param url - The fully resolved URL to make the request to
+   * @param options - The fetch options needed to make the request
+   * @param requestData - Extra data from the user's request needed for errors and additional processing
+   * @param retries - The number of retries this request has already attempted (recursion)
+   */
+  async runRequest(routeId, url, options, requestData, retries = 0) {
+    const method = options.method ?? "get";
+    const res = await makeNetworkRequest(this.manager, routeId, url, options, requestData, retries);
+    if (res === null) {
+      return this.runRequest(routeId, url, options, requestData, ++retries);
+    }
+    const status = res.statusCode;
+    let retryAfter = 0;
+    const retry = parseHeader(res.headers["retry-after"]);
+    if (retry)
+      retryAfter = Number(retry) * 1e3 + this.manager.options.offset;
+    if (status === 401 || status === 403 || status === 429) {
+      incrementInvalidCount(this.manager);
+    }
+    if (status >= 200 && status < 300) {
+      return res;
+    } else if (status === 429) {
+      const isGlobal = res.headers["x-ratelimit-global"] !== void 0;
+      await onRateLimit(this.manager, {
+        timeToReset: retryAfter,
+        limit: Number.POSITIVE_INFINITY,
+        method,
+        hash: this.hash,
+        url,
+        route: routeId.bucketRoute,
+        majorParameter: this.majorParameter,
+        global: isGlobal
+      });
+      this.debug(
+        [
+          "Encountered unexpected 429 rate limit",
+          `  Global         : ${isGlobal}`,
+          `  Method         : ${method}`,
+          `  URL            : ${url}`,
+          `  Bucket         : ${routeId.bucketRoute}`,
+          `  Major parameter: ${routeId.majorParameter}`,
+          `  Hash           : ${this.hash}`,
+          `  Limit          : ${Number.POSITIVE_INFINITY}`,
+          `  Retry After    : ${retryAfter}ms`,
+          `  Sublimit       : None`
+        ].join("\n")
+      );
+      await (0, import_promises.setTimeout)(retryAfter);
+      return this.runRequest(routeId, url, options, requestData, retries);
+    } else {
+      const handled = await handleErrors(this.manager, res, method, url, requestData, retries);
+      if (handled === null) {
+        return this.runRequest(routeId, url, options, requestData, ++retries);
+      }
+      return handled;
+    }
+  }
+};
+__name(BurstHandler, "BurstHandler");
+
+// src/lib/handlers/SequentialHandler.ts
+var import_promises2 = require("timers/promises");
+var import_async_queue = require("@sapphire/async-queue");
 var SequentialHandler = class {
   /**
    * @param manager - The request manager
@@ -644,21 +834,9 @@ var SequentialHandler = class {
    * @param time - The amount of time to delay all requests for
    */
   async globalDelayFor(time) {
-    await (0, import_promises.setTimeout)(time);
+    await (0, import_promises2.setTimeout)(time);
     this.manager.globalDelay = null;
   }
-  /*
-   * Determines whether the request should be queued or whether a RateLimitError should be thrown
-   */
-  async onRateLimit(rateLimitData) {
-    const { options } = this.manager;
-    if (!options.rejectOnRateLimit)
-      return;
-    const shouldThrow = typeof options.rejectOnRateLimit === "function" ? await options.rejectOnRateLimit(rateLimitData) : options.rejectOnRateLimit.some((route) => rateLimitData.route.startsWith(route.toLowerCase()));
-    if (shouldThrow) {
-      throw new RateLimitError(rateLimitData);
-    }
-  }
   /**
    * {@inheritDoc IHandler.queueRequest}
    */
@@ -707,22 +885,22 @@ var SequentialHandler = class {
     while (this.limited) {
       const isGlobal = this.globalLimited;
       let limit2;
-      let timeout2;
+      let timeout;
       let delay;
       if (isGlobal) {
         limit2 = this.manager.options.globalRequestsPerSecond;
-        timeout2 = this.manager.globalReset + this.manager.options.offset - Date.now();
+        timeout = this.manager.globalReset + this.manager.options.offset - Date.now();
         if (!this.manager.globalDelay) {
-          this.manager.globalDelay = this.globalDelayFor(timeout2);
+          this.manager.globalDelay = this.globalDelayFor(timeout);
         }
         delay = this.manager.globalDelay;
       } else {
         limit2 = this.limit;
-        timeout2 = this.timeToReset;
-        delay = (0, import_promises.setTimeout)(timeout2);
+        timeout = this.timeToReset;
+        delay = (0, import_promises2.setTimeout)(timeout);
       }
       const rateLimitData = {
-        timeToReset: timeout2,
+        timeToReset: timeout,
         limit: limit2,
         method: options.method ?? "get",
         hash: this.hash,
@@ -732,11 +910,11 @@ var SequentialHandler = class {
         global: isGlobal
       };
       this.manager.emit("rateLimited" /* RateLimited */, rateLimitData);
-      await this.onRateLimit(rateLimitData);
+      await onRateLimit(this.manager, rateLimitData);
       if (isGlobal) {
-        this.debug(`Global rate limit hit, blocking all requests for ${timeout2}ms`);
+        this.debug(`Global rate limit hit, blocking all requests for ${timeout}ms`);
       } else {
-        this.debug(`Waiting ${timeout2}ms for rate limit to pass`);
+        this.debug(`Waiting ${timeout}ms for rate limit to pass`);
       }
       await delay;
     }
@@ -746,41 +924,9 @@ var SequentialHandler = class {
     }
     this.manager.globalRemaining--;
     const method = options.method ?? "get";
-    const controller = new AbortController();
-    const timeout = (0, import_node_timers.setTimeout)(() => controller.abort(), this.manager.options.timeout).unref();
-    if (requestData.signal) {
-      const signal = requestData.signal;
-      if (signal.aborted)
-        controller.abort();
-      else
-        signal.addEventListener("abort", () => controller.abort());
-    }
-    let res;
-    try {
-      res = await (0, import_undici3.request)(url, { ...options, signal: controller.signal });
-    } catch (error) {
-      if (!(error instanceof Error))
-        throw error;
-      if (shouldRetry(error) && retries !== this.manager.options.retries) {
-        return await this.runRequest(routeId, url, options, requestData, ++retries);
-      }
-      throw error;
-    } finally {
-      (0, import_node_timers.clearTimeout)(timeout);
-    }
-    if (this.manager.listenerCount("response" /* Response */)) {
-      this.manager.emit(
-        "response" /* Response */,
-        {
-          method,
-          path: routeId.original,
-          route: routeId.bucketRoute,
-          options,
-          data: requestData,
-          retries
-        },
-        { ...res }
-      );
+    const res = await makeNetworkRequest(this.manager, routeId, url, options, requestData, retries);
+    if (res === null) {
+      return this.runRequest(routeId, url, options, requestData, ++retries);
     }
     const status = res.statusCode;
     let retryAfter = 0;
@@ -813,34 +959,23 @@ var SequentialHandler = class {
       }
     }
     if (status === 401 || status === 403 || status === 429) {
-      if (!invalidCountResetTime || invalidCountResetTime < Date.now()) {
-        invalidCountResetTime = Date.now() + 1e3 * 60 * 10;
-        invalidCount = 0;
-      }
-      invalidCount++;
-      const emitInvalid = this.manager.options.invalidRequestWarningInterval > 0 && invalidCount % this.manager.options.invalidRequestWarningInterval === 0;
-      if (emitInvalid) {
-        this.manager.emit("invalidRequestWarning" /* InvalidRequestWarning */, {
-          count: invalidCount,
-          remainingTime: invalidCountResetTime - Date.now()
-        });
-      }
+      incrementInvalidCount(this.manager);
     }
     if (status >= 200 && status < 300) {
       return res;
     } else if (status === 429) {
       const isGlobal = this.globalLimited;
       let limit2;
-      let timeout2;
+      let timeout;
       if (isGlobal) {
         limit2 = this.manager.options.globalRequestsPerSecond;
-        timeout2 = this.manager.globalReset + this.manager.options.offset - Date.now();
+        timeout = this.manager.globalReset + this.manager.options.offset - Date.now();
       } else {
         limit2 = this.limit;
-        timeout2 = this.timeToReset;
+        timeout = this.timeToReset;
       }
-      await this.onRateLimit({
-        timeToReset: timeout2,
+      await onRateLimit(this.manager, {
+        timeToReset: timeout,
         limit: limit2,
         method,
         hash: this.hash,
@@ -872,7 +1007,7 @@ var SequentialHandler = class {
         }
         this.#sublimitPromise?.resolve();
         this.#sublimitPromise = null;
-        await (0, import_promises.setTimeout)(sublimitTimeout);
+        await (0, import_promises2.setTimeout)(sublimitTimeout);
         let resolve;
         const promise = new Promise((res2) => resolve = res2);
         this.#sublimitPromise = { promise, resolve };
@@ -882,20 +1017,12 @@ var SequentialHandler = class {
         }
       }
       return this.runRequest(routeId, url, options, requestData, retries);
-    } else if (status >= 500 && status < 600) {
-      if (retries !== this.manager.options.retries) {
-        return this.runRequest(routeId, url, options, requestData, ++retries);
-      }
-      throw new HTTPError(status, method, url, requestData);
     } else {
-      if (status >= 400 && status < 500) {
-        if (status === 401 && requestData.auth) {
-          this.manager.setToken(null);
-        }
-        const data = await parseResponse(res);
-        throw new DiscordAPIError(data, "code" in data ? data.code : data.error, status, method, url, requestData);
+      const handled = await handleErrors(this.manager, res, method, url, requestData, retries);
+      if (handled === null) {
+        return this.runRequest(routeId, url, options, requestData, ++retries);
       }
-      return res;
+      return handled;
     }
   }
 };
@@ -1036,7 +1163,7 @@ var RequestManager = class extends import_node_events.EventEmitter {
    * @internal
    */
   createHandler(hash, majorParameter) {
-    const queue = new SequentialHandler(this, hash, majorParameter);
+    const queue = majorParameter === BurstHandlerMajorIdKey ? new BurstHandler(this, hash, majorParameter) : new SequentialHandler(this, hash, majorParameter);
     this.handlers.set(queue.id, queue);
     return queue;
   }
@@ -1137,6 +1264,13 @@ var RequestManager = class extends import_node_events.EventEmitter {
    * @internal
    */
   static generateRouteData(endpoint, method) {
+    if (endpoint.startsWith("/interactions/") && endpoint.endsWith("/callback")) {
+      return {
+        majorParameter: BurstHandlerMajorIdKey,
+        bucketRoute: "/interactions/:id/:token/callback",
+        original: endpoint
+      };
+    }
     const majorIdMatch = /^\/(?:channels|guilds|webhooks)\/(\d{17,19})/.exec(endpoint);
     const majorId = majorIdMatch?.[1] ?? "global";
     const baseRoute = endpoint.replaceAll(/\d{17,19}/g, ":id").replace(/\/reactions\/(.*)/, "/reactions/:reaction");
@@ -1265,15 +1399,17 @@ var REST = class extends import_node_events2.EventEmitter {
 __name(REST, "REST");
 
 // src/index.ts
-var version = "1.7.0-dev.1679918672-b8b852e.0";
+var version = "1.7.0";
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ALLOWED_EXTENSIONS,
   ALLOWED_SIZES,
   ALLOWED_STICKER_EXTENSIONS,
+  BurstHandlerMajorIdKey,
   CDN,
   DefaultRestOptions,
   DefaultUserAgent,
+  DefaultUserAgentAppendix,
   DiscordAPIError,
   HTTPError,
   OverwrittenMimeTypes,