seyfert 1.0.1 → 1.1.1

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;
@@ -81,6 +81,7 @@ export declare class GuildMember extends BaseGuildMember {
     write(body: MessageCreateBodyRequest): Promise<import("./Message").Message>;
     avatarURL(options?: ImageOptions): string;
     dynamicAvatarURL(options?: ImageOptions): string;
+    bannerURL(options?: ImageOptions): string | undefined;
     fetchPermissions(): Promise<PermissionsBitField>;
 }
 export interface UnavailableMember {
@@ -97,7 +98,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))),
@@ -125,6 +125,9 @@ class GuildMember extends BaseGuildMember {
         }
         return this.rest.cdn.guildMemberAvatar(this.guildId, this.id, this.avatar, options);
     }
+    bannerURL(options) {
+        return this.user.bannerURL(options);
+    }
     async fetchPermissions() {
         if ('permissions' in this)
             return this.permissions;

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 */
@@ -58,8 +57,8 @@ export declare class Interaction<FromGuild extends boolean = boolean, Type exten
     editOrReply<FR extends boolean = false>(body: InteractionCreateBodyRequest, fetchReply?: FR): Promise<When<FR, WebhookMessage, void>>;
     editMessage(messageId: string, body: InteractionMessageUpdateBodyRequest): Promise<Message>;
     editResponse(body: InteractionMessageUpdateBodyRequest): Promise<Message>;
-    deleteResponse(): Promise<void>;
-    deleteMessage(messageId: string): Promise<void>;
+    deleteResponse(): Promise<void | undefined>;
+    deleteMessage(messageId: string): Promise<void | undefined>;
     createResponse({ files, ...body }: MessageWebhookCreateBodyRequest): Promise<Message>;
 }
 export declare class ApplicationCommandInteraction<FromGuild extends boolean = boolean, Type extends APIApplicationCommandInteraction = APIApplicationCommandInteraction> extends Interaction<FromGuild, Type> {
@@ -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');
@@ -240,7 +240,7 @@ class Interaction extends BaseInteraction {
             .webhooks(this.applicationId)(this.token)
             .messages(messageId)
             .delete()
-            .then(() => this.client.components.onMessageDelete(messageId === '@original' ? this.id : messageId));
+            .then(() => this.client.components?.onMessageDelete(messageId === '@original' ? this.id : messageId));
     }
     async createResponse({ files, ...body }) {
         files ??= files ? await (0, builders_1.resolveFiles)(files) : undefined;

package/lib/structures/Message.d.ts

@@ -1,5 +1,5 @@
 import type { ListenerOptions } from '../builders';
-import type { BaseClient } from '../client/base';
+import type { UsingClient } from '../commands';
 import type { APIChannelMention, APIMessage, GatewayMessageCreateDispatchData, ObjectToLower } from '../common';
 import type { EmojiResolvable } from '../common/types/resolvables';
 import type { MessageCreateBodyRequest, MessageUpdateBodyRequest } from '../common/types/write';
@@ -23,26 +23,27 @@ export declare class BaseMessage extends DiscordBase {
         channels: APIChannelMention[];
         users: (GuildMember | User)[];
     };
-    constructor(client: BaseClient, data: MessageData);
+    constructor(client: UsingClient, data: MessageData);
+    get user(): User;
     createComponentCollector(options?: ListenerOptions): {
-        run: (customId: string, callback: import("../builders").ComponentCallback) => any;
+        run: (customId: string | RegExp | string[], callback: import("../builders").ComponentCallback) => any;
         stop: (reason?: string | undefined) => void;
     };
     get url(): string;
     guild(force?: boolean): Promise<import("./Guild").Guild<"cached"> | import("./Guild").Guild<"api">> | undefined;
     channel(force?: boolean): Promise<import("./channels").AllChannels>;
-    react(emoji: EmojiResolvable): Promise<never>;
+    react(emoji: EmojiResolvable): Promise<void>;
     private patch;
 }
 export interface Message extends BaseMessage, ObjectToLower<Omit<MessageData, 'timestamp' | 'author' | 'mentions' | 'components'>> {
 }
 export declare class Message extends BaseMessage {
-    constructor(client: BaseClient, data: MessageData);
+    constructor(client: UsingClient, data: MessageData);
     fetch(): Promise<Message>;
     reply(body: Omit<MessageCreateBodyRequest, 'message_reference'>, fail?: boolean): Promise<Message>;
     edit(body: MessageUpdateBodyRequest): Promise<Message>;
     write(body: MessageCreateBodyRequest): Promise<Message>;
-    delete(reason?: string): Promise<void>;
+    delete(reason?: string): Promise<void | undefined>;
     crosspost(reason?: string): Promise<Message>;
 }
 export type EditMessageWebhook = Omit<MessageWebhookMethodEditParams, 'messageId'>;
@@ -50,7 +51,7 @@ export type WriteMessageWebhook = MessageWebhookMethodWriteParams;
 export declare class WebhookMessage extends BaseMessage {
     readonly webhookId: string;
     readonly webhookToken: string;
-    constructor(client: BaseClient, data: MessageData, webhookId: string, webhookToken: string);
+    constructor(client: UsingClient, data: MessageData, webhookId: string, webhookToken: string);
     fetch(): Promise<import("discord-api-types/rest/v10/webhook").RESTGetAPIWebhookWithTokenResult>;
     edit(body: EditMessageWebhook): Promise<WebhookMessage>;
     write(body: WriteMessageWebhook): Promise<WebhookMessage | null>;

package/lib/structures/Message.js

@@ -23,6 +23,9 @@ class BaseMessage extends DiscordBase_1.DiscordBase {
         this.components = data.components?.map(x => new ActionRow_1.MessageActionRowComponent(x)) ?? [];
         this.patch(data);
     }
+    get user() {
+        return this.author;
+    }
     createComponentCollector(options) {
         return this.client.components.createComponentCollector(this.id, options);
     }
@@ -38,7 +41,7 @@ class BaseMessage extends DiscordBase_1.DiscordBase {
         return this.client.channels.fetch(this.channelId, force);
     }
     react(emoji) {
-        return this.client.messages.reactions.add(this.id, this.channelId, emoji);
+        return this.client.reactions.add(this.id, this.channelId, emoji);
     }
     patch(data) {
         if ('guild_id' in data) {
@@ -114,13 +117,13 @@ class WebhookMessage extends BaseMessage {
         return this.api.webhooks(this.webhookId)(this.webhookToken).get({ query: this.thread?.id });
     }
     edit(body) {
-        return this.client.webhooks.messages.edit(this.webhookId, this.webhookToken, { ...body, messageId: this.id });
+        return this.client.webhooks.editMessage(this.webhookId, this.webhookToken, { ...body, messageId: this.id });
     }
     write(body) {
-        return this.client.webhooks.messages.write(this.webhookId, this.webhookToken, body);
+        return this.client.webhooks.writeMessage(this.webhookId, this.webhookToken, body);
     }
     delete(reason) {
-        return this.client.webhooks.messages.delete(this.webhookId, this.webhookToken, this.id, reason);
+        return this.client.webhooks.deleteMessage(this.webhookId, this.webhookToken, this.id, reason);
     }
 }
 exports.WebhookMessage = WebhookMessage;

package/lib/structures/Sticker.d.ts

@@ -1,5 +1,5 @@
+import type { UsingClient } from '..';
 import type { Attachment } from '../builders';
-import type { BaseClient } from '../client/base';
 import type { APISticker, MethodContext, ObjectToLower, RESTPatchAPIGuildStickerJSONBody, RESTPostAPIGuildStickerFormDataBody } from '../common';
 import { User } from './User';
 import { DiscordBase } from './extra/DiscordBase';
@@ -7,7 +7,7 @@ export interface Sticker extends DiscordBase, ObjectToLower<Omit<APISticker, 'us
 }
 export declare class Sticker extends DiscordBase {
     user?: User;
-    constructor(client: BaseClient, data: APISticker);
+    constructor(client: UsingClient, data: APISticker);
     guild(force?: boolean): Promise<import("./Guild").Guild<"cached"> | import("./Guild").Guild<"api">> | undefined;
     edit(body: RESTPatchAPIGuildStickerJSONBody, reason?: string): Promise<Sticker> | undefined;
     fetch(force?: boolean): Promise<Sticker> | undefined;

package/lib/structures/User.d.ts

@@ -16,6 +16,7 @@ export declare class User extends DiscordBase<APIUser> {
     dm(force?: boolean): Promise<import("./channels").DMChannel>;
     write(body: MessageCreateBodyRequest): Promise<import("./Message").Message>;
     avatarURL(options?: ImageOptions): string;
+    bannerURL(options?: ImageOptions): string | undefined;
     presence(): import("..").ReturnCache<(Omit<import("discord-api-types/payloads/v10/gateway").GatewayPresenceUpdate, "user"> & {
         id: string;
     } & {

package/lib/structures/User.js

@@ -30,6 +30,11 @@ class User extends DiscordBase_1.DiscordBase {
         }
         return this.rest.cdn.avatar(this.id, this.avatar, options);
     }
+    bannerURL(options) {
+        if (!this.banner)
+            return;
+        return this.rest.cdn.banner(this.id, this.banner, options);
+    }
     presence() {
         return this.cache.presences?.get(this.id);
     }

package/lib/structures/Webhook.d.ts

@@ -1,4 +1,4 @@
-import type { BaseClient } from '../client/base';
+import type { UsingClient } from '../commands';
 import type { APIWebhook, ImageOptions, MessageWebhookCreateBodyRequest, MessageWebhookPayload, MessageWebhookUpdateBodyRequest, MethodContext, ObjectToLower, RESTGetAPIWebhookWithTokenMessageQuery, RESTPatchAPIWebhookJSONBody, RESTPatchAPIWebhookWithTokenJSONBody, RESTPostAPIWebhookWithTokenQuery } from '../common';
 import { AnonymousGuild } from './AnonymousGuild';
 import { User } from './User';
@@ -9,7 +9,7 @@ export declare class Webhook extends DiscordBase {
     user?: User;
     sourceGuild?: Partial<AnonymousGuild>;
     messages: ReturnType<typeof Webhook.messages>;
-    constructor(client: BaseClient, data: APIWebhook);
+    constructor(client: UsingClient, data: APIWebhook);
     guild(force?: boolean): Promise<import("./Guild").Guild<"cached"> | import("./Guild").Guild<"api">> | undefined;
     channel(force?: boolean): Promise<import("./channels").BaseChannel<import("discord-api-types/payloads/v10/channel").ChannelType> | import("./channels").DMChannel | import("./channels").CategoryChannel | undefined>;
     avatarURL(options?: ImageOptions): string | null;

package/lib/structures/Webhook.js

@@ -47,9 +47,9 @@ class Webhook extends DiscordBase_1.DiscordBase {
     }
     static messages({ client, webhookId, webhookToken }) {
         return {
-            write: (payload) => client.webhooks.messages.write(webhookId, webhookToken, payload),
-            edit: (payload) => client.webhooks.messages.edit(webhookId, webhookToken, payload),
-            delete: (messageId, reason) => client.webhooks.messages.delete(webhookId, webhookToken, messageId, reason),
+            write: (payload) => client.webhooks.writeMessage(webhookId, webhookToken, payload),
+            edit: (payload) => client.webhooks.editMessage(webhookId, webhookToken, payload),
+            delete: (messageId, reason) => client.webhooks.deleteMessage(webhookId, webhookToken, messageId, reason),
         };
     }
     static methods({ client, webhookId, webhookToken }) {

package/lib/structures/channels.d.ts

@@ -1,13 +1,12 @@
 import { ChannelType, VideoQualityMode, type APIDMChannel, type APIGuildCategoryChannel, type APIGuildForumChannel, type APIGuildMediaChannel, type APIGuildStageVoiceChannel, type APIGuildVoiceChannel, type APINewsChannel, type APITextChannel, type APIThreadChannel, type ThreadAutoArchiveDuration } from 'discord-api-types/v10';
-import type { BaseClient } from '../client/base';
+import type { UsingClient } from '../commands';
 import type { APIChannelBase, APIGuildChannel, APIGuildForumDefaultReactionEmoji, APIGuildForumTag, EmojiResolvable, MessageCreateBodyRequest, MessageUpdateBodyRequest, MethodContext, ObjectToLower, RESTGetAPIChannelMessageReactionUsersQuery, RESTPatchAPIChannelJSONBody, RESTPatchAPIGuildChannelPositionsJSONBody, RESTPostAPIChannelWebhookJSONBody, RESTPostAPIGuildChannelJSONBody, SortOrderType, StringToNumber, ToClass } from '../common';
 import type { GuildMember } from './GuildMember';
 import type { GuildRole } from './GuildRole';
-import { Webhook } from './Webhook';
 import { DiscordBase } from './extra/DiscordBase';
 export declare class BaseChannel<T extends ChannelType> extends DiscordBase<APIChannelBase<ChannelType>> {
     type: T;
-    constructor(client: BaseClient, data: APIChannelBase<ChannelType>);
+    constructor(client: UsingClient, data: APIChannelBase<ChannelType>);
     static __intent__(id: '@me'): 'DirectMessages';
     static __intent__(id: string): 'DirectMessages' | 'Guilds';
     /** The URL to the channel */
@@ -58,7 +57,7 @@ interface IChannelTypes {
 export interface BaseGuildChannel extends ObjectToLower<Omit<APIGuildChannel<ChannelType>, 'permission_overwrites'>> {
 }
 export declare class BaseGuildChannel extends BaseChannel<ChannelType> {
-    constructor(client: BaseClient, data: APIGuildChannel<ChannelType>);
+    constructor(client: UsingClient, data: APIGuildChannel<ChannelType>);
     permissionOverwrites: {
         fetch: () => import("..").ReturnCache<{
             type: number;
@@ -104,12 +103,12 @@ export declare class BaseGuildChannel extends BaseChannel<ChannelType> {
 export interface MessagesMethods extends BaseChannel<ChannelType> {
 }
 export declare class MessagesMethods extends DiscordBase {
-    typing(): Promise<never>;
+    typing(): Promise<void>;
     messages: {
         write: (body: MessageCreateBodyRequest) => Promise<import("./Message").Message>;
         edit: (messageId: string, body: MessageUpdateBodyRequest) => Promise<import("./Message").Message>;
         crosspost: (messageId: string, reason?: string) => Promise<import("./Message").Message>;
-        delete: (messageId: string, reason?: string) => Promise<void>;
+        delete: (messageId: string, reason?: string) => Promise<void | undefined>;
         fetch: (messageId: string) => Promise<import("./Message").Message>;
         purge: (messages: string[], reason?: string) => Promise<never>;
     };
@@ -119,10 +118,10 @@ export declare class MessagesMethods extends DiscordBase {
         delete: (messageId: string, reason?: string) => Promise<never>;
     };
     reactions: {
-        add: (messageId: string, emoji: EmojiResolvable) => Promise<never>;
-        delete: (messageId: string, emoji: EmojiResolvable, userId?: string) => Promise<never>;
+        add: (messageId: string, emoji: EmojiResolvable) => Promise<void>;
+        delete: (messageId: string, emoji: EmojiResolvable, userId?: string) => Promise<void>;
         fetch: (messageId: string, emoji: EmojiResolvable, query?: RESTGetAPIChannelMessageReactionUsersQuery) => Promise<import("./User").User[]>;
-        purge: (messageId: string, emoji?: EmojiResolvable) => Promise<never>;
+        purge: (messageId: string, emoji?: EmojiResolvable) => Promise<void>;
     };
     static messages(ctx: MethodContext<{
         channelId: string;
@@ -130,17 +129,17 @@ export declare class MessagesMethods extends DiscordBase {
         write: (body: MessageCreateBodyRequest) => Promise<import("./Message").Message>;
         edit: (messageId: string, body: MessageUpdateBodyRequest) => Promise<import("./Message").Message>;
         crosspost: (messageId: string, reason?: string) => Promise<import("./Message").Message>;
-        delete: (messageId: string, reason?: string) => Promise<void>;
+        delete: (messageId: string, reason?: string) => Promise<void | undefined>;
         fetch: (messageId: string) => Promise<import("./Message").Message>;
         purge: (messages: string[], reason?: string) => Promise<never>;
     };
     static reactions(ctx: MethodContext<{
         channelId: string;
     }>): {
-        add: (messageId: string, emoji: EmojiResolvable) => Promise<never>;
-        delete: (messageId: string, emoji: EmojiResolvable, userId?: string) => Promise<never>;
+        add: (messageId: string, emoji: EmojiResolvable) => Promise<void>;
+        delete: (messageId: string, emoji: EmojiResolvable, userId?: string) => Promise<void>;
         fetch: (messageId: string, emoji: EmojiResolvable, query?: RESTGetAPIChannelMessageReactionUsersQuery) => Promise<import("./User").User[]>;
-        purge: (messageId: string, emoji?: EmojiResolvable) => Promise<never>;
+        purge: (messageId: string, emoji?: EmojiResolvable) => Promise<void>;
     };
     static pins(ctx: MethodContext<{
         channelId: string;
@@ -155,7 +154,7 @@ export interface TextBaseGuildChannel extends ObjectToLower<Omit<APITextChannel,
 }
 export declare class TextBaseGuildChannel extends BaseGuildChannel {
 }
-export default function channelFrom(data: APIChannelBase<ChannelType>, client: BaseClient): AllChannels;
+export default function channelFrom(data: APIChannelBase<ChannelType>, client: UsingClient): AllChannels;
 export interface TopicableGuildChannel extends BaseChannel<ChannelType> {
 }
 export declare class TopicableGuildChannel extends DiscordBase {
@@ -180,24 +179,24 @@ export declare class VoiceChannelMethods extends DiscordBase {
 }
 export declare class WebhookGuildMethods extends DiscordBase {
     webhooks: {
-        list: () => Promise<Webhook[]>;
+        list: () => Promise<import("./Webhook").Webhook[]>;
     };
     static guild(ctx: MethodContext<{
         guildId: string;
     }>): {
-        list: () => Promise<Webhook[]>;
+        list: () => Promise<import("./Webhook").Webhook[]>;
     };
 }
 export declare class WebhookChannelMethods extends DiscordBase {
     webhooks: {
-        list: () => Promise<Webhook[]>;
-        create: (body: RESTPostAPIChannelWebhookJSONBody) => Promise<Webhook>;
+        list: () => Promise<import("./Webhook").Webhook[]>;
+        create: (body: RESTPostAPIChannelWebhookJSONBody) => Promise<import("./Webhook").Webhook>;
     };
     static channel(ctx: MethodContext<{
         channelId: string;
     }>): {
-        list: () => Promise<Webhook[]>;
-        create: (body: RESTPostAPIChannelWebhookJSONBody) => Promise<Webhook>;
+        list: () => Promise<import("./Webhook").Webhook[]>;
+        create: (body: RESTPostAPIChannelWebhookJSONBody) => Promise<import("./Webhook").Webhook>;
     };
 }
 export interface TextGuildChannel extends ObjectToLower<Omit<APITextChannel, 'type' | 'permission_overwrites'>>, BaseGuildChannel, TextBaseGuildChannel, WebhookChannelMethods {
@@ -238,8 +237,8 @@ export interface ThreadChannel extends ObjectToLower<Omit<APIThreadChannel, 'per
 export declare class ThreadChannel extends BaseChannel<ChannelType.PublicThread | ChannelType.AnnouncementThread | ChannelType.PrivateThread> {
     type: ChannelType.PublicThread | ChannelType.AnnouncementThread | ChannelType.PrivateThread;
     webhooks: {
-        list: () => Promise<Webhook[]>;
-        create: (body: RESTPostAPIChannelWebhookJSONBody) => Promise<Webhook>;
+        list: () => Promise<import("./Webhook").Webhook[]>;
+        create: (body: RESTPostAPIChannelWebhookJSONBody) => Promise<import("./Webhook").Webhook>;
     };
     setRatelimitPerUser(rate_limit_per_user: number | null | undefined): Promise<AllChannels>;
     pin(reason?: string): Promise<AllChannels>;