seyfert 0.1.0

package/lib/structures/Message.js

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebhookMessage = exports.Message = exports.BaseMessage = void 0;
+const ActionRow_1 = require("../components/ActionRow");
+const GuildMember_1 = require("./GuildMember");
+const User_1 = require("./User");
+const DiscordBase_1 = require("./extra/DiscordBase");
+const functions_1 = require("./extra/functions");
+class BaseMessage extends DiscordBase_1.DiscordBase {
+    guildId;
+    timestamp;
+    author;
+    member;
+    components;
+    mentions;
+    constructor(client, data) {
+        super(client, data);
+        this.mentions = {
+            roles: data.mention_roles ?? [],
+            channels: data.mention_channels ?? [],
+            users: [],
+        };
+        this.components = data.components?.map(x => new ActionRow_1.MessageActionRowComponent(x)) ?? [];
+        this.patch(data);
+    }
+    get url() {
+        return (0, functions_1.messageLink)(this.channelId, this.id, this.guildId);
+    }
+    async guild(force = false) {
+        if (!this.guildId)
+            return;
+        return this.client.guilds.fetch(this.guildId, force);
+    }
+    async channel(force = false) {
+        return this.client.channels.fetch(this.channelId, force);
+    }
+    react(emoji) {
+        return this.client.messages.reactions.add(this.id, this.channelId, emoji);
+    }
+    patch(data) {
+        if ('guild_id' in data) {
+            this.guildId = data.guild_id;
+        }
+        if (data.type !== undefined) {
+            this.type = data.type;
+        }
+        if ('timestamp' in data && data.timestamp) {
+            this.timestamp = Date.parse(data.timestamp);
+        }
+        if ('application_id' in data) {
+            this.applicationId = data.application_id;
+        }
+        if ('author' in data && data.author) {
+            this.author = new User_1.User(this.client, data.author);
+        }
+        if ('member' in data && data.member) {
+            this.member = new GuildMember_1.GuildMember(this.client, data.member, this.author, this.guildId);
+        }
+        if (data.mentions?.length) {
+            this.mentions.users = this.guildId
+                ? data.mentions.map(m => new GuildMember_1.GuildMember(this.client, {
+                    ...m.member,
+                    user: m,
+                }, m, this.guildId))
+                : data.mentions.map(u => new User_1.User(this.client, u));
+        }
+    }
+}
+exports.BaseMessage = BaseMessage;
+class Message extends BaseMessage {
+    constructor(client, data) {
+        super(client, data);
+    }
+    fetch() {
+        return this.client.messages.fetch(this.id, this.channelId);
+    }
+    reply(body) {
+        return this.write({
+            ...body,
+            message_reference: {
+                message_id: this.id,
+                channel_id: this.channelId,
+                guild_id: this.guildId,
+                fail_if_not_exists: true,
+            },
+        });
+    }
+    edit(body) {
+        return this.client.messages.edit(this.id, this.channelId, body);
+    }
+    write(body) {
+        return this.client.messages.write(this.channelId, body);
+    }
+    delete(reason) {
+        return this.client.messages.delete(this.id, this.channelId, reason);
+    }
+    crosspost(reason) {
+        return this.client.messages.crosspost(this.id, this.channelId, reason);
+    }
+}
+exports.Message = Message;
+class WebhookMessage extends BaseMessage {
+    webhookId;
+    webhookToken;
+    constructor(client, data, webhookId, webhookToken) {
+        super(client, data);
+        this.webhookId = webhookId;
+        this.webhookToken = webhookToken;
+    }
+    fetch() {
+        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 });
+    }
+    write(body) {
+        return this.client.webhooks.messages.write(this.webhookId, this.webhookToken, body);
+    }
+    delete(reason) {
+        return this.client.webhooks.messages.delete(this.webhookId, this.webhookToken, this.id, reason);
+    }
+}
+exports.WebhookMessage = WebhookMessage;

package/lib/structures/Sticker.d.ts

@@ -0,0 +1,27 @@
+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';
+export interface Sticker extends DiscordBase, ObjectToLower<Omit<APISticker, 'user'>> {
+}
+export declare class Sticker extends DiscordBase {
+    user?: User;
+    constructor(client: BaseClient, 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;
+    delete(reason?: string): Promise<void> | undefined;
+    static methods({ client, guildId }: MethodContext<{
+        guildId: string;
+    }>): {
+        list: () => Promise<Sticker[]>;
+        create: (payload: CreateStickerBodyRequest, reason?: string) => Promise<Sticker>;
+        edit: (stickerId: string, body: RESTPatchAPIGuildStickerJSONBody, reason?: string) => Promise<Sticker>;
+        fetch: (stickerId: string, force?: boolean) => Promise<Sticker>;
+        delete: (stickerId: string, reason?: string) => Promise<void>;
+    };
+}
+export interface CreateStickerBodyRequest extends Omit<RESTPostAPIGuildStickerFormDataBody, 'file'> {
+    file: Attachment;
+}

package/lib/structures/Sticker.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Sticker = void 0;
+const User_1 = require("./User");
+const DiscordBase_1 = require("./extra/DiscordBase");
+class Sticker extends DiscordBase_1.DiscordBase {
+    user;
+    constructor(client, data) {
+        super(client, data);
+        if (data.user) {
+            this.user = new User_1.User(this.client, data.user);
+        }
+    }
+    async guild(force = false) {
+        if (!this.guildId)
+            return;
+        return this.client.guilds.fetch(this.id, force);
+    }
+    edit(body, reason) {
+        if (!this.guildId)
+            return;
+        return this.client.guilds.stickers.edit(this.guildId, this.id, body, reason);
+    }
+    fetch(force = false) {
+        if (!this.guildId)
+            return;
+        return this.client.guilds.stickers.fetch(this.guildId, this.id, force);
+    }
+    delete(reason) {
+        if (!this.guildId)
+            return;
+        return this.client.guilds.stickers.delete(this.guildId, this.id, reason);
+    }
+    static methods({ client, guildId }) {
+        return {
+            list: () => client.guilds.stickers.list(guildId),
+            create: (payload, reason) => client.guilds.stickers.create(guildId, payload, reason),
+            edit: (stickerId, body, reason) => client.guilds.stickers.edit(guildId, stickerId, body, reason),
+            fetch: (stickerId, force = false) => client.guilds.stickers.fetch(guildId, stickerId, force),
+            delete: (stickerId, reason) => client.guilds.stickers.delete(guildId, stickerId, reason),
+        };
+    }
+}
+exports.Sticker = Sticker;

package/lib/structures/User.d.ts

@@ -0,0 +1,20 @@
+import type { APIUser, MessageCreateBodyRequest, ObjectToLower } from '../common';
+import type { ImageOptions } from '../common/types/options';
+import { DiscordBase } from './extra/DiscordBase';
+export interface User extends ObjectToLower<APIUser> {
+}
+export declare class User extends DiscordBase<APIUser> {
+    get tag(): string;
+    get name(): string;
+    /**
+     * Fetch user
+     */
+    fetch(force?: boolean): Promise<User>;
+    /**
+     * Open a DM with the user
+     */
+    dm(force?: boolean): Promise<import("./channels").DMChannel>;
+    write(body: MessageCreateBodyRequest): Promise<import("./Message").Message>;
+    avatarURL(options?: ImageOptions): string;
+    toString(): string;
+}

package/lib/structures/User.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.User = void 0;
+const DiscordBase_1 = require("./extra/DiscordBase");
+class User extends DiscordBase_1.DiscordBase {
+    get tag() {
+        return this.globalName ?? `${this.username}#${this.discriminator}`;
+    }
+    get name() {
+        return this.globalName ?? this.username;
+    }
+    /**
+     * Fetch user
+     */
+    fetch(force = false) {
+        return this.client.users.fetch(this.id, force);
+    }
+    /**
+     * Open a DM with the user
+     */
+    dm(force = false) {
+        return this.client.users.createDM(this.id, force);
+    }
+    write(body) {
+        return this.client.users.write(this.id, body);
+    }
+    avatarURL(options) {
+        if (!this.avatar) {
+            return this.rest.cdn.defaultAvatar(Number(this.discriminator));
+        }
+        return this.rest.cdn.avatar(this.id, this.avatar, options);
+    }
+    toString() {
+        return `<@${this.id}>`;
+    }
+}
+exports.User = User;

package/lib/structures/Webhook.d.ts

@@ -0,0 +1,42 @@
+import type { BaseClient } from '../client/base';
+import type { APIWebhook, ImageOptions, MessageWebhookCreateBodyRequest, MessageWebhookPayload, MessageWebhookUpdateBodyRequest, MethodContext, ObjectToLower, RESTGetAPIWebhookWithTokenMessageQuery, RESTPatchAPIWebhookJSONBody, RESTPatchAPIWebhookWithTokenJSONBody, RESTPostAPIWebhookWithTokenQuery } from '../common';
+import { AnonymousGuild } from './AnonymousGuild';
+import { User } from './User';
+import { DiscordBase } from './extra/DiscordBase';
+export interface Webhook extends DiscordBase, ObjectToLower<Omit<APIWebhook, 'user' | 'source_guild'>> {
+}
+export declare class Webhook extends DiscordBase {
+    user?: User;
+    sourceGuild?: Partial<AnonymousGuild>;
+    messages: ReturnType<typeof Webhook.messages>;
+    constructor(client: BaseClient, 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;
+    fetch(): Promise<Webhook>;
+    edit(body: RESTPatchAPIWebhookJSONBody | RESTPatchAPIWebhookWithTokenJSONBody, reason?: string): Promise<import("discord-api-types/rest/v10/webhook").RESTGetAPIWebhookWithTokenResult>;
+    delete(reason?: string): Promise<never>;
+    static messages({ client, webhookId, webhookToken }: MethodContext<{
+        webhookId: string;
+        webhookToken: string;
+    }>): {
+        write: (payload: MessageWebhookMethodWriteParams) => Promise<import("./Message").WebhookMessage | null>;
+        edit: (payload: MessageWebhookMethodEditParams) => Promise<import("./Message").WebhookMessage>;
+        delete: (messageId: string, reason?: string) => Promise<never>;
+    };
+    static methods({ client, webhookId, webhookToken }: MethodContext<{
+        webhookId: string;
+        webhookToken?: string;
+    }>): {
+        delete: (reason?: string) => Promise<never>;
+        edit: (body: RESTPatchAPIWebhookWithTokenJSONBody | RESTPatchAPIWebhookJSONBody, reason?: string) => Promise<import("discord-api-types/rest/v10/webhook").RESTGetAPIWebhookWithTokenResult>;
+        fetch: () => Promise<Webhook>;
+    };
+}
+export type MessageWebhookMethodEditParams = MessageWebhookPayload<MessageWebhookUpdateBodyRequest, {
+    messageId: string;
+    query?: RESTGetAPIWebhookWithTokenMessageQuery;
+}>;
+export type MessageWebhookMethodWriteParams = MessageWebhookPayload<MessageWebhookCreateBodyRequest, {
+    query?: RESTPostAPIWebhookWithTokenQuery;
+}>;

package/lib/structures/Webhook.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Webhook = void 0;
+const AnonymousGuild_1 = require("./AnonymousGuild");
+const User_1 = require("./User");
+const DiscordBase_1 = require("./extra/DiscordBase");
+class Webhook extends DiscordBase_1.DiscordBase {
+    user;
+    sourceGuild;
+    messages;
+    constructor(client, data) {
+        super(client, data);
+        if (data.user) {
+            this.user = new User_1.User(this.client, data.user);
+        }
+        if (data.source_guild) {
+            this.sourceGuild = new AnonymousGuild_1.AnonymousGuild(this.client, data.source_guild);
+        }
+        Object.assign(this, {
+            messages: Webhook.messages({ client, webhookId: this.id, webhookToken: this.token }),
+        });
+    }
+    async guild(force = false) {
+        if (!this.sourceGuild?.id)
+            return;
+        return this.client.guilds.fetch(this.sourceGuild.id, force);
+    }
+    async channel(force = false) {
+        if (!this.sourceChannel?.id)
+            return;
+        return this.client.channels.fetch(this.sourceChannel.id, force);
+    }
+    avatarURL(options) {
+        if (!this.avatar) {
+            return null;
+        }
+        return this.rest.cdn.avatar(this.id, this.avatar, options);
+    }
+    async fetch() {
+        return this.client.webhooks.fetch(this.id, this.token);
+    }
+    async edit(body, reason) {
+        return this.client.webhooks.edit(this.id, body, { reason, token: this.token });
+    }
+    delete(reason) {
+        return this.client.webhooks.delete(this.id, { token: this.token, reason });
+    }
+    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),
+        };
+    }
+    static methods({ client, webhookId, webhookToken }) {
+        return {
+            delete: (reason) => client.webhooks.delete(webhookId, { reason, token: webhookToken }),
+            edit: (body, reason) => client.webhooks.edit(webhookId, body, { token: webhookToken, reason }),
+            fetch: () => client.webhooks.fetch(webhookId, webhookToken),
+        };
+    }
+}
+exports.Webhook = Webhook;

package/lib/structures/channels.d.ts

@@ -0,0 +1,232 @@
+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 { APIChannelBase, APIGuildChannel, APIGuildForumDefaultReactionEmoji, APIGuildForumTag, EmojiResolvable, MessageCreateBodyRequest, MessageUpdateBodyRequest, MethodContext, ObjectToLower, RESTGetAPIChannelMessageReactionUsersQuery, RESTPatchAPIChannelJSONBody, RESTPatchAPIGuildChannelPositionsJSONBody, RESTPostAPIChannelWebhookJSONBody, RESTPostAPIGuildChannelJSONBody, SortOrderType, StringToNumber, ToClass } from '../common';
+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>);
+    static __intent__(id: '@me'): 'DirectMessages';
+    static __intent__(id: string): 'DirectMessages' | 'Guilds';
+    /** The URL to the channel */
+    get url(): string;
+    fetch(force?: boolean): Promise<AllChannels>;
+    delete(reason?: string): Promise<AllChannels>;
+    edit(body: RESTPatchAPIChannelJSONBody, reason?: string): Promise<AllChannels>;
+    toString(): string;
+    isStage(): this is StageChannel;
+    isMedia(): this is MediaChannel;
+    isDM(): this is DMChannel;
+    isForum(): this is ForumChannel;
+    isThread(): this is ThreadChannel;
+    isDirectory(): this is DirectoryChannel;
+    isVoice(): this is VoiceChannel;
+    isTextGuild(): this is TextGuildChannel;
+    isCategory(): this is CategoryChannel;
+    isNews(): this is NewsChannel;
+    isTextable(): this is AllTextableChannels;
+    isGuildTextable(): this is AllGuildTextableChannels;
+    isThreadOnly(): this is ForumChannel | MediaChannel;
+    is<T extends (keyof IChannelTypes)[]>(channelTypes: T): this is IChannelTypes[T[number]];
+    static allMethods(ctx: MethodContext<{
+        guildId: string;
+    }>): {
+        list: (force?: boolean) => Promise<AllChannels[]>;
+        fetch: (id: string, force?: boolean) => Promise<AllChannels>;
+        create: (body: RESTPostAPIGuildChannelJSONBody) => Promise<AllChannels>;
+        delete: (id: string, reason?: string) => Promise<AllChannels>;
+        edit: (id: string, body: RESTPatchAPIChannelJSONBody, reason?: string) => Promise<AllChannels>;
+        editPositions: (body: RESTPatchAPIGuildChannelPositionsJSONBody) => Promise<never>;
+    };
+}
+interface IChannelTypes {
+    GuildStageVoice: StageChannel;
+    GuildMedia: MediaChannel;
+    DM: DMChannel;
+    GuildForum: ForumChannel;
+    AnnouncementThread: ThreadChannel;
+    PrivateThread: ThreadChannel;
+    PublicThread: ThreadChannel;
+    GuildDirectory: DirectoryChannel;
+    GuildVoice: VoiceChannel;
+    GuildText: TextGuildChannel;
+    GuildCategory: CategoryChannel;
+    GuildAnnouncement: NewsChannel;
+}
+export interface BaseGuildChannel extends ObjectToLower<APIGuildChannel<ChannelType>> {
+}
+export declare class BaseGuildChannel extends BaseChannel<ChannelType> {
+    guild(force?: boolean): Promise<import("./Guild").Guild<"cached"> | import("./Guild").Guild<"api">>;
+    get url(): string;
+    setPosition(position: number, reason?: string): Promise<AllChannels>;
+    setName(name: string, reason?: string): Promise<AllChannels>;
+    setParent(parent_id: string | null, reason?: string): Promise<AllChannels>;
+}
+export interface MessagesMethods extends BaseChannel<ChannelType> {
+}
+export declare class MessagesMethods extends DiscordBase {
+    typing(): Promise<never>;
+    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>;
+        fetch: (messageId: string) => Promise<import("./Message").Message>;
+        purge: (messages: string[], reason?: string) => Promise<never>;
+    };
+    pins: {
+        fetch: () => Promise<import("./Message").Message[]>;
+        set: (messageId: string, reason?: string) => Promise<never>;
+        delete: (messageId: string, reason?: string) => Promise<never>;
+    };
+    reactions: {
+        add: (messageId: string, emoji: EmojiResolvable) => Promise<never>;
+        delete: (messageId: string, emoji: EmojiResolvable, userId?: string) => Promise<never>;
+        fetch: (messageId: string, emoji: EmojiResolvable, query?: RESTGetAPIChannelMessageReactionUsersQuery) => Promise<import("./User").User[]>;
+        purge: (messageId: string, emoji?: EmojiResolvable) => Promise<never>;
+    };
+    static messages(ctx: MethodContext<{
+        channelId: string;
+    }>): {
+        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>;
+        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>;
+        fetch: (messageId: string, emoji: EmojiResolvable, query?: RESTGetAPIChannelMessageReactionUsersQuery) => Promise<import("./User").User[]>;
+        purge: (messageId: string, emoji?: EmojiResolvable) => Promise<never>;
+    };
+    static pins(ctx: MethodContext<{
+        channelId: string;
+    }>): {
+        fetch: () => Promise<import("./Message").Message[]>;
+        set: (messageId: string, reason?: string) => Promise<never>;
+        delete: (messageId: string, reason?: string) => Promise<never>;
+    };
+    static transformMessageBody<T>(body: MessageCreateBodyRequest | MessageUpdateBodyRequest): T;
+}
+export interface TextBaseGuildChannel extends ObjectToLower<Omit<APITextChannel, 'type'>>, MessagesMethods {
+}
+export declare class TextBaseGuildChannel extends BaseGuildChannel {
+}
+export default function channelFrom(data: APIChannelBase<ChannelType>, client: BaseClient): AllChannels;
+export interface TopicableGuildChannel extends BaseChannel<ChannelType> {
+}
+export declare class TopicableGuildChannel extends DiscordBase {
+    setTopic(topic: string | null, reason?: string): Promise<AllChannels>;
+}
+export interface ThreadOnlyMethods extends BaseChannel<ChannelType>, TopicableGuildChannel {
+}
+export declare class ThreadOnlyMethods extends DiscordBase {
+    setTags(tags: APIGuildForumTag[], reason?: string): Promise<AllChannels>;
+    setAutoArchiveDuration(duration: ThreadAutoArchiveDuration, reason?: string): Promise<AllChannels>;
+    setReactionEmoji(emoji: APIGuildForumDefaultReactionEmoji, reason?: string): Promise<AllChannels>;
+    setSortOrder(sort: SortOrderType, reason?: string): Promise<AllChannels>;
+    setThreadRateLimit(rate: number, reason?: string): Promise<AllChannels>;
+}
+export interface VoiceChannelMethods extends BaseChannel<ChannelType> {
+}
+export declare class VoiceChannelMethods extends DiscordBase {
+    setBitrate(bitrate: number | null, reason?: string): Promise<AllChannels>;
+    setUserLimit(user_limit: number | null, reason?: string): Promise<AllChannels>;
+    setRTC(rtc_region: string | null, reason?: string): Promise<AllChannels>;
+    setVideoQuality(quality: keyof typeof VideoQualityMode, reason?: string): Promise<AllChannels>;
+}
+export declare class WebhookGuildMethods extends DiscordBase {
+    webhooks: {
+        list: () => Promise<Webhook[]>;
+    };
+    static guild(ctx: MethodContext<{
+        guildId: string;
+    }>): {
+        list: () => Promise<Webhook[]>;
+    };
+}
+export declare class WebhookChannelMethods extends DiscordBase {
+    webhooks: {
+        list: () => Promise<Webhook[]>;
+        create: (body: RESTPostAPIChannelWebhookJSONBody) => Promise<Webhook>;
+    };
+    static channel(ctx: MethodContext<{
+        channelId: string;
+    }>): {
+        list: () => Promise<Webhook[]>;
+        create: (body: RESTPostAPIChannelWebhookJSONBody) => Promise<Webhook>;
+    };
+}
+export interface TextGuildChannel extends ObjectToLower<Omit<APITextChannel, 'type'>>, BaseGuildChannel, TextBaseGuildChannel, WebhookChannelMethods {
+}
+export declare class TextGuildChannel extends BaseGuildChannel {
+    type: ChannelType.GuildText;
+    setRatelimitPerUser(rate_limit_per_user: number | null | undefined): Promise<AllChannels>;
+    setNsfw(nsfw?: boolean, reason?: string): Promise<AllChannels>;
+}
+export interface DMChannel extends ObjectToLower<APIDMChannel>, Omit<MessagesMethods, 'edit'> {
+}
+declare const DMChannel_base: ToClass<Omit<BaseChannel<ChannelType.DM>, "edit">, DMChannel>;
+export declare class DMChannel extends DMChannel_base {
+    type: ChannelType.DM;
+}
+export interface VoiceChannel extends ObjectToLower<APIGuildVoiceChannel>, Omit<TextGuildChannel, 'type'>, VoiceChannelMethods, WebhookChannelMethods {
+}
+export declare class VoiceChannel extends BaseChannel<ChannelType.GuildVoice> {
+    type: ChannelType.GuildVoice;
+}
+export interface StageChannel extends ObjectToLower<Omit<APIGuildStageVoiceChannel, 'type'>>, TopicableGuildChannel, VoiceChannelMethods {
+}
+export declare class StageChannel extends BaseChannel<ChannelType> {
+    type: ChannelType.GuildStageVoice;
+}
+export interface MediaChannel extends ObjectToLower<Omit<APIGuildMediaChannel, 'type'>>, ThreadOnlyMethods {
+}
+export declare class MediaChannel extends BaseChannel<ChannelType> {
+    type: ChannelType.GuildMedia;
+}
+export interface ForumChannel extends ObjectToLower<APIGuildForumChannel>, Omit<ThreadOnlyMethods, 'type'>, WebhookChannelMethods {
+}
+export declare class ForumChannel extends BaseChannel<ChannelType.GuildForum> {
+    type: ChannelType.GuildForum;
+}
+export interface ThreadChannel extends ObjectToLower<APIThreadChannel>, TextBaseGuildChannel {
+}
+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>;
+    };
+    setRatelimitPerUser(rate_limit_per_user: number | null | undefined): Promise<AllChannels>;
+    pin(reason?: string): Promise<AllChannels>;
+    unpin(reason?: string): Promise<AllChannels>;
+    setTags(applied_tags: string[], reason?: string): Promise<AllChannels>;
+    setArchived(archived?: boolean, reason?: string): Promise<AllChannels>;
+    setAutoArchiveDuration(auto_archive_duration: StringToNumber<`${ThreadAutoArchiveDuration}`>, reason?: string): Promise<AllChannels>;
+    setInvitable(invitable?: boolean, reason?: string): Promise<AllChannels>;
+    setLocked(locked?: boolean, reason?: string): Promise<AllChannels>;
+}
+export interface CategoryChannel extends ObjectToLower<APIGuildCategoryChannel> {
+}
+declare const CategoryChannel_base: ToClass<Omit<BaseGuildChannel, "type" | "setParent">, CategoryChannel>;
+export declare class CategoryChannel extends CategoryChannel_base {
+    type: ChannelType.GuildCategory;
+}
+export interface NewsChannel extends ObjectToLower<APINewsChannel>, WebhookChannelMethods {
+}
+export declare class NewsChannel extends BaseChannel<ChannelType.GuildAnnouncement> {
+    type: ChannelType.GuildAnnouncement;
+    addFollower(webhook_channel_id: string, reason?: string): Promise<import("discord-api-types/v10").APIFollowedChannel>;
+}
+export declare class DirectoryChannel extends BaseChannel<ChannelType.GuildDirectory> {
+}
+export type AllGuildChannels = TextGuildChannel | VoiceChannel | MediaChannel | ForumChannel | ThreadChannel | CategoryChannel | NewsChannel | DirectoryChannel | StageChannel;
+export type AllTextableChannels = TextGuildChannel | VoiceChannel | DMChannel | NewsChannel | ThreadChannel;
+export type AllGuildTextableChannels = TextGuildChannel | VoiceChannel | NewsChannel | ThreadChannel;
+export type AllChannels = BaseChannel<ChannelType> | BaseGuildChannel | TextGuildChannel | DMChannel | VoiceChannel | MediaChannel | ForumChannel | ThreadChannel | CategoryChannel | NewsChannel | DirectoryChannel | StageChannel;
+export {};