seyfert 0.1.0

package/lib/events/handler.js

@@ -0,0 +1,112 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventHandler = void 0;
+const common_1 = require("../common");
+const RawEvents = __importStar(require("../events/hooks"));
+class EventHandler extends common_1.BaseHandler {
+    onFail;
+    filter = (path) => path.endsWith('.js') || path.endsWith('.ts');
+    values = {};
+    set OnFail(cb) {
+        this.onFail = cb;
+    }
+    async load(eventsDir) {
+        for (const i of await this.loadFilesK(await this.getFiles(eventsDir))) {
+            const instance = i.file;
+            if (typeof instance?.run !== 'function') {
+                this.logger.warn(i.path.split(process.cwd()).slice(1).join(process.cwd()), 'Missing run function, use `export default {...}` syntax');
+                continue;
+            }
+            instance.__filePath = i.path;
+            this.values[common_1.ReplaceRegex.snake(instance.data.name).toUpperCase()] = instance;
+        }
+    }
+    async execute(name, ...args) {
+        switch (name) {
+            case 'MESSAGE_CREATE':
+                {
+                    const { d: data } = args[0];
+                    if (args[1].components.values.has(data.interaction?.id ?? '')) {
+                        args[1].components.values.get(data.interaction.id).messageId = data.id;
+                    }
+                }
+                break;
+            case 'MESSAGE_DELETE':
+                {
+                    const { d: data } = args[0];
+                    const value = [...args[1].components.values].find(x => x[1].messageId === data.id);
+                    if (value) {
+                        args[1].components.onMessageDelete(value[0]);
+                    }
+                }
+                break;
+            case 'MESSAGE_DELETE_BULK':
+                {
+                    const { d: data } = args[0];
+                    const values = [...args[1].components.values];
+                    data.ids.forEach(id => {
+                        const value = values.find(x => x[1].messageId === id);
+                        if (value) {
+                            args[1].components.onMessageDelete(value[0]);
+                        }
+                    });
+                }
+                break;
+        }
+        const Event = this.values[name];
+        if (!Event) {
+            return;
+        }
+        try {
+            if (Event.data.once && Event.fired) {
+                return;
+            }
+            Event.fired = true;
+            const hook = await RawEvents[args[0].t]?.(args[1], args[0].d);
+            await Event.run(...[hook, args[1], args[2]]);
+        }
+        catch (e) {
+            await this.onFail?.(e);
+        }
+    }
+    async reload(name) {
+        const eventName = common_1.ReplaceRegex.snake(name).toUpperCase();
+        const event = this.values[eventName];
+        if (!event)
+            return null;
+        delete require.cache[event.__filePath];
+        const imported = await (0, common_1.magicImport)(event.__filePath).then(x => x.default ?? x);
+        imported.__filePath = event.__filePath;
+        this.values[eventName] = imported;
+        return imported;
+    }
+    async reloadAll() {
+        for (const i in this.values) {
+            await this.reload(common_1.ReplaceRegex.camel(i));
+        }
+    }
+}
+exports.EventHandler = EventHandler;

package/lib/events/hooks/application_command.d.ts

@@ -0,0 +1,12 @@
+import type { BaseClient } from '../../client/base';
+import type { GatewayApplicationCommandPermissionsUpdateDispatchData } from '../../common';
+export declare const APPLICATION_COMMAND_PERMISSIONS_UPDATE: (_self: BaseClient, data: GatewayApplicationCommandPermissionsUpdateDispatchData) => {
+    id: string;
+    applicationId: string;
+    guildId: string;
+    permissions: {
+        id: string;
+        type: import("discord-api-types/payloads/v10/_interactions/_applicationCommands/permissions").ApplicationCommandPermissionType;
+        permission: boolean;
+    }[];
+};

package/lib/events/hooks/application_command.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.APPLICATION_COMMAND_PERMISSIONS_UPDATE = void 0;
+const common_1 = require("../../common");
+const APPLICATION_COMMAND_PERMISSIONS_UPDATE = (_self, data) => {
+    return (0, common_1.toCamelCase)(data);
+};
+exports.APPLICATION_COMMAND_PERMISSIONS_UPDATE = APPLICATION_COMMAND_PERMISSIONS_UPDATE;

package/lib/events/hooks/auto_moderation.d.ts

@@ -0,0 +1,22 @@
+import type { BaseClient } from '../../client/base';
+import { type GatewayAutoModerationActionExecutionDispatchData, type GatewayAutoModerationRuleCreateDispatchData, type GatewayAutoModerationRuleDeleteDispatchData, type GatewayAutoModerationRuleUpdateDispatchData } from '../../common';
+import { AutoModerationRule } from '../../structures';
+export declare const AUTO_MODERATION_ACTION_EXECUTION: (_self: BaseClient, data: GatewayAutoModerationActionExecutionDispatchData) => {
+    guildId: string;
+    action: {
+        type: import("discord-api-types/payloads/v10/autoModeration").AutoModerationActionType;
+        metadata?: import("discord-api-types/payloads/v10/autoModeration").APIAutoModerationActionMetadata | undefined;
+    };
+    ruleId: string;
+    ruleTriggerType: import("discord-api-types/payloads/v10/autoModeration").AutoModerationRuleTriggerType;
+    userId: string;
+    channelId?: string | undefined;
+    messageId?: string | undefined;
+    alertSystemMessageId?: string | undefined;
+    content: string;
+    matchedKeyword: string | null;
+    matchedContent: string | null;
+};
+export declare const AUTO_MODERATION_RULE_CREATE: (self: BaseClient, data: GatewayAutoModerationRuleCreateDispatchData) => AutoModerationRule;
+export declare const AUTO_MODERATION_RULE_DELETE: (self: BaseClient, data: GatewayAutoModerationRuleDeleteDispatchData) => AutoModerationRule;
+export declare const AUTO_MODERATION_RULE_UPDATE: (self: BaseClient, data: GatewayAutoModerationRuleUpdateDispatchData) => AutoModerationRule;

package/lib/events/hooks/auto_moderation.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AUTO_MODERATION_RULE_UPDATE = exports.AUTO_MODERATION_RULE_DELETE = exports.AUTO_MODERATION_RULE_CREATE = exports.AUTO_MODERATION_ACTION_EXECUTION = void 0;
+const common_1 = require("../../common");
+const structures_1 = require("../../structures");
+const AUTO_MODERATION_ACTION_EXECUTION = (_self, data) => {
+    return (0, common_1.toCamelCase)(data);
+};
+exports.AUTO_MODERATION_ACTION_EXECUTION = AUTO_MODERATION_ACTION_EXECUTION;
+const AUTO_MODERATION_RULE_CREATE = (self, data) => {
+    return new structures_1.AutoModerationRule(self, data);
+};
+exports.AUTO_MODERATION_RULE_CREATE = AUTO_MODERATION_RULE_CREATE;
+const AUTO_MODERATION_RULE_DELETE = (self, data) => {
+    return new structures_1.AutoModerationRule(self, data);
+};
+exports.AUTO_MODERATION_RULE_DELETE = AUTO_MODERATION_RULE_DELETE;
+const AUTO_MODERATION_RULE_UPDATE = (self, data) => {
+    return new structures_1.AutoModerationRule(self, data);
+};
+exports.AUTO_MODERATION_RULE_UPDATE = AUTO_MODERATION_RULE_UPDATE;

package/lib/events/hooks/channel.d.ts

@@ -0,0 +1,11 @@
+import { type GatewayChannelCreateDispatchData, type GatewayChannelDeleteDispatchData, type GatewayChannelPinsUpdateDispatchData, type GatewayChannelUpdateDispatchData } from '../../common';
+import type { BaseClient } from '../../client/base';
+import type { AllChannels } from '../../structures';
+export declare const CHANNEL_CREATE: (self: BaseClient, data: GatewayChannelCreateDispatchData) => AllChannels;
+export declare const CHANNEL_DELETE: (self: BaseClient, data: GatewayChannelDeleteDispatchData) => AllChannels;
+export declare const CHANNEL_PINS_UPDATE: (_self: BaseClient, data: GatewayChannelPinsUpdateDispatchData) => {
+    guildId?: string | undefined;
+    channelId: string;
+    lastPinTimestamp?: string | null | undefined;
+};
+export declare const CHANNEL_UPDATE: (self: BaseClient, data: GatewayChannelUpdateDispatchData) => Promise<[channel: AllChannels, old?: AllChannels]>;

package/lib/events/hooks/channel.js

@@ -0,0 +1,24 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CHANNEL_UPDATE = exports.CHANNEL_PINS_UPDATE = exports.CHANNEL_DELETE = exports.CHANNEL_CREATE = void 0;
+const common_1 = require("../../common");
+const channels_1 = __importDefault(require("../../structures/channels"));
+const CHANNEL_CREATE = (self, data) => {
+    return (0, channels_1.default)(data, self);
+};
+exports.CHANNEL_CREATE = CHANNEL_CREATE;
+const CHANNEL_DELETE = (self, data) => {
+    return (0, channels_1.default)(data, self);
+};
+exports.CHANNEL_DELETE = CHANNEL_DELETE;
+const CHANNEL_PINS_UPDATE = (_self, data) => {
+    return (0, common_1.toCamelCase)(data);
+};
+exports.CHANNEL_PINS_UPDATE = CHANNEL_PINS_UPDATE;
+const CHANNEL_UPDATE = async (self, data) => {
+    return [(0, channels_1.default)(data, self), await self.cache.channels?.get(data.id)];
+};
+exports.CHANNEL_UPDATE = CHANNEL_UPDATE;

package/lib/events/hooks/custom.d.ts

@@ -0,0 +1,4 @@
+import type { BaseClient } from '../../client/base';
+import type { ClientUser } from '../../structures';
+export declare const BOT_READY: (_self: BaseClient, me: ClientUser) => ClientUser;
+export declare const WORKER_READY: (_self: BaseClient, me: ClientUser) => ClientUser;

package/lib/events/hooks/custom.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WORKER_READY = exports.BOT_READY = void 0;
+const BOT_READY = (_self, me) => {
+    return me;
+};
+exports.BOT_READY = BOT_READY;
+const WORKER_READY = (_self, me) => {
+    return me;
+};
+exports.WORKER_READY = WORKER_READY;

package/lib/events/hooks/dispatch.d.ts

@@ -0,0 +1,5 @@
+import type { BaseClient } from '../../client/base';
+import type { GatewayReadyDispatchData, GatewayResumedDispatch } from '../../common';
+import { ClientUser } from '../../structures';
+export declare const READY: (self: BaseClient, data: GatewayReadyDispatchData) => ClientUser;
+export declare const RESUMED: (_self: BaseClient, _data: GatewayResumedDispatch['d']) => void;

package/lib/events/hooks/dispatch.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RESUMED = exports.READY = void 0;
+const structures_1 = require("../../structures");
+const READY = (self, data) => {
+    return new structures_1.ClientUser(self, data.user, data.application);
+};
+exports.READY = READY;
+const RESUMED = (_self, _data) => {
+    return;
+};
+exports.RESUMED = RESUMED;

package/lib/events/hooks/entitlement.d.ts

@@ -0,0 +1,35 @@
+import type { BaseClient } from '../../client/base';
+import { type APIEntitlement } from '../../common';
+export declare const ENTITLEMENT_CREATE: (_: BaseClient, data: APIEntitlement) => {
+    id: string;
+    skuId: string;
+    userId?: string | undefined;
+    guildId?: string | undefined;
+    applicationId: string;
+    type: import("discord-api-types/payloads/v10/monetization").EntitlementType;
+    deleted: boolean;
+    startsAt?: string | undefined;
+    endsAt?: string | undefined;
+};
+export declare const ENTITLEMENT_UPDATE: (_: BaseClient, data: APIEntitlement) => {
+    id: string;
+    skuId: string;
+    userId?: string | undefined;
+    guildId?: string | undefined;
+    applicationId: string;
+    type: import("discord-api-types/payloads/v10/monetization").EntitlementType;
+    deleted: boolean;
+    startsAt?: string | undefined;
+    endsAt?: string | undefined;
+};
+export declare const ENTITLEMENT_DELETE: (_: BaseClient, data: APIEntitlement) => {
+    id: string;
+    skuId: string;
+    userId?: string | undefined;
+    guildId?: string | undefined;
+    applicationId: string;
+    type: import("discord-api-types/payloads/v10/monetization").EntitlementType;
+    deleted: boolean;
+    startsAt?: string | undefined;
+    endsAt?: string | undefined;
+};

package/lib/events/hooks/entitlement.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ENTITLEMENT_DELETE = exports.ENTITLEMENT_UPDATE = exports.ENTITLEMENT_CREATE = void 0;
+const common_1 = require("../../common");
+const ENTITLEMENT_CREATE = (_, data) => {
+    return (0, common_1.toCamelCase)(data);
+};
+exports.ENTITLEMENT_CREATE = ENTITLEMENT_CREATE;
+const ENTITLEMENT_UPDATE = (_, data) => {
+    return (0, common_1.toCamelCase)(data);
+};
+exports.ENTITLEMENT_UPDATE = ENTITLEMENT_UPDATE;
+const ENTITLEMENT_DELETE = (_, data) => {
+    return (0, common_1.toCamelCase)(data);
+};
+exports.ENTITLEMENT_DELETE = ENTITLEMENT_DELETE;

package/lib/events/hooks/guild.d.ts

@@ -0,0 +1,228 @@
+import type { BaseClient } from '../../client/base';
+import type { GatewayGuildAuditLogEntryCreateDispatchData, GatewayGuildBanAddDispatchData, GatewayGuildBanRemoveDispatchData, GatewayGuildCreateDispatchData, GatewayGuildDeleteDispatchData, GatewayGuildEmojisUpdateDispatchData, GatewayGuildIntegrationsUpdateDispatchData, GatewayGuildMemberRemoveDispatchData, GatewayGuildMemberUpdateDispatchData, GatewayGuildMembersChunkDispatchData, GatewayGuildRoleCreateDispatchData, GatewayGuildRoleDeleteDispatchData, GatewayGuildRoleUpdateDispatchData, GatewayGuildScheduledEventCreateDispatchData, GatewayGuildScheduledEventDeleteDispatchData, GatewayGuildScheduledEventUpdateDispatchData, GatewayGuildScheduledEventUserAddDispatchData, GatewayGuildScheduledEventUserRemoveDispatchData, GatewayGuildStickersUpdateDispatchData, GatewayGuildUpdateDispatchData } from '../../common';
+import { Guild, GuildEmoji, GuildMember, GuildRole, Sticker, UnavailableMember, User, type GatewayGuildMemberAddDispatchDataFixed } from '../../structures';
+export declare const GUILD_AUDIT_LOG_ENTRY_CREATE: (_self: BaseClient, data: GatewayGuildAuditLogEntryCreateDispatchData) => {
+    guildId: string;
+    targetId: string | null;
+    changes?: import("discord-api-types/payloads/v10/auditLog").APIAuditLogChange[] | undefined;
+    userId: string | null;
+    id: string;
+    actionType: import("discord-api-types/payloads/v10/auditLog").AuditLogEvent;
+    options?: import("discord-api-types/payloads/v10/auditLog").APIAuditLogOptions | undefined;
+    reason?: string | undefined;
+};
+export declare const GUILD_BAN_ADD: (self: BaseClient, data: GatewayGuildBanAddDispatchData) => {
+    user: User;
+    guildId: string;
+};
+export declare const GUILD_BAN_REMOVE: (self: BaseClient, data: GatewayGuildBanRemoveDispatchData) => {
+    user: User;
+    guildId: string;
+};
+export declare const GUILD_CREATE: (self: BaseClient, data: GatewayGuildCreateDispatchData) => Guild<"create">;
+export declare const GUILD_DELETE: (_self: BaseClient, data: GatewayGuildDeleteDispatchData) => Promise<import("discord-api-types/payloads/v10/guild").APIUnavailableGuild>;
+export declare const GUILD_EMOJIS_UPDATE: (self: BaseClient, data: GatewayGuildEmojisUpdateDispatchData) => {
+    emojis: GuildEmoji[];
+    guildId: string;
+};
+export declare const GUILD_INTEGRATIONS_UPDATE: (_self: BaseClient, data: GatewayGuildIntegrationsUpdateDispatchData) => {
+    guildId: string;
+};
+export declare const GUILD_MEMBER_ADD: (self: BaseClient, data: GatewayGuildMemberAddDispatchDataFixed<boolean>) => GuildMember | UnavailableMember;
+export declare const GUILD_MEMBER_REMOVE: (self: BaseClient, data: GatewayGuildMemberRemoveDispatchData) => {
+    user: User;
+    guildId: string;
+};
+export declare const GUILD_MEMBERS_CHUNK: (self: BaseClient, data: GatewayGuildMembersChunkDispatchData) => {
+    members: GuildMember[];
+    guildId: string;
+    chunkIndex: number;
+    chunkCount: number;
+    notFound?: unknown[] | undefined;
+    presences?: import("discord-api-types/gateway/v10").GatewayGuildMembersChunkPresence[] | undefined;
+    nonce?: string | undefined;
+};
+export declare const GUILD_MEMBER_UPDATE: (self: BaseClient, data: GatewayGuildMemberUpdateDispatchData) => Promise<[member: GuildMember, old?: GuildMember]>;
+export declare const GUILD_SCHEDULED_EVENT_CREATE: (_self: BaseClient, data: GatewayGuildScheduledEventCreateDispatchData) => {
+    channelId: string;
+    entityMetadata: null;
+    id: string;
+    guildId: string;
+    creatorId?: string | null | undefined;
+    name: string;
+    description?: string | null | undefined;
+    scheduledStartTime: string;
+    scheduledEndTime: string | null;
+    privacyLevel: import("discord-api-types/payloads/v10/guildScheduledEvent").GuildScheduledEventPrivacyLevel;
+    status: import("discord-api-types/payloads/v10/guildScheduledEvent").GuildScheduledEventStatus;
+    entityType: import("discord-api-types/payloads/v10/guildScheduledEvent").GuildScheduledEventEntityType.StageInstance;
+    entityId: string | null;
+    creator?: import("discord-api-types/payloads/v10/user").APIUser | undefined;
+    userCount?: number | undefined;
+    image?: string | null | undefined;
+} | {
+    channelId: string;
+    entityMetadata: null;
+    id: string;
+    guildId: string;
+    creatorId?: string | null | undefined;
+    name: string;
+    description?: string | null | undefined;
+    scheduledStartTime: string;
+    scheduledEndTime: string | null;
+    privacyLevel: import("discord-api-types/payloads/v10/guildScheduledEvent").GuildScheduledEventPrivacyLevel;
+    status: import("discord-api-types/payloads/v10/guildScheduledEvent").GuildScheduledEventStatus;
+    entityType: import("discord-api-types/payloads/v10/guildScheduledEvent").GuildScheduledEventEntityType.Voice;
+    entityId: string | null;
+    creator?: import("discord-api-types/payloads/v10/user").APIUser | undefined;
+    userCount?: number | undefined;
+    image?: string | null | undefined;
+} | {
+    channelId: null;
+    entityMetadata: {
+        location: string;
+    };
+    id: string;
+    guildId: string;
+    creatorId?: string | null | undefined;
+    name: string;
+    description?: string | null | undefined;
+    scheduledStartTime: string;
+    scheduledEndTime: string | null;
+    privacyLevel: import("discord-api-types/payloads/v10/guildScheduledEvent").GuildScheduledEventPrivacyLevel;
+    status: import("discord-api-types/payloads/v10/guildScheduledEvent").GuildScheduledEventStatus;
+    entityType: import("discord-api-types/payloads/v10/guildScheduledEvent").GuildScheduledEventEntityType.External;
+    entityId: string | null;
+    creator?: import("discord-api-types/payloads/v10/user").APIUser | undefined;
+    userCount?: number | undefined;
+    image?: string | null | undefined;
+};
+export declare const GUILD_SCHEDULED_EVENT_UPDATE: (_self: BaseClient, data: GatewayGuildScheduledEventUpdateDispatchData) => {
+    channelId: string;
+    entityMetadata: null;
+    id: string;
+    guildId: string;
+    creatorId?: string | null | undefined;
+    name: string;
+    description?: string | null | undefined;
+    scheduledStartTime: string;
+    scheduledEndTime: string | null;
+    privacyLevel: import("discord-api-types/payloads/v10/guildScheduledEvent").GuildScheduledEventPrivacyLevel;
+    status: import("discord-api-types/payloads/v10/guildScheduledEvent").GuildScheduledEventStatus;
+    entityType: import("discord-api-types/payloads/v10/guildScheduledEvent").GuildScheduledEventEntityType.StageInstance;
+    entityId: string | null;
+    creator?: import("discord-api-types/payloads/v10/user").APIUser | undefined;
+    userCount?: number | undefined;
+    image?: string | null | undefined;
+} | {
+    channelId: string;
+    entityMetadata: null;
+    id: string;
+    guildId: string;
+    creatorId?: string | null | undefined;
+    name: string;
+    description?: string | null | undefined;
+    scheduledStartTime: string;
+    scheduledEndTime: string | null;
+    privacyLevel: import("discord-api-types/payloads/v10/guildScheduledEvent").GuildScheduledEventPrivacyLevel;
+    status: import("discord-api-types/payloads/v10/guildScheduledEvent").GuildScheduledEventStatus;
+    entityType: import("discord-api-types/payloads/v10/guildScheduledEvent").GuildScheduledEventEntityType.Voice;
+    entityId: string | null;
+    creator?: import("discord-api-types/payloads/v10/user").APIUser | undefined;
+    userCount?: number | undefined;
+    image?: string | null | undefined;
+} | {
+    channelId: null;
+    entityMetadata: {
+        location: string;
+    };
+    id: string;
+    guildId: string;
+    creatorId?: string | null | undefined;
+    name: string;
+    description?: string | null | undefined;
+    scheduledStartTime: string;
+    scheduledEndTime: string | null;
+    privacyLevel: import("discord-api-types/payloads/v10/guildScheduledEvent").GuildScheduledEventPrivacyLevel;
+    status: import("discord-api-types/payloads/v10/guildScheduledEvent").GuildScheduledEventStatus;
+    entityType: import("discord-api-types/payloads/v10/guildScheduledEvent").GuildScheduledEventEntityType.External;
+    entityId: string | null;
+    creator?: import("discord-api-types/payloads/v10/user").APIUser | undefined;
+    userCount?: number | undefined;
+    image?: string | null | undefined;
+};
+export declare const GUILD_SCHEDULED_EVENT_DELETE: (_self: BaseClient, data: GatewayGuildScheduledEventDeleteDispatchData) => {
+    channelId: string;
+    entityMetadata: null;
+    id: string;
+    guildId: string;
+    creatorId?: string | null | undefined;
+    name: string;
+    description?: string | null | undefined;
+    scheduledStartTime: string;
+    scheduledEndTime: string | null;
+    privacyLevel: import("discord-api-types/payloads/v10/guildScheduledEvent").GuildScheduledEventPrivacyLevel;
+    status: import("discord-api-types/payloads/v10/guildScheduledEvent").GuildScheduledEventStatus;
+    entityType: import("discord-api-types/payloads/v10/guildScheduledEvent").GuildScheduledEventEntityType.StageInstance;
+    entityId: string | null;
+    creator?: import("discord-api-types/payloads/v10/user").APIUser | undefined;
+    userCount?: number | undefined;
+    image?: string | null | undefined;
+} | {
+    channelId: string;
+    entityMetadata: null;
+    id: string;
+    guildId: string;
+    creatorId?: string | null | undefined;
+    name: string;
+    description?: string | null | undefined;
+    scheduledStartTime: string;
+    scheduledEndTime: string | null;
+    privacyLevel: import("discord-api-types/payloads/v10/guildScheduledEvent").GuildScheduledEventPrivacyLevel;
+    status: import("discord-api-types/payloads/v10/guildScheduledEvent").GuildScheduledEventStatus;
+    entityType: import("discord-api-types/payloads/v10/guildScheduledEvent").GuildScheduledEventEntityType.Voice;
+    entityId: string | null;
+    creator?: import("discord-api-types/payloads/v10/user").APIUser | undefined;
+    userCount?: number | undefined;
+    image?: string | null | undefined;
+} | {
+    channelId: null;
+    entityMetadata: {
+        location: string;
+    };
+    id: string;
+    guildId: string;
+    creatorId?: string | null | undefined;
+    name: string;
+    description?: string | null | undefined;
+    scheduledStartTime: string;
+    scheduledEndTime: string | null;
+    privacyLevel: import("discord-api-types/payloads/v10/guildScheduledEvent").GuildScheduledEventPrivacyLevel;
+    status: import("discord-api-types/payloads/v10/guildScheduledEvent").GuildScheduledEventStatus;
+    entityType: import("discord-api-types/payloads/v10/guildScheduledEvent").GuildScheduledEventEntityType.External;
+    entityId: string | null;
+    creator?: import("discord-api-types/payloads/v10/user").APIUser | undefined;
+    userCount?: number | undefined;
+    image?: string | null | undefined;
+};
+export declare const GUILD_SCHEDULED_EVENT_USER_ADD: (_self: BaseClient, data: GatewayGuildScheduledEventUserAddDispatchData) => {
+    guildScheduledEventId: string;
+    userId: string;
+    guildId: string;
+};
+export declare const GUILD_SCHEDULED_EVENT_USER_REMOVE: (_self: BaseClient, data: GatewayGuildScheduledEventUserRemoveDispatchData) => {
+    guildScheduledEventId: string;
+    userId: string;
+    guildId: string;
+};
+export declare const GUILD_ROLE_CREATE: (self: BaseClient, data: GatewayGuildRoleCreateDispatchData) => GuildRole;
+export declare const GUILD_ROLE_DELETE: (_self: BaseClient, data: GatewayGuildRoleDeleteDispatchData) => {
+    guildId: string;
+    roleId: string;
+};
+export declare const GUILD_ROLE_UPDATE: (self: BaseClient, data: GatewayGuildRoleUpdateDispatchData) => GuildRole;
+export declare const GUILD_STICKERS_UPDATE: (self: BaseClient, data: GatewayGuildStickersUpdateDispatchData) => {
+    stickers: Sticker[];
+    guildId: string;
+};
+export declare const GUILD_UPDATE: (self: BaseClient, data: GatewayGuildUpdateDispatchData) => Guild<"api">;

package/lib/events/hooks/guild.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GUILD_UPDATE = exports.GUILD_STICKERS_UPDATE = exports.GUILD_ROLE_UPDATE = exports.GUILD_ROLE_DELETE = exports.GUILD_ROLE_CREATE = exports.GUILD_SCHEDULED_EVENT_USER_REMOVE = exports.GUILD_SCHEDULED_EVENT_USER_ADD = exports.GUILD_SCHEDULED_EVENT_DELETE = exports.GUILD_SCHEDULED_EVENT_UPDATE = exports.GUILD_SCHEDULED_EVENT_CREATE = exports.GUILD_MEMBER_UPDATE = exports.GUILD_MEMBERS_CHUNK = exports.GUILD_MEMBER_REMOVE = exports.GUILD_MEMBER_ADD = exports.GUILD_INTEGRATIONS_UPDATE = exports.GUILD_EMOJIS_UPDATE = exports.GUILD_DELETE = exports.GUILD_CREATE = exports.GUILD_BAN_REMOVE = exports.GUILD_BAN_ADD = exports.GUILD_AUDIT_LOG_ENTRY_CREATE = void 0;
+const common_1 = require("../../common");
+const structures_1 = require("../../structures");
+const GUILD_AUDIT_LOG_ENTRY_CREATE = (_self, data) => {
+    return (0, common_1.toCamelCase)(data);
+};
+exports.GUILD_AUDIT_LOG_ENTRY_CREATE = GUILD_AUDIT_LOG_ENTRY_CREATE;
+const GUILD_BAN_ADD = (self, data) => {
+    return { ...(0, common_1.toCamelCase)(data), user: new structures_1.User(self, data.user) };
+};
+exports.GUILD_BAN_ADD = GUILD_BAN_ADD;
+const GUILD_BAN_REMOVE = (self, data) => {
+    return { ...(0, common_1.toCamelCase)(data), user: new structures_1.User(self, data.user) };
+};
+exports.GUILD_BAN_REMOVE = GUILD_BAN_REMOVE;
+const GUILD_CREATE = (self, data) => {
+    return new structures_1.Guild(self, data);
+};
+exports.GUILD_CREATE = GUILD_CREATE;
+const GUILD_DELETE = async (_self, data) => {
+    return data;
+};
+exports.GUILD_DELETE = GUILD_DELETE;
+const GUILD_EMOJIS_UPDATE = (self, data) => {
+    return {
+        ...(0, common_1.toCamelCase)(data),
+        emojis: data.emojis.map(x => new structures_1.GuildEmoji(self, x, data.guild_id)),
+    };
+};
+exports.GUILD_EMOJIS_UPDATE = GUILD_EMOJIS_UPDATE;
+const GUILD_INTEGRATIONS_UPDATE = (_self, data) => {
+    return (0, common_1.toCamelCase)(data);
+};
+exports.GUILD_INTEGRATIONS_UPDATE = GUILD_INTEGRATIONS_UPDATE;
+const GUILD_MEMBER_ADD = (self, data) => {
+    if (!('user' in data))
+        return new structures_1.UnavailableMember(self, data, data.id, data.guild_id);
+    return new structures_1.GuildMember(self, data, data.user, data.guild_id);
+};
+exports.GUILD_MEMBER_ADD = GUILD_MEMBER_ADD;
+const GUILD_MEMBER_REMOVE = (self, data) => {
+    return { ...(0, common_1.toCamelCase)(data), user: new structures_1.User(self, data.user) };
+};
+exports.GUILD_MEMBER_REMOVE = GUILD_MEMBER_REMOVE;
+const GUILD_MEMBERS_CHUNK = (self, data) => {
+    return {
+        ...(0, common_1.toCamelCase)(data),
+        members: data.members.map(x => new structures_1.GuildMember(self, x, x.user, data.guild_id)),
+    };
+};
+exports.GUILD_MEMBERS_CHUNK = GUILD_MEMBERS_CHUNK;
+const GUILD_MEMBER_UPDATE = async (self, data) => {
+    const oldData = await self.cache.members?.get(data.user.id, data.guild_id);
+    return [new structures_1.GuildMember(self, data, data.user, data.guild_id), oldData];
+};
+exports.GUILD_MEMBER_UPDATE = GUILD_MEMBER_UPDATE;
+const GUILD_SCHEDULED_EVENT_CREATE = (_self, data) => {
+    return (0, common_1.toCamelCase)(data);
+};
+exports.GUILD_SCHEDULED_EVENT_CREATE = GUILD_SCHEDULED_EVENT_CREATE;
+const GUILD_SCHEDULED_EVENT_UPDATE = (_self, data) => {
+    return (0, common_1.toCamelCase)(data);
+};
+exports.GUILD_SCHEDULED_EVENT_UPDATE = GUILD_SCHEDULED_EVENT_UPDATE;
+const GUILD_SCHEDULED_EVENT_DELETE = (_self, data) => {
+    return (0, common_1.toCamelCase)(data);
+};
+exports.GUILD_SCHEDULED_EVENT_DELETE = GUILD_SCHEDULED_EVENT_DELETE;
+const GUILD_SCHEDULED_EVENT_USER_ADD = (_self, data) => {
+    return (0, common_1.toCamelCase)(data);
+};
+exports.GUILD_SCHEDULED_EVENT_USER_ADD = GUILD_SCHEDULED_EVENT_USER_ADD;
+const GUILD_SCHEDULED_EVENT_USER_REMOVE = (_self, data) => {
+    return (0, common_1.toCamelCase)(data);
+};
+exports.GUILD_SCHEDULED_EVENT_USER_REMOVE = GUILD_SCHEDULED_EVENT_USER_REMOVE;
+const GUILD_ROLE_CREATE = (self, data) => {
+    return new structures_1.GuildRole(self, data.role, data.guild_id);
+};
+exports.GUILD_ROLE_CREATE = GUILD_ROLE_CREATE;
+const GUILD_ROLE_DELETE = (_self, data) => {
+    return (0, common_1.toCamelCase)(data);
+};
+exports.GUILD_ROLE_DELETE = GUILD_ROLE_DELETE;
+const GUILD_ROLE_UPDATE = (self, data) => {
+    return new structures_1.GuildRole(self, data.role, data.guild_id);
+};
+exports.GUILD_ROLE_UPDATE = GUILD_ROLE_UPDATE;
+const GUILD_STICKERS_UPDATE = (self, data) => {
+    return {
+        ...(0, common_1.toCamelCase)(data),
+        stickers: data.stickers.map(x => new structures_1.Sticker(self, x)),
+    };
+};
+exports.GUILD_STICKERS_UPDATE = GUILD_STICKERS_UPDATE;
+const GUILD_UPDATE = (self, data) => {
+    return new structures_1.Guild(self, data);
+};
+exports.GUILD_UPDATE = GUILD_UPDATE;

package/lib/events/hooks/index.d.ts

@@ -0,0 +1,23 @@
+export * from './application_command';
+export * from './auto_moderation';
+export * from './channel';
+export * from './custom';
+export * from './dispatch';
+export * from './entitlement';
+export * from './guild';
+export * from './integration';
+export * from './interactions';
+export * from './invite';
+export * from './message';
+export * from './presence';
+export * from './stage';
+export * from './thread';
+export * from './typing';
+export * from './user';
+export * from './voice';
+export * from './webhook';
+import type { CamelCase } from '../../common';
+import type * as RawEvents from './index';
+export type ClientEvents = {
+    [X in keyof typeof RawEvents as CamelCase<X>]: ReturnType<(typeof RawEvents)[X]>;
+};