@crowbartools/firebot-types 5.67.0-alpha2 → 5.67.0-alpha21

package/README.md

@@ -1,8 +1,8 @@
 # @crowbartools/firebot-types
 
-Type definitions and the script API contract for [Firebot](https://firebot.app) custom scripts and plugins.
+Type definitions and the plugin API contract for [Firebot](https://firebot.app) plugins.
 
-This package is **type-only**. At runtime the `@crowbartools/firebot-types` module is provided by the Firebot host application via a `require()` interceptor — installing this package in a standalone Node project and importing it will throw.
+This package is **type-only**. At runtime the `@crowbartools/firebot-types` module is provided by the Firebot host application via a `require()` interceptor (installing this package in a standalone Node project and importing it will throw).
 
 ## Install
 
@@ -10,32 +10,44 @@ This package is **type-only**. At runtime the `@crowbartools/firebot-types` modu
 npm i -D @crowbartools/firebot-types
 ```
 
-A `@types/node` peer dependency is required (the script API uses `Buffer` / `BufferEncoding`).
+The following peer dependencies are required:
+- `@types/express`
+- `@types/node`
 
 ## Usage
 
 The default export is the runtime API object provided by Firebot. Named types are re-exported from the package root and can be imported alongside the default in a single statement.
 
 ```ts
-import firebot, { Plugin, EffectScript, Manifest } from "@crowbartools/firebot-types";
+import firebot, { Plugin } from "@crowbartools/firebot-types";
 
-export const manifest: Manifest = {
+type Params = {
+    message: string;
+}
+
+const plugin: Plugin<Params> = {
+  manifest: {
     name: "My Plugin",
     version: "1.0.0",
     author: "you",
     description: "Example",
     type: "plugin"
-};
-
-export function onLoad() {
-    firebot.logger.info(`Running on Firebot ${firebot.version}`);
+  },
+  parametersSchema: [
+    {
+      name: "message",
+      type: "string",
+      default: "Hello World!",
+      title: "Hello!",
+      description: "Message",
+    }
+  ],
+  onLoad: (context) => {
+    firebot.logger.info(`${context.parameters.message} (${firebot.version})`);
+  }
 }
-```
-
-Deep imports for less common types are also supported:
 
-```ts
-import type { EffectHelperService } from "@crowbartools/firebot-types/types/ui/effect-helper-service";
+export default plugin;
 ```
 
 CommonJS style works too (requires `esModuleInterop` in your tsconfig):

package/backend/app-management/app-close-listener-manager.d.ts

@@ -0,0 +1,11 @@
+import type { Awaitable } from "../../types";
+type AppCloseListener = () => Awaitable<void>;
+declare class AppCloseListenerManager {
+    private listeners;
+    constructor();
+    registerListener(listener: AppCloseListener): void;
+    unregisterListener(listener: AppCloseListener): void;
+    runListeners(): Promise<void>;
+}
+declare const manager: AppCloseListenerManager;
+export { manager as AppCloseListenerManager };

package/backend/app-management/data-tasks.d.ts

@@ -0,0 +1 @@
+export declare function ensureRequiredFoldersExist(): Promise<void>;

package/backend/app-management/electron/app-helpers.d.ts

@@ -0,0 +1 @@
+export declare function restartApp(): void;

package/backend/app-management/electron/electron-events.d.ts

@@ -0,0 +1,7 @@
+import { whenReady } from "./events/when-ready";
+import { windowsAllClosed } from "./events/windows-all-closed";
+import { willQuit } from "./events/will-quit";
+import { secondInstance } from "./events/second-instance";
+import { openUrl } from "./events/open-url";
+import { openFile } from "./events/open-file";
+export { whenReady, windowsAllClosed, willQuit, secondInstance, openUrl, openFile };

package/backend/app-management/electron/events/ipc-events.d.ts

@@ -0,0 +1 @@
+export declare function setupIpcEvents(): void;

package/backend/app-management/electron/events/open-file.d.ts

@@ -0,0 +1,2 @@
+import type { Event } from "electron";
+export declare function openFile(event: Event, path: string): void;

package/backend/app-management/electron/events/open-url.d.ts

@@ -0,0 +1,2 @@
+import type { Event } from "electron";
+export declare function openUrl(_: Event, url: string): Promise<void>;

package/backend/app-management/electron/events/second-instance.d.ts

@@ -0,0 +1,2 @@
+import type { Event } from "electron";
+export declare function secondInstance(event: Event, argv: string[]): Promise<void>;

package/backend/app-management/electron/events/when-ready.d.ts

@@ -0,0 +1 @@
+export declare function whenReady(): Promise<void>;

package/backend/app-management/electron/events/will-quit.d.ts

@@ -0,0 +1,2 @@
+import { type Event } from "electron";
+export declare function willQuit(event: Event): Promise<void>;

package/backend/app-management/electron/events/windows-all-closed.d.ts

@@ -0,0 +1 @@
+export declare function windowsAllClosed(): void;

package/backend/app-management/electron/screen-helpers.d.ts

@@ -0,0 +1,3 @@
+export declare function getAllDisplays(): Electron.Display[];
+export declare function getPrimaryDisplay(): Electron.Display;
+export declare function takeScreenshot(displayId: number): Promise<string>;

package/backend/app-management/electron/tray-creation.d.ts

@@ -0,0 +1,2 @@
+import { type BrowserWindow } from "electron";
+export declare function createTray(mainWindow: BrowserWindow): void;

package/backend/app-management/electron/windows/effect-queue-monitor-window.d.ts

@@ -0,0 +1,3 @@
+import { BrowserWindow } from "electron";
+export declare function getEffectQueueMonitorWindow(): BrowserWindow | null;
+export declare function createEffectQueueMonitorWindow(): Promise<BrowserWindow>;

package/backend/app-management/file-open-helpers.d.ts

@@ -0,0 +1,3 @@
+export declare function setWindowReady(ready: boolean): void;
+export declare function checkForFirebotSetupInPath(filePath: string): boolean;
+export declare function checkForFirebotSetupPathInArgs(args: string[]): void;

package/backend/app-management/profile-tasks.d.ts

@@ -0,0 +1,2 @@
+export declare function handleProfileRename(): void;
+export declare function handleProfileDeletion(): void;

package/backend/app-management/squirrel-events.d.ts

@@ -0,0 +1 @@
+export declare function handleSquirrelEvents(): boolean;

package/backend/auth/auth-manager.d.ts

@@ -0,0 +1,24 @@
+import { TypedEmitter } from "tiny-typed-emitter";
+import ClientOAuth2 from "client-oauth2";
+import type { AuthDetails, AuthProvider, AuthProviderDefinition } from "../../types";
+type Events = {
+    "auth-success": (event: AuthSuccessEventArgs) => void;
+};
+interface AuthSuccessEventArgs {
+    providerId: string;
+    tokenData: AuthDetails;
+}
+declare class AuthManager extends TypedEmitter<Events> {
+    private logger;
+    private readonly _httpPort;
+    private _authProviders;
+    constructor();
+    registerAuthProvider(provider: AuthProviderDefinition): void;
+    getAuthProvider(providerId: string): AuthProvider;
+    buildOAuthClientForProvider(provider: AuthProviderDefinition, redirectUri: string): ClientOAuth2;
+    refreshTokenIfExpired(providerId: string, tokenData: ClientOAuth2.Data): Promise<unknown>;
+    revokeTokens(providerId: string, tokenData: ClientOAuth2.Data): Promise<void>;
+    successfulAuth(providerId: string, tokenData: AuthDetails): void;
+}
+declare const manager: AuthManager;
+export = manager;

package/backend/auth/firebot-device-auth-provider.d.ts

@@ -0,0 +1,18 @@
+import type { AuthDetails, AuthProviderDefinition } from "../../types";
+import { DeviceAuthProvider } from "../streaming-platforms/twitch/auth/twitch-device-auth-provider";
+type ValidationRequest = {
+    accountType: "streamer" | "bot";
+    authDetails: AuthDetails;
+};
+declare class FirebotDeviceAuthProvider {
+    private logger;
+    streamerProvider: DeviceAuthProvider;
+    botProvider: DeviceAuthProvider;
+    private onRefresh;
+    setupDeviceAuthProvider(): void;
+    isTwitchTokenDataValid(definition: AuthProviderDefinition, authDetails: AuthDetails): boolean;
+    validateTwitchAccount(request: ValidationRequest): boolean;
+    validateTwitchAccounts(): void;
+}
+declare const firebotDeviceAuthProvider: FirebotDeviceAuthProvider;
+export { firebotDeviceAuthProvider as FirebotDeviceAuthProvider };

package/backend/backup-manager.d.ts

@@ -0,0 +1,32 @@
+export type FirebotBackup = {
+    name: string;
+    path: string;
+    backupDate: Date;
+    version: string;
+    size: number;
+    isManual: boolean;
+    neverDelete: boolean;
+};
+declare class BackupManager {
+    private _backupFolderPath;
+    private logger;
+    constructor();
+    get backupFolderPath(): string;
+    getBackupList(): Promise<FirebotBackup[]>;
+    private getBackupInfo;
+    private updateBackupFolderPath;
+    toggleBackupPreventDeletion(backupFilePath: string): Promise<void>;
+    private cleanUpOldBackups;
+    startBackup(manualActivation?: boolean): Promise<void>;
+    onceADayBackUpCheck(): Promise<void>;
+    restoreBackup(backupFilePath: string): Promise<{
+        success: boolean;
+        reason?: string;
+    }>;
+    private validateBackupZip;
+    private extractBackupZip;
+    private copyRestoreFilesToUserData;
+    private moveBackupFolder;
+}
+declare const backupManager: BackupManager;
+export { backupManager as BackupManager };

package/backend/channel-rewards/channel-reward-manager.d.ts

@@ -0,0 +1,30 @@
+import { JsonDB } from "node-json-db";
+import type { RewardRedemptionMetadata, SavedChannelReward } from "../../types";
+import type { CustomReward, RewardRedemption, RewardRedemptionsApprovalRequest } from "../streaming-platforms/twitch/api/resource/channel-rewards";
+declare class ChannelRewardManager {
+    private logger;
+    channelRewards: Record<string, SavedChannelReward>;
+    private _channelRewardRedemptions;
+    private _eligible;
+    constructor();
+    getChannelRewardsDb(): JsonDB;
+    loadChannelRewards(): Promise<void>;
+    saveChannelReward(channelReward: SavedChannelReward, emitUpdateEvent?: boolean): Promise<SavedChannelReward>;
+    saveTwitchDataForChannelReward(twitchData: CustomReward): SavedChannelReward;
+    saveAllChannelRewards(allChannelRewards: SavedChannelReward[], updateTwitch?: boolean): Promise<void>;
+    deleteChannelReward(channelRewardId: string, propagateToTwitch?: boolean, notifyFrontend?: boolean): Promise<void>;
+    getChannelReward(channelRewardId: string): SavedChannelReward;
+    getChannelRewardIdByName(channelRewardName: string): string;
+    private triggerRewardEffects;
+    triggerChannelReward(rewardId: string, metadata: RewardRedemptionMetadata, manual?: boolean): Promise<boolean | void>;
+    triggerChannelRewardFulfilled(rewardId: string, metadata: RewardRedemptionMetadata, manual?: boolean): Promise<void>;
+    triggerChannelRewardCanceled(rewardId: string, metadata: RewardRedemptionMetadata, manual?: boolean): Promise<void>;
+    refreshChannelRewardRedemptions(): Promise<void>;
+    addRewardRedemption(rewardId: string, redemption: RewardRedemption): void;
+    removeRewardRedemption(rewardId: string, redemptionId: string): void;
+    getChannelRewardRedemptions(): Record<string, RewardRedemption[]>;
+    approveOrRejectChannelRewardRedemptions(request: RewardRedemptionsApprovalRequest): Promise<void>;
+    approveOrRejectAllRedemptionsForChannelRewards(rewardIds: string[], approve?: boolean): Promise<void>;
+}
+declare const channelRewardManager: ChannelRewardManager;
+export = channelRewardManager;

package/backend/chat/active-user-handler.d.ts

@@ -0,0 +1,55 @@
+import { TypedEmitter } from "tiny-typed-emitter";
+import type { HelixChatChatter } from "@twurple/api";
+type User = {
+    id: string;
+    username: string;
+};
+type UserDetails = User & {
+    displayName: string;
+    profilePicUrl: string;
+    twitchRoles: string[];
+    disableViewerList?: boolean;
+};
+type ChatUser = {
+    userId: string;
+    userName: string;
+    displayName: string;
+    isBroadcaster?: boolean;
+    isFounder?: boolean;
+    isSubscriber?: boolean;
+    isMod?: boolean;
+    isVip?: boolean;
+    online?: boolean;
+    badges?: Map<string, string>;
+};
+type Events = {
+    "user:online": (userDetails: UserDetails) => void;
+    "user:offline": (userId: string) => void;
+};
+declare class ActiveUserHandler extends TypedEmitter<Events> {
+    private logger;
+    private readonly DEFAULT_ACTIVE_TIMEOUT;
+    private readonly ONLINE_TIMEOUT;
+    private _onlineUsers;
+    private _activeUsers;
+    constructor();
+    /**
+     * Check if user is active
+     * @param usernameOrId Twitch username or user ID
+     * @returns `true` if the specified user is active, or `false` otherwise
+     */
+    userIsActive(usernameOrId: string): boolean;
+    getActiveUserCount(): number;
+    getRandomActiveUser(ignoreUser?: string): User;
+    getAllActiveUsers(): User[];
+    getOnlineUserCount(): number;
+    getRandomOnlineUser(ignoreUser?: string): UserDetails;
+    getAllOnlineUsers(): UserDetails[];
+    private updateUserOnlineStatus;
+    addOnlineUser(viewer: HelixChatChatter): Promise<void>;
+    addActiveUser(chatUser: ChatUser, includeInOnline?: boolean, forceActive?: boolean): Promise<void>;
+    removeActiveUser(usernameOrId: string | number): void;
+    clearAllActiveUsers(): void;
+}
+declare const handler: ActiveUserHandler;
+export { handler as ActiveUserHandler };

package/backend/chat/chat-helpers.d.ts

@@ -0,0 +1,21 @@
+import { type ChatMessage, type ParsedMessageCheerPart } from "@twurple/chat";
+import type { EventSubAutoModMessageHoldV2Event } from "@twurple/eventsub-base";
+import type { FirebotChatMessage, FirebotCheermoteInstance, FirebotParsedMessagePart } from "../../types";
+interface ExtensionBadge {
+    id: string;
+    version: string;
+}
+declare class FirebotChatHelpers {
+    private logger;
+    private readonly URL_REGEX;
+    parseCheermote(part: ParsedMessageCheerPart | FirebotParsedMessagePart): FirebotCheermoteInstance;
+    private _parseMessageParts;
+    private _getChatBadges;
+    private _getMessageParts;
+    buildBasicFirebotChatMessage(msgText: string, username: string): FirebotChatMessage;
+    buildFirebotChatMessage(msg: ChatMessage, msgText: string, whisper?: boolean, action?: boolean): Promise<FirebotChatMessage>;
+    buildFirebotChatMessageFromExtensionMessage(text: string, extensionName: string, extensionIconUrl: string, badges: ExtensionBadge[], color: string, id: string): Promise<FirebotChatMessage>;
+    buildViewerFirebotChatMessageFromAutoModMessage(msg: EventSubAutoModMessageHoldV2Event): Promise<FirebotChatMessage>;
+}
+declare const chatHelpers: FirebotChatHelpers;
+export = chatHelpers;

package/backend/chat/commands/builtin/command-list.d.ts

@@ -0,0 +1,9 @@
+import type { SystemCommand } from "../../../../types";
+/**
+ * The `!commands` command
+ */
+export declare const CommandListSystemCommand: SystemCommand<{
+    successTemplate: string;
+    noCommandsTemplate: string;
+    defaultTag?: string;
+}>;

package/backend/chat/commands/builtin/command-management.d.ts

@@ -0,0 +1,5 @@
+import type { SystemCommand } from "../../../../types";
+/**
+ * The `!command` command
+ */
+export declare const CommandManagementSystemCommand: SystemCommand;

package/backend/chat/commands/builtin/custom-role-management.d.ts

@@ -0,0 +1,5 @@
+import type { SystemCommand } from "../../../../types";
+/**
+ * The `!role` command
+ */
+export declare const CustomRoleManagementSystemCommand: SystemCommand;

package/backend/chat/commands/builtin/follow-age.d.ts

@@ -0,0 +1,7 @@
+import type { SystemCommand } from "../../../../types";
+/**
+ * The `!followage` command
+ */
+export declare const FollowAgeSystemCommand: SystemCommand<{
+    displayTemplate: string;
+}>;

package/backend/chat/commands/builtin/marker.d.ts

@@ -0,0 +1,9 @@
+import type { SystemCommand } from "../../../../types";
+/**
+ * The `!marker` command
+ */
+export declare const MarkerSystemCommand: SystemCommand<{
+    successTemplate: string;
+    unableTemplate: string;
+    errorTemplate: string;
+}>;

package/backend/chat/commands/builtin/quotes.d.ts

@@ -0,0 +1,10 @@
+import type { SystemCommand } from "../../../../types";
+/**
+ * The `!quote` command
+ */
+export declare const QuotesManagementSystemCommand: SystemCommand<{
+    quoteDisplayTemplate: string;
+    quoteDateFormat: string;
+    useTTS: boolean;
+    defaultStreamerAttribution: boolean;
+}>;

package/backend/chat/commands/builtin/spam-raid-protection.d.ts

@@ -0,0 +1,16 @@
+import type { SystemCommand } from "../../../../types";
+/**
+ * The `!spamraidprotection` command
+ */
+export declare const SpamRaidProtectionSystemCommand: SystemCommand<{
+    displayTemplate: string;
+    enableFollowerOnly: boolean;
+    enableFollowerOnlyDuration: string;
+    enableEmoteOnly: boolean;
+    enableSubscriberOnly: boolean;
+    enableSlowMode: boolean;
+    enableSlowModeDelay: number;
+    clearChat: boolean;
+    blockRaiders: boolean;
+    banRaiders: boolean;
+}>;

package/backend/chat/commands/builtin/steam/steam-access.d.ts

@@ -0,0 +1,16 @@
+interface FirebotSteamGameDetails {
+    name: string;
+    shortDescription?: string;
+    price: string;
+    score: number;
+    releaseDate: string;
+    url: string;
+}
+declare class SteamManager {
+    private logger;
+    getSteamGameDetails(requestedGame: string, countryCode?: string): Promise<FirebotSteamGameDetails>;
+    private getAppIdFromGameName;
+    private getSteamAppDetails;
+}
+declare const steamCacheManager: SteamManager;
+export = steamCacheManager;

package/backend/chat/commands/builtin/steam/steam.d.ts

@@ -0,0 +1,8 @@
+import type { SystemCommand } from "../../../../../types";
+/**
+ * The `!steam` command
+ */
+export declare const SteamSystemCommand: SystemCommand<{
+    outputTemplate: string;
+    countryCode: string;
+}>;

package/backend/chat/commands/builtin/uptime.d.ts

@@ -0,0 +1,7 @@
+import type { SystemCommand } from "../../../../types";
+/**
+ * The `!uptime` command
+ */
+export declare const UptimeSystemCommand: SystemCommand<{
+    uptimeDisplayTemplate: string;
+}>;

package/backend/chat/commands/chat-command-handler.d.ts

@@ -0,0 +1,17 @@
+import type { CommandDefinition, FirebotChatMessage, SystemCommandDefinition, UserCommand } from "../../../types";
+declare class CommandHandler {
+    private logger;
+    private _handledMessageIds;
+    private buildCommandRegexStr;
+    private testForTrigger;
+    private checkForCommand;
+    private updateCommandCount;
+    checkCommandRestrictions(firebotChatMessage: FirebotChatMessage, command: CommandDefinition, userCmd: UserCommand, sendFailureMessage?: boolean): Promise<boolean>;
+    handleChatMessage(firebotChatMessage: FirebotChatMessage): Promise<{
+        ranCommand: boolean;
+        command?: CommandDefinition | SystemCommandDefinition;
+        userCommand?: UserCommand;
+    }>;
+}
+declare const commandHandler: CommandHandler;
+export = commandHandler;

package/backend/chat/commands/command-cooldown-manager.d.ts

@@ -0,0 +1,32 @@
+import type { CommandDefinition, SubCommand } from "../../../types";
+interface CooldownConfig {
+    commandId: string;
+    subcommandId?: string;
+    username: string;
+    cooldown: {
+        global: number;
+        user: number;
+    };
+}
+interface ClearCooldownConfig {
+    commandId: string;
+    subcommandId?: string;
+    username: string;
+    cooldown: {
+        global: boolean;
+        user: boolean;
+    };
+}
+declare class CommandCooldownManager {
+    private logger;
+    private _cooldownCache;
+    private buildCooldownCacheKey;
+    getRemainingCooldown(command: CommandDefinition, triggeredSubcmd: SubCommand, username: string): number;
+    cooldownCommand(command: CommandDefinition, triggeredSubcmd: SubCommand, username: string): void;
+    manuallyCooldownCommand(config: CooldownConfig): void;
+    manuallyClearCooldownCommand(config: ClearCooldownConfig): void;
+    clearCooldownsForSingleCommand(commandId: string): void;
+    flushCooldownCache(): void;
+}
+declare const commandCooldownManager: CommandCooldownManager;
+export = commandCooldownManager;

package/backend/chat/commands/command-manager.d.ts

@@ -0,0 +1,156 @@
+import { TypedEmitter } from "tiny-typed-emitter";
+import type { CommandDefinition, SystemCommand, SystemCommandDefinition } from "../../../types";
+type Events = {
+    "created-item": (item: object) => void;
+    "updated-item": (item: object) => void;
+    "deleted-item": (item: object) => void;
+    "systemCommandRegistered": (item: SystemCommand) => void;
+    "systemCommandUnRegistered": (id: string) => void;
+};
+/**
+ * The class for the manager object that maintains Firebot system/custom chat commands
+ */
+declare class CommandManager extends TypedEmitter<Events> {
+    private logger;
+    private _registeredSysCommands;
+    private _commandCache;
+    constructor();
+    private getCommandsDb;
+    /**
+     * Registers a system command
+     *
+     * @param command The system command to register
+     */
+    registerSystemCommand(command: SystemCommand): void;
+    /**
+     * Unregisters a system command
+     *
+     * @param id The ID of the system command to unregister
+     */
+    unregisterSystemCommand(id: string): void;
+    /**
+     * Gets a system command that matches the given ID
+     *
+     * @param id The ID of the system command to retrieve
+     * @returns The cached `SystemCommand` object that matches the given ID, or `null` if there is no matching system command
+     */
+    getSystemCommandById(id: string): SystemCommand;
+    /**
+     * Gets the trigger for the system command that matches the given ID
+     *
+     * @param id The ID of the system command
+     * @returns The trigger for the cached system command that matches the given ID, or `null` if there is no matching system command
+     */
+    getSystemCommandTrigger(id: string): string;
+    /**
+     * Returns whether or not a given system command is in the cache
+     *
+     * @param id The ID of the system command
+     * @returns `true` if the system command exists in the cache, or `false` if it doesn't
+     */
+    hasSystemCommand(id: string): boolean;
+    /**
+     * Returns all cached system commands
+     *
+     * @returns An array of all cached `SystemCommand` objects
+     */
+    getSystemCommands(): SystemCommand[];
+    /**
+     * Returns the definitions of all cached system commands
+     *
+     * @returns An array of `SystemCommandDefinition` objects for all cached system commands
+     */
+    getAllSystemCommandDefinitions(): SystemCommandDefinition[];
+    /**
+     * Gets a custom command
+     *
+     * @param id The ID of the custom command
+     * @returns The cached `CommandDefinition` object for the given custom command
+     */
+    getCustomCommandById(id: string): CommandDefinition;
+    /**
+     * Gets all custom commands in the cache
+     *
+     * @returns An array of all cached `CommandDefinition` objects
+     */
+    getAllCustomCommands(): CommandDefinition[];
+    /**
+     * Gets the definitions for all active system and custom commands in the cache
+     *
+     * @returns An array of `CommandDefinition` objects for all active system and custom commands in the cache
+     */
+    getAllActiveCommands(): CommandDefinition[];
+    /**
+     * Returns whether or not the given trigger is already in use on an active command
+     *
+     * @param trigger The trigger to check if it's taken
+     * @returns `true` if the given trigger is already in use for an active command in the cache, or `false` otherwise
+     */
+    triggerIsTaken(trigger: string): boolean;
+    /**
+     * Forces an update to a system command trigger even if the user has saved an override of the default trigger
+     *
+     * @param id The ID of the system command
+     * @param newTrigger The new trigger for the given system command
+     */
+    forceUpdateSysCommandTrigger(id: string, newTrigger: string): void;
+    /**
+     * Saves a system command override
+     *
+     * @param command The `SystemCommandDefinition` with the system command override data
+     */
+    saveSystemCommandOverride(command: SystemCommandDefinition, fireEvent?: boolean): void;
+    /**
+     * Removes the override for a given system command
+     *
+     * @param id The ID of the system command for which to remove the override
+     */
+    removeSystemCommandOverride(id: string): void;
+    /**
+     * Saves a new custom command, or overwrites an existing custom command.
+     *
+     * To create a new custom command, set the `command` parameter's `id` property to an empty string or `null`.
+     * To overwrite an existing custom command, specify the `id` property.
+     *
+     * @param command The `CommandDefinition` for the custom command
+     * @param user The user who is creating/editing the custom command
+     */
+    saveCustomCommand(command: CommandDefinition, user?: string): void;
+    /**
+     * Imports a custom command, like from a setup or a previous version of Firebot
+     *
+     * @param command The `CommandDefinition` for the custom command to import
+     */
+    saveImportedCustomCommand(command: CommandDefinition): void;
+    /**
+     * Saves all the specified custom commands
+     *
+     * @param commands An array of `CommandDefinition` objects to save
+     */
+    saveAllCustomCommands(commands: CommandDefinition[]): void;
+    /**
+     * Deletes a custom command
+     *
+     * @param id ID of the custom command to delete
+     */
+    deleteCustomCommand(id: string): void;
+    /**
+     * Deletes a custom command by its trigger
+     *
+     * @param trigger The trigger of the custom command to delete
+     */
+    removeCustomCommandByTrigger(trigger: string): void;
+    /**
+     * Refreshes the command cache
+     */
+    refreshCommandCache(): void;
+    /**
+     * Triggers a refresh of the frontend copy of the command cache
+     */
+    triggerUiRefresh(): void;
+}
+/**
+ * The Firebot system/custom chat command manager
+ */
+declare const manager: CommandManager;
+export { manager as CommandManager };