seyfert 1.4.0 → 2.0.0

package/lib/cache/resources/roles.js

@@ -2,8 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Roles = 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 Roles extends guild_related_1.GuildRelatedResource {
     namespace = 'role';
     //@ts-expect-error
@@ -11,13 +11,22 @@ class Roles extends guild_related_1.GuildRelatedResource {
         return true;
     }
     get(id) {
-        return (0, common_1.fakePromise)(super.get(id)).then(rawRole => rawRole ? new structures_1.GuildRole(this.client, rawRole, rawRole.guild_id) : undefined);
+        return (0, common_1.fakePromise)(super.get(id)).then(rawRole => rawRole ? transformers_1.Transformers.GuildRole(this.client, rawRole, rawRole.guild_id) : undefined);
+    }
+    raw(id) {
+        return super.get(id);
     }
     bulk(ids) {
-        return (0, common_1.fakePromise)(super.bulk(ids)).then(roles => roles.map(rawRole => new structures_1.GuildRole(this.client, rawRole, rawRole.guild_id)));
+        return (0, common_1.fakePromise)(super.bulk(ids)).then(roles => roles.map(rawRole => transformers_1.Transformers.GuildRole(this.client, rawRole, rawRole.guild_id)));
+    }
+    bulkRaw(ids) {
+        return super.bulk(ids);
     }
     values(guild) {
-        return (0, common_1.fakePromise)(super.values(guild)).then(roles => roles.map(rawRole => new structures_1.GuildRole(this.client, rawRole, rawRole.guild_id)));
+        return (0, common_1.fakePromise)(super.values(guild)).then(roles => roles.map(rawRole => transformers_1.Transformers.GuildRole(this.client, rawRole, rawRole.guild_id)));
+    }
+    valuesRaw(guild) {
+        return super.values(guild);
     }
 }
 exports.Roles = Roles;

package/lib/cache/resources/stage-instances.d.ts

@@ -1,6 +1,6 @@
-import type { APIStageInstance } from 'discord-api-types/v10';
+import type { APIStageInstance } from '../../types';
 import { GuildRelatedResource } from './default/guild-related';
-export declare class StageInstances extends GuildRelatedResource<APIStageInstance> {
+export declare class StageInstances extends GuildRelatedResource<APIStageInstance, APIStageInstance> {
     namespace: string;
     filter(data: APIStageInstance, id: string, guild_id?: string): boolean;
 }

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

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

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,19 +1,23 @@
 import { ApiHandler } from '../api';
 import type { Adapter } from '../cache';
 import { Cache } from '../cache';
-import type { Command, 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 { 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;
@@ -25,12 +29,14 @@ export declare class BaseClient {
     reactions: ReactionShorter;
     emojis: EmojiShorter;
     threads: ThreadShorter;
+    bans: BanShorter;
     interactions: InteractionShorter;
     debugger?: Logger;
     logger: Logger;
     langs?: LangsHandler | undefined;
     commands?: CommandHandler | undefined;
     components?: ComponentHandler | undefined;
+    handleCommand: HandleCommand;
     private _applicationId?;
     private _botId?;
     middlewares?: Record<string, MiddlewareContext>;
@@ -43,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;
@@ -68,17 +78,18 @@ 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;
         };
     };
     components?: {
@@ -100,6 +111,7 @@ export interface BaseClientOptions {
     allowedMentions?: Omit<NonNullable<RESTPostAPIChannelMessageJSONBody['allowed_mentions']>, 'parse'> & {
         parse?: ('everyone' | 'roles' | 'users')[];
     };
+    getRC?(): Awaitable<InternalRuntimeConfig | InternalRuntimeConfigHTTP>;
 }
 export interface StartOptions {
     eventsDir: string;
@@ -112,7 +124,6 @@ export interface StartOptions {
     httpConnection: {
         publicKey: string;
         port: number;
-        useUWS: boolean;
     };
     token: string;
 }
@@ -158,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

@@ -10,9 +10,12 @@ const common_1 = require("../common");
 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);
@@ -24,6 +27,7 @@ class BaseClient {
     reactions = new common_1.ReactionShorter(this);
     emojis = new common_1.EmojiShorter(this);
     threads = new common_1.ThreadShorter(this);
+    bans = new bans_1.BanShorter(this);
     interactions = new common_1.InteractionShorter(this);
     debugger;
     logger = new common_1.Logger({
@@ -32,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;
@@ -45,7 +50,7 @@ class BaseClient {
     }
     options;
     /**@internal */
-    static _seyferHttpConfig;
+    static _seyfertCfWorkerConfig;
     constructor(options) {
         this.options = (0, common_1.MergeOptions)({
             commands: {
@@ -113,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;
         }
@@ -130,7 +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;
@@ -142,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;
@@ -154,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;
@@ -167,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) {
@@ -186,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');
@@ -194,50 +198,67 @@ class BaseClient {
                 token,
                 baseUrl: 'api/v10',
                 domain: 'https://discord.com',
-                debug: (await this.getRC()).debug,
+                debug,
             });
         }
-        if (!this.cache) {
-            this.cache = new cache_1.Cache(0, new cache_1.MemoryAdapter(), [], this);
+        if (this.cache) {
+            this.cache.__setClient(this);
         }
         else {
-            this.cache.__setClient(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) {
+    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()),
-        });
+        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);
@@ -264,8 +285,9 @@ class BaseClient {
         return this.langs.get(locale);
     }
     async getRC() {
-        const seyfertConfig = (BaseClient._seyferHttpConfig ||
-            (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,
@@ -278,7 +300,6 @@ class BaseClient {
             base: (0, node_path_1.join)(process.cwd(), locations.base),
             output: (0, node_path_1.join)(process.cwd(), locations.output),
         };
-        BaseClient._seyferHttpConfig = seyfertConfig;
         return obj;
     }
 }