seyfert 1.2.3 → 1.3.1

package/lib/common/shorters/guilds.d.ts

@@ -1,6 +1,6 @@
 import type { GuildWidgetStyle, RESTGetAPICurrentUserGuildsQuery, RESTPatchAPIAutoModerationRuleJSONBody, RESTPatchAPIChannelJSONBody, RESTPatchAPIGuildChannelPositionsJSONBody, RESTPatchAPIGuildStickerJSONBody, RESTPostAPIAutoModerationRuleJSONBody, RESTPostAPIGuildChannelJSONBody, RESTPostAPIGuildsJSONBody } from 'discord-api-types/v10';
-import type { ObjectToLower } from '..';
-import { AnonymousGuild, Guild, GuildMember, Sticker, type CreateStickerBodyRequest } from '../../structures';
+import { type ObjectToLower } from '..';
+import { AnonymousGuild, AutoModerationRule, Guild, GuildMember, Sticker, type CreateStickerBodyRequest } from '../../structures';
 import { BaseShorter } from './base';
 export declare class GuildShorter extends BaseShorter {
     /**
@@ -75,6 +75,7 @@ export declare class GuildShorter extends BaseShorter {
          * @param body The data containing the new positions of channels.
          */
         editPositions: (guildId: string, body: RESTPatchAPIGuildChannelPositionsJSONBody) => Promise<never>;
+        addFollower: (channelId: string, webhook_channel_id: string, reason?: string) => Promise<import("discord-api-types/v10").APIFollowedChannel>;
     };
     /**
      * Provides access to auto-moderation rule-related functionality in a guild.
@@ -85,14 +86,14 @@ export declare class GuildShorter extends BaseShorter {
          * @param guildId The ID of the guild.
          * @returns A Promise that resolves to an array of auto-moderation rules.
          */
-        list: (guildId: string) => Promise<import("discord-api-types/v10").RESTGetAPIAutoModerationRulesResult>;
+        list: (guildId: string) => Promise<AutoModerationRule[]>;
         /**
          * Creates a new auto-moderation rule in the guild.
          * @param guildId The ID of the guild.
          * @param body The data for creating the auto-moderation rule.
          * @returns A Promise that resolves to the created auto-moderation rule.
          */
-        create: (guildId: string, body: RESTPostAPIAutoModerationRuleJSONBody) => Promise<import("discord-api-types/v10").APIAutoModerationRule>;
+        create: (guildId: string, body: RESTPostAPIAutoModerationRuleJSONBody) => Promise<AutoModerationRule>;
         /**
          * Deletes an auto-moderation rule from the guild.
          * @param guildId The ID of the guild.
@@ -107,7 +108,7 @@ export declare class GuildShorter extends BaseShorter {
          * @param ruleId The ID of the rule to fetch.
          * @returns A Promise that resolves to the fetched auto-moderation rule.
          */
-        fetch: (guildId: string, ruleId: string) => Promise<import("discord-api-types/v10").APIAutoModerationRule>;
+        fetch: (guildId: string, ruleId: string) => Promise<AutoModerationRule>;
         /**
          * Edits an auto-moderation rule in the guild.
          * @param guildId The ID of the guild.
@@ -116,7 +117,7 @@ export declare class GuildShorter extends BaseShorter {
          * @param reason The reason for editing the rule.
          * @returns A Promise that resolves to the edited auto-moderation rule.
          */
-        edit: (guildId: string, ruleId: string, body: ObjectToLower<RESTPatchAPIAutoModerationRuleJSONBody>, reason?: string) => Promise<import("discord-api-types/v10").APIAutoModerationRule>;
+        edit: (guildId: string, ruleId: string, body: ObjectToLower<RESTPatchAPIAutoModerationRuleJSONBody>, reason?: string) => Promise<AutoModerationRule>;
     };
     /**
      * Provides access to sticker-related functionality in a guild.

package/lib/common/shorters/guilds.js

@@ -4,6 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GuildShorter = void 0;
+const __1 = require("..");
 const builders_1 = require("../../builders");
 const structures_1 = require("../../structures");
 const channels_1 = __importDefault(require("../../structures/channels"));
@@ -154,6 +155,14 @@ class GuildShorter extends base_1.BaseShorter {
              * @param body The data containing the new positions of channels.
              */
             editPositions: (guildId, body) => this.client.proxy.guilds(guildId).channels.patch({ body }),
+            addFollower: async (channelId, webhook_channel_id, reason) => {
+                return this.client.proxy.channels(channelId).followers.post({
+                    body: {
+                        webhook_channel_id,
+                    },
+                    reason,
+                });
+            },
         };
     }
     /**
@@ -166,14 +175,18 @@ class GuildShorter extends base_1.BaseShorter {
              * @param guildId The ID of the guild.
              * @returns A Promise that resolves to an array of auto-moderation rules.
              */
-            list: (guildId) => this.client.proxy.guilds(guildId)['auto-moderation'].rules.get(),
+            list: (guildId) => this.client.proxy
+                .guilds(guildId)['auto-moderation'].rules.get()
+                .then(rules => rules.map(rule => new structures_1.AutoModerationRule(this.client, rule))),
             /**
              * Creates a new auto-moderation rule in the guild.
              * @param guildId The ID of the guild.
              * @param body The data for creating the auto-moderation rule.
              * @returns A Promise that resolves to the created auto-moderation rule.
              */
-            create: (guildId, body) => this.client.proxy.guilds(guildId)['auto-moderation'].rules.post({ body }),
+            create: (guildId, body) => this.client.proxy
+                .guilds(guildId)['auto-moderation'].rules.post({ body })
+                .then(rule => new structures_1.AutoModerationRule(this.client, rule)),
             /**
              * Deletes an auto-moderation rule from the guild.
              * @param guildId The ID of the guild.
@@ -191,7 +204,10 @@ class GuildShorter extends base_1.BaseShorter {
              * @returns A Promise that resolves to the fetched auto-moderation rule.
              */
             fetch: (guildId, ruleId) => {
-                return this.client.proxy.guilds(guildId)['auto-moderation'].rules(ruleId).get();
+                return this.client.proxy
+                    .guilds(guildId)['auto-moderation'].rules(ruleId)
+                    .get()
+                    .then(rule => new structures_1.AutoModerationRule(this.client, rule));
             },
             /**
              * Edits an auto-moderation rule in the guild.
@@ -202,7 +218,10 @@ class GuildShorter extends base_1.BaseShorter {
              * @returns A Promise that resolves to the edited auto-moderation rule.
              */
             edit: (guildId, ruleId, body, reason) => {
-                return this.client.proxy.guilds(guildId)['auto-moderation'].rules(ruleId).patch({ body, reason });
+                return this.client.proxy
+                    .guilds(guildId)['auto-moderation'].rules(ruleId)
+                    .patch({ body: (0, __1.toSnakeCase)(body), reason })
+                    .then(rule => new structures_1.AutoModerationRule(this.client, rule));
             },
         };
     }

package/lib/common/shorters/interaction.d.ts

@@ -0,0 +1,13 @@
+import { WebhookMessage, type ReplyInteractionBody } from '../..';
+import type { InteractionMessageUpdateBodyRequest, MessageWebhookCreateBodyRequest } from '../types/write';
+import { BaseShorter } from './base';
+export declare class InteractionShorter extends BaseShorter {
+    reply(id: string, token: string, body: ReplyInteractionBody): Promise<never>;
+    fetchResponse(token: string, messageId: string): Promise<WebhookMessage | undefined>;
+    fetchOriginal(token: string): Promise<WebhookMessage | undefined>;
+    editMessage(token: string, messageId: string, body: InteractionMessageUpdateBodyRequest): Promise<WebhookMessage>;
+    editOriginal(token: string, body: InteractionMessageUpdateBodyRequest): Promise<WebhookMessage>;
+    deleteResponse(interactionId: string, token: string, messageId: string): Promise<void | undefined>;
+    deleteOriginal(interactionId: string, token: string): Promise<void | undefined>;
+    followup(token: string, { files, ...body }: MessageWebhookCreateBodyRequest): Promise<WebhookMessage>;
+}

package/lib/common/shorters/interaction.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InteractionShorter = void 0;
+const __1 = require("../..");
+const base_1 = require("./base");
+class InteractionShorter extends base_1.BaseShorter {
+    async reply(id, token, body) {
+        //@ts-expect-error
+        const { files, ...data } = body.data ?? {};
+        return this.client.proxy
+            .interactions(id)(token)
+            .callback.post({
+            body: __1.BaseInteraction.transformBodyRequest({
+                type: body.type,
+                data,
+            }),
+            files: files ? await (0, __1.resolveFiles)(files) : undefined,
+        });
+    }
+    fetchResponse(token, messageId) {
+        return this.client.webhooks.fetchMessage(this.client.applicationId, token, messageId);
+    }
+    fetchOriginal(token) {
+        return this.fetchResponse(token, '@original');
+    }
+    async editMessage(token, messageId, body) {
+        const { files, ...data } = body;
+        const apiMessage = await this.client.proxy
+            .webhooks(this.client.applicationId)(token)
+            .messages(messageId)
+            .patch({
+            body: __1.BaseInteraction.transformBody(data),
+            files: files ? await (0, __1.resolveFiles)(files) : undefined,
+        });
+        return new __1.WebhookMessage(this.client, apiMessage, this.client.applicationId, token);
+    }
+    editOriginal(token, body) {
+        return this.editMessage(token, '@original', body);
+    }
+    deleteResponse(interactionId, token, messageId) {
+        return this.client.proxy
+            .webhooks(this.client.applicationId)(token)
+            .messages(messageId)
+            .delete()
+            .then(() => this.client.components?.onMessageDelete(messageId === '@original' ? interactionId : messageId));
+    }
+    deleteOriginal(interactionId, token) {
+        return this.deleteResponse(interactionId, token, '@original');
+    }
+    async followup(token, { files, ...body }) {
+        files = files ? await (0, __1.resolveFiles)(files) : undefined;
+        const apiMessage = await this.client.proxy
+            .webhooks(this.client.applicationId)(token)
+            .post({
+            body: __1.BaseInteraction.transformBody(body),
+            files: files,
+        });
+        return new __1.WebhookMessage(this.client, apiMessage, this.client.applicationId, token);
+    }
+}
+exports.InteractionShorter = InteractionShorter;

package/lib/common/shorters/messages.d.ts

@@ -1,15 +1,18 @@
 import type { RESTPostAPIChannelMessagesThreadsJSONBody } from 'discord-api-types/v10';
-import { Message, type ThreadChannel } from '../../structures';
+import { Message, User } from '../../structures';
 import type { MessageCreateBodyRequest, MessageUpdateBodyRequest } from '../types/write';
 import { BaseShorter } from './base';
+import type { ValidAnswerId } from '../../api/Routes/channels';
 export declare class MessageShorter extends BaseShorter {
     write(channelId: string, { files, ...body }: MessageCreateBodyRequest): Promise<Message>;
     edit(messageId: string, channelId: string, { files, ...body }: MessageUpdateBodyRequest): Promise<Message>;
     crosspost(messageId: string, channelId: string, reason?: string): Promise<Message>;
     delete(messageId: string, channelId: string, reason?: string): Promise<void>;
     fetch(messageId: string, channelId: string): Promise<Message>;
-    purge(messages: string[], channelId: string, reason?: string): Promise<never>;
+    purge(messages: string[], channelId: string, reason?: string): Promise<void | undefined>;
     thread(channelId: string, messageId: string, options: RESTPostAPIChannelMessagesThreadsJSONBody & {
         reason?: string;
-    }): Promise<ThreadChannel>;
+    }): Promise<import("../../structures").ThreadChannel>;
+    endPoll(channelId: string, messageId: string): Promise<Message>;
+    getAnswerVoters(channelId: string, messageId: string, answerId: ValidAnswerId): Promise<User[]>;
 }

package/lib/common/shorters/messages.js

@@ -1,12 +1,8 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MessageShorter = void 0;
 const builders_1 = require("../../builders");
 const structures_1 = require("../../structures");
-const channels_1 = __importDefault(require("../../structures/channels"));
 const base_1 = require("./base");
 class MessageShorter extends base_1.BaseShorter {
     async write(channelId, { files, ...body }) {
@@ -18,7 +14,8 @@ class MessageShorter extends base_1.BaseShorter {
             body: transformedBody,
             files: parsedFiles,
         })
-            .then(message => {
+            .then(async (message) => {
+            await this.client.cache.messages?.setIfNI('GuildMessages', message.id, message.channel_id, message);
             return new structures_1.Message(this.client, message);
         });
     }
@@ -31,7 +28,8 @@ class MessageShorter extends base_1.BaseShorter {
             body: structures_1.MessagesMethods.transformMessageBody(body),
             files: parsedFiles,
         })
-            .then(message => {
+            .then(async (message) => {
+            await this.client.cache.messages?.setIfNI('GuildMessages', message.id, message.channel_id, message);
             return new structures_1.Message(this.client, message);
         });
     }
@@ -40,14 +38,18 @@ class MessageShorter extends base_1.BaseShorter {
             .channels(channelId)
             .messages(messageId)
             .crosspost.post({ reason })
-            .then(m => new structures_1.Message(this.client, m));
+            .then(async (m) => {
+            await this.client.cache.messages?.setIfNI('GuildMessages', m.id, m.channel_id, m);
+            return new structures_1.Message(this.client, m);
+        });
     }
     delete(messageId, channelId, reason) {
         return this.client.proxy
             .channels(channelId)
             .messages(messageId)
             .delete({ reason })
-            .then(() => {
+            .then(async () => {
+            await this.client.cache.messages?.removeIfNI('GuildMessages', messageId, channelId);
             void this.client.components?.onMessageDelete(messageId);
         });
     }
@@ -56,18 +58,34 @@ class MessageShorter extends base_1.BaseShorter {
             .channels(channelId)
             .messages(messageId)
             .get()
-            .then(x => new structures_1.Message(this.client, x));
+            .then(async (x) => {
+            await this.client.cache.messages?.set(x.id, x.channel_id, x);
+            return new structures_1.Message(this.client, x);
+        });
     }
     purge(messages, channelId, reason) {
-        return this.client.proxy.channels(channelId).messages['bulk-delete'].post({ body: { messages }, reason });
+        return this.client.proxy
+            .channels(channelId)
+            .messages['bulk-delete'].post({ body: { messages }, reason })
+            .then(() => this.client.cache.messages?.removeIfNI('GuildMessages', messages, channelId));
+    }
+    thread(channelId, messageId, options) {
+        return this.client.threads.fromMessage(channelId, messageId, options);
     }
-    async thread(channelId, messageId, options) {
-        const { reason, ...body } = options;
+    endPoll(channelId, messageId) {
         return this.client.proxy
             .channels(channelId)
-            .messages(messageId)
-            .threads.post({ body, reason })
-            .then(thread => (0, channels_1.default)(thread, this.client));
+            .polls(messageId)
+            .expire.post()
+            .then(message => new structures_1.Message(this.client, message));
+    }
+    getAnswerVoters(channelId, messageId, answerId) {
+        return this.client.proxy
+            .channels(channelId)
+            .polls(messageId)
+            .answers(answerId)
+            .get()
+            .then(data => data.users.map(user => new structures_1.User(this.client, user)));
     }
 }
 exports.MessageShorter = MessageShorter;

package/lib/common/shorters/roles.d.ts

@@ -9,7 +9,7 @@ export declare class RoleShorter extends BaseShorter {
      * @param reason The reason for creating the role.
      * @returns A Promise that resolves when the role is created.
      */
-    create(guildId: string, body: RESTPostAPIGuildRoleJSONBody, reason?: string): Promise<any>;
+    create(guildId: string, body: RESTPostAPIGuildRoleJSONBody, reason?: string): Promise<GuildRole>;
     /**
      * Retrieves a list of roles in the guild.
      * @param guildId The ID of the guild.
@@ -25,7 +25,7 @@ export declare class RoleShorter extends BaseShorter {
      * @param reason The reason for editing the role.
      * @returns A Promise that resolves when the role is edited.
      */
-    edit(guildId: string, roleId: string, body: RESTPatchAPIGuildRoleJSONBody, reason?: string): Promise<any>;
+    edit(guildId: string, roleId: string, body: RESTPatchAPIGuildRoleJSONBody, reason?: string): Promise<GuildRole>;
     /**
      * Deletes a role from the guild.
      * @param guildId The ID of the guild.
@@ -33,7 +33,7 @@ export declare class RoleShorter extends BaseShorter {
      * @param reason The reason for deleting the role.
      * @returns A Promise that resolves when the role is deleted.
      */
-    delete(guildId: string, roleId: string, reason?: string): Promise<void | undefined>;
+    delete(guildId: string, roleId: string, reason?: string): Promise<GuildRole>;
     /**
      * Edits the positions of roles in the guild.
      * @param guildId The ID of the guild.

package/lib/common/shorters/roles.js

@@ -11,11 +11,10 @@ class RoleShorter extends base_1.BaseShorter {
      * @param reason The reason for creating the role.
      * @returns A Promise that resolves when the role is created.
      */
-    create(guildId, body, reason) {
-        return this.client.proxy
-            .guilds(guildId)
-            .roles.post({ body, reason })
-            .then(res => this.client.cache.roles?.setIfNI('Guilds', res.id, guildId, res));
+    async create(guildId, body, reason) {
+        const res = await this.client.proxy.guilds(guildId).roles.post({ body, reason });
+        await this.client.cache.roles?.setIfNI('Guilds', res.id, guildId, res);
+        return new structures_1.GuildRole(this.client, res, guildId);
     }
     /**
      * Retrieves a list of roles in the guild.
@@ -43,12 +42,10 @@ class RoleShorter extends base_1.BaseShorter {
      * @param reason The reason for editing the role.
      * @returns A Promise that resolves when the role is edited.
      */
-    edit(guildId, roleId, body, reason) {
-        return this.client.proxy
-            .guilds(guildId)
-            .roles(roleId)
-            .patch({ body, reason })
-            .then(res => this.client.cache.roles?.setIfNI('Guilds', roleId, guildId, res));
+    async edit(guildId, roleId, body, reason) {
+        const res = await this.client.proxy.guilds(guildId).roles(roleId).patch({ body, reason });
+        await this.client.cache.roles?.setIfNI('Guilds', roleId, guildId, res);
+        return new structures_1.GuildRole(this.client, res, guildId);
     }
     /**
      * Deletes a role from the guild.
@@ -57,12 +54,10 @@ class RoleShorter extends base_1.BaseShorter {
      * @param reason The reason for deleting the role.
      * @returns A Promise that resolves when the role is deleted.
      */
-    delete(guildId, roleId, reason) {
-        return this.client.proxy
-            .guilds(guildId)
-            .roles(roleId)
-            .delete({ reason })
-            .then(() => this.client.cache.roles?.removeIfNI('Guilds', roleId, guildId));
+    async delete(guildId, roleId, reason) {
+        const res = await this.client.proxy.guilds(guildId).roles(roleId).delete({ reason });
+        this.client.cache.roles?.removeIfNI('Guilds', roleId, guildId);
+        return new structures_1.GuildRole(this.client, res, guildId);
     }
     /**
      * Edits the positions of roles in the guild.

package/lib/common/shorters/templates.d.ts

@@ -1,10 +1,11 @@
 import type { RESTPatchAPIGuildTemplateJSONBody, RESTPostAPIGuildTemplatesJSONBody } from 'discord-api-types/v10';
 import { BaseShorter } from './base';
+import { GuildTemplate } from '../..';
 export declare class TemplateShorter extends BaseShorter {
-    fetch(code: string): Promise<import("discord-api-types/v10").APITemplate>;
-    list(guildId: string): Promise<import("discord-api-types/v10").RESTGetAPIGuildTemplatesResult>;
-    create(guildId: string, body: RESTPostAPIGuildTemplatesJSONBody): Promise<import("discord-api-types/v10").APITemplate>;
-    sync(guildId: string, code: string): Promise<import("discord-api-types/v10").APITemplate>;
-    edit(guildId: string, code: string, body: RESTPatchAPIGuildTemplateJSONBody): Promise<import("discord-api-types/v10").APITemplate>;
-    delete(guildId: string, code: string): Promise<import("discord-api-types/v10").APITemplate>;
+    fetch(code: string): Promise<GuildTemplate>;
+    list(guildId: string): Promise<GuildTemplate[]>;
+    create(guildId: string, body: RESTPostAPIGuildTemplatesJSONBody): Promise<GuildTemplate>;
+    sync(guildId: string, code: string): Promise<GuildTemplate>;
+    edit(guildId: string, code: string, body: RESTPatchAPIGuildTemplateJSONBody): Promise<GuildTemplate>;
+    delete(guildId: string, code: string): Promise<GuildTemplate>;
 }

package/lib/common/shorters/templates.js

@@ -2,24 +2,46 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TemplateShorter = void 0;
 const base_1 = require("./base");
+const __1 = require("../..");
 class TemplateShorter extends base_1.BaseShorter {
     fetch(code) {
-        return this.client.proxy.guilds.templates(code).get();
+        return this.client.proxy.guilds
+            .templates(code)
+            .get()
+            .then(template => new __1.GuildTemplate(this.client, template));
     }
     list(guildId) {
-        return this.client.proxy.guilds(guildId).templates.get();
+        return this.client.proxy
+            .guilds(guildId)
+            .templates.get()
+            .then(list => list.map(template => new __1.GuildTemplate(this.client, template)));
     }
     create(guildId, body) {
-        return this.client.proxy.guilds(guildId).templates.post({ body });
+        return this.client.proxy
+            .guilds(guildId)
+            .templates.post({ body })
+            .then(template => new __1.GuildTemplate(this.client, template));
     }
     sync(guildId, code) {
-        return this.client.proxy.guilds(guildId).templates(code).put({});
+        return this.client.proxy
+            .guilds(guildId)
+            .templates(code)
+            .put({})
+            .then(template => new __1.GuildTemplate(this.client, template));
     }
     edit(guildId, code, body) {
-        return this.client.proxy.guilds(guildId).templates(code).patch({ body });
+        return this.client.proxy
+            .guilds(guildId)
+            .templates(code)
+            .patch({ body })
+            .then(template => new __1.GuildTemplate(this.client, template));
     }
     delete(guildId, code) {
-        return this.client.proxy.guilds(guildId).templates(code).delete();
+        return this.client.proxy
+            .guilds(guildId)
+            .templates(code)
+            .delete()
+            .then(template => new __1.GuildTemplate(this.client, template));
     }
 }
 exports.TemplateShorter = TemplateShorter;

package/lib/common/shorters/threads.d.ts

@@ -0,0 +1,39 @@
+import type { APIThreadMember, RESTGetAPIChannelThreadMembersQuery, RESTGetAPIChannelThreadsArchivedQuery, RESTPatchAPIChannelJSONBody, RESTPostAPIChannelMessagesThreadsJSONBody, RESTPostAPIChannelThreadsJSONBody, RESTPostAPIGuildForumThreadsJSONBody } from 'discord-api-types/v10';
+import type { ThreadChannel } from '../../structures';
+import { BaseShorter } from './base';
+import type { MakeRequired, When } from '../types/util';
+export declare class ThreadShorter extends BaseShorter {
+    /**
+     * Creates a new thread in the channel (only guild based channels).
+     * @param channelId The ID of the parent channel.
+     * @param reason The reason for unpinning the message.
+     * @returns A promise that resolves when the thread is succesfully created.
+     */
+    create(channelId: string, body: RESTPostAPIChannelThreadsJSONBody | RESTPostAPIGuildForumThreadsJSONBody, reason?: string): Promise<ThreadChannel>;
+    fromMessage(channelId: string, messageId: string, options: RESTPostAPIChannelMessagesThreadsJSONBody & {
+        reason?: string;
+    }): Promise<ThreadChannel>;
+    join(threadId: string): Promise<never>;
+    leave(threadId: string): Promise<never>;
+    lock(threadId: string, locked?: boolean, reason?: string): Promise<ThreadChannel>;
+    edit(threadId: string, body: RESTPatchAPIChannelJSONBody, reason?: string): Promise<import("../../structures").AllChannels>;
+    removeMember(threadId: string, memberId: string): Promise<never>;
+    fetchMember<WithMember extends boolean = false>(threadId: string, memberId: string, with_member: WithMember): Promise<When<WithMember, Required<APIThreadMember>, GetAPIChannelThreadMemberResult>>;
+    addMember(threadId: string, memberId: string): Promise<never>;
+    listMembers<T extends RESTGetAPIChannelThreadMembersQuery = RESTGetAPIChannelThreadMembersQuery>(threadId: string, query?: T): Promise<InferWithMemberOnList<T>>;
+    listArchivedThreads(channelId: string, type: 'public' | 'private', query?: RESTGetAPIChannelThreadsArchivedQuery): Promise<{
+        threads: ThreadChannel[];
+        members: GetAPIChannelThreadMemberResult[];
+        hasMore: boolean;
+    }>;
+    listJoinedArchivedPrivate(channelId: string, query?: RESTGetAPIChannelThreadsArchivedQuery): Promise<{
+        threads: ThreadChannel[];
+        members: GetAPIChannelThreadMemberResult[];
+        hasMore: boolean;
+    }>;
+}
+export type GetAPIChannelThreadMemberResult = MakeRequired<APIThreadMember, 'id' | 'user_id'>;
+type InferWithMemberOnList<T extends RESTGetAPIChannelThreadMembersQuery> = T extends {
+    with_member: infer B;
+} ? B extends true ? Required<APIThreadMember>[] : GetAPIChannelThreadMemberResult[] : GetAPIChannelThreadMemberResult[];
+export {};

package/lib/common/shorters/threads.js

@@ -0,0 +1,76 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ThreadShorter = void 0;
+const channels_1 = __importDefault(require("../../structures/channels"));
+const base_1 = require("./base");
+class ThreadShorter extends base_1.BaseShorter {
+    /**
+     * Creates a new thread in the channel (only guild based channels).
+     * @param channelId The ID of the parent channel.
+     * @param reason The reason for unpinning the message.
+     * @returns A promise that resolves when the thread is succesfully created.
+     */
+    async create(channelId, body, reason) {
+        return (this.client.proxy
+            .channels(channelId)
+            .threads.post({ body, reason })
+            // When testing this, discord returns the thread object, but in discord api types it does not.
+            .then(thread => (0, channels_1.default)(thread, this.client)));
+    }
+    async fromMessage(channelId, messageId, options) {
+        const { reason, ...body } = options;
+        return this.client.proxy
+            .channels(channelId)
+            .messages(messageId)
+            .threads.post({ body, reason })
+            .then(thread => (0, channels_1.default)(thread, this.client));
+    }
+    async join(threadId) {
+        return this.client.proxy.channels(threadId)['thread-members']('@me').put();
+    }
+    async leave(threadId) {
+        return this.client.proxy.channels(threadId)['thread-members']('@me').delete();
+    }
+    async lock(threadId, locked = true, reason) {
+        return this.edit(threadId, { locked }, reason).then(x => (0, channels_1.default)(x, this.client));
+    }
+    async edit(threadId, body, reason) {
+        return this.client.channels.edit(threadId, body, { reason });
+    }
+    async removeMember(threadId, memberId) {
+        return this.client.proxy.channels(threadId)['thread-members'](memberId).delete();
+    }
+    async fetchMember(threadId, memberId, with_member) {
+        return this.client.proxy.channels(threadId)['thread-members'](memberId).get({
+            query: {
+                with_member,
+            },
+        });
+    }
+    async addMember(threadId, memberId) {
+        return this.client.proxy.channels(threadId)['thread-members'](memberId).put();
+    }
+    async listMembers(threadId, query) {
+        return this.client.proxy.channels(threadId)['thread-members'].get({ query });
+    }
+    async listArchivedThreads(channelId, type, query) {
+        const data = await this.client.proxy.channels(channelId).threads.archived[type].get({ query });
+        return {
+            threads: data.threads.map(thread => (0, channels_1.default)(thread, this.client)),
+            members: data.members,
+            hasMore: data.has_more,
+        };
+    }
+    async listJoinedArchivedPrivate(channelId, query) {
+        const data = await this.client.proxy.channels(channelId).users('@me').threads.archived.private.get({ query });
+        return {
+            threads: data.threads.map(thread => (0, channels_1.default)(thread, this.client)),
+            members: data.members,
+            hasMore: data.has_more,
+        };
+    }
+}
+exports.ThreadShorter = ThreadShorter;

package/lib/common/shorters/webhook.d.ts

@@ -17,7 +17,7 @@ export declare class WebhookShorter extends BaseShorter {
      * @param options The optional parameters including token and reason.
      * @returns A Promise that resolves when the webhook is edited.
      */
-    edit(webhookId: string, body: RESTPatchAPIWebhookWithTokenJSONBody | RESTPatchAPIWebhookJSONBody, options: WebhookShorterOptionalParams): Promise<import("discord-api-types/v10").RESTGetAPIWebhookWithTokenResult>;
+    edit(webhookId: string, body: RESTPatchAPIWebhookWithTokenJSONBody | RESTPatchAPIWebhookJSONBody, options: WebhookShorterOptionalParams): Promise<Webhook>;
     /**
      * Fetches a webhook.
      * @param webhookId The ID of the webhook.

package/lib/common/shorters/webhook.js

@@ -32,9 +32,15 @@ class WebhookShorter extends base_1.BaseShorter {
      */
     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)(options.token)
+                .patch({ body, reason: options.reason, auth: false })
+                .then(webhook => new structures_1.Webhook(this.client, webhook));
         }
-        return this.client.proxy.webhooks(webhookId).patch({ body, reason: options.reason });
+        return this.client.proxy
+            .webhooks(webhookId)
+            .patch({ body, reason: options.reason })
+            .then(webhook => new structures_1.Webhook(this.client, webhook));
     }
     /**
      * Fetches a webhook.

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

@@ -49,10 +49,16 @@ export type NonFalsy<T> = T extends false | 0 | '' | null | undefined | 0n ? nev
 export type CamelCase<S extends string> = S extends `${infer P1}_${infer P2}${infer P3}` ? `${Lowercase<P1>}${Uppercase<P2>}${CamelCase<P3>}` : Lowercase<S>;
 export type SnakeCase<S extends string> = S extends `${infer A}${infer Rest}` ? A extends Uppercase<A> ? `_${Lowercase<A>}${SnakeCase<Rest>}` : `${A}${SnakeCase<Rest>}` : Lowercase<S>;
 export type ObjectToLower<T> = Identify<{
-    [K in keyof T as CamelCase<Exclude<K, symbol | number>>]: T[K] extends unknown[] ? Identify<ObjectToLower<T[K][0]>[]> : T[K] extends object ? Identify<ObjectToLower<T[K]>> : T[K];
+    [K in keyof T as CamelCase<Exclude<K, symbol | number>>]: T[K] extends unknown[] ? Identify<ObjectToLower<T[K][0]>[]> : T[K] extends object ? Identify<ObjectToLower<T[K]>> : AuxIsStrictlyUndefined<T[K]> extends true ? undefined : ObjectToLowerUndefined<T[K]>;
+}>;
+export type ObjectToLowerUndefined<T> = T extends unknown[] ? ObjectToLower<T[0]>[] : Identify<{
+    [K in keyof T as CamelCase<Exclude<K, symbol | number>>]?: T[K] extends unknown[] ? ObjectToLower<T[K][0]>[] : T[K] extends object ? ObjectToLower<T[K]> : T[K];
 }>;
 export type ObjectToSnake<T> = Identify<{
-    [K in keyof T as SnakeCase<Exclude<K, symbol | number>>]: T[K] extends unknown[] ? Identify<ObjectToSnake<T[K][0]>[]> : T[K] extends object ? Identify<ObjectToSnake<T[K]>> : T[K];
+    [K in keyof T as SnakeCase<Exclude<K, symbol | number>>]: T[K] extends unknown[] ? Identify<ObjectToSnake<T[K][0]>[]> : T[K] extends object ? Identify<ObjectToSnake<T[K]>> : AuxIsStrictlyUndefined<T[K]> extends true ? undefined : ObjectToSnakeUndefined<T[K]>;
+}>;
+export type ObjectToSnakeUndefined<T> = T extends unknown[] ? ObjectToSnake<T[0]>[] : Identify<{
+    [K in keyof T as SnakeCase<Exclude<K, symbol | number>>]?: T[K] extends unknown[] ? ObjectToSnake<T[K][0]>[] : T[K] extends object ? ObjectToSnake<T[K]> : T[K];
 }>;
 export type UnionToTuple<U, A extends any[] = []> = (U extends void ? void : (arg: () => U) => never) extends (arg: infer I) => void ? I extends () => infer W ? UnionToTuple<Exclude<U, W>, [W, ...A]> : A : never;
 export type KeysWithUndefined<T> = {