revbot.js 0.0.15-build-test → 0.0.15-build-test-2

package/dist/{index-XkxTx7UU.d.cts → index.d.mts}

@@ -1,7 +1,4 @@
 import { User as User$1, FieldsUser, SystemMessage, File, Message as Message$1, Server as Server$1, FieldsServer, Role as Role$1, FieldsRole, Channel as Channel$1, Invite as Invite$1, Embed as Embed$1, SendableEmbed, Special, FieldsChannel, Member, FieldsMember, Category as Category$1, MessageSort } from 'revolt-api';
-import { Badges } from './utils/badges.cjs';
-import { FullPermissions, ChannelPermissions } from './utils/permissions.cjs';
-import { editableRole } from './utils/types.cjs';
 import { File as File$1 } from 'node:buffer';
 import { Readable } from 'stream';
 import { EventEmitter } from 'node:events';
@@ -62,6 +59,69 @@ declare abstract class Base {
     _clone(): this;
 }
 
+declare class UUID extends null {
+    static readonly ENCODING = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
+    static readonly ENCODING_LENGTH: number;
+    static readonly RANDOM_LENGTH = 16;
+    static readonly TIME_LENGTH = 10;
+    static readonly TIME_MAX: number;
+    static get PROG(): number;
+    private static time;
+    private static hash;
+    static generate(timestamp?: number): string;
+    static timestampOf(id: string): Date;
+}
+
+type BitFieldResolvable = BitField | number | string | BitFieldResolvable[];
+/**
+ * Represents a bitfield that can be used to manage flags or permissions.
+ */
+declare class BitField {
+    static FLAGS: Record<string, number>;
+    bitfield: number;
+    constructor(bits?: BitFieldResolvable);
+    /**
+     * Resolves a bitfield or an array of bitfields into a single number.
+     * @param bit The bitfield or array of bitfields to resolve.
+     * @returns The resolved bitfield as a number.
+     */
+    static resolve(bit: BitFieldResolvable): number;
+    /**
+     * Returns the class that this instance belongs to.
+     * @returns The class of the bitfield.
+     */
+    get self(): {
+        FLAGS: Record<string, number>;
+        resolve(bit: BitFieldResolvable): number;
+        new (bits?: BitFieldResolvable): BitField;
+    };
+    /**
+     * Checks if any of the bits in the bitfield are set.
+     * @param bit The bitfield or array of bitfields to check.
+     * @returns True if any bits are set, false otherwise.
+     */
+    any(bit: BitFieldResolvable): boolean;
+    /**
+     * checks if a specific permission is set.
+     */
+    has(bit: BitFieldResolvable): boolean;
+    /**
+     * Returns an array of all the Permissions that are set in the bitfield.
+     * @returns An array of flag names.
+     */
+    toArray(): string[];
+    add(...bits: BitFieldResolvable[]): this;
+    remove(...bits: BitFieldResolvable[]): this;
+    freeze(): Readonly<this>;
+    valueOf(): number;
+    /**
+     *
+     * @returns A record of all flags and their boolean values indicating whether they are set.
+     */
+    serialize(): Record<string, boolean>;
+    [Symbol.iterator](): Iterable<string>;
+}
+
 declare class RestClient {
     private readonly client;
     private rateLimitQueue;
@@ -370,6 +430,135 @@ declare const cdnUrl = "https://cdn.revoltusercontent.com";
 /** The system user ID used for identifying system messages. */
 declare const SYSTEM_USER_ID: string;
 
+type ChannelPermissionsString = keyof typeof ChannelPermissions.FLAGS;
+type UserPermissionsString = keyof typeof UserPermissions.FLAGS;
+type ServerPermissionsString = keyof typeof ServerPermissions.FLAGS;
+type ChannelPermissionsResolvable = number | ChannelPermissionsString | ChannelPermissions | ChannelPermissionsResolvable[];
+type UserPermissionsResolvable = number | UserPermissionsString | UserPermissions | UserPermissionsResolvable[];
+type ServerPermissionsResolvable = number | ServerPermissionsString | ServerPermissions | ServerPermissionsResolvable[];
+declare interface ChannelPermissions {
+    serialize(): Record<ChannelPermissionsString, boolean>;
+    any(bit: ChannelPermissionsResolvable): boolean;
+    add(...bits: ChannelPermissionsResolvable[]): this;
+    remove(...bits: ChannelPermissionsResolvable[]): this;
+    has(bit: ChannelPermissionsResolvable): boolean;
+}
+declare class ChannelPermissions extends BitField {
+    static readonly FLAGS: {
+        readonly VIEW_CHANNEL: number;
+        readonly SEND_MESSAGE: number;
+        readonly MANAGE_MESSAGE: number;
+        readonly MANAGE_CHANNEL: number;
+        readonly VOICE_CALL: number;
+        readonly INVITE_OTHERS: number;
+        readonly EMBED_LINKS: number;
+        readonly UPLOAD_FILES: number;
+    };
+    constructor(bits?: ChannelPermissionsResolvable);
+    static resolve(bit: ChannelPermissionsResolvable): number;
+}
+declare interface UserPermissions {
+    serialize(): Record<UserPermissionsString, boolean>;
+    any(bit: UserPermissionsResolvable): boolean;
+    add(...bits: UserPermissionsResolvable[]): this;
+    remove(...bits: UserPermissionsResolvable[]): this;
+    has(bit: UserPermissionsResolvable): boolean;
+}
+declare class UserPermissions extends BitField {
+    static readonly FLAGS: {
+        readonly ACCESS: number;
+        readonly VIEW_PROFILE: number;
+        readonly SEND_MESSAGES: number;
+        readonly INVITE: number;
+    };
+    constructor(bits?: UserPermissionsResolvable);
+    static resolve(bit: UserPermissionsResolvable): number;
+}
+declare interface ServerPermissions {
+    serialize(): Record<ServerPermissionsString, boolean>;
+    any(bit: ServerPermissionsResolvable): boolean;
+    add(...bits: ServerPermissionsResolvable[]): this;
+    remove(...bits: ServerPermissionsResolvable[]): this;
+    has(bit: ServerPermissionsResolvable): boolean;
+}
+declare class ServerPermissions extends BitField {
+    static readonly FLAGS: {
+        readonly VIEW_SERVER: number;
+        readonly MANAGE_ROLES: number;
+        readonly MANAGE_CHANNELS: number;
+        readonly MANAGE_SERVER: number;
+        readonly KICK_MEMBERS: number;
+        readonly BAN_MEMBERS: number;
+        readonly CHANGE_NICKNAME: number;
+        readonly MANAGE_NICKNAMES: number;
+        readonly CHANGE_AVATAR: number;
+        readonly REMOVE_AVATARS: number;
+    };
+    constructor(bits?: ServerPermissionsResolvable);
+    static resolve(bit: ServerPermissionsResolvable): number;
+}
+declare class FullPermissions extends BitField {
+    static readonly FLAGS: {
+        readonly ManageChannel: number;
+        readonly ManageServer: number;
+        readonly ManagePermissions: number;
+        readonly ManageRole: number;
+        readonly ManageCustomisation: number;
+        readonly KickMembers: number;
+        readonly BanMembers: number;
+        readonly TimeoutMembers: number;
+        readonly AssignRoles: number;
+        readonly ChangeNickname: number;
+        readonly ManageNicknames: number;
+        readonly ChangeAvatar: number;
+        readonly RemoveAvatars: number;
+        readonly ViewChannel: number;
+        readonly ReadMessageHistory: number;
+        readonly SendMessage: number;
+        readonly ManageMessages: number;
+        readonly ManageWebhooks: number;
+        readonly InviteOthers: number;
+        readonly SendEmbeds: number;
+        readonly UploadFiles: number;
+        readonly Masquerade: number;
+        readonly React: number;
+        readonly Connect: number;
+        readonly Speak: number;
+        readonly Video: number;
+        readonly MuteMembers: number;
+        readonly DeafenMembers: number;
+        readonly MoveMembers: number;
+        readonly MentionEveryone: number;
+        readonly MentionRoles: number;
+        readonly GrantAll: 4503599627370495;
+    };
+    constructor(bits?: number | string | FullPermissions | Array<number | string | FullPermissions>);
+    static resolve(bit: number | string | FullPermissions): number;
+}
+declare const DEFAULT_PERMISSION_DM: Readonly<ChannelPermissions>;
+
+type BadgeString = keyof typeof Badges.FLAGS;
+type BadgesResolvable = number | BadgeString | Badges | BadgesResolvable[];
+declare interface Badges {
+    serialize(): Record<BadgeString, boolean>;
+    any(bit: BadgesResolvable): boolean;
+    add(...bits: BadgesResolvable[]): this;
+    remove(...bits: BadgesResolvable[]): this;
+    has(bit: BadgesResolvable): boolean;
+}
+declare class Badges extends BitField {
+    static readonly FLAGS: {
+        readonly DEVELOPER: number;
+        readonly TRANSLATOR: number;
+        readonly SUPPORTER: number;
+        readonly RESPONSIBLE_DISCLOSURE: number;
+        readonly REVOLT_TEAM: number;
+        readonly EARLY_ADOPTER: number;
+    };
+    constructor(bits?: BadgesResolvable);
+    static resolve(bit: BadgesResolvable): number;
+}
+
 /**
  * Represents a user in the client.
  *
@@ -774,6 +963,55 @@ declare class Server extends Base {
     toString(): string;
 }
 
+/**
+ * Represents the permissions that can be set for a role.
+ */
+type editablePermissions = {
+    /**
+     * Permissions to allow for the role.
+     * Each key corresponds to a permission flag in FullPermissions.
+     */
+    a?: Array<keyof (typeof FullPermissions)["FLAGS"]>;
+    /**
+     * Permissions to deny for the role.
+     * Each key corresponds to a permission flag in FullPermissions.
+     */
+    d?: Array<keyof (typeof FullPermissions)["FLAGS"]>;
+};
+/**
+ * Represents a role that can be edited in a server.
+ */
+type editableRole = {
+    /**
+     * Name of the role.
+     */
+    name?: string;
+    /**
+     * Colour of the role, or `null` if no colour is set.
+     */
+    colour?: string | null;
+    /**
+     * Whether the role is displayed separately in the member list.
+     */
+    hoist?: boolean;
+    /**
+     * Rank of the role, used for ordering.
+     */
+    rank?: number;
+    /**
+     * Permissions to set for the role.
+     * Format: { a: allow, d: deny }
+     */
+    permissions?: editablePermissions;
+    /**
+     * Fields to remove from the role.
+     * Each key corresponds to a field in the Role type.
+     */
+    remove?: Array<keyof Role$1 & {
+        [key: string]: unknown;
+    }>;
+};
+
 /**
  * Represents a role in a server.
  *
@@ -2383,4 +2621,4 @@ declare class ServerMemberManager extends BaseManager<ServerMember, Member> {
     resolveId(member: ServerMemberResolvable): string | null;
 }
 
-export { ServerMember as $, Attachment as A, BaseManager as B, ChannelTypes as C, DEFAULT_CLIENT_OPTIONS as D, Events as E, Status as F, Server as G, Role as H, Channel as I, DMChannel as J, GroupChannel as K, Invite as L, type MessageResolvable as M, Mentions as N, type Embed as O, Presence as P, type EmbedImage as Q, type RoleResolvable as R, SYSTEM_USER_ID as S, type EmbedVideo as T, type UserResolvable as U, type EmbedSpecial as V, WSEvents as W, MessageEmbed as X, NotesChannel as Y, type Overwrite as Z, ServerChannel as _, apiUrl as a, TextChannel as a0, VoiceChannel as a1, Category as a2, Emoji as a3, Event as a4, RestClient as a5, CDNClient as a6, BaseClient as a7, type ClientEvents as a8, type clientOptions as a9, type TextBasedChannel as aa, ClientUser as ab, EventManager as ac, WebSocketClient as ad, client as b, cdnUrl as c, type ChannelResolvable as d, ChannelManager as e, type ServerResolvable as f, type EditServerOptions as g, ServerManager as h, UserManager as i, type MessageReply as j, type MessageOptions as k, type MessageEditOptions as l, type MessageSearchOptions as m, type MessageQueryOptions as n, MessageManager as o, RoleManager as p, type ServerChannelResolvable as q, type CreateChannelOptions as r, ServerChannelManager as s, type ServerMemberResolvable as t, type EditServerMemberOptions as u, ServerMemberManager as v, wsUrl as w, Base as x, User as y, Message as z };
+export { Attachment, type BadgeString, Badges, type BadgesResolvable, Base, BaseManager, BitField, type BitFieldResolvable, Category, Channel, ChannelManager, ChannelPermissions, type ChannelPermissionsResolvable, type ChannelPermissionsString, type ChannelResolvable, ChannelTypes, type CreateChannelOptions, DEFAULT_CLIENT_OPTIONS, DEFAULT_PERMISSION_DM, DMChannel, type EditServerMemberOptions, type EditServerOptions, type Embed, type EmbedImage, type EmbedSpecial, type EmbedVideo, Emoji, Events, FullPermissions, GroupChannel, Invite, Mentions, Message, type MessageEditOptions, MessageEmbed, MessageManager, type MessageOptions, type MessageQueryOptions, type MessageReply, type MessageResolvable, type MessageSearchOptions, NotesChannel, type Overwrite, Presence, Role, RoleManager, type RoleResolvable, SYSTEM_USER_ID, Server, ServerChannel, ServerChannelManager, type ServerChannelResolvable, ServerManager, ServerMember, ServerMemberManager, type ServerMemberResolvable, ServerPermissions, type ServerPermissionsResolvable, type ServerPermissionsString, type ServerResolvable, Status, TextChannel, UUID, User, UserManager, UserPermissions, type UserPermissionsResolvable, type UserPermissionsString, type UserResolvable, VoiceChannel, WSEvents, apiUrl, cdnUrl, client, wsUrl };