@open-discord-bots/framework 0.0.1 → 0.0.2

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

@@ -0,0 +1,33 @@
+import { ODManager, ODManagerData, ODValidId } from "./base";
+import { ODDebugger } from "./console";
+/**## ODCode `class`
+ * This is an Open Discord code runner.
+ *
+ * Using this, you're able to execute a function just before the startup screen. (90% of the code is already loaded)
+ * You can also specify a priority to change the execution order.
+ * In Open Discord, this is used for the following processes:
+ * - Autoclose/delete
+ * - Database syncronisation (with tickets, stats & used options)
+ * - Panel auto-update
+ * - Database Garbage Collection (removing tickets that don't exist anymore)
+ * - And more!
+ */
+export declare class ODCode extends ODManagerData {
+    /**The priority of this code */
+    priority: number;
+    /**The main function of this code */
+    func: () => void | Promise<void>;
+    constructor(id: ODValidId, priority: number, func: () => void | Promise<void>);
+}
+/**## ODCodeManager `class`
+ * This is an Open Discord code manager.
+ *
+ * It manages & executes `ODCode`'s in the correct order.
+ *
+ * Use this to register a function/code which executes just before the startup screen. (90% is already loaded)
+ */
+export declare class ODCodeManager extends ODManager<ODCode> {
+    constructor(debug: ODDebugger);
+    /**Execute all `ODCode` functions in order of their priority (high to low). */
+    execute(): Promise<void>;
+}

package/dist/api/modules/code.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ODCodeManager = exports.ODCode = void 0;
+///////////////////////////////////////
+//CODE MODULE
+///////////////////////////////////////
+const base_1 = require("./base");
+/**## ODCode `class`
+ * This is an Open Discord code runner.
+ *
+ * Using this, you're able to execute a function just before the startup screen. (90% of the code is already loaded)
+ * You can also specify a priority to change the execution order.
+ * In Open Discord, this is used for the following processes:
+ * - Autoclose/delete
+ * - Database syncronisation (with tickets, stats & used options)
+ * - Panel auto-update
+ * - Database Garbage Collection (removing tickets that don't exist anymore)
+ * - And more!
+ */
+class ODCode extends base_1.ODManagerData {
+    /**The priority of this code */
+    priority;
+    /**The main function of this code */
+    func;
+    constructor(id, priority, func) {
+        super(id);
+        this.priority = priority;
+        this.func = func;
+    }
+}
+exports.ODCode = ODCode;
+/**## ODCodeManager `class`
+ * This is an Open Discord code manager.
+ *
+ * It manages & executes `ODCode`'s in the correct order.
+ *
+ * Use this to register a function/code which executes just before the startup screen. (90% is already loaded)
+ */
+class ODCodeManager extends base_1.ODManager {
+    constructor(debug) {
+        super(debug, "code");
+    }
+    /**Execute all `ODCode` functions in order of their priority (high to low). */
+    async execute() {
+        const derefArray = [...this.getAll()];
+        const workers = derefArray.sort((a, b) => b.priority - a.priority);
+        for (const worker of workers) {
+            try {
+                await worker.func();
+            }
+            catch (err) {
+                process.emit("uncaughtException", err);
+            }
+        }
+    }
+}
+exports.ODCodeManager = ODCodeManager;

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

@@ -0,0 +1,70 @@
+import { ODManager, ODManagerData, ODPromiseVoid, ODValidId } from "./base";
+import { ODDebugger } from "./console";
+import * as fjs from "formatted-json-stringify";
+/**## ODConfigManager `class`
+ * This is an Open Discord config manager.
+ *
+ * It manages all config files in the bot and allows plugins to access config files from Open Discord & other plugins!
+ *
+ * You can use this class to get/change/add a config file (`ODConfig`) in your plugin!
+ */
+export declare class ODConfigManager extends ODManager<ODConfig> {
+    #private;
+    constructor(debug: ODDebugger);
+    add(data: ODConfig | ODConfig[], overwrite?: boolean): boolean;
+    /**Init all config files. */
+    init(): Promise<void>;
+}
+/**## ODConfig `class`
+ * This is an Open Discord config helper.
+ * This class doesn't do anything at all, it just gives a template & basic methods for a config. Use `ODJsonConfig` instead!
+ *
+ * You can use this class if you want to create your own config implementation (e.g. `yml`, `xml`,...)!
+ */
+export declare class ODConfig extends ODManagerData {
+    /**The name of the file with extension. */
+    file: string;
+    /**The path to the file relative to the main directory. */
+    path: string;
+    /**An object/array of the entire config file! Variables inside it can be edited while the bot is running! */
+    data: any;
+    /**Is this config already initiated? */
+    initiated: boolean;
+    /**An array of listeners to run when the config gets reloaded. These are not executed on the initial loading. */
+    protected reloadListeners: Function[];
+    /**Alias to Open Discord debugger. */
+    protected debug: ODDebugger | null;
+    constructor(id: ODValidId, data: any);
+    /**Use the Open Discord debugger for logs. */
+    useDebug(debug: ODDebugger | null): void;
+    /**Init the config. */
+    init(): ODPromiseVoid;
+    /**Reload the config. Be aware that this doesn't update the config data everywhere in the bot! */
+    reload(): ODPromiseVoid;
+    /**Save the edited config to the filesystem. This is used by the Interactive Setup CLI. It's not recommended to use this while the bot is running. */
+    save(): ODPromiseVoid;
+    /**Listen for a reload of this JSON file! */
+    onReload(cb: Function): void;
+    /**Remove all reload listeners. Not recommended! */
+    removeAllReloadListeners(): void;
+}
+/**## ODJsonConfig `class`
+ * This is an Open Discord JSON config.
+ * You can use this class to get & edit variables from the config files or to create your own JSON config!
+ * @example
+ * //create a config from: ./config/test.json with the id "some-config"
+ * const config = new api.ODJsonConfig("some-config","test.json")
+ *
+ * //create a config with custom dir: ./plugins/testplugin/test.json
+ * const config = new api.ODJsonConfig("plugin-config","test.json","./plugins/testplugin/")
+ */
+export declare class ODJsonConfig extends ODConfig {
+    formatter: fjs.custom.BaseFormatter;
+    constructor(id: ODValidId, file: string, customPath?: string, formatter?: fjs.custom.BaseFormatter);
+    /**Init the config. */
+    init(): ODPromiseVoid;
+    /**Reload the config. Be aware that this doesn't update the config data everywhere in the bot! */
+    reload(): void;
+    /**Save the edited config to the filesystem. This is used by the Interactive Setup CLI. It's not recommended to use this while the bot is running. */
+    save(): ODPromiseVoid;
+}

package/dist/api/modules/config.js

@@ -0,0 +1,206 @@
+"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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ODJsonConfig = exports.ODConfig = exports.ODConfigManager = void 0;
+///////////////////////////////////////
+//CONFIG MODULE
+///////////////////////////////////////
+const base_1 = require("./base");
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const fjs = __importStar(require("formatted-json-stringify"));
+/**## ODConfigManager `class`
+ * This is an Open Discord config manager.
+ *
+ * It manages all config files in the bot and allows plugins to access config files from Open Discord & other plugins!
+ *
+ * You can use this class to get/change/add a config file (`ODConfig`) in your plugin!
+ */
+class ODConfigManager extends base_1.ODManager {
+    /**Alias to Open Discord debugger. */
+    #debug;
+    constructor(debug) {
+        super(debug, "config");
+        this.#debug = debug;
+    }
+    add(data, overwrite) {
+        if (Array.isArray(data))
+            data.forEach((d) => d.useDebug(this.#debug));
+        else
+            data.useDebug(this.#debug);
+        return super.add(data, overwrite);
+    }
+    /**Init all config files. */
+    async init() {
+        for (const config of this.getAll()) {
+            try {
+                await config.init();
+            }
+            catch (err) {
+                process.emit("uncaughtException", new base_1.ODSystemError(err));
+            }
+        }
+    }
+}
+exports.ODConfigManager = ODConfigManager;
+/**## ODConfig `class`
+ * This is an Open Discord config helper.
+ * This class doesn't do anything at all, it just gives a template & basic methods for a config. Use `ODJsonConfig` instead!
+ *
+ * You can use this class if you want to create your own config implementation (e.g. `yml`, `xml`,...)!
+ */
+class ODConfig extends base_1.ODManagerData {
+    /**The name of the file with extension. */
+    file = "";
+    /**The path to the file relative to the main directory. */
+    path = "";
+    /**An object/array of the entire config file! Variables inside it can be edited while the bot is running! */
+    data;
+    /**Is this config already initiated? */
+    initiated = false;
+    /**An array of listeners to run when the config gets reloaded. These are not executed on the initial loading. */
+    reloadListeners = [];
+    /**Alias to Open Discord debugger. */
+    debug = null;
+    constructor(id, data) {
+        super(id);
+        this.data = data;
+    }
+    /**Use the Open Discord debugger for logs. */
+    useDebug(debug) {
+        this.debug = debug;
+    }
+    /**Init the config. */
+    init() {
+        this.initiated = true;
+        if (this.debug)
+            this.debug.debug("Initiated config '" + this.file + "' in ODConfigManager.", [{ key: "id", value: this.id.value }]);
+        //please implement this feature in your own config extension & extend this function.
+    }
+    /**Reload the config. Be aware that this doesn't update the config data everywhere in the bot! */
+    reload() {
+        if (this.debug)
+            this.debug.debug("Reloaded config '" + this.file + "' in ODConfigManager.", [{ key: "id", value: this.id.value }]);
+        //please implement this feature in your own config extension & extend this function.
+    }
+    /**Save the edited config to the filesystem. This is used by the Interactive Setup CLI. It's not recommended to use this while the bot is running. */
+    save() {
+        if (this.debug)
+            this.debug.debug("Saved config '" + this.file + "' in ODConfigManager.", [{ key: "id", value: this.id.value }]);
+        //please implement this feature in your own config extension & extend this function.
+    }
+    /**Listen for a reload of this JSON file! */
+    onReload(cb) {
+        this.reloadListeners.push(cb);
+    }
+    /**Remove all reload listeners. Not recommended! */
+    removeAllReloadListeners() {
+        this.reloadListeners = [];
+    }
+}
+exports.ODConfig = ODConfig;
+/**## ODJsonConfig `class`
+ * This is an Open Discord JSON config.
+ * You can use this class to get & edit variables from the config files or to create your own JSON config!
+ * @example
+ * //create a config from: ./config/test.json with the id "some-config"
+ * const config = new api.ODJsonConfig("some-config","test.json")
+ *
+ * //create a config with custom dir: ./plugins/testplugin/test.json
+ * const config = new api.ODJsonConfig("plugin-config","test.json","./plugins/testplugin/")
+ */
+class ODJsonConfig extends ODConfig {
+    formatter;
+    constructor(id, file, customPath, formatter) {
+        super(id, {});
+        this.file = (file.endsWith(".json")) ? file : file + ".json";
+        this.path = customPath ? path_1.default.join("./", customPath, this.file) : path_1.default.join("./config/", this.file);
+        this.formatter = formatter ?? new fjs.DefaultFormatter(null, true, "    ");
+    }
+    /**Init the config. */
+    init() {
+        if (!fs_1.default.existsSync(this.path))
+            throw new base_1.ODSystemError("Unable to parse config \"" + path_1.default.join("./", this.path) + "\", the file doesn't exist!");
+        try {
+            this.data = JSON.parse(fs_1.default.readFileSync(this.path).toString());
+            super.init();
+        }
+        catch (err) {
+            process.emit("uncaughtException", err);
+            throw new base_1.ODSystemError("Unable to parse config \"" + path_1.default.join("./", this.path) + "\"!");
+        }
+    }
+    /**Reload the config. Be aware that this doesn't update the config data everywhere in the bot! */
+    reload() {
+        if (!this.initiated)
+            throw new base_1.ODSystemError("Unable to reload config \"" + path_1.default.join("./", this.path) + "\", the file hasn't been initiated yet!");
+        if (!fs_1.default.existsSync(this.path))
+            throw new base_1.ODSystemError("Unable to reload config \"" + path_1.default.join("./", this.path) + "\", the file doesn't exist!");
+        try {
+            this.data = JSON.parse(fs_1.default.readFileSync(this.path).toString());
+            super.reload();
+            this.reloadListeners.forEach((cb) => {
+                try {
+                    cb();
+                }
+                catch (err) {
+                    process.emit("uncaughtException", err);
+                }
+            });
+        }
+        catch (err) {
+            process.emit("uncaughtException", err);
+            throw new base_1.ODSystemError("Unable to reload config \"" + path_1.default.join("./", this.path) + "\"!");
+        }
+    }
+    /**Save the edited config to the filesystem. This is used by the Interactive Setup CLI. It's not recommended to use this while the bot is running. */
+    save() {
+        if (!this.initiated)
+            throw new base_1.ODSystemError("Unable to save config \"" + path_1.default.join("./", this.path) + "\", the file hasn't been initiated yet!");
+        try {
+            const contents = this.formatter.stringify(this.data);
+            fs_1.default.writeFileSync(this.path, contents);
+            super.save();
+        }
+        catch (err) {
+            process.emit("uncaughtException", err);
+            throw new base_1.ODSystemError("Unable to save config \"" + path_1.default.join("./", this.path) + "\"!");
+        }
+    }
+}
+exports.ODJsonConfig = ODJsonConfig;

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

@@ -0,0 +1,305 @@
+import { ODHTTPGetRequest, ODVersion, ODSystemError, ODPluginError, ODManager, ODManagerData, ODValidId } from "./base";
+import { ODMain } from "../main";
+/**## ODValidConsoleColor `type`
+ * This is a collection of all the supported console colors within Open Discord.
+ */
+export type ODValidConsoleColor = "white" | "red" | "yellow" | "green" | "blue" | "gray" | "cyan" | "magenta";
+/**## ODConsoleMessageParam `type`
+ * This interface contains all data required for a console log parameter within Open Discord.
+ */
+export interface ODConsoleMessageParam {
+    /**The key of this parameter. */
+    key: string;
+    /**The value of this parameter. */
+    value: string;
+    /**When enabled, this parameter will only be shown in the debug file. */
+    hidden?: boolean;
+}
+/**## ODConsoleMessage `class`
+ * This is an Open Discord console message.
+ *
+ * It is used to create beautiful & styled logs in the console with a prefix, message & parameters.
+ * It also has full color support using `ansis` and parameters are parsed for you!
+ */
+export declare class ODConsoleMessage {
+    /**The main message sent in the console */
+    message: string;
+    /**An array of all the parameters in this message */
+    params: ODConsoleMessageParam[];
+    /**The prefix of this message (!uppercase recommended!) */
+    prefix: string;
+    /**The color of the prefix of this message */
+    color: ODValidConsoleColor;
+    constructor(message: string, prefix: string, color: ODValidConsoleColor, params?: ODConsoleMessageParam[]);
+    /**Render this message to the console using `console.log`! Returns `false` when something went wrong. */
+    render(): boolean;
+    /**Create a more-detailed, non-colored version of this message to store it in the `debug.txt` file! */
+    toDebugString(): string;
+    /**Render the parameters of this message in a specific color. */
+    createParamsString(color: ODValidConsoleColor): string;
+    /**Set the message */
+    setMessage(message: string): this;
+    /**Set the params */
+    setParams(params: ODConsoleMessageParam[]): this;
+    /**Set the prefix */
+    setPrefix(prefix: string): this;
+    /**Set the prefix color */
+    setColor(color: ODValidConsoleColor): this;
+}
+/**## ODConsoleInfoMessage `class`
+ * This is an Open Discord console info message.
+ *
+ * It is the same as a normal `ODConsoleMessage`, but it has a predefined prefix & color scheme for the "INFO" messages!
+ */
+export declare class ODConsoleInfoMessage extends ODConsoleMessage {
+    constructor(message: string, params?: ODConsoleMessageParam[]);
+}
+/**## ODConsoleSystemMessage `class`
+ * This is an Open Discord console system message.
+ *
+ * It is the same as a normal `ODConsoleMessage`, but it has a predefined prefix & color scheme for the "SYSTEM" messages!
+ */
+export declare class ODConsoleSystemMessage extends ODConsoleMessage {
+    constructor(message: string, params?: ODConsoleMessageParam[]);
+}
+/**## ODConsolePluginMessage `class`
+ * This is an Open Discord console plugin message.
+ *
+ * It is the same as a normal `ODConsoleMessage`, but it has a predefined prefix & color scheme for the "PLUGIN" messages!
+ */
+export declare class ODConsolePluginMessage extends ODConsoleMessage {
+    constructor(message: string, params?: ODConsoleMessageParam[]);
+}
+/**## ODConsoleDebugMessage `class`
+ * This is an Open Discord console debug message.
+ *
+ * It is the same as a normal `ODConsoleMessage`, but it has a predefined prefix & color scheme for the "DEBUG" messages!
+ */
+export declare class ODConsoleDebugMessage extends ODConsoleMessage {
+    constructor(message: string, params?: ODConsoleMessageParam[]);
+}
+/**## ODConsoleWarningMessage `class`
+ * This is an Open Discord console warning message.
+ *
+ * It is the same as a normal `ODConsoleMessage`, but it has a predefined prefix & color scheme for the "WARNING" messages!
+ */
+export declare class ODConsoleWarningMessage extends ODConsoleMessage {
+    constructor(message: string, params?: ODConsoleMessageParam[]);
+}
+/**## ODConsoleErrorMessage `class`
+ * This is an Open Discord console error message.
+ *
+ * It is the same as a normal `ODConsoleMessage`, but it has a predefined prefix & color scheme for the "ERROR" messages!
+ */
+export declare class ODConsoleErrorMessage extends ODConsoleMessage {
+    constructor(message: string, params?: ODConsoleMessageParam[]);
+}
+/**## ODError `class`
+ * This is an Open Discord error.
+ *
+ * It is used to render and log Node.js errors & crashes in a styled way to the console & `debug.txt` file!
+ */
+export declare class ODError {
+    /**The original error that this class wraps around */
+    error: Error | ODSystemError | ODPluginError;
+    /**The origin of the original error */
+    origin: NodeJS.UncaughtExceptionOrigin;
+    constructor(error: Error | ODSystemError | ODPluginError, origin: NodeJS.UncaughtExceptionOrigin);
+    /**Render this error to the console using `console.log`! Returns `false` when something went wrong. */
+    render(): boolean;
+    /**Create a more-detailed, non-colored version of this error to store it in the `debug.txt` file! */
+    toDebugString(): string;
+}
+/**## ODConsoleMessageTypes `type`
+ * This is a collection of all the default console message types within Open Discord.
+ */
+export type ODConsoleMessageTypes = "info" | "system" | "plugin" | "debug" | "warning" | "error";
+/**## ODConsoleManager `class`
+ * This is the Open Discord console manager.
+ *
+ * It handles the entire console system of Open Discord. It's also the place where you need to log `ODConsoleMessage`'s.
+ * This manager keeps a short history of messages sent to the console which is configurable by plugins.
+ *
+ * The debug file (`debug.txt`) is handled in a sub-manager!
+ */
+export declare class ODConsoleManager {
+    #private;
+    /**The history of `ODConsoleMessage`'s and `ODError`'s since startup */
+    history: (ODConsoleMessage | ODError)[];
+    /**The max length of the history. The oldest messages will be removed when over the limit */
+    historylength: number;
+    /**An alias to the debugfile manager. (`debug.txt`) */
+    debugfile: ODDebugFileManager;
+    /**Is silent mode enabled? */
+    silent: boolean;
+    constructor(historylength: number, debugfile: ODDebugFileManager);
+    /**Log a message to the console ... But in the Open Discord way :) */
+    log(message: ODConsoleMessage): void;
+    log(message: ODError): void;
+    log(message: string, type?: ODConsoleMessageTypes, params?: ODConsoleMessageParam[]): void;
+}
+/**## ODDebugFileManager `class`
+ * This is the Open Discord debug file manager.
+ *
+ * It manages the Open Discord debug file (`debug.txt`) which keeps a history of all system logs.
+ * There are even internal logs that aren't logged to the console which are available in this file!
+ *
+ * Using this class, you can change the max length of this file and some other cool things!
+ */
+export declare class ODDebugFileManager {
+    #private;
+    /**The path to the debugfile (`./debug.txt` by default) */
+    path: string;
+    /**The filename of the debugfile (`debug.txt` by default) */
+    filename: string;
+    /**The current version of the bot used in the debug file. */
+    version: ODVersion;
+    /**The max length of the debug file. */
+    maxlines: number;
+    constructor(path: string, filename: string, maxlines: number, version: ODVersion);
+    /**Write an `ODConsoleMessage` to the debug file */
+    writeConsoleMessage(message: ODConsoleMessage): void;
+    /**Write an `ODError` to the debug file */
+    writeErrorMessage(error: ODError): void;
+    /**Write custom text to the debug file */
+    writeText(text: string): void;
+    /**Write a custom note to the debug file (starting with `[NOTE]:`) */
+    writeNote(text: string): void;
+}
+/**## ODDebugger `class`
+ * This is the Open Discord debugger.
+ *
+ * It is a simple wrapper around the `ODConsoleManager` to handle debugging (primarily for `ODManagers`).
+ * Messages created using this debugger are only logged to the debug file unless specified otherwise.
+ *
+ * You will probably notice this class being used in the `ODManager` constructor.
+ *
+ * Using this system, all additions & removals inside a manager are logged to the debug file. This makes searching for errors a lot easier!
+ */
+export declare class ODDebugger {
+    /**An alias to the Open Discord console manager. */
+    console: ODConsoleManager;
+    /**When enabled, debug logs are also shown in the console. */
+    visible: boolean;
+    constructor(console: ODConsoleManager);
+    /**Create a debug message. This will always be logged to `debug.txt` & sometimes to the console (when enabled). Returns `true` when visible */
+    debug(message: string, params?: {
+        key: string;
+        value: string;
+    }[]): boolean;
+}
+/**## ODLivestatusColor `type`
+ * This is a collection of all the colors available within the LiveStatus system.
+ */
+export type ODLiveStatusColor = "normal" | "red" | "green" | "blue" | "yellow" | "white" | "gray" | "magenta" | "cyan";
+/**## ODLiveStatusSourceData `interface`
+ * This is an interface containing all raw data received from the LiveStatus system.
+ */
+export interface ODLiveStatusSourceData {
+    /**The message to display */
+    message: {
+        /**The title of the message to display */
+        title: string;
+        /**The title color of the message to display */
+        titleColor: ODLiveStatusColor;
+        /**The description of the message to display */
+        description: string;
+        /**The description color of the message to display */
+        descriptionColor: ODLiveStatusColor;
+    };
+    /**The message will only be shown when the bot matches all statements */
+    active: {
+        /**A list of versions to match */
+        versions: string[];
+        /**A list of languages to match */
+        languages: string[];
+        /**All languages should match */
+        allLanguages: boolean;
+        /**Match when the bot is using plugins */
+        usingPlugins: boolean;
+        /**Match when the bot is not using plugins */
+        notUsingPlugins: boolean;
+        /**Match when the bot is using slash commands */
+        usingSlashCommands: boolean;
+        /**Match when the bot is not using slash commands */
+        notUsingSlashCommands: boolean;
+        /**Match when the bot is not using transcripts */
+        notUsingTranscripts: boolean;
+        /**Match when the bot is using text transcripts */
+        usingTextTranscripts: boolean;
+        /**Match when the bot is using html transcripts */
+        usingHtmlTranscripts: boolean;
+    };
+}
+/**## ODLiveStatusSource `class`
+ * This is the Open Discord livestatus source.
+ *
+ * It is an empty template for a livestatus source.
+ * By default, you should use `ODLiveStatusUrlSource` or `ODLiveStatusFileSource`,
+ * unless you want to create one on your own!
+ *
+ * This class doesn't do anything on it's own! It's just a template!
+ */
+export declare class ODLiveStatusSource extends ODManagerData {
+    /**The raw data of this source */
+    data: ODLiveStatusSourceData[];
+    constructor(id: ODValidId, data: ODLiveStatusSourceData[]);
+    /**Change the current data using this method! */
+    setData(data: ODLiveStatusSourceData[]): void;
+    /**Get all messages relevant to the bot based on some parameters. */
+    getMessages(main: ODMain): Promise<ODLiveStatusSourceData[]>;
+}
+/**## ODLiveStatusFileSource `class`
+ * This is the Open Discord livestatus file source.
+ *
+ * It is a LiveStatus source that will read the data from a local file.
+ *
+ * This can be used for testing/extending the LiveStatus system!
+ */
+export declare class ODLiveStatusFileSource extends ODLiveStatusSource {
+    /**The path to the source file */
+    path: string;
+    constructor(id: ODValidId, path: string);
+}
+/**## ODLiveStatusUrlSource `class`
+ * This is the Open Discord livestatus url source.
+ *
+ * It is a LiveStatus source that will read the data from a http URL (json file).
+ *
+ * This is the default way of receiving LiveStatus messages!
+ */
+export declare class ODLiveStatusUrlSource extends ODLiveStatusSource {
+    /**The url used in the request */
+    url: string;
+    /**The `ODHTTPGetRequest` helper to fetch the url! */
+    request: ODHTTPGetRequest;
+    constructor(main: ODMain, id: ODValidId, url: string);
+    getMessages(main: ODMain): Promise<ODLiveStatusSourceData[]>;
+}
+/**## ODLiveStatusManager `class`
+ * This is the Open Discord livestatus manager.
+ *
+ * It manages all LiveStatus sources and has the renderer for all LiveStatus messages.
+ *
+ * You can use this to customise or add stuff to the LiveStatus system.
+ * Access it in the global `opendiscord.startscreen.livestatus` variable!
+ */
+export declare class ODLiveStatusManager extends ODManager<ODLiveStatusSource> {
+    #private;
+    /**The class responsible for rendering the livestatus messages. */
+    renderer: ODLiveStatusRenderer;
+    constructor(debug: ODDebugger, main: ODMain);
+    /**Get the messages from all sources combined! */
+    getAllMessages(): Promise<ODLiveStatusSourceData[]>;
+}
+/**## ODLiveStatusRenderer `class`
+ * This is the Open Discord livestatus renderer.
+ *
+ * It's responsible for rendering all LiveStatus messages to the console.
+ */
+export declare class ODLiveStatusRenderer {
+    #private;
+    constructor(console: ODConsoleManager);
+    /**Render all messages */
+    render(messages: ODLiveStatusSourceData[]): string;
+}