@open-discord-bots/framework 0.0.1 → 0.0.2

package/dist/api/modules/permission.js

@@ -0,0 +1,314 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ODPermissionManager = exports.ODPermission = exports.ODPermissionLevel = void 0;
+///////////////////////////////////////
+//PERMISSION MODULE
+///////////////////////////////////////
+const base_1 = require("./base");
+const discord = __importStar(require("discord.js"));
+/**## ODPermissionLevel `enum`
+ * All available permission types/levels. But as `enum` instead of `type`. Used to calculate the level.
+ */
+var ODPermissionLevel;
+(function (ODPermissionLevel) {
+    /**A normal member. (Default for everyone) */
+    ODPermissionLevel[ODPermissionLevel["member"] = 0] = "member";
+    /**Support team. Higher than a normal member. (Used for ticket-admins) */
+    ODPermissionLevel[ODPermissionLevel["support"] = 1] = "support";
+    /**Moderator. Higher than the support team. (Unused) */
+    ODPermissionLevel[ODPermissionLevel["moderator"] = 2] = "moderator";
+    /**Admin. Higher than a moderator. (Used for global-admins) */
+    ODPermissionLevel[ODPermissionLevel["admin"] = 3] = "admin";
+    /**Server owner. (Able to use all commands including `/stats reset`) */
+    ODPermissionLevel[ODPermissionLevel["owner"] = 4] = "owner";
+    /**Bot owner or all users from dev team. (Able to use all commands including `/stats reset`) */
+    ODPermissionLevel[ODPermissionLevel["developer"] = 5] = "developer";
+})(ODPermissionLevel || (exports.ODPermissionLevel = ODPermissionLevel = {}));
+/**## ODPermission `class`
+ * This is an Open Discord permission.
+ *
+ * It defines a single permission level for a specific scope (global/channel & user/role)
+ * These permissions only apply to commands & interactions.
+ * They are not related to channel permissions in the ticket system.
+ *
+ * Register this class to an `ODPermissionManager` to use it!
+ */
+class ODPermission extends base_1.ODManagerData {
+    /**The scope of this permission. */
+    scope;
+    /**The type/level of this permission. */
+    permission;
+    /**The user/role of this permission. */
+    value;
+    /**The channel that this permission applies to. (`null` when global) */
+    channel;
+    constructor(id, scope, permission, value, channel) {
+        super(id);
+        this.scope = scope;
+        this.permission = permission;
+        this.value = value;
+        this.channel = channel ?? null;
+    }
+}
+exports.ODPermission = ODPermission;
+/**## ODPermissionManager `class`
+ * This is an Open Discord permission manager.
+ *
+ * It manages all permissions in the bot!
+ * Use the `getPermissions()` and `hasPermissions()` methods to get user perms.
+ *
+ * Add new permissions using the `ODPermission` class in your plugin!
+ */
+class ODPermissionManager extends base_1.ODManager {
+    /**Alias for Open Discord debugger. */
+    #debug;
+    /**The function for calculating permissions in this manager. */
+    #calculation;
+    /**An alias to the Open Discord client manager. */
+    #client;
+    /**The result which is returned when no other permissions match. (`member` by default) */
+    defaultResult = {
+        level: ODPermissionLevel["member"],
+        scope: "default",
+        type: "member",
+        source: null
+    };
+    constructor(debug, client, useDefaultCalculation) {
+        super(debug, "permission");
+        this.#debug = debug;
+        this.#calculation = useDefaultCalculation ? this.#defaultCalculation : null;
+        this.#client = client;
+    }
+    /**Edit the permission calculation function in this manager. */
+    setCalculation(calculation) {
+        this.#calculation = calculation;
+    }
+    /**Edit the result which is returned when no other permissions match. (`member` by default) */
+    setDefaultResult(result) {
+        this.defaultResult = result;
+    }
+    /**Get an `ODPermissionResult` based on a few context factors. Use `hasPermissions()` to simplify the result. */
+    getPermissions(user, channel, guild, settings) {
+        try {
+            if (!this.#calculation)
+                throw new base_1.ODSystemError("ODPermissionManager:getPermissions() => missing perms calculation");
+            return this.#calculation(user, channel, guild, settings);
+        }
+        catch (err) {
+            process.emit("uncaughtException", err);
+            throw new base_1.ODSystemError("ODPermissionManager:getPermissions() => failed perms calculation");
+        }
+    }
+    /**Simplifies the `ODPermissionResult` returned from `getPermissions()` and returns a boolean to check if the user matches the required permissions. */
+    hasPermissions(minimum, data) {
+        if (minimum == "member")
+            return true;
+        else if (minimum == "support")
+            return (data.level >= ODPermissionLevel["support"]);
+        else if (minimum == "moderator")
+            return (data.level >= ODPermissionLevel["moderator"]);
+        else if (minimum == "admin")
+            return (data.level >= ODPermissionLevel["admin"]);
+        else if (minimum == "owner")
+            return (data.level >= ODPermissionLevel["owner"]);
+        else if (minimum == "developer")
+            return (data.level >= ODPermissionLevel["developer"]);
+        else
+            throw new base_1.ODSystemError("Invalid minimum permission type at ODPermissionManager.hasPermissions()");
+    }
+    /**Check for permissions. (default calculation) */
+    async #defaultCalculation(user, channel, guild, settings) {
+        const globalCalc = await this.#defaultGlobalCalculation(user, channel, guild, settings);
+        const channelCalc = await this.#defaultChannelCalculation(user, channel, guild, settings);
+        if (globalCalc.level > channelCalc.level)
+            return globalCalc;
+        else
+            return channelCalc;
+    }
+    /**Check for global permissions. Result will be compared with the channel perms in `#defaultCalculation()`. */
+    async #defaultGlobalCalculation(user, channel, guild, settings) {
+        const idRegex = (settings && typeof settings.idRegex != "undefined") ? settings.idRegex : null;
+        const allowGlobalUserScope = (settings && typeof settings.allowGlobalUserScope != "undefined") ? settings.allowGlobalUserScope : true;
+        const allowGlobalRoleScope = (settings && typeof settings.allowGlobalRoleScope != "undefined") ? settings.allowGlobalRoleScope : true;
+        //check for global user permissions
+        if (allowGlobalUserScope) {
+            const users = this.getFiltered((permission) => (!idRegex || (idRegex && idRegex.test(permission.id.value))) && permission.scope == "global-user" && (permission.value instanceof discord.User) && permission.value.id == user.id);
+            if (users.length > 0) {
+                //sort all permisions from highest to lowest
+                users.sort((a, b) => {
+                    const levelA = ODPermissionLevel[a.permission];
+                    const levelB = ODPermissionLevel[b.permission];
+                    if (levelB > levelA)
+                        return 1;
+                    else if (levelA > levelB)
+                        return -1;
+                    else
+                        return 0;
+                });
+                return {
+                    type: users[0].permission,
+                    scope: "global-user",
+                    level: ODPermissionLevel[users[0].permission],
+                    source: users[0] ?? null
+                };
+            }
+        }
+        //check for global role permissions
+        if (allowGlobalRoleScope) {
+            if (guild) {
+                const member = await this.#client.fetchGuildMember(guild, user.id);
+                if (member) {
+                    const memberRoles = member.roles.cache.map((role) => role.id);
+                    const roles = this.getFiltered((permission) => (!idRegex || (idRegex && idRegex.test(permission.id.value))) && permission.scope == "global-role" && (permission.value instanceof discord.Role) && memberRoles.includes(permission.value.id) && permission.value.guild.id == guild.id);
+                    if (roles.length > 0) {
+                        //sort all permisions from highest to lowest
+                        roles.sort((a, b) => {
+                            const levelA = ODPermissionLevel[a.permission];
+                            const levelB = ODPermissionLevel[b.permission];
+                            if (levelB > levelA)
+                                return 1;
+                            else if (levelA > levelB)
+                                return -1;
+                            else
+                                return 0;
+                        });
+                        return {
+                            type: roles[0].permission,
+                            scope: "global-role",
+                            level: ODPermissionLevel[roles[0].permission],
+                            source: roles[0] ?? null
+                        };
+                    }
+                }
+            }
+        }
+        //spread result to prevent accidental referencing
+        return { ...this.defaultResult };
+    }
+    /**Check for channel permissions. Result will be compared with the global perms in `#defaultCalculation()`. */
+    async #defaultChannelCalculation(user, channel, guild, settings) {
+        const idRegex = (settings && typeof settings.idRegex != "undefined") ? settings.idRegex : null;
+        const allowChannelUserScope = (settings && typeof settings.allowChannelUserScope != "undefined") ? settings.allowChannelUserScope : true;
+        const allowChannelRoleScope = (settings && typeof settings.allowChannelRoleScope != "undefined") ? settings.allowChannelRoleScope : true;
+        if (guild && channel && !channel.isDMBased()) {
+            //check for channel user permissions
+            if (allowChannelUserScope) {
+                const users = this.getFiltered((permission) => (!idRegex || (idRegex && idRegex.test(permission.id.value))) && permission.scope == "channel-user" && permission.channel && (permission.channel.id == channel.id) && (permission.value instanceof discord.User) && permission.value.id == user.id);
+                if (users.length > 0) {
+                    //sort all permisions from highest to lowest
+                    users.sort((a, b) => {
+                        const levelA = ODPermissionLevel[a.permission];
+                        const levelB = ODPermissionLevel[b.permission];
+                        if (levelB > levelA)
+                            return 1;
+                        else if (levelA > levelB)
+                            return -1;
+                        else
+                            return 0;
+                    });
+                    return {
+                        type: users[0].permission,
+                        scope: "channel-user",
+                        level: ODPermissionLevel[users[0].permission],
+                        source: users[0] ?? null
+                    };
+                }
+            }
+            //check for channel role permissions
+            if (allowChannelRoleScope) {
+                const member = await this.#client.fetchGuildMember(guild, user.id);
+                if (member) {
+                    const memberRoles = member.roles.cache.map((role) => role.id);
+                    const roles = this.getFiltered((permission) => (!idRegex || (idRegex && idRegex.test(permission.id.value))) && permission.scope == "channel-role" && permission.channel && (permission.channel.id == channel.id) && (permission.value instanceof discord.Role) && memberRoles.includes(permission.value.id) && permission.value.guild.id == guild.id);
+                    if (roles.length > 0) {
+                        //sort all permisions from highest to lowest
+                        roles.sort((a, b) => {
+                            const levelA = ODPermissionLevel[a.permission];
+                            const levelB = ODPermissionLevel[b.permission];
+                            if (levelB > levelA)
+                                return 1;
+                            else if (levelA > levelB)
+                                return -1;
+                            else
+                                return 0;
+                        });
+                        return {
+                            type: roles[0].permission,
+                            scope: "channel-role",
+                            level: ODPermissionLevel[roles[0].permission],
+                            source: roles[0] ?? null
+                        };
+                    }
+                }
+            }
+        }
+        //spread result to prevent accidental modification because of referencing
+        return { ...this.defaultResult };
+    }
+    /**Check the permissions for a certain command of the bot. */
+    async checkCommandPerms(permissionMode, requiredLevel, user, member, channel, guild, settings) {
+        if (permissionMode === "none") {
+            return { hasPerms: false, reason: "disabled" };
+        }
+        else if (permissionMode === "everyone") {
+            const isAdmin = this.hasPermissions(requiredLevel, await this.getPermissions(user, channel, guild, settings));
+            return { hasPerms: true, isAdmin };
+        }
+        else if (permissionMode === "admin") {
+            const isAdmin = this.hasPermissions(requiredLevel, await this.getPermissions(user, channel, guild, settings));
+            if (!isAdmin)
+                return { hasPerms: false, reason: "no-perms" };
+            else
+                return { hasPerms: true, isAdmin };
+        }
+        else {
+            if (!guild || !member) {
+                this.#debug.debug("ODPermissionManager.checkCommandPerms(): Permission Error, Not in server! (#1)");
+                return { hasPerms: false, reason: "not-in-server" };
+            }
+            const role = await this.#client.fetchGuildRole(guild, permissionMode);
+            if (!role) {
+                this.#debug.debug("ODPermissionManager.checkCommandPerms(): Permission Error, Not in server! (#2)");
+                return { hasPerms: false, reason: "not-in-server" };
+            }
+            if (!role.members.has(member.id))
+                return { hasPerms: false, reason: "no-perms" };
+            const isAdmin = this.hasPermissions(requiredLevel, await this.getPermissions(user, channel, guild, settings));
+            return { hasPerms: true, isAdmin };
+        }
+    }
+}
+exports.ODPermissionManager = ODPermissionManager;

package/dist/api/modules/plugin.d.ts

@@ -0,0 +1,128 @@
+import { ODManager, ODManagerData, ODValidId, ODVersion } from "./base";
+import { ODDebugger } from "./console";
+/**## ODUnknownCrashedPlugin `interface`
+ * Basic details for a plugin that crashed while loading the `plugin.json` file.
+ */
+export interface ODUnknownCrashedPlugin {
+    /**The name of the plugin. (path when plugin crashed before `name` was loaded) */
+    name: string;
+    /**The description of the plugin. (when found before crashing) */
+    description: string;
+}
+/**## ODPluginManager `class`
+ * This is an Open Discord plugin manager.
+ *
+ * It manages all active plugins in the bot!
+ * It also contains all "plugin classes" which are managers registered by plugins.
+ * These are accessible via the `opendiscord.plugins.classes` global.
+ *
+ * Use `isPluginLoaded()` to check if a plugin has been loaded.
+ */
+export declare class ODPluginManager extends ODManager<ODPlugin> {
+    /**A manager for all custom managers registered by plugins. */
+    classes: ODPluginClassManager;
+    /**A list of basic details from all plugins that crashed while loading the `plugin.json` file. */
+    unknownCrashedPlugins: ODUnknownCrashedPlugin[];
+    constructor(debug: ODDebugger);
+    /**Check if a plugin has been loaded successfully and is available for usage.*/
+    isPluginLoaded(id: ODValidId): boolean;
+}
+/**## ODPluginData `interface`
+ * Parsed data from the `plugin.json` file in a plugin.
+ */
+export interface ODPluginData {
+    /**The name of this plugin (shown on startup) */
+    name: string;
+    /**The id of this plugin. (Must be identical to directory name) */
+    id: string;
+    /**The version of this plugin. */
+    version: string;
+    /**The location of the start file of the plugin relative to the rootDir of the plugin */
+    startFile: string;
+    /**Is this plugin enabled? */
+    enabled: boolean;
+    /**The priority of this plugin. Higher priority will load before lower priority. */
+    priority: number;
+    /**A list of events to register to the `opendiscord.events` global before loading any plugins. This way, plugins with a higher priority are able to use events from this plugin as well! */
+    events: string[];
+    /**Npm dependencies which are required for this plugin to work. */
+    npmDependencies: string[];
+    /**Plugins which are required for this plugin to work. */
+    requiredPlugins: string[];
+    /**Plugins which are incompatible with this plugin. */
+    incompatiblePlugins: string[];
+    /**Additional details about this plugin. */
+    details: ODPluginDetails;
+}
+/**## ODPluginDetails `interface`
+ * Additional details in the `plugin.json` file from a plugin.
+ */
+export interface ODPluginDetails {
+    /**The author of the plugin. */
+    author: string;
+    /**A short description of this plugin. */
+    shortDescription: string;
+    /**A large description of this plugin. */
+    longDescription: string;
+    /**A URL to a cover image of this plugin. (currently unused) */
+    imageUrl: string;
+    /**A URL to the website/project page of this plugin. (currently unused) */
+    projectUrl: string;
+    /**A list of tags/categories that this plugin affects. */
+    tags: string[];
+}
+/**## ODPlugin `class`
+ * This is an Open Discord plugin.
+ *
+ * It represents a single plugin in the `./plugins/` directory.
+ * All plugins are accessible via the `opendiscord.plugins` global.
+ *
+ * Don't re-execute plugins which are already enabled! It might break the bot or plugin.
+ */
+export declare class ODPlugin extends ODManagerData {
+    #private;
+    /**The name of the directory of this plugin. (same as id) */
+    dir: string;
+    /**All plugin data found in the `plugin.json` file. */
+    data: ODPluginData;
+    /**The name of this plugin. */
+    name: string;
+    /**The priority of this plugin. */
+    priority: number;
+    /**The version of this plugin. */
+    version: ODVersion;
+    /**The additional details of this plugin. */
+    details: ODPluginDetails;
+    /**Is this plugin enabled? */
+    enabled: boolean;
+    /**Did this plugin execute successfully?. */
+    executed: boolean;
+    /**Did this plugin crash? (A reason is available in the `crashReason`) */
+    crashed: boolean;
+    /**The reason which caused this plugin to crash. */
+    crashReason: null | "incompatible.plugin" | "missing.plugin" | "missing.dependency" | "executed";
+    constructor(dir: string, jsondata: ODPluginData);
+    /**Get the startfile location relative to the `./plugins/` directory. (`./dist/plugins/`) when compiled) */
+    getStartFile(): string;
+    /**Execute this plugin. Returns `false` on crash. */
+    execute(debug: ODDebugger, force?: boolean): Promise<boolean>;
+    /**Get a list of all missing npm dependencies that are required for this plugin. */
+    dependenciesInstalled(): string[];
+    /**Get a list of all missing plugins that are required for this plugin. */
+    pluginsInstalled(manager: ODPluginManager): string[];
+    /**Get a list of all enabled incompatible plugins that interfere with this plugin. */
+    pluginsIncompatible(manager: ODPluginManager): string[];
+}
+/**## ODPluginClassManager `class`
+ * This is an Open Discord plugin class manager.
+ *
+ * It manages all managers registered by plugins!
+ * Plugins are able to register their own managers, handlers, functions, classes, ... here.
+ * By doing this, other plugins are also able to make use of it.
+ * This can be useful for plugins that want to extend other plugins.
+ *
+ * Use `isPluginLoaded()` to check if a plugin has been loaded before trying to access the manager.
+ */
+export declare class ODPluginClassManager extends ODManager<ODManagerData> {
+    constructor(debug: ODDebugger);
+}

package/dist/api/modules/plugin.js

@@ -0,0 +1,168 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ODPluginClassManager = exports.ODPlugin = exports.ODPluginManager = void 0;
+///////////////////////////////////////
+//PLUGIN MODULE
+///////////////////////////////////////
+const base_1 = require("./base");
+const path_1 = __importDefault(require("path"));
+/**## ODPluginManager `class`
+ * This is an Open Discord plugin manager.
+ *
+ * It manages all active plugins in the bot!
+ * It also contains all "plugin classes" which are managers registered by plugins.
+ * These are accessible via the `opendiscord.plugins.classes` global.
+ *
+ * Use `isPluginLoaded()` to check if a plugin has been loaded.
+ */
+class ODPluginManager extends base_1.ODManager {
+    /**A manager for all custom managers registered by plugins. */
+    classes;
+    /**A list of basic details from all plugins that crashed while loading the `plugin.json` file. */
+    unknownCrashedPlugins = [];
+    constructor(debug) {
+        super(debug, "plugin");
+        this.classes = new ODPluginClassManager(debug);
+    }
+    /**Check if a plugin has been loaded successfully and is available for usage.*/
+    isPluginLoaded(id) {
+        const newId = new base_1.ODId(id);
+        const plugin = this.get(newId);
+        return (plugin !== null && plugin.executed);
+    }
+}
+exports.ODPluginManager = ODPluginManager;
+/**## ODPlugin `class`
+ * This is an Open Discord plugin.
+ *
+ * It represents a single plugin in the `./plugins/` directory.
+ * All plugins are accessible via the `opendiscord.plugins` global.
+ *
+ * Don't re-execute plugins which are already enabled! It might break the bot or plugin.
+ */
+class ODPlugin extends base_1.ODManagerData {
+    /**The name of the directory of this plugin. (same as id) */
+    dir;
+    /**All plugin data found in the `plugin.json` file. */
+    data;
+    /**The name of this plugin. */
+    name;
+    /**The priority of this plugin. */
+    priority;
+    /**The version of this plugin. */
+    version;
+    /**The additional details of this plugin. */
+    details;
+    /**Is this plugin enabled? */
+    enabled;
+    /**Did this plugin execute successfully?. */
+    executed;
+    /**Did this plugin crash? (A reason is available in the `crashReason`) */
+    crashed;
+    /**The reason which caused this plugin to crash. */
+    crashReason = null;
+    constructor(dir, jsondata) {
+        super(jsondata.id);
+        this.dir = dir;
+        this.data = jsondata;
+        this.name = jsondata.name;
+        this.priority = jsondata.priority;
+        this.version = base_1.ODVersion.fromString("plugin", jsondata.version);
+        this.details = jsondata.details;
+        this.enabled = jsondata.enabled;
+        this.executed = false;
+        this.crashed = false;
+    }
+    /**Get the startfile location relative to the `./plugins/` directory. (`./dist/plugins/`) when compiled) */
+    getStartFile() {
+        const newFile = this.data.startFile.replace(/\.ts$/, ".js");
+        return path_1.default.join(this.dir, newFile);
+    }
+    /**Execute this plugin. Returns `false` on crash. */
+    async execute(debug, force) {
+        if ((this.enabled && !this.crashed) || force) {
+            try {
+                //import relative plugin directory path (works on windows & unix based systems)
+                const pluginPath = path_1.default.join("../../../../plugins/", this.getStartFile()).replaceAll("\\", "/");
+                await import(pluginPath);
+                debug.console.log("Plugin \"" + this.id.value + "\" loaded successfully!", "plugin");
+                this.executed = true;
+                return true;
+            }
+            catch (error) {
+                this.crashed = true;
+                this.crashReason = "executed";
+                debug.console.log(error.message + ", canceling plugin execution...", "plugin", [
+                    { key: "path", value: "./plugins/" + this.dir }
+                ]);
+                debug.console.log("You can see more about this error in the ./debug.txt file!", "info");
+                debug.console.debugfile.writeText(error.stack);
+                return false;
+            }
+        }
+        else
+            return true;
+    }
+    /**Check if a npm dependency exists. */
+    #checkDependency(id) {
+        try {
+            require.resolve(id);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**Get a list of all missing npm dependencies that are required for this plugin. */
+    dependenciesInstalled() {
+        const missing = [];
+        this.data.npmDependencies.forEach((d) => {
+            if (!this.#checkDependency(d)) {
+                missing.push(d);
+            }
+        });
+        return missing;
+    }
+    /**Get a list of all missing plugins that are required for this plugin. */
+    pluginsInstalled(manager) {
+        const missing = [];
+        this.data.requiredPlugins.forEach((p) => {
+            const plugin = manager.get(p);
+            if (!plugin || !plugin.enabled) {
+                missing.push(p);
+            }
+        });
+        return missing;
+    }
+    /**Get a list of all enabled incompatible plugins that interfere with this plugin. */
+    pluginsIncompatible(manager) {
+        const incompatible = [];
+        this.data.incompatiblePlugins.forEach((p) => {
+            const plugin = manager.get(p);
+            if (plugin && plugin.enabled) {
+                incompatible.push(p);
+            }
+        });
+        return incompatible;
+    }
+}
+exports.ODPlugin = ODPlugin;
+/**## ODPluginClassManager `class`
+ * This is an Open Discord plugin class manager.
+ *
+ * It manages all managers registered by plugins!
+ * Plugins are able to register their own managers, handlers, functions, classes, ... here.
+ * By doing this, other plugins are also able to make use of it.
+ * This can be useful for plugins that want to extend other plugins.
+ *
+ * Use `isPluginLoaded()` to check if a plugin has been loaded before trying to access the manager.
+ */
+class ODPluginClassManager extends base_1.ODManager {
+    constructor(debug) {
+        super(debug, "plugin class");
+    }
+}
+exports.ODPluginClassManager = ODPluginClassManager;

package/dist/api/modules/post.d.ts

@@ -0,0 +1,44 @@
+import { ODManager, ODManagerData, ODValidId } from "./base";
+import { ODMessageBuildResult, ODMessageBuildSentResult } from "./builder";
+import { ODDebugger } from "./console";
+import * as discord from "discord.js";
+/**## ODPostManager `class`
+ * This is an Open Discord post manager.
+ *
+ * It manages `ODPosts`'s for you.
+ *
+ * You can use this to get the logs channel of the bot (or some other static channel/category).
+ */
+export declare class ODPostManager extends ODManager<ODPost<discord.GuildBasedChannel>> {
+    #private;
+    constructor(debug: ODDebugger);
+    add(data: ODPost<discord.GuildBasedChannel>, overwrite?: boolean): boolean;
+    /**Initialize the post manager & all posts. */
+    init(guild: discord.Guild): Promise<void>;
+}
+/**## ODPost `class`
+ * This is an Open Discord post class.
+ *
+ * A post is just a shortcut to a static discord channel or category.
+ * This can be used to get a specific channel over and over again!
+ *
+ * This class also contains utilities for sending messages via the Open Discord builders.
+ */
+export declare class ODPost<ChannelType extends discord.GuildBasedChannel> extends ODManagerData {
+    #private;
+    /**Is this post already initialized? */
+    ready: boolean;
+    /**The discord.js channel */
+    channel: ChannelType | null;
+    /**The discord channel id */
+    channelId: string;
+    constructor(id: ODValidId, channelId: string);
+    /**Use a specific guild in this class for fetching the channel*/
+    useGuild(guild: discord.Guild | null): void;
+    /**Change the channel id to another channel! */
+    setChannelId(id: string): void;
+    /**Initialize the discord.js channel of this post. */
+    init(): Promise<null | undefined>;
+    /**Send a message to this channel using the Open Discord builder system */
+    send(msg: ODMessageBuildResult): Promise<ODMessageBuildSentResult<true>>;
+}