seyfert 1.4.0 → 2.0.0

package/lib/deps/mixer.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Mixes a class with other classes.
+ * @param args The classes to mix.
+ * @returns The mixed class.
+ */
+export declare function Mixin<T, C extends TypeClass[]>(...args: C): C[number] & T;
+export type TypeClass<InstanceType = {}, StaticType = {}> = (abstract new (...args: any[]) => InstanceType) & StaticType;
+export declare const mix: (...ingredients: TypeClass[]) => (decoratedClass: any) => any;

package/lib/deps/mixer.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mix = void 0;
+exports.Mixin = Mixin;
+/**
+ * Gets the descriptors of a class.
+ * @param c The class to get the descriptors of.
+ * @returns The descriptors of the class.
+ */
+function getDescriptors(c) {
+    let proto = c.prototype;
+    const result = [];
+    while (proto) {
+        const descriptors = Object.getOwnPropertyDescriptors(proto);
+        // @ts-expect-error this is not a function in all cases
+        if (descriptors.valueOf.configurable)
+            break;
+        result.push(descriptors);
+        proto = proto.__proto__;
+    }
+    return result;
+}
+/**
+ * Mixes a class with other classes.
+ * @param args The classes to mix.
+ * @returns The mixed class.
+ */
+function Mixin(...args) {
+    function MixedClass(...constructorArgs) {
+        for (const i of args) {
+            const descriptors = getDescriptors(i);
+            for (const j of descriptors) {
+                // @ts-expect-error
+                Object.assign(this, new j.constructor.value(...constructorArgs));
+                for (const descriptorK in j) {
+                    if (descriptorK === 'constructor')
+                        continue;
+                    if (descriptorK in MixedClass.prototype)
+                        continue;
+                    const descriptor = j[descriptorK];
+                    if (descriptor.value) {
+                        MixedClass.prototype[descriptorK] = descriptor.value;
+                        continue;
+                    }
+                    if (descriptor.get || descriptor.set) {
+                        Object.defineProperty(MixedClass.prototype, descriptorK, {
+                            get: descriptor.get,
+                            set: descriptor.set,
+                        });
+                    }
+                }
+            }
+        }
+    }
+    return MixedClass;
+}
+const mix = (...ingredients) => (decoratedClass) => {
+    ingredients.unshift(decoratedClass);
+    const mixedClass = Mixin(...ingredients);
+    Object.defineProperty(mixedClass, 'name', {
+        value: decoratedClass.name,
+        writable: false,
+    });
+    return mixedClass;
+};
+exports.mix = mix;

package/lib/events/event.d.ts

@@ -1,16 +1,17 @@
 import type { UsingClient } from '../commands';
 import type { ClientEvents } from './hooks';
-export interface DeclareEventsOptions {
-    name: `${keyof ClientEvents}`;
-    once?: boolean;
+export interface CustomEvents {
 }
 export type ClientNameEvents = Extract<keyof ClientEvents, string>;
+export type CustomEventsKeys = Extract<keyof CustomEvents, string>;
 export interface ClientDataEvent {
     name: ClientNameEvents;
     once: boolean;
 }
 export type CallbackEventHandler = {
     [K in keyof ClientEvents]: (...data: [Awaited<ClientEvents[K]>, UsingClient, number]) => unknown;
+} & {
+    [K in keyof CustomEvents]: (...data: [Parameters<CustomEvents[K]>, UsingClient, number]) => unknown;
 };
 export type EventContext<T extends {
     data: {

package/lib/events/handler.d.ts

@@ -1,26 +1,51 @@
-import type { GatewayDispatchPayload } from 'discord-api-types/v10';
+import type { GatewayDispatchPayload } from '../types';
 import type { Client, WorkerClient } from '../client';
-import { BaseHandler, type MakeRequired, type SnakeCase } from '../common';
+import { BaseHandler, type CamelCase, type MakeRequired, type SnakeCase } from '../common';
 import type { ClientEvents } from '../events/hooks';
-import type { ClientEvent, ClientNameEvents } from './event';
+import type { ClientEvent, CustomEvents, CustomEventsKeys, ClientNameEvents, EventContext } from './event';
+import type { FileLoaded } from '../commands/handler';
+import type { UsingClient } from '../commands';
 export type EventValue = MakeRequired<ClientEvent, '__filePath'> & {
     fired?: boolean;
 };
 export type GatewayEvents = Uppercase<SnakeCase<keyof ClientEvents>>;
+export type ResolveEventParams<T extends ClientNameEvents | CustomEventsKeys | GatewayEvents> = T extends CustomEventsKeys ? [...Parameters<CustomEvents[T]>, UsingClient] : T extends GatewayEvents ? EventContext<{
+    data: {
+        name: CamelCase<T>;
+    };
+}> : T extends ClientNameEvents ? EventContext<{
+    data: {
+        name: T;
+    };
+}> : never;
+export type ResolveEventRunParams<T extends ClientNameEvents | CustomEventsKeys | GatewayEvents> = T extends CustomEventsKeys ? Parameters<CustomEvents[T]> : T extends GatewayEvents ? EventContext<{
+    data: {
+        name: CamelCase<T>;
+    };
+}> : T extends ClientNameEvents ? EventContext<{
+    data: {
+        name: T;
+    };
+}> : never;
+export type EventValues = {
+    [K in CustomEventsKeys | GatewayEvents]: Omit<EventValue, 'run'> & {
+        run(...args: ResolveEventRunParams<K>): any;
+    };
+};
 export declare class EventHandler extends BaseHandler {
-    onFail: (event: GatewayEvents, err: unknown) => void;
+    protected client: Client | WorkerClient;
+    constructor(client: Client | WorkerClient);
+    onFail: (event: GatewayEvents | CustomEventsKeys, err: unknown) => void;
     protected filter: (path: string) => boolean;
-    values: Partial<Record<GatewayEvents, EventValue>>;
-    load(eventsDir: string, instances?: {
-        file: ClientEvent;
-        path: string;
-    }[]): Promise<void>;
+    values: Partial<EventValues>;
+    discordEvents: ClientNameEvents[];
+    set(events: ClientEvent[]): void;
+    load(eventsDir: string): Promise<void>;
     execute(name: GatewayEvents, ...args: [GatewayDispatchPayload, Client<true> | WorkerClient<true>, number]): Promise<void>;
-    runEvent(name: GatewayEvents, client: Client | WorkerClient, packet: any, shardId: number): Promise<void>;
-    reload(name: ClientNameEvents): Promise<any>;
-    reloadAll(): Promise<void>;
-    setHandlers({ callback }: {
-        callback: EventHandler['callback'];
-    }): void;
+    runEvent(name: GatewayEvents, client: Client | WorkerClient, packet: any, shardId: number, runCache?: boolean): Promise<void>;
+    runCustom<T extends CustomEventsKeys>(name: T, ...args: ResolveEventRunParams<T>): Promise<void>;
+    reload(name: GatewayEvents | CustomEventsKeys): Promise<any>;
+    reloadAll(stopIfFail?: boolean): Promise<void>;
+    onFile(file: FileLoaded<ClientEvent>): ClientEvent[] | undefined;
     callback: (file: ClientEvent) => ClientEvent | false;
 }

package/lib/events/handler.js

@@ -27,20 +27,47 @@ exports.EventHandler = void 0;
 const common_1 = require("../common");
 const RawEvents = __importStar(require("../events/hooks"));
 class EventHandler extends common_1.BaseHandler {
+    client;
+    constructor(client) {
+        super(client.logger);
+        this.client = client;
+    }
     onFail = (event, err) => this.logger.warn('<Client>.events.onFail', err, event);
     filter = (path) => path.endsWith('.js') || (!path.endsWith('.d.ts') && path.endsWith('.ts'));
     values = {};
-    async load(eventsDir, instances) {
-        for (const i of instances ?? (await this.loadFilesK(await this.getFiles(eventsDir)))) {
-            const instance = this.callback(i.file);
+    discordEvents = Object.keys(RawEvents).map(x => common_1.ReplaceRegex.camel(x.toLowerCase()));
+    set(events) {
+        for (const event of events) {
+            const instance = this.callback(event);
             if (!instance)
                 continue;
             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');
+                this.logger.warn('Missing event run function');
+                continue;
+            }
+            this.values[this.discordEvents.includes(instance.data.name)
+                ? common_1.ReplaceRegex.snake(instance.data.name).toUpperCase()
+                : instance.data.name] = instance;
+        }
+    }
+    async load(eventsDir) {
+        const paths = await this.loadFilesK(await this.getFiles(eventsDir));
+        for (const { events, file } of paths.map(x => ({ events: this.onFile(x.file), file: x }))) {
+            if (!events)
                 continue;
+            for (const i of events) {
+                const instance = this.callback(i);
+                if (!instance)
+                    continue;
+                if (typeof instance?.run !== 'function') {
+                    this.logger.warn(file.path.split(process.cwd()).slice(1).join(process.cwd()), 'Missing run function, use `export default {...}` syntax');
+                    continue;
+                }
+                instance.__filePath = file.path;
+                this.values[this.discordEvents.includes(instance.data.name)
+                    ? common_1.ReplaceRegex.snake(instance.data.name).toUpperCase()
+                    : instance.data.name] = instance;
             }
-            instance.__filePath = i.path;
-            this.values[common_1.ReplaceRegex.snake(instance.data.name).toUpperCase()] = instance;
         }
     }
     async execute(name, ...args) {
@@ -48,8 +75,8 @@ class EventHandler extends common_1.BaseHandler {
             case 'MESSAGE_CREATE':
                 {
                     const { d: data } = args[0];
-                    if (args[1].components?.values.has(data.interaction?.id ?? data.id)) {
-                        args[1].components.values.get(data.interaction?.id ?? data.id).messageId = data.id;
+                    if (args[1].components?.values.has(data.interaction_metadata?.id ?? data.id)) {
+                        args[1].components.values.get(data.interaction_metadata.id ?? data.id).messageId = data.id;
                     }
                 }
                 break;
@@ -75,43 +102,94 @@ class EventHandler extends common_1.BaseHandler {
                 }
                 break;
         }
-        await this.runEvent(args[0].t, args[1], args[0].d, args[2]);
+        await Promise.all([
+            this.runEvent(args[0].t, args[1], args[0].d, args[2]),
+            this.client.collectors.run(args[0].t, args[0].d, this.client),
+        ]);
     }
-    async runEvent(name, client, packet, shardId) {
+    async runEvent(name, client, packet, shardId, runCache = true) {
         const Event = this.values[name];
         if (!Event) {
-            return;
+            return runCache
+                ? this.client.cache.onPacket?.({
+                    t: name,
+                    d: packet,
+                })
+                : undefined;
         }
         try {
             if (Event.data.once && Event.fired) {
-                return;
+                return runCache
+                    ? this.client.cache.onPacket?.({
+                        t: name,
+                        d: packet,
+                    })
+                    : undefined;
             }
             Event.fired = true;
             const hook = await RawEvents[name]?.(client, packet);
-            await Event.run(...[hook, client, shardId]);
+            if (runCache)
+                await this.client.cache.onPacket?.({
+                    t: name,
+                    d: packet,
+                });
+            await Event.run(hook, client, shardId);
+        }
+        catch (e) {
+            await this.onFail(name, e);
+        }
+    }
+    async runCustom(name, ...args) {
+        const Event = this.values[name];
+        if (!Event) {
+            // @ts-expect-error working with non-existent types is hard
+            return this.client.collectors.run(name, args, this.client);
+        }
+        try {
+            if (Event.data.once && Event.fired) {
+                // @ts-expect-error working with non-existent types is hard
+                return this.client.collectors.run(name, args, this.client);
+            }
+            Event.fired = true;
+            this.logger.debug(`executed a custom event [${name}]`, Event.data.once ? 'once' : '');
+            await Promise.all([
+                // @ts-expect-error working with non-existent types is hard
+                Event.run(...args, this.client),
+                // @ts-expect-error working with non-existent types is hard
+                this.client.collectors.run(name, args, this.client),
+            ]);
         }
         catch (e) {
             await this.onFail(name, e);
         }
     }
     async reload(name) {
-        const eventName = common_1.ReplaceRegex.snake(name).toUpperCase();
-        const event = this.values[eventName];
-        if (!event)
+        if ((0, common_1.isCloudfareWorker)()) {
+            throw new Error('Reload in cloudfare worker is not supported');
+        }
+        const event = this.values[name];
+        if (!event?.__filePath)
             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;
+        this.values[name] = imported;
         return imported;
     }
-    async reloadAll() {
+    async reloadAll(stopIfFail = true) {
         for (const i in this.values) {
-            await this.reload(common_1.ReplaceRegex.camel(i));
+            try {
+                await this.reload(i);
+            }
+            catch (e) {
+                if (stopIfFail) {
+                    throw e;
+                }
+            }
         }
     }
-    setHandlers({ callback }) {
-        this.callback = callback;
+    onFile(file) {
+        return file.default ? [file.default] : undefined;
     }
     callback = (file) => file;
 }

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

@@ -1,4 +1,4 @@
-import type { GatewayApplicationCommandPermissionsUpdateDispatchData } from 'discord-api-types/v10';
+import type { GatewayApplicationCommandPermissionsUpdateDispatchData } from '../../types';
 import type { UsingClient } from '../../commands';
 export declare const APPLICATION_COMMAND_PERMISSIONS_UPDATE: (_self: UsingClient, data: GatewayApplicationCommandPermissionsUpdateDispatchData) => {
     id: string;
@@ -6,7 +6,7 @@ export declare const APPLICATION_COMMAND_PERMISSIONS_UPDATE: (_self: UsingClient
     guildId: string;
     permissions: {
         id: string;
-        type: import("discord-api-types/v10").ApplicationCommandPermissionType;
+        type: import("../../types").ApplicationCommandPermissionType;
         permission: boolean;
     }[];
 };

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

@@ -1,10 +1,9 @@
-import type { GatewayAutoModerationActionExecutionDispatchData, GatewayAutoModerationRuleCreateDispatchData, GatewayAutoModerationRuleDeleteDispatchData, GatewayAutoModerationRuleUpdateDispatchData } from 'discord-api-types/v10';
-import { AutoModerationRule } from '../../structures';
+import type { GatewayAutoModerationActionExecutionDispatchData, GatewayAutoModerationRuleCreateDispatchData, GatewayAutoModerationRuleDeleteDispatchData, GatewayAutoModerationRuleUpdateDispatchData } from '../../types';
 import type { UsingClient } from '../../commands';
 export declare const AUTO_MODERATION_ACTION_EXECUTION: (_self: UsingClient, data: GatewayAutoModerationActionExecutionDispatchData) => {
     guildId: string;
     action: {
-        type: import("discord-api-types/v10").AutoModerationActionType;
+        type: import("../../types").AutoModerationActionType;
         metadata?: {
             channelId?: string | undefined;
             durationSeconds?: number | undefined;
@@ -12,7 +11,7 @@ export declare const AUTO_MODERATION_ACTION_EXECUTION: (_self: UsingClient, data
         } | undefined;
     };
     ruleId: string;
-    ruleTriggerType: import("discord-api-types/v10").AutoModerationRuleTriggerType;
+    ruleTriggerType: import("../../types").AutoModerationRuleTriggerType;
     userId: string;
     channelId?: string | undefined;
     messageId?: string | undefined;
@@ -21,6 +20,6 @@ export declare const AUTO_MODERATION_ACTION_EXECUTION: (_self: UsingClient, data
     matchedKeyword: string | null;
     matchedContent: string | null;
 };
-export declare const AUTO_MODERATION_RULE_CREATE: (self: UsingClient, data: GatewayAutoModerationRuleCreateDispatchData) => AutoModerationRule;
-export declare const AUTO_MODERATION_RULE_DELETE: (self: UsingClient, data: GatewayAutoModerationRuleDeleteDispatchData) => AutoModerationRule;
-export declare const AUTO_MODERATION_RULE_UPDATE: (self: UsingClient, data: GatewayAutoModerationRuleUpdateDispatchData) => AutoModerationRule;
+export declare const AUTO_MODERATION_RULE_CREATE: (self: UsingClient, data: GatewayAutoModerationRuleCreateDispatchData) => import("../..").AutoModerationRule;
+export declare const AUTO_MODERATION_RULE_DELETE: (self: UsingClient, data: GatewayAutoModerationRuleDeleteDispatchData) => import("../..").AutoModerationRule;
+export declare const AUTO_MODERATION_RULE_UPDATE: (self: UsingClient, data: GatewayAutoModerationRuleUpdateDispatchData) => import("../..").AutoModerationRule;

package/lib/events/hooks/auto_moderation.js

@@ -2,20 +2,20 @@
 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 transformers_1 = require("../../client/transformers");
 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);
+    return transformers_1.Transformers.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);
+    return transformers_1.Transformers.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);
+    return transformers_1.Transformers.AutoModerationRule(self, data);
 };
 exports.AUTO_MODERATION_RULE_UPDATE = AUTO_MODERATION_RULE_UPDATE;

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

@@ -1,5 +1,5 @@
-import type { GatewayChannelCreateDispatchData, GatewayChannelDeleteDispatchData, GatewayChannelPinsUpdateDispatchData, GatewayChannelUpdateDispatchData } from 'discord-api-types/v10';
-import type { AllChannels } from '../../structures';
+import type { GatewayChannelCreateDispatchData, GatewayChannelDeleteDispatchData, GatewayChannelPinsUpdateDispatchData, GatewayChannelUpdateDispatchData } from '../../types';
+import { type AllChannels } from '../../structures';
 import type { UsingClient } from '../../commands';
 export declare const CHANNEL_CREATE: (self: UsingClient, data: GatewayChannelCreateDispatchData) => AllChannels;
 export declare const CHANNEL_DELETE: (self: UsingClient, data: GatewayChannelDeleteDispatchData) => AllChannels;

package/lib/events/hooks/channel.js

@@ -1,17 +1,14 @@
 "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 structures_1 = require("../../structures");
 const CHANNEL_CREATE = (self, data) => {
-    return (0, channels_1.default)(data, self);
+    return (0, structures_1.channelFrom)(data, self);
 };
 exports.CHANNEL_CREATE = CHANNEL_CREATE;
 const CHANNEL_DELETE = (self, data) => {
-    return (0, channels_1.default)(data, self);
+    return (0, structures_1.channelFrom)(data, self);
 };
 exports.CHANNEL_DELETE = CHANNEL_DELETE;
 const CHANNEL_PINS_UPDATE = (_self, data) => {
@@ -19,6 +16,6 @@ const CHANNEL_PINS_UPDATE = (_self, 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)];
+    return [(0, structures_1.channelFrom)(data, self), await self.cache.channels?.get(data.id)];
 };
 exports.CHANNEL_UPDATE = CHANNEL_UPDATE;

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

@@ -1,4 +1,4 @@
+import type { ClientUserStructure } from '../../client/transformers';
 import type { UsingClient } from '../../commands';
-import type { ClientUser } from '../../structures';
-export declare const BOT_READY: (_self: UsingClient, me: ClientUser) => ClientUser;
-export declare const WORKER_READY: (_self: UsingClient, me: ClientUser) => ClientUser;
+export declare const BOT_READY: (_self: UsingClient, me: ClientUserStructure) => import("../..").ClientUser;
+export declare const WORKER_READY: (_self: UsingClient, me: ClientUserStructure) => import("../..").ClientUser;

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

@@ -1,6 +1,5 @@
-import type { GatewayDispatchPayload, GatewayReadyDispatchData, GatewayResumedDispatch } from 'discord-api-types/v10';
-import { ClientUser } from '../../structures';
+import type { GatewayDispatchPayload, GatewayReadyDispatchData, GatewayResumedDispatch } from '../../types';
 import type { UsingClient } from '../../commands';
-export declare const READY: (self: UsingClient, data: GatewayReadyDispatchData) => ClientUser;
-export declare const RESUMED: (_self: UsingClient, _data: GatewayResumedDispatch['d']) => void;
+export declare const READY: (self: UsingClient, data: GatewayReadyDispatchData) => import("../..").ClientUser;
+export declare const RESUMED: (_self: UsingClient, _data: GatewayResumedDispatch["d"]) => void;
 export declare const RAW: (_self: UsingClient, data: GatewayDispatchPayload) => GatewayDispatchPayload;

package/lib/events/hooks/dispatch.js

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

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

@@ -1,38 +1,6 @@
-import type { APIEntitlement } from 'discord-api-types/v10';
+import type { APIEntitlement } from '../../types';
 import type { UsingClient } from '../../commands';
-export declare const ENTITLEMENT_CREATE: (_: UsingClient, data: APIEntitlement) => {
-    id: string;
-    skuId: string;
-    userId?: string | undefined;
-    guildId?: string | undefined;
-    applicationId: string;
-    type: import("discord-api-types/v10").EntitlementType;
-    deleted: boolean;
-    startsAt?: string | undefined;
-    endsAt?: string | undefined;
-    consumed?: boolean | undefined;
-};
-export declare const ENTITLEMENT_UPDATE: (_: UsingClient, data: APIEntitlement) => {
-    id: string;
-    skuId: string;
-    userId?: string | undefined;
-    guildId?: string | undefined;
-    applicationId: string;
-    type: import("discord-api-types/v10").EntitlementType;
-    deleted: boolean;
-    startsAt?: string | undefined;
-    endsAt?: string | undefined;
-    consumed?: boolean | undefined;
-};
-export declare const ENTITLEMENT_DELETE: (_: UsingClient, data: APIEntitlement) => {
-    id: string;
-    skuId: string;
-    userId?: string | undefined;
-    guildId?: string | undefined;
-    applicationId: string;
-    type: import("discord-api-types/v10").EntitlementType;
-    deleted: boolean;
-    startsAt?: string | undefined;
-    endsAt?: string | undefined;
-    consumed?: boolean | undefined;
-};
+import { Entitlement } from '../../structures/Entitlement';
+export declare const ENTITLEMENT_CREATE: (client: UsingClient, data: APIEntitlement) => Entitlement;
+export declare const ENTITLEMENT_UPDATE: (client: UsingClient, data: APIEntitlement) => Entitlement;
+export declare const ENTITLEMENT_DELETE: (client: UsingClient, data: APIEntitlement) => Entitlement;

package/lib/events/hooks/entitlement.js

@@ -1,16 +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);
+const Entitlement_1 = require("../../structures/Entitlement");
+const ENTITLEMENT_CREATE = (client, data) => {
+    return new Entitlement_1.Entitlement(client, data);
 };
 exports.ENTITLEMENT_CREATE = ENTITLEMENT_CREATE;
-const ENTITLEMENT_UPDATE = (_, data) => {
-    return (0, common_1.toCamelCase)(data);
+const ENTITLEMENT_UPDATE = (client, data) => {
+    return new Entitlement_1.Entitlement(client, data);
 };
 exports.ENTITLEMENT_UPDATE = ENTITLEMENT_UPDATE;
-const ENTITLEMENT_DELETE = (_, data) => {
-    return (0, common_1.toCamelCase)(data);
+const ENTITLEMENT_DELETE = (client, data) => {
+    return new Entitlement_1.Entitlement(client, data);
 };
 exports.ENTITLEMENT_DELETE = ENTITLEMENT_DELETE;