bakit 3.1.0 → 3.2.0

package/dist/index.mjs

@@ -129,6 +129,188 @@ var User = class extends BaseStructure {
 	}
 };
 
+//#endregion
+//#region src/lib/structures/Message.ts
+var Message = class extends BaseStructure {
+	#cachedAuthor;
+	constructor(client, data) {
+		super(client);
+		this.data = data;
+		this.#ensureChannelCache();
+	}
+	get partial() {
+		return typeof this.data.content !== "string" || typeof this.data.author !== "object" || this.channel === void 0;
+	}
+	get content() {
+		return this.data.content;
+	}
+	get id() {
+		return this.data.id;
+	}
+	get channelId() {
+		return this.data.channel_id;
+	}
+	get channel() {
+		return this.#ensureChannelCache();
+	}
+	get guildId() {
+		return "guild_id" in this.data ? this.data.guild_id : void 0;
+	}
+	get guild() {
+		return this.guildId ? this.client.cache.guilds.get(this.guildId) : void 0;
+	}
+	/**
+	* The author of this message.
+	*
+	* **Note:** This property returns the cached `User` synchronously.
+	* It may be stale if the users cache has short lifetime or uses an asynchronous remote store.
+	* To ensure the author is up-to-date, use the `fetchAuthor()` method instead.
+	*/
+	get author() {
+		let author = this.#cachedAuthor;
+		if (!author && this.client.cache.isModuleEnabled("users")) author = this.client.cache.resolveLocal(this.client.cache.users.local, this.data.author.id, () => new User(this.client, this.data.author), (user) => user._patch(this.data.author));
+		if (!author) author = new User(this.client, this.data.author);
+		this.#cachedAuthor = author;
+		return this.#cachedAuthor;
+	}
+	get createdAt() {
+		return new Date(this.data.timestamp);
+	}
+	get editedAt() {
+		return this.data.edited_timestamp ? new Date(this.data.edited_timestamp) : void 0;
+	}
+	get createdTimestamp() {
+		return this.createdAt.getTime();
+	}
+	get editedTimestamp() {
+		return this.editedAt?.getTime();
+	}
+	get url() {
+		return `https://discord.com/channels/${this.guildId ?? "@me"}/${this.channelId}/${this.id}`;
+	}
+	inGuild() {
+		return this.guild !== void 0;
+	}
+	async fetch() {
+		const message = await this.client.helper.fetchMessage(this.channelId, this.id);
+		this.data = message.data;
+		this.#cachedAuthor = await this.client.cache.resolve(this.client.cache.users, message.data.author.id, () => new User(this.client, message.data.author));
+		return this;
+	}
+	/**
+	* Fetches the author of this message from cache or Discord API.
+	*
+	* **Note:** It is recommended to use this method instead of the `author` property
+	* if the users cache has short lifetime or is backed by an asynchronous remote cache.
+	*
+	* @param force - Whether to bypass the cache and force a request to the API.
+	* @returns A promise that resolves to the `User` who authored this message.
+	*/
+	async fetchAuthor(force = false) {
+		if (!force && this.client.cache.isModuleEnabled("users")) return this.client.cache.resolve(this.client.cache.users, this.data.author.id, () => new User(this.client, this.data.author), (user) => user._patch(this.data.author));
+		return this.client.helper.fetchUser(this.data.author.id, force);
+	}
+	async reply(options) {
+		return this.client.channels.replyMessage(this.channelId, this.id, options);
+	}
+	async edit(options) {
+		return this.client.channels.editMessage(this.channelId, this.id, options);
+	}
+	async _patch(data) {
+		this.data = {
+			...this.data,
+			...data
+		};
+		if (data.author && this.client.cache.isModuleEnabled("users")) if (this.client.cache.isModuleEnabled("users")) this.#cachedAuthor = await this.client.cache.resolve(this.client.cache.users, data.author.id, () => new User(this.client, data.author));
+		else this.#cachedAuthor?._patch(data.author);
+	}
+	#ensureChannelCache() {
+		const { client } = this;
+		let channel = client.cache.channels.get(this.channelId) ?? this.guild?.channels.get(this.channelId);
+		if (!channel) {
+			if (this.guildId) channel = this.client.channels.resolve({
+				id: this.channelId,
+				type: ChannelType.GuildText
+			});
+			else channel = this.client.channels.resolve({
+				id: this.channelId,
+				type: ChannelType.DM,
+				name: null,
+				recipients: [this.data.author]
+			});
+			if (!channel) throw new Error("Channel not found");
+			client.cache.channels.set(this.channelId, channel);
+		}
+		return channel;
+	}
+	toJSON() {
+		return this.data;
+	}
+	toString() {
+		return this.data.content;
+	}
+};
+
+//#endregion
+//#region src/lib/structures/Typing.ts
+var Typing = class extends BaseStructure {
+	constructor(client, data) {
+		super(client);
+		this.data = data;
+	}
+	get channelId() {
+		return this.data.channel_id;
+	}
+	get guildId() {
+		return this.data.guild_id;
+	}
+	get userId() {
+		return this.data.user_id;
+	}
+	get timestamp() {
+		return this.data.timestamp;
+	}
+	get member() {
+		return this.data.member;
+	}
+	get channel() {
+		return this.guild?.channels.get(this.channelId) ?? this.client.cache.channels.get(this.channelId);
+	}
+	get guild() {
+		if (this.data.guild_id) return this.client.cache.guilds.get(this.data.guild_id);
+	}
+};
+
+//#endregion
+//#region src/lib/structures/Tag.ts
+var Tag = class extends BaseStructure {
+	constructor(client, data) {
+		super(client);
+		this.data = data;
+	}
+	get id() {
+		return this.data.id;
+	}
+	get name() {
+		return this.data.name;
+	}
+	get moderated() {
+		return this.data.moderated ?? false;
+	}
+	get emojiId() {
+		return this.data.emoji_id ?? void 0;
+	}
+	get emojiName() {
+		return this.data.emoji_name ?? void 0;
+	}
+	_patch(data) {
+		this.data = {
+			...this.data,
+			...data
+		};
+	}
+};
+
 //#endregion
 //#region src/lib/structures/channel/BaseChannel.ts
 var BaseChannel = class extends BaseStructure {
@@ -136,6 +318,9 @@ var BaseChannel = class extends BaseStructure {
 		super(client);
 		this.data = data;
 	}
+	get partial() {
+		return Object.keys(this.data).length <= 2;
+	}
 	get id() {
 		return this.data.id;
 	}
@@ -157,11 +342,28 @@ var BaseChannel = class extends BaseStructure {
 	isDM() {
 		return this.type === ChannelType.DM;
 	}
+	isThread() {
+		return this.type === ChannelType.AnnouncementThread || this.type === ChannelType.PublicThread || this.type === ChannelType.PrivateThread;
+	}
+	isPublicThread() {
+		return this.type === ChannelType.PublicThread;
+	}
+	isPrivateThread() {
+		return this.type === ChannelType.PrivateThread;
+	}
+	isAnnouncementThread() {
+		return this.type === ChannelType.AnnouncementThread;
+	}
+	isCategory() {
+		return this.type === ChannelType.GuildCategory;
+	}
 	inGuild() {
 		return "guild_id" in this.data;
 	}
-	fetch() {
-		return this.client.helper.fetchChannel(this.id, true);
+	async fetch() {
+		const channel = await this.client.channels.fetch(this.id, true);
+		if (!channel) throw new Error("Channel not found");
+		return channel;
 	}
 	_patch(data) {
 		this.data = {
@@ -175,8 +377,14 @@ var BaseChannel = class extends BaseStructure {
 //#region src/lib/mixins/ChannelMixin.ts
 const TextBasedChannelMixin = createMixin((base) => {
 	class TextBasedChannel extends base {
+		get lastMessageId() {
+			return this.data.last_message_id ?? void 0;
+		}
+		get rateLimitPerUser() {
+			return this.data.rate_limit_per_user;
+		}
 		send(options) {
-			return this.client.helper.createMessage(this.id, options);
+			return this.client.channels.createMessage(this.id, options);
 		}
 	}
 	return TextBasedChannel;
@@ -187,6 +395,12 @@ const VoiceBasedChannelMixin = createMixin((base) => {
 });
 const GuildChannelMixin = createMixin((base) => {
 	class GuildChannel extends base {
+		get parentId() {
+			return this.data.parent_id ?? void 0;
+		}
+		get parent() {
+			return this.parentId ? this.client.cache.channels.get(this.parentId) : void 0;
+		}
 		get guildId() {
 			if (!this.data.guild_id) throw new Error("This channel is not a guild channel");
 			return this.data.guild_id;
@@ -198,6 +412,86 @@ const GuildChannelMixin = createMixin((base) => {
 	return GuildChannel;
 });
 
+//#endregion
+//#region src/lib/structures/channel/GuildTextChannel.ts
+var GuildTextChannel = class extends applyMixins(BaseChannel, [GuildChannelMixin, TextBasedChannelMixin]) {};
+
+//#endregion
+//#region src/lib/structures/channel/GuildVoiceChannel.ts
+var GuildVoiceChannel = class extends applyMixins(BaseChannel, [
+	GuildChannelMixin,
+	TextBasedChannelMixin,
+	VoiceBasedChannelMixin
+]) {};
+
+//#endregion
+//#region src/lib/structures/channel/GuildStageVoiceChannel.ts
+var GuildStageVoiceChannel = class extends applyMixins(BaseChannel, [
+	GuildChannelMixin,
+	TextBasedChannelMixin,
+	VoiceBasedChannelMixin
+]) {};
+
+//#endregion
+//#region src/lib/structures/channel/GuildAnnouncementChannel.ts
+var GuildAnnouncementChannel = class extends applyMixins(BaseChannel, [GuildChannelMixin, TextBasedChannelMixin]) {
+	crosspost(messageId) {
+		return this.client.channels.crosspost(this.id, messageId);
+	}
+};
+
+//#endregion
+//#region src/lib/structures/channel/GuildForumChannel.ts
+var GuildForumChannel = class extends applyMixins(BaseChannel, [GuildChannelMixin]) {
+	#cachedTags;
+	constructor(client, data) {
+		super(client, data);
+	}
+	get topic() {
+		return this.data.topic ?? void 0;
+	}
+	get defaultAutoArchiveDuration() {
+		return this.data.default_auto_archive_duration;
+	}
+	get defaultSortOrder() {
+		return this.data.default_sort_order;
+	}
+	get defaultForumLayout() {
+		return this.data.default_forum_layout;
+	}
+	get defaultThreadRateLimitPerUser() {
+		return this.data.default_thread_rate_limit_per_user;
+	}
+	get nsfw() {
+		return this.data.nsfw ?? false;
+	}
+	get tags() {
+		if (!this.#cachedTags) {
+			this.#cachedTags = new Collection();
+			for (const tagData of this.data.available_tags ?? []) {
+				const tag = new Tag(this.client, tagData);
+				this.#cachedTags.set(tag.id, tag);
+			}
+		}
+		return this.#cachedTags;
+	}
+	_patch(data) {
+		super._patch(data);
+		this.#cachedTags = void 0;
+	}
+};
+
+//#endregion
+//#region src/lib/structures/channel/GuildCategory.ts
+var GuildCategory = class extends applyMixins(BaseChannel, [GuildChannelMixin]) {
+	constructor(client, data) {
+		super(client, data);
+	}
+	get children() {
+		return this.guild?.channels.filter((channel) => channel.inGuild() && channel.parentId === this.id);
+	}
+};
+
 //#endregion
 //#region src/lib/structures/channel/DMChannel.ts
 var DMChannel = class extends applyMixins(BaseChannel, [TextBasedChannelMixin]) {
@@ -260,151 +554,153 @@ var DMChannel = class extends applyMixins(BaseChannel, [TextBasedChannelMixin])
 };
 
 //#endregion
-//#region src/lib/structures/Message.ts
-var Message = class extends BaseStructure {
-	#cachedAuthor;
-	constructor(client, data) {
-		super(client);
-		this.data = data;
-		this.#ensureChannelCache();
+//#region src/lib/structures/channel/ThreadChannel.ts
+var ThreadChannel = class extends applyMixins(BaseChannel, [GuildChannelMixin, TextBasedChannelMixin]) {
+	get ownerId() {
+		return this.data.owner_id;
 	}
-	get partial() {
-		return typeof this.data.content !== "string" || typeof this.data.author !== "object";
+	get archived() {
+		return this.data.thread_metadata?.archived ?? false;
 	}
-	get content() {
-		return this.data.content;
+	get locked() {
+		return this.data.thread_metadata?.locked ?? false;
 	}
-	get id() {
-		return this.data.id;
+	get autoArchiveDuration() {
+		return this.data.thread_metadata?.auto_archive_duration;
 	}
-	get channelId() {
-		return this.data.channel_id;
+	get archiveTimestamp() {
+		return this.data.thread_metadata?.archive_timestamp;
 	}
-	get channel() {
-		return this.#ensureChannelCache();
+	get invitable() {
+		return this.data.thread_metadata?.invitable;
 	}
-	get guildId() {
-		return "guild_id" in this.data ? this.data.guild_id : void 0;
+	get memberCount() {
+		return this.data.member_count;
 	}
-	get guild() {
-		return this.guildId ? this.client.cache.guilds.get(this.guildId) : void 0;
+	get messageCount() {
+		return this.data.message_count;
 	}
-	/**
-	* The author of this message.
-	*
-	* **Note:** This property returns the cached `User` synchronously.
-	* It may be stale if the users cache has short lifetime or uses an asynchronous remote store.
-	* To ensure the author is up-to-date, use the `fetchAuthor()` method instead.
-	*/
-	get author() {
-		let author = this.#cachedAuthor;
-		if (!author && this.client.cache.isModuleEnabled("users")) author = this.client.cache.resolveLocal(this.client.cache.users.local, this.data.author.id, () => new User(this.client, this.data.author), (user) => user._patch(this.data.author));
-		if (!author) author = new User(this.client, this.data.author);
-		this.#cachedAuthor = author;
-		return this.#cachedAuthor;
-	}
-	get createdAt() {
-		return new Date(this.data.timestamp);
-	}
-	get editedAt() {
-		return this.data.edited_timestamp ? new Date(this.data.edited_timestamp) : void 0;
-	}
-	get createdTimestamp() {
-		return this.createdAt.getTime();
+	get totalMessageSent() {
+		return this.data.total_message_sent;
 	}
-	get editedTimestamp() {
-		return this.editedAt?.getTime();
-	}
-	get url() {
-		return `https://discord.com/channels/${this.guildId ?? "@me"}/${this.channelId}/${this.id}`;
+};
+
+//#endregion
+//#region src/lib/managers/client/ClientChannelManager.ts
+var ClientChannelManager = class ClientChannelManager {
+	constructor(client) {
+		Object.defineProperty(this, "client", {
+			value: client,
+			enumerable: false,
+			writable: false
+		});
 	}
-	inGuild() {
-		return this.guild !== void 0;
+	async fetch(id, force = false) {
+		if (!force) {
+			const cached = this.client.cache.channels.get(id);
+			if (cached) return cached;
+		}
+		const data = await this.client.rest.get(Routes.channel(id)).catch(() => void 0);
+		if (!data) return;
+		const existing = this.client.cache.channels.get(id);
+		if (existing && existing.type === data.type) {
+			existing._patch(data);
+			return existing;
+		}
+		const newChannel = ClientChannelManager.create(this.client, data);
+		this.client.cache.channels.set(id, newChannel);
+		return newChannel;
+	}
+	async delete(id, force = false) {
+		const channel = this.client.cache.channels.get(id);
+		if (!channel && !force) return;
+		await this.client.rest.delete(Routes.channel(id));
+		if (channel) {
+			this.client.cache.channels.delete(id);
+			if (channel.inGuild()) channel.guild.channels.delete(id);
+		}
+		return channel;
 	}
-	async fetch() {
-		const message = await this.client.helper.fetchMessage(this.channelId, this.id);
-		this.data = message.data;
-		this.#cachedAuthor = await this.client.cache.resolve(this.client.cache.users, message.data.author.id, () => new User(this.client, message.data.author));
-		return this;
+	async create(guildId, payload) {
+		const data = await this.client.rest.post(Routes.guildChannels(guildId), { body: payload });
+		const channel = ClientChannelManager.create(this.client, data);
+		this.client.cache.channels.set(channel.id, channel);
+		if (channel.inGuild()) channel.guild.channels.set(channel.id, channel);
+		return channel;
 	}
-	/**
-	* Fetches the author of this message from cache or Discord API.
-	*
-	* **Note:** It is recommended to use this method instead of the `author` property
-	* if the users cache has short lifetime or is backed by an asynchronous remote cache.
-	*
-	* @param force - Whether to bypass the cache and force a request to the API.
-	* @returns A promise that resolves to the `User` who authored this message.
-	*/
-	async fetchAuthor(force = false) {
-		if (!force && this.client.cache.isModuleEnabled("users")) return this.client.cache.resolve(this.client.cache.users, this.data.author.id, () => new User(this.client, this.data.author), (user) => user._patch(this.data.author));
-		return this.client.helper.fetchUser(this.data.author.id, force);
+	async crosspost(channelId, messageId) {
+		const data = await this.client.rest.post(Routes.channelMessageCrosspost(channelId, messageId));
+		const message = new Message(this.client, data);
+		if (this.client.cache.isModuleEnabled("messages")) await this.client.cache.messages.set(message.id, message);
+		return message;
 	}
-	async reply(options) {
-		return this.client.helper.replyMessage(this.channelId, this.id, options);
+	async createMessage(channelId, options) {
+		if (typeof options === "string") options = { content: options };
+		const data = this.client.rest.post(Routes.channelMessages(channelId), { body: ClientChannelManager.createMessagePayload(options) });
+		const message = new Message(this.client, await data);
+		if (this.client.cache.isModuleEnabled("messages")) await this.client.cache.messages.set(message.id, message);
+		return message;
 	}
-	async sendToChannel(options) {
-		return this.client.helper.createMessage(this.channelId, options);
+	async editMessage(channelId, messageId, options) {
+		if (typeof options === "string") options = { content: options };
+		const data = await this.client.rest.patch(Routes.channelMessage(channelId, messageId), { body: ClientChannelManager.createMessagePayload(options) });
+		let message;
+		if (this.client.cache.isModuleEnabled("messages")) message = await this.client.cache.resolve(this.client.cache.messages, messageId, () => new Message(this.client, data), (m) => m._patch(data));
+		else message = new Message(this.client, data);
+		return message;
 	}
-	async edit(options) {
-		return this.client.helper.editMessage(this.channelId, this.id, options);
+	async deleteMessage(channelId, messageId, force = false) {
+		let message;
+		if (!force && this.client.cache.isModuleEnabled("messages")) {
+			message = await this.client.cache.messages.get(messageId);
+			if (!message) return;
+		}
+		await this.client.rest.delete(Routes.channelMessage(channelId, messageId));
+		if (this.client.cache.isModuleEnabled("messages")) await this.client.cache.messages.delete(messageId);
+		return message;
 	}
-	async _patch(data) {
-		this.data = {
-			...this.data,
-			...data
-		};
-		if (data.author && this.client.cache.isModuleEnabled("users")) if (this.client.cache.isModuleEnabled("users")) this.#cachedAuthor = await this.client.cache.resolve(this.client.cache.users, data.author.id, () => new User(this.client, data.author));
-		else this.#cachedAuthor?._patch(data.author);
+	async replyMessage(channelId, messageId, options) {
+		if (typeof options === "string") options = { content: options };
+		return this.createMessage(channelId, {
+			...options,
+			messageReference: {
+				channel_id: channelId,
+				message_id: messageId
+			}
+		});
 	}
-	#ensureChannelCache() {
-		const { client } = this;
-		let channel = client.cache.channels.get(this.channelId);
-		if (!channel) if (this.inGuild()) channel = this.guild.channels.get(this.channelId);
-		else {
-			channel = new DMChannel(client, {
-				id: this.channelId,
-				type: ChannelType.DM,
-				name: null,
-				recipients: [this.data.author, this.client.user.data]
-			});
-			console.log(channel);
+	resolve(data) {
+		return this.client.cache.resolveLocal(this.client.cache.channels, data.id, () => ClientChannelManager.create(this.client, data), (c) => c?._patch(data));
+	}
+	static create(client, data) {
+		switch (data.type) {
+			case ChannelType.GuildText: return new GuildTextChannel(client, data);
+			case ChannelType.GuildVoice: return new GuildVoiceChannel(client, data);
+			case ChannelType.GuildStageVoice: return new GuildStageVoiceChannel(client, data);
+			case ChannelType.GuildAnnouncement: return new GuildAnnouncementChannel(client, data);
+			case ChannelType.DM: return new DMChannel(client, data);
+			case ChannelType.GuildForum: return new GuildForumChannel(client, data);
+			case ChannelType.PublicThread:
+			case ChannelType.PrivateThread:
+			case ChannelType.AnnouncementThread: return new ThreadChannel(client, data);
 		}
-		if (!channel) throw new Error(`Channel not found: ${this.channelId}`);
-		client.cache.channels.set(this.channelId, channel);
-		return channel;
+		return new BaseChannel(client, data);
 	}
-	toJSON() {
-		return this.data;
+	joinThread(threadId) {
+		return this.client.rest.post(Routes.threadMembers(threadId));
 	}
-	toString() {
-		return this.data.content;
+	static createMessagePayload(options) {
+		return {
+			content: options.content,
+			tts: options.tts,
+			embeds: options.embeds,
+			allowed_mentions: options.allowedMentions,
+			message_reference: options.messageReference,
+			flags: options.flags
+		};
 	}
 };
 
-//#endregion
-//#region src/lib/structures/channel/GuildTextChannel.ts
-var GuildTextChannel = class extends applyMixins(BaseChannel, [GuildChannelMixin, TextBasedChannelMixin]) {};
-
-//#endregion
-//#region src/lib/structures/channel/GuildVoiceChannel.ts
-var GuildVoiceChannel = class extends applyMixins(BaseChannel, [
-	GuildChannelMixin,
-	TextBasedChannelMixin,
-	VoiceBasedChannelMixin
-]) {};
-
-//#endregion
-//#region src/lib/utils/channel.ts
-function createChannel(client, data) {
-	switch (data.type) {
-		case ChannelType.GuildText: return new GuildTextChannel(client, data);
-		case ChannelType.GuildVoice: return new GuildVoiceChannel(client, data);
-		case ChannelType.DM: return new DMChannel(client, data);
-		default: return null;
-	}
-}
-
 //#endregion
 //#region src/lib/structures/Guild.ts
 var Guild = class extends BaseStructure {
@@ -447,7 +743,7 @@ var Guild = class extends BaseStructure {
 		for (const id of this.channels.keys()) this.client.cache.channels.delete(id);
 		this.channels.clear();
 		for (const channelData of this.data.channels) {
-			const channel = createChannel(this.client, channelData);
+			const channel = ClientChannelManager.create(this.client, channelData);
 			if (channel) {
 				this.channels.set(channel.id, channel);
 				this.client.cache.channels.set(channel.id, channel);
@@ -458,7 +754,7 @@ var Guild = class extends BaseStructure {
 
 //#endregion
 //#region src/lib/client/ClientHelper.ts
-var ClientHelper = class ClientHelper {
+var ClientHelper = class {
 	constructor(client) {
 		Object.defineProperty(this, "client", {
 			value: client,
@@ -501,30 +797,6 @@ var ClientHelper = class ClientHelper {
 		await this.client.rest.delete(Routes.channelMessage(channelId, messageId));
 		if (this.client.cache.isModuleEnabled("messages")) await this.client.cache.messages.delete(messageId);
 	}
-	async createMessage(channelId, options) {
-		if (typeof options === "string") options = { content: options };
-		const data = this.client.rest.post(Routes.channelMessages(channelId), { body: ClientHelper.toAPICreateMessagePayload(options) });
-		const message = new Message(this.client, await data);
-		if (this.client.cache.isModuleEnabled("messages")) await this.client.cache.messages.set(message.id, message);
-		return message;
-	}
-	async editMessage(channelId, messageId, options) {
-		if (typeof options === "string") options = { content: options };
-		const data = await this.client.rest.patch(Routes.channelMessage(channelId, messageId), { body: ClientHelper.toAPICreateMessagePayload(options) });
-		let message;
-		if (this.client.cache.isModuleEnabled("messages")) message = await this.client.cache.resolve(this.client.cache.messages, messageId, () => new Message(this.client, data), (m) => m._patch(data));
-		else message = new Message(this.client, data);
-		return message;
-	}
-	async replyMessage(channelId, messageId, options) {
-		return this.createMessage(channelId, {
-			...options,
-			messageReference: {
-				channel_id: channelId,
-				message_id: messageId
-			}
-		});
-	}
 	async fetchGuild(guildId, force = false) {
 		let guild = this.client.cache.guilds.get(guildId);
 		if (!guild || force) {
@@ -534,26 +806,14 @@ var ClientHelper = class ClientHelper {
 		}
 		return guild;
 	}
-	async fetchChannel(channelId, force = false) {
-		let channel = this.client.cache.channels.get(channelId);
-		if (!channel || force) {
-			const data = await this.client.rest.get(Routes.channel(channelId));
-			channel = createChannel(this.client, data) ?? void 0;
-			if (!channel) throw new Error(`Channel not found: ${channelId}`);
-			this.client.cache.channels.set(channelId, channel);
-			if (channel.inGuild()) channel.guild.channels.set(channelId, channel);
-		}
-		return channel;
+	fetchChannel(channelId, force = false) {
+		return this.client.channels.fetch(channelId, force);
 	}
-	static toAPICreateMessagePayload(options) {
-		return {
-			content: options.content,
-			tts: options.tts,
-			embeds: options.embeds,
-			allowed_mentions: options.allowedMentions,
-			message_reference: options.messageReference,
-			flags: options.flags
-		};
+	async crosspostMessage(channelId, messageId) {
+		const data = await this.client.rest.post(Routes.channelMessageCrosspost(channelId, messageId));
+		const message = new Message(this.client, data);
+		if (this.client.cache.isModuleEnabled("messages")) await this.client.cache.messages.set(message.id, message);
+		return message;
 	}
 };
 
@@ -562,6 +822,7 @@ var ClientHelper = class ClientHelper {
 let Partial = /* @__PURE__ */ function(Partial) {
 	Partial[Partial["Message"] = 0] = "Message";
 	Partial[Partial["User"] = 1] = "User";
+	Partial[Partial["Channel"] = 2] = "Channel";
 	return Partial;
 }({});
 
@@ -636,6 +897,12 @@ var LocalCacheAdapter = class extends BaseCacheAdapter {
 	find(filter) {
 		for (const entry of this.collection.values()) if (filter(entry.value)) return entry.value;
 	}
+	forEach(callback) {
+		for (const [key, entry] of this.collection) callback(entry.value, key);
+	}
+	map(callback) {
+		return this.collection.map((entry, key) => callback(entry.value, key));
+	}
 	sweep(filter) {
 		for (const [key, entry] of this.collection) if (filter(entry.value)) this.delete(key);
 	}
@@ -690,7 +957,7 @@ var HybridCache = class {
 };
 
 //#endregion
-//#region src/lib/client/ClientCacheManager.ts
+//#region src/lib/managers/client/ClientCacheManager.ts
 var ClientCacheManager = class {
 	channels = new LocalCacheAdapter();
 	guilds = new LocalCacheAdapter();
@@ -751,31 +1018,49 @@ function registerHandler(event, handler) {
 
 //#endregion
 //#region src/lib/client/dispatches/handlers/message.ts
-async function onCreateAndUpdate$1(client, payload) {
+async function ensureMessageCache(client, payload) {
 	let message;
 	if (client.cache.isModuleEnabled("messages")) message = await client.cache.resolve(client.cache.messages, payload.d.id, () => new Message(client, payload.d), (m) => m._patch(payload.d));
 	else message = new Message(client, payload.d);
-	if (message.partial && !client.options.partials.has(Partial.Message)) return;
-	client.emit(payload.t === GatewayDispatchEvents.MessageUpdate ? "messageUpdate" : "messageCreate", message);
+	return message;
 }
-registerHandler(GatewayDispatchEvents.MessageCreate, onCreateAndUpdate$1);
-registerHandler(GatewayDispatchEvents.MessageUpdate, onCreateAndUpdate$1);
+registerHandler(GatewayDispatchEvents.MessageCreate, async (client, payload) => {
+	const message = await ensureMessageCache(client, payload);
+	message.channel.data.last_message_id = message.id;
+	if (message.channel.isThread()) {
+		message.channel.data.message_count = (message.channel.data.message_count ?? 0) + 1;
+		message.channel.data.total_message_sent = (message.channel.data.total_message_sent ?? 0) + 1;
+	}
+	if (message.partial && !client.options.partials.has(Partial.Message)) return;
+	if (message.channel.partial && !client.options.partials.has(Partial.Channel)) return;
+	client.emit("messageCreate", message);
+});
+registerHandler(GatewayDispatchEvents.MessageUpdate, async (client, payload) => {
+	const message = await ensureMessageCache(client, payload);
+	if (message.partial && !client.options.partials.has(Partial.Message)) return;
+	if (message.channel.partial && !client.options.partials.has(Partial.Channel)) return;
+	client.emit("messageUpdate", message);
+});
 registerHandler(GatewayDispatchEvents.MessageDelete, async (client, payload) => {
 	let message;
 	if (client.cache.isModuleEnabled("messages")) message = await client.cache.messages.get(payload.d.id);
 	if (!message) message = new Message(client, payload.d);
+	if (message.channel.isThread()) message.channel.data.message_count = Math.min((message.channel.data.message_count ?? 0) - 1, 0);
 	client.emit("messageDelete", message);
 });
 
 //#endregion
 //#region src/lib/client/dispatches/handlers/guild.ts
-async function onCreateAndUpdate(client, payload) {
-	const guild = await client.cache.resolve(client.cache.guilds, payload.d.id, () => new Guild(client, payload.d), (g) => g._patch(payload.d));
-	if (payload.t === GatewayDispatchEvents.GuildCreate) client.emit(payload.d.unavailable ? "guildCreate" : "guildAvailable", guild);
-	else client.emit("guildUpdate", guild);
-}
-registerHandler(GatewayDispatchEvents.GuildCreate, onCreateAndUpdate);
-registerHandler(GatewayDispatchEvents.GuildUpdate, onCreateAndUpdate);
+registerHandler(GatewayDispatchEvents.GuildCreate, (client, payload) => {
+	const guild = client.cache.resolveLocal(client.cache.guilds, payload.d.id, () => new Guild(client, payload.d), (g) => g._patch(payload.d));
+	for (const data of payload.d.channels) client.channels.resolve(data);
+	for (const thread of payload.d.threads) client.channels.resolve(thread);
+	client.emit(payload.d.unavailable ? "guildCreate" : "guildAvailable", guild);
+});
+registerHandler(GatewayDispatchEvents.GuildUpdate, (client, payload) => {
+	const guild = client.cache.resolveLocal(client.cache.guilds, payload.d.id, () => new Guild(client, payload.d), (g) => g._patch(payload.d));
+	client.emit("guildUpdate", guild);
+});
 registerHandler(GatewayDispatchEvents.GuildDelete, async (client, payload) => {
 	const guild = client.cache.guilds.get(payload.d.id);
 	if (!guild) return;
@@ -787,20 +1072,28 @@ registerHandler(GatewayDispatchEvents.GuildDelete, async (client, payload) => {
 //#endregion
 //#region src/lib/client/dispatches/handlers/channel.ts
 async function onCreateOrUpdate(client, payload) {
-	const channel = await client.cache.resolve(client.cache.channels, payload.d.id, () => createChannel(client, payload.d), (c) => c?._patch(payload.d));
-	if (!channel) return;
+	let channel = client.cache.channels.get(payload.d.id);
+	if (channel && channel.type === payload.d.type) channel._patch(payload.d);
+	else {
+		channel = ClientChannelManager.create(client, payload.d);
+		client.cache.channels.set(payload.d.id, channel);
+	}
 	if (channel.inGuild() && !channel.guild.channels.has(channel.id)) channel.guild.channels.set(channel.id, channel);
+	if (channel.partial && !client.options.partials.has(Partial.Channel)) return;
 	client.emit(payload.t === GatewayDispatchEvents.ChannelCreate ? "channelCreate" : "channelUpdate", channel);
 }
 registerHandler(GatewayDispatchEvents.ChannelCreate, onCreateOrUpdate);
 registerHandler(GatewayDispatchEvents.ChannelUpdate, onCreateOrUpdate);
-registerHandler(GatewayDispatchEvents.ChannelDelete, (client, payload) => {
-	const channel = client.cache.channels.get(payload.d.id);
+registerHandler(GatewayDispatchEvents.ChannelDelete, async (client, payload) => {
+	const channel = client.channels.resolve(payload.d);
 	const guild = client.cache.guilds.get(payload.d.guild_id);
 	if (guild) guild.channels.delete(payload.d.id);
-	if (!channel) return;
 	client.cache.channels.delete(payload.d.id);
-	client.emit("channelDelete", channel);
+	if (!channel.partial || client.options.partials.has(Partial.Channel)) client.emit("channelDelete", channel);
+	if (client.cache.isModuleEnabled("messages")) await Promise.all(client.cache.messages.local.map((message) => {
+		if (message.channelId !== payload.d.id) return;
+		return client.cache.messages.delete(message.id);
+	}));
 });
 
 //#endregion
@@ -813,14 +1106,65 @@ registerHandler(GatewayDispatchEvents.UserUpdate, async (client, payload) => {
 	client.emit("userUpdate", user);
 });
 
+//#endregion
+//#region src/lib/client/dispatches/handlers/thread.ts
+function resolveThread(client, payload) {
+	let thread = client.cache.channels.get(payload.id);
+	if (!thread?.isThread()) {
+		thread = ClientChannelManager.create(client, payload);
+		client.cache.channels.set(payload.id, thread);
+		thread.guild.channels.set(payload.id, thread);
+	} else thread._patch(payload);
+	if ("member" in payload) {}
+	return thread;
+}
+registerHandler(GatewayDispatchEvents.ThreadCreate, (client, payload) => {
+	const thread = resolveThread(client, payload.d);
+	if (thread.partial && !client.options.partials.has(Partial.Channel)) return;
+	client.emit("threadCreate", thread);
+});
+registerHandler(GatewayDispatchEvents.ThreadUpdate, (client, payload) => {
+	const thread = resolveThread(client, payload.d);
+	if (thread.partial && !client.options.partials.has(Partial.Channel)) return;
+	client.emit("threadUpdate", thread);
+});
+registerHandler(GatewayDispatchEvents.ThreadDelete, (client, payload) => {
+	let thread = client.cache.channels.get(payload.d.id);
+	if (thread) client.cache.channels.delete(payload.d.id);
+	else thread = ClientChannelManager.create(client, {
+		id: payload.d.id,
+		guild_id: payload.d.guild_id,
+		parent_id: payload.d.parent_id,
+		type: payload.d.type
+	});
+	if (!thread.isThread()) return;
+	if (thread.partial && !client.options.partials.has(Partial.Channel)) return;
+	client.emit("threadDelete", thread);
+});
+registerHandler(GatewayDispatchEvents.ThreadListSync, (client, payload) => {
+	for (const thread of payload.d.threads) resolveThread(client, thread);
+});
+
+//#endregion
+//#region src/lib/client/dispatches/handlers/member.ts
+registerHandler(GatewayDispatchEvents.TypingStart, async (client, payload) => {
+	const typing = new Typing(client, payload.d);
+	client.emit("typingStart", typing);
+});
+
 //#endregion
 //#region src/lib/client/Client.ts
 var Client = class extends EventEmitter {
 	options;
 	shards;
 	rest;
+	/**
+	* @private
+	* @deprecated
+	*/
 	helper;
 	cache;
+	channels;
 	#user;
 	#ready = false;
 	constructor(options, rest) {
@@ -844,6 +1188,7 @@ var Client = class extends EventEmitter {
 			intents: this.options.intents.toBigInt()
 		}, rest);
 		this.cache = new ClientCacheManager(this.options.cache);
+		this.channels = new ClientChannelManager(this);
 		this.helper = new ClientHelper(this);
 		this.#setupShardsListeners();
 	}
@@ -904,5 +1249,5 @@ function createClient(options) {
 }
 
 //#endregion
-export { BaseCacheAdapter, BaseChannel, Client, ClientHelper, Cluster, DEFAULT_REST_OPTIONS, DiscordAPIV10, DiscordHTTPError, Guild, GuildTextChannel, GuildVoiceChannel, HybridCache, Intent, IntentsBitField, LocalCacheAdapter, Message, Partial, REST, RESTAdapter, RESTMethod, Service, ServiceDriver, ServiceProcess, ServiceState, Shard, ShardState, ShardStrategy, ShardingManager, TransportClient, TransportServer, User, capitalize, createClient, createREST, createRESTAdapter, createService, createTransportClient, createTransportServer, instanceToObject, isCommonJS, isESM, isPlainObject, isPromiseLike, promisify, sleep };
+export { BaseCacheAdapter, BaseChannel, Client, ClientHelper, Cluster, DEFAULT_REST_OPTIONS, DMChannel, DiscordAPIV10, DiscordHTTPError, Guild, GuildAnnouncementChannel, GuildCategory, GuildForumChannel, GuildStageVoiceChannel, GuildTextChannel, GuildVoiceChannel, HybridCache, Intent, IntentsBitField, LocalCacheAdapter, Message, Partial, REST, RESTAdapter, RESTMethod, Service, ServiceDriver, ServiceProcess, ServiceState, Shard, ShardState, ShardStrategy, ShardingManager, Tag, ThreadChannel, TransportClient, TransportServer, Typing, User, capitalize, createClient, createREST, createRESTAdapter, createService, createTransportClient, createTransportServer, instanceToObject, isCommonJS, isESM, isPlainObject, isPromiseLike, promisify, sleep };
 //# sourceMappingURL=index.mjs.map