seyfert 1.0.1 → 1.1.1

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/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/cache/adapters/redis.js

@@ -138,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_')) {
@@ -156,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,26 +1,26 @@
+import type { Awaitable } from '../../common';
 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)[]>;
-    get(keys: string[]): RPV<any[]>;
-    get(keys: string): RPV<any | null>;
-    get(keys: string | string[]): RPV<any | null>;
-    set(keyValue: [string, any][]): RPV<void>;
-    set(id: string, data: any): RPV<void>;
-    set(id: string | [string, any][], data?: any): RPV<void>;
-    patch(updateOnly: boolean, keyValue: [string, any][]): RPV<void>;
-    patch(updateOnly: boolean, id: string, data: any): RPV<void>;
-    patch(updateOnly: boolean, id: string | [string, any][], data?: any): RPV<void>;
-    values(to: string): RPV<any[]>;
-    keys(to: string): RPV<string[]>;
-    count(to: string): RPV<number>;
-    remove(keys: string | string[]): RPV<void>;
-    contains(to: string, keys: string): RPV<boolean>;
-    getToRelationship(to: string): RPV<string[]>;
-    bulkAddToRelationShip(data: Record<string, string[]>): RPV<void>;
-    addToRelationship(to: string, keys: string | string[]): RPV<void>;
-    removeToRelationship(to: string, keys: string | string[]): RPV<void>;
-    removeRelationship(to: string | string[]): RPV<void>;
+    scan(query: string, keys?: false): Awaitable<any[]>;
+    scan(query: string, keys: true): Awaitable<string[]>;
+    scan(query: string, keys?: boolean): Awaitable<(any | string)[]>;
+    get(keys: string[]): Awaitable<any[]>;
+    get(keys: string): Awaitable<any | null>;
+    get(keys: string | string[]): Awaitable<any | null>;
+    set(keyValue: [string, any][]): Awaitable<void>;
+    set(id: string, data: any): Awaitable<void>;
+    set(id: string | [string, any][], data?: any): Awaitable<void>;
+    patch(updateOnly: boolean, keyValue: [string, any][]): Awaitable<void>;
+    patch(updateOnly: boolean, id: string, data: any): Awaitable<void>;
+    patch(updateOnly: boolean, id: string | [string, any][], data?: any): Awaitable<void>;
+    values(to: string): Awaitable<any[]>;
+    keys(to: string): Awaitable<string[]>;
+    count(to: string): Awaitable<number>;
+    remove(keys: string | string[]): Awaitable<void>;
+    contains(to: string, keys: string): Awaitable<boolean>;
+    getToRelationship(to: string): Awaitable<string[]>;
+    bulkAddToRelationShip(data: Record<string, string[]>): Awaitable<void>;
+    addToRelationship(to: string, keys: string | string[]): Awaitable<void>;
+    removeToRelationship(to: string, keys: string | string[]): Awaitable<void>;
+    removeRelationship(to: string | string[]): Awaitable<void>;
 }
-export type RPV<V> = Promise<V> | V;

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

@@ -3,18 +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,22 +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 {
@@ -31,6 +30,7 @@ export declare class Cache {
     users?: Users;
     guilds?: Guilds;
     members?: Members;
+    voiceStates?: VoiceStates;
     overwrites?: Overwrites;
     roles?: Roles;
     emojis?: Emojis;
@@ -38,9 +38,8 @@ export declare class Cache {
     channels?: Channels;
     stickers?: Stickers;
     presences?: Presences;
-    voiceStates?: VoiceStates;
     stageInstances?: StageInstances;
-    constructor(intents: number, adapter: Adapter, 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;
@@ -65,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

@@ -38,6 +38,7 @@ class Cache {
     guilds;
     // guild based
     members;
+    voiceStates;
     // guild related
     overwrites;
     roles;
@@ -46,7 +47,6 @@ class Cache {
     channels;
     stickers;
     presences;
-    voiceStates;
     stageInstances;
     constructor(intents, adapter, disabledCache = [], client) {
         this.intents = intents;
@@ -99,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);
@@ -223,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':
@@ -287,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,26 +1,27 @@
 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>;
+    removeIfNI(intent: keyof typeof GatewayIntentBits, id: string): import("../../../common").Awaitable<void>;
     setIfNI(intent: keyof typeof GatewayIntentBits, id: string, data: any): any;
     get(id: string): ReturnCache<T | undefined>;
     bulk(ids: string[]): ReturnCache<T[]>;
-    set(id: string, data: any): import("../../index").RPV<void>;
-    patch<T extends Record<any, any> = Record<any, any>>(id: string, data: T): import("../../index").RPV<void>;
-    remove(id: string): import("../../index").RPV<void>;
+    set(id: string, data: any): import("../../../common").Awaitable<void>;
+    patch<T extends Record<any, any> = Record<any, any>>(id: string, data: T): import("../../../common").Awaitable<void>;
+    remove(id: string): import("../../../common").Awaitable<void>;
     keys(): ReturnCache<string[]>;
     values(): ReturnCache<T[]>;
-    count(): import("../../index").RPV<number>;
-    contains(id: string): import("../../index").RPV<boolean>;
-    getToRelationship(): import("../../index").RPV<string[]>;
-    addToRelationship(id: string | string[]): import("../../index").RPV<void>;
-    removeToRelationship(id: string | string[]): import("../../index").RPV<void>;
+    count(): import("../../../common").Awaitable<number>;
+    contains(id: string): import("../../../common").Awaitable<boolean>;
+    getToRelationship(): import("../../../common").Awaitable<string[]>;
+    addToRelationship(id: string | string[]): import("../../../common").Awaitable<void>;
+    removeToRelationship(id: string | string[]): import("../../../common").Awaitable<void>;
     hashId(id: string): string;
 }

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

@@ -1,14 +1,15 @@
 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>;
+    removeIfNI(intent: keyof typeof GatewayIntentBits, id: string | string[], guildId: string): import("../../../common").Awaitable<void>;
     setIfNI(intent: keyof typeof GatewayIntentBits, id: string, guildId: string, data: any): any;
     get(id: string, guild: string): ReturnCache<(T & {
         guild_id: string;
@@ -20,17 +21,17 @@ export declare class GuildBasedResource<T = any> {
     set(__keys: [string, any][], guild: string): ReturnCache<void>;
     patch(__keys: string, guild: string, data: any): ReturnCache<void>;
     patch(__keys: [string, any][], guild: string): ReturnCache<void>;
-    remove(id: string | string[], guild: string): import("../../index").RPV<void>;
+    remove(id: string | string[], guild: string): import("../../../common").Awaitable<void>;
     keys(guild: string): ReturnCache<string[]>;
     values(guild: string): ReturnCache<(T & {
         guild_id: string;
     })[]>;
     count(guild: string): ReturnCache<number>;
     contains(id: string, guild: string): ReturnCache<boolean>;
-    getToRelationship(guild: string): import("../../index").RPV<string[]>;
-    addToRelationship(id: string | string[], guild: string): import("../../index").RPV<void>;
-    removeToRelationship(id: string | string[], guild: string): import("../../index").RPV<void>;
-    removeRelationship(id: string | string[]): import("../../index").RPV<void>;
+    getToRelationship(guild: string): import("../../../common").Awaitable<string[]>;
+    addToRelationship(id: string | string[], guild: string): import("../../../common").Awaitable<void>;
+    removeToRelationship(id: string | string[], guild: string): import("../../../common").Awaitable<void>;
+    removeRelationship(id: string | string[]): import("../../../common").Awaitable<void>;
     hashId(id: string): string;
     hashGuildId(guild: string, id: string): string;
 }

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

@@ -17,7 +17,8 @@ class GuildBasedResource {
         this.client = client;
     }
     parse(data, id, guild_id) {
-        data.id = id;
+        if (!data.id)
+            data.id = id;
         data.guild_id = guild_id;
         return data;
     }
@@ -36,27 +37,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);

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

@@ -1,14 +1,15 @@
 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 GuildRelatedResource<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>;
+    removeIfNI(intent: keyof typeof GatewayIntentBits, id: string | string[], guildId: string): import("../../../common").Awaitable<void>;
     setIfNI(intent: keyof typeof GatewayIntentBits, id: string, guildId: string, data: any): any;
     get(id: string): ReturnCache<(T & {
         guild_id: string;
@@ -20,16 +21,16 @@ export declare class GuildRelatedResource<T = any> {
     set(__keys: [string, any][], guild: string): ReturnCache<void>;
     patch(__keys: string, guild?: string, data?: any): ReturnCache<void>;
     patch(__keys: [string, any][], guild?: string): ReturnCache<void>;
-    remove(id: string | string[], guild: string): import("../../index").RPV<void>;
+    remove(id: string | string[], guild: string): import("../../../common").Awaitable<void>;
     keys(guild: string): ReturnCache<string[]>;
     values(guild: string): ReturnCache<(T & {
         guild_id: string;
     })[]>;
-    count(to: string): import("../../index").RPV<number>;
-    contains(id: string, guild: string): import("../../index").RPV<boolean>;
-    getToRelationship(guild: string): import("../../index").RPV<string[]>;
-    addToRelationship(id: string | string[], guild: string): import("../../index").RPV<void>;
-    removeToRelationship(id: string | string[], guild: string): import("../../index").RPV<void>;
-    removeRelationship(id: string | string[]): import("../../index").RPV<void>;
+    count(to: string): import("../../../common").Awaitable<number>;
+    contains(id: string, guild: string): import("../../../common").Awaitable<boolean>;
+    getToRelationship(guild: string): import("../../../common").Awaitable<string[]>;
+    addToRelationship(id: string | string[], guild: string): import("../../../common").Awaitable<void>;
+    removeToRelationship(id: string | string[], guild: string): import("../../../common").Awaitable<void>;
+    removeRelationship(id: string | string[]): import("../../../common").Awaitable<void>;
     hashId(id: string): string;
 }

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

@@ -17,7 +17,8 @@ class GuildRelatedResource {
         this.client = client;
     }
     parse(data, id, guild_id) {
-        data.id = id;
+        if (!data.id)
+            data.id = id;
         data.guild_id = guild_id;
         return data;
     }
@@ -72,7 +73,7 @@ class GuildRelatedResource {
             : (0, common_1.fakePromise)(this.adapter.getToRelationship(this.hashId(guild))).then(keys => this.adapter.get(keys.map(x => `${this.namespace}.${x}`)));
     }
     count(to) {
-        return this.adapter.count(this.hashId(to));
+        return to === '*' ? (0, common_1.fakePromise)(this.keys(to)).then(x => x.length) : this.adapter.count(this.hashId(to));
     }
     contains(id, guild) {
         return this.adapter.contains(this.hashId(guild), id);