chapterjs 0.1.1 → 0.1.4

package/dist/structures/channel.d.ts

@@ -0,0 +1,380 @@
+import type { CacheStore } from '../cache/store.js';
+import { Permissions, type PermissionResolvable } from '../discord/permissions.js';
+import { ChannelType, type CreateChannelInviteJSONParams, type ModifyGuildChannelJSONParams, type ModifyThreadJSONParams, type RawChannel, type RawForumTag, type RawThreadMember, type StartThreadWithoutMessageJSONParams } from '../discord/types/channel.js';
+import type { Snowflake } from '../discord/types/common.js';
+import type { CreateWebhookJSONParams } from '../discord/types/webhook.js';
+import { type Camelize } from '../util/case.js';
+import { IdStructure } from './base.js';
+import type { Guild } from './guild.js';
+import type { Invite } from './invite.js';
+import { GuildMember } from './member.js';
+import { type Message } from './message.js';
+import { type MessageInput } from './payload.js';
+import { Role } from './role.js';
+import type { User } from './user.js';
+import type { Webhook } from './webhook.js';
+import type { JoinOptions, VoiceConnection } from '../voice/connection.js';
+/** Only the framework writes to the messages of a channel. */
+export declare function messagesOf(channel: Channel): CacheStore<Snowflake, Message>;
+/**
+ * A channel of any kind. Use the `is...()` methods to know which kind it is
+ * and get the properties and actions of that kind.
+ * @see https://docs.discord.com/developers/resources/channel#channel-object
+ */
+export declare class Channel extends IdStructure<RawChannel> {
+    /**
+     * The kind of channel, as a value of `ChannelType`.
+     * @see https://docs.discord.com/developers/resources/channel#channel-object-channel-types
+     */
+    get type(): ChannelType;
+    /** The id of the server of the channel; `null` for a private one. */
+    get guildId(): Snowflake | null;
+    /** The server of the channel; `null` for a private one. */
+    get guild(): Guild | null;
+    /** Whether messages can be sent in it. */
+    isTextBased(): this is TextBasedChannel;
+    /** Whether it belongs to a server and is not a thread. */
+    isGuildChannel(): this is GuildChannel;
+    /** A text or announcement channel of a server. */
+    isText(): this is TextChannel;
+    /** A voice or stage channel. */
+    isVoice(): this is VoiceChannel;
+    /** A category, which groups channels. */
+    isCategory(): this is CategoryChannel;
+    /** A forum or media channel, made of posts. */
+    isForum(): this is ForumChannel;
+    /** A thread, or a post of a forum. */
+    isThread(): this is ThreadChannel;
+    /** A private conversation. */
+    isDM(): this is DMChannel;
+    /** Asks Discord for the latest data of the channel. */
+    fetch(): Promise<Channel>;
+    /**
+     * Deletes the channel (closes it, for a private conversation).
+     * @see https://docs.discord.com/developers/resources/channel#deleteclose-channel
+     */
+    delete(reason?: string): Promise<void>;
+    /** `<#id>`: links the channel when put in a message. */
+    toString(): string;
+}
+/** What `fetchMessages()` takes: how many messages, and from where. */
+export interface FetchMessagesOptions {
+    /** How many messages, from 1 to 100. Default: 50. */
+    limit?: number;
+    /** Only messages before this one. */
+    before?: Snowflake | {
+        id: Snowflake;
+    };
+    /** Only messages after this one. */
+    after?: Snowflake | {
+        id: Snowflake;
+    };
+    /** Messages around this one. */
+    around?: Snowflake | {
+        id: Snowflake;
+    };
+}
+/** What every channel messages can be sent in has. */
+export interface TextBasedMethods {
+    /** The messages of the channel the bot remembers. */
+    readonly messages: ReadonlyMap<Snowflake, Message>;
+    /** The id of the last message sent in the channel, when known. */
+    readonly lastMessageId: Snowflake | null;
+    /**
+     * Sends a message in the channel.
+     * @see https://docs.discord.com/developers/resources/message#create-message
+     */
+    send(message: MessageInput): Promise<Message>;
+    /**
+     * A message of the channel: from what the bot remembers, or else from Discord.
+     * @see https://docs.discord.com/developers/resources/message#get-channel-message
+     */
+    fetchMessage(id: Snowflake, options?: {
+        force?: boolean;
+    }): Promise<Message>;
+    /**
+     * The latest messages of the channel, newest first.
+     * @see https://docs.discord.com/developers/resources/message#get-channel-messages
+     */
+    fetchMessages(options?: FetchMessagesOptions): Promise<Message[]>;
+    /**
+     * Deletes several messages at once. Messages older than two weeks can't
+     * be deleted in bulk: they are left out, and their number is not counted
+     * in the result.
+     * @returns how many messages were deleted
+     * @see https://docs.discord.com/developers/resources/message#bulk-delete-messages
+     */
+    bulkDelete(messages: readonly (Snowflake | {
+        id: Snowflake;
+    })[], reason?: string): Promise<number>;
+    /**
+     * Shows "the bot is typing…" for 10 seconds, or until it sends a message.
+     * @see https://docs.discord.com/developers/resources/channel#trigger-typing-indicator
+     */
+    sendTyping(): Promise<void>;
+    /**
+     * The pinned messages of the channel, latest pin first.
+     * @see https://docs.discord.com/developers/resources/message#get-channel-pins
+     */
+    fetchPins(): Promise<Message[]>;
+}
+/** What a role or a member is allowed or denied in one channel. */
+export interface PermissionOverwrite {
+    /** The id of the role or of the member. */
+    id: Snowflake;
+    /** Whether it applies to a role or to a member. */
+    type: 'role' | 'member';
+    /** What is allowed, whatever the server says. */
+    allow: Permissions;
+    /** What is denied, whatever the server says. */
+    deny: Permissions;
+}
+/** What `edit()` takes on a channel of a server. */
+export type GuildChannelEditOptions = Camelize<ModifyGuildChannelJSONParams>;
+/** What `createInvite()` takes. */
+export type InviteCreateOptions = Camelize<CreateChannelInviteJSONParams>;
+/**
+ * A channel of a server (not a thread).
+ * @see https://docs.discord.com/developers/resources/channel#channel-object
+ */
+export declare class GuildChannel extends Channel {
+    /** The id of the server of the channel. */
+    get guildId(): Snowflake;
+    /** The server of the channel. */
+    get guild(): Guild;
+    /** The name of the channel. */
+    get name(): string;
+    /** Where the channel is in the list. */
+    get position(): number;
+    /** The id of the category of the channel, when it is in one. */
+    get parentId(): Snowflake | null;
+    /** The category of the channel, when it is in one and it is known. */
+    get parent(): CategoryChannel | null;
+    /** Whether the channel is age-restricted. */
+    get nsfw(): boolean;
+    /** What roles and members are allowed or denied in this channel. */
+    get permissionOverwrites(): PermissionOverwrite[];
+    /**
+     * What a member can do in this channel: their permissions in the server,
+     * changed by the overwrites of the channel.
+     * @see https://docs.discord.com/developers/topics/permissions#permission-overwrites
+     */
+    permissionsFor(member: GuildMember): Permissions;
+    /**
+     * Changes the channel.
+     * @see https://docs.discord.com/developers/resources/channel#modify-channel
+     */
+    edit(options: GuildChannelEditOptions, reason?: string): Promise<this>;
+    /**
+     * Allows or denies permissions to a role or a member in this channel.
+     * Permissions that are in neither list follow the server.
+     * @see https://docs.discord.com/developers/resources/channel#edit-channel-permissions
+     */
+    setPermissions(target: Role | GuildMember | User, permissions: {
+        allow?: PermissionResolvable;
+        deny?: PermissionResolvable;
+    }, reason?: string): Promise<void>;
+    /**
+     * Removes what was set for a role or a member in this channel.
+     * @see https://docs.discord.com/developers/resources/channel#delete-channel-permission
+     */
+    deletePermissions(target: Snowflake | {
+        id: Snowflake;
+    }, reason?: string): Promise<void>;
+    /**
+     * Creates an invite to this channel.
+     * @see https://docs.discord.com/developers/resources/channel#create-channel-invite
+     */
+    createInvite(options?: InviteCreateOptions, reason?: string): Promise<Invite>;
+    /**
+     * The invites that lead to this channel.
+     * @see https://docs.discord.com/developers/resources/channel#get-channel-invites
+     */
+    fetchInvites(): Promise<Invite[]>;
+    /**
+     * Creates a webhook that posts in this channel.
+     * @see https://docs.discord.com/developers/resources/webhook#create-webhook
+     */
+    createWebhook(options: Camelize<CreateWebhookJSONParams>, reason?: string): Promise<Webhook>;
+    /**
+     * The webhooks that post in this channel.
+     * @see https://docs.discord.com/developers/resources/webhook#get-channel-webhooks
+     */
+    fetchWebhooks(): Promise<Webhook[]>;
+}
+/** What `startThread()` takes on a text channel. */
+export type ThreadCreateOptions = Camelize<StartThreadWithoutMessageJSONParams>;
+/** A text or announcement channel of a server. */
+export declare class TextChannel extends GuildChannel {
+    /** The topic shown at the top of the channel. */
+    get topic(): string | null;
+    /** How many seconds a member waits between two messages (slowmode). */
+    get slowmode(): number;
+    /** Whether it is an announcement channel, which servers can follow. */
+    get isAnnouncement(): boolean;
+    /**
+     * Starts a thread that is not attached to a message. To start one from a
+     * message, use `message.startThread()`.
+     * @see https://docs.discord.com/developers/resources/channel#start-thread-without-message
+     */
+    startThread(options: ThreadCreateOptions, reason?: string): Promise<ThreadChannel>;
+    /**
+     * Makes another channel receive what is published in this announcement
+     * channel.
+     * @see https://docs.discord.com/developers/resources/channel#follow-announcement-channel
+     */
+    follow(target: Snowflake | {
+        id: Snowflake;
+    }, reason?: string): Promise<void>;
+}
+export interface TextChannel extends TextBasedMethods {
+}
+/** A voice or stage channel: people talk in it, and can write too. */
+export declare class VoiceChannel extends GuildChannel {
+    /** The audio quality, in bits per second. */
+    get bitrate(): number;
+    /** How many people can join; `0` means no limit. */
+    get userLimit(): number;
+    /** The voice region of the channel; `null` when Discord picks it. */
+    get rtcRegion(): string | null;
+    /** Whether it is a stage channel, where a few speak and the others listen. */
+    get isStage(): boolean;
+    /**
+     * Joins the voice channel, or moves the bot there from another voice
+     * channel of the server. Resolves once the bot can play. On a stage, the
+     * bot becomes a speaker when it may, and asks to speak otherwise.
+     * @see https://docs.discord.com/developers/topics/voice-connections#connecting-to-voice
+     */
+    join(options?: JoinOptions): Promise<VoiceConnection>;
+    /**
+     * Sets the status shown under the name of the voice channel; `null`
+     * removes it.
+     * @see https://docs.discord.com/developers/resources/channel#set-voice-channel-status
+     */
+    setStatus(status: string | null, reason?: string): Promise<void>;
+}
+export interface VoiceChannel extends TextBasedMethods {
+}
+/** A category: it groups channels. */
+export declare class CategoryChannel extends GuildChannel {
+    /** The channels of the category the bot knows, in order. */
+    get children(): GuildChannel[];
+}
+/** A tag the posts of a forum can have. */
+export type ForumTag = Camelize<RawForumTag>;
+/** What `createPost()` takes. */
+export interface ForumPostOptions {
+    /** The title of the post. */
+    name: string;
+    /** The first message of the post. */
+    message: MessageInput;
+    /** The ids of the tags of the post. */
+    appliedTags?: Snowflake[];
+    /** After how many minutes without activity the post is archived. */
+    autoArchiveDuration?: 60 | 1440 | 4320 | 10080;
+    /** Slowmode of the post, in seconds. */
+    slowmode?: number;
+}
+/** A forum or media channel: it only contains posts, which are threads. */
+export declare class ForumChannel extends GuildChannel {
+    /** The guidelines of the forum. */
+    get topic(): string | null;
+    /** The tags posts of this forum can have. */
+    get availableTags(): ForumTag[];
+    /**
+     * Creates a post in the forum.
+     * @see https://docs.discord.com/developers/resources/channel#start-thread-in-forum-or-media-channel
+     */
+    createPost(options: ForumPostOptions, reason?: string): Promise<ThreadChannel>;
+}
+/** What `edit()` takes on a thread. */
+export type ThreadEditOptions = Camelize<ModifyThreadJSONParams>;
+/** Someone in a thread, and since when. */
+export type ThreadMember = Camelize<Omit<RawThreadMember, 'member'>>;
+/**
+ * A thread, or a post of a forum.
+ * @see https://docs.discord.com/developers/topics/threads
+ */
+export declare class ThreadChannel extends Channel {
+    /** The id of the server of the thread. */
+    get guildId(): Snowflake;
+    /** The server of the thread. */
+    get guild(): Guild;
+    /** The name of the thread. */
+    get name(): string;
+    /** The id of the channel the thread was created in. */
+    get parentId(): Snowflake;
+    /**
+     * The channel the thread was created in; `null` when it is of a kind
+     * this version does not know.
+     */
+    get parent(): TextChannel | ForumChannel | null;
+    /** The id of the user who created the thread. */
+    get ownerId(): Snowflake | null;
+    /** Whether the thread is archived. */
+    get archived(): boolean;
+    /** Whether only moderators can unarchive it. */
+    get locked(): boolean;
+    /** Whether only invited members and moderators can see it. */
+    get isPrivate(): boolean;
+    /** When the thread was archived or unarchived for the last time. */
+    get archivedAt(): Date | null;
+    /** An approximate count of the members of the thread (stops at 50). */
+    get memberCount(): number;
+    /** The ids of the tags of the post, in a forum. */
+    get appliedTags(): readonly Snowflake[];
+    /** Threads inherit the permissions of the channel they are in. */
+    permissionsFor(member: GuildMember): Permissions;
+    /**
+     * Changes the thread: name, archive, lock, slowmode, tags.
+     * @see https://docs.discord.com/developers/resources/channel#modify-channel
+     */
+    edit(options: ThreadEditOptions, reason?: string): Promise<this>;
+    /** Archives the thread: it leaves the channel list but can come back. */
+    archive(reason?: string): Promise<this>;
+    /** Brings an archived thread back. */
+    unarchive(reason?: string): Promise<this>;
+    /** Makes the bot join the thread. */
+    join(): Promise<void>;
+    /** Makes the bot leave the thread. */
+    leave(): Promise<void>;
+    /**
+     * Adds a member to the thread.
+     * @see https://docs.discord.com/developers/resources/channel#add-thread-member
+     */
+    addMember(user: Snowflake | {
+        id: Snowflake;
+    }): Promise<void>;
+    /**
+     * Removes a member from the thread.
+     * @see https://docs.discord.com/developers/resources/channel#remove-thread-member
+     */
+    removeMember(user: Snowflake | {
+        id: Snowflake;
+    }): Promise<void>;
+    /**
+     * Who is in the thread (100 at most per call).
+     * @see https://docs.discord.com/developers/resources/channel#list-thread-members
+     */
+    fetchMembers(options?: {
+        limit?: number;
+        after?: Snowflake;
+    }): Promise<ThreadMember[]>;
+}
+export interface ThreadChannel extends TextBasedMethods {
+}
+/** A private conversation between the bot and a user. */
+export declare class DMChannel extends Channel {
+    /** The id of the user the bot talks to. */
+    get recipientId(): Snowflake | null;
+    /** The user the bot talks to, when it is known. */
+    get recipient(): User | null;
+}
+export interface DMChannel extends TextBasedMethods {
+}
+/** Any channel of a server messages can be sent in. */
+export type GuildTextBasedChannel = TextChannel | VoiceChannel | ThreadChannel;
+/** Any channel messages can be sent in. */
+export type TextBasedChannel = GuildTextBasedChannel | DMChannel;
+/** The class that represents a channel of a given type. */
+export declare function channelClass(data: RawChannel): typeof Channel;