seyfert 0.1.0 → 1.0.1

package/README.md

@@ -2,29 +2,32 @@
 
   # **Seyfert**
 
-  <img src="https://github.com/potoland/potocuit/raw/main/assets/icon.jpg" alt="seyfert" width="200px" />
+  <img src="./assets/icon.png" alt="seyfert" width="200px" />
 
-  **A brand new bleeding edge non bloated Discord framework**
+  **Discord.js and Sapphire are deprecated, use Seyfert instead**
 
-  [![License](https://img.shields.io/npm/l/@potoland/core?style=flat-square&logo=apache&color=white)](https://github.com/potoland/potocuit/blob/main/LICENSE)
-  [![Version](https://img.shields.io/npm/v/@potoland/core?color=%23ff0000&logo=npm&style=flat-square)](https://www.npmjs.com/package/@potoland/core)
-  [![Discord](https://img.shields.io/discord/973427352560365658?color=%23406da2&label=support&logo=discord&style=flat-square)](https://discord.com/invite/XNw2RZFzaP)
+  [![License](https://img.shields.io/npm/l/seyfert?style=flat-square&logo=apache&color=white)](https://github.com/tiramisulabs/seyfert/blob/main/LICENSE)
+  [![Version](https://img.shields.io/npm/v/seyfert?color=%23ff0000&logo=npm&style=flat-square)](https://www.npmjs.com/package/seyfert)
+  [![Discord](https://img.shields.io/discord/1003825077969764412?color=%23406da2&label=support&logo=discord&style=flat-square)](https://discord.com/invite/XNw2RZFzaP)
 
 </div>
 
-> [!WARNING]
-> This readme is work in progress!
-
 # FAQ
 ## So, what is `seyfert`?
-Seyfert is the ultimate Discord framework! With its highly efficient interaction with the Discord API, you can achieve anything you set your mind to.
+Seyfert is the ultimate Discord framework! We make easy to interact with the Discord API, big cache control, scalable code and a pretty dev experience.
 
 ## Why I should use it?
-Seyfert has a good scalability, strict types, smooth developing experience...
+There is a lot of reasons to use Seyfert, but we cannot put them all in here so there is a few of them!
+
+- **RAM Saver**
+- **Latest features**
+- **Dev experience**
+- **24/6 support (Sunday is for going to church)**
+- **Written from Scratch**
+- **Type-safe**
+- **And many more!!**
 
-> more questions soon...
 
-# User guide
 ## Installation
 > [!NOTE]
 > You **NEED** Node.js 18>= for this to work, also we recomended Node.js 20 LTS and Bun latest
@@ -34,24 +37,10 @@ pnpm add seyfert
 
 > You may use your preferred package manager, for this example I am using PNPM since is more efficient.
 
-## Basic bot example
-
-```ts
-import { Client } from 'seyfert';
-
-const client = new Client();
-
-(async () => {
-    await client.start();
-    await client.uploadCommands().catch(e => {
-        console.error(JSON.stringify(e, null, 2))
-        process.exit(1)
-    })
-})();
-```
-
 # Useful links
 
-- [GitHub Repository](https://github.com/potoland/potocuit)
+- [GitHub Repository](https://github.com/tiramisulabs/seyfert)
 - [Discord server](https://discord.com/invite/XNw2RZFzaP)
-- [npm - core](https://www.npmjs.com/package/@potoland/core)
+- [npm - core](https://www.npmjs.com/package/seyfert)
+- [Website](https://seyfert.dev)
+- [Documentation](https://docs.seyfert.dev)

package/lib/api/CDN.d.ts

@@ -120,14 +120,6 @@ export declare class CDN {
      * @param options - Optional options for the emoji
      */
     emoji(emojiId: string, options?: Readonly<BaseImageURLOptions>): string;
-    /**
-     * Generates an emoji's URL for an emoji.
-     *
-     * @param emojiId - The emoji id
-     * @param extension - The extension of the emoji
-     * @deprecated This overload is deprecated. Pass an object containing the extension instead.
-     */
-    emoji(emojiId: string, extension?: ImageExtension): string;
     /**
      * Generates a guild member avatar URL.
      *

package/lib/api/CDN.js

@@ -4,8 +4,6 @@ exports.CDN = void 0;
 /* eslint-disable jsdoc/check-param-names */
 const index_js_1 = require("../common/index.js");
 const constants_js_1 = require("./utils/constants.js");
-const utils_js_1 = require("./utils/utils.js");
-let deprecationEmittedForEmoji = false;
 /**
  * The CDN link builder
  */
@@ -95,18 +93,14 @@ class CDN {
     discoverySplash(guildId, splashHash, options) {
         return this.makeURL(`/discovery-splashes/${guildId}/${splashHash}`, options);
     }
+    /**
+     * Generates an emoji's URL for an emoji.
+     *
+     * @param emojiId - The emoji id
+     * @param options - Optional options for the emoji
+     */
     emoji(emojiId, options) {
-        let resolvedOptions;
-        if (typeof options === 'string') {
-            if (!deprecationEmittedForEmoji) {
-                (0, utils_js_1.deprecationWarning)('Passing a string for the second parameter of CDN#emoji() is deprecated. Use an object instead.');
-                deprecationEmittedForEmoji = true;
-            }
-            resolvedOptions = { extension: options };
-        }
-        else {
-            resolvedOptions = options;
-        }
+        const resolvedOptions = options;
         return this.makeURL(`/emojis/${emojiId}`, resolvedOptions);
     }
     /**

package/lib/api/Router.d.ts

@@ -1,4 +1,4 @@
-import type { APIRoutes, CDNRoute, REST } from './index';
+import type { APIRoutes, ApiHandler, CDNRoute } from './index';
 export declare enum ProxyRequestMethod {
     Delete = "delete",
     Get = "get",
@@ -9,7 +9,7 @@ export declare enum ProxyRequestMethod {
 export declare class Router {
     private rest;
     noop: () => void;
-    constructor(rest: REST);
+    constructor(rest: ApiHandler);
     createProxy(route?: string[]): APIRoutes;
 }
 export declare const CDNRouter: {

package/lib/api/Router.js

@@ -23,7 +23,7 @@ class Router {
         return new Proxy(this.noop, {
             get: (_, key) => {
                 if (ArrRequestsMethods.includes(key)) {
-                    return (...options) => this.rest[key](`/${route.join('/')}`, ...options);
+                    return (...options) => this.rest.request(key.toUpperCase(), `/${route.join('/')}`, ...options);
                 }
                 return this.createProxy([...route, key]);
             },

package/lib/api/Routes/applications.d.ts

@@ -1,5 +1,5 @@
 import type { RESTGetAPIApplicationCommandResult, RESTGetAPIApplicationCommandsQuery, RESTGetAPIApplicationCommandsResult, RESTGetAPIApplicationGuildCommandResult, RESTGetAPIApplicationGuildCommandsQuery, RESTGetAPIApplicationGuildCommandsResult, RESTGetAPIApplicationRoleConnectionMetadataResult, RESTGetAPIGuildApplicationCommandsPermissionsResult, RESTPatchAPIApplicationCommandJSONBody, RESTPatchAPIApplicationCommandResult, RESTPatchAPIApplicationGuildCommandJSONBody, RESTPatchAPIApplicationGuildCommandResult, RESTPostAPIApplicationCommandsJSONBody, RESTPostAPIApplicationCommandsResult, RESTPostAPIApplicationGuildCommandsJSONBody, RESTPostAPIApplicationGuildCommandsResult, RESTPutAPIApplicationCommandPermissionsJSONBody, RESTPutAPIApplicationCommandsJSONBody, RESTPutAPIApplicationCommandsResult, RESTPutAPIApplicationGuildCommandsJSONBody, RESTPutAPIApplicationGuildCommandsResult, RESTPutAPIApplicationRoleConnectionMetadataJSONBody, RESTPutAPIApplicationRoleConnectionMetadataResult, RESTPutAPIGuildApplicationCommandsPermissionsResult } from '../../common';
-import type { RestArguments } from '../REST';
+import type { RestArguments } from '../api';
 import type { ProxyRequestMethod } from '../Router';
 export interface ApplicationRoutes {
     applications: {

package/lib/api/Routes/channels.d.ts

@@ -1,5 +1,5 @@
 import type { RESTDeleteAPIChannelAllMessageReactionsResult, RESTDeleteAPIChannelMessageReactionResult, RESTDeleteAPIChannelMessageResult, RESTDeleteAPIChannelPermissionResult, RESTDeleteAPIChannelPinResult, RESTDeleteAPIChannelRecipientResult, RESTDeleteAPIChannelResult, RESTDeleteAPIChannelThreadMembersResult, RESTGetAPIChannelInvitesResult, RESTGetAPIChannelMessageReactionUsersQuery, RESTGetAPIChannelMessageReactionUsersResult, RESTGetAPIChannelMessageResult, RESTGetAPIChannelMessagesQuery, RESTGetAPIChannelMessagesResult, RESTGetAPIChannelPinsResult, RESTGetAPIChannelResult, RESTGetAPIChannelThreadMemberQuery, RESTGetAPIChannelThreadMemberResult, RESTGetAPIChannelThreadMembersQuery, RESTGetAPIChannelThreadMembersResult, RESTGetAPIChannelThreadsArchivedPrivateResult, RESTGetAPIChannelThreadsArchivedPublicResult, RESTGetAPIChannelThreadsArchivedQuery, RESTGetAPIChannelUsersThreadsArchivedResult, RESTGetAPIGuildWebhooksResult, RESTPatchAPIChannelJSONBody, RESTPatchAPIChannelMessageJSONBody, RESTPatchAPIChannelMessageResult, RESTPatchAPIChannelResult, RESTPostAPIChannelFollowersJSONBody, RESTPostAPIChannelFollowersResult, RESTPostAPIChannelInviteJSONBody, RESTPostAPIChannelInviteResult, RESTPostAPIChannelMessageCrosspostResult, RESTPostAPIChannelMessageJSONBody, RESTPostAPIChannelMessageResult, RESTPostAPIChannelMessagesBulkDeleteJSONBody, RESTPostAPIChannelMessagesBulkDeleteResult, RESTPostAPIChannelMessagesThreadsJSONBody, RESTPostAPIChannelMessagesThreadsResult, RESTPostAPIChannelThreadsJSONBody, RESTPostAPIChannelThreadsResult, RESTPostAPIChannelTypingResult, RESTPostAPIChannelWebhookJSONBody, RESTPostAPIChannelWebhookResult, RESTPostAPIGuildForumThreadsJSONBody, RESTPutAPIChannelMessageReactionResult, RESTPutAPIChannelPermissionJSONBody, RESTPutAPIChannelPermissionResult, RESTPutAPIChannelPinResult, RESTPutAPIChannelRecipientJSONBody, RESTPutAPIChannelRecipientResult, RESTPutAPIChannelThreadMembersResult } from '../../common';
-import type { RestArguments } from '../REST';
+import type { RestArguments } from '../api';
 import type { ProxyRequestMethod } from '../Router';
 export interface ChannelRoutes {
     channels(id: string): {

package/lib/api/Routes/gateway.d.ts

@@ -1,5 +1,5 @@
 import type { RESTGetAPIGatewayBotResult, RESTGetAPIGatewayResult } from '../../common';
-import type { RestArguments } from '../REST';
+import type { RestArguments } from '../api';
 import type { ProxyRequestMethod } from '../Router';
 export interface GatewayRoutes {
     gateway: {

package/lib/api/Routes/guilds.d.ts

@@ -1,6 +1,6 @@
 import type { APIThreadChannel, Identify, OmitInsert, RESTDeleteAPIAutoModerationRuleResult, RESTDeleteAPIGuildBanResult, RESTDeleteAPIGuildEmojiResult, RESTDeleteAPIGuildIntegrationResult, RESTDeleteAPIGuildMemberResult, RESTDeleteAPIGuildMemberRoleResult, RESTDeleteAPIGuildResult, RESTDeleteAPIGuildRoleResult, RESTDeleteAPIGuildScheduledEventResult, RESTDeleteAPIGuildStickerResult, RESTDeleteAPIGuildTemplateResult, RESTGetAPIAuditLogQuery, RESTGetAPIAuditLogResult, RESTGetAPIAutoModerationRuleResult, RESTGetAPIAutoModerationRulesResult, RESTGetAPIGuildBanResult, RESTGetAPIGuildBansQuery, RESTGetAPIGuildBansResult, RESTGetAPIGuildChannelsResult, RESTGetAPIGuildEmojiResult, RESTGetAPIGuildEmojisResult, RESTGetAPIGuildIntegrationsResult, RESTGetAPIGuildInvitesResult, RESTGetAPIGuildMemberResult, RESTGetAPIGuildMembersQuery, RESTGetAPIGuildMembersResult, RESTGetAPIGuildMembersSearchQuery, RESTGetAPIGuildMembersSearchResult, RESTGetAPIGuildPreviewResult, RESTGetAPIGuildPruneCountQuery, RESTGetAPIGuildPruneCountResult, RESTGetAPIGuildQuery, RESTGetAPIGuildResult, RESTGetAPIGuildRolesResult, RESTGetAPIGuildScheduledEventQuery, RESTGetAPIGuildScheduledEventResult, RESTGetAPIGuildScheduledEventUsersQuery, RESTGetAPIGuildScheduledEventUsersResult, RESTGetAPIGuildScheduledEventsQuery, RESTGetAPIGuildScheduledEventsResult, RESTGetAPIGuildStickerResult, RESTGetAPIGuildStickersResult, RESTGetAPIGuildTemplatesResult, RESTGetAPIGuildThreadsResult, RESTGetAPIGuildVanityUrlResult, RESTGetAPIGuildVoiceRegionsResult, RESTGetAPIGuildWebhooksResult, RESTGetAPIGuildWelcomeScreenResult, RESTGetAPIGuildWidgetImageQuery, RESTGetAPIGuildWidgetImageResult, RESTGetAPIGuildWidgetJSONResult, RESTGetAPIGuildWidgetSettingsResult, RESTGetAPITemplateResult, RESTPatchAPIAutoModerationRuleJSONBody, RESTPatchAPIAutoModerationRuleResult, RESTPatchAPICurrentGuildMemberJSONBody, RESTPatchAPIGuildChannelPositionsJSONBody, RESTPatchAPIGuildChannelPositionsResult, RESTPatchAPIGuildEmojiJSONBody, RESTPatchAPIGuildEmojiResult, RESTPatchAPIGuildJSONBody, RESTPatchAPIGuildMemberJSONBody, RESTPatchAPIGuildMemberResult, RESTPatchAPIGuildResult, RESTPatchAPIGuildRoleJSONBody, RESTPatchAPIGuildRolePositionsJSONBody, RESTPatchAPIGuildRolePositionsResult, RESTPatchAPIGuildRoleResult, RESTPatchAPIGuildScheduledEventJSONBody, RESTPatchAPIGuildScheduledEventResult, RESTPatchAPIGuildStickerJSONBody, RESTPatchAPIGuildStickerResult, RESTPatchAPIGuildTemplateJSONBody, RESTPatchAPIGuildTemplateResult, RESTPatchAPIGuildVoiceStateCurrentMemberJSONBody, RESTPatchAPIGuildVoiceStateCurrentMemberResult, RESTPatchAPIGuildVoiceStateUserJSONBody, RESTPatchAPIGuildVoiceStateUserResult, RESTPatchAPIGuildWelcomeScreenJSONBody, RESTPatchAPIGuildWelcomeScreenResult, RESTPatchAPIGuildWidgetSettingsJSONBody, RESTPatchAPIGuildWidgetSettingsResult, RESTPostAPIAutoModerationRuleJSONBody, RESTPostAPIAutoModerationRuleResult, RESTPostAPIGuildChannelJSONBody, RESTPostAPIGuildChannelResult, RESTPostAPIGuildEmojiJSONBody, RESTPostAPIGuildEmojiResult, RESTPostAPIGuildPruneJSONBody, RESTPostAPIGuildPruneResult, RESTPostAPIGuildRoleJSONBody, RESTPostAPIGuildRoleResult, RESTPostAPIGuildScheduledEventJSONBody, RESTPostAPIGuildScheduledEventResult, RESTPostAPIGuildStickerFormDataBody, RESTPostAPIGuildStickerResult, RESTPostAPIGuildTemplatesJSONBody, RESTPostAPIGuildTemplatesResult, RESTPostAPIGuildsJSONBody, RESTPostAPIGuildsMFAJSONBody, RESTPostAPIGuildsMFAResult, RESTPostAPIGuildsResult, RESTPostAPITemplateCreateGuildJSONBody, RESTPostAPITemplateCreateGuildResult, RESTPutAPIGuildBanJSONBody, RESTPutAPIGuildBanResult, RESTPutAPIGuildMemberJSONBody, RESTPutAPIGuildMemberResult, RESTPutAPIGuildMemberRoleResult, RESTPutAPIGuildTemplateSyncResult } from '../../common';
-import type { RestArguments } from '../REST';
 import type { ProxyRequestMethod } from '../Router';
+import type { RestArguments } from '../api';
 import type { RawFile } from '../shared';
 export interface GuildRoutes {
     guilds: {

package/lib/api/Routes/interactions.d.ts

@@ -1,5 +1,5 @@
 import type { RESTPostAPIInteractionCallbackJSONBody } from '../../common';
-import type { RestArguments } from '../REST';
+import type { RestArguments } from '../api';
 import type { ProxyRequestMethod } from '../Router';
 export interface InteractionRoutes {
     interactions: {

package/lib/api/Routes/invites.d.ts

@@ -1,5 +1,5 @@
 import type { RESTDeleteAPIInviteResult, RESTGetAPIInviteQuery, RESTGetAPIInviteResult } from '../../common';
-import type { RestArguments } from '../REST';
+import type { RestArguments } from '../api';
 import type { ProxyRequestMethod } from '../Router';
 export interface InviteRoutes {
     invites(id: string): {

package/lib/api/Routes/stage-instances.d.ts

@@ -1,5 +1,5 @@
 import type { RESTDeleteAPIStageInstanceResult, RESTGetAPIStageInstanceResult, RESTPatchAPIStageInstanceJSONBody, RESTPatchAPIStageInstanceResult, RESTPostAPIStageInstanceJSONBody, RESTPostAPIStageInstanceResult } from '../../common';
-import type { RestArguments } from '../REST';
+import type { RestArguments } from '../api';
 import type { ProxyRequestMethod } from '../Router';
 export interface StageInstanceRoutes {
     'stage-instances': {

package/lib/api/Routes/stickers.d.ts

@@ -1,5 +1,5 @@
 import type { RESTGetAPIStickerResult, RESTGetNitroStickerPacksResult } from '../../common';
-import type { RestArguments } from '../REST';
+import type { RestArguments } from '../api';
 import type { ProxyRequestMethod } from '../Router';
 export interface StickerRoutes {
     stickers(id: string): {

package/lib/api/Routes/users.d.ts

@@ -1,5 +1,5 @@
 import type { APIDMChannel, RESTDeleteAPIGuildResult, RESTGetAPICurrentUserApplicationRoleConnectionResult, RESTGetAPICurrentUserConnectionsResult, RESTGetAPICurrentUserGuildsQuery, RESTGetAPICurrentUserGuildsResult, RESTGetAPICurrentUserResult, RESTGetAPIUserResult, RESTGetCurrentUserGuildMemberResult, RESTPatchAPICurrentUserJSONBody, RESTPatchAPICurrentUserResult, RESTPostAPICurrentUserCreateDMChannelJSONBody, RESTPutAPICurrentUserApplicationRoleConnectionJSONBody, RESTPutAPICurrentUserApplicationRoleConnectionResult } from '../../common';
-import type { RestArguments } from '../REST';
+import type { RestArguments } from '../api';
 import type { ProxyRequestMethod } from '../Router';
 export interface UserRoutes {
     users: {

package/lib/api/Routes/voice.d.ts

@@ -1,5 +1,5 @@
 import type { RESTGetAPIVoiceRegionsResult } from '../../common';
-import type { RestArguments } from '../REST';
+import type { RestArguments } from '../api';
 import type { ProxyRequestMethod } from '../Router';
 export interface VoiceRoutes {
     voice: {

package/lib/api/Routes/webhooks.d.ts

@@ -1,5 +1,5 @@
 import type { RESTDeleteAPIWebhookResult, RESTDeleteAPIWebhookWithTokenMessageResult, RESTDeleteAPIWebhookWithTokenResult, RESTGetAPIWebhookResult, RESTGetAPIWebhookWithTokenMessageResult, RESTGetAPIWebhookWithTokenResult, RESTPatchAPIWebhookJSONBody, RESTPatchAPIWebhookResult, RESTPatchAPIWebhookWithTokenJSONBody, RESTPatchAPIWebhookWithTokenMessageJSONBody, RESTPatchAPIWebhookWithTokenMessageResult, RESTPatchAPIWebhookWithTokenResult, RESTPostAPIWebhookWithTokenGitHubQuery, RESTPostAPIWebhookWithTokenGitHubResult, RESTPostAPIWebhookWithTokenGitHubWaitResult, RESTPostAPIWebhookWithTokenJSONBody, RESTPostAPIWebhookWithTokenQuery, RESTPostAPIWebhookWithTokenResult, RESTPostAPIWebhookWithTokenSlackQuery, RESTPostAPIWebhookWithTokenSlackResult, RESTPostAPIWebhookWithTokenSlackWaitResult, RESTPostAPIWebhookWithTokenWaitResult } from '../../common';
-import type { RestArguments } from '../REST';
+import type { RestArguments } from '../api';
 import type { ProxyRequestMethod } from '../Router';
 export interface WebhookRoutes {
     webhooks(id: string): {

package/lib/api/api.d.ts

@@ -0,0 +1,44 @@
+import { Logger } from '../common';
+import { CDN } from './CDN';
+import type { ProxyRequestMethod } from './Router';
+import { Bucket } from './bucket';
+import { type ApiHandlerInternalOptions, type ApiHandlerOptions, type ApiRequestOptions, type HttpMethods, type RawFile, type RequestHeaders } from './shared';
+export declare class ApiHandler {
+    #private;
+    options: ApiHandlerInternalOptions;
+    globalBlock: boolean;
+    ratelimits: Map<string, Bucket>;
+    readyQueue: (() => void)[];
+    cdn: CDN;
+    debugger?: Logger;
+    workerPromises?: Map<string, {
+        resolve: (value: any) => any;
+        reject: (error: any) => any;
+    }>;
+    constructor(options: ApiHandlerOptions);
+    globalUnblock(): void;
+    request<T = any>(method: HttpMethods, url: `/${string}`, { auth, ...request }?: ApiRequestOptions): Promise<T>;
+    parseError(response: Response, result: unknown): Error;
+    handle50X(method: HttpMethods, url: `/${string}`, request: ApiRequestOptions, next: () => void): Promise<any>;
+    handle429(route: string, method: HttpMethods, url: `/${string}`, request: ApiRequestOptions, response: Response, result: any, next: () => void, reject: (err: unknown) => void, now: number): Promise<any>;
+    clearResetInterval(route: string): void;
+    setResetBucket(route: string, resp: Response, now: number, headerNow: number): void;
+    setRatelimitsBucket(route: string, resp: Response): void;
+    parseRequest(options: {
+        url: string;
+        headers: RequestHeaders;
+        request: ApiRequestOptions;
+    }): {
+        data: string | FormData | undefined;
+        finalUrl: `/${string}`;
+    };
+    routefy(url: string, method: HttpMethods): `/${string}`;
+}
+export type RequestOptions = Pick<ApiRequestOptions, 'reason' | 'auth' | 'appendToFormData'>;
+export type RequestObject<M extends ProxyRequestMethod, B = Record<string, any>, Q = Record<string, any>, F extends RawFile[] = RawFile[]> = {
+    query?: Q;
+} & RequestOptions & (M extends `${ProxyRequestMethod.Get}` ? unknown : {
+    body?: B;
+    files?: F;
+});
+export type RestArguments<M extends ProxyRequestMethod, B = any, Q extends never | Record<string, any> = any, F extends RawFile[] = RawFile[]> = M extends ProxyRequestMethod.Get ? Q extends never ? RequestObject<M, never, B, never> : never : RequestObject<M, B, Q, F>;

package/lib/api/api.js

@@ -0,0 +1,354 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiHandler = void 0;
+const magic_bytes_js_1 = require("magic-bytes.js");
+const node_crypto_1 = require("node:crypto");
+const promises_1 = require("node:timers/promises");
+const node_worker_threads_1 = require("node:worker_threads");
+const common_1 = require("../common");
+const functions_1 = require("../structures/extra/functions");
+const CDN_1 = require("./CDN");
+const bucket_1 = require("./bucket");
+const shared_1 = require("./shared");
+const utils_1 = require("./utils/utils");
+class ApiHandler {
+    options;
+    globalBlock = false;
+    ratelimits = new Map();
+    readyQueue = [];
+    cdn = new CDN_1.CDN();
+    debugger;
+    workerPromises;
+    constructor(options) {
+        this.options = {
+            baseUrl: 'api/v10',
+            domain: 'https://discord.com',
+            ...options,
+            userAgent: shared_1.DefaultUserAgent,
+        };
+        if (options.debug) {
+            this.debugger = new common_1.Logger({
+                name: '[API]',
+            });
+        }
+        if (options.workerProxy && !node_worker_threads_1.parentPort)
+            throw new Error('Cannot use workerProxy without a parent.');
+        if (options.workerProxy)
+            this.workerPromises = new Map();
+    }
+    globalUnblock() {
+        this.globalBlock = false;
+        let cb;
+        while ((cb = this.readyQueue.shift())) {
+            cb();
+        }
+    }
+    #randomUUID() {
+        const uuid = (0, node_crypto_1.randomUUID)();
+        if (this.workerPromises.has(uuid))
+            return this.#randomUUID();
+        return uuid;
+    }
+    async request(method, url, { auth = true, ...request } = {}) {
+        if (this.options.workerProxy) {
+            const nonce = this.#randomUUID();
+            node_worker_threads_1.parentPort.postMessage({
+                method,
+                url,
+                type: 'WORKER_API_REQUEST',
+                workerId: node_worker_threads_1.workerData.workerId,
+                nonce,
+                requestOptions: { auth, ...request },
+            }, request.files
+                ?.filter(x => !['string', 'boolean', 'number'].includes(typeof x.data))
+                .map(x => x.data));
+            let resolve = (_value) => { };
+            let reject = () => { };
+            const promise = new Promise((res, rej) => {
+                resolve = res;
+                reject = rej;
+            });
+            this.workerPromises.set(nonce, { reject, resolve });
+            return promise;
+        }
+        const route = request.route || this.routefy(url, method);
+        let attempts = 0;
+        const callback = async (next, resolve, reject) => {
+            const headers = {
+                'User-Agent': this.options.userAgent,
+            };
+            const { data, finalUrl } = this.parseRequest({
+                url,
+                headers,
+                request: { ...request, auth },
+            });
+            let response;
+            try {
+                const url = `${this.options.domain}/${this.options.baseUrl}${finalUrl}`;
+                this.debugger?.debug(`Sending, Method: ${method} | Url: [${finalUrl}](${route}) | Auth: ${auth}`);
+                response = await fetch(url, {
+                    method,
+                    headers,
+                    body: data,
+                });
+                this.debugger?.debug(`Received response: ${response.statusText}(${response.status})`);
+            }
+            catch (err) {
+                this.debugger?.debug('Fetch error', err);
+                next();
+                reject(err);
+                return;
+            }
+            const now = Date.now();
+            const headerNow = Date.parse(response.headers.get('date') ?? '');
+            this.setRatelimitsBucket(route, response);
+            this.setResetBucket(route, response, now, headerNow);
+            let result = await response.text();
+            if (response.status >= 300) {
+                if (response.status === 429) {
+                    const result429 = await this.handle429(route, method, url, request, response, result, next, reject, now);
+                    if (result429 !== false)
+                        return resolve(result429);
+                    return this.clearResetInterval(route);
+                }
+                if ([502, 503].includes(response.status) && ++attempts < 4) {
+                    this.clearResetInterval(route);
+                    return this.handle50X(method, url, request, next);
+                }
+                this.clearResetInterval(route);
+                next();
+                if (result.length > 0) {
+                    if (response.headers.get('content-type') === 'application/json') {
+                        try {
+                            result = JSON.parse(result);
+                        }
+                        catch (err) {
+                            this.debugger?.warn('Error parsing result error (', result, ')', err);
+                            reject(err);
+                            return;
+                        }
+                    }
+                }
+                const parsedError = this.parseError(response, result);
+                this.debugger?.warn(parsedError);
+                reject(parsedError);
+                return;
+            }
+            if (result.length > 0) {
+                if (response.headers.get('content-type') === 'application/json') {
+                    try {
+                        result = JSON.parse(result);
+                    }
+                    catch (err) {
+                        this.debugger?.warn('Error parsing result (', result, ')', err);
+                        next();
+                        reject(err);
+                        return;
+                    }
+                }
+            }
+            next();
+            return resolve((result || undefined));
+        };
+        return new Promise((resolve, reject) => {
+            if (this.globalBlock && auth) {
+                this.readyQueue.push(() => {
+                    if (!this.ratelimits.has(route)) {
+                        this.ratelimits.set(route, new bucket_1.Bucket(1));
+                    }
+                    this.ratelimits.get(route).push({ next: callback, resolve, reject }, request.unshift);
+                });
+            }
+            else {
+                if (!this.ratelimits.has(route)) {
+                    this.ratelimits.set(route, new bucket_1.Bucket(1));
+                }
+                this.ratelimits.get(route).push({ next: callback, resolve, reject }, request.unshift);
+            }
+        });
+    }
+    parseError(response, result) {
+        let errMessage = '';
+        if (typeof result === 'object' && result) {
+            if ('message' in result) {
+                errMessage += `${result.message}${'code' in result ? ` ${result.code}` : ''}\n`;
+            }
+            if ('errors' in result && result) {
+                errMessage += `${JSON.stringify(result.errors, null, 2)}\n`;
+            }
+        }
+        if (response.status) {
+            return new Error(errMessage ?? response.statusText);
+        }
+        return new Error('Unknown error');
+    }
+    async handle50X(method, url, request, next) {
+        const wait = Math.floor(Math.random() * 1900 + 100);
+        this.debugger?.warn(`Handling a 50X status, retrying in ${wait}ms`);
+        next();
+        await (0, promises_1.setTimeout)(wait);
+        return this.request(method, url, {
+            body: request.body,
+            auth: request.auth,
+            reason: request.reason,
+            route: request.route,
+            unshift: true,
+        });
+    }
+    async handle429(route, method, url, request, response, result, next, reject, now) {
+        const content = typeof request === 'object' ? `${JSON.stringify(request)} ` : '';
+        let retryAfter;
+        try {
+            retryAfter = JSON.parse(result).retry_after * 1000;
+        }
+        catch (err) {
+            this.debugger?.warn(`Unexpected error: ${err}`);
+            reject(err);
+            return false;
+        }
+        this.debugger?.info(`${response.headers.get('x-ratelimit-global') ? 'Global' : 'Unexpected'} 429: ${result}\n${content} ${now} ${route} ${response.status}: ${this.ratelimits.get(route).remaining}/${this.ratelimits.get(route).limit} left | Reset ${retryAfter} (${this.ratelimits.get(route).reset - now}ms left) | Scope ${response.headers.get('x-ratelimit-scope')}`);
+        if (retryAfter) {
+            await (0, promises_1.setTimeout)(retryAfter);
+            next();
+            return this.request(method, url, {
+                body: request.body,
+                auth: request.auth,
+                reason: request.reason,
+                route: request.route,
+                unshift: true,
+            });
+        }
+        next();
+        return this.request(method, url, {
+            body: request.body,
+            auth: request.auth,
+            reason: request.reason,
+            route: request.route,
+            unshift: true,
+        });
+    }
+    clearResetInterval(route) {
+        clearInterval(this.ratelimits.get(route).processingResetAfter);
+        this.ratelimits.get(route).processingResetAfter = undefined;
+        this.ratelimits.get(route).resetAfter = 0;
+    }
+    setResetBucket(route, resp, now, headerNow) {
+        const retryAfter = Number(resp.headers.get('x-ratelimit-reset-after') || resp.headers.get('retry-after')) * 1000;
+        if (retryAfter >= 0) {
+            if (resp.headers.get('x-ratelimit-global')) {
+                this.globalBlock = true;
+                setTimeout(() => this.globalUnblock(), retryAfter || 1);
+            }
+            else {
+                this.ratelimits.get(route).reset = (retryAfter || 1) + now;
+            }
+        }
+        else if (resp.headers.get('x-ratelimit-reset')) {
+            let resetTime = +resp.headers.get('x-ratelimit-reset') * 1000;
+            if (route.endsWith('/reactions/:id') && +resp.headers.get('x-ratelimit-reset') * 1000 - headerNow === 1000) {
+                resetTime = now + 250;
+            }
+            this.ratelimits.get(route).reset = Math.max(resetTime, now);
+        }
+        else {
+            this.ratelimits.get(route).reset = now;
+        }
+    }
+    setRatelimitsBucket(route, resp) {
+        if (resp.headers.get('x-ratelimit-limit')) {
+            this.ratelimits.get(route).limit = +resp.headers.get('x-ratelimit-limit');
+        }
+        this.ratelimits.get(route).remaining =
+            resp.headers.get('x-ratelimit-remaining') === undefined ? 1 : +resp.headers.get('x-ratelimit-remaining');
+        if (this.options.smartBucket) {
+            if (resp.headers.get('x-ratelimit-reset-after') &&
+                !this.ratelimits.get(route).resetAfter &&
+                Number(resp.headers.get('x-ratelimit-limit')) === Number(resp.headers.get('x-ratelimit-remaining')) + 1) {
+                this.ratelimits.get(route).resetAfter = +resp.headers.get('x-ratelimit-reset-after') * 1000;
+            }
+            if (this.ratelimits.get(route).resetAfter && !this.ratelimits.get(route).remaining) {
+                this.ratelimits.get(route).triggerResetAfter();
+            }
+        }
+    }
+    parseRequest(options) {
+        let finalUrl = options.url;
+        let data;
+        if (options.request.auth) {
+            options.headers.Authorization = `Bot ${this.options.token}`;
+        }
+        if (options.request.query) {
+            finalUrl += `?${new URLSearchParams(options.request.query)}`;
+        }
+        if (options.request.files) {
+            const formData = new FormData();
+            for (const [index, file] of options.request.files.entries()) {
+                const fileKey = file.key ?? `files[${index}]`;
+                if ((0, utils_1.isBufferLike)(file.data)) {
+                    let contentType = file.contentType;
+                    if (!contentType) {
+                        const [parsedType] = (0, magic_bytes_js_1.filetypeinfo)(file.data);
+                        if (parsedType) {
+                            contentType =
+                                shared_1.OverwrittenMimeTypes[parsedType.mime] ??
+                                    parsedType.mime ??
+                                    'application/octet-stream';
+                        }
+                    }
+                    formData.append(fileKey, new Blob([file.data], { type: contentType }), file.name);
+                }
+                else {
+                    formData.append(fileKey, new Blob([`${file.data}`], { type: file.contentType }), file.name);
+                }
+            }
+            if (options.request.body) {
+                if (options.request.appendToFormData) {
+                    for (const [key, value] of Object.entries(options.request.body)) {
+                        formData.append(key, value);
+                    }
+                }
+                else {
+                    formData.append('payload_json', JSON.stringify(options.request.body));
+                }
+            }
+            data = formData;
+        }
+        else if (options.request.body) {
+            options.headers['Content-Type'] = 'application/json';
+            data = JSON.stringify(options.request.body);
+        }
+        if (options.request.reason) {
+            options.headers['X-Audit-Log-Reason'] = encodeURIComponent(options.request.reason);
+        }
+        return { data, finalUrl };
+    }
+    routefy(url, method) {
+        let route = url
+            .replace(/\/([a-z-]+)\/(?:[0-9]{17,19})/g, (match, p) => p === 'channels' || p === 'guilds' || p === 'webhooks' ? match : `/${p}/:id`)
+            .replace(/\/reactions\/[^/]+/g, '/reactions/:id')
+            .replace(/\/reactions\/:id\/[^/]+/g, '/reactions/:id/:userID')
+            .replace(/^\/webhooks\/(\d+)\/[A-Za-z0-9-_]{64,}/, '/webhooks/$1/:token');
+        if (method === 'DELETE' && route.endsWith('/messages/:id')) {
+            const messageID = url.slice(url.lastIndexOf('/') + 1);
+            const createdAt = Number((0, functions_1.snowflakeToTimestamp)(messageID));
+            if (Date.now() - createdAt >= 1000 * 60 * 60 * 24 * 14) {
+                method += '_OLD';
+            }
+            else if (Date.now() - createdAt <= 1000 * 10) {
+                method += '_NEW';
+            }
+            route = method + route;
+        }
+        else if (method === 'GET' && /\/guilds\/[0-9]+\/channels$/.test(route)) {
+            route = '/guilds/:id/channels';
+        }
+        if (method === 'PUT' || method === 'DELETE') {
+            const index = route.indexOf('/reactions');
+            if (index !== -1) {
+                route = `MODIFY${route.slice(0, index + 10)}`;
+            }
+        }
+        return route;
+    }
+}
+exports.ApiHandler = ApiHandler;