seyfert 1.0.0 → 1.1.0

package/lib/api/CDN.d.ts

@@ -36,7 +36,7 @@ export interface MakeURLOptions {
      *
      * @defaultValue `'webp'`
      */
-    extension?: string | undefined;
+    extension?: ImageExtension | StickerExtension | undefined;
     /**
      * The size specified in the image URL
      */

package/lib/api/CDN.js

@@ -212,8 +212,6 @@ class CDN {
      * @param options - The extension/size options for the link
      */
     makeURL(route, { allowedExtensions = constants_js_1.ALLOWED_EXTENSIONS, extension = 'webp', size } = {}) {
-        // eslint-disable-next-line no-param-reassign
-        extension = String(extension).toLowerCase();
         if (!allowedExtensions.includes(extension)) {
             throw new RangeError(`Invalid extension provided: ${extension}\nMust be one of: ${allowedExtensions.join(', ')}`);
         }

package/lib/api/Router.js

@@ -28,7 +28,7 @@ class Router {
                 return this.createProxy([...route, key]);
             },
             apply: (...[, _, args]) => {
-                return this.createProxy([...route, ...args.filter(x => x != null)]);
+                return this.createProxy([...route, ...args]);
             },
         });
     }
@@ -56,7 +56,7 @@ exports.CDNRouter = {
                 return this.createProxy([...route, key]);
             },
             apply: (...[, _, args]) => {
-                return this.createProxy([...route, ...args.filter(x => x != null)]);
+                return this.createProxy([...route, ...args]);
             },
         });
     },

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

@@ -2,44 +2,40 @@ import type { RESTGetAPIApplicationCommandResult, RESTGetAPIApplicationCommandsQ
 import type { RestArguments } from '../api';
 import type { ProxyRequestMethod } from '../Router';
 export interface ApplicationRoutes {
-    applications: {
-        (id: string): {
-            guilds: {
-                (id: string): {
-                    commands: {
-                        get(args?: RestArguments<ProxyRequestMethod.Get, RESTGetAPIApplicationGuildCommandsQuery>): Promise<RESTGetAPIApplicationGuildCommandsResult>;
-                        post(args: RestArguments<ProxyRequestMethod.Post, RESTPostAPIApplicationGuildCommandsJSONBody>): Promise<RESTPostAPIApplicationGuildCommandsResult>;
-                        put(args?: RestArguments<ProxyRequestMethod.Put, RESTPutAPIApplicationGuildCommandsJSONBody>): Promise<RESTPutAPIApplicationGuildCommandsResult>;
-                        permissions: {
-                            get(args?: RestArguments<ProxyRequestMethod.Get>): Promise<RESTGetAPIGuildApplicationCommandsPermissionsResult>;
-                        };
-                        (id: string): {
-                            get(args?: RestArguments<ProxyRequestMethod.Get>): Promise<RESTGetAPIApplicationGuildCommandResult>;
-                            patch(args: RestArguments<ProxyRequestMethod.Patch, RESTPatchAPIApplicationGuildCommandJSONBody>): Promise<RESTPatchAPIApplicationGuildCommandResult>;
-                            delete(args?: RestArguments<ProxyRequestMethod.Delete>): Promise<never>;
-                            permissions: {
-                                get(args?: RestArguments<ProxyRequestMethod.Get>): Promise<RESTGetAPIGuildApplicationCommandsPermissionsResult>;
-                                put(args?: RestArguments<ProxyRequestMethod.Put, RESTPutAPIApplicationCommandPermissionsJSONBody>): Promise<RESTPutAPIGuildApplicationCommandsPermissionsResult>;
-                            };
-                        };
-                    };
-                };
-            };
+    applications: (id: string) => {
+        guilds: (id: string) => {
             commands: {
-                get(args?: RestArguments<ProxyRequestMethod.Get, RESTGetAPIApplicationCommandsQuery>): Promise<RESTGetAPIApplicationCommandsResult>;
-                post(args: RestArguments<ProxyRequestMethod.Post, RESTPostAPIApplicationCommandsJSONBody>): Promise<RESTPostAPIApplicationCommandsResult>;
-                put(args?: RestArguments<ProxyRequestMethod.Put, RESTPutAPIApplicationCommandsJSONBody>): Promise<RESTPutAPIApplicationCommandsResult>;
+                get(args?: RestArguments<ProxyRequestMethod.Get, RESTGetAPIApplicationGuildCommandsQuery>): Promise<RESTGetAPIApplicationGuildCommandsResult>;
+                post(args: RestArguments<ProxyRequestMethod.Post, RESTPostAPIApplicationGuildCommandsJSONBody>): Promise<RESTPostAPIApplicationGuildCommandsResult>;
+                put(args?: RestArguments<ProxyRequestMethod.Put, RESTPutAPIApplicationGuildCommandsJSONBody>): Promise<RESTPutAPIApplicationGuildCommandsResult>;
+                permissions: {
+                    get(args?: RestArguments<ProxyRequestMethod.Get>): Promise<RESTGetAPIGuildApplicationCommandsPermissionsResult>;
+                };
                 (id: string): {
-                    get(args?: RestArguments<ProxyRequestMethod.Get>): Promise<RESTGetAPIApplicationCommandResult>;
-                    patch(args: RestArguments<ProxyRequestMethod.Patch, RESTPatchAPIApplicationCommandJSONBody>): Promise<RESTPatchAPIApplicationCommandResult>;
+                    get(args?: RestArguments<ProxyRequestMethod.Get>): Promise<RESTGetAPIApplicationGuildCommandResult>;
+                    patch(args: RestArguments<ProxyRequestMethod.Patch, RESTPatchAPIApplicationGuildCommandJSONBody>): Promise<RESTPatchAPIApplicationGuildCommandResult>;
                     delete(args?: RestArguments<ProxyRequestMethod.Delete>): Promise<never>;
+                    permissions: {
+                        get(args?: RestArguments<ProxyRequestMethod.Get>): Promise<RESTGetAPIGuildApplicationCommandsPermissionsResult>;
+                        put(args?: RestArguments<ProxyRequestMethod.Put, RESTPutAPIApplicationCommandPermissionsJSONBody>): Promise<RESTPutAPIGuildApplicationCommandsPermissionsResult>;
+                    };
                 };
             };
-            'role-connections': {
-                metadata: {
-                    get(args?: RestArguments<ProxyRequestMethod.Get>): Promise<RESTGetAPIApplicationRoleConnectionMetadataResult>;
-                    put(args: RestArguments<ProxyRequestMethod.Put, RESTPutAPIApplicationRoleConnectionMetadataJSONBody>): Promise<RESTPutAPIApplicationRoleConnectionMetadataResult>;
-                };
+        };
+        commands: {
+            get(args?: RestArguments<ProxyRequestMethod.Get, RESTGetAPIApplicationCommandsQuery>): Promise<RESTGetAPIApplicationCommandsResult>;
+            post(args: RestArguments<ProxyRequestMethod.Post, RESTPostAPIApplicationCommandsJSONBody>): Promise<RESTPostAPIApplicationCommandsResult>;
+            put(args?: RestArguments<ProxyRequestMethod.Put, RESTPutAPIApplicationCommandsJSONBody>): Promise<RESTPutAPIApplicationCommandsResult>;
+            (id: string): {
+                get(args?: RestArguments<ProxyRequestMethod.Get>): Promise<RESTGetAPIApplicationCommandResult>;
+                patch(args: RestArguments<ProxyRequestMethod.Patch, RESTPatchAPIApplicationCommandJSONBody>): Promise<RESTPatchAPIApplicationCommandResult>;
+                delete(args?: RestArguments<ProxyRequestMethod.Delete>): Promise<never>;
+            };
+        };
+        'role-connections': {
+            metadata: {
+                get(args?: RestArguments<ProxyRequestMethod.Get>): Promise<RESTGetAPIApplicationRoleConnectionMetadataResult>;
+                put(args: RestArguments<ProxyRequestMethod.Put, RESTPutAPIApplicationRoleConnectionMetadataJSONBody>): Promise<RESTPutAPIApplicationRoleConnectionMetadataResult>;
             };
         };
     };

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

@@ -6,13 +6,11 @@ export interface ChannelRoutes {
         get(args?: RestArguments<ProxyRequestMethod.Get>): Promise<RESTGetAPIChannelResult>;
         patch(args: RestArguments<ProxyRequestMethod.Patch, RESTPatchAPIChannelJSONBody>): Promise<RESTPatchAPIChannelResult>;
         delete(args?: RestArguments<ProxyRequestMethod.Delete>): Promise<RESTDeleteAPIChannelResult>;
-        users: {
-            (id: '@me'): {
-                threads: {
-                    archived: {
-                        private: {
-                            get(args?: RestArguments<ProxyRequestMethod.Get, RESTGetAPIChannelThreadsArchivedQuery>): Promise<RESTGetAPIChannelUsersThreadsArchivedResult>;
-                        };
+        users: (id: '@me') => {
+            threads: {
+                archived: {
+                    private: {
+                        get(args?: RestArguments<ProxyRequestMethod.Get, RESTGetAPIChannelThreadsArchivedQuery>): Promise<RESTGetAPIChannelUsersThreadsArchivedResult>;
                     };
                 };
             };
@@ -40,11 +38,9 @@ export interface ChannelRoutes {
                 };
             };
         };
-        recipients: {
-            (id: string): {
-                put(args?: RestArguments<ProxyRequestMethod.Put, RESTPutAPIChannelRecipientJSONBody>): Promise<RESTPutAPIChannelRecipientResult>;
-                delete(args?: RestArguments<ProxyRequestMethod.Delete>): Promise<RESTDeleteAPIChannelRecipientResult>;
-            };
+        recipients: (id: string) => {
+            put(args?: RestArguments<ProxyRequestMethod.Put, RESTPutAPIChannelRecipientJSONBody>): Promise<RESTPutAPIChannelRecipientResult>;
+            delete(args?: RestArguments<ProxyRequestMethod.Delete>): Promise<RESTDeleteAPIChannelRecipientResult>;
         };
         pins: {
             get(args?: RestArguments<ProxyRequestMethod.Get>): Promise<RESTGetAPIChannelPinsResult>;
@@ -56,11 +52,9 @@ export interface ChannelRoutes {
         followers: {
             post(args: RestArguments<ProxyRequestMethod.Post, RESTPostAPIChannelFollowersJSONBody>): Promise<RESTPostAPIChannelFollowersResult>;
         };
-        permissions: {
-            (id: string): {
-                put(args?: RestArguments<ProxyRequestMethod.Put, RESTPutAPIChannelPermissionJSONBody>): Promise<RESTPutAPIChannelPermissionResult>;
-                delete(args?: RestArguments<ProxyRequestMethod.Delete>): Promise<RESTDeleteAPIChannelPermissionResult>;
-            };
+        permissions: (id: string) => {
+            put(args?: RestArguments<ProxyRequestMethod.Put, RESTPutAPIChannelPermissionJSONBody>): Promise<RESTPutAPIChannelPermissionResult>;
+            delete(args?: RestArguments<ProxyRequestMethod.Delete>): Promise<RESTDeleteAPIChannelPermissionResult>;
         };
         invites: {
             get(args?: RestArguments<ProxyRequestMethod.Get>): Promise<RESTGetAPIChannelInvitesResult>;

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

@@ -2,13 +2,9 @@ import type { RESTPostAPIInteractionCallbackJSONBody } from '../../common';
 import type { RestArguments } from '../api';
 import type { ProxyRequestMethod } from '../Router';
 export interface InteractionRoutes {
-    interactions: {
-        (id: string): {
-            (token: string): {
-                callback: {
-                    post(args: RestArguments<ProxyRequestMethod.Post, RESTPostAPIInteractionCallbackJSONBody>): Promise<never>;
-                };
-            };
+    interactions: (id: string) => (token: string) => {
+        callback: {
+            post(args: RestArguments<ProxyRequestMethod.Post, RESTPostAPIInteractionCallbackJSONBody>): Promise<never>;
         };
     };
 }

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

@@ -17,12 +17,10 @@ export interface WebhookRoutes {
             github: {
                 post(args: RestArguments<ProxyRequestMethod.Post, RESTPostAPIWebhookWithTokenJSONBody, RESTPostAPIWebhookWithTokenGitHubQuery>): Promise<RESTPostAPIWebhookWithTokenGitHubResult | RESTPostAPIWebhookWithTokenGitHubWaitResult>;
             };
-            messages: {
-                (id: string | '@original'): {
-                    get(args?: RestArguments<ProxyRequestMethod.Get>): Promise<RESTGetAPIWebhookWithTokenMessageResult>;
-                    patch(args: RestArguments<ProxyRequestMethod.Patch, RESTPatchAPIWebhookWithTokenMessageJSONBody>): Promise<RESTPatchAPIWebhookWithTokenMessageResult>;
-                    delete(args?: RestArguments<ProxyRequestMethod.Delete>): Promise<RESTDeleteAPIWebhookWithTokenMessageResult>;
-                };
+            messages: (id: string | '@original') => {
+                get(args?: RestArguments<ProxyRequestMethod.Get>): Promise<RESTGetAPIWebhookWithTokenMessageResult>;
+                patch(args: RestArguments<ProxyRequestMethod.Patch, RESTPatchAPIWebhookWithTokenMessageJSONBody>): Promise<RESTPatchAPIWebhookWithTokenMessageResult>;
+                delete(args?: RestArguments<ProxyRequestMethod.Delete>): Promise<RESTDeleteAPIWebhookWithTokenMessageResult>;
             };
         };
     };

package/lib/api/api.d.ts

@@ -4,12 +4,17 @@ 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>;

package/lib/api/api.js

@@ -2,7 +2,9 @@
 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");
@@ -16,8 +18,11 @@ class ApiHandler {
     readyQueue = [];
     cdn = new CDN_1.CDN();
     debugger;
+    workerPromises;
     constructor(options) {
         this.options = {
+            baseUrl: 'api/v10',
+            domain: 'https://discord.com',
             ...options,
             userAgent: shared_1.DefaultUserAgent,
         };
@@ -26,6 +31,10 @@ class ApiHandler {
                 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;
@@ -34,7 +43,34 @@ class ApiHandler {
             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) => {

package/lib/api/shared.d.ts

@@ -1,17 +1,19 @@
 /// <reference types="node" />
+import type { MakeRequired } from '../common';
 export * from './api';
 export * from './utils/constants';
 export * from './utils/types';
 export { calculateUserDefaultAvatarIndex } from './utils/utils';
 export interface ApiHandlerOptions {
-    baseUrl: string;
-    domain: string;
+    baseUrl?: string;
+    domain?: string;
     token: string;
     debug?: boolean;
     agent?: string;
     smartBucket?: boolean;
+    workerProxy?: boolean;
 }
-export interface ApiHandlerInternalOptions extends ApiHandlerOptions {
+export interface ApiHandlerInternalOptions extends MakeRequired<ApiHandlerOptions, 'baseUrl' | 'domain'> {
     userAgent: string;
 }
 export interface RawFile {

package/lib/builders/Attachment.d.ts

@@ -1,7 +1,6 @@
 /// <reference types="node" />
 import type { APIAttachment, RESTAPIAttachment } from 'discord-api-types/v10';
-import { type RawFile } from '..';
-import type { BaseClient } from '../client/base';
+import { type UsingClient, type RawFile } from '..';
 import type { ImageResolvable, ObjectToLower } from '../common';
 import { Base } from '../structures/extra/Base';
 export interface AttachmentResolvableMap {
@@ -21,7 +20,7 @@ export interface Attachment extends ObjectToLower<APIAttachment> {
 }
 export declare class Attachment extends Base {
     data: APIAttachment;
-    constructor(client: BaseClient, data: APIAttachment);
+    constructor(client: UsingClient, data: APIAttachment);
 }
 export declare class AttachmentBuilder {
     data: Partial<AttachmentData>;

package/lib/builders/Button.d.ts

@@ -1,4 +1,4 @@
-import { type APIButtonComponent, type APIButtonComponentWithCustomId, type APIButtonComponentWithURL, type ButtonStyle, type EmojiResolvable, type When } from '../common';
+import { type APIButtonComponentWithCustomId, type APIButtonComponentWithURL, type ButtonStyle, type EmojiResolvable, type When } from '../common';
 export type ButtonStylesForID = Exclude<ButtonStyle, ButtonStyle.Link>;
 /**
  * Represents a button component.
@@ -46,5 +46,5 @@ export declare class Button<Type extends boolean = boolean> {
      * Converts the Button instance to its JSON representation.
      * @returns The JSON representation of the Button instance.
      */
-    toJSON(): APIButtonComponent;
+    toJSON(): When<Type, APIButtonComponentWithCustomId, APIButtonComponentWithURL>;
 }

package/lib/cache/adapters/default.d.ts

@@ -1,5 +1,6 @@
 import type { Adapter } from './types';
 export declare class MemoryAdapter implements Adapter {
+    isAsync: boolean;
     readonly storage: Map<string, string>;
     readonly relationships: Map<string, string[]>;
     scan(query: string, keys?: false): any[];

package/lib/cache/adapters/default.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MemoryAdapter = void 0;
 class MemoryAdapter {
+    isAsync = false;
     storage = new Map();
     relationships = new Map();
     scan(query, keys = false) {

package/lib/cache/adapters/redis.d.ts

@@ -4,6 +4,7 @@ interface RedisAdapterOptions {
     namespace?: string;
 }
 export declare class RedisAdapter implements Adapter {
+    isAsync: boolean;
     client: import('ioredis').Redis;
     namespace: string;
     constructor(data: ({

package/lib/cache/adapters/redis.js

@@ -9,6 +9,7 @@ catch {
     // potocuit > seyfert
 }
 class RedisAdapter {
+    isAsync = true;
     client;
     namespace;
     constructor(data) {
@@ -137,6 +138,10 @@ const isObject = (o) => {
     return !!o && typeof o === 'object' && !Array.isArray(o);
 };
 function toNormal(target) {
+    if (typeof target.ARRAY_OF === 'string')
+        return JSON.parse(target.ARRAY_OF).map(toNormal);
+    if (!Object.keys(target).length)
+        return undefined;
     const result = {};
     for (const [key, value] of Object.entries(target)) {
         if (key.startsWith('O_')) {
@@ -155,6 +160,8 @@ function toNormal(target) {
     return result;
 }
 function toDb(target) {
+    if (Array.isArray(target))
+        return { ARRAY_OF: JSON.stringify(target.map(toDb)) };
     const result = {};
     for (const [key, value] of Object.entries(target)) {
         switch (typeof value) {

package/lib/cache/adapters/types.d.ts

@@ -1,4 +1,5 @@
 export interface Adapter {
+    isAsync: boolean;
     scan(query: string, keys?: false): RPV<any[]>;
     scan(query: string, keys: true): RPV<string[]>;
     scan(query: string, keys?: boolean): RPV<(any | string)[]>;

package/lib/cache/adapters/workeradapter.d.ts

@@ -3,17 +3,18 @@
 /// <reference types="node" />
 /// <reference types="node" />
 /// <reference types="node" />
-/// <reference types="node" />
-import { type MessagePort } from 'node:worker_threads';
+import type { WorkerData } from '../../websocket';
 import type { WorkerSendCacheRequest } from '../../websocket/discord/worker';
 import type { Adapter } from './types';
 export declare class WorkerAdapter implements Adapter {
-    readonly parent: MessagePort;
+    workerData: WorkerData;
+    isAsync: boolean;
     promises: Map<string, {
         resolve: (value: unknown) => void;
         timeout: NodeJS.Timeout;
     }>;
-    constructor(parent: MessagePort);
+    constructor(workerData: WorkerData);
+    postMessage(body: any): boolean | void;
     protected send(method: WorkerSendCacheRequest['method'], ...args: any[]): Promise<any>;
     scan(...rest: any[]): Promise<any>;
     get(...rest: any[]): Promise<any>;

package/lib/cache/adapters/workeradapter.js

@@ -4,21 +4,27 @@ exports.WorkerAdapter = void 0;
 const node_crypto_1 = require("node:crypto");
 const node_worker_threads_1 = require("node:worker_threads");
 class WorkerAdapter {
-    parent;
+    workerData;
+    isAsync = true;
     promises = new Map();
-    constructor(parent) {
-        this.parent = parent;
+    constructor(workerData) {
+        this.workerData = workerData;
+    }
+    postMessage(body) {
+        if (node_worker_threads_1.parentPort)
+            return node_worker_threads_1.parentPort.postMessage(body);
+        return process.send(body);
     }
     send(method, ...args) {
         const nonce = (0, node_crypto_1.randomUUID)();
         if (this.promises.has(nonce))
             return this.send(method, ...args);
-        node_worker_threads_1.parentPort.postMessage({
+        this.postMessage({
             type: 'CACHE_REQUEST',
             args,
             nonce,
             method,
-            workerId: node_worker_threads_1.workerData.workerId,
+            workerId: this.workerData.workerId,
         });
         let resolve = (_) => {
             /**/

package/lib/cache/index.d.ts

@@ -11,8 +11,7 @@ import { StageInstances } from './resources/stage-instances';
 import { Stickers } from './resources/stickers';
 import { Threads } from './resources/threads';
 import { VoiceStates } from './resources/voice-states';
-import type { BaseClient } from '../client/base';
-import type { InternalOptions } from '../commands';
+import type { InternalOptions, UsingClient } from '../commands';
 import { GatewayIntentBits } from '../common';
 import { Overwrites } from './resources/overwrites';
 export type InferAsyncCache = InternalOptions extends {
@@ -27,11 +26,11 @@ export type CachedEvents = 'READY' | 'GUILD_CREATE' | 'GUILD_UPDATE' | 'GUILD_DE
 export declare class Cache {
     intents: number;
     adapter: Adapter;
-    asyncCache: boolean;
     readonly disabledCache: (NonGuildBased | GuildBased | GuildRelated)[];
     users?: Users;
     guilds?: Guilds;
     members?: Members;
+    voiceStates?: VoiceStates;
     overwrites?: Overwrites;
     roles?: Roles;
     emojis?: Emojis;
@@ -39,9 +38,8 @@ export declare class Cache {
     channels?: Channels;
     stickers?: Stickers;
     presences?: Presences;
-    voiceStates?: VoiceStates;
     stageInstances?: StageInstances;
-    constructor(intents: number, adapter: Adapter, asyncCache?: boolean, disabledCache?: (NonGuildBased | GuildBased | GuildRelated)[], client?: BaseClient);
+    constructor(intents: number, adapter: Adapter, disabledCache?: (NonGuildBased | GuildBased | GuildRelated)[], client?: UsingClient);
     hasIntent(intent: keyof typeof GatewayIntentBits): boolean;
     get hasGuildsIntent(): boolean;
     get hasRolesIntent(): boolean;
@@ -66,12 +64,12 @@ export declare class Cache {
         channels: NonNullable<ReturnCache<import("..").AllChannels | undefined>>[];
         members: import("..").GuildMember[];
         users: import("..").User[];
+        threads: import("..").ThreadChannel[];
         presences: (Omit<import("discord-api-types/payloads/v10/gateway").GatewayPresenceUpdate, "user"> & {
             id: string;
         } & {
             guild_id: string;
         })[];
-        threads: import("..").ThreadChannel[];
         voiceStates: (Omit<import("discord-api-types/payloads/v10/voice").GatewayVoiceState, "member"> & {
             guild_id: string;
         } & {

package/lib/cache/index.js

@@ -32,13 +32,13 @@ __exportStar(require("./adapters/index"), exports);
 class Cache {
     intents;
     adapter;
-    asyncCache;
     disabledCache;
     // non-guild based
     users;
     guilds;
     // guild based
     members;
+    voiceStates;
     // guild related
     overwrites;
     roles;
@@ -47,12 +47,10 @@ class Cache {
     channels;
     stickers;
     presences;
-    voiceStates;
     stageInstances;
-    constructor(intents, adapter, asyncCache = false, disabledCache = [], client) {
+    constructor(intents, adapter, disabledCache = [], client) {
         this.intents = intents;
         this.adapter = adapter;
-        this.asyncCache = asyncCache;
         this.disabledCache = disabledCache;
         // non-guild based
         if (!this.disabledCache.includes('users')) {
@@ -101,6 +99,7 @@ class Cache {
         this.members?.__setClient(client);
         this.voiceStates?.__setClient(client);
         this.roles?.__setClient(client);
+        this.overwrites?.__setClient(client);
         this.channels?.__setClient(client);
         this.emojis?.__setClient(client);
         this.stickers?.__setClient(client);
@@ -225,7 +224,7 @@ class Cache {
                         }
                         relationshipsData[hashId].push(id);
                         data.guild_id = guildId;
-                        allData.push([this[type].hashGuildId(id, guildId), this[type].parse(data, id, guildId)]);
+                        allData.push([this[type].hashGuildId(guildId, id), this[type].parse(data, id, guildId)]);
                     }
                     break;
                 case 'users':
@@ -289,7 +288,7 @@ class Cache {
                         }
                         relationshipsData[hashId].push(id);
                         data.guild_id = guildId;
-                        allData.push([this[type].hashGuildId(id, guildId), this[type].parse(data, id, guildId)]);
+                        allData.push([this[type].hashGuildId(guildId, id), this[type].parse(data, id, guildId)]);
                     }
                     break;
                 case 'users':

package/lib/cache/resources/default/base.d.ts

@@ -1,11 +1,12 @@
 import type { BaseClient } from '../../../client/base';
+import type { UsingClient } from '../../../commands';
 import { type GatewayIntentBits } from '../../../common';
 import type { Cache, ReturnCache } from '../../index';
 export declare class BaseResource<T = any> {
     protected cache: Cache;
     client: BaseClient;
     namespace: string;
-    constructor(cache: Cache, client?: BaseClient);
+    constructor(cache: Cache, client?: UsingClient);
     get rest(): import("../../..").ApiHandler;
     get adapter(): import("../../index").Adapter;
     removeIfNI(intent: keyof typeof GatewayIntentBits, id: string): import("../../index").RPV<void>;

package/lib/cache/resources/default/guild-based.d.ts

@@ -1,11 +1,12 @@
 import type { BaseClient } from '../../../client/base';
+import type { UsingClient } from '../../../commands';
 import { type GatewayIntentBits } from '../../../common';
 import type { Cache, ReturnCache } from '../../index';
 export declare class GuildBasedResource<T = any> {
     protected cache: Cache;
     client: BaseClient;
     namespace: string;
-    constructor(cache: Cache, client?: BaseClient);
+    constructor(cache: Cache, client?: UsingClient);
     parse(data: any, id: string, guild_id: string): any;
     get adapter(): import("../../index").Adapter;
     removeIfNI(intent: keyof typeof GatewayIntentBits, id: string | string[], guildId: string): import("../../index").RPV<void>;

package/lib/cache/resources/default/guild-based.js

@@ -36,27 +36,27 @@ class GuildBasedResource {
         }
     }
     get(id, guild) {
-        return this.adapter.get(this.hashGuildId(id, guild));
+        return this.adapter.get(this.hashGuildId(guild, id));
     }
     bulk(ids, guild) {
-        return (0, common_1.fakePromise)(this.adapter.get(ids.map(id => this.hashGuildId(id, guild)))).then(x => x.filter(y => y));
+        return (0, common_1.fakePromise)(this.adapter.get(ids.map(id => this.hashGuildId(guild, id)))).then(x => x.filter(y => y));
     }
     set(__keys, guild, data) {
         const keys = Array.isArray(__keys) ? __keys : [[__keys, data]];
         return (0, common_1.fakePromise)(this.addToRelationship(keys.map(x => x[0]), guild)).then(() => this.adapter.set(keys.map(([key, value]) => {
-            return [this.hashGuildId(key, guild), this.parse(value, key, guild)];
+            return [this.hashGuildId(guild, key), this.parse(value, key, guild)];
         })));
     }
     patch(__keys, guild, data) {
         const keys = Array.isArray(__keys) ? __keys : [[__keys, data]];
-        return (0, common_1.fakePromise)(this.adapter.get(keys.map(([key]) => this.hashGuildId(key, guild)))).then(oldDatas => (0, common_1.fakePromise)(this.addToRelationship(keys.map(x => x[0]), guild)).then(() => this.adapter.set(keys.map(([key, value]) => {
+        return (0, common_1.fakePromise)(this.adapter.get(keys.map(([key]) => this.hashGuildId(guild, key)))).then(oldDatas => (0, common_1.fakePromise)(this.addToRelationship(keys.map(x => x[0]), guild)).then(() => this.adapter.set(keys.map(([key, value]) => {
             const oldData = oldDatas.find(x => x.id === key) ?? {};
-            return [this.hashGuildId(key, guild), this.parse({ ...oldData, ...value }, key, guild)];
+            return [this.hashGuildId(guild, key), this.parse({ ...oldData, ...value }, key, guild)];
         }))));
     }
     remove(id, guild) {
         const ids = Array.isArray(id) ? id : [id];
-        return (0, common_1.fakePromise)(this.removeToRelationship(ids, guild)).then(() => this.adapter.remove(ids.map(x => this.hashGuildId(x, guild))));
+        return (0, common_1.fakePromise)(this.removeToRelationship(ids, guild)).then(() => this.adapter.remove(ids.map(x => this.hashGuildId(guild, x))));
     }
     keys(guild) {
         return this.adapter.scan(this.hashGuildId(guild, '*'), true);