seyfert 1.0.1 → 1.1.0

package/lib/common/shorters/webhook.js

@@ -5,65 +5,120 @@ const builders_1 = require("../../builders");
 const structures_1 = require("../../structures");
 const base_1 = require("./base");
 class WebhookShorter extends base_1.BaseShorter {
-    get webhooks() {
-        return {
-            delete: (webhookId, { token, reason }) => {
-                if (token) {
-                    return this.client.proxy.webhooks(webhookId)(token).delete({ reason, auth: false });
-                }
-                return this.client.proxy.webhooks(webhookId).delete({ reason });
-            },
-            edit: (webhookId, body, { token, reason }) => {
-                if (token) {
-                    return this.client.proxy.webhooks(webhookId)(token).patch({ body, reason, auth: false });
-                }
-                return this.client.proxy.webhooks(webhookId).patch({ body, reason });
-            },
-            fetch: async (webhookId, token) => {
-                let webhook;
-                if (token) {
-                    webhook = await this.client.proxy.webhooks(webhookId)(token).get({ auth: false });
-                }
-                else {
-                    webhook = await this.client.proxy.webhooks(webhookId).get();
-                }
-                return new structures_1.Webhook(this.client, webhook);
-            },
-            messages: this.messages,
-        };
+    async create(channelId, body) {
+        const webhook = await this.client.proxy.channels(channelId).webhooks.post({
+            body,
+        });
+        return new structures_1.Webhook(this.client, webhook);
     }
-    get messages() {
-        return {
-            write: async (webhookId, token, { body: data, ...payload }) => {
-                const { files, ...body } = data;
-                const transformedBody = structures_1.MessagesMethods.transformMessageBody(body);
-                const parsedFiles = files ? await (0, builders_1.resolveFiles)(files) : [];
-                return this.client.proxy
-                    .webhooks(webhookId)(token)
-                    .post({ ...payload, files: parsedFiles, body: transformedBody })
-                    .then(m => (m?.id ? new structures_1.WebhookMessage(this.client, m, webhookId, token) : null));
-            },
-            edit: async (webhookId, token, { messageId, body: data, ...json }) => {
-                const { files, ...body } = data;
-                const transformedBody = structures_1.MessagesMethods.transformMessageBody(body);
-                const parsedFiles = files ? await (0, builders_1.resolveFiles)(files) : [];
-                return this.client.proxy
-                    .webhooks(webhookId)(token)
-                    .messages(messageId)
-                    .patch({ ...json, auth: false, files: parsedFiles, body: transformedBody })
-                    .then(m => new structures_1.WebhookMessage(this.client, m, webhookId, token));
-            },
-            delete: async (webhookId, token, messageId, reason) => {
-                return this.client.proxy.webhooks(webhookId)(token).messages(messageId).delete({ reason });
-            },
-            fetch: async (webhookId, token, messageId, threadId) => {
-                const message = await this.client.proxy
-                    .webhooks(webhookId)(token)
-                    .messages(messageId)
-                    .get({ auth: false, query: { threadId } });
-                return message ? new structures_1.WebhookMessage(this.client, message, webhookId, token) : undefined;
-            },
-        };
+    /**
+     * Deletes a webhook.
+     * @param webhookId The ID of the webhook.
+     * @param options The optional parameters including token and reason.
+     * @returns A Promise that resolves when the webhook is deleted.
+     */
+    delete(webhookId, options) {
+        if (options.token) {
+            return this.client.proxy.webhooks(webhookId)(options.token).delete({ reason: options.reason, auth: false });
+        }
+        return this.client.proxy.webhooks(webhookId).delete({ reason: options.reason });
+    }
+    /**
+     * Edits a webhook.
+     * @param webhookId The ID of the webhook.
+     * @param body The data to update the webhook with.
+     * @param options The optional parameters including token and reason.
+     * @returns A Promise that resolves when the webhook is edited.
+     */
+    edit(webhookId, body, options) {
+        if (options.token) {
+            return this.client.proxy.webhooks(webhookId)(options.token).patch({ body, reason: options.reason, auth: false });
+        }
+        return this.client.proxy.webhooks(webhookId).patch({ body, reason: options.reason });
+    }
+    /**
+     * Fetches a webhook.
+     * @param webhookId The ID of the webhook.
+     * @param token The token of the webhook (optional).
+     * @returns A Promise that resolves to the fetched webhook.
+     */
+    async fetch(webhookId, token) {
+        let webhook;
+        if (token) {
+            webhook = await this.client.proxy.webhooks(webhookId)(token).get({ auth: false });
+        }
+        else {
+            webhook = await this.client.proxy.webhooks(webhookId).get();
+        }
+        return new structures_1.Webhook(this.client, webhook);
+    }
+    /**
+     * Writes a message using the webhook.
+     * @param webhookId The ID of the webhook.
+     * @param token The token of the webhook.
+     * @param data The data for writing the message.
+     * @returns A Promise that resolves to the written message.
+     */
+    async writeMessage(webhookId, token, { body: data, ...payload }) {
+        const { files, ...body } = data;
+        const transformedBody = structures_1.MessagesMethods.transformMessageBody(body);
+        const parsedFiles = files ? await (0, builders_1.resolveFiles)(files) : [];
+        return this.client.proxy
+            .webhooks(webhookId)(token)
+            .post({ ...payload, files: parsedFiles, body: transformedBody })
+            .then(m => (m?.id ? new structures_1.WebhookMessage(this.client, m, webhookId, token) : null));
+    }
+    /**
+     * Edits a message sent by the webhook.
+     * @param webhookId The ID of the webhook.
+     * @param token The token of the webhook.
+     * @param messageId The ID of the message to edit.
+     * @param data The data for editing the message.
+     * @returns A Promise that resolves to the edited message.
+     */
+    async editMessage(webhookId, token, { messageId, body: data, ...json }) {
+        const { files, ...body } = data;
+        const transformedBody = structures_1.MessagesMethods.transformMessageBody(body);
+        const parsedFiles = files ? await (0, builders_1.resolveFiles)(files) : [];
+        return this.client.proxy
+            .webhooks(webhookId)(token)
+            .messages(messageId)
+            .patch({ ...json, auth: false, files: parsedFiles, body: transformedBody })
+            .then(m => new structures_1.WebhookMessage(this.client, m, webhookId, token));
+    }
+    /**
+     * Deletes a message sent by the webhook.
+     * @param webhookId The ID of the webhook.
+     * @param token The token of the webhook.
+     * @param messageId The ID of the message to delete.
+     * @param reason The reason for deleting the message.
+     * @returns A Promise that resolves when the message is deleted.
+     */
+    deleteMessage(webhookId, token, messageId, reason) {
+        return this.client.proxy.webhooks(webhookId)(token).messages(messageId).delete({ reason });
+    }
+    /**
+     * Fetches a message sent by the webhook.
+     * @param webhookId The ID of the webhook.
+     * @param token The token of the webhook.
+     * @param messageId The ID of the message to fetch.
+     * @param threadId The ID of the thread the message belongs to.
+     * @returns A Promise that resolves to the fetched message, or undefined if not found.
+     */
+    async fetchMessage(webhookId, token, messageId, threadId) {
+        const message = await this.client.proxy
+            .webhooks(webhookId)(token)
+            .messages(messageId)
+            .get({ auth: false, query: { threadId } });
+        return message ? new structures_1.WebhookMessage(this.client, message, webhookId, token) : undefined;
+    }
+    async listFromGuild(guildId) {
+        const webhooks = await this.client.proxy.guilds(guildId).webhooks.get();
+        return webhooks.map(webhook => new structures_1.Webhook(this.client, webhook));
+    }
+    async listFromChannel(channelId) {
+        const webhooks = await this.client.proxy.channels(channelId).webhooks.get();
+        return webhooks.map(webhook => new structures_1.Webhook(this.client, webhook));
     }
 }
 exports.WebhookShorter = WebhookShorter;

package/lib/common/types/options.d.ts

@@ -1,9 +1,9 @@
 import type { Identify } from '..';
 import type { ImageURLOptions } from '../../api';
-import type { BaseClient } from '../../client/base';
+import type { UsingClient } from '../../commands';
 export type ImageOptions = ImageURLOptions;
 export type MethodContext<T = {}> = Identify<{
-    client: BaseClient;
+    client: UsingClient;
 } & T>;
 export type MessageWebhookPayload<Body, Extra = {}> = Identify<{
     body: Body;

package/lib/components/handler.d.ts

@@ -1,33 +1,36 @@
 /// <reference types="node" />
 import type { ComponentCallback, ListenerOptions, ModalSubmitCallback } from '../builders/types';
-import type { BaseClient } from '../client/base';
 import { LimitedCollection } from '../collection';
+import type { UsingClient } from '../commands';
 import { BaseHandler, type Logger, type OnFailCallback } from '../common';
 import type { ComponentInteraction, ModalSubmitInteraction } from '../structures';
 import { ComponentCommand, ModalCommand } from './command';
 type COMPONENTS = {
-    components: Partial<Record<string, ComponentCallback>>;
+    components: {
+        match: string | string[] | RegExp;
+        callback: ComponentCallback;
+    }[];
     options?: ListenerOptions;
     messageId?: string;
     idle?: NodeJS.Timeout;
     timeout?: NodeJS.Timeout;
-    __run: (customId: string, callback: ComponentCallback) => any;
+    __run: (customId: string | string[] | RegExp, callback: ComponentCallback) => any;
 };
 export declare class ComponentHandler extends BaseHandler {
-    protected client: BaseClient;
+    protected client: UsingClient;
     protected onFail?: OnFailCallback;
     readonly values: Map<string, COMPONENTS>;
     readonly modals: LimitedCollection<string, ModalSubmitCallback>;
     readonly commands: (ComponentCommand | ModalCommand)[];
     protected filter: (path: string) => boolean;
-    constructor(logger: Logger, client: BaseClient);
+    constructor(logger: Logger, client: UsingClient);
     set OnFail(cb: OnFailCallback);
     createComponentCollector(messageId: string, options?: ListenerOptions): {
-        run: (customId: string, callback: ComponentCallback) => any;
+        run: (customId: string | RegExp | string[], callback: ComponentCallback) => any;
         stop: (reason?: string) => void;
     };
     onComponent(id: string, interaction: ComponentInteraction): Promise<void>;
-    hasComponent(id: string, customId: string): ComponentCallback | undefined;
+    hasComponent(id: string, customId: string): boolean | undefined;
     resetTimeouts(id: string): void;
     hasModal(interaction: ModalSubmitInteraction): boolean;
     onModalSubmit(interaction: ModalSubmitInteraction): any;

package/lib/components/handler.js

@@ -21,7 +21,7 @@ class ComponentHandler extends common_1.BaseHandler {
     }
     createComponentCollector(messageId, options = {}) {
         this.values.set(messageId, {
-            components: {},
+            components: [],
             options,
             idle: options.idle
                 ? setTimeout(() => {
@@ -41,7 +41,10 @@ class ComponentHandler extends common_1.BaseHandler {
                 : undefined,
             __run: (customId, callback) => {
                 if (this.values.has(messageId)) {
-                    this.values.get(messageId).components[customId] = callback;
+                    this.values.get(messageId).components.push({
+                        callback,
+                        match: customId,
+                    });
                 }
             },
         });
@@ -57,7 +60,13 @@ class ComponentHandler extends common_1.BaseHandler {
     }
     async onComponent(id, interaction) {
         const row = this.values.get(id);
-        const component = row?.components?.[interaction.customId];
+        const component = row?.components?.find(x => {
+            if (typeof x.match === 'string')
+                return x.match === interaction.customId;
+            if (Array.isArray(x.match))
+                return x.match.includes(interaction.customId);
+            return interaction.customId.match(x.match);
+        });
         if (!component)
             return;
         if (row.options?.filter) {
@@ -65,7 +74,7 @@ class ComponentHandler extends common_1.BaseHandler {
                 return;
         }
         row.idle?.refresh();
-        await component(interaction, reason => {
+        await component.callback(interaction, reason => {
             row.options?.onStop?.(reason ?? 'stop');
             this.deleteValue(id);
         }, () => {
@@ -73,7 +82,13 @@ class ComponentHandler extends common_1.BaseHandler {
         });
     }
     hasComponent(id, customId) {
-        return this.values.get(id)?.components?.[customId];
+        return this.values.get(id)?.components?.some(x => {
+            if (typeof x.match === 'string')
+                return x.match === customId;
+            if (Array.isArray(x.match))
+                return x.match.includes(customId);
+            return customId.match(x.match);
+        });
     }
     resetTimeouts(id) {
         const listener = this.values.get(id);

package/lib/index.d.ts

@@ -1,6 +1,8 @@
 import type { InternalRuntimeConfig, InternalRuntimeConfigHTTP, RuntimeConfig, RuntimeConfigHTTP } from './client/base';
+import type { InferWithPrefix } from './commands';
+import { type When } from './common';
 import type { ClientNameEvents, EventContext } from './events';
-import type { ChatInputCommandInteraction, MessageCommandInteraction, UserCommandInteraction } from './structures';
+import type { ChatInputCommandInteraction, Message, MessageCommandInteraction, UserCommandInteraction } from './structures';
 export { Logger, PermissionFlagsBits, PermissionStrings, Watcher } from './common';
 export { Collection, LimitedCollection } from './collection';
 export * from './api';
@@ -79,4 +81,4 @@ export declare const config: {
  * 	};
  * });
  */
-export declare function extendContext<T extends {}>(cb: (interaction: ChatInputCommandInteraction | UserCommandInteraction | MessageCommandInteraction) => T): (interaction: ChatInputCommandInteraction | UserCommandInteraction | MessageCommandInteraction) => T;
+export declare function extendContext<T extends {}>(cb: (interaction: ChatInputCommandInteraction | UserCommandInteraction | MessageCommandInteraction | When<InferWithPrefix, Message, never>) => T): (interaction: ChatInputCommandInteraction | UserCommandInteraction | MessageCommandInteraction | When<InferWithPrefix, Message, never>) => T;

package/lib/langs/handler.js

@@ -13,8 +13,13 @@ class LangsHandler extends common_1.BaseHandler {
     }
     getKey(lang, message) {
         let value = this.values[lang];
-        for (const i of message.split('.')) {
-            value = value[i];
+        try {
+            for (const i of message.split('.')) {
+                value = value[i];
+            }
+        }
+        catch {
+            return;
         }
         if (typeof value !== 'string') {
             return;

package/lib/structures/AutoModerationRule.d.ts

@@ -1,10 +1,10 @@
-import type { BaseClient } from '../client/base';
+import type { UsingClient } from '../commands';
 import type { APIAutoModerationRule, MethodContext, ObjectToLower, RESTPatchAPIAutoModerationRuleJSONBody, RESTPostAPIAutoModerationRuleJSONBody } from '../common';
 import { DiscordBase } from './extra/DiscordBase';
 export interface AutoModerationRule extends ObjectToLower<APIAutoModerationRule> {
 }
 export declare class AutoModerationRule extends DiscordBase<APIAutoModerationRule> {
-    constructor(client: BaseClient, data: APIAutoModerationRule);
+    constructor(client: UsingClient, data: APIAutoModerationRule);
     fetchCreator(force?: boolean): Promise<import("./GuildMember").GuildMember>;
     guild(force?: boolean): Promise<import("./Guild").Guild<"cached"> | import("./Guild").Guild<"api">>;
     fetch(): Promise<APIAutoModerationRule>;

package/lib/structures/ClientUser.d.ts

@@ -1,10 +1,10 @@
-import type { BaseClient } from '../client/base';
+import type { UsingClient } from '../commands';
 import type { GatewayReadyDispatchData, RESTPatchAPICurrentUserJSONBody } from '../common';
 import { User } from './User';
 export declare class ClientUser extends User {
     application: GatewayReadyDispatchData['application'];
     bot: boolean;
-    constructor(client: BaseClient, data: GatewayReadyDispatchData['user'], application: GatewayReadyDispatchData['application']);
+    constructor(client: UsingClient, data: GatewayReadyDispatchData['user'], application: GatewayReadyDispatchData['application']);
     fetch(): Promise<ClientUser>;
     edit(body: RESTPatchAPICurrentUserJSONBody): Promise<ClientUser>;
 }

package/lib/structures/Guild.d.ts

@@ -1,4 +1,4 @@
-import type { BaseClient } from '../client/base';
+import type { UsingClient } from '../commands';
 import type { APIGuild, GatewayGuildCreateDispatchData, ObjectToLower } from '../common';
 import type { StructPropState, StructStates, ToClass } from '../common/types/util';
 import { GuildEmoji } from './GuildEmoji';
@@ -15,7 +15,7 @@ export declare class Guild<State extends StructStates = 'api'> extends Guild_bas
     memberCount: StructPropState<number, State, 'create'>;
     large: StructPropState<boolean, State, 'create'>;
     unavailable?: StructPropState<boolean, State, 'create'>;
-    constructor(client: BaseClient, data: APIGuild | GatewayGuildCreateDispatchData);
+    constructor(client: UsingClient, data: APIGuild | GatewayGuildCreateDispatchData);
     webhooks: {
         list: () => Promise<import("./Webhook").Webhook[]>;
     };

package/lib/structures/GuildEmoji.d.ts

@@ -1,12 +1,12 @@
 import type { BaseImageURLOptions } from '../api';
-import type { BaseClient } from '../client/base';
-import type { APIEmoji, GuildShorter, MethodContext, ObjectToLower, RESTPatchAPIChannelJSONBody, RESTPatchAPIGuildEmojiJSONBody } from '../common';
+import type { UsingClient } from '../commands';
+import type { APIEmoji, EmojiShorter, MethodContext, ObjectToLower, RESTPatchAPIChannelJSONBody, RESTPatchAPIGuildEmojiJSONBody } from '../common';
 import { DiscordBase } from './extra/DiscordBase';
 export interface GuildEmoji extends DiscordBase, ObjectToLower<Omit<APIEmoji, 'id'>> {
 }
 export declare class GuildEmoji extends DiscordBase {
     readonly guildId: string;
-    constructor(client: BaseClient, data: APIEmoji, guildId: string);
+    constructor(client: UsingClient, data: APIEmoji, guildId: string);
     guild(force?: boolean): Promise<import("./Guild").Guild<"cached"> | import("./Guild").Guild<"api">> | undefined;
     edit(body: RESTPatchAPIChannelJSONBody, reason?: string): Promise<GuildEmoji>;
     delete(reason?: string): Promise<void>;
@@ -22,7 +22,7 @@ export declare class GuildEmoji extends DiscordBase {
         guildId: string;
     }>): {
         edit: (emojiId: string, body: RESTPatchAPIGuildEmojiJSONBody, reason?: string) => Promise<GuildEmoji>;
-        create: (body: Parameters<GuildShorter['emojis']['create']>[1]) => Promise<void>;
+        create: (body: Parameters<EmojiShorter['create']>[1]) => Promise<void>;
         fetch: (emojiId: string, force?: boolean) => Promise<GuildEmoji>;
         list: (force?: boolean) => Promise<GuildEmoji[]>;
     };

package/lib/structures/GuildEmoji.js

@@ -14,13 +14,13 @@ class GuildEmoji extends DiscordBase_1.DiscordBase {
         return this.client.guilds.fetch(this.guildId, force);
     }
     edit(body, reason) {
-        return this.client.guilds.emojis.edit(this.guildId, this.id, body, reason);
+        return this.client.emojis.edit(this.guildId, this.id, body, reason);
     }
     delete(reason) {
-        return this.client.guilds.emojis.delete(this.guildId, this.id, reason);
+        return this.client.emojis.delete(this.guildId, this.id, reason);
     }
     fetch(force = false) {
-        return this.client.guilds.emojis.fetch(this.guildId, this.id, force);
+        return this.client.emojis.fetch(this.guildId, this.id, force);
     }
     url(options) {
         return this.rest.cdn.emoji(this.id, options);
@@ -37,10 +37,10 @@ class GuildEmoji extends DiscordBase_1.DiscordBase {
     }
     static methods({ client, guildId }) {
         return {
-            edit: (emojiId, body, reason) => client.guilds.emojis.edit(guildId, emojiId, body, reason),
-            create: (body) => client.guilds.emojis.create(guildId, body),
-            fetch: (emojiId, force = false) => client.guilds.emojis.fetch(guildId, emojiId, force),
-            list: (force = false) => client.guilds.emojis.list(guildId, force),
+            edit: (emojiId, body, reason) => client.emojis.edit(guildId, emojiId, body, reason),
+            create: (body) => client.emojis.create(guildId, body),
+            fetch: (emojiId, force = false) => client.emojis.fetch(guildId, emojiId, force),
+            list: (force = false) => client.emojis.list(guildId, force),
         };
     }
 }

package/lib/structures/GuildMember.d.ts

@@ -1,7 +1,7 @@
 import type { APIGuildMember, APIInteractionDataResolvedGuildMember, APIUser, GatewayGuildMemberAddDispatchData, GatewayGuildMemberUpdateDispatchData, MakeRequired, MessageCreateBodyRequest, ObjectToLower, RESTGetAPIGuildMembersQuery, RESTGetAPIGuildMembersSearchQuery, RESTPatchAPIGuildMemberJSONBody, RESTPutAPIGuildBanJSONBody, RESTPutAPIGuildMemberJSONBody, ToClass } from '../common';
 import { DiscordBase } from './extra/DiscordBase';
 export type GuildMemberData = APIGuildMember | GatewayGuildMemberUpdateDispatchData | GatewayGuildMemberAddDispatchData | APIInteractionDataResolvedGuildMember;
-import type { BaseClient } from '../client/base';
+import type { UsingClient } from '../commands';
 import type { ImageOptions, MethodContext } from '../common/types/options';
 import type { GuildMemberResolvable } from '../common/types/resolvables';
 import { User } from './User';
@@ -17,7 +17,7 @@ export declare class BaseGuildMember extends DiscordBase {
     private _roles;
     joinedTimestamp?: number;
     communicationDisabledUntilTimestamp?: number | null;
-    constructor(client: BaseClient, data: GuildMemberData, id: string, 
+    constructor(client: UsingClient, data: GuildMemberData, id: string, 
     /** the choosen guild id */
     guildId: string);
     guild(force?: boolean): Promise<import("./Guild").Guild<"cached"> | import("./Guild").Guild<"api">>;
@@ -39,8 +39,8 @@ export declare class BaseGuildMember extends DiscordBase {
     private patch;
     get roles(): {
         values: readonly string[];
-        add: (id: string) => Promise<void>;
-        remove: (id: string) => Promise<void>;
+        add: (id: string) => void;
+        remove: (id: string) => Promise<never>;
         permissions: () => Promise<PermissionsBitField>;
     };
     static methods({ client, guildId }: MethodContext<{
@@ -67,7 +67,7 @@ export declare class GuildMember extends BaseGuildMember {
     /** the choosen guild id */
     readonly guildId: string;
     user: User;
-    constructor(client: BaseClient, data: GuildMemberData, user: APIUser | User, 
+    constructor(client: UsingClient, data: GuildMemberData, user: APIUser | User, 
     /** the choosen guild id */
     guildId: string);
     get tag(): string;
@@ -97,7 +97,7 @@ declare const InteractionGuildMember_base: ToClass<Omit<GuildMember, "deaf" | "m
  */
 export declare class InteractionGuildMember extends InteractionGuildMember_base {
     permissions: PermissionsBitField;
-    constructor(client: BaseClient, data: APIInteractionDataResolvedGuildMember, user: APIUser | User, 
+    constructor(client: UsingClient, data: APIInteractionDataResolvedGuildMember, user: APIUser | User, 
     /** the choosen guild id */
     guildId: string);
 }

package/lib/structures/GuildMember.js

@@ -55,8 +55,8 @@ class BaseGuildMember extends DiscordBase_1.DiscordBase {
     get roles() {
         return {
             values: Object.freeze(this._roles),
-            add: (id) => this.client.members.roles.add(this.guildId, this.id, id),
-            remove: (id) => this.client.members.roles.remove(this.guildId, this.id, id),
+            add: (id) => this.client.members.addRole(this.guildId, this.id, id),
+            remove: (id) => this.client.members.removeRole(this.guildId, this.id, id),
             permissions: async () => new Permissions_1.PermissionsBitField(((await this.cache.roles?.bulk(this.roles.values)) ?? [])
                 .filter(x => x)
                 .map(x => BigInt(x.permissions.bits))),

package/lib/structures/GuildPreview.d.ts

@@ -1,4 +1,4 @@
-import type { BaseClient } from '../client/base';
+import type { UsingClient } from '../commands';
 import type { APIGuildPreview } from '../common';
 import { AnonymousGuild } from './AnonymousGuild';
 /**
@@ -6,5 +6,5 @@ import { AnonymousGuild } from './AnonymousGuild';
  * @link https://discord.com/developers/docs/resources/guild#guild-preview-object
  */
 export declare class GuildPreview extends AnonymousGuild {
-    constructor(client: BaseClient, data: APIGuildPreview);
+    constructor(client: UsingClient, data: APIGuildPreview);
 }

package/lib/structures/GuildRole.d.ts

@@ -1,4 +1,4 @@
-import type { BaseClient } from '../client/base';
+import type { UsingClient } from '../commands';
 import type { APIRole, MethodContext, ObjectToLower, RESTPatchAPIGuildRoleJSONBody, RESTPatchAPIGuildRolePositionsJSONBody, RESTPostAPIGuildRoleJSONBody } from '../common';
 import { DiscordBase } from './extra/DiscordBase';
 import { PermissionsBitField } from './extra/Permissions';
@@ -7,7 +7,7 @@ export interface GuildRole extends DiscordBase, ObjectToLower<Omit<APIRole, 'per
 export declare class GuildRole extends DiscordBase {
     readonly guildId: string;
     permissions: PermissionsBitField;
-    constructor(client: BaseClient, data: APIRole, guildId: string);
+    constructor(client: UsingClient, data: APIRole, guildId: string);
     guild(force?: boolean): Promise<import("./Guild").Guild<"cached"> | import("./Guild").Guild<"api">> | undefined;
     edit(body: RESTPatchAPIGuildRoleJSONBody, reason?: string): Promise<any>;
     delete(reason?: string): Promise<void | undefined>;

package/lib/structures/GuildTemplate.d.ts

@@ -1,10 +1,10 @@
-import type { BaseClient } from '../client/base';
+import type { UsingClient } from '../commands';
 import type { APITemplate, MethodContext, ObjectToLower, RESTPatchAPIGuildTemplateJSONBody, RESTPostAPIGuildTemplatesJSONBody } from '../common';
 import { Base } from './extra/Base';
 export interface GuildTemplate extends Base, ObjectToLower<APITemplate> {
 }
 export declare class GuildTemplate extends Base {
-    constructor(client: BaseClient, data: APITemplate);
+    constructor(client: UsingClient, data: APITemplate);
     guild(force?: boolean): Promise<import("./Guild").Guild<"cached"> | import("./Guild").Guild<"api">>;
     fetch(): Promise<APITemplate>;
     sync(): Promise<APITemplate>;

package/lib/structures/Interaction.d.ts

@@ -1,4 +1,3 @@
-import type { BaseClient } from '../client/base';
 import { OptionResolver, type UsingClient } from '../commands';
 import type { APIApplicationCommandAutocompleteInteraction, APIApplicationCommandInteraction, APIBaseInteraction, APIChatInputApplicationCommandInteraction, APIChatInputApplicationCommandInteractionData, APICommandAutocompleteInteractionResponseCallbackData, APIInteraction, APIInteractionResponse, APIInteractionResponseChannelMessageWithSource, APIInteractionResponseDeferredChannelMessageWithSource, APIInteractionResponseDeferredMessageUpdate, APIInteractionResponsePong, APIInteractionResponseUpdateMessage, APIMessageApplicationCommandInteraction, APIMessageApplicationCommandInteractionData, APIMessageButtonInteractionData, APIMessageComponentInteraction, APIMessageComponentSelectMenuInteraction, APIMessageStringSelectInteractionData, APIModalSubmission, APIModalSubmitInteraction, APIUserApplicationCommandInteraction, APIUserApplicationCommandInteractionData, GatewayInteractionCreateDispatchData, MessageFlags, ObjectToLower, OmitInsert, RESTPostAPIInteractionCallbackJSONBody, ToClass, When } from '../common';
 import { ApplicationCommandType, ComponentType, InteractionResponseType, InteractionType } from '../common';
@@ -33,7 +32,7 @@ export declare class BaseInteraction<FromGuild extends boolean = boolean, Type e
     private matchReplied;
     reply(body: ReplyInteractionBody): Promise<void>;
     deferReply(flags?: MessageFlags): Promise<void>;
-    static from(client: BaseClient, gateway: GatewayInteractionCreateDispatchData, __reply?: __InternalReplyFunction): StringSelectMenuInteraction<string[]> | AutocompleteInteraction<boolean> | BaseInteraction<boolean, import("discord-api-types/payloads/v10/_interactions/ping").APIPingInteraction>;
+    static from(client: UsingClient, gateway: GatewayInteractionCreateDispatchData, __reply?: __InternalReplyFunction): StringSelectMenuInteraction<string[]> | AutocompleteInteraction<boolean> | BaseInteraction<boolean, import("discord-api-types/payloads/v10/_interactions/ping").APIPingInteraction>;
     fetchGuild(force?: boolean): Promise<import("./Guild").Guild<"cached"> | import("./Guild").Guild<"api">> | undefined;
 }
 export type AllInteractions = AutocompleteInteraction | ChatInputCommandInteraction | UserCommandInteraction | MessageCommandInteraction | ComponentInteraction | SelectMenuInteraction | ModalSubmitInteraction | BaseInteraction;
@@ -44,7 +43,7 @@ export declare class AutocompleteInteraction<FromGuild extends boolean = boolean
     type: InteractionType.ApplicationCommandAutocomplete;
     data: ObjectToLower<APIApplicationCommandAutocompleteInteraction['data']>;
     options: OptionResolver;
-    constructor(client: BaseClient, interaction: APIApplicationCommandAutocompleteInteraction, __reply?: __InternalReplyFunction | undefined);
+    constructor(client: UsingClient, interaction: APIApplicationCommandAutocompleteInteraction, __reply?: __InternalReplyFunction | undefined);
     getInput(): string;
     respond(choices: APICommandAutocompleteInteractionResponseCallbackData['choices']): Promise<void>;
     /** @intenal */
@@ -91,7 +90,7 @@ export declare class ButtonInteraction extends ComponentInteraction {
 export declare class SelectMenuInteraction extends ComponentInteraction {
     protected __reply?: __InternalReplyFunction | undefined;
     data: ObjectToLower<APIMessageComponentSelectMenuInteraction['data']>;
-    constructor(client: BaseClient, interaction: APIMessageComponentSelectMenuInteraction, __reply?: __InternalReplyFunction | undefined);
+    constructor(client: UsingClient, interaction: APIMessageComponentSelectMenuInteraction, __reply?: __InternalReplyFunction | undefined);
     get values(): string[];
 }
 declare const StringSelectMenuInteraction_base: ToClass<Omit<SelectMenuInteraction, "data">, StringSelectMenuInteraction<string[]>>;
@@ -104,25 +103,25 @@ export declare class StringSelectMenuInteraction<T extends any[] = string[]> ext
 export declare class ChannelSelectMenuInteraction extends SelectMenuInteraction {
     protected __reply?: __InternalReplyFunction | undefined;
     channels: AllChannels[];
-    constructor(client: BaseClient, interaction: APIMessageComponentSelectMenuInteraction, __reply?: __InternalReplyFunction | undefined);
+    constructor(client: UsingClient, interaction: APIMessageComponentSelectMenuInteraction, __reply?: __InternalReplyFunction | undefined);
 }
 export declare class MentionableSelectMenuInteraction extends SelectMenuInteraction {
     protected __reply?: __InternalReplyFunction | undefined;
     roles: GuildRole[];
     members: InteractionGuildMember[];
     users: User[];
-    constructor(client: BaseClient, interaction: APIMessageComponentSelectMenuInteraction, __reply?: __InternalReplyFunction | undefined);
+    constructor(client: UsingClient, interaction: APIMessageComponentSelectMenuInteraction, __reply?: __InternalReplyFunction | undefined);
 }
 export declare class RoleSelectMenuInteraction extends SelectMenuInteraction {
     protected __reply?: __InternalReplyFunction | undefined;
     roles: GuildRole[];
-    constructor(client: BaseClient, interaction: APIMessageComponentSelectMenuInteraction, __reply?: __InternalReplyFunction | undefined);
+    constructor(client: UsingClient, interaction: APIMessageComponentSelectMenuInteraction, __reply?: __InternalReplyFunction | undefined);
 }
 export declare class UserSelectMenuInteraction extends SelectMenuInteraction {
     protected __reply?: __InternalReplyFunction | undefined;
     members: InteractionGuildMember[];
     users: User[];
-    constructor(client: BaseClient, interaction: APIMessageComponentSelectMenuInteraction, __reply?: __InternalReplyFunction | undefined);
+    constructor(client: UsingClient, interaction: APIMessageComponentSelectMenuInteraction, __reply?: __InternalReplyFunction | undefined);
 }
 export declare class ChatInputCommandInteraction<FromGuild extends boolean = boolean> extends ApplicationCommandInteraction<FromGuild, APIChatInputApplicationCommandInteraction> {
     data: ObjectToLower<APIChatInputApplicationCommandInteractionData>;

package/lib/structures/Interaction.js

@@ -191,7 +191,7 @@ class AutocompleteInteraction extends BaseInteraction {
 exports.AutocompleteInteraction = AutocompleteInteraction;
 class Interaction extends BaseInteraction {
     fetchMessage(messageId) {
-        return this.client.webhooks.messages.fetch(this.applicationId, this.token, messageId);
+        return this.client.webhooks.fetchMessage(this.applicationId, this.token, messageId);
     }
     fetchResponse() {
         return this.fetchMessage('@original');