seyfert 0.1.0

package/lib/client/base.d.ts

@@ -0,0 +1,244 @@
+import { REST } from '../api';
+import type { Adapter } from '../cache';
+import { Cache } from '../cache';
+import type { RegisteredMiddlewares } from '../commands';
+import type { DefaultLocale, MiddlewareContext } from '../commands/applications/shared';
+import { CommandHandler } from '../commands/handler';
+import { Logger, type MakeRequired } from '../common';
+import type { DeepPartial, IntentStrings, OmitInsert } from '../common/types/util';
+import { ComponentHandler } from '../components/handler';
+import { LangsHandler } from '../langs/handler';
+import type { ChatInputCommandInteraction, MessageCommandInteraction, UserCommandInteraction } from '../structures';
+export declare class BaseClient {
+    rest: REST;
+    cache: Cache;
+    users: {
+        createDM: (userId: string, force?: boolean) => Promise<import("../structures").DMChannel>;
+        deleteDM: (userId: string, reason?: string | undefined) => Promise<import("../structures").DMChannel>;
+        fetch: (userId: string, force?: boolean) => Promise<import("../structures").User>;
+        write: (userId: string, body: Omit<import("discord-api-types/rest/v10/channel").RESTPostAPIChannelMessageJSONBody, "embeds" | "components"> & import("../common").ResolverProps) => Promise<import("../structures").Message>;
+    };
+    channels: {
+        fetch: (id: string, force?: boolean | undefined) => Promise<import("../structures").AllChannels>;
+        delete: (id: string, optional?: Partial<{
+            guildId: string;
+            reason: string;
+        }>) => Promise<import("../structures").AllChannels>;
+        edit: (id: string, body: import("discord-api-types/rest/v10/channel").RESTPatchAPIChannelJSONBody, optional?: Partial<{
+            guildId: string;
+            reason: string;
+        }>) => Promise<import("../structures").AllChannels>;
+        typing: (id: string) => Promise<never>;
+        pins: {
+            fetch: (channelId: string) => Promise<import("../structures").Message[]>;
+            set: (messageId: string, channelId: string, reason?: string | undefined) => Promise<never>;
+            delete: (messageId: string, channelId: string, reason?: string | undefined) => Promise<never>;
+        };
+    };
+    guilds: {
+        create: (body: import("discord-api-types/rest/v10/guild").RESTPostAPIGuildsJSONBody) => Promise<import("../structures").Guild<"api">>;
+        fetch: (id: string, force?: boolean) => Promise<import("../structures").Guild<"cached"> | import("../structures").Guild<"api">>;
+        widgetURL: (id: string, style?: import("discord-api-types/payloads/v10/guild").GuildWidgetStyle | undefined) => Promise<import("discord-api-types/payloads/v10/guild").APIGuildWidgetSettings>;
+        channels: {
+            list: (guildId: string, force?: boolean) => Promise<import("../structures").AllChannels[]>;
+            fetch: (guildId: string, channelId: string, force?: boolean | undefined) => Promise<import("../structures").AllChannels>;
+            create: (guildId: string, body: import("discord-api-types/rest/v10/guild").RESTPostAPIGuildChannelJSONBody) => Promise<import("../structures").AllChannels>;
+            delete: (guildId: string, channelId: string, reason?: string | undefined) => Promise<import("../structures").AllChannels>;
+            edit: (guildchannelId: string, channelId: string, body: import("discord-api-types/rest/v10/channel").RESTPatchAPIChannelJSONBody, reason?: string | undefined) => Promise<import("../structures").AllChannels>;
+            editPositions: (guildId: string, body: import("discord-api-types/rest/v10/guild").RESTPatchAPIGuildChannelPositionsJSONBody) => Promise<never>;
+        };
+        moderation: {
+            list: (guildId: string) => Promise<import("discord-api-types/rest/v10/autoModeration").RESTGetAPIAutoModerationRulesResult>;
+            create: (guildId: string, body: import("discord-api-types/rest/v10/autoModeration").RESTPostAPIAutoModerationRuleJSONBody) => Promise<import("discord-api-types/payloads/v10/autoModeration").APIAutoModerationRule>;
+            delete: (guildId: string, ruleId: string, reason?: string | undefined) => Promise<never>;
+            fetch: (guildId: string, ruleId: string) => Promise<import("discord-api-types/payloads/v10/autoModeration").APIAutoModerationRule>;
+            edit: (guildId: string, ruleId: string, body: {
+                name?: string | undefined;
+                eventType?: import("discord-api-types/payloads/v10/autoModeration").AutoModerationRuleEventType | undefined;
+                triggerMetadata?: import("discord-api-types/payloads/v10/autoModeration").APIAutoModerationRuleTriggerMetadata | undefined;
+                actions?: import("discord-api-types/payloads/v10/autoModeration").APIAutoModerationAction[] | undefined;
+                enabled?: boolean | undefined;
+                exemptRoles?: string[] | undefined;
+                exemptChannels?: string[] | undefined;
+            }, reason?: string | undefined) => Promise<import("discord-api-types/payloads/v10/autoModeration").APIAutoModerationRule>;
+        };
+        stickers: {
+            list: (guildId: string) => Promise<import("../structures").Sticker[]>;
+            create: (guildId: string, { file, ...json }: import("../structures").CreateStickerBodyRequest, reason?: string | undefined) => Promise<import("../structures").Sticker>;
+            edit: (guildId: string, stickerId: string, body: import("discord-api-types/rest/v10/sticker").RESTPatchAPIGuildStickerJSONBody, reason?: string | undefined) => Promise<import("../structures").Sticker>;
+            fetch: (guildId: string, stickerId: string, force?: boolean) => Promise<import("../structures").Sticker>;
+            delete: (guildId: string, stickerId: string, reason?: string | undefined) => Promise<void>;
+        };
+        emojis: {
+            list: (guildId: string, force?: boolean) => Promise<import("../structures").GuildEmoji[]>;
+            create: (guildId: string, body: Omit<import("discord-api-types/rest/v10/emoji").RESTPostAPIGuildEmojiJSONBody, "image"> & {
+                image: import("../common").ImageResolvable;
+            }) => Promise<void>;
+            fetch: (guildId: string, emojiId: string, force?: boolean) => Promise<import("../structures").GuildEmoji>;
+            delete: (guildId: string, emojiId: string, reason?: string | undefined) => Promise<void>;
+            edit: (guildId: string, emojiId: string, body: import("discord-api-types/rest/v10/emoji").RESTPatchAPIGuildEmojiJSONBody, reason?: string | undefined) => Promise<import("../structures").GuildEmoji>;
+        };
+    };
+    messages: {
+        write: (channelId: string, { files, ...body }: Omit<import("discord-api-types/rest/v10/channel").RESTPostAPIChannelMessageJSONBody, "embeds" | "components"> & import("../common").ResolverProps) => Promise<import("../structures").Message>;
+        edit: (messageId: string, channelId: string, { files, ...body }: Omit<import("discord-api-types/rest/v10/channel").RESTPatchAPIChannelMessageJSONBody, "embeds" | "components"> & import("../common").ResolverProps) => Promise<import("../structures").Message>;
+        crosspost: (messageId: string, channelId: string, reason?: string | undefined) => Promise<import("../structures").Message>;
+        delete: (messageId: string, channelId: string, reason?: string | undefined) => Promise<void>;
+        fetch: (messageId: string, channelId: string) => Promise<import("../structures").Message>;
+        purge: (messages: string[], channelId: string, reason?: string | undefined) => Promise<never>;
+        reactions: {
+            add: (messageId: string, channelId: string, emoji: import("../common").EmojiResolvable) => Promise<never>;
+            delete: (messageId: string, channelId: string, emoji: import("../common").EmojiResolvable, userId?: string) => Promise<never>;
+            fetch: (messageId: string, channelId: string, emoji: import("../common").EmojiResolvable, query?: import("discord-api-types/rest/v10/channel").RESTGetAPIChannelMessageReactionUsersQuery | undefined) => Promise<import("../structures").User[]>;
+            purge: (messageId: string, channelId: string, emoji?: import("../common").EmojiResolvable | undefined) => Promise<never>;
+        };
+    };
+    members: {
+        resolve: (guildId: string, resolve: import("../common").GuildMemberResolvable) => Promise<import("../structures").GuildMember | undefined>;
+        search: (guildId: string, query?: import("discord-api-types/rest/v10/guild").RESTGetAPIGuildMembersSearchQuery | undefined) => Promise<import("../structures").GuildMember[]>;
+        unban: (guildId: string, memberId: string, body?: import("discord-api-types/rest/v10/guild").RESTPutAPIGuildBanJSONBody | undefined, reason?: string | undefined) => Promise<void>;
+        ban: (guildId: string, memberId: string, body?: import("discord-api-types/rest/v10/guild").RESTPutAPIGuildBanJSONBody | undefined, reason?: string | undefined) => Promise<void>;
+        kick: (guildId: string, memberId: string, reason?: string | undefined) => Promise<void>;
+        edit: (guildId: string, memberId: string, body: import("discord-api-types/rest/v10/guild").RESTPatchAPIGuildMemberJSONBody, reason?: string | undefined) => Promise<import("../structures").GuildMember>;
+        add: (guildId: string, memberId: string, body: import("discord-api-types/rest/v10/guild").RESTPutAPIGuildMemberJSONBody) => Promise<import("../structures").GuildMember | undefined>;
+        fetch: (guildId: string, memberId: string, force?: boolean) => Promise<import("../structures").GuildMember>;
+        list: (guildId: string, query?: import("discord-api-types/rest/v10/guild").RESTGetAPIGuildMembersQuery | undefined, force?: boolean) => Promise<import("../structures").GuildMember[]>;
+        roles: {
+            add: (guildId: string, memberId: string, id: string) => Promise<void>;
+            remove: (guildId: string, memberId: string, id: string) => Promise<void>;
+        };
+    };
+    webhooks: {
+        delete: (webhookId: string, { token, reason }: Partial<{
+            token: string;
+            reason: string;
+        }>) => Promise<never>;
+        edit: (webhookId: string, body: import("discord-api-types/rest/v10/webhook").RESTPatchAPIWebhookJSONBody | import("discord-api-types/rest/v10/webhook").RESTPatchAPIWebhookWithTokenJSONBody, { token, reason }: Partial<{
+            token: string;
+            reason: string;
+        }>) => Promise<import("discord-api-types/rest/v10/webhook").RESTGetAPIWebhookWithTokenResult>;
+        fetch: (webhookId: string, token?: string | undefined) => Promise<import("../structures").Webhook>;
+        messages: {
+            write: (webhookId: string, token: string, { body: data, ...payload }: {
+                body: Omit<import("discord-api-types/rest/v10/webhook").RESTPostAPIWebhookWithTokenJSONBody, "embeds" | "components"> & import("../common").ResolverProps;
+                query?: import("discord-api-types/rest/v10/webhook").RESTPostAPIWebhookWithTokenQuery | undefined;
+            }) => Promise<import("../structures").WebhookMessage | null>;
+            edit: (webhookId: string, token: string, { messageId, body: data, ...json }: {
+                body: Omit<import("discord-api-types/rest/v10/webhook").RESTPatchAPIWebhookWithTokenMessageJSONBody, "embeds" | "components"> & import("../common").ResolverProps;
+                messageId: string;
+                query?: import("discord-api-types/rest/v10/webhook").RESTGetAPIWebhookWithTokenMessageQuery | undefined;
+            }) => Promise<import("../structures").WebhookMessage>;
+            delete: (webhookId: string, token: string, messageId: string, reason?: string | undefined) => Promise<never>;
+            fetch: (webhookId: string, token: string, messageId: string, threadId?: string | undefined) => Promise<import("../structures").WebhookMessage | undefined>;
+        };
+    };
+    templates: {
+        fetch: (code: string) => Promise<import("discord-api-types/payloads/v10/template").APITemplate>;
+        list: (guildId: string) => Promise<import("discord-api-types/rest/v10/template").RESTGetAPIGuildTemplatesResult>;
+        create: (guildId: string, body: import("discord-api-types/rest/v10/template").RESTPostAPIGuildTemplatesJSONBody) => Promise<import("discord-api-types/payloads/v10/template").APITemplate>;
+        sync: (guildId: string, code: string) => Promise<import("discord-api-types/payloads/v10/template").APITemplate>;
+        edit: (guildId: string, code: string, body: import("discord-api-types/utils/internals").AddUndefinedToPossiblyUndefinedPropertiesOfInterface<Partial<import("discord-api-types/rest/v10/template").RESTPostAPIGuildTemplatesJSONBody>>) => Promise<import("discord-api-types/payloads/v10/template").APITemplate>;
+        delete: (guildId: string, code: string) => Promise<import("discord-api-types/payloads/v10/template").APITemplate>;
+    };
+    roles: {
+        create: (guildId: string, body: import("discord-api-types/rest/v10/guild").RESTPostAPIGuildRoleJSONBody, reason?: string | undefined) => Promise<any>;
+        list: (guildId: string, force?: boolean) => Promise<import("../structures").GuildRole[]>;
+        edit: (guildId: string, roleId: string, body: import("discord-api-types/rest/v10/guild").RESTPatchAPIGuildRoleJSONBody, reason?: string | undefined) => Promise<any>;
+        delete: (guildId: string, roleId: string, reason?: string | undefined) => Promise<void | undefined>;
+        editPositions: (guildId: string, body: import("discord-api-types/rest/v10/guild").RESTPatchAPIGuildRolePositionsJSONBody) => Promise<import("../structures").GuildRole[]>;
+    };
+    debugger?: Logger;
+    logger: Logger;
+    commands: CommandHandler;
+    langs: LangsHandler;
+    components: ComponentHandler;
+    private _applicationId?;
+    private _botId?;
+    middlewares?: Record<string, MiddlewareContext>;
+    protected static assertString(value: unknown, message?: string): asserts value is string;
+    protected static getBotIdFromToken(token: string): string;
+    options: BaseClientOptions | undefined;
+    constructor(options?: BaseClientOptions);
+    set botId(id: string);
+    get botId(): string;
+    set applicationId(id: string);
+    get applicationId(): string;
+    get proxy(): import("../api").APIRoutes;
+    setServices({ rest, cache, defaultLang, middlewares }: 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>;
+    uploadCommands(applicationId?: string): Promise<void>;
+    loadCommands(dir?: string): Promise<void>;
+    loadComponents(dir?: string): Promise<void>;
+    t(locale: string): DefaultLocale;
+    loadLangs(dir?: string): Promise<void>;
+    getRC<T extends InternalRuntimeConfigHTTP | InternalRuntimeConfig = InternalRuntimeConfigHTTP | InternalRuntimeConfig>(): Promise<{
+        debug: boolean;
+    } & Omit<T, "debug" | "locations"> & {
+        templates: string | undefined;
+        langs: string | undefined;
+        events: string | undefined;
+        components: string | undefined;
+        base: string;
+        output: string;
+        commands: string;
+    }>;
+}
+export interface BaseClientOptions {
+    context?: (interaction: ChatInputCommandInteraction<boolean> | UserCommandInteraction<boolean> | MessageCommandInteraction<boolean>) => {};
+    globalMiddlewares?: readonly (keyof RegisteredMiddlewares)[];
+}
+export interface StartOptions {
+    eventsDir: string;
+    langsDir: string;
+    commandsDir: string;
+    componentsDir: string;
+    connection: {
+        intents: number;
+    };
+    httpConnection: {
+        publicKey: string;
+        port: number;
+    };
+    token: string;
+}
+interface RC extends Variables {
+    debug?: boolean;
+    locations: {
+        base: string;
+        output: string;
+        commands: string;
+        langs?: string;
+        templates?: string;
+        events?: string;
+        components?: string;
+    };
+}
+export interface Variables {
+    token: string;
+    intents?: number;
+    applicationId?: string;
+    port?: number;
+    publicKey?: string;
+}
+export type InternalRuntimeConfigHTTP = Omit<MakeRequired<RC, 'publicKey' | 'port' | 'applicationId'>, 'intents' | 'locations'> & {
+    locations: Omit<RC['locations'], 'events'>;
+};
+export type RuntimeConfigHTTP = Omit<MakeRequired<RC, 'publicKey' | 'applicationId'>, 'intents' | 'locations'> & {
+    locations: Omit<RC['locations'], 'events'>;
+};
+export type InternalRuntimeConfig = Omit<MakeRequired<RC, 'intents'>, 'publicKey' | 'port'>;
+export type RuntimeConfig = OmitInsert<InternalRuntimeConfig, 'intents', {
+    intents?: IntentStrings | number;
+}>;
+export type ServicesOptions = {
+    rest?: REST;
+    cache?: {
+        adapter: Adapter;
+        disabledCache?: Cache['disabledCache'];
+    };
+    defaultLang?: string;
+    middlewares?: Record<string, MiddlewareContext>;
+};
+export {};

package/lib/client/base.js

@@ -0,0 +1,178 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseClient = void 0;
+const node_path_1 = require("node:path");
+const api_1 = require("../api");
+const cache_1 = require("../cache");
+const handler_1 = require("../commands/handler");
+const common_1 = require("../common");
+const members_1 = require("../common/shorters/members");
+const messages_1 = require("../common/shorters/messages");
+const roles_1 = require("../common/shorters/roles");
+const templates_1 = require("../common/shorters/templates");
+const webhook_1 = require("../common/shorters/webhook");
+const handler_2 = require("../components/handler");
+const handler_3 = require("../langs/handler");
+class BaseClient {
+    /** @internal */
+    __handleGuilds = new Set();
+    rest;
+    cache;
+    users = new common_1.UsersShorter(this).users;
+    channels = new common_1.ChannelShorter(this).channels;
+    guilds = new common_1.GuildShorter(this).guilds;
+    messages = new messages_1.MessageShorter(this).messages;
+    members = new members_1.MemberShorter(this).members;
+    webhooks = new webhook_1.WebhookShorter(this).webhooks;
+    templates = new templates_1.TemplateShorter(this).templates;
+    roles = new roles_1.RoleShorter(this).roles;
+    debugger;
+    logger = new common_1.Logger({
+        name: '[Seyfert]',
+    });
+    commands = new handler_1.CommandHandler(this.logger);
+    langs = new handler_3.LangsHandler(this.logger);
+    components = new handler_2.ComponentHandler(this.logger, this);
+    _applicationId;
+    _botId;
+    middlewares;
+    static assertString(value, message) {
+        if (!(typeof value === 'string' && value !== '')) {
+            throw new Error(message ?? 'Value is not a string');
+        }
+    }
+    static getBotIdFromToken(token) {
+        return Buffer.from(token.split('.')[0], 'base64').toString('ascii');
+    }
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    set botId(id) {
+        this._botId = id;
+    }
+    get botId() {
+        return this._botId ?? BaseClient.getBotIdFromToken(this.rest.options.token);
+    }
+    set applicationId(id) {
+        this._applicationId = id;
+    }
+    get applicationId() {
+        return this._applicationId ?? this.botId;
+    }
+    get proxy() {
+        return new api_1.Router(this.rest).createProxy();
+    }
+    setServices({ rest, cache, defaultLang, middlewares }) {
+        if (rest) {
+            this.rest = rest;
+        }
+        if (cache) {
+            this.cache = new cache_1.Cache(this.cache?.intents ?? 0, cache.adapter, cache.disabledCache ?? this.cache?.disabledCache, this);
+        }
+        if (defaultLang) {
+            this.langs.defaultLang = defaultLang;
+        }
+        if (middlewares) {
+            this.middlewares = middlewares;
+        }
+    }
+    async execute(..._options) {
+        if ((await this.getRC()).debug) {
+            this.debugger = new common_1.Logger({
+                name: '[Debug]',
+                logLevel: common_1.LogLevels.Debug,
+            });
+        }
+    }
+    async start(options = {
+        token: undefined,
+        langsDir: undefined,
+        commandsDir: undefined,
+        connection: undefined,
+        componentsDir: undefined,
+    }) {
+        await this.loadLangs(options.langsDir);
+        await this.loadCommands(options.commandsDir);
+        await this.loadComponents(options.componentsDir);
+        const { token: tokenRC } = await this.getRC();
+        const token = options?.token ?? tokenRC;
+        if (!this.rest) {
+            BaseClient.assertString(token, 'token is not a string');
+            this.rest = new api_1.REST({
+                token,
+                debug: false, //(await this.getRC()).debug,
+            });
+        }
+        if (!this.cache) {
+            this.cache = new cache_1.Cache(0, new cache_1.MemoryAdapter(), [], this);
+        }
+        else {
+            this.cache.__setClient(this);
+        }
+    }
+    async onPacket(..._packet) {
+        throw new Error('Function not implemented');
+    }
+    async uploadCommands(applicationId) {
+        applicationId ??= await this.getRC().then(x => x.applicationId ?? this.applicationId);
+        BaseClient.assertString(applicationId, 'applicationId is not a string');
+        const commands = this.commands.values.map(x => x.toJSON());
+        const filter = (0, common_1.filterSplit)(commands, command => !command.guild_id);
+        await this.proxy.applications(applicationId).commands.put({
+            body: filter.expect,
+        });
+        const guilds = new Set();
+        for (const command of filter.never) {
+            for (const guild_id of command.guild_id) {
+                guilds.add(guild_id);
+            }
+        }
+        for (const guild of guilds) {
+            await this.proxy
+                .applications(applicationId)
+                .guilds(guild)
+                .commands.put({
+                body: filter.never.filter(x => x.guild_id?.includes(guild)),
+            });
+        }
+    }
+    async loadCommands(dir) {
+        dir ??= await this.getRC().then(x => x.commands);
+        BaseClient.assertString(dir);
+        await this.commands.load(dir, this);
+        this.logger.info('CommandHandler loaded');
+    }
+    async loadComponents(dir) {
+        dir ??= await this.getRC().then(x => x.components);
+        if (dir) {
+            await this.components.load(dir);
+            this.logger.info('ComponentHandler loaded');
+        }
+    }
+    t(locale) {
+        return this.langs.get(locale);
+    }
+    async loadLangs(dir) {
+        dir ??= await this.getRC().then(x => x.langs);
+        if (dir) {
+            await this.langs.load(dir);
+            this.logger.info('LangsHandler loaded');
+        }
+    }
+    async getRC() {
+        const { locations, debug, ...env } = (await (0, common_1.magicImport)((0, node_path_1.join)(process.cwd(), 'seyfert.config.js')).then(x => x.default ?? x));
+        return {
+            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,
+            base: (0, node_path_1.join)(process.cwd(), locations.base),
+            output: (0, node_path_1.join)(process.cwd(), locations.output),
+            commands: (0, node_path_1.join)(process.cwd(), locations.output, locations.commands),
+        };
+    }
+}
+exports.BaseClient = BaseClient;

package/lib/client/client.d.ts

@@ -0,0 +1,32 @@
+import type { DeepPartial, GatewayDispatchPayload, GatewayPresenceUpdateData, If } from '../common';
+import { EventHandler } from '../events';
+import { ClientUser } from '../structures';
+import { ShardManager } 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';
+export declare class Client<Ready extends boolean = boolean> extends BaseClient {
+    gateway: ShardManager;
+    events: EventHandler;
+    me: If<Ready, ClientUser>;
+    options: ClientOptions | undefined;
+    memberUpdateHandler: MemberUpdateHandler;
+    presenceUpdateHandler: PresenceUpdateHandler;
+    constructor(options?: ClientOptions);
+    setServices({ gateway, ...rest }: ServicesOptions & {
+        gateway?: ShardManager;
+    }): void;
+    loadEvents(dir?: string): Promise<void>;
+    protected execute(options?: {
+        token?: string;
+        intents?: number;
+    }): Promise<void>;
+    start(options?: Omit<DeepPartial<StartOptions>, 'httpConnection'>, execute?: boolean): Promise<void>;
+    protected onPacket(shardId: number, packet: GatewayDispatchPayload): Promise<void>;
+}
+export interface ClientOptions extends BaseClientOptions {
+    presence?: (shardId: number) => GatewayPresenceUpdateData;
+    shardStart?: number;
+    shardEnd?: number;
+}

package/lib/client/client.js

@@ -0,0 +1,156 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Client = void 0;
+const node_worker_threads_1 = require("node:worker_threads");
+const events_1 = require("../events");
+const structures_1 = require("../structures");
+const websocket_1 = require("../websocket");
+const memberUpdate_1 = require("../websocket/discord/events/memberUpdate");
+const presenceUpdate_1 = require("../websocket/discord/events/presenceUpdate");
+const base_1 = require("./base");
+const oninteraction_1 = require("./oninteraction");
+class Client extends base_1.BaseClient {
+    gateway;
+    events = new events_1.EventHandler(this.logger);
+    me;
+    memberUpdateHandler = new memberUpdate_1.MemberUpdateHandler();
+    presenceUpdateHandler = new presenceUpdate_1.PresenceUpdateHandler();
+    constructor(options) {
+        super(options);
+    }
+    setServices({ gateway, ...rest }) {
+        super.setServices(rest);
+        if (gateway) {
+            const onPacket = this.onPacket.bind(this);
+            const oldFn = gateway.options.handlePayload;
+            gateway.options.handlePayload = async (shardId, packet) => {
+                await onPacket(shardId, packet);
+                return oldFn(shardId, packet);
+            };
+            this.gateway = gateway;
+        }
+    }
+    async loadEvents(dir) {
+        dir ??= await this.getRC().then(x => x.events);
+        if (dir) {
+            await this.events.load(dir);
+            this.logger.info('EventHandler loaded');
+        }
+    }
+    async execute(options = {}) {
+        await super.execute(options);
+        if (!node_worker_threads_1.workerData?.__USING_WATCHER__) {
+            await this.gateway.spawnShards();
+        }
+        else {
+            node_worker_threads_1.parentPort?.on('message', (data) => {
+                switch (data.type) {
+                    case 'PAYLOAD':
+                        this.gateway.options.handlePayload(data.shardId, data.payload);
+                        break;
+                    case 'SEND_TO_SHARD':
+                        this.gateway.send(data.shardId, data.payload);
+                        break;
+                }
+            });
+        }
+    }
+    async start(options = {}, execute = true) {
+        await super.start(options);
+        await this.loadEvents(options.eventsDir);
+        const { token: tokenRC, intents: intentsRC, debug: debugRC } = await this.getRC();
+        const token = options?.token ?? tokenRC;
+        const intents = options?.connection?.intents ?? intentsRC;
+        if (!this.gateway) {
+            base_1.BaseClient.assertString(token, 'token is not a string');
+            this.gateway = new websocket_1.ShardManager({
+                token,
+                info: await this.proxy.gateway.bot.get(),
+                intents,
+                handlePayload: (shardId, packet) => {
+                    return this.onPacket(shardId, packet);
+                },
+                presence: this.options?.presence,
+                debug: debugRC,
+                shardStart: this.options?.shardStart,
+                shardEnd: this.options?.shardEnd,
+            });
+        }
+        this.cache.intents = this.gateway.options.intents;
+        if (execute) {
+            await this.execute(options.connection);
+        }
+        else {
+            await super.execute(options);
+        }
+    }
+    async onPacket(shardId, packet) {
+        switch (packet.t) {
+            //// Cases where we must obtain the old data before updating
+            case 'GUILD_MEMBER_UPDATE':
+                if (!this.memberUpdateHandler.check(packet.d)) {
+                    return;
+                }
+                await this.events.execute(packet.t, packet, this, shardId);
+                await this.cache.onPacket(packet);
+                break;
+            case 'PRESENCE_UPDATE':
+                if (!this.presenceUpdateHandler.check(packet.d)) {
+                    return;
+                }
+                await this.events.execute(packet.t, packet, this, shardId);
+                await this.cache.onPacket(packet);
+                break;
+            case 'GUILD_DELETE':
+            case 'CHANNEL_UPDATE': {
+                await this.events.execute(packet.t, packet, this, shardId);
+                await this.cache.onPacket(packet);
+                break;
+            }
+            //rest of the events
+            default: {
+                await this.cache.onPacket(packet);
+                switch (packet.t) {
+                    case 'READY':
+                        for (const g of packet.d.guilds) {
+                            this.__handleGuilds.add(g.id);
+                        }
+                        this.botId = packet.d.user.id;
+                        this.applicationId = packet.d.application.id;
+                        this.me = new structures_1.ClientUser(this, packet.d.user, packet.d.application);
+                        if (!this.__handleGuilds.size) {
+                            if ([...this.gateway.values()].every(shard => shard.data.session_id) &&
+                                this.events.values.BOT_READY &&
+                                (this.events.values.BOT_READY.fired ? !this.events.values.BOT_READY.data.once : true)) {
+                                this.events.values.BOT_READY.fired = true;
+                                await this.events.values.BOT_READY.run(this.me, this, -1);
+                            }
+                        }
+                        this.debugger?.debug(`#${shardId}[${packet.d.user.username}](${this.botId}) is online...`);
+                        break;
+                    case 'INTERACTION_CREATE': {
+                        await (0, oninteraction_1.onInteraction)(shardId, packet.d, this);
+                        break;
+                    }
+                    case 'GUILD_CREATE': {
+                        if (this.__handleGuilds.has(packet.d.id)) {
+                            this.__handleGuilds.delete(packet.d.id);
+                            if (!this.__handleGuilds.size &&
+                                [...this.gateway.values()].every(shard => shard.data.session_id) &&
+                                this.events.values.BOT_READY &&
+                                (this.events.values.BOT_READY.fired ? !this.events.values.BOT_READY.data.once : true)) {
+                                this.events.values.BOT_READY.fired = true;
+                                await this.events.values.BOT_READY.run(this.me, this, -1);
+                            }
+                            return;
+                        }
+                        break;
+                    }
+                }
+                await this.events.execute(packet.t, packet, this, shardId);
+                break;
+            }
+        }
+    }
+}
+exports.Client = Client;

package/lib/client/httpclient.d.ts

@@ -0,0 +1,21 @@
+/// <reference types="node" />
+import type { HttpRequest, HttpResponse } from 'uWebSockets.js';
+import type { APIInteraction, DeepPartial } from '../common';
+import type { StartOptions } from './base';
+import { BaseClient } from './base';
+declare let UWS: typeof import('uWebSockets.js');
+export declare class HttpClient extends BaseClient {
+    app: ReturnType<typeof UWS.App>;
+    publicKey: string;
+    publicKeyHex: Buffer;
+    constructor();
+    protected static readJson<T extends Record<string, any>>(res: HttpResponse): Promise<T>;
+    protected execute(options?: {
+        publicKey?: string;
+        port?: number;
+    }): Promise<void>;
+    start(options?: DeepPartial<Omit<StartOptions, 'connection'>>): Promise<void>;
+    protected verifySignature(res: HttpResponse, req: HttpRequest): Promise<APIInteraction | undefined>;
+    onPacket(res: HttpResponse, req: HttpRequest): Promise<void>;
+}
+export {};