seyfert 4.4.0 → 5.0.1-dev-27866487194.0

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

@@ -21,7 +21,7 @@ export interface CDNRoute {
     splashes(guildId: string): {
         get(hash: string, options?: BaseCDNUrlOptions): string;
     };
-    'discovery-splashes'(guidId: string): {
+    'discovery-splashes'(guildId: string): {
         get(hash: string, options?: BaseCDNUrlOptions): string;
     };
     banners(id: string): {
@@ -82,4 +82,4 @@ export interface CDNRoute {
         };
     };
 }
-export type UserAvatarDefault = 1 | 2 | 3 | 4 | 5 | number;
+export type UserAvatarDefault = 0 | 1 | 2 | 3 | 4 | 5;

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

@@ -1,6 +1,6 @@
 import type { Identify, OmitInsert } from '../../common';
 import type { APIThreadChannel, 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, RESTGetAPIGuildMessagesSearchQuery, RESTGetAPIGuildMessagesSearchResult, RESTGetAPIGuildPreviewResult, RESTGetAPIGuildPruneCountQuery, RESTGetAPIGuildPruneCountResult, RESTGetAPIGuildQuery, RESTGetAPIGuildResult, RESTGetAPIGuildRoleMemberCountsResult, RESTGetAPIGuildRoleResult, RESTGetAPIGuildRolesResult, RESTGetAPIGuildScheduledEventQuery, RESTGetAPIGuildScheduledEventResult, RESTGetAPIGuildScheduledEventsQuery, RESTGetAPIGuildScheduledEventsResult, RESTGetAPIGuildScheduledEventUsersQuery, RESTGetAPIGuildScheduledEventUsersResult, RESTGetAPIGuildSoundboardSoundsResult, RESTGetAPIGuildStickerResult, RESTGetAPIGuildStickersResult, RESTGetAPIGuildTemplatesResult, RESTGetAPIGuildThreadsResult, RESTGetAPIGuildVanityUrlResult, RESTGetAPIGuildVoiceRegionsResult, RESTGetAPIGuildVoiceStateCurrentMemberResult, RESTGetAPIGuildVoiceStateUserResult, RESTGetAPIGuildWebhooksResult, RESTGetAPIGuildWelcomeScreenResult, RESTGetAPIGuildWidgetImageQuery, RESTGetAPIGuildWidgetImageResult, RESTGetAPIGuildWidgetJSONResult, RESTGetAPIGuildWidgetSettingsResult, RESTGetAPITemplateResult, RESTPatchAPIAutoModerationRuleJSONBody, RESTPatchAPIAutoModerationRuleResult, RESTPatchAPICurrentGuildMemberJSONBody, RESTPatchAPIGuildChannelPositionsJSONBody, RESTPatchAPIGuildChannelPositionsResult, RESTPatchAPIGuildEmojiJSONBody, RESTPatchAPIGuildEmojiResult, RESTPatchAPIGuildJSONBody, RESTPatchAPIGuildMemberJSONBody, RESTPatchAPIGuildMemberResult, RESTPatchAPIGuildResult, RESTPatchAPIGuildRoleJSONBody, RESTPatchAPIGuildRolePositionsJSONBody, RESTPatchAPIGuildRolePositionsResult, RESTPatchAPIGuildRoleResult, RESTPatchAPIGuildScheduledEventJSONBody, RESTPatchAPIGuildScheduledEventResult, RESTPatchAPIGuildSoundboardSoundJSONBody, RESTPatchAPIGuildSoundboardSoundResult, RESTPatchAPIGuildStickerJSONBody, RESTPatchAPIGuildStickerResult, RESTPatchAPIGuildTemplateJSONBody, RESTPatchAPIGuildTemplateResult, RESTPatchAPIGuildVoiceStateCurrentMemberJSONBody, RESTPatchAPIGuildVoiceStateCurrentMemberResult, RESTPatchAPIGuildVoiceStateUserJSONBody, RESTPatchAPIGuildVoiceStateUserResult, RESTPatchAPIGuildWelcomeScreenJSONBody, RESTPatchAPIGuildWelcomeScreenResult, RESTPatchAPIGuildWidgetSettingsJSONBody, RESTPatchAPIGuildWidgetSettingsResult, RESTPostAPIAutoModerationRuleJSONBody, RESTPostAPIAutoModerationRuleResult, RESTPostAPIGuildBulkBanJSONBody, RESTPostAPIGuildBulkBanResult, RESTPostAPIGuildChannelJSONBody, RESTPostAPIGuildChannelResult, RESTPostAPIGuildEmojiJSONBody, RESTPostAPIGuildEmojiResult, RESTPostAPIGuildPruneJSONBody, RESTPostAPIGuildPruneResult, RESTPostAPIGuildRoleJSONBody, RESTPostAPIGuildRoleResult, RESTPostAPIGuildScheduledEventJSONBody, RESTPostAPIGuildScheduledEventResult, RESTPostAPIGuildSoundboardSoundJSONBody, RESTPostAPIGuildSoundboardSoundResult, RESTPostAPIGuildStickerFormDataBody, RESTPostAPIGuildStickerResult, RESTPostAPIGuildsMFAJSONBody, RESTPostAPIGuildsMFAResult, RESTPostAPIGuildTemplatesJSONBody, RESTPostAPIGuildTemplatesResult, RESTPostAPITemplateCreateGuildJSONBody, RESTPostAPITemplateCreateGuildResult, RESTPutAPIGuildBanJSONBody, RESTPutAPIGuildBanResult, RESTPutAPIGuildMemberJSONBody, RESTPutAPIGuildMemberResult, RESTPutAPIGuildMemberRoleResult, RESTPutAPIGuildTemplateSyncResult } from '../../types';
-import type { RestArguments, RestArgumentsNoBody } from '../api';
+import type { RestArguments, RestArgumentsNoBody, RestArgumentsRequiredQuery } from '../api';
 import type { RawFile } from '../shared';
 export interface GuildRoutes {
     guilds: {
@@ -40,7 +40,7 @@ export interface GuildRoutes {
             members: {
                 get(args?: RestArgumentsNoBody<RESTGetAPIGuildMembersQuery>): Promise<RESTGetAPIGuildMembersResult>;
                 search: {
-                    get(args: RestArgumentsNoBody<RESTGetAPIGuildMembersSearchQuery>): Promise<RESTGetAPIGuildMembersSearchResult>;
+                    get(args: RestArgumentsRequiredQuery<RESTGetAPIGuildMembersSearchQuery>): Promise<RESTGetAPIGuildMembersSearchResult>;
                 };
                 '@me': {
                     patch(args: RestArguments<RESTPatchAPICurrentGuildMemberJSONBody>): Promise<RESTGetAPIGuildMemberResult>;

package/lib/api/api.d.ts

@@ -1,16 +1,17 @@
 import { type UUID } from 'node:crypto';
 import { type Awaitable, Logger, SeyfertError } from '../common';
-import type { WorkerSendApiRequest } from '../websocket/discord/worker';
+import { type WorkerSendApiRequest } from '../websocket/discord/worker';
 import { Bucket } from './bucket';
 import type { APIRoutes } from './Routes';
-import { type ApiHandlerInternalOptions, type ApiHandlerOptions, type ApiRequestOptions, type HttpMethods, type RawFile, type RequestHeaders } from './shared';
-export interface ApiHandler {
+import { type ApiHandlerInternalOptions, type ApiHandlerOptions, type ApiRequestOptions, type HttpMethods, type RawFile, type RequestHeaders, type RestObserveOptions, type RestObserver, type RestObserverDisposer, type RestObserverEntry } from './shared';
+export type { RestObserveOptions, RestObserver, RestObserverDisposer, RestObserverEntry, RestObserverFailPayload, RestObserverRatelimitPayload, RestObserverRequestPayload, RestObserverSuccessPayload, } from './shared';
+export interface ApiHandler<TClient = unknown> {
     debugger?: Logger;
 }
 export type OnRatelimitCallback = (response: Response, request: ApiRequestOptions) => Awaitable<any>;
 export type OnSuccessRequestCallback = (method: HttpMethods, url: `/${string}`, response: Response) => Awaitable<any>;
 export type OnFailRequestCallback = (method: HttpMethods, url: `/${string}`, error: unknown, statusCode?: number) => Awaitable<any>;
-export declare class ApiHandler {
+export declare class ApiHandler<TClient = unknown> {
     options: ApiHandlerInternalOptions;
     globalBlock: boolean;
     ratelimits: Map<string, Bucket>;
@@ -23,22 +24,30 @@ export declare class ApiHandler {
     onRatelimit?: OnRatelimitCallback;
     onSuccessRequest?: OnSuccessRequestCallback;
     onFailRequest?: OnFailRequestCallback;
+    pluginRestObserverProvider?: () => readonly RestObserverEntry[];
+    pluginRestObserverClient?: TClient;
+    private restObservers;
     constructor(options: ApiHandlerOptions);
+    observe(observer: RestObserver<TClient>, _opts?: RestObserveOptions): RestObserverDisposer;
     set debug(active: boolean);
     get proxy(): APIRoutes;
     globalUnblock(): void;
     randomUUID(): UUID;
     protected sendMessage(_body: WorkerSendApiRequest): void;
     protected postMessage<T = unknown>(body: WorkerSendApiRequest): Promise<T>;
+    private notifyRequest;
     private notifySuccessRequest;
     private notifyFailRequest;
-    request<T = unknown>(method: HttpMethods, url: `/${string}`, { auth, ...request }?: ApiRequestOptions): Promise<T>;
+    private notifyRatelimit;
+    private notifyRestObservers;
+    private notifyRestObserverEntries;
+    request<T = unknown>(method: HttpMethods, url: `/${string}`, request?: ApiRequestOptions): Promise<T>;
     parseError(method: HttpMethods, route: `/${string}`, response: Response, result: string | Record<string, any>, originTrace?: {
         stack?: string;
     }): SeyfertError;
     parseValidationError(data: Record<string, any>, path?: string, errors?: string[]): string[];
-    handle50X(method: HttpMethods, url: `/${string}`, request: ApiRequestOptions, next: () => void): Promise<unknown>;
-    handle429(route: string, method: HttpMethods, url: `/${string}`, request: ApiRequestOptions, response: Response, result: string, next: () => void, reject: (err: unknown) => void, now: number): Promise<unknown>;
+    handle50X(method: HttpMethods, url: `/${string}`, request: ApiRequestOptions, attempts: number | (() => void), next?: () => void, resolve?: (value: unknown) => void, reject?: (err: unknown) => void): Promise<unknown>;
+    handle429(route: string, method: HttpMethods, url: `/${string}`, request: ApiRequestOptions, response: Response, result: string, next: () => void, reject: (err: unknown) => void, now: number, notifyUrl: `/${string}`): Promise<unknown>;
     clearResetInterval(route: string): void;
     setResetBucket(route: string, resp: Response, now: number, headerNow: number): void;
     setRatelimitsBucket(route: string, resp: Response): void;
@@ -63,3 +72,6 @@ export type RestArgumentsNoBody<Q extends never | Record<string, any> = never> =
     query?: Q;
     files?: RawFile[];
 } & RequestOptions;
+export type RestArgumentsRequiredQuery<Q extends Record<string, any>> = Omit<RestArgumentsNoBody<Q>, 'query'> & {
+    query: Q;
+};

package/lib/api/api.js

@@ -4,6 +4,7 @@ exports.ApiHandler = void 0;
 const node_crypto_1 = require("node:crypto");
 const common_1 = require("../common");
 const utils_1 = require("../common/it/utils");
+const worker_1 = require("../websocket/discord/worker");
 const bucket_1 = require("./bucket");
 const Router_1 = require("./Router");
 const shared_1 = require("./shared");
@@ -18,6 +19,9 @@ class ApiHandler {
     onRatelimit;
     onSuccessRequest;
     onFailRequest;
+    pluginRestObserverProvider;
+    pluginRestObserverClient;
+    restObservers = new Map();
     constructor(options) {
         this.options = {
             baseUrl: 'api/v10',
@@ -59,6 +63,17 @@ class ApiHandler {
             };
         }
     }
+    observe(observer, _opts) {
+        const id = Symbol('rest-observer');
+        this.restObservers.set(id, { observer });
+        let disposed = false;
+        return () => {
+            if (disposed)
+                return;
+            disposed = true;
+            this.restObservers.delete(id);
+        };
+    }
     set debug(active) {
         this.debugger = active
             ? new common_1.Logger({
@@ -83,15 +98,45 @@ class ApiHandler {
         return uuid;
     }
     sendMessage(_body) {
-        throw new common_1.SeyfertError('FUNCTION_NOT_IMPLEMENTED', { metadata: { detail: 'Function not implemented' } });
+        throw new common_1.SeyfertError('FUNCTION_NOT_IMPLEMENTED', {
+            metadata: { detail: 'Function not implemented' },
+        });
     }
     postMessage(body) {
         this.sendMessage(body);
         return new Promise((res, rej) => {
-            this.workerPromises.set(body.nonce, { reject: rej, resolve: res });
+            const timeout = setTimeout(() => {
+                this.workerPromises.delete(body.nonce);
+                rej(new common_1.SeyfertError('WORKER_TIMEOUT', { metadata: { detail: `nonce: ${body.nonce}` } }));
+            }, worker_1.WORKER_TIMEOUT_MS);
+            this.workerPromises.set(body.nonce, {
+                resolve: value => {
+                    clearTimeout(timeout);
+                    res(value);
+                },
+                reject: reason => {
+                    clearTimeout(timeout);
+                    rej(reason);
+                },
+            });
         });
     }
-    async notifySuccessRequest(method, url, response) {
+    async notifyRequest(method, url, request) {
+        await this.notifyRestObservers('onRequest', () => freezeRestPayload({
+            client: this.pluginRestObserverClient,
+            method,
+            url,
+            request: readonlyRequestOptions(request),
+        }));
+    }
+    async notifySuccessRequest(method, url, response, request) {
+        await this.notifyRestObservers('onSuccess', () => freezeRestPayload({
+            client: this.pluginRestObserverClient,
+            method,
+            url,
+            request: readonlyRequestOptions(request),
+            response,
+        }));
         try {
             await this.onSuccessRequest?.(method, url, response);
         }
@@ -99,7 +144,15 @@ class ApiHandler {
             this.debugger?.warn('onSuccessRequest callback error', error);
         }
     }
-    async notifyFailRequest(method, url, error, statusCode) {
+    async notifyFailRequest(method, url, error, statusCode, request) {
+        await this.notifyRestObservers('onFail', () => freezeRestPayload({
+            client: this.pluginRestObserverClient,
+            method,
+            url,
+            request: readonlyRequestOptions(request),
+            error,
+            statusCode,
+        }));
         try {
             await this.onFailRequest?.(method, url, error, statusCode);
         }
@@ -107,7 +160,54 @@ class ApiHandler {
             this.debugger?.warn('onFailRequest callback error', callbackError);
         }
     }
-    async request(method, url, { auth = true, ...request } = {}) {
+    async notifyRatelimit(response, request, method, url) {
+        await this.notifyRestObservers('onRatelimit', () => freezeRestPayload({
+            client: this.pluginRestObserverClient,
+            method,
+            url,
+            request: readonlyRequestOptions(request),
+            response,
+        }));
+        try {
+            await this.onRatelimit?.(response, request);
+        }
+        catch (error) {
+            this.debugger?.warn('onRatelimit callback error', error);
+        }
+    }
+    async notifyRestObservers(name, createPayload) {
+        let payload;
+        let hasPayload = false;
+        const getPayload = () => {
+            if (!hasPayload) {
+                payload = createPayload();
+                hasPayload = true;
+            }
+            return payload;
+        };
+        await this.notifyRestObserverEntries(name, getPayload, this.pluginRestObserverProvider?.() ?? []);
+        await this.notifyRestObserverEntries(name, getPayload, this.restObservers.values());
+    }
+    async notifyRestObserverEntries(name, getPayload, entries) {
+        for (const entry of entries) {
+            const observer = entry.observer[name];
+            if (!observer)
+                continue;
+            const payload = getPayload();
+            try {
+                await observer(payload);
+            }
+            catch (error) {
+                const source = entry.plugin ? `[plugin:${entry.plugin}] ` : '';
+                this.debugger?.warn(`${source}REST observer "${name}" callback error`, error);
+            }
+        }
+    }
+    async request(method, url, request = {}) {
+        const requestOptions = { ...request };
+        const { auth = true } = requestOptions;
+        let attempts = requestOptions._50xRetries ?? 0;
+        delete requestOptions._50xRetries;
         const originTrace = {};
         Error.captureStackTrace(originTrace, this.request);
         if (this.options.workerProxy) {
@@ -118,23 +218,32 @@ class ApiHandler {
                 type: 'WORKER_API_REQUEST',
                 workerId: this.workerData.workerId,
                 nonce,
-                requestOptions: { auth, ...request },
+                requestOptions: { auth, ...requestOptions },
             });
         }
-        const route = request.route || this.routefy(url, method);
-        let attempts = 0;
+        const route = requestOptions.route || this.routefy(url, method);
         const callback = async (next, resolve, reject) => {
             const headers = {
                 'User-Agent': this.options.userAgent,
             };
-            const { data, finalUrl } = this.parseRequest({
-                url,
-                headers,
-                request: { ...request, auth },
-            });
+            let data;
+            let finalUrl;
+            try {
+                ({ data, finalUrl } = this.parseRequest({
+                    url,
+                    headers,
+                    request: { ...requestOptions, auth },
+                }));
+            }
+            catch (err) {
+                next();
+                reject(err);
+                return;
+            }
             let response;
             try {
                 const requestUrl = `${this.options.domain}/${this.options.baseUrl}${finalUrl}`;
+                await this.notifyRequest(method, finalUrl, { ...request, auth });
                 this.debugger?.debug(`Sending, Method: ${method} | Url: [${finalUrl}](${route}) | Auth: ${auth}`);
                 response = await fetch(requestUrl, {
                     method,
@@ -145,7 +254,7 @@ class ApiHandler {
             }
             catch (err) {
                 this.debugger?.debug('Fetch error', err);
-                await this.notifyFailRequest(method, finalUrl, err);
+                await this.notifyFailRequest(method, finalUrl, err, undefined, { ...request, auth });
                 next();
                 reject(err);
                 return;
@@ -154,18 +263,19 @@ class ApiHandler {
             const headerNow = Date.parse(response.headers.get('date') ?? '');
             this.setRatelimitsBucket(route, response);
             this.setResetBucket(route, response, now, headerNow);
+            const observerResponse = response.clone();
             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);
+                    const result429 = await this.handle429(route, method, url, { ...request, auth }, observerResponse, result, next, reject, now, finalUrl);
                     if (result429 !== false)
                         return resolve(result429);
-                    await this.notifyFailRequest(method, finalUrl, result, response.status);
+                    await this.notifyFailRequest(method, finalUrl, result, response.status, { ...request, auth });
                     return this.clearResetInterval(route);
                 }
                 if ([502, 503].includes(response.status) && ++attempts < 4) {
                     this.clearResetInterval(route);
-                    return this.handle50X(method, url, request, next);
+                    return this.handle50X(method, url, requestOptions, attempts, next, resolve, reject);
                 }
                 this.clearResetInterval(route);
                 next();
@@ -176,7 +286,7 @@ class ApiHandler {
                         }
                         catch (err) {
                             this.debugger?.warn('SeyfertError parsing result error (', result, ')', err);
-                            await this.notifyFailRequest(method, finalUrl, err, response.status);
+                            await this.notifyFailRequest(method, finalUrl, err, response.status, { ...request, auth });
                             reject(err);
                             return;
                         }
@@ -184,7 +294,7 @@ class ApiHandler {
                 }
                 const parsedError = this.parseError(method, route, response, result, originTrace);
                 this.debugger?.warn(parsedError.message);
-                await this.notifyFailRequest(method, finalUrl, parsedError, response.status);
+                await this.notifyFailRequest(method, finalUrl, parsedError, response.status, { ...request, auth });
                 reject(parsedError);
                 return;
             }
@@ -195,14 +305,14 @@ class ApiHandler {
                     }
                     catch (err) {
                         this.debugger?.warn('Failed parsing result (', result, ')', err);
-                        await this.notifyFailRequest(method, finalUrl, err, response.status);
+                        await this.notifyFailRequest(method, finalUrl, err, response.status, { ...request, auth });
                         next();
                         reject(err);
                         return;
                     }
                 }
             }
-            await this.notifySuccessRequest(method, finalUrl, response);
+            await this.notifySuccessRequest(method, finalUrl, observerResponse, { ...request, auth });
             next();
             return resolve(result || undefined);
         };
@@ -279,21 +389,30 @@ class ApiHandler {
         }
         return errors;
     }
-    async handle50X(method, url, request, next) {
+    async handle50X(method, url, request, attempts, next = () => { }, resolve, reject) {
+        const retryAttempt = typeof attempts === 'number' ? attempts : 0;
+        const callback = typeof attempts === 'function' ? attempts : next;
+        const requestOptions = {
+            ...request,
+            unshift: true,
+            ...(retryAttempt > 0 ? { _50xRetries: retryAttempt } : {}),
+        };
         const wait = Math.floor(Math.random() * 1900 + 100);
         this.debugger?.warn(`Handling a 50X status, retrying in ${wait}ms`);
-        next();
+        callback();
         await (0, common_1.delay)(wait);
-        return this.request(method, url, {
-            body: request.body,
-            auth: request.auth,
-            reason: request.reason,
-            route: request.route,
-            unshift: true,
+        return this.request(method, url, requestOptions)
+            .then(value => {
+            resolve?.(value);
+            return value;
+        })
+            .catch(error => {
+            reject?.(error);
+            throw error;
         });
     }
-    async handle429(route, method, url, request, response, result, next, reject, now) {
-        await this.onRatelimit?.(response, request);
+    async handle429(route, method, url, request, response, result, next, reject, now, notifyUrl) {
+        await this.notifyRatelimit(response, request, method, notifyUrl);
         const bucket = this.ratelimits.get(route);
         let retryAfter;
         const data = JSON.parse(result);
@@ -325,19 +444,13 @@ class ApiHandler {
             await (0, common_1.delay)(retryAfter);
             next();
             return this.request(method, url, {
-                body: request.body,
-                auth: request.auth,
-                reason: request.reason,
-                route: request.route,
+                ...request,
                 unshift: true,
             });
         }
         next();
         return this.request(method, url, {
-            body: request.body,
-            auth: request.auth,
-            reason: request.reason,
-            route: request.route,
+            ...request,
             unshift: true,
         });
     }
@@ -372,8 +485,8 @@ class ApiHandler {
         if (resp.headers.has('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');
+        const raw = resp.headers.get('x-ratelimit-remaining');
+        this.ratelimits.get(route).remaining = raw != null ? +raw : 1;
         if (this.options.smartBucket) {
             if (resp.headers.has('x-ratelimit-reset-after') &&
                 !this.ratelimits.get(route).resetAfter &&
@@ -389,7 +502,11 @@ class ApiHandler {
         let finalUrl = options.url;
         let data;
         if (options.request.auth) {
-            options.headers.Authorization = `${this.options.type} ${options.request.token || this.options.token}`;
+            const token = options.request.token || this.options.token;
+            if (token === 'INVALID' || typeof token !== 'string' || token.length === 0) {
+                throw new common_1.SeyfertError('INVALID_TOKEN', { metadata: { detail: 'token is not a string' } });
+            }
+            options.headers.Authorization = `${this.options.type} ${token}`;
         }
         if (options.request.query) {
             const params = new URLSearchParams();
@@ -449,7 +566,7 @@ class ApiHandler {
             .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, common_1.snowflakeToTimestamp)(messageID));
+            const createdAt = (0, common_1.snowflakeToTimestamp)(messageID);
             if (Date.now() - createdAt >= 1000 * 60 * 60 * 24 * 14) {
                 method += '_OLD';
             }
@@ -471,3 +588,40 @@ class ApiHandler {
     }
 }
 exports.ApiHandler = ApiHandler;
+function freezeRestPayload(payload) {
+    return Object.freeze(payload);
+}
+function readonlyRequestOptions(request) {
+    const clone = deepClonePlain({
+        ...request,
+        body: request.body ? deepClonePlain(request.body) : undefined,
+        query: request.query ? deepClonePlain(request.query) : undefined,
+        files: request.files?.map(file => deepClonePlain(file)),
+    });
+    return deepFreezePlain(clone);
+}
+function deepClonePlain(value) {
+    if (Array.isArray(value))
+        return value.map(deepClonePlain);
+    if (!isPlainObject(value))
+        return value;
+    return Object.fromEntries(Object.entries(value).map(([key, entry]) => [key, deepClonePlain(entry)]));
+}
+function deepFreezePlain(value) {
+    if (Array.isArray(value)) {
+        for (const entry of value)
+            deepFreezePlain(entry);
+        return Object.freeze(value);
+    }
+    if (!isPlainObject(value))
+        return value;
+    for (const entry of Object.values(value))
+        deepFreezePlain(entry);
+    return Object.freeze(value);
+}
+function isPlainObject(value) {
+    if (typeof value !== 'object' || value === null)
+        return false;
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+}

package/lib/api/shared.d.ts

@@ -1,4 +1,4 @@
-import type { MakeRequired } from '../common';
+import type { Awaitable, MakeRequired } from '../common';
 export * from './api';
 export * from './utils/constants';
 export * from './utils/types';
@@ -34,3 +34,32 @@ export interface ApiRequestOptions {
     token?: string;
 }
 export type HttpMethods = 'GET' | 'DELETE' | 'PUT' | 'POST' | 'PATCH';
+export interface RestObserverRequestPayload<TClient = unknown> {
+    readonly client: TClient;
+    readonly method: HttpMethods;
+    readonly url: `/${string}`;
+    readonly request: Readonly<ApiRequestOptions>;
+}
+export interface RestObserverSuccessPayload<TClient = unknown> extends RestObserverRequestPayload<TClient> {
+    readonly response: Response;
+}
+export interface RestObserverFailPayload<TClient = unknown> extends RestObserverRequestPayload<TClient> {
+    readonly error: unknown;
+    readonly statusCode?: number;
+}
+export interface RestObserverRatelimitPayload<TClient = unknown> extends RestObserverRequestPayload<TClient> {
+    readonly response: Response;
+}
+export interface RestObserver<TClient = unknown> {
+    onRequest?(payload: RestObserverRequestPayload<TClient>): Awaitable<unknown>;
+    onSuccess?(payload: RestObserverSuccessPayload<TClient>): Awaitable<unknown>;
+    onFail?(payload: RestObserverFailPayload<TClient>): Awaitable<unknown>;
+    onRatelimit?(payload: RestObserverRatelimitPayload<TClient>): Awaitable<unknown>;
+}
+export interface RestObserverEntry<TClient = unknown> {
+    readonly plugin?: string;
+    readonly observer: RestObserver<TClient>;
+}
+export interface RestObserveOptions {
+}
+export type RestObserverDisposer = () => void;

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

@@ -1,4 +1,4 @@
-export declare const DefaultUserAgent: "DiscordBot (https://seyfert.dev, v4.4.0)";
+export declare const DefaultUserAgent: "DiscordBot (https://seyfert.dev, v4.0.0)";
 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, 100, 128, 256, 512, 1024, 2048, 4096];

package/lib/api/utils/constants.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ALLOWED_TAG_BADGE_EXTENSIONS = exports.ALLOWED_SOUNDS_EXTENSIONS = exports.ALLOWED_SIZES = exports.ALLOWED_STICKER_EXTENSIONS = exports.ALLOWED_EXTENSIONS = exports.DefaultUserAgent = void 0;
-exports.DefaultUserAgent = 'DiscordBot (https://seyfert.dev, v4.4.0)';
+exports.DefaultUserAgent = 'DiscordBot (https://seyfert.dev, v4.0.0)';
 exports.ALLOWED_EXTENSIONS = ['webp', 'png', 'jpg', 'jpeg', 'gif'];
 exports.ALLOWED_STICKER_EXTENSIONS = ['png', 'json', 'gif'];
 exports.ALLOWED_SIZES = [16, 32, 64, 100, 128, 256, 512, 1_024, 2_048, 4_096];

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

@@ -1,10 +1,11 @@
 import type { Snowflake } from '../../types';
+import type { UserAvatarDefault } from '../Routes/cdn';
 /**
  * Calculates the default avatar index for a given user id.
  *
  * @param userId - The user id to calculate the default avatar index for
  */
-export declare function calculateUserDefaultAvatarIndex(userId: Snowflake, discriminator: string): number;
+export declare function calculateUserDefaultAvatarIndex(userId: Snowflake, discriminator: string): UserAvatarDefault;
 /**
  * Verifies that a value is a buffer-like object.
  *

package/lib/api/utils/utils.js

@@ -8,7 +8,7 @@ exports.isBufferLike = isBufferLike;
  * @param userId - The user id to calculate the default avatar index for
  */
 function calculateUserDefaultAvatarIndex(userId, discriminator) {
-    return discriminator === '0' ? Number(BigInt(userId) >> 22n) % 6 : Number.parseInt(discriminator) % 5;
+    return (discriminator === '0' ? Number(BigInt(userId) >> 22n) % 6 : Number.parseInt(discriminator) % 5);
 }
 /**
  * Verifies that a value is a buffer-like object.

package/lib/builders/Attachment.d.ts

@@ -101,7 +101,7 @@ export declare function resolveAttachmentData(data: AttachmentResolvable, type:
  * @param data - The base64 data.
  * @returns The resolved data URL.
  */
-export declare function resolveBase64(data: string | Buffer): string;
+export declare function resolveBase64(data: string | Buffer, contentType?: string): string;
 /**
  * Resolves an image to a base64 data URL.
  * @param image - The image to resolve.