trivious 1.3.20 → 1.3.22

package/dist/index.d.cts

@@ -1,3 +1,973 @@
-import 'discord.js';
-export { A as AnyCommand, B as ButtonInteraction, w as ChatInputCommandInteraction, k as Command, l as CommandBuilder, o as CommandInteraction, p as CommandMetadata, C as CommandRegistry, u as Component, v as ComponentBuilder, c as ComponentCustomIdTag, d as ComponentInteraction, f as ComponentMetadata, a as ComponentRegistry, e as ComponentType, j as ContextMenuBuilder, i as ContextMenuCommand, z as ContextMenuCommandInteraction, r as ContextMenuMetadata, s as Event, y as ModalSubmitInteraction, t as Module, P as PermissionLevel, S as SlashCommand, x as StringSelectMenuInteraction, m as Subcommand, n as SubcommandBuilder, q as SubcommandMetadata, T as TriviousClient, b as TriviousClientOptions, h as deconstructCustomId, g as getPermissionLevel } from './index-CU2Xl9Xo.cjs';
-export { BaseRegistry } from './shared/typings/registry.cjs';
+import * as discord_js from 'discord.js';
+import { GuildMember, Collection, AnySelectMenuInteraction, CacheType, ButtonInteraction as ButtonInteraction$1, ModalSubmitInteraction as ModalSubmitInteraction$1, SlashCommandBuilder, ContextMenuCommandBuilder, MessagePayload, InteractionEditReplyOptions, InteractionReplyOptions, SlashCommandSubcommandBuilder, ChatInputCommandInteraction as ChatInputCommandInteraction$1, ClientOptions, ClientEvents, ComponentType as ComponentType$1, Client, StringSelectMenuInteraction as StringSelectMenuInteraction$1, ContextMenuCommandInteraction as ContextMenuCommandInteraction$1 } from 'discord.js';
+
+/**
+ * User permission level enums
+ *
+ * @export
+ * @enum {number}
+ */
+declare enum PermissionLevel {
+    USER = 0,
+    GUILD_STAFF = 1,
+    GUILD_MODERATOR = 2,
+    GUILD_ADMINISTRATOR = 3,
+    GUILD_OWNER = 4,
+    BOT_OWNER = 5
+}
+/**
+ * Get the permission level of a user.
+ *
+ * @param {GuildMember} member
+ * @returns {*}
+ */
+declare const getPermissionLevel: (client: TriviousClient, member: GuildMember) => PermissionLevel;
+
+/**
+ * Base registry for loading, getting and binding core events and functions.
+ *
+ * @export
+ * @abstract
+ * @class BaseRegistry
+ * @typedef {BaseRegistry}
+ * @template T
+ */
+declare abstract class BaseRegistry<T> {
+    protected abstract items: Collection<string, T>;
+    /**
+     * Load all of T
+     *
+     * @protected
+     * @abstract
+     * @param {string} directory
+     * @returns {Promise<this>}
+     */
+    protected abstract load(directory: string): Promise<this>;
+    /**
+     * Get all of loaded T
+     *
+     * @returns {Collection<string, T>}
+     */
+    get(): Collection<string, T>;
+    /**
+     * Import a file from a path to be loaded.
+     *
+     * @protected
+     * @async
+     * @template T
+     * @param {string} filePath
+     * @returns {Promise<T | null>}
+     */
+    protected importFile<T>(filePath: string): Promise<T | null>;
+    /**
+     * Clear file path cache.
+     * Does not run in production environment.
+     *
+     * @protected
+     * @async
+     * @param {string} filePath
+     * @returns {*}
+     */
+    protected clearCache(filePath: string): Promise<void>;
+}
+
+/**
+ * Tags for component customIds.
+ *
+ * @export
+ * @typedef {ComponentCustomIdTag}
+ */
+type ComponentCustomIdTag = "awaited";
+/**
+ * Interaction types for components.
+ *
+ * @export
+ * @typedef {ComponentInteraction}
+ */
+type ComponentInteraction = AnySelectMenuInteraction<CacheType> | ButtonInteraction$1<CacheType> | ModalSubmitInteraction$1<CacheType>;
+/**
+ * What type of component is the componenty.
+ *
+ * @export
+ * @enum {number}
+ */
+declare enum ComponentType {
+    Button = "button",
+    SelectMenu = "select",
+    Modal = "modal"
+}
+/**
+ * Metadata for Components.
+ *
+ * @export
+ * @interface ComponentMetadata
+ * @typedef {ComponentMetadata}
+ */
+interface ComponentMetadata {
+    /**
+     * The customId of the component.
+     *
+     * @type {string}
+     */
+    customId: string;
+    /**
+     * The permission level required to use the component.
+     *
+     * @type {PermissionLevel}
+     */
+    permission: PermissionLevel;
+    /**
+     * Whether the interaction reply is ephemeral.
+     *
+     * @type {boolean}
+     */
+    ephemeralReply: boolean;
+}
+/**
+ * Deconstruct a component customId into its parts.
+ *
+ * @param {string} customId
+ * @returns {{ componentType: ComponentType; data: string; tags: {}; }}
+ */
+declare const deconstructCustomId: (customId: string) => {
+    componentType: ComponentType;
+    data: string;
+    tags: "awaited"[];
+};
+
+/**
+ * Base class for a Command.
+ *
+ * @export
+ * @abstract
+ * @class Command
+ * @typedef {Command}
+ */
+declare abstract class Command {
+    abstract data: SlashCommandBuilder | ContextMenuCommandBuilder;
+    abstract metadata: CommandMetadata | ContextMenuMetadata;
+    /**
+     * Returns whether the command is a SlashCommand.
+     *
+     * @public
+     * @param {Command} this
+     * @returns {this is SlashCommand}
+     */
+    isSlashCommand(this: Command): this is SlashCommand;
+    /**
+     * Returns whether the command is a ContextMenuCommand.
+     *
+     * @public
+     * @param {Command} this
+     * @returns {this is ContextMenuCommand}
+     */
+    isContextMenuCommand(this: Command): this is ContextMenuCommand;
+    /**
+     * Returns JSON of the command builder.
+     *
+     * @public
+     * @returns {*}
+     */
+    toJSON(): discord_js.RESTPostAPIChatInputApplicationCommandsJSONBody | discord_js.RESTPostAPIContextMenuApplicationCommandsJSONBody;
+    /**
+     * Reply to the interaction respecting command metadata and if the interaction has already been replied to.
+     *
+     * @public
+     * @async
+     * @param {CommandInteraction} interaction
+     * @param {(MessagePayload | InteractionEditReplyOptions | InteractionReplyOptions)} options
+     * @returns {*}
+     */
+    reply(interaction: CommandInteraction, options: MessagePayload | InteractionEditReplyOptions | InteractionReplyOptions): Promise<void>;
+    /**
+     * Validate permissions for a user/member in a guild.
+     *
+     * @async
+     * @param {CommandInteraction} interaction
+     * @param {PermissionLevel} permission
+     * @param {boolean} [doReply=true]
+     * @returns {unknown}
+     */
+    validateGuildPermission(client: TriviousClient, interaction: CommandInteraction, permission: PermissionLevel, doReply?: boolean): Promise<boolean>;
+}
+/**
+ * Base SlashCommand.
+ *
+ * @export
+ * @abstract
+ * @class SlashCommand
+ * @typedef {SlashCommand}
+ * @extends {Command}
+ */
+declare abstract class SlashCommand extends Command {
+    abstract data: SlashCommandBuilder;
+    abstract metadata: CommandMetadata;
+    /**
+     * Optional function to run if the SlashCommand has no subcommands or for extra fuctionality.
+     *
+     * @abstract
+     * @type {?(
+     * 		client: TriviousClient,
+     * 		interaction: ChatInputCommandInteraction
+     * 	) => Promise<void>}
+     */
+    run?: (client: TriviousClient, interaction: ChatInputCommandInteraction) => Promise<void>;
+    /**
+     * General handler for the command and its subcommand, if applicable.
+     *
+     * @public
+     * @async
+     * @param {TriviousClient} client
+     * @param {ChatInputCommandInteraction} interaction
+     * @returns {*}
+     */
+    execute(client: TriviousClient, interaction: ChatInputCommandInteraction): Promise<void>;
+}
+/**
+ * Base CommandBuilder.
+ *
+ * @export
+ * @class CommandBuilder
+ * @typedef {CommandBuilder}
+ * @extends {SlashCommandBuilder}
+ */
+declare class CommandBuilder extends SlashCommandBuilder {
+    private _active;
+    private _guildOnly;
+    private _ownerOnly;
+    private _permission;
+    private _subcommands;
+    private _ephemeralReply;
+    /**
+     * Set the command as disabled.
+     *
+     * @public
+     * @returns {this}
+     */
+    disable(): this;
+    /**
+     * Set the command as guild only.
+     *
+     * @public
+     * @returns {this}
+     */
+    setGuildOnly(): this;
+    /**
+     * Set the command as public only.
+     *
+     * @public
+     * @returns {this}
+     */
+    setOwnerOnly(): this;
+    /**
+     * Set the permission level required to run the command.
+     *
+     * @public
+     * @param {PermissionLevel} permission
+     * @returns {this}
+     */
+    setPermission(permission: PermissionLevel): this;
+    /**
+     * Set the interaction as ephemeral.
+     *
+     * @public
+     * @returns {this}
+     */
+    setEphemeralReply(): this;
+    /**
+     * Build the builder.
+     *
+     * @public
+     * @returns {{ data: CommandBuilder; metadata: CommandMetadata; }}
+     */
+    build(): {
+        data: CommandBuilder;
+        metadata: {
+            active: boolean;
+            guildOnly: boolean;
+            ownerOnly: boolean;
+            permission: PermissionLevel;
+            subcommands: Collection<string, Subcommand>;
+            ephemeralReply: boolean;
+        };
+    };
+}
+/**
+ * Base ContextMenuCommand.
+ *
+ * @export
+ * @abstract
+ * @class ContextMenuCommand
+ * @typedef {ContextMenuCommand}
+ * @extends {Command}
+ */
+declare abstract class ContextMenuCommand extends Command {
+    abstract data: ContextMenuCommandBuilder;
+    abstract metadata: ContextMenuMetadata;
+    /**
+     * Function to run when the command is used.
+     *
+     * @abstract
+     * @type {(
+     * 		client: TriviousClient,
+     * 		interaction: ContextMenuCommandInteraction
+     * 	) => Promise<void>}
+     */
+    abstract run: (client: TriviousClient, interaction: ContextMenuCommandInteraction) => Promise<void>;
+    /**
+     * Base command handler.
+     *
+     * @public
+     * @async
+     * @param {TriviousClient} client
+     * @param {ContextMenuCommandInteraction} interaction
+     * @returns {*}
+     */
+    execute(client: TriviousClient, interaction: ContextMenuCommandInteraction): Promise<void>;
+}
+/**
+ * Base ContextMenuBuilder.
+ *
+ * @export
+ * @class ContextMenuBuilder
+ * @typedef {ContextMenuBuilder}
+ * @extends {ContextMenuCommandBuilder}
+ */
+declare class ContextMenuBuilder extends ContextMenuCommandBuilder {
+    private _active;
+    private _ownerOnly;
+    private _permission;
+    private _ephemeralReply;
+    /**
+     * Set the command as disabled.
+     *
+     * @public
+     * @returns {this}
+     */
+    disable(): this;
+    /**
+     * Set the command as owner only.
+     *
+     * @public
+     * @returns {this}
+     */
+    setOwnerOnly(): this;
+    /**
+     * Set the permission level required to run the command.
+     *
+     * @public
+     * @param {PermissionLevel} permission
+     * @returns {this}
+     */
+    setPermission(permission: PermissionLevel): this;
+    /**
+     * Set the interaction as ephemeral.
+     *
+     * @public
+     * @returns {this}
+     */
+    setEphemeralReply(): this;
+    /**
+     * Build the builder
+     *
+     * @public
+     * @returns {{ data: ContextMenuBuilder; metadata: ContextMenuMetadata; }}
+     */
+    build(): {
+        data: ContextMenuBuilder;
+        metadata: {
+            active: boolean;
+            ownerOnly: boolean;
+            permission: PermissionLevel;
+            ephemeralReply: boolean;
+        };
+    };
+}
+
+/**
+ * Base SubcommandBuilder.
+ *
+ * @export
+ * @class SubcommandBuilder
+ * @typedef {SubcommandBuilder}
+ * @extends {SlashCommandSubcommandBuilder}
+ */
+declare class SubcommandBuilder extends SlashCommandSubcommandBuilder {
+    private _active;
+    private _ownerOnly;
+    private _permission;
+    private _ephemeralReply;
+    /**
+     * Set the subcommand as disabled.
+     *
+     * @public
+     * @returns {this}
+     */
+    disable(): this;
+    /**
+     * Set the subcommand as owner only.
+     *
+     * @public
+     * @returns {this}
+     */
+    setOwnerOnly(): this;
+    /**
+     * Set the permission level required to run the subcommand.
+     *
+     * @public
+     * @param {PermissionLevel} permission
+     * @returns {this}
+     */
+    setPermission(permission: PermissionLevel): this;
+    /**
+     * Set the interaction as ephemeral
+     *
+     * @public
+     * @returns {this}
+     */
+    setEphemeralReply(): this;
+    /**
+     * Build the builder.
+     *
+     * @public
+     * @returns {{ data: SlashCommandSubcommandBuilder; metadata: SubcommandMetadata; }}
+     */
+    build(): {
+        data: SlashCommandSubcommandBuilder;
+        metadata: {
+            active: boolean;
+            ownerOnly: boolean;
+            permission: PermissionLevel;
+            ephemeralReply: boolean;
+        };
+    };
+}
+/**
+ * Base Subcommand
+ *
+ * @export
+ * @abstract
+ * @class Subcommand
+ * @typedef {Subcommand}
+ */
+declare abstract class Subcommand {
+    abstract data: SlashCommandSubcommandBuilder;
+    abstract metadata: SubcommandMetadata;
+    /**
+     * Function to execute the subcommand.
+     *
+     * @abstract
+     * @readonly
+     * @type {(
+     * 		client: TriviousClient,
+     * 		interaction: ChatInputCommandInteraction<CacheType>
+     * 	) => Promise<void>}
+     */
+    abstract readonly execute: (client: TriviousClient, interaction: ChatInputCommandInteraction$1<CacheType>) => Promise<void>;
+    /**
+     * Reply to the interaction respecting command metadata and if the interaction has already been replied to.
+     *
+     * @async
+     * @param {ChatInputCommandInteraction<CacheType>} interaction
+     * @param {(MessagePayload | InteractionEditReplyOptions | InteractionReplyOptions)} options
+     * @returns {*}
+     */
+    reply(interaction: ChatInputCommandInteraction$1<CacheType>, options: MessagePayload | InteractionEditReplyOptions | InteractionReplyOptions): Promise<void>;
+}
+
+/**
+ * Literal type for possible CommandInteractions.
+ *
+ * @export
+ * @typedef {CommandInteraction}
+ */
+type CommandInteraction = ChatInputCommandInteraction | ContextMenuCommandInteraction;
+/**
+ * Metadata for Commands.
+ *
+ * @export
+ * @interface CommandMetadata
+ * @typedef {CommandMetadata}
+ */
+interface CommandMetadata {
+    /**
+     * Whether the command is active, if `false`, the command is skipped during loading and deployment.
+     *
+     * @type {boolean}
+     */
+    active: boolean;
+    /**
+     * Whether the command is guild-only.
+     *
+     * @type {boolean}
+     */
+    guildOnly: boolean;
+    /**
+     * Whether the command is owner-only.
+     *
+     * @type {boolean}
+     */
+    ownerOnly: boolean;
+    /**
+     * The permission level required to use the command.
+     *
+     * @type {PermissionLevel}
+     */
+    permission: PermissionLevel;
+    /**
+     * Collection of subcommands.
+     *
+     * @type {Collection<string, Subcommand>}
+     */
+    subcommands: Collection<string, Subcommand>;
+    /**
+     * Whether the interaction is ephemeral.
+     *
+     * @type {boolean}
+     */
+    ephemeralReply: boolean;
+}
+/**
+ * Metadata for Subcommands.
+ *
+ * @export
+ * @interface SubcommandMetadata
+ * @typedef {SubcommandMetadata}
+ */
+interface SubcommandMetadata {
+    /**
+     * Whether the subcommand is active, if `false`, the command is skipped during loading.
+     *
+     * @type {boolean}
+     */
+    active: boolean;
+    /**
+     * Whether the subcommand is owner-only.
+     *
+     * @type {boolean}
+     */
+    ownerOnly: boolean;
+    /**
+     * The permission level required to use the subcommand.
+     *
+     * @type {PermissionLevel}
+     */
+    permission: PermissionLevel;
+    /**
+     * Whether the interaction is ephemeral.
+     *
+     * @type {boolean}
+     */
+    ephemeralReply: boolean;
+}
+/**
+ * Metadata for ContextMenuCommands.
+ *
+ * @export
+ * @interface ContextMenuMetadata
+ * @typedef {ContextMenuMetadata}
+ */
+interface ContextMenuMetadata {
+    /**
+     * Whether the command is active, if `false`, the command is skipped during loading and deployment.
+     *
+     * @type {boolean}
+     */
+    active: boolean;
+    /**
+     * Whether the command is owner-only.
+     *
+     * @type {boolean}
+     */
+    ownerOnly: boolean;
+    /**
+     * The permission level required to use the command.
+     *
+     * @type {PermissionLevel}
+     */
+    permission: PermissionLevel;
+    /**
+     * Whether the interaction is ephemeral.
+     *
+     * @type {boolean}
+     */
+    ephemeralReply: boolean;
+}
+/**
+ * Literal type for generic Command use.
+ *
+ * @export
+ * @typedef {AnyCommand}
+ */
+type AnyCommand = SlashCommand | ContextMenuCommand;
+
+/**
+ * Client options for the TriviousClient
+ *
+ * @export
+ * @interface TriviousClientOptions
+ * @typedef {TriviousClientOptions}
+ * @extends {ClientOptions}
+ */
+interface TriviousClientOptions extends ClientOptions {
+    /**
+     * Environment variable for the bot token.
+     *
+     * @type {string}
+     */
+    tokenReference: string;
+    /**
+     * Environment variable for the client id.
+     *
+     * @type {string}
+     */
+    clientIdReference: string;
+    /**
+     * Set core paths for where the registries should look.
+     *
+     * @type {?{
+     * 		commandsPath?: string;
+     * 		componentsPath?: string;
+     * 		eventsPath?: string;
+     * 		modulesPath?: string;
+     * 	}}
+     */
+    corePaths?: {
+        commandsPath?: string;
+        componentsPath?: string;
+        eventsPath?: string;
+        modulesPath?: string;
+    };
+    /**
+     * Set base core path, only use if you aren't defining corePaths. This is intended for the case where all your registry folders are in the same directory.
+     *
+     * @type {?string}
+     */
+    corePath?: string;
+    /**
+     * Roles tied to a PermissionLevel.
+     *
+     * @type {Record<string, PermissionLevel>}
+     */
+    rolePermissions?: Record<string, PermissionLevel>;
+}
+
+/**
+ * Base Event.
+ *
+ * @export
+ * @interface Event
+ * @typedef {Event}
+ * @template {keyof ClientEvents} [K=keyof ClientEvents]
+ */
+interface Event<K extends keyof ClientEvents = keyof ClientEvents> {
+    /**
+     * Name of the ClientEvent.
+     *
+     * @type {K}
+     */
+    name: K;
+    /**
+     * Whether the event is once.
+     *
+     * @type {?boolean}
+     */
+    once?: boolean;
+    /**
+     * Execute the event.
+     *
+     * @type {(client: TriviousClient, ...args: ClientEvents[K]) => Promise<void> | void}
+     */
+    execute: (client: TriviousClient, ...args: ClientEvents[K]) => Promise<void> | void;
+}
+
+/**
+ * Base Module.
+ *
+ * @export
+ * @interface Module
+ * @typedef {Module}
+ */
+interface Module {
+    /**
+     * The name of the Module.
+     *
+     * @type {string}
+     */
+    name: string;
+    /**
+     * The events the module is listening for.
+     *
+     * @type {{
+     * 		[K in keyof ClientEvents]?: (
+     * 			client: TriviousClient,
+     * 			...args: ClientEvents[K]
+     * 		) => Promise<void> | void;
+     * 	}}
+     */
+    events?: {
+        [K in keyof ClientEvents]?: (client: TriviousClient, ...args: ClientEvents[K]) => Promise<void> | void;
+    };
+}
+
+/**
+ * Registry to load, get and bind modules.
+ *
+ * @export
+ * @class ModuleRegistry
+ * @typedef {ModuleRegistry}
+ * @extends {BaseRegistry<Module>}
+ */
+declare class ModuleRegistry extends BaseRegistry<Module> {
+    protected items: Collection<string, Module>;
+    /**
+     * Load all modules.
+     *
+     * @async
+     * @param {string} [directory=getCorePath({ coreDirectory: "module" })]
+     * @returns {Promise<this>}
+     */
+    load(directory?: string): Promise<this>;
+    /**
+     * Bind all loaded modules to their client event respectively.
+     *
+     * @param {TriviousClient} client
+     */
+    bind(client: TriviousClient): void;
+}
+
+/**
+ * Registry to load, get and bind events.
+ *
+ * @export
+ * @class EventRegistry
+ * @typedef {EventRegistry}
+ * @extends {BaseRegistry<Event>}
+ */
+declare class EventRegistry extends BaseRegistry<Event> {
+    protected items: Collection<string, Event<keyof ClientEvents>>;
+    /**
+     * Load all events.
+     *
+     * @async
+     * @param {string} [directory=getCorePath({ coreDirectory: "events" })]
+     * @returns {Promise<this>}
+     */
+    load(directory?: string): Promise<this>;
+    /**
+     * Bind loaded events to their client events respectively.
+     *
+     * @param {TriviousClient} client
+     */
+    bind(client: TriviousClient): void;
+}
+
+/**
+ * Base ComponentBuilder.
+ *
+ * @export
+ * @class ComponentBuilder
+ * @typedef {ComponentBuilder}
+ */
+declare class ComponentBuilder {
+    private _customId;
+    private _permission;
+    private _ephemeralReply;
+    /**
+     * Set the customId for the component.
+     *
+     * @public
+     * @param {{
+     * 		type: ComponentType;
+     * 		data: string;
+     * 		tags?: ComponentCustomIdTag[];
+     * 	}} options
+     * @returns {this}
+     */
+    setCustomId(options: {
+        type: ComponentType$1;
+        data: string;
+        tags?: ComponentCustomIdTag[];
+    }): this;
+    /**
+     * Set the permission required to use the component.
+     *
+     * @public
+     * @param {PermissionLevel} permission
+     * @returns {this}
+     */
+    setPermission(permission: PermissionLevel): this;
+    /**
+     * Set the interaction as ephemeral.
+     *
+     * @public
+     * @returns {this}
+     */
+    setEphemeralReply(): this;
+    /**
+     * Builder the builder.
+     *
+     * @public
+     * @returns {{ metadata: ComponentMetadata; }}
+     */
+    build(): {
+        metadata: {
+            customId: string;
+            permission: PermissionLevel;
+            ephemeralReply: boolean;
+        };
+    };
+}
+/**
+ * Base Component.
+ *
+ * @export
+ * @abstract
+ * @class Component
+ * @typedef {Component}
+ */
+declare abstract class Component {
+    abstract metadata: ComponentMetadata;
+    /**
+     * Execute the component.
+     *
+     * @abstract
+     * @type {(client: TriviousClient, interaction: ComponentInteraction) => Promise<void>}
+     */
+    abstract execute: (client: TriviousClient, interaction: ComponentInteraction) => Promise<void>;
+    /**
+     * Validate permissions for a user/member in a guild.
+     *
+     * @async
+     * @param {ComponentInteraction} interaction
+     * @param {PermissionLevel} permission
+     * @param {boolean} [doReply=true] Defaults to `true`
+     * @returns {unknown}
+     */
+    validateGuildPermission(client: TriviousClient, interaction: ComponentInteraction, permission: PermissionLevel, doReply?: boolean): Promise<boolean>;
+    /**
+     * Reply to the interaction respecting command metadata and if the interaction has already been replied to.
+     *
+     * @async
+     * @param {ComponentInteraction} interaction
+     * @param {(MessagePayload | InteractionEditReplyOptions | InteractionReplyOptions)} options
+     * @returns {*}
+     */
+    reply(interaction: ComponentInteraction, options: MessagePayload | InteractionEditReplyOptions | InteractionReplyOptions): Promise<void>;
+}
+
+/**
+ * Registry to load and get all components.
+ *
+ * @export
+ * @class ComponentRegistry
+ * @typedef {ComponentRegistry}
+ * @extends {BaseRegistry<Component>}
+ */
+declare class ComponentRegistry extends BaseRegistry<Component> {
+    protected items: Collection<string, Component>;
+    /**
+     * Load all components.
+     *
+     * @async
+     * @param {string} [directory=getCorePath({ coreDirectory: "components" })]
+     * @returns {Promise<this>}
+     */
+    load(directory?: string): Promise<this>;
+}
+
+/**
+ * Registry to load and get all commands.
+ *
+ * @export
+ * @class CommandRegistry
+ * @typedef {CommandRegistry}
+ * @extends {BaseRegistry<AnyCommand>}
+ */
+declare class CommandRegistry extends BaseRegistry<AnyCommand> {
+    protected items: Collection<string, AnyCommand>;
+    /**
+     * Load all commands and their subcommands
+     *
+     * @async
+     * @param {string} [directory=getCorePath({ coreDirectory: "commands" })]
+     * @returns {unknown}
+     */
+    load(directory?: string): Promise<this>;
+}
+
+/**
+ * Trivious base client.
+ *
+ * @export
+ * @class TriviousClient
+ * @typedef {TriviousClient}
+ * @extends {Client}
+ */
+declare class TriviousClient extends Client {
+    /**
+     * Client registries.
+     *
+     * @public
+     * @readonly
+     * @type {*}
+     */
+    readonly registries: {
+        commands: CommandRegistry;
+        components: ComponentRegistry;
+        events: EventRegistry;
+        modules: ModuleRegistry;
+        loadAll(options: TriviousClientOptions): Promise<void>;
+        bind(client: TriviousClient): void;
+    };
+    /**
+     * Client copy of the constructor options.
+     *
+     * @private
+     * @type {TriviousClientOptions}
+     */
+    private _options;
+    /**
+     * Creates an instance of TriviousClient.
+     *
+     * @constructor
+     * @param {TriviousClientOptions} options
+     */
+    constructor(options: TriviousClientOptions);
+    /**
+     * Load all registries.
+     *
+     * @async
+     * @returns {*}
+     */
+    register(): Promise<void>;
+    /**
+     * Login and start the bot.
+     *
+     * @async
+     * @returns {*}
+     */
+    start(): Promise<void>;
+    /**
+     * Deploy all commands.
+     *
+     * @async
+     * @returns {*}
+     */
+    deploy(): Promise<void>;
+    /**
+     * Set the roles tied to a permission level.
+     *
+     * @param {Record<string, PermissionLevel>} roles
+     */
+    setRolePermissions(roles: Record<string, PermissionLevel>): void;
+    get rolePermissions(): Record<string, PermissionLevel>;
+}
+
+type ChatInputCommandInteraction = ChatInputCommandInteraction$1<CacheType>;
+type ButtonInteraction = ButtonInteraction$1<CacheType>;
+type StringSelectMenuInteraction = StringSelectMenuInteraction$1<CacheType>;
+type ModalSubmitInteraction = ModalSubmitInteraction$1<CacheType>;
+type ContextMenuCommandInteraction = ContextMenuCommandInteraction$1<CacheType>;
+
+export { type AnyCommand, BaseRegistry, type ButtonInteraction, type ChatInputCommandInteraction, Command, CommandBuilder, type CommandInteraction, type CommandMetadata, CommandRegistry, Component, ComponentBuilder, type ComponentCustomIdTag, type ComponentInteraction, type ComponentMetadata, ComponentRegistry, ComponentType, ContextMenuBuilder, ContextMenuCommand, type ContextMenuCommandInteraction, type ContextMenuMetadata, type Event, type ModalSubmitInteraction, type Module, PermissionLevel, SlashCommand, type StringSelectMenuInteraction, Subcommand, SubcommandBuilder, type SubcommandMetadata, TriviousClient, type TriviousClientOptions, deconstructCustomId, getPermissionLevel };