seyfert 1.5.0 → 2.0.0

package/lib/components/index.d.ts

@@ -1,13 +1,13 @@
-import { type APIMessageActionRowComponent } from 'discord-api-types/v10';
+import { type APIMessageActionRowComponent } from '../types';
 import { BaseComponent } from './BaseComponent';
-import { ButtonComponent, LinkButtonComponent } from './ButtonComponent';
+import { ButtonComponent, LinkButtonComponent, SKUButtonComponent } from './ButtonComponent';
 import { ChannelSelectMenuComponent } from './ChannelSelectMenuComponent';
 import { MentionableSelectMenuComponent } from './MentionableSelectMenuComponent';
 import { RoleSelectMenuComponent } from './RoleSelectMenuComponent';
 import { StringSelectMenuComponent } from './StringSelectMenuComponent';
 import type { TextInputComponent } from './TextInputComponent';
 import { UserSelectMenuComponent } from './UserSelectMenuComponent';
-export type MessageComponents = ButtonComponent | LinkButtonComponent | RoleSelectMenuComponent | UserSelectMenuComponent | StringSelectMenuComponent | ChannelSelectMenuComponent | MentionableSelectMenuComponent | TextInputComponent;
+export type MessageComponents = ButtonComponent | LinkButtonComponent | SKUButtonComponent | RoleSelectMenuComponent | UserSelectMenuComponent | StringSelectMenuComponent | ChannelSelectMenuComponent | MentionableSelectMenuComponent | TextInputComponent;
 export type ActionRowMessageComponents = Exclude<MessageComponents, TextInputComponent>;
 export * from './componentcommand';
 export * from './componentcontext';

package/lib/components/index.js

@@ -14,8 +14,8 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.componentFactory = void 0;
-const v10_1 = require("discord-api-types/v10");
+exports.componentFactory = componentFactory;
+const types_1 = require("../types");
 const BaseComponent_1 = require("./BaseComponent");
 const ButtonComponent_1 = require("./ButtonComponent");
 const ChannelSelectMenuComponent_1 = require("./ChannelSelectMenuComponent");
@@ -35,23 +35,25 @@ __exportStar(require("./modalcontext"), exports);
  */
 function componentFactory(component) {
     switch (component.type) {
-        case v10_1.ComponentType.Button:
-            if (component.style === v10_1.ButtonStyle.Link) {
+        case types_1.ComponentType.Button:
+            if (component.style === types_1.ButtonStyle.Link) {
                 return new ButtonComponent_1.LinkButtonComponent(component);
             }
+            if (component.style === types_1.ButtonStyle.Premium) {
+                return new ButtonComponent_1.SKUButtonComponent(component);
+            }
             return new ButtonComponent_1.ButtonComponent(component);
-        case v10_1.ComponentType.ChannelSelect:
+        case types_1.ComponentType.ChannelSelect:
             return new ChannelSelectMenuComponent_1.ChannelSelectMenuComponent(component);
-        case v10_1.ComponentType.RoleSelect:
+        case types_1.ComponentType.RoleSelect:
             return new RoleSelectMenuComponent_1.RoleSelectMenuComponent(component);
-        case v10_1.ComponentType.StringSelect:
+        case types_1.ComponentType.StringSelect:
             return new StringSelectMenuComponent_1.StringSelectMenuComponent(component);
-        case v10_1.ComponentType.UserSelect:
+        case types_1.ComponentType.UserSelect:
             return new UserSelectMenuComponent_1.UserSelectMenuComponent(component);
-        case v10_1.ComponentType.MentionableSelect:
+        case types_1.ComponentType.MentionableSelect:
             return new MentionableSelectMenuComponent_1.MentionableSelectMenuComponent(component);
         default:
             return new BaseComponent_1.BaseComponent(component);
     }
 }
-exports.componentFactory = componentFactory;

package/lib/components/modalcontext.d.ts

@@ -1,7 +1,8 @@
-import type { AllChannels, Guild, GuildMember, Message, ModalCommand, ModalSubmitInteraction, ReturnCache, WebhookMessage } from '..';
+import type { AllChannels, ModalCommand, ModalSubmitInteraction, ReturnCache } from '..';
 import type { CommandMetadata, ExtendContext, GlobalMetadata, RegisteredMiddlewares, UsingClient } from '../commands';
 import { BaseContext } from '../commands/basecontext';
 import type { InteractionCreateBodyRequest, InteractionMessageUpdateBodyRequest, ModalCreateBodyRequest, UnionToTuple, When } from '../common';
+import type { GuildMemberStructure, GuildStructure, MessageStructure, WebhookMessageStructure } from '../client/transformers';
 export interface ModalContext extends BaseContext, ExtendContext {
 }
 /**
@@ -23,24 +24,24 @@ export declare class ModalContext<M extends keyof RegisteredMiddlewares = never>
     get customId(): string;
     get components(): {
         components: {
-            type: import("discord-api-types/v10").ComponentType;
+            type: import("../types").ComponentType;
             customId: string;
             value: string;
         }[];
-        type: import("discord-api-types/v10").ComponentType.ActionRow;
+        type: import("../types").ComponentType.ActionRow;
     }[];
     /**
      * Gets the language object for the interaction's locale.
      */
     get t(): import("..").__InternalParseLocale<import("..").DefaultLocale> & {
-        get(locale?: string | undefined): import("..").DefaultLocale;
+        get(locale?: string): import("..").DefaultLocale;
     };
     /**
      * Writes a response to the interaction.
      * @param body - The body of the response.
      * @param fetchReply - Whether to fetch the reply or not.
      */
-    write<FR extends boolean = false>(body: InteractionCreateBodyRequest, fetchReply?: FR): Promise<When<FR, WebhookMessage, void>>;
+    write<FR extends boolean = false>(body: InteractionCreateBodyRequest, fetchReply?: FR): Promise<When<FR, import("..").WebhookMessage, void>>;
     /**
      * Defers the reply to the interaction.
      * @param ephemeral - Whether the reply should be ephemeral or not.
@@ -50,13 +51,13 @@ export declare class ModalContext<M extends keyof RegisteredMiddlewares = never>
      * Edits the response of the interaction.
      * @param body - The updated body of the response.
      */
-    editResponse(body: InteractionMessageUpdateBodyRequest): Promise<WebhookMessage>;
+    editResponse(body: InteractionMessageUpdateBodyRequest): Promise<import("..").WebhookMessage>;
     /**
      * Edits the response or replies to the interaction.
      * @param body - The body of the response or updated body of the interaction.
      * @param fetchReply - Whether to fetch the reply or not.
      */
-    editOrReply<FR extends boolean = false>(body: InteractionCreateBodyRequest | InteractionMessageUpdateBodyRequest, fetchReply?: FR): Promise<When<FR, WebhookMessage | Message, void | WebhookMessage | Message>>;
+    editOrReply<FR extends boolean = false>(body: InteractionCreateBodyRequest | InteractionMessageUpdateBodyRequest, fetchReply?: FR): Promise<When<FR, WebhookMessageStructure | MessageStructure, void | WebhookMessageStructure | MessageStructure>>;
     /**
      * Deletes the response of the interaction.
      * @returns A promise that resolves when the response is deleted.
@@ -75,15 +76,15 @@ export declare class ModalContext<M extends keyof RegisteredMiddlewares = never>
      * @param mode - The mode to fetch the member.
      * @returns A promise that resolves to the bot member.
      */
-    me(mode?: 'rest' | 'flow'): Promise<GuildMember>;
-    me(mode?: 'cache'): ReturnCache<GuildMember | undefined>;
+    me(mode?: 'rest' | 'flow'): Promise<GuildMemberStructure>;
+    me(mode?: 'cache'): ReturnCache<GuildMemberStructure | undefined>;
     /**
      * Gets the guild of the interaction.
      * @param mode - The mode to fetch the guild.
      * @returns A promise that resolves to the guild.
      */
-    guild(mode?: 'rest' | 'flow'): Promise<Guild<'cached' | 'api'> | undefined>;
-    guild(mode?: 'cache'): ReturnCache<Guild<'cached'> | undefined>;
+    guild(mode?: 'rest' | 'flow'): Promise<GuildStructure<'cached' | 'api'> | undefined>;
+    guild(mode?: 'cache'): ReturnCache<GuildStructure<'cached'> | undefined>;
     /**
      * Gets the ID of the guild of the interaction.
      */

package/lib/components/modalcontext.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ModalContext = void 0;
-const v10_1 = require("discord-api-types/v10");
+const types_1 = require("../types");
 const basecontext_1 = require("../commands/basecontext");
 /**
  * Represents a context for interacting with components in a Discord bot.
@@ -48,7 +48,7 @@ class ModalContext extends basecontext_1.BaseContext {
      * @param ephemeral - Whether the reply should be ephemeral or not.
      */
     deferReply(ephemeral = false) {
-        return this.interaction.deferReply(ephemeral ? v10_1.MessageFlags.Ephemeral : undefined);
+        return this.interaction.deferReply(ephemeral ? types_1.MessageFlags.Ephemeral : undefined);
     }
     /**
      * Edits the response of the interaction.

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/handler.d.ts

@@ -1,29 +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, CustomEvents, CustomEventsKeys } 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 {
     protected client: Client | WorkerClient;
     constructor(client: Client | WorkerClient);
     onFail: (event: GatewayEvents | CustomEventsKeys, err: unknown) => void;
     protected filter: (path: string) => boolean;
-    values: Partial<Record<GatewayEvents | CustomEventsKeys, 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>;
-    runCustom<T extends CustomEventsKeys>(name: T, ...args: Parameters<CustomEvents[T]>): Promise<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>;
-    setHandlers({ callback }: {
-        callback: EventHandler['callback'];
-    }): void;
+    onFile(file: FileLoaded<ClientEvent>): ClientEvent[] | undefined;
     callback: (file: ClientEvent) => ClientEvent | false;
 }

package/lib/events/handler.js

@@ -35,29 +35,48 @@ class EventHandler extends common_1.BaseHandler {
     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) {
-        const discordEvents = Object.keys(RawEvents).map(x => common_1.ReplaceRegex.camel(x.toLowerCase()));
-        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;
             }
-            instance.__filePath = i.path;
-            this.values[discordEvents.includes(instance.data.name)
+            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;
+            }
+        }
+    }
     async execute(name, ...args) {
         switch (name) {
             case 'MESSAGE_CREATE':
                 {
                     const { d: data } = args[0];
                     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;
+                        args[1].components.values.get(data.interaction_metadata.id ?? data.id).messageId = data.id;
                     }
                 }
                 break;
@@ -85,28 +104,32 @@ class EventHandler extends common_1.BaseHandler {
         }
         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.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 this.client.cache.onPacket({
-                t: name,
-                d: packet,
-            });
+            return runCache
+                ? this.client.cache.onPacket?.({
+                    t: name,
+                    d: packet,
+                })
+                : undefined;
         }
         try {
             if (Event.data.once && Event.fired) {
-                return this.client.cache.onPacket({
-                    t: name,
-                    d: packet,
-                });
+                return runCache
+                    ? this.client.cache.onPacket?.({
+                        t: name,
+                        d: packet,
+                    })
+                    : undefined;
             }
             Event.fired = true;
             const hook = await RawEvents[name]?.(client, packet);
-            if (name !== 'RAW')
-                await this.client.cache.onPacket({
+            if (runCache)
+                await this.client.cache.onPacket?.({
                     t: name,
                     d: packet,
                 });
@@ -119,21 +142,31 @@ class EventHandler extends common_1.BaseHandler {
     async runCustom(name, ...args) {
         const Event = this.values[name];
         if (!Event) {
-            return this.client.collectors.run(name, args);
+            // @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) {
-                return this.client.collectors.run(name, args);
+                // @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([Event.run(args, this.client), this.client.collectors.run(name, args)]);
+            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) {
+        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;
@@ -155,8 +188,8 @@ class EventHandler extends common_1.BaseHandler {
             }
         }
     }
-    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;