seyfert 0.1.0

package/lib/structures/channels.js

@@ -0,0 +1,366 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DirectoryChannel = exports.NewsChannel = exports.CategoryChannel = exports.ThreadChannel = exports.ForumChannel = exports.MediaChannel = exports.StageChannel = exports.VoiceChannel = exports.DMChannel = exports.TextGuildChannel = exports.WebhookChannelMethods = exports.WebhookGuildMethods = exports.VoiceChannelMethods = exports.ThreadOnlyMethods = exports.TopicableGuildChannel = exports.TextBaseGuildChannel = exports.MessagesMethods = exports.BaseGuildChannel = exports.BaseChannel = void 0;
+const v10_1 = require("discord-api-types/v10");
+const ts_mixer_1 = require("ts-mixer");
+const builders_1 = require("../builders");
+const components_1 = require("../components");
+const Webhook_1 = require("./Webhook");
+const DiscordBase_1 = require("./extra/DiscordBase");
+const functions_1 = require("./extra/functions");
+class BaseChannel extends DiscordBase_1.DiscordBase {
+    constructor(client, data) {
+        super(client, data);
+    }
+    static __intent__(id) {
+        return id === '@me' ? 'DirectMessages' : 'Guilds';
+    }
+    /** The URL to the channel */
+    get url() {
+        return (0, functions_1.channelLink)(this.id);
+    }
+    fetch(force = false) {
+        return this.client.channels.fetch(this.id, force);
+    }
+    delete(reason) {
+        return this.client.channels.delete(this.id, { reason });
+    }
+    edit(body, reason) {
+        return this.client.channels.edit(this.id, body, { reason });
+    }
+    toString() {
+        return `<#${this.id}>`;
+    }
+    isStage() {
+        return this.type === v10_1.ChannelType.GuildStageVoice;
+    }
+    isMedia() {
+        return this.type === v10_1.ChannelType.GuildMedia;
+    }
+    isDM() {
+        return [v10_1.ChannelType.DM, v10_1.ChannelType.GroupDM].includes(this.type);
+    }
+    isForum() {
+        return this.type === v10_1.ChannelType.GuildForum;
+    }
+    isThread() {
+        return [v10_1.ChannelType.PublicThread, v10_1.ChannelType.PrivateThread, v10_1.ChannelType.AnnouncementThread].includes(this.type);
+    }
+    isDirectory() {
+        return this.type === v10_1.ChannelType.GuildDirectory;
+    }
+    isVoice() {
+        return this.type === v10_1.ChannelType.GuildVoice;
+    }
+    isTextGuild() {
+        return this.type === v10_1.ChannelType.GuildText;
+    }
+    isCategory() {
+        return this.type === v10_1.ChannelType.GuildCategory;
+    }
+    isNews() {
+        return this.type === v10_1.ChannelType.GuildAnnouncement;
+    }
+    isTextable() {
+        return 'messages' in this;
+    }
+    isGuildTextable() {
+        return !this.isDM() && this.isTextable();
+    }
+    isThreadOnly() {
+        return this.isForum() || this.isMedia();
+    }
+    is(channelTypes) {
+        return channelTypes.some(x => v10_1.ChannelType[x] === this.type);
+    }
+    static allMethods(ctx) {
+        return {
+            list: (force = false) => ctx.client.guilds.channels.list(ctx.guildId, force),
+            fetch: (id, force = false) => ctx.client.guilds.channels.fetch(ctx.guildId, id, force),
+            create: (body) => ctx.client.guilds.channels.create(ctx.guildId, body),
+            delete: (id, reason) => ctx.client.guilds.channels.delete(ctx.guildId, id, reason),
+            edit: (id, body, reason) => ctx.client.guilds.channels.edit(ctx.guildId, id, body, reason),
+            editPositions: (body) => ctx.client.guilds.channels.editPositions(ctx.guildId, body),
+        };
+    }
+}
+exports.BaseChannel = BaseChannel;
+class BaseGuildChannel extends BaseChannel {
+    async guild(force = false) {
+        return this.client.guilds.fetch(this.guildId, force);
+    }
+    get url() {
+        return (0, functions_1.channelLink)(this.id, this.guildId);
+    }
+    setPosition(position, reason) {
+        return this.edit({ position }, reason);
+    }
+    setName(name, reason) {
+        return this.edit({ name }, reason);
+    }
+    setParent(parent_id, reason) {
+        return this.edit({ parent_id }, reason);
+    }
+}
+exports.BaseGuildChannel = BaseGuildChannel;
+class MessagesMethods extends DiscordBase_1.DiscordBase {
+    typing() {
+        return this.client.channels.typing(this.id);
+    }
+    messages = MessagesMethods.messages({ client: this.client, channelId: this.id });
+    pins = MessagesMethods.pins({ client: this.client, channelId: this.id });
+    reactions = MessagesMethods.reactions({ client: this.client, channelId: this.id });
+    static messages(ctx) {
+        return {
+            write: (body) => ctx.client.messages.write(ctx.channelId, body),
+            edit: (messageId, body) => ctx.client.messages.edit(messageId, ctx.channelId, body),
+            crosspost: (messageId, reason) => ctx.client.messages.crosspost(messageId, ctx.channelId, reason),
+            delete: (messageId, reason) => ctx.client.messages.delete(messageId, ctx.channelId, reason),
+            fetch: (messageId) => ctx.client.messages.fetch(messageId, ctx.channelId),
+            purge: (messages, reason) => ctx.client.messages.purge(messages, ctx.channelId, reason),
+        };
+    }
+    static reactions(ctx) {
+        return {
+            add: (messageId, emoji) => ctx.client.messages.reactions.add(messageId, ctx.channelId, emoji),
+            delete: (messageId, emoji, userId = '@me') => ctx.client.messages.reactions.delete(messageId, ctx.channelId, emoji, userId),
+            fetch: (messageId, emoji, query) => ctx.client.messages.reactions.fetch(messageId, ctx.channelId, emoji, query),
+            purge: (messageId, emoji) => ctx.client.messages.reactions.purge(messageId, ctx.channelId, emoji),
+        };
+    }
+    static pins(ctx) {
+        return {
+            fetch: () => ctx.client.channels.pins.fetch(ctx.channelId),
+            set: (messageId, reason) => ctx.client.channels.pins.set(messageId, ctx.channelId, reason),
+            delete: (messageId, reason) => ctx.client.channels.pins.delete(messageId, ctx.channelId, reason),
+        };
+    }
+    static transformMessageBody(body) {
+        return {
+            ...body,
+            components: body.components
+                ? (body?.components instanceof components_1.ComponentsListener ? body.components.components : body.components).map(x => 'toJSON' in x ? x.toJSON() : x)
+                : undefined,
+            embeds: body.embeds?.map(x => (x instanceof builders_1.Embed ? x.toJSON() : x)) ?? undefined,
+            //?
+            attachments: body.attachments?.map((x, i) => ({ id: i, ...(0, builders_1.resolveAttachment)(x) })) ?? undefined,
+        };
+    }
+}
+exports.MessagesMethods = MessagesMethods;
+let TextBaseGuildChannel = class TextBaseGuildChannel extends BaseGuildChannel {
+};
+exports.TextBaseGuildChannel = TextBaseGuildChannel;
+exports.TextBaseGuildChannel = TextBaseGuildChannel = __decorate([
+    (0, ts_mixer_1.mix)(MessagesMethods)
+], TextBaseGuildChannel);
+function channelFrom(data, client) {
+    switch (data.type) {
+        case v10_1.ChannelType.GuildStageVoice:
+            return new StageChannel(client, data);
+        case v10_1.ChannelType.GuildMedia:
+            return new MediaChannel(client, data);
+        case v10_1.ChannelType.DM:
+            return new DMChannel(client, data);
+        case v10_1.ChannelType.GuildForum:
+            return new ForumChannel(client, data);
+        case v10_1.ChannelType.AnnouncementThread:
+        case v10_1.ChannelType.PrivateThread:
+        case v10_1.ChannelType.PublicThread:
+            return new ThreadChannel(client, data);
+        case v10_1.ChannelType.GuildDirectory:
+            return new DirectoryChannel(client, data);
+        case v10_1.ChannelType.GuildVoice:
+            return new VoiceChannel(client, data);
+        case v10_1.ChannelType.GuildText:
+            return new TextGuildChannel(client, data);
+        case v10_1.ChannelType.GuildCategory:
+            return new CategoryChannel(client, data);
+        case v10_1.ChannelType.GuildAnnouncement:
+            return new NewsChannel(client, data);
+        default:
+            if ('guild_id' in data) {
+                return new BaseGuildChannel(client, data);
+            }
+            return new BaseChannel(client, data);
+    }
+}
+exports.default = channelFrom;
+class TopicableGuildChannel extends DiscordBase_1.DiscordBase {
+    setTopic(topic, reason) {
+        return this.edit({ topic }, reason);
+    }
+}
+exports.TopicableGuildChannel = TopicableGuildChannel;
+let ThreadOnlyMethods = class ThreadOnlyMethods extends DiscordBase_1.DiscordBase {
+    setTags(tags, reason) {
+        return this.edit({ available_tags: tags }, reason);
+    }
+    setAutoArchiveDuration(duration, reason) {
+        return this.edit({ default_auto_archive_duration: duration }, reason);
+    }
+    setReactionEmoji(emoji, reason) {
+        return this.edit({ default_reaction_emoji: emoji }, reason);
+    }
+    setSortOrder(sort, reason) {
+        return this.edit({ default_sort_order: sort }, reason);
+    }
+    setThreadRateLimit(rate, reason) {
+        return this.edit({ default_thread_rate_limit_per_user: rate }, reason);
+    }
+};
+exports.ThreadOnlyMethods = ThreadOnlyMethods;
+exports.ThreadOnlyMethods = ThreadOnlyMethods = __decorate([
+    (0, ts_mixer_1.mix)(TopicableGuildChannel)
+], ThreadOnlyMethods);
+class VoiceChannelMethods extends DiscordBase_1.DiscordBase {
+    setBitrate(bitrate, reason) {
+        return this.edit({ bitrate }, reason);
+    }
+    setUserLimit(user_limit, reason) {
+        return this.edit({ user_limit: user_limit ?? 0 }, reason);
+    }
+    setRTC(rtc_region, reason) {
+        return this.edit({ rtc_region }, reason);
+    }
+    setVideoQuality(quality, reason) {
+        return this.edit({ video_quality_mode: v10_1.VideoQualityMode[quality] }, reason);
+    }
+}
+exports.VoiceChannelMethods = VoiceChannelMethods;
+class WebhookGuildMethods extends DiscordBase_1.DiscordBase {
+    webhooks = WebhookGuildMethods.guild({ client: this.client, guildId: this.id });
+    static guild(ctx) {
+        return {
+            list: async () => {
+                const webhooks = await ctx.client.proxy.guilds(ctx.guildId).webhooks.get();
+                return webhooks.map(webhook => new Webhook_1.Webhook(ctx.client, webhook));
+            },
+        };
+    }
+}
+exports.WebhookGuildMethods = WebhookGuildMethods;
+class WebhookChannelMethods extends DiscordBase_1.DiscordBase {
+    webhooks = WebhookChannelMethods.channel({ client: this.client, channelId: this.id });
+    static channel(ctx) {
+        return {
+            list: async () => {
+                const webhooks = await ctx.client.proxy.channels(ctx.channelId).webhooks.get();
+                return webhooks.map(webhook => new Webhook_1.Webhook(ctx.client, webhook));
+            },
+            create: async (body) => {
+                const webhook = await ctx.client.proxy.channels(ctx.channelId).webhooks.post({
+                    body,
+                });
+                return new Webhook_1.Webhook(ctx.client, webhook);
+            },
+        };
+    }
+}
+exports.WebhookChannelMethods = WebhookChannelMethods;
+let TextGuildChannel = class TextGuildChannel extends BaseGuildChannel {
+    setRatelimitPerUser(rate_limit_per_user) {
+        return this.edit({ rate_limit_per_user });
+    }
+    setNsfw(nsfw = true, reason) {
+        return this.edit({ nsfw }, reason);
+    }
+};
+exports.TextGuildChannel = TextGuildChannel;
+exports.TextGuildChannel = TextGuildChannel = __decorate([
+    (0, ts_mixer_1.mix)(TextBaseGuildChannel, WebhookChannelMethods)
+], TextGuildChannel);
+let DMChannel = class DMChannel extends BaseChannel {
+};
+exports.DMChannel = DMChannel;
+exports.DMChannel = DMChannel = __decorate([
+    (0, ts_mixer_1.mix)(MessagesMethods)
+], DMChannel);
+let VoiceChannel = class VoiceChannel extends BaseChannel {
+};
+exports.VoiceChannel = VoiceChannel;
+exports.VoiceChannel = VoiceChannel = __decorate([
+    (0, ts_mixer_1.mix)(TextGuildChannel, WebhookChannelMethods, VoiceChannelMethods)
+], VoiceChannel);
+let StageChannel = class StageChannel extends BaseChannel {
+};
+exports.StageChannel = StageChannel;
+exports.StageChannel = StageChannel = __decorate([
+    (0, ts_mixer_1.mix)(TopicableGuildChannel, VoiceChannelMethods)
+], StageChannel);
+let MediaChannel = class MediaChannel extends BaseChannel {
+};
+exports.MediaChannel = MediaChannel;
+exports.MediaChannel = MediaChannel = __decorate([
+    (0, ts_mixer_1.mix)(ThreadOnlyMethods)
+], MediaChannel);
+let ForumChannel = class ForumChannel extends BaseChannel {
+};
+exports.ForumChannel = ForumChannel;
+exports.ForumChannel = ForumChannel = __decorate([
+    (0, ts_mixer_1.mix)(ThreadOnlyMethods, WebhookChannelMethods)
+], ForumChannel);
+let ThreadChannel = class ThreadChannel extends BaseChannel {
+    webhooks = WebhookChannelMethods.channel({
+        client: this.client,
+        channelId: this.parentId,
+    });
+    setRatelimitPerUser(rate_limit_per_user) {
+        return this.edit({ rate_limit_per_user });
+    }
+    pin(reason) {
+        return this.edit({ flags: (this.flags ?? 0) | v10_1.ChannelFlags.Pinned }, reason);
+    }
+    unpin(reason) {
+        return this.edit({ flags: (this.flags ?? 0) & ~v10_1.ChannelFlags.Pinned }, reason);
+    }
+    setTags(applied_tags, reason) {
+        /**
+         * The available_tags field can be set when creating or updating a channel.
+         * Which determines which tags can be set on individual threads within the thread's applied_tags field.
+         */
+        return this.edit({ applied_tags }, reason);
+    }
+    setArchived(archived = true, reason) {
+        return this.edit({ archived }, reason);
+    }
+    setAutoArchiveDuration(auto_archive_duration, reason) {
+        return this.edit({ auto_archive_duration }, reason);
+    }
+    setInvitable(invitable = true, reason) {
+        return this.edit({ invitable }, reason);
+    }
+    setLocked(locked = true, reason) {
+        return this.edit({ locked }, reason);
+    }
+};
+exports.ThreadChannel = ThreadChannel;
+exports.ThreadChannel = ThreadChannel = __decorate([
+    (0, ts_mixer_1.mix)(TextBaseGuildChannel)
+], ThreadChannel);
+class CategoryChannel extends BaseGuildChannel {
+}
+exports.CategoryChannel = CategoryChannel;
+let NewsChannel = class NewsChannel extends BaseChannel {
+    addFollower(webhook_channel_id, reason) {
+        return this.api.channels(this.id).followers.post({
+            body: {
+                webhook_channel_id,
+            },
+            reason,
+        });
+    }
+};
+exports.NewsChannel = NewsChannel;
+exports.NewsChannel = NewsChannel = __decorate([
+    (0, ts_mixer_1.mix)(WebhookChannelMethods)
+], NewsChannel);
+class DirectoryChannel extends BaseChannel {
+}
+exports.DirectoryChannel = DirectoryChannel;

package/lib/structures/extra/Base.d.ts

@@ -0,0 +1,7 @@
+import type { BaseClient } from '../../client/base';
+import type { UsingClient } from '../../commands';
+/** */
+export declare abstract class Base {
+    constructor(client: BaseClient);
+    readonly client: UsingClient;
+}

package/lib/structures/extra/Base.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Base = void 0;
+const api_1 = require("../../api");
+const common_1 = require("../../common");
+/** */
+class Base {
+    constructor(client) {
+        Object.assign(this, { client });
+    }
+    /**@internal */
+    get rest() {
+        return this.client.rest;
+    }
+    /**@internal */
+    get cache() {
+        return this.client.cache;
+    }
+    /**@internal */
+    get api() {
+        const rest = this.rest;
+        return api_1.Router.prototype.createProxy.call({
+            rest,
+            noop: () => {
+                return;
+            },
+            createProxy(route) {
+                return api_1.Router.prototype.createProxy.call({ ...this, rest }, route);
+            },
+        });
+    }
+    /**@internal */
+    __patchThis(data) {
+        Object.assign(this, (0, common_1.toCamelCase)(data));
+        return this;
+    }
+    client;
+}
+exports.Base = Base;

package/lib/structures/extra/BaseComponent.d.ts

@@ -0,0 +1,9 @@
+import type { APIBaseComponent, ComponentType } from '../../common';
+export interface BaseComponent<T extends ComponentType> extends APIBaseComponent<T> {
+}
+export declare class BaseComponent<T extends ComponentType> {
+    constructor(data: APIBaseComponent<T>);
+    toJSON(): {
+        type: T;
+    };
+}

package/lib/structures/extra/BaseComponent.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseComponent = void 0;
+class BaseComponent {
+    constructor(data) {
+        Object.assign(this, data);
+    }
+    toJSON() {
+        return { type: this.type };
+    }
+}
+exports.BaseComponent = BaseComponent;

package/lib/structures/extra/BaseGuild.d.ts

@@ -0,0 +1,40 @@
+import type { APIPartialGuild, ObjectToLower } from '../../common';
+import type { ImageOptions } from '../../common/types/options';
+import { DiscordBase } from './DiscordBase';
+export interface BaseGuild extends ObjectToLower<APIPartialGuild> {
+}
+/**
+ * Base guild class
+ */
+export declare class BaseGuild extends DiscordBase<APIPartialGuild> {
+    get partnered(): boolean;
+    /**
+     * If the guild is verified.
+     * @link https://discord.com/developers/docs/resources/guild#guild-object-guild-features
+     */
+    get verified(): boolean;
+    /**
+     * Fetch guild on API
+     */
+    fetch(): Promise<BaseGuild>;
+    /**
+     * iconURL gets the current guild icon.
+     * @link https://discord.com/developers/docs/reference#image-formatting
+     */
+    iconURL(options?: ImageOptions): string | undefined;
+    /**
+     * splashURL gets the current guild splash as a string.
+     * @link https://discord.com/developers/docs/reference#image-formatting
+     * @param options - Image options for the splash url.
+     * @returns Splash url or void.
+     */
+    splashURL(options?: ImageOptions): string | undefined;
+    /**
+     * bannerURL gets the current guild banner as a string.
+     * @link https://discord.com/developers/docs/reference#image-formatting
+     * @param options - Image options for the banner url.
+     * @returns Banner url or void
+     */
+    bannerURL(options?: ImageOptions): string | undefined;
+    toString(): string;
+}

package/lib/structures/extra/BaseGuild.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseGuild = void 0;
+const common_1 = require("../../common");
+const DiscordBase_1 = require("./DiscordBase");
+/**
+ * Base guild class
+ */
+class BaseGuild extends DiscordBase_1.DiscordBase {
+    get partnered() {
+        if (!this.features) {
+            return false;
+        }
+        return this.features.includes(common_1.GuildFeature.Partnered);
+    }
+    /**
+     * If the guild is verified.
+     * @link https://discord.com/developers/docs/resources/guild#guild-object-guild-features
+     */
+    get verified() {
+        if (!this.features) {
+            return false;
+        }
+        return this.features.includes(common_1.GuildFeature.Verified);
+    }
+    /**
+     * Fetch guild on API
+     */
+    async fetch() {
+        const data = await this.api.guilds(this.id).get();
+        return new BaseGuild(this.client, data);
+    }
+    /**
+     * iconURL gets the current guild icon.
+     * @link https://discord.com/developers/docs/reference#image-formatting
+     */
+    iconURL(options) {
+        if (!this.icon) {
+            return;
+        }
+        return this.rest.cdn.icon(this.id, this.icon, options);
+    }
+    /**
+     * splashURL gets the current guild splash as a string.
+     * @link https://discord.com/developers/docs/reference#image-formatting
+     * @param options - Image options for the splash url.
+     * @returns Splash url or void.
+     */
+    splashURL(options) {
+        if (!this.splash) {
+            return;
+        }
+        return this.rest.cdn.discoverySplash(this.id, this.splash, options);
+    }
+    /**
+     * bannerURL gets the current guild banner as a string.
+     * @link https://discord.com/developers/docs/reference#image-formatting
+     * @param options - Image options for the banner url.
+     * @returns Banner url or void
+     */
+    bannerURL(options) {
+        if (!this.banner) {
+            return;
+        }
+        return this.rest.cdn.banner(this.id, this.banner, options);
+    }
+    toString() {
+        return this.name;
+    }
+}
+exports.BaseGuild = BaseGuild;

package/lib/structures/extra/BaseSelectMenuComponent.d.ts

@@ -0,0 +1,9 @@
+import type { APIBaseSelectMenuComponent, ComponentType, Identify, ObjectToLower } from '../../common';
+import { BaseComponent } from './BaseComponent';
+export type APISelectMenuComponentTypes = ComponentType.ChannelSelect | ComponentType.MentionableSelect | ComponentType.RoleSelect | ComponentType.StringSelect | ComponentType.UserSelect;
+export interface BaseSelectMenuComponent<T extends APISelectMenuComponentTypes> extends BaseComponent<T>, ObjectToLower<Identify<Omit<APIBaseSelectMenuComponent<APISelectMenuComponentTypes>, 'type'>>> {
+}
+export declare class BaseSelectMenuComponent<T extends APISelectMenuComponentTypes> extends BaseComponent<T> {
+    constructor(data: APIBaseSelectMenuComponent<T>);
+    toJSON(): this;
+}

package/lib/structures/extra/BaseSelectMenuComponent.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseSelectMenuComponent = void 0;
+const BaseComponent_1 = require("./BaseComponent");
+class BaseSelectMenuComponent extends BaseComponent_1.BaseComponent {
+    constructor(data) {
+        super(data);
+    }
+    toJSON() {
+        return { ...this };
+    }
+}
+exports.BaseSelectMenuComponent = BaseSelectMenuComponent;

package/lib/structures/extra/BitField.d.ts

@@ -0,0 +1,14 @@
+export type BitFieldResolvable<T extends object> = keyof T | number | bigint | (keyof T | number | bigint)[];
+export declare class BitField<T extends object> {
+    static None: number;
+    Flags: Partial<Record<string, bigint>>;
+    private bit;
+    constructor(bitfields?: BitFieldResolvable<T>);
+    set bits(bits: BitFieldResolvable<T>);
+    get bits(): number;
+    add(...bits: BitFieldResolvable<T>[]): number;
+    remove(...bits: BitFieldResolvable<T>[]): number;
+    has(...bits: BitFieldResolvable<T>[]): boolean;
+    equals(other: BitFieldResolvable<T>): boolean;
+    resolve(bits?: BitFieldResolvable<T>): number;
+}

package/lib/structures/extra/BitField.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BitField = void 0;
+class BitField {
+    static None = 0;
+    Flags = {};
+    bit;
+    constructor(bitfields) {
+        this.bit = this.resolve(bitfields);
+    }
+    set bits(bits) {
+        this.bit = this.resolve(bits);
+    }
+    get bits() {
+        return this.bit;
+    }
+    add(...bits) {
+        let reduced = BitField.None;
+        for (const bit of bits) {
+            reduced |= this.resolve(bit);
+        }
+        return (this.bit |= reduced);
+    }
+    remove(...bits) {
+        let reduced = BitField.None;
+        for (const bit of bits) {
+            reduced |= this.resolve(bit);
+        }
+        return (this.bit &= ~reduced);
+    }
+    has(...bits) {
+        const bitsResolved = bits.map(bit => this.resolve(bit));
+        return bitsResolved.every(bit => (this.bits & bit) === bit);
+    }
+    equals(other) {
+        return this.bits === this.resolve(other);
+    }
+    resolve(bits) {
+        switch (typeof bits) {
+            case 'number':
+                return bits;
+            case 'string':
+                return this.resolve(this.Flags[bits]);
+            case 'bigint':
+                return Number(bits);
+            case 'object':
+                if (!Array.isArray(bits)) {
+                    throw new TypeError(`Cannot resolve permission: ${bits}`);
+                }
+                return bits.map(x => this.resolve(x)).reduce((acc, cur) => acc | cur, BitField.None);
+            default:
+                throw new TypeError(`Cannot resolve permission: ${typeof bits === 'symbol' ? String(bits) : bits}`);
+        }
+    }
+}
+exports.BitField = BitField;

package/lib/structures/extra/DiscordBase.d.ts

@@ -0,0 +1,18 @@
+import type { BaseClient } from '../../client/base';
+import { Base } from './Base';
+export declare class DiscordBase<Data extends Record<string, any> = {
+    id: string;
+}> extends Base {
+    id: string;
+    constructor(client: BaseClient, 
+    /** Unique ID of the object */
+    data: Data);
+    /**
+     * Create a timestamp for the current object.
+     */
+    get createdTimestamp(): number;
+    /**
+     * createdAt gets the creation Date instace of the current object.
+     */
+    get createdAt(): Date;
+}