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

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 };

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

@@ -0,0 +1,14 @@
+import type { CommandDefinition, FirebotChatMessage, Trigger, UserCommand } from "../../../types";
+declare class CommandRunner {
+    private logger;
+    private parseCommandTriggerAndArgs;
+    buildUserCommand(command: CommandDefinition, rawMessage: string, sender: string, senderRoles?: string[]): UserCommand;
+    private execute;
+    fireCommand(command: CommandDefinition, userCmd: UserCommand, firebotChatMessage: FirebotChatMessage, commandSender: string, isManual?: boolean): void;
+    triggerCustomCommand(id: string, isManual?: boolean): void;
+    private runCommandFromEffect;
+    runSystemCommandFromEffect(id: string, trigger: Trigger, args: string): void;
+    runCustomCommandFromEffect(id: string, trigger: Trigger, args: string): void;
+}
+declare const commandRunner: CommandRunner;
+export = commandRunner;

package/backend/chat/commands/system-command-loader.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Loads all in-box system commands, along with any currency commands
+ */
+export declare function loadSystemCommands(): void;

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

@@ -0,0 +1,14 @@
+import type { FirebotChatMessage } from "../../types";
+declare class FirebotFrontendChatHelpers {
+    private logger;
+    private _pendingMessageCache;
+    private sendChatMessageToChatWidget;
+    sendChatMessageToFrontend(chatMessage: FirebotChatMessage): void;
+    private deleteMessageFromChatWidget;
+    deleteMessageFromFrontend(messageId: string, animate?: boolean): void;
+    deleteUserMessagesFromFrontend(username: string): void;
+    clearChatFeed(moderatorName: string): void;
+    updateMessageAutomodStatus(messageId: string, newStatus: FirebotChatMessage["autoModStatus"], resolverName: string, resolverId: string, flaggedPhrases: string[]): void;
+}
+declare const frontendChatHelpers: FirebotFrontendChatHelpers;
+export { frontendChatHelpers as FirebotFrontendChatHelpers };

package/backend/chat/moderation/chat-moderation-manager.d.ts

@@ -0,0 +1,44 @@
+import type { AllowList, BannedRegularExpressions, BannedWords, ChatModerationSettings, FirebotChatMessage } from "../../../types";
+declare class ChatModerationManager {
+    private logger;
+    bannedWords: BannedWords;
+    bannedRegularExpressions: BannedRegularExpressions;
+    allowlist: AllowList;
+    chatModerationSettings: ChatModerationSettings;
+    constructor();
+    private getBannedWordsDb;
+    private getBannedWordsList;
+    private addBannedWords;
+    private removeBannedWord;
+    private removeAllBannedWords;
+    private importBannedWordList;
+    private saveBannedWordList;
+    private getBannedRegularExpressionsDb;
+    private getBannedRegularExpressionsList;
+    private addBannedRegularExpression;
+    private removeBannedRegularExpression;
+    private removeAllBannedRegularExpressions;
+    private saveBannedRegularExpressionsList;
+    private getAllowlistDb;
+    private getUrlAllowlist;
+    private addAllowedUrls;
+    private removeAllowedUrl;
+    private removeAllAllowedUrls;
+    private importUrlAllowlist;
+    private saveUrlAllowlist;
+    private getUserAllowlist;
+    private addAllowedUser;
+    private removeAllowedUser;
+    private removeAllAllowedUsers;
+    private saveUserAllowlist;
+    private getChatModerationSettingsDb;
+    private saveChatModerationSettings;
+    private countEmojis;
+    private hasBannedWord;
+    private matchesBannedRegex;
+    private deleteMessage;
+    load(): void;
+    moderateMessage(chatMessage: FirebotChatMessage): Promise<void>;
+}
+declare const chatModerationManager: ChatModerationManager;
+export { chatModerationManager as ChatModerationManager };

package/backend/chat/moderation/raid-message-checker.d.ts

@@ -0,0 +1,20 @@
+interface RaidMessage {
+    rawText: string;
+    userId: string;
+}
+declare class RaidMessageChecker {
+    private logger;
+    private readonly _chatCacheLimit;
+    private _messageCache;
+    private _raidMessage;
+    private _checkerEnabled;
+    private _settings;
+    private handleRaider;
+    private getRaidMessage;
+    private checkPreviousMessages;
+    sendMessageToCache(raidMessage: RaidMessage): Promise<void>;
+    enable(shouldBan: boolean, shouldBlock: boolean): Promise<void>;
+    disable(): void;
+}
+declare const raidMessageChecker: RaidMessageChecker;
+export = raidMessageChecker;

package/backend/chat/moderation/url-permit-command.d.ts

@@ -0,0 +1,11 @@
+declare class PermitManager {
+    private logger;
+    private readonly _permidCommandId;
+    private _tempPermittedUsers;
+    private readonly _permitCommand;
+    hasTemporaryPermission(username: string): boolean;
+    registerPermitCommand(): void;
+    unregisterPermitCommand(): void;
+}
+declare const manager: PermitManager;
+export = manager;

package/backend/chat/third-party/7tv.d.ts

@@ -0,0 +1,29 @@
+import { ThirdPartyEmote, ThirdPartyEmoteProvider } from "./third-party-emote-provider";
+type SevenTVEmotesResponse = {
+    emotes: Array<{
+        name: string;
+        data: {
+            animated: boolean;
+            host: {
+                url: string;
+                files: Array<{
+                    name: string;
+                    static_name: string;
+                }>;
+            };
+        };
+    }>;
+};
+type SevenTVChannelEmotesResponse = {
+    emote_set: SevenTVEmotesResponse;
+};
+export declare class SevenTVEmoteProvider extends ThirdPartyEmoteProvider<SevenTVEmotesResponse, SevenTVChannelEmotesResponse> {
+    providerName: string;
+    globalEmoteUrl: string;
+    getChannelEmotesUrl(streamerUserId: string): string;
+    private globalEmoteMapper;
+    private channelEmoteMapper;
+    globalEmotesMapper: (response: SevenTVEmotesResponse) => ThirdPartyEmote[];
+    channelEmotesMapper: (response: SevenTVChannelEmotesResponse) => ThirdPartyEmote[];
+}
+export {};

package/backend/chat/third-party/bttv.d.ts

@@ -0,0 +1,19 @@
+import { ThirdPartyEmote, ThirdPartyEmoteProvider } from "./third-party-emote-provider";
+type BTTVEmotesResponse = Array<{
+    id: string;
+    code: string;
+    imageType: string;
+}>;
+type BTTVChannelEmotesResponse = {
+    channelEmotes: BTTVEmotesResponse;
+    sharedEmotes: BTTVEmotesResponse;
+};
+export declare class BTTVEmoteProvider extends ThirdPartyEmoteProvider<BTTVEmotesResponse, BTTVChannelEmotesResponse> {
+    providerName: string;
+    globalEmoteUrl: string;
+    getChannelEmotesUrl(streamerUserId: string): string;
+    private emoteMapper;
+    globalEmotesMapper: (response: BTTVEmotesResponse) => ThirdPartyEmote[];
+    channelEmotesMapper(response: BTTVChannelEmotesResponse): ThirdPartyEmote[];
+}
+export {};

package/backend/chat/third-party/ffz.d.ts

@@ -0,0 +1,19 @@
+import { ThirdPartyEmote, ThirdPartyEmoteProvider } from "./third-party-emote-provider";
+type FFZEmotesResponse = Array<{
+    images: {
+        "1x": string;
+        "2x": string;
+        "4x": string;
+    };
+    code: string;
+    imageType: string;
+}>;
+export declare class FFZEmoteProvider extends ThirdPartyEmoteProvider<FFZEmotesResponse> {
+    providerName: string;
+    globalEmoteUrl: string;
+    getChannelEmotesUrl(streamerUserId: string): string;
+    private emoteMapper;
+    globalEmotesMapper: (response: FFZEmotesResponse) => ThirdPartyEmote[];
+    channelEmotesMapper: (response: FFZEmotesResponse) => ThirdPartyEmote[];
+}
+export {};

package/backend/chat/third-party/third-party-emote-provider.d.ts

@@ -0,0 +1,15 @@
+export declare class ThirdPartyEmote {
+    origin: string;
+    url: string;
+    code: string;
+    animated: boolean;
+}
+export declare abstract class ThirdPartyEmoteProvider<GlobalEmotesResponse, ChannelEmotesResponse = GlobalEmotesResponse> {
+    private logger;
+    abstract providerName: string;
+    abstract globalEmoteUrl: string;
+    abstract getChannelEmotesUrl(streamerUserId: string): string;
+    abstract globalEmotesMapper(response: GlobalEmotesResponse): ThirdPartyEmote[];
+    abstract channelEmotesMapper(response: ChannelEmotesResponse): ThirdPartyEmote[];
+    getAllEmotes(): Promise<ThirdPartyEmote[]>;
+}

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

@@ -0,0 +1,34 @@
+import { EventEmitter } from "events";
+declare class TwitchChat extends EventEmitter {
+    private logger;
+    private _streamerChatClient;
+    private _botChatClient;
+    constructor();
+    /**
+     * Whether or not the streamer is currently connected
+     */
+    get chatIsConnected(): boolean;
+    /**
+     * Disconnects the streamer and bot from chat
+     */
+    disconnect(emitDisconnectEvent?: boolean): void;
+    /**
+     * Connects the streamer and bot to chat
+     */
+    connect(): Promise<void>;
+    private connectBotClient;
+    /**
+     * Sends the message as the bot if available, otherwise as the streamer.
+     * If a username is provided, the message will be whispered.
+     * If the message is too long, it will be automatically broken into multiple fragments and sent individually.
+     *
+     * @param message The message to send
+     * @param username If provided, message will be whispered to the given user.
+     * @param accountType Which account to chat as. Defaults to bot if available otherwise, the streamer.
+     * @param replyToMessageId A message id to reply to
+     * @deprecated Use the API wrapper methods ({@linkcode TwitchApi.chat.sendChatMessage()} and {@linkcode TwitchApi.whispers.sendWhisper()}) instead
+     */
+    sendChatMessage(message: string, username?: string, accountType?: string, replyToMessageId?: string): Promise<void>;
+}
+declare const twitchChat: TwitchChat;
+export = twitchChat;

package/backend/cloud-sync/index.d.ts

@@ -0,0 +1,9 @@
+interface ProfileSyncData {
+    username: string;
+    userRoles: string[];
+    profilePage: "commands" | "quotes";
+}
+export declare function sync<T = unknown>(jsonData: T): Promise<string>;
+export declare function getData<T = unknown>(shareCode: string): Promise<T>;
+export declare function syncProfileData(profileSyncData: ProfileSyncData): Promise<string>;
+export {};

package/backend/cloud-sync/sync-handlers/command-list.d.ts

@@ -0,0 +1,3 @@
+export declare function getCommandListForSync(): {
+    allowedCmds: any[];
+};

package/backend/cloud-sync/sync-handlers/quotes-list.d.ts

@@ -0,0 +1,3 @@
+export declare function getQuoteListForSync(): Promise<{
+    quotes: import("../../../types").Quote[];
+}>;

package/backend/common/account-access.d.ts

@@ -0,0 +1,47 @@
+import { TypedEmitter } from "tiny-typed-emitter";
+import type { FirebotAccount } from "../../types";
+type AccountType = "streamer" | "bot";
+type AccountCache = {
+    [accountType in AccountType]: FirebotAccount;
+};
+interface AccountAuthUpdateEvent {
+    accountType: AccountType;
+    account: FirebotAccount;
+}
+type Events = {
+    "account-update": (cache: AccountCache) => void;
+    "account-auth-update": (event: AccountAuthUpdateEvent) => void;
+};
+declare class AccountAccess extends TypedEmitter<Events> {
+    private logger;
+    private _cache;
+    private _accountTokenIssueFlags;
+    private _readyResolve;
+    readyPromise: Promise<unknown>;
+    constructor();
+    getAccounts(): AccountCache;
+    streamerTokenIssue(): boolean;
+    botTokenIssue(): boolean;
+    private sendAccountUpdate;
+    private sendAccountAuthUpdate;
+    /**
+     * Updates a streamer account object with various settings
+     */
+    updateStreamerAccountSettings(streamerAccount: FirebotAccount): FirebotAccount;
+    private saveAccountDataToFile;
+    /**
+     * Loads account data from file into memory
+     * @param emitUpdate If an account update event should be emitted
+     */
+    loadAccountData(emitUpdate?: boolean): void;
+    /**
+     * Update and save data for an account
+     * @param accountType The type of account
+     * @param account The account
+     */
+    updateAccount(accountType: AccountType, account: FirebotAccount, emitGeneralUpdate?: boolean, emitAuthUpdateEvent?: boolean): void;
+    removeAccount(accountType: AccountType): void;
+    setAccountTokenIssue(accountType: AccountType): void;
+}
+declare const accountAccess: AccountAccess;
+export { accountAccess as AccountAccess };

package/backend/common/argv-parser.d.ts

@@ -0,0 +1,3 @@
+import parser from "yargs-parser";
+declare const argv: parser.Arguments;
+export default argv;

package/backend/common/custom-variable-manager.d.ts

@@ -0,0 +1,46 @@
+import { TypedEmitter } from "tiny-typed-emitter";
+import { WrappedValue } from "node-cache";
+interface CustomVariableInspectorItem {
+    key: string;
+    value: unknown;
+    ttl: number;
+}
+type FirebotCacheData = {
+    [key: string]: WrappedValue<unknown> & {
+        meta?: {
+            persist?: boolean;
+        };
+    };
+};
+declare class CustomVariableManager extends TypedEmitter<{
+    "created-item": (item: {
+        name: string;
+        value: unknown;
+    }) => void;
+    "updated-item": (item: {
+        name: string;
+        value: unknown;
+    }) => void;
+    "deleted-item": (item: {
+        name: string;
+        value: unknown;
+    }) => void;
+}> {
+    private logger;
+    private _cache;
+    constructor();
+    private onCustomVariableCreate;
+    private onCustomVariableExpire;
+    private onCustomVariableDelete;
+    private getVariableCacheDb;
+    getInitialInspectorVariables(): CustomVariableInspectorItem[];
+    getAllVariables(): FirebotCacheData;
+    persistVariablesToFile(): void;
+    loadVariablesFromFile(): void;
+    private setValueWithMeta;
+    addCustomVariable(name: string, data: unknown, ttl?: number, propertyPath?: string, persist?: boolean): void;
+    getCustomVariable<T = unknown>(name: string, propertyPath?: string, defaultData?: T): T;
+    deleteCustomVariable(name: string): void;
+}
+declare const manager: CustomVariableManager;
+export { manager as CustomVariableManager };

package/backend/common/data-access.d.ts

@@ -0,0 +1,23 @@
+import fs from "fs";
+import { JsonDB } from "node-json-db";
+export declare function getWorkingDirectoryPath(): string;
+declare let tmpDirectoryPath: string;
+export declare function getPathInUserData(filePath: string): string;
+export declare function getPathInWorkingDir(filePath: string): string;
+export declare function getPathInTmpDir(filePath: string): string;
+export declare function deletePathInTmpDir(filePath: string): void;
+export declare function deletePathInUserData(filePath: string): void;
+export declare function deleteFolderRecursive(pathname: string): void;
+export declare function getUserDataPath(): string;
+export declare function createFirebotDataDir(): Promise<void>;
+export declare function getJsonDbInUserData(filePath: string): JsonDB;
+export declare function makeDirInUserData(filePath: string): Promise<void>;
+export declare function makeDirInUserDataSync(filePath: string): boolean;
+export declare function writeFileInWorkingDir(filePath: string, data: string, callback: fs.NoParamCallback): void;
+export declare function writeFileInUserData(filePath: string, data: string, callback: fs.NoParamCallback): void;
+export declare function copyDefaultConfigToUserData(configFileName: string, userDataDestination: string): void;
+export declare function copyResourceToUserData(resourcePath: string, resourceName: string, userDataDestination?: string): void;
+export declare function workingDirPathExists(filePath: string): Promise<unknown>;
+export declare function userDataPathExists(filePath: string): Promise<boolean>;
+export declare function userDataPathExistsSync(filePath: string): boolean;
+export { tmpDirectoryPath as getTmpDirectory };

package/backend/common/debug-info.d.ts

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

package/backend/common/effect-abort-helpers.d.ts

@@ -0,0 +1,10 @@
+type EffectAbortData = {
+    executionId: string;
+    abortController: AbortController;
+};
+export declare function addEffectAbortController(type: "effect" | "effect-list", effectOrEffectListId: string, abortData: EffectAbortData): void;
+export declare function removeEffectAbortController(type: "effect" | "effect-list", effectOrEffectListId: string, executionId: string): void;
+export declare function abortEffectList(effectListId: string, bubbleStop?: boolean): void;
+export declare function abortEffect(effectId: string): void;
+export declare function abortAllEffectLists(bubbleStop?: boolean): void;
+export {};

package/backend/common/effect-run-mode-handler.d.ts

@@ -0,0 +1,2 @@
+import { EffectInstance, EffectList } from "../../types";
+export declare function resolveEffectsForExecution(effectList: EffectList): EffectInstance[];

package/backend/common/frontend-communicator.d.ts

@@ -0,0 +1,15 @@
+import type { FrontendCommunicatorModule } from "../../types";
+declare class FrontendCommunicator implements FrontendCommunicatorModule {
+    private _listeners;
+    private registerEventWithElectron;
+    send<ExpectedArg = unknown>(eventName: string, data?: ExpectedArg): void;
+    sendToVariableInspector(eventName: string, data?: unknown): void;
+    fireEventAsync<ReturnPayload = void, ExpectedArg = unknown>(eventName: string, data?: ExpectedArg): Promise<ReturnPayload>;
+    private registerListener;
+    on<ExpectedArgs extends Array<unknown> = [], ReturnPayload = void>(eventName: string, callback: (...args: ExpectedArgs) => ReturnPayload): string;
+    onAsync<ExpectedArgs extends Array<unknown> = [], ReturnPayload = void>(eventName: string, callback: (...args: ExpectedArgs) => Promise<ReturnPayload>): string;
+    private unregisterListener;
+    off(eventName: string, id: string): void;
+}
+declare const frontendCommunicator: FrontendCommunicator;
+export = frontendCommunicator;

package/backend/common/handlers/dice-processor.d.ts

@@ -0,0 +1,10 @@
+import type { Trigger } from "../../../types";
+export interface DiceEffectModel {
+    dice: string;
+    chatter: string;
+    whisper: string;
+    resultType: string;
+}
+declare function processDice(diceConfig: string, showEach: boolean): string | number;
+declare function handleDiceEffect(effect: DiceEffectModel, trigger: Trigger): Promise<void>;
+export { handleDiceEffect, processDice };

package/backend/common/handlers/js-sandbox/sandbox-eval.d.ts

@@ -0,0 +1,2 @@
+import type { Trigger } from "../../../../types";
+export declare const evalSandboxedJs: (code: string, args: unknown[], trigger: Trigger) => Promise<unknown>;

package/backend/common/handlers/reddit-processor.d.ts

@@ -0,0 +1,2 @@
+declare function randomImageFromSubReddit(subreddit: string): Promise<string>;
+export { randomImageFromSubReddit as getRandomImage };

package/backend/common/handlers/sound-handler.d.ts

@@ -0,0 +1,14 @@
+import type { FirebotAudioDevice } from "../../../types";
+export type SoundType = "url" | "rawData" | "folderRandom" | "local";
+export declare function playSound(soundData: {
+    soundType: SoundType;
+    filePath?: string;
+    url?: string;
+    rawData?: Uint8Array | number[] | string;
+    mimeType?: string;
+    folder?: string;
+    volume?: number;
+    overlayInstance?: string;
+    audioOutputDevice?: FirebotAudioDevice;
+    waitForSound?: boolean;
+}): Promise<boolean>;

package/backend/common/handlers/twitch-clip-url-resolver.d.ts

@@ -0,0 +1,5 @@
+import { HelixClip } from '@twurple/api';
+export declare const resolveTwitchClipVideoUrl: (clip: HelixClip) => Promise<{
+    url: string;
+    useIframe: boolean;
+}>;

package/backend/common/icon-manager.d.ts

@@ -0,0 +1,8 @@
+import type { FontAwesomeIcon } from "../../types";
+declare class IconManager {
+    icons: FontAwesomeIcon[];
+    constructor();
+    loadFontAwesomeIcons(): Promise<void>;
+}
+declare const iconManager: IconManager;
+export { iconManager as IconManager };

package/backend/common/profile-manager.d.ts

@@ -0,0 +1,22 @@
+import { JsonDB } from "node-json-db";
+declare class ProfileManager {
+    private logger;
+    loggedInUser: string;
+    profileToRename: string;
+    constructor();
+    private restartApp;
+    logInProfile(profileId: string, restart?: boolean): void;
+    createNewProfile(profileId: string, restart?: boolean): void;
+    getLoggedInProfile(restartIfNotLoggedIn?: boolean): string;
+    renameProfile(newProfileId: string): void;
+    deleteProfile(): void;
+    getPathInProfile(filepath: string): string;
+    private getPathInProfileRelativeToUserData;
+    getJsonDbInProfile(filepath: string, humanReadable?: boolean): JsonDB;
+    profileDataPathExistsSync(filePath: string): boolean;
+    deletePathInProfile(filePath: string): void;
+    getNewProfileName: () => string;
+    hasProfileRename: () => boolean;
+}
+declare const manager: ProfileManager;
+export { manager as ProfileManager };