trivious 1.3.24 → 1.3.26

package/dist/index-BjPKCNAw.d.cts

@@ -0,0 +1,940 @@
+import { BaseRegistry } from './shared/typings/registry.cjs';
+import * as discord_js from 'discord.js';
+import { GuildMember, AnySelectMenuInteraction, CacheType, ButtonInteraction as ButtonInteraction$1, ModalSubmitInteraction as ModalSubmitInteraction$1, SlashCommandBuilder, ContextMenuCommandBuilder, MessagePayload, InteractionEditReplyOptions, InteractionReplyOptions, Collection, 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;
+
+/**
+ * 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>;
+    /**
+     * Discord user Ids of the bot owner(s)
+     *
+     * @type {string[]}
+     */
+    botOwnerIds?: string[];
+}
+
+/**
+ * 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 preset events, can be overridden by user-provided events.
+     *
+     * @async
+     * @protected
+     * @returns {Promise<this>}
+     */
+    protected loadPresetEvents(): Promise<this | undefined>;
+    /**
+     * 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}
+     */
+    readonly _options: TriviousClientOptions;
+    /**
+     * 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 as A, type ButtonInteraction as B, CommandRegistry as C, EventRegistry as E, ModuleRegistry as M, PermissionLevel as P, SlashCommand as S, TriviousClient as T, ComponentRegistry as a, type TriviousClientOptions as b, type ComponentCustomIdTag as c, type ComponentInteraction as d, ComponentType as e, type ComponentMetadata as f, getPermissionLevel as g, deconstructCustomId as h, Command as i, CommandBuilder as j, ContextMenuCommand as k, ContextMenuBuilder as l, Subcommand as m, SubcommandBuilder as n, type CommandInteraction as o, type CommandMetadata as p, type SubcommandMetadata as q, type ContextMenuMetadata as r, type Event as s, type Module as t, Component as u, ComponentBuilder as v, type ChatInputCommandInteraction as w, type StringSelectMenuInteraction as x, type ModalSubmitInteraction as y, type ContextMenuCommandInteraction as z };