seyfert 0.1.0

package/lib/api/handlers/SequentialHandler.js

@@ -0,0 +1,365 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SequentialHandler = void 0;
+const async_queue_1 = require("@sapphire/async-queue");
+const utils_js_1 = require("../utils/utils.js");
+const Shared_js_1 = require("./Shared.js");
+var QueueType;
+(function (QueueType) {
+    QueueType[QueueType["Standard"] = 0] = "Standard";
+    QueueType[QueueType["Sublimit"] = 1] = "Sublimit";
+})(QueueType || (QueueType = {}));
+/**
+ * The structure used to handle sequential requests for a given bucket
+ */
+class SequentialHandler {
+    manager;
+    hash;
+    majorParameter;
+    /**
+     * {@inheritDoc IHandler.id}
+     */
+    id;
+    /**
+     * The time this rate limit bucket will reset
+     */
+    reset = -1;
+    /**
+     * The remaining requests that can be made before we are rate limited
+     */
+    remaining = 1;
+    /**
+     * The total number of requests that can be made before we are rate limited
+     */
+    limit = Number.POSITIVE_INFINITY;
+    /**
+     * The interface used to sequence async requests sequentially
+     */
+    #asyncQueue = new async_queue_1.AsyncQueue();
+    /**
+     * The interface used to sequence sublimited async requests sequentially
+     */
+    #sublimitedQueue = null;
+    /**
+     * A promise wrapper for when the sublimited queue is finished being processed or null when not being processed
+     */
+    #sublimitPromise = null;
+    /**
+     * Whether the sublimit queue needs to be shifted in the finally block
+     */
+    #shiftSublimit = false;
+    /**
+     * @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.inactive}
+     */
+    get inactive() {
+        return (this.#asyncQueue.remaining === 0 &&
+            (this.#sublimitedQueue === null || this.#sublimitedQueue.remaining === 0) &&
+            !this.limited);
+    }
+    /**
+     * If the rate limit bucket is currently limited by the global limit
+     */
+    get globalLimited() {
+        return this.manager.globalRemaining <= 0 && Date.now() < this.manager.globalReset;
+    }
+    /**
+     * If the rate limit bucket is currently limited by its limit
+     */
+    get localLimited() {
+        return this.remaining <= 0 && Date.now() < this.reset;
+    }
+    /**
+     * If the rate limit bucket is currently limited
+     */
+    get limited() {
+        return this.globalLimited || this.localLimited;
+    }
+    /**
+     * The time until queued requests can continue
+     */
+    get timeToReset() {
+        return this.reset + this.manager.options.offset - Date.now();
+    }
+    /**
+     * Emits a debug message
+     *
+     * @param message - The message to debug
+     */
+    debug(message) {
+        this.manager.debugger?.info(`#${this.id} ${message}`);
+    }
+    /**
+     * Delay all requests for the specified amount of time, handling global rate limits
+     *
+     * @param time - The amount of time to delay all requests for
+     */
+    async globalDelayFor(time) {
+        await (0, utils_js_1.sleep)(time);
+        this.manager.globalDelay = null;
+    }
+    /**
+     * {@inheritDoc IHandler.queueRequest}
+     */
+    async queueRequest(routeId, url, options, requestData) {
+        let queue = this.#asyncQueue;
+        let queueType = QueueType.Standard;
+        // Separate sublimited requests when already sublimited
+        if (this.#sublimitedQueue && (0, utils_js_1.hasSublimit)(routeId.bucketRoute, requestData.body, options.method)) {
+            queue = this.#sublimitedQueue;
+            queueType = QueueType.Sublimit;
+        }
+        // Wait for any previous requests to be completed before this one is run
+        await queue.wait({ signal: requestData.signal });
+        // This set handles retroactively sublimiting requests
+        if (queueType === QueueType.Standard) {
+            if (this.#sublimitedQueue && (0, utils_js_1.hasSublimit)(routeId.bucketRoute, requestData.body, options.method)) {
+                /**
+                 * Remove the request from the standard queue, it should never be possible to get here while processing the
+                 * sublimit queue so there is no need to worry about shifting the wrong request
+                 */
+                queue = this.#sublimitedQueue;
+                const wait = queue.wait();
+                this.#asyncQueue.shift();
+                await wait;
+            }
+            else if (this.#sublimitPromise) {
+                // Stall requests while the sublimit queue gets processed
+                await this.#sublimitPromise.promise;
+            }
+        }
+        try {
+            // Make the request, and return the results
+            return this.runRequest(routeId, url, options, requestData);
+        }
+        finally {
+            // Allow the next request to fire
+            queue.shift();
+            if (this.#shiftSublimit) {
+                this.#shiftSublimit = false;
+                this.#sublimitedQueue?.shift();
+            }
+            // If this request is the last request in a sublimit
+            if (this.#sublimitedQueue?.remaining === 0) {
+                this.#sublimitPromise?.resolve();
+                this.#sublimitedQueue = null;
+            }
+        }
+    }
+    /**
+     * 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) {
+        /*
+         * After calculations have been done, pre-emptively stop further requests
+         * Potentially loop until this task can run if e.g. the global rate limit is hit twice
+         */
+        while (this.limited) {
+            const isGlobal = this.globalLimited;
+            let limit;
+            let timeout;
+            let delay;
+            if (isGlobal) {
+                // Set RateLimitData based on the global limit
+                limit = this.manager.options.globalRequestsPerSecond;
+                timeout = this.manager.globalReset + this.manager.options.offset - Date.now();
+                // If this is the first task to reach the global timeout, set the global delay
+                if (!this.manager.globalDelay) {
+                    // The global delay function clears the global delay state when it is resolved
+                    this.manager.globalDelay = this.globalDelayFor(timeout);
+                }
+                delay = this.manager.globalDelay;
+            }
+            else {
+                // Set RateLimitData based on the route-specific limit
+                limit = this.limit;
+                timeout = this.timeToReset;
+                delay = (0, utils_js_1.sleep)(timeout);
+            }
+            const rateLimitData = {
+                global: isGlobal,
+                method: options.method ?? 'get',
+                url,
+                route: routeId.bucketRoute,
+                majorParameter: this.majorParameter,
+                hash: this.hash,
+                limit,
+                timeToReset: timeout,
+                retryAfter: timeout,
+                sublimitTimeout: 0,
+                scope: 'user',
+            };
+            // Let library users know they have hit a rate limit
+            this.manager.debugger?.info(rateLimitData);
+            // Determine whether a RateLimitError should be thrown
+            await (0, utils_js_1.onRateLimit)(this.manager, rateLimitData);
+            // When not erroring, emit debug for what is happening
+            if (isGlobal) {
+                this.debug(`Global rate limit hit, blocking all requests for ${timeout}ms`);
+            }
+            else {
+                this.debug(`Waiting ${timeout}ms for rate limit to pass`);
+            }
+            // Wait the remaining time left before the rate limit resets
+            await delay;
+        }
+        // As the request goes out, update the global usage information
+        if (!this.manager.globalReset || this.manager.globalReset < Date.now()) {
+            this.manager.globalReset = Date.now() + 1_000;
+            this.manager.globalRemaining = this.manager.options.globalRequestsPerSecond;
+        }
+        this.manager.globalRemaining--;
+        const method = options.method ?? 'get';
+        const res = await (0, Shared_js_1.makeNetworkRequest)(this.manager, routeId, url, options, requestData, retries);
+        // Retry requested
+        if (res === null) {
+            // eslint-disable-next-line no-param-reassign
+            return this.runRequest(routeId, url, options, requestData, ++retries);
+        }
+        const status = res.status;
+        let retryAfter = 0;
+        const limit = res.headers.get('X-RateLimit-Limit');
+        const remaining = res.headers.get('X-RateLimit-Remaining');
+        const reset = res.headers.get('X-RateLimit-Reset-After');
+        const hash = res.headers.get('X-RateLimit-Bucket');
+        const retry = res.headers.get('Retry-After');
+        const scope = (res.headers.get('X-RateLimit-Scope') ?? 'user');
+        // Update the total number of requests that can be made before the rate limit resets
+        this.limit = limit ? Number(limit) : Number.POSITIVE_INFINITY;
+        // Update the number of remaining requests that can be made before the rate limit resets
+        this.remaining = remaining ? Number(remaining) : 1;
+        // Update the time when this rate limit resets (reset-after is in seconds)
+        this.reset = reset ? Number(reset) * 1_000 + Date.now() + this.manager.options.offset : Date.now();
+        // Amount of time in milliseconds until we should retry if rate limited (globally or otherwise)
+        if (retry)
+            retryAfter = Number(retry) * 1_000 + this.manager.options.offset;
+        // Handle buckets via the hash header retroactively
+        if (hash && hash !== this.hash) {
+            // Let library users know when rate limit buckets have been updated
+            this.debug(['Received bucket hash update', `  Old Hash  : ${this.hash}`, `  New Hash  : ${hash}`].join('\n'));
+            // This queue will eventually be eliminated via attrition
+            this.manager.hashes.set(`${method}:${routeId.bucketRoute}`, { value: hash, lastAccess: Date.now() });
+        }
+        else if (hash) {
+            // Handle the case where hash value doesn't change
+            // Fetch the hash data from the manager
+            const hashData = this.manager.hashes.get(`${method}:${routeId.bucketRoute}`);
+            // When fetched, update the last access of the hash
+            if (hashData) {
+                hashData.lastAccess = Date.now();
+            }
+        }
+        // Handle retryAfter, which means we have actually hit a rate limit
+        let sublimitTimeout = null;
+        if (retryAfter > 0) {
+            if (res.headers.has('X-RateLimit-Global')) {
+                this.manager.globalRemaining = 0;
+                this.manager.globalReset = Date.now() + retryAfter;
+            }
+            else if (!this.localLimited) {
+                /*
+                 * This is a sublimit (e.g. 2 channel name changes/10 minutes) since the headers don't indicate a
+                 * route-wide rate limit. Don't update remaining or reset to avoid rate limiting the whole
+                 * endpoint, just set a reset time on the request itself to avoid retrying too soon.
+                 */
+                sublimitTimeout = retryAfter;
+            }
+        }
+        // Count the invalid requests
+        if (status === 401 || status === 403 || status === 429) {
+            (0, Shared_js_1.incrementInvalidCount)(this.manager);
+        }
+        if (res.ok) {
+            return res;
+        }
+        if (status === 429) {
+            // A rate limit was hit - this may happen if the route isn't associated with an official bucket hash yet, or when first globally rate limited
+            const isGlobal = this.globalLimited;
+            let limit;
+            let timeout;
+            if (isGlobal) {
+                // Set RateLimitData based on the global limit
+                limit = this.manager.options.globalRequestsPerSecond;
+                timeout = this.manager.globalReset + this.manager.options.offset - Date.now();
+            }
+            else {
+                // Set RateLimitData based on the route-specific limit
+                limit = this.limit;
+                timeout = this.timeToReset;
+            }
+            await (0, utils_js_1.onRateLimit)(this.manager, {
+                global: isGlobal,
+                method,
+                url,
+                route: routeId.bucketRoute,
+                majorParameter: this.majorParameter,
+                hash: this.hash,
+                limit,
+                timeToReset: timeout,
+                retryAfter,
+                sublimitTimeout: sublimitTimeout ?? 0,
+                scope,
+            });
+            this.debug([
+                'Encountered unexpected 429 rate limit',
+                `  Global         : ${isGlobal.toString()}`,
+                `  Method         : ${method}`,
+                `  URL            : ${url}`,
+                `  Bucket         : ${routeId.bucketRoute}`,
+                `  Major parameter: ${routeId.majorParameter}`,
+                `  Hash           : ${this.hash}`,
+                `  Limit          : ${limit}`,
+                `  Retry After    : ${retryAfter}ms`,
+                `  Sublimit       : ${sublimitTimeout ? `${sublimitTimeout}ms` : 'None'}`,
+                `  Scope          : ${scope}`,
+            ].join('\n'));
+            // If caused by a sublimit, wait it out here so other requests on the route can be handled
+            if (sublimitTimeout) {
+                // Normally the sublimit queue will not exist, however, if a sublimit is hit while in the sublimit queue, it will
+                const firstSublimit = !this.#sublimitedQueue;
+                if (firstSublimit) {
+                    this.#sublimitedQueue = new async_queue_1.AsyncQueue();
+                    void this.#sublimitedQueue.wait();
+                    this.#asyncQueue.shift();
+                }
+                this.#sublimitPromise?.resolve();
+                this.#sublimitPromise = null;
+                await (0, utils_js_1.sleep)(sublimitTimeout);
+                let resolve;
+                // eslint-disable-next-line promise/param-names, no-promise-executor-return
+                const promise = new Promise(res => (resolve = res));
+                this.#sublimitPromise = { promise, resolve: resolve };
+                if (firstSublimit) {
+                    // Re-queue this request so it can be shifted by the finally
+                    await this.#asyncQueue.wait();
+                    this.#shiftSublimit = true;
+                }
+            }
+            // Since this is not a server side issue, the next request should pass, so we don't bump the retries counter
+            return this.runRequest(routeId, url, options, requestData, retries);
+        }
+        const handled = await (0, Shared_js_1.handleErrors)(this.manager, res, method, url, requestData, retries);
+        if (handled === null) {
+            // eslint-disable-next-line no-param-reassign
+            return this.runRequest(routeId, url, options, requestData, ++retries);
+        }
+        return handled;
+    }
+}
+exports.SequentialHandler = SequentialHandler;

package/lib/api/handlers/Shared.d.ts

@@ -0,0 +1,14 @@
+import type { REST } from '../REST.js';
+import type { HandlerRequestData, ResponseLike } from '../utils/types.js';
+/**
+ * Handles 5xx and 4xx errors (not 429's) conventionally. 429's should be handled before calling this function
+ *
+ * @param manager - The manager that holds options and emits informational events
+ * @param res - The response received from {@link makeNetworkRequest}
+ * @param method - The method used to make the request
+ * @param url - The fully resolved url to make the request to
+ * @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 occurs on the handler)
+ * @returns The response if the status code is not handled or null to request a retry
+ */
+export declare function handleErrors(manager: REST, res: ResponseLike, method: string, url: string, requestData: HandlerRequestData, retries: number): Promise<ResponseLike | null>;

package/lib/api/handlers/Shared.js

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleErrors = exports.makeNetworkRequest = exports.incrementInvalidCount = void 0;
+const DiscordAPIError_js_1 = require("../errors/DiscordAPIError.js");
+const HTTPError_js_1 = require("../errors/HTTPError.js");
+const constants_js_1 = require("../utils/constants.js");
+const utils_js_1 = require("../utils/utils.js");
+/**
+ * Invalid request limiting is done on a per-IP basis, not a per-token basis.
+ * The best we can do is track invalid counts process-wide (on the theory that
+ * users could have multiple bots run from one process) rather than per-bot.
+ * Therefore, store these at file scope here rather than in the client's
+ * RESTManager object.
+ */
+let invalidCount = 0;
+let invalidCountResetTime = null;
+/**
+ * Increment the invalid request count and emit warning if necessary
+ *
+ * @internal
+ */
+function incrementInvalidCount(manager) {
+    if (!invalidCountResetTime || invalidCountResetTime < Date.now()) {
+        invalidCountResetTime = Date.now() + 1_000 * 60 * 10;
+        invalidCount = 0;
+    }
+    invalidCount++;
+    const emitInvalid = manager.options.invalidRequestWarningInterval > 0 &&
+        invalidCount % manager.options.invalidRequestWarningInterval === 0;
+    if (emitInvalid) {
+        // Let library users know periodically about invalid requests
+        manager.debugger?.info({
+            count: invalidCount,
+            remainingTime: invalidCountResetTime - Date.now(),
+        });
+    }
+}
+exports.incrementInvalidCount = incrementInvalidCount;
+/**
+ * Performs the actual network request for a request handler
+ *
+ * @param manager - The manager that holds options and emits informational events
+ * @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 occurs on the handler)
+ * @returns The respond from the network or `null` when the request should be retried
+ * @internal
+ */
+async function makeNetworkRequest(manager, routeId, url, options, requestData, retries) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), manager.options.timeout);
+    if (requestData.signal) {
+        // If the user signal was aborted, abort the controller, else abort the local signal.
+        // The reason why we don't re-use the user's signal, is because users may use the same signal for multiple
+        // requests, and we do not want to cause unexpected side-effects.
+        if (requestData.signal.aborted)
+            controller.abort();
+        else
+            requestData.signal.addEventListener('abort', () => controller.abort());
+    }
+    let res;
+    try {
+        res = await manager.options.makeRequest(url, { ...options, signal: controller.signal });
+    }
+    catch (error) {
+        if (!(error instanceof Error))
+            throw error;
+        // Retry the specified number of times if needed
+        if ((0, utils_js_1.shouldRetry)(error) && retries !== manager.options.retries) {
+            // Retry is handled by the handler upon receiving null
+            return null;
+        }
+        throw error;
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+    manager.debugger?.info(constants_js_1.RESTEvents.Response, {
+        method: options.method ?? 'get',
+        path: routeId.original,
+        route: routeId.bucketRoute,
+        options,
+        data: requestData,
+        retries,
+    }, res instanceof Response ? res.clone() : { ...res });
+    return res;
+}
+exports.makeNetworkRequest = makeNetworkRequest;
+/**
+ * Handles 5xx and 4xx errors (not 429's) conventionally. 429's should be handled before calling this function
+ *
+ * @param manager - The manager that holds options and emits informational events
+ * @param res - The response received from {@link makeNetworkRequest}
+ * @param method - The method used to make the request
+ * @param url - The fully resolved url to make the request to
+ * @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 occurs on the handler)
+ * @returns The response if the status code is not handled or null to request a retry
+ */
+async function handleErrors(manager, res, method, url, requestData, retries) {
+    const status = res.status;
+    if (status >= 500 && status < 600) {
+        // Retry the specified number of times for possible server side issues
+        if (retries !== manager.options.retries) {
+            return null;
+        }
+        // We are out of retries, throw an error
+        throw new HTTPError_js_1.HTTPError(status, res.statusText, method, url, requestData);
+    }
+    // Handle possible malformed requests
+    if (status >= 400 && status < 500) {
+        // If we receive this status code, it means the token we had is no longer valid.
+        if (status === 401 && requestData.auth) {
+            manager.setToken(null);
+        }
+        // The request will not succeed for some reason, parse the error returned from the api
+        const data = (await (0, utils_js_1.parseResponse)(res));
+        // throw the API error
+        throw new DiscordAPIError_js_1.DiscordAPIError(data, 'code' in data ? data.code : data.error, status, method, url, requestData);
+    }
+    return res;
+}
+exports.handleErrors = handleErrors;

package/lib/api/index.d.ts

@@ -0,0 +1,5 @@
+export * from './CDN';
+export * from './REST';
+export * from './Router';
+export * from './Routes';
+export * from './shared';

package/lib/api/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./CDN"), exports);
+__exportStar(require("./REST"), exports);
+__exportStar(require("./Router"), exports);
+__exportStar(require("./Routes"), exports);
+__exportStar(require("./shared"), exports);

package/lib/api/interfaces/Handler.d.ts

@@ -0,0 +1,21 @@
+import type { RequestInit } from 'undici-types';
+import type { HandlerRequestData, ResponseLike, RouteData } from '../utils/types.js';
+export interface IHandler {
+    /**
+     * The unique id of the handler
+     */
+    readonly id: string;
+    /**
+     * If the bucket is currently inactive (no pending requests)
+     */
+    get inactive(): boolean;
+    /**
+     * Queues a request to be sent
+     *
+     * @param routeId - The generalized api route with literal ids for major parameters
+     * @param url - The url to do the request on
+     * @param options - All the information needed to make a request
+     * @param requestData - Extra data from the user's request needed for errors and additional processing
+     */
+    queueRequest(routeId: RouteData, url: string, options: RequestInit, requestData: HandlerRequestData): Promise<ResponseLike>;
+}

package/lib/api/interfaces/Handler.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/api/shared.d.ts

@@ -0,0 +1,7 @@
+export * from './REST';
+export * from './errors/DiscordAPIError';
+export * from './errors/HTTPError';
+export * from './errors/RateLimitError';
+export * from './utils/constants';
+export * from './utils/types';
+export { calculateUserDefaultAvatarIndex, makeURLSearchParams, parseResponse } from './utils/utils';

package/lib/api/shared.js

@@ -0,0 +1,27 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseResponse = exports.makeURLSearchParams = exports.calculateUserDefaultAvatarIndex = void 0;
+__exportStar(require("./REST"), exports);
+__exportStar(require("./errors/DiscordAPIError"), exports);
+__exportStar(require("./errors/HTTPError"), exports);
+__exportStar(require("./errors/RateLimitError"), exports);
+__exportStar(require("./utils/constants"), exports);
+__exportStar(require("./utils/types"), exports);
+var utils_1 = require("./utils/utils");
+Object.defineProperty(exports, "calculateUserDefaultAvatarIndex", { enumerable: true, get: function () { return utils_1.calculateUserDefaultAvatarIndex; } });
+Object.defineProperty(exports, "makeURLSearchParams", { enumerable: true, get: function () { return utils_1.makeURLSearchParams; } });
+Object.defineProperty(exports, "parseResponse", { enumerable: true, get: function () { return utils_1.parseResponse; } });

package/lib/api/utils/constants.d.ts

@@ -0,0 +1,39 @@
+export declare const DefaultUserAgent = "DiscordBot (https://seyfert.com)";
+export declare const DefaultRestOptions: {
+    agent: null;
+    api: string;
+    authPrefix: string;
+    headers: {};
+    invalidRequestWarningInterval: number;
+    globalRequestsPerSecond: number;
+    offset: number;
+    rejectOnRateLimit: null;
+    retries: number;
+    timeout: number;
+    version: string;
+    hashSweepInterval: number;
+    hashLifetime: number;
+    handlerSweepInterval: number;
+    makeRequest(url: string, init: RequestInit): Promise<Response>;
+};
+/**
+ * The events that the REST manager emits
+ */
+export declare enum RESTEvents {
+    Debug = "restDebug",
+    HandlerSweep = "handlerSweep",
+    HashSweep = "hashSweep",
+    InvalidRequestWarning = "invalidRequestWarning",
+    RateLimited = "rateLimited",
+    Response = "response"
+}
+export declare const ALLOWED_EXTENSIONS: readonly ["webp", "png", "jpg", "jpeg", "gif"];
+export declare const ALLOWED_STICKER_EXTENSIONS: readonly ["png", "json", "gif"];
+export declare const ALLOWED_SIZES: readonly [16, 32, 64, 128, 256, 512, 1024, 2048, 4096];
+export type ImageExtension = (typeof ALLOWED_EXTENSIONS)[number];
+export type StickerExtension = (typeof ALLOWED_STICKER_EXTENSIONS)[number];
+export type ImageSize = (typeof ALLOWED_SIZES)[number];
+export declare const OverwrittenMimeTypes: {
+    readonly 'image/apng': "image/png";
+};
+export declare const BurstHandlerMajorIdKey = "burst";