seyfert 1.5.0 → 2.0.0

package/lib/cache/resources/stickers.js

@@ -2,8 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Stickers = void 0;
 const common_1 = require("../../common");
-const structures_1 = require("../../structures");
 const guild_related_1 = require("./default/guild-related");
+const transformers_1 = require("../../client/transformers");
 class Stickers extends guild_related_1.GuildRelatedResource {
     namespace = 'sticker';
     //@ts-expect-error
@@ -11,13 +11,22 @@ class Stickers extends guild_related_1.GuildRelatedResource {
         return true;
     }
     get(id) {
-        return (0, common_1.fakePromise)(super.get(id)).then(rawSticker => rawSticker ? new structures_1.Sticker(this.client, rawSticker) : undefined);
+        return (0, common_1.fakePromise)(super.get(id)).then(rawSticker => rawSticker ? transformers_1.Transformers.Sticker(this.client, rawSticker) : undefined);
+    }
+    raw(id) {
+        return super.get(id);
     }
     bulk(ids) {
-        return (0, common_1.fakePromise)(super.bulk(ids)).then(emojis => emojis.map(rawSticker => new structures_1.Sticker(this.client, rawSticker)));
+        return (0, common_1.fakePromise)(super.bulk(ids)).then(emojis => emojis.map(rawSticker => transformers_1.Transformers.Sticker(this.client, rawSticker)));
+    }
+    bulkRaw(ids) {
+        return super.bulk(ids);
     }
     values(guild) {
-        return (0, common_1.fakePromise)(super.values(guild)).then(emojis => emojis.map(rawSticker => new structures_1.Sticker(this.client, rawSticker)));
+        return (0, common_1.fakePromise)(super.values(guild)).then(emojis => emojis.map(rawSticker => transformers_1.Transformers.Sticker(this.client, rawSticker)));
+    }
+    valuesRaw(guild) {
+        return super.values(guild);
     }
 }
 exports.Stickers = Stickers;

package/lib/cache/resources/threads.d.ts

@@ -1,11 +1,14 @@
-import type { APIThreadChannel } from 'discord-api-types/v10';
+import type { APIThreadChannel } from '../../types';
 import type { ReturnCache } from '../..';
-import { ThreadChannel } from '../../structures';
 import { GuildRelatedResource } from './default/guild-related';
-export declare class Threads extends GuildRelatedResource {
+import { type ThreadChannelStructure } from '../../client/transformers';
+export declare class Threads extends GuildRelatedResource<any, APIThreadChannel> {
     namespace: string;
     filter(data: APIThreadChannel, id: string, guild_id?: string): boolean;
-    get(id: string): ReturnCache<ThreadChannel | undefined>;
-    bulk(ids: string[]): ReturnCache<ThreadChannel[]>;
-    values(guild: string): ReturnCache<ThreadChannel[]>;
+    get(id: string): ReturnCache<ThreadChannelStructure | undefined>;
+    raw(id: string): ReturnCache<APIThreadChannel | undefined>;
+    bulk(ids: string[]): ReturnCache<ThreadChannelStructure[]>;
+    bulkRaw(ids: string[]): ReturnCache<APIThreadChannel[]>;
+    values(guild: string): ReturnCache<ThreadChannelStructure[]>;
+    valuesRaw(guild: string): ReturnCache<APIThreadChannel[]>;
 }

package/lib/cache/resources/threads.js

@@ -2,8 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Threads = void 0;
 const common_1 = require("../../common");
-const structures_1 = require("../../structures");
 const guild_related_1 = require("./default/guild-related");
+const transformers_1 = require("../../client/transformers");
 class Threads extends guild_related_1.GuildRelatedResource {
     namespace = 'thread';
     //@ts-expect-error
@@ -11,13 +11,22 @@ class Threads extends guild_related_1.GuildRelatedResource {
         return true;
     }
     get(id) {
-        return (0, common_1.fakePromise)(super.get(id)).then(rawThread => rawThread ? new structures_1.ThreadChannel(this.client, rawThread) : undefined);
+        return (0, common_1.fakePromise)(super.get(id)).then(rawThread => rawThread ? transformers_1.Transformers.ThreadChannel(this.client, rawThread) : undefined);
+    }
+    raw(id) {
+        return super.get(id);
     }
     bulk(ids) {
-        return (0, common_1.fakePromise)(super.bulk(ids)).then(threads => threads.map(rawThread => new structures_1.ThreadChannel(this.client, rawThread)));
+        return (0, common_1.fakePromise)(super.bulk(ids)).then(threads => threads.map(rawThread => transformers_1.Transformers.ThreadChannel(this.client, rawThread)));
+    }
+    bulkRaw(ids) {
+        return super.bulk(ids);
     }
     values(guild) {
-        return (0, common_1.fakePromise)(super.values(guild)).then(threads => threads.map(rawThread => new structures_1.ThreadChannel(this.client, rawThread)));
+        return (0, common_1.fakePromise)(super.values(guild)).then(threads => threads.map(rawThread => transformers_1.Transformers.ThreadChannel(this.client, rawThread)));
+    }
+    valuesRaw(guild) {
+        return super.values(guild);
     }
 }
 exports.Threads = Threads;

package/lib/cache/resources/users.d.ts

@@ -1,11 +1,14 @@
-import type { APIUser } from 'discord-api-types/v10';
+import type { APIUser } from '../../types';
 import type { ReturnCache } from '../..';
-import { User } from '../../structures';
 import { BaseResource } from './default/base';
-export declare class Users extends BaseResource {
+import { type UserStructure } from '../../client/transformers';
+export declare class Users extends BaseResource<any, APIUser> {
     namespace: string;
     filter(data: APIUser, id: string): boolean;
-    get(id: string): ReturnCache<User | undefined>;
-    bulk(ids: string[]): ReturnCache<User[]>;
-    values(): ReturnCache<User[]>;
+    get(id: string): ReturnCache<UserStructure | undefined>;
+    raw(id: string): ReturnCache<APIUser | undefined>;
+    bulk(ids: string[]): ReturnCache<UserStructure[]>;
+    bulkRaw(ids: string[]): ReturnCache<APIUser[]>;
+    values(): ReturnCache<UserStructure[]>;
+    valuesRaw(): ReturnCache<APIUser[]>;
 }

package/lib/cache/resources/users.js

@@ -2,8 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Users = void 0;
 const common_1 = require("../../common");
-const structures_1 = require("../../structures");
 const base_1 = require("./default/base");
+const transformers_1 = require("../../client/transformers");
 class Users extends base_1.BaseResource {
     namespace = 'user';
     //@ts-expect-error
@@ -11,13 +11,22 @@ class Users extends base_1.BaseResource {
         return true;
     }
     get(id) {
-        return (0, common_1.fakePromise)(super.get(id)).then(rawUser => (rawUser ? new structures_1.User(this.client, rawUser) : undefined));
+        return (0, common_1.fakePromise)(super.get(id)).then(rawUser => (rawUser ? transformers_1.Transformers.User(this.client, rawUser) : undefined));
+    }
+    raw(id) {
+        return super.get(id);
     }
     bulk(ids) {
-        return (0, common_1.fakePromise)(super.bulk(ids)).then(users => users.map(rawUser => new structures_1.User(this.client, rawUser)));
+        return (0, common_1.fakePromise)(super.bulk(ids)).then(users => users.map(rawUser => transformers_1.Transformers.User(this.client, rawUser)));
+    }
+    bulkRaw(ids) {
+        return super.bulk(ids);
     }
     values() {
-        return (0, common_1.fakePromise)(super.values()).then(users => users.map(rawUser => new structures_1.User(this.client, rawUser)));
+        return (0, common_1.fakePromise)(super.values()).then(users => users.map(rawUser => transformers_1.Transformers.User(this.client, rawUser)));
+    }
+    valuesRaw() {
+        return super.values();
     }
 }
 exports.Users = Users;

package/lib/cache/resources/voice-states.d.ts

@@ -1,15 +1,18 @@
-import type { GatewayVoiceState } from 'discord-api-types/v10';
+import type { APIVoiceState } from '../../types';
 import type { ReturnCache } from '../..';
-import { VoiceState } from '../../structures';
 import { GuildBasedResource } from './default/guild-based';
-export declare class VoiceStates extends GuildBasedResource {
+import { type VoiceStateStructure } from '../../client/transformers';
+export declare class VoiceStates extends GuildBasedResource<any, APIVoiceState> {
     namespace: string;
-    filter(data: GatewayVoiceState, id: string, guild_id: string): boolean;
+    filter(data: APIVoiceState, id: string, guild_id: string): boolean;
     parse(data: any, id: string, guild_id: string): any;
-    get(memberId: string, guildId: string): ReturnCache<VoiceState | undefined>;
-    bulk(ids: string[], guild: string): ReturnCache<VoiceState[]>;
-    values(guildId: string): ReturnCache<VoiceState[]>;
+    get(memberId: string, guildId: string): ReturnCache<VoiceStateStructure | undefined>;
+    raw(memberId: string, guildId: string): ReturnCache<APIVoiceState | undefined>;
+    bulk(ids: string[], guild: string): ReturnCache<VoiceStateStructure[]>;
+    bulkRaw(ids: string[], guild: string): ReturnCache<APIVoiceState[]>;
+    values(guildId: string): ReturnCache<VoiceStateStructure[]>;
+    valuesRaw(guildId: string): ReturnCache<APIVoiceState[]>;
 }
-export type VoiceStateResource = Omit<GatewayVoiceState, 'member'> & {
+export type VoiceStateResource = Omit<APIVoiceState, 'member'> & {
     guild_id: string;
 };

package/lib/cache/resources/voice-states.js

@@ -2,8 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.VoiceStates = void 0;
 const common_1 = require("../../common");
-const structures_1 = require("../../structures");
 const guild_based_1 = require("./default/guild-based");
+const transformers_1 = require("../../client/transformers");
 class VoiceStates extends guild_based_1.GuildBasedResource {
     namespace = 'voice_state';
     //@ts-expect-error
@@ -15,13 +15,24 @@ class VoiceStates extends guild_based_1.GuildBasedResource {
         return rest;
     }
     get(memberId, guildId) {
-        return (0, common_1.fakePromise)(super.get(memberId, guildId)).then(state => state ? new structures_1.VoiceState(this.client, state) : undefined);
+        return (0, common_1.fakePromise)(super.get(memberId, guildId)).then(state => state ? transformers_1.Transformers.VoiceState(this.client, state) : undefined);
+    }
+    raw(memberId, guildId) {
+        return super.get(memberId, guildId);
     }
     bulk(ids, guild) {
-        return (0, common_1.fakePromise)(super.bulk(ids, guild)).then(states => states.map(state => (state ? new structures_1.VoiceState(this.client, state) : undefined)).filter(y => !!y));
+        return (0, common_1.fakePromise)(super.bulk(ids, guild)).then(states => states
+            .map(state => (state ? transformers_1.Transformers.VoiceState(this.client, state) : undefined))
+            .filter(y => !!y));
+    }
+    bulkRaw(ids, guild) {
+        return super.bulk(ids, guild);
     }
     values(guildId) {
-        return (0, common_1.fakePromise)(super.values(guildId)).then(states => states.map(state => new structures_1.VoiceState(this.client, state)));
+        return (0, common_1.fakePromise)(super.values(guildId)).then(states => states.map(state => transformers_1.Transformers.VoiceState(this.client, state)));
+    }
+    valuesRaw(guildId) {
+        return super.values(guildId);
     }
 }
 exports.VoiceStates = VoiceStates;

package/lib/client/base.d.ts

@@ -1,20 +1,23 @@
 import { ApiHandler } from '../api';
 import type { Adapter } from '../cache';
 import { Cache } from '../cache';
-import type { Command, ExtraProps, RegisteredMiddlewares } from '../commands';
+import type { Command, CommandContext, ContextMenuCommand, ExtraProps, MenuCommandContext, RegisteredMiddlewares, SubCommand, UsingClient } from '../commands';
 import { type InferWithPrefix, type MiddlewareContext } from '../commands/applications/shared';
 import { CommandHandler } from '../commands/handler';
-import { ChannelShorter, EmojiShorter, GuildShorter, InteractionShorter, Logger, MemberShorter, MessageShorter, ReactionShorter, RoleShorter, TemplateShorter, ThreadShorter, UsersShorter, WebhookShorter, type MakeRequired } from '../common';
-import type { LocaleString, RESTPostAPIChannelMessageJSONBody } from 'discord-api-types/rest/v10';
-import type { Awaitable, DeepPartial, IntentStrings, OmitInsert, When } from '../common/types/util';
+import { ApplicationShorter, ChannelShorter, EmojiShorter, GuildShorter, InteractionShorter, Logger, MemberShorter, MessageShorter, ReactionShorter, RoleShorter, TemplateShorter, ThreadShorter, UsersShorter, WebhookShorter, type MakeRequired } from '../common';
+import type { LocaleString, RESTPostAPIChannelMessageJSONBody } from '../types';
+import type { Awaitable, DeepPartial, IntentStrings, OmitInsert, PermissionStrings, When } from '../common/types/util';
 import { ComponentHandler } from '../components/handler';
 import { LangsHandler } from '../langs/handler';
-import type { ChatInputCommandInteraction, ComponentInteraction, Message, MessageCommandInteraction, ModalSubmitInteraction, UserCommandInteraction } from '../structures';
+import type { ChatInputCommandInteraction, ComponentInteraction, MessageCommandInteraction, ModalSubmitInteraction, UserCommandInteraction } from '../structures';
 import type { ComponentCommand, ModalCommand } from '../components';
 import { BanShorter } from '../common/shorters/bans';
+import { HandleCommand } from '../commands/handle';
+import type { MessageStructure } from './transformers';
 export declare class BaseClient {
     rest: ApiHandler;
     cache: Cache;
+    applications: ApplicationShorter;
     users: UsersShorter;
     channels: ChannelShorter;
     guilds: GuildShorter;
@@ -33,6 +36,7 @@ export declare class BaseClient {
     langs?: LangsHandler | undefined;
     commands?: CommandHandler | undefined;
     components?: ComponentHandler | undefined;
+    handleCommand: HandleCommand;
     private _applicationId?;
     private _botId?;
     middlewares?: Record<string, MiddlewareContext>;
@@ -45,21 +49,25 @@ export declare class BaseClient {
     set applicationId(id: string);
     get applicationId(): string;
     get proxy(): import("../api").APIRoutes;
-    setServices({ rest, cache, langs, middlewares, handlers, }: ServicesOptions): void;
+    setServices({ rest, cache, langs, middlewares, handlers, handleCommand }: ServicesOptions): void;
     protected execute(..._options: unknown[]): Promise<void>;
     start(options?: Pick<DeepPartial<StartOptions>, 'langsDir' | 'commandsDir' | 'connection' | 'token' | 'componentsDir'>): Promise<void>;
-    protected onPacket(..._packet: unknown[]): Promise<void>;
-    shouldUploadCommands(cachePath: string): Promise<boolean>;
-    uploadCommands(applicationId?: string): Promise<void>;
+    protected onPacket(..._packet: unknown[]): Promise<any>;
+    private shouldUploadCommands;
+    private syncCachePath;
+    uploadCommands({ applicationId, cachePath }?: {
+        applicationId?: string;
+        cachePath?: string;
+    }): Promise<void>;
     loadCommands(dir?: string): Promise<void>;
     loadComponents(dir?: string): Promise<void>;
     loadLangs(dir?: string): Promise<void>;
     t(locale: string): import("..").__InternalParseLocale<import("../commands").DefaultLocale> & {
-        get(locale?: string | undefined): import("../commands").DefaultLocale;
+        get(locale?: string): import("../commands").DefaultLocale;
     };
     getRC<T extends InternalRuntimeConfigHTTP | InternalRuntimeConfig = InternalRuntimeConfigHTTP | InternalRuntimeConfig>(): Promise<{
         debug: boolean;
-    } & Omit<T, "locations" | "debug"> & {
+    } & Omit<T, "debug" | "locations"> & {
         templates: string | undefined;
         langs: string | undefined;
         events: string | undefined;
@@ -70,17 +78,17 @@ export declare class BaseClient {
     }>;
 }
 export interface BaseClientOptions {
-    context?: (interaction: ChatInputCommandInteraction<boolean> | UserCommandInteraction<boolean> | MessageCommandInteraction<boolean> | ComponentInteraction | ModalSubmitInteraction | When<InferWithPrefix, Message, never>) => {};
+    context?: (interaction: ChatInputCommandInteraction<boolean> | UserCommandInteraction<boolean> | MessageCommandInteraction<boolean> | ComponentInteraction | ModalSubmitInteraction | When<InferWithPrefix, MessageStructure, never>) => {};
     globalMiddlewares?: readonly (keyof RegisteredMiddlewares)[];
     commands?: {
         defaults?: {
-            onRunError?: Command['onRunError'];
+            onRunError?: (context: MenuCommandContext<any, never> | CommandContext, error: unknown) => unknown;
             onPermissionsFail?: Command['onPermissionsFail'];
-            onBotPermissionsFail?: Command['onBotPermissionsFail'];
-            onInternalError?: Command['onInternalError'];
-            onMiddlewaresError?: Command['onMiddlewaresError'];
+            onBotPermissionsFail?: (context: MenuCommandContext<any, never> | CommandContext, permissions: PermissionStrings) => unknown;
+            onInternalError?: (client: UsingClient, command: Command | SubCommand | ContextMenuCommand, error?: unknown) => unknown;
+            onMiddlewaresError?: (context: CommandContext | MenuCommandContext<any, never>, error: string) => unknown;
             onOptionsError?: Command['onOptionsError'];
-            onAfterRun?: Command['onAfterRun'];
+            onAfterRun?: (context: CommandContext | MenuCommandContext<any, never>, error: unknown) => unknown;
             props?: ExtraProps;
         };
     };
@@ -116,7 +124,6 @@ export interface StartOptions {
     httpConnection: {
         publicKey: string;
         port: number;
-        useUWS: boolean;
     };
     token: string;
 }
@@ -162,8 +169,9 @@ export interface ServicesOptions {
     middlewares?: Record<string, MiddlewareContext>;
     handlers?: {
         components?: ComponentHandler | ComponentHandler['callback'];
-        commands?: CommandHandler | Parameters<CommandHandler['setHandlers']>[0];
-        langs?: LangsHandler | LangsHandler['callback'];
+        commands?: CommandHandler;
+        langs?: LangsHandler;
     };
+    handleCommand?: typeof HandleCommand;
 }
 export {};

package/lib/client/base.js

@@ -11,9 +11,11 @@ const handler_2 = require("../components/handler");
 const handler_3 = require("../langs/handler");
 const node_fs_1 = require("node:fs");
 const bans_1 = require("../common/shorters/bans");
+const handle_1 = require("../commands/handle");
 class BaseClient {
     rest;
     cache;
+    applications = new common_1.ApplicationShorter(this);
     users = new common_1.UsersShorter(this);
     channels = new common_1.ChannelShorter(this);
     guilds = new common_1.GuildShorter(this);
@@ -34,6 +36,7 @@ class BaseClient {
     langs = new handler_3.LangsHandler(this.logger);
     commands = new handler_1.CommandHandler(this.logger, this);
     components = new handler_2.ComponentHandler(this.logger, this);
+    handleCommand;
     _applicationId;
     _botId;
     middlewares;
@@ -47,7 +50,7 @@ class BaseClient {
     }
     options;
     /**@internal */
-    static _seyfertConfig;
+    static _seyfertCfWorkerConfig;
     constructor(options) {
         this.options = (0, common_1.MergeOptions)({
             commands: {
@@ -104,7 +107,7 @@ class BaseClient {
         this._botId = id;
     }
     get botId() {
-        return (this._botId ?? BaseClient.getBotIdFromToken(this.rest.options.token));
+        return this._botId ?? BaseClient.getBotIdFromToken(this.rest.options.token);
     }
     set applicationId(id) {
         this._applicationId = id;
@@ -115,7 +118,7 @@ class BaseClient {
     get proxy() {
         return new api_1.Router(this.rest).createProxy();
     }
-    setServices({ rest, cache, langs, middlewares, handlers, }) {
+    setServices({ rest, cache, langs, middlewares, handlers, handleCommand }) {
         if (rest) {
             this.rest = rest;
         }
@@ -132,9 +135,6 @@ class BaseClient {
                 }
                 else if (typeof handlers.components === 'function') {
                     this.components ??= new handler_2.ComponentHandler(this.logger, this);
-                    this.components.setHandlers({
-                        callback: handlers.components,
-                    });
                 }
                 else {
                     this.components = handlers.components;
@@ -146,7 +146,6 @@ class BaseClient {
                 }
                 else if (typeof handlers.commands === 'object') {
                     this.commands ??= new handler_1.CommandHandler(this.logger, this);
-                    this.commands.setHandlers(handlers.commands);
                 }
                 else {
                     this.commands = handlers.commands;
@@ -158,7 +157,6 @@ class BaseClient {
                 }
                 else if (typeof handlers.langs === 'function') {
                     this.langs ??= new handler_3.LangsHandler(this.logger);
-                    this.langs.setHandlers({ callback: handlers.langs });
                 }
                 else {
                     this.langs = handlers.langs;
@@ -171,6 +169,8 @@ class BaseClient {
             if (langs.aliases)
                 this.langs.aliases = Object.entries(langs.aliases);
         }
+        if (handleCommand)
+            this.handleCommand = new handleCommand(this);
     }
     async execute(..._options) {
         if ((await this.getRC()).debug) {
@@ -190,7 +190,7 @@ class BaseClient {
         await this.loadLangs(options.langsDir);
         await this.loadCommands(options.commandsDir);
         await this.loadComponents(options.componentsDir);
-        const { token: tokenRC } = await this.getRC();
+        const { token: tokenRC, debug } = await this.getRC();
         const token = options?.token ?? tokenRC;
         if (!this.rest) {
             BaseClient.assertString(token, 'token is not a string');
@@ -198,71 +198,84 @@ class BaseClient {
                 token,
                 baseUrl: 'api/v10',
                 domain: 'https://discord.com',
-                debug: (await this.getRC()).debug,
+                debug,
             });
         }
         if (this.cache) {
             this.cache.__setClient(this);
         }
         else {
-            this.cache = new cache_1.Cache(0, new cache_1.MemoryAdapter(), [], this);
+            this.cache = new cache_1.Cache(0, new cache_1.MemoryAdapter(), {}, this);
         }
+        if (!this.handleCommand)
+            this.handleCommand = new handle_1.HandleCommand(this);
+        // The reason of this method is so for adapters that need to connect somewhere, have time to connect.
+        // Or maybe clear cache?
+        await this.cache.adapter.start();
     }
     async onPacket(..._packet) {
         throw new Error('Function not implemented');
     }
-    shouldUploadCommands(cachePath) {
-        return this.commands.shouldUpload(cachePath).then(async (should) => {
-            if (should)
-                await node_fs_1.promises.writeFile(cachePath, JSON.stringify(this.commands.values.map((x) => x.toJSON())));
+    shouldUploadCommands(cachePath, guildId) {
+        return this.commands.shouldUpload(cachePath, guildId).then(should => {
+            this.logger.debug(should
+                ? `[${guildId ?? 'global'}] Change(s) detected, uploading commands`
+                : `[${guildId ?? 'global'}] commands seems to be up to date`);
             return should;
         });
     }
-    async uploadCommands(applicationId) {
-        applicationId ??= await this.getRC().then((x) => x.applicationId ?? this.applicationId);
+    syncCachePath(cachePath) {
+        this.logger.debug('Syncing commands cache');
+        return node_fs_1.promises.writeFile(cachePath, JSON.stringify(this.commands.values.filter(cmd => !('ignore' in cmd) || cmd.ignore !== shared_1.IgnoreCommand.Slash).map(x => x.toJSON())));
+    }
+    async uploadCommands({ applicationId, cachePath } = {}) {
+        applicationId ??= await this.getRC().then(x => x.applicationId ?? this.applicationId);
         BaseClient.assertString(applicationId, 'applicationId is not a string');
         const commands = this.commands.values;
-        const filter = (0, common_1.filterSplit)(commands, (command) => !command.guildId);
-        await this.proxy.applications(applicationId).commands.put({
-            body: filter.expect
-                .filter((cmd) => !('ignore' in cmd) || cmd.ignore !== shared_1.IgnoreCommand.Slash)
-                .map((x) => x.toJSON()),
-        });
+        const filter = (0, common_1.filterSplit)(commands, command => !command.guildId);
+        if (!cachePath || (await this.shouldUploadCommands(cachePath)))
+            await this.proxy.applications(applicationId).commands.put({
+                body: filter.expect
+                    .filter(cmd => !('ignore' in cmd) || cmd.ignore !== shared_1.IgnoreCommand.Slash)
+                    .map(x => x.toJSON()),
+            });
         const guilds = new Set();
         for (const command of filter.never) {
             for (const guild_id of command.guildId) {
                 guilds.add(guild_id);
             }
         }
-        for (const guild of guilds) {
-            await this.proxy
-                .applications(applicationId)
-                .guilds(guild)
-                .commands.put({
-                body: filter.never
-                    .filter((cmd) => cmd.guildId?.includes(guild) &&
-                    (!('ignore' in cmd) ||
-                        cmd.ignore !== shared_1.IgnoreCommand.Slash))
-                    .map((x) => x.toJSON()),
-            });
+        for (const guildId of guilds) {
+            if (!cachePath || (await this.shouldUploadCommands(cachePath, guildId))) {
+                await this.proxy
+                    .applications(applicationId)
+                    .guilds(guildId)
+                    .commands.put({
+                    body: filter.never
+                        .filter(cmd => cmd.guildId?.includes(guildId) && (!('ignore' in cmd) || cmd.ignore !== shared_1.IgnoreCommand.Slash))
+                        .map(x => x.toJSON()),
+                });
+            }
         }
+        if (cachePath)
+            await this.syncCachePath(cachePath);
     }
     async loadCommands(dir) {
-        dir ??= await this.getRC().then((x) => x.commands);
+        dir ??= await this.getRC().then(x => x.commands);
         if (dir && this.commands) {
             await this.commands.load(dir, this);
             this.logger.info('CommandHandler loaded');
         }
     }
     async loadComponents(dir) {
-        dir ??= await this.getRC().then((x) => x.components);
+        dir ??= await this.getRC().then(x => x.components);
         if (dir && this.components) {
             await this.components.load(dir);
             this.logger.info('ComponentHandler loaded');
         }
     }
     async loadLangs(dir) {
-        dir ??= await this.getRC().then((x) => x.langs);
+        dir ??= await this.getRC().then(x => x.langs);
         if (dir && this.langs) {
             await this.langs.load(dir);
             this.logger.info('LangsHandler loaded');
@@ -272,32 +285,21 @@ class BaseClient {
         return this.langs.get(locale);
     }
     async getRC() {
-        const seyfertConfig = (BaseClient._seyfertConfig ||
-            (await this.options.getRC?.()) ||
-            (await (0, common_1.magicImport)((0, node_path_1.join)(process.cwd(), 'seyfert.config.js')).then((x) => x.default ?? x)));
+        const seyfertConfig = (BaseClient._seyfertCfWorkerConfig ||
+            (await this.options?.getRC?.()) ||
+            (await Promise.any(['.js', '.mjs', '.cjs', '.ts', '.mts', '.cts'].map(ext => (0, common_1.magicImport)((0, node_path_1.join)(process.cwd(), `seyfert.config${ext}`)).then(x => x.default ?? x)))));
         const { locations, debug, ...env } = seyfertConfig;
         const obj = {
             debug: !!debug,
             ...env,
-            templates: locations.templates
-                ? (0, node_path_1.join)(process.cwd(), locations.base, locations.templates)
-                : undefined,
-            langs: locations.langs
-                ? (0, node_path_1.join)(process.cwd(), locations.output, locations.langs)
-                : undefined,
-            events: 'events' in locations && locations.events
-                ? (0, node_path_1.join)(process.cwd(), locations.output, locations.events)
-                : undefined,
-            components: locations.components
-                ? (0, node_path_1.join)(process.cwd(), locations.output, locations.components)
-                : undefined,
-            commands: locations.commands
-                ? (0, node_path_1.join)(process.cwd(), locations.output, locations.commands)
-                : undefined,
+            templates: locations.templates ? (0, node_path_1.join)(process.cwd(), locations.base, locations.templates) : undefined,
+            langs: locations.langs ? (0, node_path_1.join)(process.cwd(), locations.output, locations.langs) : undefined,
+            events: 'events' in locations && locations.events ? (0, node_path_1.join)(process.cwd(), locations.output, locations.events) : undefined,
+            components: locations.components ? (0, node_path_1.join)(process.cwd(), locations.output, locations.components) : undefined,
+            commands: locations.commands ? (0, node_path_1.join)(process.cwd(), locations.output, locations.commands) : undefined,
             base: (0, node_path_1.join)(process.cwd(), locations.base),
             output: (0, node_path_1.join)(process.cwd(), locations.output),
         };
-        BaseClient._seyfertConfig = seyfertConfig;
         return obj;
     }
 }

package/lib/client/client.d.ts

@@ -1,20 +1,20 @@
-import { type APIApplicationCommandInteractionDataOption, type GatewayMessageCreateDispatchData, type GatewayDispatchPayload, type GatewayPresenceUpdateData } from 'discord-api-types/v10';
-import type { Command, CommandContext, ContextOptionsResolved, Message, MessageCommandOptionErrors, SubCommand, UsingClient } from '..';
-import { type Awaitable, type MakeRequired, type DeepPartial, type If } from '../common';
+import { type GatewayDispatchPayload, type GatewayPresenceUpdateData } from '../types';
+import type { CommandContext, Message } from '..';
+import { type Awaitable, type DeepPartial, type If } from '../common';
 import { EventHandler } from '../events';
-import { ClientUser } from '../structures';
 import { ShardManager, type ShardManagerOptions } from '../websocket';
 import { MemberUpdateHandler } from '../websocket/discord/events/memberUpdate';
 import { PresenceUpdateHandler } from '../websocket/discord/events/presenceUpdate';
 import type { BaseClientOptions, ServicesOptions, StartOptions } from './base';
 import { BaseClient } from './base';
 import { Collectors } from './collectors';
+import { type ClientUserStructure, type MessageStructure } from './transformers';
 export declare class Client<Ready extends boolean = boolean> extends BaseClient {
     private __handleGuilds?;
     gateway: ShardManager;
-    me: If<Ready, ClientUser>;
+    me: If<Ready, ClientUserStructure>;
     options: Omit<ClientOptions, 'commands'> & {
-        commands: MakeRequired<NonNullable<ClientOptions['commands']>, 'argsParser' | 'optionsParser'>;
+        commands: NonNullable<ClientOptions['commands']>;
     };
     memberUpdateHandler: MemberUpdateHandler;
     presenceUpdateHandler: PresenceUpdateHandler;
@@ -47,18 +47,9 @@ export interface ClientOptions extends BaseClientOptions {
         compress?: ShardManagerOptions['compress'];
     };
     commands?: BaseClientOptions['commands'] & {
-        prefix?: (message: Message) => Promise<string[]> | string[];
+        prefix?: (message: MessageStructure) => Awaitable<string[]>;
         deferReplyResponse?: (ctx: CommandContext) => Parameters<Message['write']>[0];
         reply?: (ctx: CommandContext) => boolean;
-        argsParser?: (content: string, command: SubCommand | Command, message: Message) => Record<string, string>;
-        optionsParser?: (self: UsingClient, command: Command | SubCommand, message: GatewayMessageCreateDispatchData, args: Partial<Record<string, string>>, resolved: MakeRequired<ContextOptionsResolved>) => Awaitable<{
-            errors: {
-                name: string;
-                error: string;
-                fullError: MessageCommandOptionErrors;
-            }[];
-            options: APIApplicationCommandInteractionDataOption[];
-        }>;
     };
     handlePayload?: ShardManagerOptions['handlePayload'];
 }